From 861c365abda1715092da25753cbaade298c41d9c Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 19 Mar 2026 18:25:03 +0100
Subject: [PATCH 01/71] chore: add tooling config, ci workflow, and dependency
 updates

Add dialyzer ignore file, pre-commit hooks config, gitignore updates,
blocks CI workflow, and mix.exs dependency updates.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .dialyzer_ignore.exs         |  6 ++++++
 .github/workflows/blocks.yml | 18 ++++++++++++++++++
 .gitignore                   |  7 +++++++
 .pre-commit-config.yaml      |  8 ++++++++
 mix.exs                      | 10 +++++++++-
 5 files changed, 48 insertions(+), 1 deletion(-)
 create mode 100644 .dialyzer_ignore.exs
 create mode 100644 .github/workflows/blocks.yml
 create mode 100644 .pre-commit-config.yaml

diff --git a/.dialyzer_ignore.exs b/.dialyzer_ignore.exs
new file mode 100644
index 0000000..b76a4d0
--- /dev/null
+++ b/.dialyzer_ignore.exs
@@ -0,0 +1,6 @@
+[
+  # Dialyzer specializes analyze/2 for the codebase call-site where include_pairs
+  # is always true, making the false branch appear unreachable. Both branches are
+  # valid and reachable at runtime from the file-level and codebase callers.
+  {"lib/codeqa/metrics/file/near_duplicate_blocks.ex", :pattern_match}
+]
diff --git a/.github/workflows/blocks.yml b/.github/workflows/blocks.yml
new file mode 100644
index 0000000..284adec
--- /dev/null
+++ b/.github/workflows/blocks.yml
@@ -0,0 +1,18 @@
+name: Extract Code Blocks
+
+on:
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  blocks:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./
+        with:
+          command: blocks
+          build: source
diff --git a/.gitignore b/.gitignore
index ad2603a..81b993d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,3 +18,10 @@ devenv.lock
 
 # Git worktrees
 .worktrees/
+docs/plans/
+
+# Claude Code
+.claude/
+
+# Node
+node_modules/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..d008842
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,8 @@
+repos:
+- repo: local
+  hooks:
+  - id: mix-precommit
+    name: Mix precommit
+    entry: devenv shell precommit
+    language: system
+    pass_filenames: false
diff --git a/mix.exs b/mix.exs
index 2e55bfe..3c06031 100644
--- a/mix.exs
+++ b/mix.exs
@@ -11,7 +11,9 @@ defmodule CodeQA.MixProject do
       escript: [main_module: CodeQA.CLI],
       elixirc_paths: elixirc_paths(Mix.env()),
       preferred_envs: [precommit: :test],
-      aliases: aliases()
+      aliases: aliases(),
+      dialyzer: [ignore_warnings: ".dialyzer_ignore.exs"],
+      consolidate_protocols: Mix.env() != :test
     ]
   end
 
@@ -30,6 +32,12 @@ defmodule CodeQA.MixProject do
         "compile --warnings-as-errors",
         "deps.unlock --unused",
         "format"
+      ],
+      health: [
+        "run -e 'CodeQA.CLI.main([\"health-report\", \".\", \"--ignore-paths\", \"test/**\"])'"
+      ],
+      "health.progress": [
+        "run -e 'CodeQA.CLI.main([\"health-report\", \".\", \"--ignore-paths\", \"test/**\", \"--progress\"])'"
       ]
     ]
   end

From dad7ca1e91c4dad3b0ebfac57031207dd5290f0d Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 19 Mar 2026 18:25:37 +0100
Subject: [PATCH 02/71] refactor(engine): extract engine layer and reorganize
 metrics namespaces

Move analyzer/collector/pipeline/registry/parallel into engine/ module,
reorganize all file metrics into metrics/file/ and codebase metrics into
metrics/codebase/ namespaces. Delete obsolete telemetry and stopwords modules.
Add new file metrics: bradford, brevity, comment_structure, punctuation_density, rfc,
and post-processing metrics (menzerath).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/analyzer.ex                        | 130 --------
 lib/codeqa/cli/stopwords.ex                   |  97 ------
 lib/codeqa/collector.ex                       |  99 -------
 lib/codeqa/engine/analyzer.ex                 | 126 ++++++++
 lib/codeqa/engine/collector.ex                | 111 +++++++
 lib/codeqa/engine/file_context.ex             |  29 ++
 lib/codeqa/{ => engine}/parallel.ex           |  30 +-
 lib/codeqa/engine/pipeline.ex                 |  93 ++++++
 lib/codeqa/{ => engine}/registry.ex           |  26 +-
 lib/codeqa/formatter.ex                       |   8 +-
 lib/codeqa/git.ex                             |  18 +-
 .../metrics/{ => codebase}/similarity.ex      | 177 +++++------
 lib/codeqa/metrics/codebase_metric.ex         |  42 ---
 lib/codeqa/metrics/file/bradford.ex           |  99 +++++++
 lib/codeqa/metrics/{ => file}/branching.ex    |  34 ++-
 lib/codeqa/metrics/file/brevity.ex            |  50 ++++
 .../metrics/{ => file}/casing_entropy.ex      |  35 ++-
 lib/codeqa/metrics/file/comment_structure.ex  |  45 +++
 lib/codeqa/metrics/{ => file}/compression.ex  |  31 +-
 lib/codeqa/metrics/{ => file}/entropy.ex      |  22 +-
 lib/codeqa/metrics/{ => file}/file_metric.ex  |   9 +-
 .../metrics/{ => file}/function_metrics.ex    |  19 +-
 lib/codeqa/metrics/{ => file}/halstead.ex     |  20 +-
 lib/codeqa/metrics/{ => file}/heaps.ex        |  16 +-
 .../{ => file}/identifier_length_variance.ex  |  12 +-
 lib/codeqa/metrics/{ => file}/indentation.ex  |  28 +-
 lib/codeqa/metrics/{ => file}/inflector.ex    |   5 +-
 .../{ => file}/magic_number_density.ex        |  25 +-
 lib/codeqa/metrics/{ => file}/ngram.ex        |  29 +-
 .../metrics/file/punctuation_density.ex       |  96 ++++++
 lib/codeqa/metrics/{ => file}/readability.ex  |  20 +-
 lib/codeqa/metrics/file/rfc.ex                |  81 +++++
 .../metrics/{ => file}/symbol_density.ex      |   7 +-
 lib/codeqa/metrics/{ => file}/vocabulary.ex   |  11 +-
 .../metrics/{ => file}/vowel_density.ex       |   9 +-
 lib/codeqa/metrics/{ => file}/winnowing.ex    |   2 +-
 lib/codeqa/metrics/{ => file}/zipf.ex         |  11 +-
 .../metrics/post_processing/menzerath.ex      | 278 ++++++++++++++++++
 .../post_processing/post_processing_metric.ex |  21 ++
 lib/codeqa/metrics/token_normalizer.ex        |  45 ---
 lib/codeqa/pipeline.ex                        | 109 -------
 lib/codeqa/stopwords.ex                       |  63 ----
 lib/codeqa/telemetry.ex                       |  68 -----
 test/codeqa/collector_test.exs                |  52 +++-
 test/codeqa/engine/analyzer_test.exs          |  44 +++
 test/codeqa/formatter_test.exs                |   1 +
 test/codeqa/git_test.exs                      | 112 +++++++
 .../metrics/codebase/similarity_test.exs      |  79 +++++
 .../metrics/{ => file}/branching_test.exs     |  10 +-
 .../{ => file}/function_metrics_test.exs      |  18 +-
 50 files changed, 1716 insertions(+), 886 deletions(-)
 delete mode 100644 lib/codeqa/analyzer.ex
 delete mode 100644 lib/codeqa/cli/stopwords.ex
 delete mode 100644 lib/codeqa/collector.ex
 create mode 100644 lib/codeqa/engine/analyzer.ex
 create mode 100644 lib/codeqa/engine/collector.ex
 create mode 100644 lib/codeqa/engine/file_context.ex
 rename lib/codeqa/{ => engine}/parallel.ex (68%)
 create mode 100644 lib/codeqa/engine/pipeline.ex
 rename lib/codeqa/{ => engine}/registry.ex (71%)
 rename lib/codeqa/metrics/{ => codebase}/similarity.ex (66%)
 delete mode 100644 lib/codeqa/metrics/codebase_metric.ex
 create mode 100644 lib/codeqa/metrics/file/bradford.ex
 rename lib/codeqa/metrics/{ => file}/branching.ex (70%)
 create mode 100644 lib/codeqa/metrics/file/brevity.ex
 rename lib/codeqa/metrics/{ => file}/casing_entropy.ex (61%)
 create mode 100644 lib/codeqa/metrics/file/comment_structure.ex
 rename lib/codeqa/metrics/{ => file}/compression.ex (56%)
 rename lib/codeqa/metrics/{ => file}/entropy.ex (82%)
 rename lib/codeqa/metrics/{ => file}/file_metric.ex (77%)
 rename lib/codeqa/metrics/{ => file}/function_metrics.ex (92%)
 rename lib/codeqa/metrics/{ => file}/halstead.ex (92%)
 rename lib/codeqa/metrics/{ => file}/heaps.ex (84%)
 rename lib/codeqa/metrics/{ => file}/identifier_length_variance.ex (81%)
 rename lib/codeqa/metrics/{ => file}/indentation.ex (60%)
 rename lib/codeqa/metrics/{ => file}/inflector.ex (89%)
 rename lib/codeqa/metrics/{ => file}/magic_number_density.ex (51%)
 rename lib/codeqa/metrics/{ => file}/ngram.ex (71%)
 create mode 100644 lib/codeqa/metrics/file/punctuation_density.ex
 rename lib/codeqa/metrics/{ => file}/readability.ex (89%)
 create mode 100644 lib/codeqa/metrics/file/rfc.ex
 rename lib/codeqa/metrics/{ => file}/symbol_density.ex (85%)
 rename lib/codeqa/metrics/{ => file}/vocabulary.ex (91%)
 rename lib/codeqa/metrics/{ => file}/vowel_density.ex (86%)
 rename lib/codeqa/metrics/{ => file}/winnowing.ex (96%)
 rename lib/codeqa/metrics/{ => file}/zipf.ex (86%)
 create mode 100644 lib/codeqa/metrics/post_processing/menzerath.ex
 create mode 100644 lib/codeqa/metrics/post_processing/post_processing_metric.ex
 delete mode 100644 lib/codeqa/metrics/token_normalizer.ex
 delete mode 100644 lib/codeqa/pipeline.ex
 delete mode 100644 lib/codeqa/stopwords.ex
 delete mode 100644 lib/codeqa/telemetry.ex
 create mode 100644 test/codeqa/engine/analyzer_test.exs
 create mode 100644 test/codeqa/git_test.exs
 create mode 100644 test/codeqa/metrics/codebase/similarity_test.exs
 rename test/codeqa/metrics/{ => file}/branching_test.exs (79%)
 rename test/codeqa/metrics/{ => file}/function_metrics_test.exs (77%)

diff --git a/lib/codeqa/analyzer.ex b/lib/codeqa/analyzer.ex
deleted file mode 100644
index ddcb6ab..0000000
--- a/lib/codeqa/analyzer.ex
+++ /dev/null
@@ -1,130 +0,0 @@
-defmodule CodeQA.Analyzer do
-  @moduledoc "Orchestrates metric computation across files."
-
-  alias CodeQA.Registry
-  alias CodeQA.Metrics
-
-  def build_registry do
-    Registry.new()
-    |> Registry.register_file_metric(Metrics.Entropy)
-    |> Registry.register_file_metric(Metrics.Compression)
-    |> Registry.register_file_metric(Metrics.Zipf)
-    |> Registry.register_file_metric(Metrics.Heaps)
-    |> Registry.register_file_metric(Metrics.Vocabulary)
-    |> Registry.register_file_metric(Metrics.Ngram)
-    |> Registry.register_file_metric(Metrics.Halstead)
-    |> Registry.register_file_metric(Metrics.Readability)
-    |> Registry.register_file_metric(Metrics.CasingEntropy)
-    |> Registry.register_file_metric(Metrics.IdentifierLengthVariance)
-    |> Registry.register_file_metric(Metrics.Indentation)
-    |> Registry.register_file_metric(Metrics.Branching)
-    |> Registry.register_file_metric(Metrics.FunctionMetrics)
-    |> Registry.register_file_metric(Metrics.MagicNumberDensity)
-    |> Registry.register_file_metric(Metrics.SymbolDensity)
-    |> Registry.register_file_metric(Metrics.VowelDensity)
-    |> Registry.register_codebase_metric(Metrics.Similarity)
-  end
-
-  def analyze_codebase(files, opts \\ []) do
-    registry = build_registry()
-
-    opts =
-      if Keyword.get(opts, :experimental_stopwords, false) do
-        has_progress = Keyword.get(opts, :on_progress)
-
-        if has_progress,
-          do: IO.puts(:stderr, "  Analyzing Stopwords (Tokens and Fingerprints)...")
-
-        word_extractor = fn content ->
-          Regex.scan(~r/\b[a-zA-Z_]\w*\b/u, content) |> List.flatten()
-        end
-
-        word_stopwords =
-          CodeQA.Telemetry.time(:stopwords_words, fn ->
-            CodeQA.Stopwords.find_stopwords(files, word_extractor, opts)
-          end)
-
-        fp_extractor = fn content ->
-          CodeQA.Metrics.TokenNormalizer.normalize(content) |> CodeQA.Metrics.Winnowing.kgrams(5)
-        end
-
-        fp_stopwords =
-          CodeQA.Telemetry.time(:stopwords_fingerprints, fn ->
-            CodeQA.Stopwords.find_stopwords(files, fp_extractor, opts)
-          end)
-
-        if has_progress do
-          IO.puts(
-            :stderr,
-            "  Found #{MapSet.size(word_stopwords)} common word stopwords and #{MapSet.size(fp_stopwords)} common fingerprint stopwords."
-          )
-        end
-
-        opts
-        |> Keyword.put(:word_stopwords, word_stopwords)
-        |> Keyword.put(:fp_stopwords, fp_stopwords)
-      else
-        opts
-      end
-
-    file_results = CodeQA.Parallel.analyze_files(files, opts)
-    codebase_metrics = Registry.run_codebase_metrics(registry, files, opts)
-    aggregate = aggregate_file_metrics(file_results)
-
-    %{
-      "files" => file_results,
-      "codebase" => %{
-        "aggregate" => aggregate,
-        "similarity" => Map.get(codebase_metrics, "similarity", %{})
-      }
-    }
-  end
-
-  defp metric_data_to_triples({metric_name, metric_data}) do
-    metric_data
-    |> Enum.filter(fn {_k, v} -> is_number(v) end)
-    |> Enum.map(fn {key, value} -> {metric_name, key, value / 1} end)
-  end
-
-  defp aggregate_file_metrics(file_results) do
-    file_results
-    |> Map.values()
-    |> Enum.flat_map(fn file_data ->
-      file_data
-      |> Map.get("metrics", %{})
-      |> Enum.flat_map(&metric_data_to_triples/1)
-    end)
-    |> Enum.group_by(fn {metric, key, _val} -> {metric, key} end, fn {_, _, val} -> val end)
-    |> Enum.reduce(%{}, fn {{metric, key}, values}, acc ->
-      stats = compute_stats(values)
-      metric_agg = Map.get(acc, metric, %{})
-
-      updated =
-        Map.merge(metric_agg, %{
-          "mean_#{key}" => stats.mean,
-          "std_#{key}" => stats.std,
-          "min_#{key}" => stats.min,
-          "max_#{key}" => stats.max
-        })
-
-      Map.put(acc, metric, updated)
-    end)
-  end
-
-  defp compute_stats([]), do: %{mean: 0.0, std: 0.0, min: 0.0, max: 0.0}
-
-  defp compute_stats(values) do
-    n = length(values)
-    mean = Enum.sum(values) / n
-    sum_squares = Enum.reduce(values, 0.0, fn v, acc -> acc + (v - mean) ** 2 end)
-    variance = sum_squares / n
-    std = :math.sqrt(variance)
-
-    %{
-      mean: Float.round(mean * 1.0, 4),
-      std: Float.round(std * 1.0, 4),
-      min: Float.round(Enum.min(values) * 1.0, 4),
-      max: Float.round(Enum.max(values) * 1.0, 4)
-    }
-  end
-end
diff --git a/lib/codeqa/cli/stopwords.ex b/lib/codeqa/cli/stopwords.ex
deleted file mode 100644
index f79027b..0000000
--- a/lib/codeqa/cli/stopwords.ex
+++ /dev/null
@@ -1,97 +0,0 @@
-defmodule CodeQA.CLI.Stopwords do
-  @moduledoc false
-
-  @behaviour CodeQA.CLI.Command
-
-  alias CodeQA.CLI.Options
-
-  @impl CodeQA.CLI.Command
-  def usage do
-    """
-    Usage: codeqa stopwords <path> [options]
-
-      Print codebase-specific stopwords based on frequency analysis.
-
-    Options:
-      --stopwords-threshold FLOAT  Frequency threshold for stopword detection
-      --progress                   Show per-file progress on stderr
-      -w, --workers N              Number of parallel workers
-      --ignore-paths PATHS         Comma-separated list of path patterns to ignore (supports wildcards, e.g. "test/*,docs/*")
-    """
-  end
-
-  @impl CodeQA.CLI.Command
-  def run(args) when args in [["--help"], ["-h"]] do
-    IO.puts(usage())
-  end
-
-  def run(args) do
-    {opts, [path], _} =
-      OptionParser.parse(args,
-        strict: [
-          workers: :integer,
-          stopwords_threshold: :float,
-          progress: :boolean,
-          ignore_paths: :string
-        ],
-        aliases: [w: :workers]
-      )
-
-    Options.validate_dir!(path)
-
-    ignore_patterns = Options.parse_ignore_paths(opts[:ignore_paths]) ++ Options.load_config_ignore_paths(path)
-    files = CodeQA.Collector.collect_files(path, ignore_patterns: ignore_patterns)
-
-    if map_size(files) == 0 do
-      IO.puts(:stderr, "Warning: no source files found in '#{path}'")
-      exit({:shutdown, 1})
-    end
-
-    IO.puts(:stderr, "Extracting stopwords for #{map_size(files)} files...")
-    start_time = System.monotonic_time(:millisecond)
-
-    word_stopwords = find_word_stopwords(files, opts)
-    fp_stopwords = find_fingerprint_stopwords(files, opts)
-
-    end_time = System.monotonic_time(:millisecond)
-
-    IO.puts(:stderr, "\nAnalysis completed in #{end_time - start_time}ms")
-    print_word_stopwords(word_stopwords)
-    IO.puts(:stderr, "\n--- Fingerprint Stopwords (#{MapSet.size(fp_stopwords)}) ---")
-    IO.puts(:stderr, "Found #{MapSet.size(fp_stopwords)} structural k-gram hashes.")
-  end
-
-  defp find_word_stopwords(files, opts) do
-    word_extractor = fn content ->
-      Regex.scan(~r/\b[a-zA-Z_]\w*\b/u, content) |> List.flatten()
-    end
-
-    CodeQA.Stopwords.find_stopwords(
-      files,
-      word_extractor,
-      Keyword.put(opts, :progress_label, "Words")
-    )
-  end
-
-  defp find_fingerprint_stopwords(files, opts) do
-    fp_extractor = fn content ->
-      CodeQA.Metrics.TokenNormalizer.normalize(content) |> CodeQA.Metrics.Winnowing.kgrams(5)
-    end
-
-    CodeQA.Stopwords.find_stopwords(
-      files,
-      fp_extractor,
-      Keyword.put(opts, :progress_label, "Fingerprints")
-    )
-  end
-
-  defp print_word_stopwords(word_stopwords) do
-    IO.puts(:stderr, "\n--- Word Stopwords (#{MapSet.size(word_stopwords)}) ---")
-
-    word_stopwords
-    |> MapSet.to_list()
-    |> Enum.sort()
-    |> Enum.chunk_every(10)
-    |> Enum.each(fn chunk -> IO.puts(Enum.join(chunk, ", ")) end)
-  end
-end
diff --git a/lib/codeqa/collector.ex b/lib/codeqa/collector.ex
deleted file mode 100644
index 02e6f34..0000000
--- a/lib/codeqa/collector.ex
+++ /dev/null
@@ -1,99 +0,0 @@
-defmodule CodeQA.Collector do
-  @moduledoc false
-
-  @source_extensions MapSet.new(~w[
-    .py .js .ts .jsx .tsx .java .rs .go .c .cpp .h .hpp .rb .ex .exs
-    .swift .kt .scala .sh .css .scss .html .vue .svelte .zig .lua .pl
-    .pm .r .jl .cs .fs .ml .hs .erl .clj .dart
-  ])
-
-  @skip_dirs MapSet.new(~w[
-    .git .hg .svn node_modules __pycache__ _build dist build vendor
-    .tox .venv venv target .mypy_cache .pytest_cache deps .elixir_ls
-    .next coverage
-  ])
-
-  @spec collect_files(String.t(), keyword()) :: %{String.t() => String.t()}
-  def collect_files(root, opts \\ []) do
-    root_path = Path.expand(root)
-    ignore_patterns = Keyword.get(opts, :ignore_patterns, [])
-
-    unless File.dir?(root_path) do
-      raise File.Error, reason: :enoent, path: root, action: "find directory"
-    end
-
-    root_path
-    |> walk_directory()
-    |> Map.new(fn path ->
-      rel = Path.relative_to(path, root_path)
-      {rel, File.read!(path)}
-    end)
-    |> reject_ignored_map(ignore_patterns)
-  end
-
-  def source_extensions, do: @source_extensions
-
-  @doc false
-  def ignored?(path, patterns) do
-    Enum.any?(patterns, fn pattern ->
-      match_pattern?(path, pattern)
-    end)
-  end
-
-  @doc false
-  def reject_ignored_map(files_map, []), do: files_map
-
-  def reject_ignored_map(files_map, patterns) do
-    Map.reject(files_map, fn {path, _} -> ignored?(path, patterns) end)
-  end
-
-  @doc false
-  def reject_ignored(list, [], _key_fn), do: list
-
-  def reject_ignored(list, patterns, key_fn) do
-    Enum.reject(list, fn item -> ignored?(key_fn.(item), patterns) end)
-  end
-
-  defp match_pattern?(path, pattern) do
-    # Convert glob pattern to regex:
-    # - ** matches any number of directories
-    # - * matches anything except /
-    # - ? matches a single character except /
-    regex_str =
-      pattern
-      |> String.replace(".", "\\.")
-      |> String.replace("**", "\0GLOBSTAR\0")
-      |> String.replace("*", "[^/]*")
-      |> String.replace("?", "[^/]")
-      |> String.replace("\0GLOBSTAR\0", ".*")
-
-    case Regex.compile("^#{regex_str}$") do
-      {:ok, regex} -> Regex.match?(regex, path)
-      _ -> false
-    end
-  end
-
-  defp walk_directory(dir) do
-    dir
-    |> File.ls!()
-    |> Enum.flat_map(fn entry ->
-      full_path = Path.join(dir, entry)
-
-      cond do
-        File.dir?(full_path) and not skip_dir?(entry) ->
-          walk_directory(full_path)
-
-        File.regular?(full_path) and source_file?(entry) ->
-          [full_path]
-
-        true ->
-          []
-      end
-    end)
-  end
-
-  defp skip_dir?(name), do: MapSet.member?(@skip_dirs, name) or String.starts_with?(name, ".")
-
-  defp source_file?(name),
-    do: MapSet.member?(@source_extensions, Path.extname(name) |> String.downcase())
-end
diff --git a/lib/codeqa/engine/analyzer.ex b/lib/codeqa/engine/analyzer.ex
new file mode 100644
index 0000000..b7e5c4e
--- /dev/null
+++ b/lib/codeqa/engine/analyzer.ex
@@ -0,0 +1,126 @@
+defmodule CodeQA.Engine.Analyzer do
+  @moduledoc "Orchestrates metric computation across files."
+
+  alias CodeQA.Analysis.RunSupervisor
+  alias CodeQA.Engine.Registry
+  alias CodeQA.Metrics.File, as: Metrics
+  alias CodeQA.Metrics.Codebase, as: CodebaseMetrics
+
+  @registry Registry.new()
+            |> Registry.register_file_metric(Metrics.Entropy)
+            |> Registry.register_file_metric(Metrics.Compression)
+            |> Registry.register_file_metric(Metrics.Zipf)
+            |> Registry.register_file_metric(Metrics.Heaps)
+            |> Registry.register_file_metric(Metrics.Vocabulary)
+            |> Registry.register_file_metric(Metrics.Ngram)
+            |> Registry.register_file_metric(Metrics.Halstead)
+            |> Registry.register_file_metric(Metrics.Readability)
+            |> Registry.register_file_metric(Metrics.CasingEntropy)
+            |> Registry.register_file_metric(Metrics.IdentifierLengthVariance)
+            |> Registry.register_file_metric(Metrics.Indentation)
+            |> Registry.register_file_metric(Metrics.Branching)
+            |> Registry.register_file_metric(Metrics.FunctionMetrics)
+            |> Registry.register_file_metric(Metrics.MagicNumberDensity)
+            |> Registry.register_file_metric(Metrics.SymbolDensity)
+            |> Registry.register_file_metric(Metrics.VowelDensity)
+            |> Registry.register_file_metric(Metrics.Brevity)
+            |> Registry.register_file_metric(Metrics.PunctuationDensity)
+            |> Registry.register_file_metric(Metrics.CommentStructure)
+            |> Registry.register_file_metric(Metrics.LinePatterns)
+            |> Registry.register_codebase_metric(CodebaseMetrics.Similarity)
+            |> Registry.register_file_metric(Metrics.NearDuplicateBlocksFile)
+            |> Registry.register_codebase_metric(CodebaseMetrics.NearDuplicateBlocksCodebase)
+
+  def build_registry, do: @registry
+
+  @spec analyze_file(String.t(), String.t()) :: map()
+  def analyze_file(_path, content) do
+    ctx = CodeQA.Engine.Pipeline.build_file_context(content)
+    CodeQA.Engine.Registry.run_file_metrics(@registry, ctx, [])
+  end
+
+  @spec analyze_codebase_aggregate(map(), keyword()) :: map()
+  def analyze_codebase_aggregate(files_map, opts \\ []) do
+    with_run_context(opts, fn opts ->
+      file_results = CodeQA.Engine.Parallel.analyze_files(files_map, opts)
+      aggregate_file_metrics(file_results)
+    end)
+  end
+
+  def analyze_codebase(files, opts \\ []) do
+    with_run_context(opts, &do_analyze_codebase(files, &1))
+  end
+
+  defp with_run_context(opts, fun) do
+    {:ok, sup} = RunSupervisor.start_link()
+    run_ctx = RunSupervisor.run_context(sup)
+    opts = Keyword.put(opts, :file_context_pid, run_ctx.file_context_pid)
+
+    try do
+      fun.(opts)
+    after
+      Supervisor.stop(sup)
+    end
+  end
+
+  defp do_analyze_codebase(files, opts) do
+    registry = @registry
+
+    file_results = CodeQA.Engine.Parallel.analyze_files(files, opts)
+    codebase_metrics = Registry.run_codebase_metrics(registry, files, opts)
+    aggregate = aggregate_file_metrics(file_results)
+
+    %{
+      "files" => file_results,
+      "codebase" => Map.put(codebase_metrics, "aggregate", aggregate)
+    }
+  end
+
+  defp metric_data_to_triples({metric_name, metric_data}) do
+    metric_data
+    |> Enum.filter(fn {_k, v} -> is_number(v) end)
+    |> Enum.map(fn {key, value} -> {metric_name, key, value / 1} end)
+  end
+
+  def aggregate_file_metrics(file_results) do
+    file_results
+    |> Map.values()
+    |> Enum.flat_map(fn file_data ->
+      file_data
+      |> Map.get("metrics", %{})
+      |> Enum.flat_map(&metric_data_to_triples/1)
+    end)
+    |> Enum.group_by(fn {metric, key, _val} -> {metric, key} end, fn {_, _, val} -> val end)
+    |> Enum.reduce(%{}, fn {{metric, key}, values}, acc ->
+      stats = compute_stats(values)
+      metric_agg = Map.get(acc, metric, %{})
+
+      updated =
+        Map.merge(metric_agg, %{
+          "mean_#{key}" => stats.mean,
+          "std_#{key}" => stats.std,
+          "min_#{key}" => stats.min,
+          "max_#{key}" => stats.max
+        })
+
+      Map.put(acc, metric, updated)
+    end)
+  end
+
+  defp compute_stats([]), do: %{mean: 0.0, std: 0.0, min: 0.0, max: 0.0}
+
+  defp compute_stats(values) do
+    n = length(values)
+    mean = Enum.sum(values) / n
+    sum_squares = Enum.reduce(values, 0.0, fn v, acc -> acc + (v - mean) ** 2 end)
+    variance = sum_squares / n
+    std = :math.sqrt(variance)
+
+    %{
+      mean: Float.round(mean * 1.0, 4),
+      std: Float.round(std * 1.0, 4),
+      min: Float.round(Enum.min(values) * 1.0, 4),
+      max: Float.round(Enum.max(values) * 1.0, 4)
+    }
+  end
+end
diff --git a/lib/codeqa/engine/collector.ex b/lib/codeqa/engine/collector.ex
new file mode 100644
index 0000000..ea6b16f
--- /dev/null
+++ b/lib/codeqa/engine/collector.ex
@@ -0,0 +1,111 @@
+defmodule CodeQA.Engine.Collector do
+  @moduledoc false
+
+  @skip_dirs MapSet.new(~w[
+    .git .hg .svn node_modules __pycache__ _build dist build vendor
+    .tox .venv venv target .mypy_cache .pytest_cache deps .elixir_ls
+    .next coverage
+  ])
+
+  @spec source_extensions() :: MapSet.t()
+  def source_extensions do
+    CodeQA.Language.all()
+    |> Enum.flat_map(& &1.extensions())
+    |> Enum.map(&".#{&1}")
+    |> MapSet.new()
+  end
+
+  @spec collect_files(String.t(), [String.t()]) :: %{String.t() => String.t()}
+  def collect_files(root, extra_ignore_patterns \\ []) do
+    root_path = Path.expand(root)
+    CodeQA.Config.load(root_path)
+    patterns = all_ignore_patterns(extra_ignore_patterns)
+    extensions = source_extensions()
+
+    unless File.dir?(root_path) do
+      raise File.Error, reason: :enoent, path: root, action: "find directory"
+    end
+
+    files_map =
+      root_path
+      |> walk_directory(extensions)
+      |> Map.new(fn path ->
+        rel = Path.relative_to(path, root_path)
+        {rel, File.read!(path)}
+      end)
+      |> do_reject_ignored_map(patterns)
+
+    gitignored = CodeQA.Git.gitignored_files(root_path, Map.keys(files_map))
+    Map.reject(files_map, fn {path, _} -> MapSet.member?(gitignored, path) end)
+  end
+
+  @doc false
+  def ignored?(path, patterns) do
+    Enum.any?(patterns, fn pattern ->
+      match_pattern?(path, pattern)
+    end)
+  end
+
+  @doc false
+  def reject_ignored_map(files_map, extra_patterns \\ []) do
+    do_reject_ignored_map(files_map, all_ignore_patterns(extra_patterns))
+  end
+
+  @doc false
+  def reject_ignored(list, key_fn, extra_patterns \\ []) do
+    patterns = all_ignore_patterns(extra_patterns)
+    Enum.reject(list, fn item -> ignored?(key_fn.(item), patterns) end)
+  end
+
+  defp all_ignore_patterns(extra), do: extra ++ CodeQA.Config.ignore_paths()
+
+  defp do_reject_ignored_map(files_map, []), do: files_map
+
+  defp do_reject_ignored_map(files_map, patterns) do
+    Map.reject(files_map, fn {path, _} -> ignored?(path, patterns) end)
+  end
+
+  defp match_pattern?(path, pattern) do
+    # Convert glob pattern to regex:
+    # - ** matches any number of directories
+    # - * matches anything except /
+    # - ? matches a single character except /
+    regex_str =
+      pattern
+      |> String.replace(".", "\\.")
+      |> String.replace("**", "\0GLOBSTAR\0")
+      |> String.replace("*", "[^/]*")
+      |> String.replace("?", "[^/]")
+      |> String.replace("\0GLOBSTAR\0", ".*")
+
+    case Regex.compile("^#{regex_str}$") do
+      {:ok, regex} -> Regex.match?(regex, path)
+      _ -> false
+    end
+  end
+
+  defp walk_directory(dir, extensions) do
+    dir
+    |> File.ls!()
+    |> Enum.flat_map(fn entry ->
+      full_path = Path.join(dir, entry)
+
+      cond do
+        File.dir?(full_path) and not skip_dir?(entry) ->
+          walk_directory(full_path, extensions)
+
+        File.regular?(full_path) and source_file?(entry, extensions) and
+            not String.starts_with?(entry, ".") ->
+          [full_path]
+
+        true ->
+          []
+      end
+    end)
+  end
+
+  defp skip_dir?(name), do: MapSet.member?(@skip_dirs, name) or String.starts_with?(name, ".")
+
+  defp source_file?(name, extensions),
+    do: MapSet.member?(extensions, Path.extname(name) |> String.downcase())
+end
diff --git a/lib/codeqa/engine/file_context.ex b/lib/codeqa/engine/file_context.ex
new file mode 100644
index 0000000..6e1da6b
--- /dev/null
+++ b/lib/codeqa/engine/file_context.ex
@@ -0,0 +1,29 @@
+defmodule CodeQA.Engine.FileContext do
+  @moduledoc "Immutable pre-computed data shared across all file metrics."
+  @enforce_keys [
+    :content,
+    :tokens,
+    :token_counts,
+    :words,
+    :identifiers,
+    :lines,
+    :encoded,
+    :byte_count,
+    :line_count
+  ]
+  defstruct @enforce_keys ++ [:path, :blocks]
+
+  @type t :: %__MODULE__{
+          content: String.t(),
+          tokens: [CodeQA.Engine.Pipeline.Token.t()],
+          token_counts: map(),
+          words: list(),
+          identifiers: list(),
+          lines: list(),
+          encoded: String.t(),
+          byte_count: non_neg_integer(),
+          line_count: non_neg_integer(),
+          path: String.t() | nil,
+          blocks: [CodeQA.AST.Enrichment.Node.t()] | nil
+        }
+end
diff --git a/lib/codeqa/parallel.ex b/lib/codeqa/engine/parallel.ex
similarity index 68%
rename from lib/codeqa/parallel.ex
rename to lib/codeqa/engine/parallel.ex
index 0e2cc46..5ddf757 100644
--- a/lib/codeqa/parallel.ex
+++ b/lib/codeqa/engine/parallel.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Parallel do
+defmodule CodeQA.Engine.Parallel do
   @moduledoc "Parallel file analysis using Flow (GenStage-based)."
 
   def analyze_files(files, opts \\ []) when is_map(files) do
@@ -22,7 +22,7 @@ defmodule CodeQA.Parallel do
     |> Flow.map(fn {path, content} ->
       start_time = System.monotonic_time(:millisecond)
 
-      result = maybe_cached_analyze(content, cache_dir, opts)
+      result = maybe_cached_analyze(path, content, cache_dir, opts)
 
       end_time = System.monotonic_time(:millisecond)
       time_taken = end_time - start_time
@@ -38,9 +38,10 @@ defmodule CodeQA.Parallel do
     |> Enum.into(%{})
   end
 
-  defp maybe_cached_analyze(content, nil, opts), do: analyze_single_file(content, opts)
+  defp maybe_cached_analyze(path, content, nil, opts),
+    do: analyze_single_file(path, content, opts)
 
-  defp maybe_cached_analyze(content, cache_dir, opts) do
+  defp maybe_cached_analyze(path, content, cache_dir, opts) do
     hash = :crypto.hash(:sha256, content) |> Base.encode16(case: :lower)
     cache_file = Path.join(cache_dir, hash <> ".json")
 
@@ -51,30 +52,25 @@ defmodule CodeQA.Parallel do
             data
 
           _ ->
-            data = analyze_single_file(content, opts)
+            data = analyze_single_file(path, content, opts)
             File.write!(cache_file, Jason.encode!(data))
             data
         end
 
       _ ->
-        data = analyze_single_file(content, opts)
+        data = analyze_single_file(path, content, opts)
         File.write!(cache_file, Jason.encode!(data))
         data
     end
   end
 
-  defp analyze_single_file(content, opts) do
-    registry = CodeQA.Analyzer.build_registry()
+  defp analyze_single_file(path, content, opts) do
+    registry = CodeQA.Engine.Analyzer.build_registry()
+    file_opts = Keyword.put(opts, :path, path)
+    pid = Keyword.fetch!(opts, :file_context_pid)
 
-    ctx =
-      CodeQA.Telemetry.time(:pipeline_build_context, fn ->
-        CodeQA.Pipeline.build_file_context(content, opts)
-      end)
-
-    metrics =
-      CodeQA.Telemetry.time(:registry_run_metrics, fn ->
-        CodeQA.Registry.run_file_metrics(registry, ctx, opts)
-      end)
+    ctx = CodeQA.Analysis.FileContextServer.get(pid, content, file_opts)
+    metrics = CodeQA.Engine.Registry.run_file_metrics(registry, ctx, opts)
 
     %{
       "bytes" => ctx.byte_count,
diff --git a/lib/codeqa/engine/pipeline.ex b/lib/codeqa/engine/pipeline.ex
new file mode 100644
index 0000000..33a9229
--- /dev/null
+++ b/lib/codeqa/engine/pipeline.ex
@@ -0,0 +1,93 @@
+defmodule CodeQA.Engine.Pipeline do
+  @moduledoc "Pre-computed shared context for file-level metrics."
+
+  defmodule Token do
+    @moduledoc "A lexical token with its string content, kind tag, and 1-based source line."
+    defstruct [:content, :kind, :line]
+
+    @type t :: %__MODULE__{
+            content: String.t(),
+            kind: String.t(),
+            line: pos_integer()
+          }
+  end
+
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.Engine.FileContext
+  alias CodeQA.Language
+
+  @word_re ~r/\b[a-zA-Z_]\w*\b/u
+
+  @spec build_file_context(String.t(), keyword()) :: FileContext.t()
+  def build_file_context(content, opts \\ []) when is_binary(content) do
+    tokens = tokenize(content)
+    token_counts = tokens |> Enum.map(& &1.content) |> Enum.frequencies()
+
+    keywords = MapSet.new(Language.all_keywords())
+
+    words =
+      Regex.scan(@word_re, content)
+      |> List.flatten()
+
+    identifiers = Enum.reject(words, &MapSet.member?(keywords, &1))
+    lines = content |> String.split("\n") |> trim_trailing_empty()
+    encoded = content
+
+    {path, blocks} =
+      case Keyword.get(opts, :path) do
+        nil ->
+          {nil, nil}
+
+        p ->
+          lang_mod = Language.detect(p)
+          structural_tokens = TokenNormalizer.normalize_structural(content)
+          {p, Parser.detect_blocks(structural_tokens, lang_mod)}
+      end
+
+    %FileContext{
+      content: content,
+      tokens: tokens,
+      token_counts: token_counts,
+      words: words,
+      identifiers: identifiers,
+      lines: lines,
+      encoded: encoded,
+      byte_count: byte_size(content),
+      line_count: length(lines),
+      path: path,
+      blocks: blocks
+    }
+  end
+
+  # Matches identifiers, integer/float literals, and single non-whitespace chars.
+  @token_re ~r/[a-zA-Z_]\w*|[0-9]+(?:\.[0-9]+)?|[^\s]/u
+
+  defp tokenize(content) do
+    content
+    |> String.split("\n")
+    |> Enum.with_index(1)
+    |> Enum.flat_map(fn {line, line_num} ->
+      @token_re
+      |> Regex.scan(line)
+      |> List.flatten()
+      |> Enum.map(&%Token{content: &1, kind: classify(&1), line: line_num})
+    end)
+  end
+
+  defp classify(tok) do
+    cond do
+      Regex.match?(~r/^[a-zA-Z_]\w*$/, tok) -> "<ID>"
+      Regex.match?(~r/^[0-9]/, tok) -> "<NUM>"
+      true -> "<PUNCT>"
+    end
+  end
+
+  defp trim_trailing_empty(lines) do
+    # Match Python's str.splitlines() behavior
+    case List.last(lines) do
+      "" -> List.delete_at(lines, -1)
+      _ -> lines
+    end
+  end
+end
diff --git a/lib/codeqa/registry.ex b/lib/codeqa/engine/registry.ex
similarity index 71%
rename from lib/codeqa/registry.ex
rename to lib/codeqa/engine/registry.ex
index 76dfe23..5f9be25 100644
--- a/lib/codeqa/registry.ex
+++ b/lib/codeqa/engine/registry.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Registry do
+defmodule CodeQA.Engine.Registry do
   @moduledoc "Metric registration and execution."
 
   defstruct file_metrics: [], codebase_metrics: []
@@ -14,17 +14,11 @@ defmodule CodeQA.Registry do
   end
 
   def run_file_metrics(%__MODULE__{} = reg, ctx, opts \\ []) do
-    base_metrics =
-      Map.new(reg.file_metrics, fn mod ->
-        {mod.name(),
-         CodeQA.Telemetry.time(String.to_atom("metric_" <> mod.name()), fn -> mod.analyze(ctx) end)}
-      end)
+    base_metrics = Map.new(reg.file_metrics, fn mod -> {mod.name(), mod.analyze(ctx)} end)
 
     if Keyword.get(opts, :combinations, false) do
-      CodeQA.Telemetry.time(:registry_combinations, fn ->
-        combinations = generate_combinations(flat_numeric_metrics(base_metrics), [])
-        Map.merge(base_metrics, Map.new(combinations))
-      end)
+      combinations = generate_combinations(flat_numeric_metrics(base_metrics), [])
+      Map.merge(base_metrics, Map.new(combinations))
     else
       base_metrics
     end
@@ -60,6 +54,16 @@ defmodule CodeQA.Registry do
   end
 
   def run_codebase_metrics(%__MODULE__{} = reg, files, opts \\ []) do
-    Map.new(reg.codebase_metrics, fn mod -> {mod.name(), mod.analyze(files, opts)} end)
+    has_progress = Keyword.has_key?(opts, :on_progress)
+    total = length(reg.codebase_metrics)
+
+    reg.codebase_metrics
+    |> Enum.with_index(1)
+    |> Map.new(fn {mod, idx} ->
+      if has_progress,
+        do: IO.puts(:stderr, "\nCODEBASE #{idx}/#{total}: #{mod.name()}...")
+
+      {mod.name(), mod.analyze(files, opts)}
+    end)
   end
 end
diff --git a/lib/codeqa/formatter.ex b/lib/codeqa/formatter.ex
index 55ba6ef..14c1992 100644
--- a/lib/codeqa/formatter.ex
+++ b/lib/codeqa/formatter.ex
@@ -54,8 +54,8 @@ defmodule CodeQA.Formatter do
   end
 
   defp mermaid_chart(head_grades) do
-    names = Enum.map(head_grades, fn g -> ~s("#{g.name}") end) |> Enum.join(", ")
-    scores = Enum.map(head_grades, fn g -> to_string(g.score) end) |> Enum.join(", ")
+    names = Enum.map_join(head_grades, ", ", fn g -> ~s("#{g.name}") end)
+    scores = Enum.map_join(head_grades, ", ", fn g -> to_string(g.score) end)
 
     [
       "```mermaid",
@@ -91,7 +91,8 @@ defmodule CodeQA.Formatter do
   end
 
   defp file_details(files, codebase, _output_mode) do
-    codebase_summary = CodeQA.Summarizer.summarize_codebase(%{"files" => files, "codebase" => codebase})
+    codebase_summary =
+      CodeQA.Summarizer.summarize_codebase(%{"files" => files, "codebase" => codebase})
 
     file_summaries =
       Map.new(files, fn {path, data} ->
@@ -291,6 +292,7 @@ defmodule CodeQA.Formatter do
         |> Enum.map(fn key ->
           direction = Map.get(direction_map, "#{metric_name}.#{key}")
           delta_cell = format_delta_with_direction(delta_m[key], direction)
+
           "| #{metric_name}.#{key} | #{format_value(base_m[key])} | #{format_value(head_m[key])} | #{delta_cell} |"
         end)
       end)
diff --git a/lib/codeqa/git.ex b/lib/codeqa/git.ex
index 78c0bdb..0576ddc 100644
--- a/lib/codeqa/git.ex
+++ b/lib/codeqa/git.ex
@@ -10,6 +10,22 @@ defmodule CodeQA.Git do
 
   @status_map %{"A" => "added", "M" => "modified", "D" => "deleted"}
 
+  @spec gitignored_files(String.t(), [String.t()]) :: MapSet.t()
+  def gitignored_files(_repo_path, []), do: MapSet.new()
+
+  def gitignored_files(repo_path, paths) do
+    {output, _exit_code} =
+      System.cmd("git", ["check-ignore", "--no-index" | paths],
+        cd: repo_path,
+        stderr_to_stdout: false
+      )
+
+    output
+    |> String.trim()
+    |> String.split("\n", trim: true)
+    |> MapSet.new()
+  end
+
   def changed_files(repo_path, base_ref, head_ref) do
     {output, 0} =
       System.cmd(
@@ -66,6 +82,6 @@ defmodule CodeQA.Git do
 
   defp source_file?(path) do
     ext = path |> Path.extname() |> String.downcase()
-    MapSet.member?(CodeQA.Collector.source_extensions(), ext)
+    MapSet.member?(CodeQA.Engine.Collector.source_extensions(), ext)
   end
 end
diff --git a/lib/codeqa/metrics/similarity.ex b/lib/codeqa/metrics/codebase/similarity.ex
similarity index 66%
rename from lib/codeqa/metrics/similarity.ex
rename to lib/codeqa/metrics/codebase/similarity.ex
index 910e631..cc8b644 100644
--- a/lib/codeqa/metrics/similarity.ex
+++ b/lib/codeqa/metrics/codebase/similarity.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.Similarity do
+defmodule CodeQA.Metrics.Codebase.Similarity do
   @moduledoc """
   Detects cross-file code duplication at the codebase level.
 
@@ -9,23 +9,15 @@ defmodule CodeQA.Metrics.Similarity do
   See [winnowing](https://theory.stanford.edu/~aiken/publications/papers/sigmod03.pdf),
   [locality-sensitive hashing](https://en.wikipedia.org/wiki/Locality-sensitive_hashing),
   and [normalized compression distance](https://en.wikipedia.org/wiki/Normalized_compression_distance).
-
-  ## Options
-
-    - `:show_ncd` — boolean, whether to compute per-pair NCD scores (default: `false`)
-    - `:ncd_paths` — list of file paths to compute similarity for (default: all files)
-    - `:ncd_top` — integer, max similar files to return per path (default: all)
-    - `:ncd_threshold` — minimum Jaccard similarity to consider as candidate (default: `0.20`)
-    - `:workers` — number of parallel workers (default: `System.schedulers_online/0`)
-    - `:on_progress` — include this key (any value) to enable progress output to stderr
-    - `:fp_stopwords` — `MapSet` of fingerprint hashes to exclude (default: empty)
   """
 
-  @behaviour CodeQA.Metrics.CodebaseMetric
+  @behaviour CodeQA.Metrics.Codebase.CodebaseMetric
 
   @impl true
   def name, do: "similarity"
 
+  def keys, do: ["ncd_pairs", "cross_file_density"]
+
   @spec analyze(map(), keyword()) :: map()
   @impl true
   def analyze(files, opts \\ [])
@@ -37,6 +29,9 @@ defmodule CodeQA.Metrics.Similarity do
   def analyze(files, opts) do
     names = Map.keys(files)
     contents = Map.values(files)
+    has_progress = Keyword.has_key?(opts, :on_progress)
+
+    if has_progress, do: IO.puts(:stderr, "  Computing cross-file density...")
 
     result = %{
       "cross_file_density" => cross_file_density(contents)
@@ -80,38 +75,45 @@ defmodule CodeQA.Metrics.Similarity do
     if has_progress, do: IO.puts(:stderr, "  2/5 Computing Winnowing fingerprints...")
 
     result =
-      CodeQA.Telemetry.time(:ncd_fingerprinting, fn ->
-        contents
-        |> Enum.with_index()
-        |> Task.async_stream(
-          fn {content, i} ->
-            fp = compute_fingerprints(content, opts)
-            {i, fp}
-          end, max_concurrency: workers, timeout: :infinity)
-        |> Enum.map(fn {:ok, {i, fp}} ->
-          print_bar_progress(has_progress, i, length(contents), "Fingerprinting")
+      contents
+      |> Enum.with_index()
+      |> Task.async_stream(
+        fn {content, i} ->
+          fp = compute_fingerprints(content, opts)
           {i, fp}
-        end)
-        |> Map.new()
+        end,
+        max_concurrency: workers,
+        timeout: :infinity
+      )
+      |> Enum.map(fn {:ok, {i, fp}} ->
+        maybe_print_fingerprint_progress(has_progress, i, length(contents))
+        {i, fp}
       end)
+      |> Map.new()
 
     if has_progress, do: IO.puts(:stderr, "")
     result
   end
 
+  defp maybe_print_fingerprint_progress(false, _i, _total), do: :ok
+
+  defp maybe_print_fingerprint_progress(true, i, total) do
+    if rem(i + 1, max(1, div(total, 20))) == 0 do
+      IO.write(:stderr, "\r" <> CodeQA.CLI.UI.progress_bar(i + 1, total, label: "Fingerprinting"))
+    end
+  end
+
   defp build_inverted_index(fingerprints_by_id, has_progress) do
     if has_progress, do: IO.puts(:stderr, "  3/5 Building inverted index...")
 
     total = map_size(fingerprints_by_id)
 
     result =
-      CodeQA.Telemetry.time(:ncd_build_index, fn ->
-        fingerprints_by_id
-        |> Enum.with_index()
-        |> Enum.reduce(%{}, fn {{i, set}, idx}, acc ->
-          print_bar_progress(has_progress, idx, total, "Indexing")
-          index_fingerprint_set(set, i, acc)
-        end)
+      fingerprints_by_id
+      |> Enum.with_index()
+      |> Enum.reduce(%{}, fn {{i, set}, idx}, acc ->
+        maybe_print_index_progress(has_progress, idx, total)
+        index_fingerprint_set(set, i, acc)
       end)
 
     if has_progress, do: IO.puts(:stderr, "")
@@ -124,6 +126,14 @@ defmodule CodeQA.Metrics.Similarity do
     end)
   end
 
+  defp maybe_print_index_progress(false, _idx, _total), do: :ok
+
+  defp maybe_print_index_progress(true, idx, total) do
+    if rem(idx + 1, max(1, div(total, 20))) == 0 do
+      IO.write(:stderr, "\r" <> CodeQA.CLI.UI.progress_bar(idx + 1, total, label: "Indexing"))
+    end
+  end
+
   defp find_candidate_pairs(
          fingerprints_by_id,
          inverted_index,
@@ -136,37 +146,37 @@ defmodule CodeQA.Metrics.Similarity do
     if has_progress, do: IO.puts(:stderr, "  4/5 Identifying candidate pairs...")
 
     total = map_size(fingerprints_by_id)
-    names_tuple = List.to_tuple(names)
 
     candidates =
-      CodeQA.Telemetry.time(:ncd_lsh_filter, fn ->
-        fingerprints_by_id
-        |> Enum.with_index()
-        |> Task.async_stream(
-          fn {{i, set}, idx} ->
-            valid_pairs =
-              collect_valid_pairs(
-                i,
-                set,
-                inverted_index,
-                fingerprints_by_id,
-                names_tuple,
-                target_set,
-                threshold
-              )
-
-            {idx, valid_pairs}
-          end, max_concurrency: workers, timeout: :infinity)
-        |> Enum.reduce(%{}, fn {:ok, {idx, valid_pairs}}, acc ->
-          print_bar_progress(has_progress, idx, total, "LSH Filter")
-          merge_valid_pairs(valid_pairs, acc)
-        end)
+      fingerprints_by_id
+      |> Enum.with_index()
+      |> Task.async_stream(
+        fn {{i, set}, idx} ->
+          valid_pairs =
+            collect_valid_pairs(
+              i,
+              set,
+              inverted_index,
+              fingerprints_by_id,
+              names,
+              target_set,
+              threshold
+            )
+
+          {idx, valid_pairs}
+        end,
+        max_concurrency: workers,
+        timeout: :infinity
+      )
+      |> Enum.reduce(%{}, fn {:ok, {idx, valid_pairs}}, acc ->
+        maybe_print_lsh_progress(has_progress, idx, total)
+        merge_valid_pairs(valid_pairs, acc)
       end)
 
     if has_progress, do: IO.puts(:stderr, "")
 
     Enum.map(candidates, fn {{i, j}, jaccard} ->
-      {elem(names_tuple, i), i, elem(names_tuple, j), j, jaccard}
+      {Enum.at(names, i), i, Enum.at(names, j), j, jaccard}
     end)
   end
 
@@ -175,19 +185,19 @@ defmodule CodeQA.Metrics.Similarity do
          set,
          inverted_index,
          fingerprints_by_id,
-         names_tuple,
+         names,
          target_set,
          threshold
        ) do
     collisions = count_collisions(set, inverted_index, i)
 
     size_a = MapSet.size(set)
-    name_a = elem(names_tuple, i)
+    name_a = Enum.at(names, i)
 
     is_target_a = MapSet.member?(target_set, name_a)
 
     collisions
-    |> Enum.filter(fn {j, _} -> is_target_a or MapSet.member?(target_set, elem(names_tuple, j)) end)
+    |> Enum.filter(fn {j, _} -> is_target_a or MapSet.member?(target_set, Enum.at(names, j)) end)
     |> Enum.reduce([], fn {j, intersection}, acc_pairs ->
       jaccard = compute_jaccard(size_a, MapSet.size(Map.get(fingerprints_by_id, j)), intersection)
       if jaccard >= threshold, do: [{{i, j}, jaccard} | acc_pairs], else: acc_pairs
@@ -217,11 +227,11 @@ defmodule CodeQA.Metrics.Similarity do
     end)
   end
 
-  defp print_bar_progress(false, _current, _total, _label), do: :ok
+  defp maybe_print_lsh_progress(false, _idx, _total), do: :ok
 
-  defp print_bar_progress(true, current, total, label) do
-    if rem(current + 1, max(1, div(total, 20))) == 0 do
-      IO.write(:stderr, "\r" <> CodeQA.CLI.UI.progress_bar(current + 1, total, label: label))
+  defp maybe_print_lsh_progress(true, idx, total) do
+    if rem(idx + 1, max(1, div(total, 20))) == 0 do
+      IO.write(:stderr, "\r" <> CodeQA.CLI.UI.progress_bar(idx + 1, total, label: "LSH Filter"))
     end
   end
 
@@ -240,26 +250,25 @@ defmodule CodeQA.Metrics.Similarity do
     counter = :counters.new(1, [:atomics])
     start_time_ncd = System.monotonic_time(:millisecond)
 
-    CodeQA.Telemetry.time(:ncd_exact_compression_phase, fn ->
-      filtered_pairs
-      |> Task.async_stream(
-        fn {name_a, i, name_b, j, _jaccard} ->
-          ncd = compute_single_ncd(precomputed, i, j)
-          maybe_print_ncd_progress(has_progress, counter, total_pairs, start_time_ncd)
-          {name_a, name_b, ncd}
-        end, max_concurrency: workers, timeout: :infinity)
-      |> Enum.map(fn {:ok, res} -> res end)
-    end)
+    filtered_pairs
+    |> Task.async_stream(
+      fn {name_a, i, name_b, j, _jaccard} ->
+        ncd = compute_single_ncd(precomputed, i, j)
+        maybe_print_ncd_progress(has_progress, counter, total_pairs, start_time_ncd)
+        {name_a, name_b, ncd}
+      end,
+      max_concurrency: workers,
+      timeout: :infinity
+    )
+    |> Enum.map(fn {:ok, res} -> res end)
   end
 
   defp compute_single_ncd(precomputed, i, j) do
-    CodeQA.Telemetry.time(:ncd_single_compression, fn ->
-      {a, ca} = elem(precomputed, i)
-      {b, cb} = elem(precomputed, j)
-      cab = byte_size(:zlib.compress([a, b]))
-      ncd = if max(ca, cb) > 0, do: (cab - min(ca, cb)) / max(ca, cb), else: 0.0
-      Float.round(ncd, 4)
-    end)
+    {a, ca} = elem(precomputed, i)
+    {b, cb} = elem(precomputed, j)
+    cab = byte_size(:zlib.compress([a, b]))
+    ncd = if max(ca, cb) > 0, do: (cab - min(ca, cb)) / max(ca, cb), else: 0.0
+    Float.round(ncd, 4)
   end
 
   defp maybe_print_ncd_progress(false, _counter, _total_pairs, _start_time), do: :ok
@@ -316,13 +325,11 @@ defmodule CodeQA.Metrics.Similarity do
     end
   end
 
-  defp compute_fingerprints(content, opts) do
-    fp_stopwords = Keyword.get(opts, :fp_stopwords, MapSet.new())
-
+  defp compute_fingerprints(content, _opts) do
     content
-    |> CodeQA.Metrics.TokenNormalizer.normalize()
-    |> CodeQA.Metrics.Winnowing.kgrams(5)
-    |> Enum.reject(&MapSet.member?(fp_stopwords, &1))
+    |> CodeQA.AST.Lexing.TokenNormalizer.normalize_structural()
+    |> Enum.map(& &1.kind)
+    |> CodeQA.Metrics.File.Winnowing.kgrams(5)
     |> MapSet.new()
   end
 
diff --git a/lib/codeqa/metrics/codebase_metric.ex b/lib/codeqa/metrics/codebase_metric.ex
deleted file mode 100644
index 0b1284d..0000000
--- a/lib/codeqa/metrics/codebase_metric.ex
+++ /dev/null
@@ -1,42 +0,0 @@
-defmodule CodeQA.Metrics.CodebaseMetric do
-  @moduledoc """
-  Behaviour for metrics that operate across an entire codebase.
-
-  Unlike `FileMetric`, which analyzes a single file, codebase metrics receive
-  a map of all source files and can compute cross-file properties such as
-  duplication or structural similarity.
-
-  ## Common opts keys
-
-  Implementations may accept keyword options including:
-  - `:workers` — number of parallel workers (default: `System.schedulers_online/0`)
-  - `:on_progress` — progress callback key (presence enables progress output)
-
-  ## Minimal implementation
-
-      defmodule MyCodebaseMetric do
-        @behaviour CodeQA.Metrics.CodebaseMetric
-
-        @impl true
-        def name, do: "my_metric"
-
-        @impl true
-        def analyze(files, _opts) do
-          %{"file_count" => map_size(files)}
-        end
-      end
-
-  See [software metrics](https://en.wikipedia.org/wiki/Software_metric).
-  """
-
-  @typedoc "Map of file path to file content string."
-  @type file_map :: %{required(String.t()) => String.t()}
-
-  @callback name() :: String.t()
-  @callback analyze(file_map(), keyword()) :: map()
-
-  @doc "Human-readable description of what this metric measures."
-  @callback description() :: String.t()
-
-  @optional_callbacks [description: 0]
-end
diff --git a/lib/codeqa/metrics/file/bradford.ex b/lib/codeqa/metrics/file/bradford.ex
new file mode 100644
index 0000000..22b7bce
--- /dev/null
+++ b/lib/codeqa/metrics/file/bradford.ex
@@ -0,0 +1,99 @@
+defmodule CodeQA.Metrics.File.Bradford do
+  @moduledoc """
+  Applies Bradford's concentration law to token density across lines.
+
+  Lines are ranked by token count (densest first), then grouped into three
+  zones of equal total tokens. The ratio between zone sizes gives Bradford's
+  k values: how many more lines each successive zone needs to match the
+  token yield of the previous one.
+
+      k ≈ 1    uniform density — tokens spread evenly across lines
+      k = 3–5  Bradford-like — a small dense core, long sparse tail
+      k >> 5   extreme concentration — a few lines carry almost all tokens
+
+  k1 = zone2_lines / zone1_lines  (core → middle transition)
+  k2 = zone3_lines / zone2_lines  (middle → tail transition)
+  k_ratio = k2 / k1               (> 1 means tail is more stretched than core)
+
+  In a perfect Bradford distribution k1 ≈ k2. In practice k2 > k1 is common
+  (moderate core, very stretched tail); k1 > k2 suggests extreme concentration
+  that levels off quickly.
+
+  See [Bradford's law](https://en.wikipedia.org/wiki/Bradford%27s_law).
+  """
+
+  @behaviour CodeQA.Metrics.File.FileMetric
+
+  @impl true
+  def name, do: "bradford"
+
+  @impl true
+  def keys, do: ["k1", "k2", "k_ratio"]
+
+  @spec analyze(map()) :: map()
+  @impl true
+  def analyze(%{tokens: []}) do
+    %{"k1" => 0.0, "k2" => 0.0, "k_ratio" => 0.0}
+  end
+
+  def analyze(%{tokens: tokens}) do
+    # Count tokens per line using the .line field, then rank densest-first —
+    # this is Bradford's "sort sources by yield" step.
+    counts =
+      tokens
+      |> Enum.group_by(& &1.line)
+      |> Enum.map(fn {_line, toks} -> length(toks) end)
+      |> Enum.sort(:desc)
+
+    total = Enum.sum(counts)
+
+    # Need at least 3 lines and 3 tokens to form meaningful zones.
+    if total < 3 or length(counts) < 3 do
+      %{"k1" => 0.0, "k2" => 0.0, "k_ratio" => 0.0}
+    else
+      # Each zone should contain one third of all tokens.
+      # We find zone boundaries by walking the ranked list until each third is filled.
+      third = total / 3
+
+      # n1: lines in zone 1 (the dense core — fewest lines, highest token density)
+      # n2: lines in zone 2 (middle tier)
+      # n3: all remaining lines (the sparse tail)
+      {n1, rest} = count_until(counts, third)
+      {n2, _} = count_until(rest, third)
+      n3 = length(counts) - n1 - n2
+
+      # k1 > 1 always: the middle zone always needs more lines than the core.
+      # Higher k1 = more extreme concentration in the core (fewer lines do more work).
+      k1 = if n1 > 0, do: Float.round(n2 / n1, 4), else: 0.0
+
+      # k2 > 1 always: the tail always needs more lines than the middle.
+      # Higher k2 = longer sparse tail relative to the middle zone.
+      k2 = if n2 > 0, do: Float.round(n3 / n2, 4), else: 0.0
+
+      # k_ratio = k2 / k1
+      # > 1: the tail is more stretched than the core is concentrated (common — many trivial lines)
+      # < 1: the core is more extreme than the tail is sparse (god-function pattern)
+      # ≈ 1: a clean Bradford distribution where each zone multiplies evenly
+      k_ratio = if k1 > 0, do: Float.round(k2 / k1, 4), else: 0.0
+
+      %{"k1" => k1, "k2" => k2, "k_ratio" => k_ratio}
+    end
+  end
+
+  # Walks the density-ranked list, consuming lines until the accumulated token
+  # count reaches the zone target. Returns {lines_consumed, remaining_list}.
+  # The remaining list is passed directly to the next zone's count_until call,
+  # so zones are computed in a single linear pass over the sorted counts.
+  defp count_until(counts, target), do: do_count(counts, target, 0, 0)
+
+  defp do_count([], _target, n, _acc), do: {n, []}
+
+  defp do_count([h | rest], target, n, acc) do
+    new_acc = acc + h
+    # Once we've accumulated enough tokens to fill the zone, stop and return
+    # the remainder so the next zone can continue from where we left off.
+    if new_acc >= target,
+      do: {n + 1, rest},
+      else: do_count(rest, target, n + 1, new_acc)
+  end
+end
diff --git a/lib/codeqa/metrics/branching.ex b/lib/codeqa/metrics/file/branching.ex
similarity index 70%
rename from lib/codeqa/metrics/branching.ex
rename to lib/codeqa/metrics/file/branching.ex
index 2cfdbe1..ce5e20a 100644
--- a/lib/codeqa/metrics/branching.ex
+++ b/lib/codeqa/metrics/file/branching.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.Branching do
+defmodule CodeQA.Metrics.File.Branching do
   @moduledoc """
   Measures branching density as a proxy for cyclomatic complexity.
 
@@ -12,7 +12,7 @@ defmodule CodeQA.Metrics.Branching do
   See [cyclomatic complexity](https://en.wikipedia.org/wiki/Cyclomatic_complexity).
   """
 
-  @behaviour CodeQA.Metrics.FileMetric
+  @behaviour CodeQA.Metrics.File.FileMetric
 
   # Python:     if elif else for while try except finally with match case
   # Ruby:       if elsif else unless for while until case when begin rescue ensure
@@ -43,18 +43,14 @@ defmodule CodeQA.Metrics.Branching do
   @impl true
   def name, do: "branching"
 
-  @spec analyze(map()) :: map()
   @impl true
-  def analyze(%{lines: lines, tokens: tokens}) do
-    non_blank_count =
-      lines
-      |> Tuple.to_list()
-      |> Enum.count(&(String.trim(&1) != ""))
+  def keys, do: ["branching_density", "branch_count", "non_blank_count", "max_nesting_depth"]
 
-    branch_count =
-      tokens
-      |> Tuple.to_list()
-      |> Enum.count(&MapSet.member?(@branching_keywords, &1))
+  @spec analyze(CodeQA.Engine.FileContext.t()) :: map()
+  @impl true
+  def analyze(%{lines: lines, tokens: tokens, content: content}) do
+    non_blank_count = Enum.count(lines, &(String.trim(&1) != ""))
+    branch_count = Enum.count(tokens, &MapSet.member?(@branching_keywords, &1.content))
 
     density =
       if non_blank_count > 0,
@@ -64,7 +60,19 @@ defmodule CodeQA.Metrics.Branching do
     %{
       "branching_density" => density,
       "branch_count" => branch_count,
-      "non_blank_count" => non_blank_count
+      "non_blank_count" => non_blank_count,
+      "max_nesting_depth" => max_nesting_depth(content)
     }
   end
+
+  defp max_nesting_depth(content) do
+    content
+    |> String.graphemes()
+    |> Enum.reduce({0, 0}, fn
+      c, {depth, max} when c in ["(", "[", "{"] -> {depth + 1, max(depth + 1, max)}
+      c, {depth, max} when c in [")", "]", "}"] -> {max(depth - 1, 0), max}
+      _, acc -> acc
+    end)
+    |> elem(1)
+  end
 end
diff --git a/lib/codeqa/metrics/file/brevity.ex b/lib/codeqa/metrics/file/brevity.ex
new file mode 100644
index 0000000..bc0d9a6
--- /dev/null
+++ b/lib/codeqa/metrics/file/brevity.ex
@@ -0,0 +1,50 @@
+defmodule CodeQA.Metrics.File.Brevity do
+  @moduledoc """
+  Measures how well Brevity law holds in the token distribution.
+
+  Computes the Pearson correlation between token length and token frequency.
+  A negative value indicates shorter tokens appear more often (law holds).
+  A positive value indicates longer tokens appear more often (law violated).
+  Also fits a log-log regression to capture the power-law slope.
+
+  See [Brevity law](https://en.wikipedia.org/wiki/Brevity_law).
+  """
+
+  @behaviour CodeQA.Metrics.File.FileMetric
+
+  @impl true
+  def name, do: "brevity"
+
+  @impl true
+  def keys, do: ["correlation", "slope", "sample_size"]
+
+  @spec analyze(map()) :: map()
+  @impl true
+  def analyze(%{token_counts: token_counts}) when map_size(token_counts) < 3 do
+    %{"correlation" => 0.0, "slope" => 0.0, "sample_size" => map_size(token_counts)}
+  end
+
+  def analyze(%{token_counts: token_counts}) do
+    pairs = Enum.map(token_counts, fn {token, freq} -> {String.length(token), freq} end)
+    lengths = Enum.map(pairs, &elem(&1, 0))
+    freqs = Enum.map(pairs, &elem(&1, 1))
+
+    %{
+      "correlation" => CodeQA.Math.pearson_correlation_list(lengths, freqs),
+      "slope" => log_log_slope(lengths, freqs),
+      "sample_size" => map_size(token_counts)
+    }
+  end
+
+  defp log_log_slope(lengths, freqs) do
+    log_lengths = lengths |> Enum.map(&:math.log(max(&1, 1))) |> Nx.tensor(type: :f64)
+    log_freqs = freqs |> Enum.map(&:math.log(max(&1, 1))) |> Nx.tensor(type: :f64)
+
+    {slope, _intercept, _r_squared} = CodeQA.Math.linear_regression(log_lengths, log_freqs)
+
+    case Nx.to_number(slope) do
+      val when is_float(val) -> Float.round(val, 4)
+      _ -> 0.0
+    end
+  end
+end
diff --git a/lib/codeqa/metrics/casing_entropy.ex b/lib/codeqa/metrics/file/casing_entropy.ex
similarity index 61%
rename from lib/codeqa/metrics/casing_entropy.ex
rename to lib/codeqa/metrics/file/casing_entropy.ex
index cb38011..6f1cb2d 100644
--- a/lib/codeqa/metrics/casing_entropy.ex
+++ b/lib/codeqa/metrics/file/casing_entropy.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.CasingEntropy do
+defmodule CodeQA.Metrics.File.CasingEntropy do
   @moduledoc """
   Measures Shannon entropy of identifier casing styles in a file.
 
@@ -12,31 +12,43 @@ defmodule CodeQA.Metrics.CasingEntropy do
   - `"pascal_case_count"`, `"camel_case_count"`, `"snake_case_count"`,
     `"macro_case_count"`, `"kebab_case_count"`, `"other_count"` — per-style
     counts (only keys for styles that appear are included)
+  - `"screaming_snake_density"` — ratio of MACRO_CASE identifiers to total identifiers
 
   See [Shannon entropy](https://en.wikipedia.org/wiki/Entropy_(information_theory))
   and [naming conventions](https://en.wikipedia.org/wiki/Naming_convention_(programming)).
   """
 
-  @behaviour CodeQA.Metrics.FileMetric
+  @behaviour CodeQA.Metrics.File.FileMetric
 
   @impl true
   def name, do: "casing_entropy"
 
+  @impl true
+  def keys,
+    do: [
+      "entropy",
+      "pascal_case_count",
+      "camel_case_count",
+      "snake_case_count",
+      "macro_case_count",
+      "kebab_case_count",
+      "other_count",
+      "screaming_snake_density"
+    ]
+
   @spec analyze(map()) :: map()
   @impl true
-  def analyze(%{identifiers: identifiers}) when tuple_size(identifiers) == 0 do
-    %{"entropy" => 0.0}
+  def analyze(%{identifiers: []}) do
+    %{"entropy" => 0.0, "screaming_snake_density" => 0.0}
   end
 
   def analyze(%{identifiers: identifiers}) do
-    identifiers_list = Tuple.to_list(identifiers)
-
     counts =
-      identifiers_list
-      |> Enum.map(&CodeQA.Metrics.Inflector.detect_casing/1)
+      identifiers
+      |> Enum.map(&CodeQA.Metrics.File.Inflector.detect_casing/1)
       |> Enum.frequencies()
 
-    total = length(identifiers_list)
+    total = length(identifiers)
 
     entropy =
       counts
@@ -46,7 +58,10 @@ defmodule CodeQA.Metrics.CasingEntropy do
         acc - p * :math.log2(p)
       end)
 
-    %{"entropy" => Float.round(entropy, 4)}
+    macro_count = Map.get(counts, :macro_case, 0)
+    screaming_density = Float.round(macro_count / total, 4)
+
+    %{"entropy" => Float.round(entropy, 4), "screaming_snake_density" => screaming_density}
     |> Map.merge(counts_to_output(counts))
   end
 
diff --git a/lib/codeqa/metrics/file/comment_structure.ex b/lib/codeqa/metrics/file/comment_structure.ex
new file mode 100644
index 0000000..65bc0e0
--- /dev/null
+++ b/lib/codeqa/metrics/file/comment_structure.ex
@@ -0,0 +1,45 @@
+defmodule CodeQA.Metrics.File.CommentStructure do
+  @moduledoc """
+  Measures comment density and annotation patterns.
+
+  Counts lines that begin with a comment marker (language-agnostic: `#`, `//`,
+  `/*`, ` *`) relative to non-blank lines. Also counts TODO/FIXME/HACK/XXX
+  markers which indicate deferred work or known issues.
+
+  ## Output keys
+
+  - `"comment_line_ratio"` — comment lines / non-blank lines
+  - `"comment_line_count"` — raw count of comment lines
+  - `"todo_fixme_count"` — occurrences of TODO, FIXME, HACK, or XXX
+  """
+
+  @behaviour CodeQA.Metrics.File.FileMetric
+
+  @impl true
+  def name, do: "comment_structure"
+
+  @impl true
+  def keys, do: ["comment_line_ratio", "comment_line_count", "todo_fixme_count"]
+
+  @comment_line ~r/^\s*(?:#|\/\/|\/\*|\*)/
+  @todo_marker ~r/\b(?:TODO|FIXME|HACK|XXX)\b/
+
+  @spec analyze(map()) :: map()
+  @impl true
+  def analyze(%{content: content, lines: lines}) do
+    non_blank = Enum.reject(lines, &(String.trim(&1) == ""))
+    non_blank_count = length(non_blank)
+
+    comment_count = Enum.count(non_blank, &Regex.match?(@comment_line, &1))
+    todo_count = @todo_marker |> Regex.scan(content) |> length()
+
+    comment_ratio =
+      if non_blank_count > 0, do: Float.round(comment_count / non_blank_count, 4), else: 0.0
+
+    %{
+      "comment_line_ratio" => comment_ratio,
+      "comment_line_count" => comment_count,
+      "todo_fixme_count" => todo_count
+    }
+  end
+end
diff --git a/lib/codeqa/metrics/compression.ex b/lib/codeqa/metrics/file/compression.ex
similarity index 56%
rename from lib/codeqa/metrics/compression.ex
rename to lib/codeqa/metrics/file/compression.ex
index fe68705..9f0981b 100644
--- a/lib/codeqa/metrics/compression.ex
+++ b/lib/codeqa/metrics/file/compression.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.Compression do
+defmodule CodeQA.Metrics.File.Compression do
   @moduledoc """
   Measures file redundancy via zlib compression ratio.
 
@@ -6,34 +6,49 @@ defmodule CodeQA.Metrics.Compression do
   original. A high compression ratio signals repetitive or boilerplate-heavy
   code.
 
-  `ctx.encoded` is the binary representation of the file content used for
-  compression, distinct from `ctx.content` which is the UTF-8 string.
-
   See [Kolmogorov complexity](https://en.wikipedia.org/wiki/Kolmogorov_complexity)
   and [data compression ratio](https://en.wikipedia.org/wiki/Data_compression_ratio).
   """
 
-  @behaviour CodeQA.Metrics.FileMetric
+  @behaviour CodeQA.Metrics.File.FileMetric
 
   @impl true
   def name, do: "compression"
 
+  @impl true
+  def keys, do: ["raw_bytes", "zlib_bytes", "zlib_ratio", "redundancy", "unique_line_ratio"]
+
   @spec analyze(map()) :: map()
   @impl true
   def analyze(%{content: "", byte_count: 0}) do
-    %{"raw_bytes" => 0, "zlib_bytes" => 0, "zlib_ratio" => 0.0, "redundancy" => 0.0}
+    %{
+      "raw_bytes" => 0,
+      "zlib_bytes" => 0,
+      "zlib_ratio" => 0.0,
+      "redundancy" => 0.0,
+      "unique_line_ratio" => 0.0
+    }
   end
 
   def analyze(ctx) do
     raw_size = ctx.byte_count
-    zlib_data = :zlib.compress(ctx.encoded)
+    zlib_data = :zlib.compress(ctx.content)
     zlib_size = byte_size(zlib_data)
 
+    non_blank = ctx.lines |> Enum.reject(&(String.trim(&1) == ""))
+
+    unique_line_ratio =
+      case length(non_blank) do
+        0 -> 0.0
+        n -> Float.round(length(Enum.uniq(non_blank)) / n, 4)
+      end
+
     %{
       "raw_bytes" => raw_size,
       "zlib_bytes" => zlib_size,
       "zlib_ratio" => Float.round(raw_size / max(1, zlib_size), 4),
-      "redundancy" => Float.round(max(0.0, 1.0 - zlib_size / raw_size), 4)
+      "redundancy" => Float.round(max(0.0, 1.0 - zlib_size / raw_size), 4),
+      "unique_line_ratio" => unique_line_ratio
     }
   end
 end
diff --git a/lib/codeqa/metrics/entropy.ex b/lib/codeqa/metrics/file/entropy.ex
similarity index 82%
rename from lib/codeqa/metrics/entropy.ex
rename to lib/codeqa/metrics/file/entropy.ex
index 4756471..6533a21 100644
--- a/lib/codeqa/metrics/entropy.ex
+++ b/lib/codeqa/metrics/file/entropy.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.Entropy do
+defmodule CodeQA.Metrics.File.Entropy do
   @moduledoc """
   Computes Shannon entropy at both character and token levels.
 
@@ -11,11 +11,24 @@ defmodule CodeQA.Metrics.Entropy do
   See [Shannon entropy](https://en.wikipedia.org/wiki/Entropy_(information_theory)).
   """
 
-  @behaviour CodeQA.Metrics.FileMetric
+  @behaviour CodeQA.Metrics.File.FileMetric
 
   @impl true
   def name, do: "entropy"
 
+  @impl true
+  def keys,
+    do: [
+      "char_entropy",
+      "char_max_entropy",
+      "char_normalized",
+      "token_entropy",
+      "token_max_entropy",
+      "token_normalized",
+      "vocab_size",
+      "total_tokens"
+    ]
+
   @spec analyze(map()) :: map()
   @impl true
   def analyze(ctx) do
@@ -30,13 +43,12 @@ defmodule CodeQA.Metrics.Entropy do
     compute_entropy(counts, total, "char")
   end
 
-  defp token_entropy(%{tokens: tokens, token_counts: _token_counts})
-       when tuple_size(tokens) == 0 do
+  defp token_entropy(%{tokens: [], token_counts: _token_counts}) do
     Map.merge(zero_entropy_map("token"), %{"vocab_size" => 0, "total_tokens" => 0})
   end
 
   defp token_entropy(%{tokens: tokens, token_counts: token_counts}) do
-    total = tuple_size(tokens)
+    total = length(tokens)
     vocab_size = map_size(token_counts)
 
     entropy_map = compute_entropy(token_counts, total, "token")
diff --git a/lib/codeqa/metrics/file_metric.ex b/lib/codeqa/metrics/file/file_metric.ex
similarity index 77%
rename from lib/codeqa/metrics/file_metric.ex
rename to lib/codeqa/metrics/file/file_metric.ex
index 75a6f61..9488c7b 100644
--- a/lib/codeqa/metrics/file_metric.ex
+++ b/lib/codeqa/metrics/file/file_metric.ex
@@ -1,8 +1,8 @@
-defmodule CodeQA.Metrics.FileMetric do
+defmodule CodeQA.Metrics.File.FileMetric do
   @moduledoc """
   Behaviour for metrics that analyze a single source file.
 
-  Implementations receive a `CodeQA.Pipeline.FileContext` struct containing
+  Implementations receive a `CodeQA.Engine.FileContext` struct containing
   pre-parsed data (tokens, identifiers, lines, etc.) and return a map of
   metric key-value pairs. On error, return an empty map `%{}` rather than
   raising.
@@ -25,7 +25,10 @@ defmodule CodeQA.Metrics.FileMetric do
   """
 
   @callback name() :: String.t()
-  @callback analyze(CodeQA.Pipeline.FileContext.t()) :: map()
+  @callback analyze(CodeQA.Engine.FileContext.t()) :: map()
+
+  @doc "List of metric keys returned by analyze/1."
+  @callback keys() :: [String.t()]
 
   @doc "Human-readable description of what this metric measures."
   @callback description() :: String.t()
diff --git a/lib/codeqa/metrics/function_metrics.ex b/lib/codeqa/metrics/file/function_metrics.ex
similarity index 92%
rename from lib/codeqa/metrics/function_metrics.ex
rename to lib/codeqa/metrics/file/function_metrics.ex
index 7fd2262..6a9bb0c 100644
--- a/lib/codeqa/metrics/function_metrics.ex
+++ b/lib/codeqa/metrics/file/function_metrics.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.FunctionMetrics do
+defmodule CodeQA.Metrics.File.FunctionMetrics do
   @moduledoc """
   Estimates function-level structure metrics from source text.
 
@@ -13,7 +13,7 @@ defmodule CodeQA.Metrics.FunctionMetrics do
   - C#: lines starting with access modifiers (`public`, `private`, etc.)
   """
 
-  @behaviour CodeQA.Metrics.FileMetric
+  @behaviour CodeQA.Metrics.File.FileMetric
 
   # Python, Ruby, Elixir: `def` family
   # JavaScript: `function`
@@ -39,14 +39,23 @@ defmodule CodeQA.Metrics.FunctionMetrics do
   @impl true
   def name, do: "function_metrics"
 
+  @impl true
+  def keys,
+    do: [
+      "function_count",
+      "avg_function_lines",
+      "max_function_lines",
+      "avg_param_count",
+      "max_param_count"
+    ]
+
   @spec analyze(map()) :: map()
   @impl true
   def analyze(%{lines: lines}) do
-    lines_list = Tuple.to_list(lines)
-    total = length(lines_list)
+    total = length(lines)
 
     {func_indices, param_counts} =
-      lines_list
+      lines
       |> Enum.with_index()
       |> Enum.filter(fn {line, _} ->
         Regex.match?(@func_keyword_re, line) or Regex.match?(@csharp_method_re, line)
diff --git a/lib/codeqa/metrics/halstead.ex b/lib/codeqa/metrics/file/halstead.ex
similarity index 92%
rename from lib/codeqa/metrics/halstead.ex
rename to lib/codeqa/metrics/file/halstead.ex
index ca38665..157f67b 100644
--- a/lib/codeqa/metrics/halstead.ex
+++ b/lib/codeqa/metrics/file/halstead.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.Halstead do
+defmodule CodeQA.Metrics.File.Halstead do
   @moduledoc """
   Implements Halstead software-science complexity metrics.
 
@@ -9,11 +9,27 @@ defmodule CodeQA.Metrics.Halstead do
   See [Halstead complexity measures](https://en.wikipedia.org/wiki/Halstead_complexity_measures).
   """
 
-  @behaviour CodeQA.Metrics.FileMetric
+  @behaviour CodeQA.Metrics.File.FileMetric
 
   @impl true
   def name, do: "halstead"
 
+  @impl true
+  def keys,
+    do: [
+      "n1_unique_operators",
+      "n2_unique_operands",
+      "N1_total_operators",
+      "N2_total_operands",
+      "vocabulary",
+      "length",
+      "volume",
+      "difficulty",
+      "effort",
+      "estimated_bugs",
+      "time_to_implement_seconds"
+    ]
+
   # Keyword operators for:
   # Python, Ruby, JavaScript, Elixir, C#,
   # Java, C++, Go, Rust, PHP, Swift, Shell, Kotlin
diff --git a/lib/codeqa/metrics/heaps.ex b/lib/codeqa/metrics/file/heaps.ex
similarity index 84%
rename from lib/codeqa/metrics/heaps.ex
rename to lib/codeqa/metrics/file/heaps.ex
index edc390b..b7cae9c 100644
--- a/lib/codeqa/metrics/heaps.ex
+++ b/lib/codeqa/metrics/file/heaps.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.Heaps do
+defmodule CodeQA.Metrics.File.Heaps do
   @moduledoc """
   Fits Heaps' law to vocabulary growth in a file.
 
@@ -9,25 +9,27 @@ defmodule CodeQA.Metrics.Heaps do
   See [Heaps' law](https://en.wikipedia.org/wiki/Heaps%27_law).
   """
 
-  @behaviour CodeQA.Metrics.FileMetric
+  @behaviour CodeQA.Metrics.File.FileMetric
 
   @impl true
   def name, do: "heaps"
 
+  @impl true
+  def keys, do: ["k", "beta", "r_squared"]
+
   @max_samples 50
 
   @spec analyze(map()) :: map()
   @impl true
-  def analyze(%{tokens: tokens}) when tuple_size(tokens) == 0 do
+  def analyze(%{tokens: []}) do
     %{"k" => 0.0, "beta" => 0.0, "r_squared" => 0.0}
   end
 
   def analyze(%{tokens: tokens}) do
-    token_list = Tuple.to_list(tokens)
-    total = length(token_list)
+    total = length(tokens)
     interval = max(1, div(total, @max_samples))
 
-    data_points = sample_vocabulary_growth(token_list, interval)
+    data_points = sample_vocabulary_growth(tokens, interval)
 
     if length(data_points) < 5 do
       %{"k" => 0.0, "beta" => 0.0, "r_squared" => 0.0}
@@ -40,7 +42,7 @@ defmodule CodeQA.Metrics.Heaps do
     tokens
     |> Enum.with_index(1)
     |> Enum.reduce({MapSet.new(), []}, fn {token, i}, {seen, points} ->
-      seen = MapSet.put(seen, token)
+      seen = MapSet.put(seen, token.content)
 
       if rem(i, interval) == 0 do
         {seen, [{i, MapSet.size(seen)} | points]}
diff --git a/lib/codeqa/metrics/identifier_length_variance.ex b/lib/codeqa/metrics/file/identifier_length_variance.ex
similarity index 81%
rename from lib/codeqa/metrics/identifier_length_variance.ex
rename to lib/codeqa/metrics/file/identifier_length_variance.ex
index 2203b10..424b95b 100644
--- a/lib/codeqa/metrics/identifier_length_variance.ex
+++ b/lib/codeqa/metrics/file/identifier_length_variance.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.IdentifierLengthVariance do
+defmodule CodeQA.Metrics.File.IdentifierLengthVariance do
   @moduledoc """
   Measures the mean, variance, and maximum length of identifiers.
 
@@ -11,20 +11,22 @@ defmodule CodeQA.Metrics.IdentifierLengthVariance do
   and [variance](https://en.wikipedia.org/wiki/Variance).
   """
 
-  @behaviour CodeQA.Metrics.FileMetric
+  @behaviour CodeQA.Metrics.File.FileMetric
 
   @impl true
   def name, do: "identifier_length_variance"
 
+  @impl true
+  def keys, do: ["mean", "variance", "std_dev", "max"]
+
   @spec analyze(map()) :: map()
   @impl true
-  def analyze(%{identifiers: identifiers}) when tuple_size(identifiers) == 0 do
+  def analyze(%{identifiers: []}) do
     %{"mean" => 0.0, "variance" => 0.0, "std_dev" => 0.0, "max" => 0}
   end
 
   def analyze(%{identifiers: identifiers}) do
-    list = Tuple.to_list(identifiers)
-    lengths = Enum.map(list, &String.length/1)
+    lengths = Enum.map(identifiers, &String.length/1)
     n = length(lengths)
     mean = Enum.sum(lengths) / n
 
diff --git a/lib/codeqa/metrics/indentation.ex b/lib/codeqa/metrics/file/indentation.ex
similarity index 60%
rename from lib/codeqa/metrics/indentation.ex
rename to lib/codeqa/metrics/file/indentation.ex
index ab44743..75923b9 100644
--- a/lib/codeqa/metrics/indentation.ex
+++ b/lib/codeqa/metrics/file/indentation.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.Indentation do
+defmodule CodeQA.Metrics.File.Indentation do
   @moduledoc """
   Analyzes indentation depth patterns across non-blank lines.
 
@@ -10,20 +10,27 @@ defmodule CodeQA.Metrics.Indentation do
   See [indentation style](https://en.wikipedia.org/wiki/Indentation_style).
   """
 
-  @behaviour CodeQA.Metrics.FileMetric
+  @behaviour CodeQA.Metrics.File.FileMetric
 
   @impl true
   def name, do: "indentation"
 
+  @impl true
+  def keys, do: ["mean_depth", "variance", "max_depth", "uses_tabs", "blank_line_ratio"]
+
   @spec analyze(map()) :: map()
   @impl true
   def analyze(%{lines: lines}) do
-    lines_list = Tuple.to_list(lines)
+    uses_tabs = Enum.any?(lines, &String.match?(&1, ~r/^\t/))
+
+    total_lines = length(lines)
+    blank_count = Enum.count(lines, &(String.trim(&1) == ""))
 
-    uses_tabs = Enum.any?(lines_list, &String.match?(&1, ~r/^\t/))
+    blank_line_ratio =
+      if total_lines > 0, do: Float.round(blank_count / total_lines, 4), else: 0.0
 
     depths =
-      lines_list
+      lines
       |> Enum.reject(&(String.trim(&1) == ""))
       |> Enum.map(fn line ->
         [leading] = Regex.run(~r/^\s*/, line)
@@ -31,7 +38,13 @@ defmodule CodeQA.Metrics.Indentation do
       end)
 
     if depths == [] do
-      %{"mean_depth" => 0.0, "max_depth" => 0, "variance" => 0.0, "uses_tabs" => uses_tabs}
+      %{
+        "mean_depth" => 0.0,
+        "max_depth" => 0,
+        "variance" => 0.0,
+        "uses_tabs" => uses_tabs,
+        "blank_line_ratio" => blank_line_ratio
+      }
     else
       n = length(depths)
       mean = Enum.sum(depths) / n
@@ -45,7 +58,8 @@ defmodule CodeQA.Metrics.Indentation do
         "mean_depth" => Float.round(mean, 4),
         "variance" => Float.round(variance, 4),
         "max_depth" => Enum.max(depths),
-        "uses_tabs" => uses_tabs
+        "uses_tabs" => uses_tabs,
+        "blank_line_ratio" => blank_line_ratio
       }
     end
   end
diff --git a/lib/codeqa/metrics/inflector.ex b/lib/codeqa/metrics/file/inflector.ex
similarity index 89%
rename from lib/codeqa/metrics/inflector.ex
rename to lib/codeqa/metrics/file/inflector.ex
index 7c49531..04e732c 100644
--- a/lib/codeqa/metrics/inflector.ex
+++ b/lib/codeqa/metrics/file/inflector.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.Inflector do
+defmodule CodeQA.Metrics.File.Inflector do
   @moduledoc """
   Utility for detecting identifier casing styles.
 
@@ -30,7 +30,8 @@ defmodule CodeQA.Metrics.Inflector do
       iex> CodeQA.Metrics.Inflector.detect_casing("FOO_BAR")
       :macro_case
   """
-  @spec detect_casing(String.t()) :: :pascal_case | :camel_case | :snake_case | :macro_case | :kebab_case | :other
+  @spec detect_casing(String.t()) ::
+          :pascal_case | :camel_case | :snake_case | :macro_case | :kebab_case | :other
   def detect_casing(identifier) do
     cond do
       identifier =~ ~r/^[A-Z][a-zA-Z0-9]*$/ -> :pascal_case
diff --git a/lib/codeqa/metrics/magic_number_density.ex b/lib/codeqa/metrics/file/magic_number_density.ex
similarity index 51%
rename from lib/codeqa/metrics/magic_number_density.ex
rename to lib/codeqa/metrics/file/magic_number_density.ex
index 3e28bb4..20428df 100644
--- a/lib/codeqa/metrics/magic_number_density.ex
+++ b/lib/codeqa/metrics/file/magic_number_density.ex
@@ -1,10 +1,10 @@
-defmodule CodeQA.Metrics.MagicNumberDensity do
+defmodule CodeQA.Metrics.File.MagicNumberDensity do
   @moduledoc """
-  Measures the density of magic numbers in source code.
+  Measures the density of magic numbers and string literals in source code.
 
-  Counts numeric literals (excluding common constants 0, 1, 0.0, 1.0) as a
-  proportion of total tokens. A high density suggests unexplained constants
-  that should be extracted into named values.
+  Counts numeric literals (excluding common constants 0, 1, 0.0, 1.0) and
+  double-quoted string literals as proportions of total tokens. High densities
+  suggest unexplained constants or hardcoded values that should be extracted.
 
   Note: negative numbers (e.g. `-42`) are not detected since the minus sign
   is a separate token.
@@ -12,22 +12,25 @@ defmodule CodeQA.Metrics.MagicNumberDensity do
   See [magic number](<https://en.wikipedia.org/wiki/Magic_number_(programming)>).
   """
 
-  @behaviour CodeQA.Metrics.FileMetric
+  @behaviour CodeQA.Metrics.File.FileMetric
 
   @impl true
   def name, do: "magic_number_density"
 
+  @impl true
+  def keys, do: ["density", "magic_number_count", "string_literal_ratio"]
+
   @number_re ~r/\b\d+\.?\d*(?:[eE][+-]?\d+)?\b/
   @idiomatic_constants ~w[0 1 2 0.0 1.0 0.5]
+  @string_literal_re ~r/"(?:[^"\\]|\\.)*"/
 
   @spec analyze(map()) :: map()
   @impl true
   def analyze(%{content: content, tokens: tokens}) do
-    token_list = Tuple.to_list(tokens)
-    total_tokens = length(token_list)
+    total_tokens = length(tokens)
 
     if total_tokens == 0 do
-      %{"density" => 0.0, "magic_number_count" => 0}
+      %{"density" => 0.0, "magic_number_count" => 0, "string_literal_ratio" => 0.0}
     else
       numbers =
         @number_re
@@ -36,10 +39,12 @@ defmodule CodeQA.Metrics.MagicNumberDensity do
         |> Enum.reject(&(&1 in @idiomatic_constants))
 
       magic_count = length(numbers)
+      string_count = @string_literal_re |> Regex.scan(content) |> length()
 
       %{
         "density" => Float.round(magic_count / total_tokens, 4),
-        "magic_number_count" => magic_count
+        "magic_number_count" => magic_count,
+        "string_literal_ratio" => Float.round(string_count / total_tokens, 4)
       }
     end
   end
diff --git a/lib/codeqa/metrics/ngram.ex b/lib/codeqa/metrics/file/ngram.ex
similarity index 71%
rename from lib/codeqa/metrics/ngram.ex
rename to lib/codeqa/metrics/file/ngram.ex
index fb2b44b..b100513 100644
--- a/lib/codeqa/metrics/ngram.ex
+++ b/lib/codeqa/metrics/file/ngram.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.Ngram do
+defmodule CodeQA.Metrics.File.Ngram do
   @moduledoc """
   Computes bigram and trigram statistics over the token stream.
 
@@ -10,15 +10,30 @@ defmodule CodeQA.Metrics.Ngram do
   and [hapax legomenon](https://en.wikipedia.org/wiki/Hapax_legomenon).
   """
 
-  @behaviour CodeQA.Metrics.FileMetric
+  @behaviour CodeQA.Metrics.File.FileMetric
 
   @impl true
   def name, do: "ngram"
 
+  @impl true
+  def keys,
+    do: [
+      "bigram_total",
+      "bigram_unique",
+      "bigram_repetition_rate",
+      "bigram_hapax_fraction",
+      "bigram_repeated_unique",
+      "trigram_total",
+      "trigram_unique",
+      "trigram_repetition_rate",
+      "trigram_hapax_fraction",
+      "trigram_repeated_unique"
+    ]
+
   @spec analyze(map()) :: map()
   @impl true
   def analyze(ctx) do
-    tokens = Tuple.to_list(ctx.tokens)
+    tokens = Enum.map(ctx.tokens, & &1.content)
 
     bigram_stats = ngram_stats(tokens, 2) |> rename_keys("bigram")
     trigram_stats = ngram_stats(tokens, 3) |> rename_keys("trigram")
@@ -27,7 +42,13 @@ defmodule CodeQA.Metrics.Ngram do
   end
 
   defp ngram_stats(tokens, n) when length(tokens) < n do
-    %{"total" => 0, "unique" => 0, "repetition_rate" => 0.0, "hapax_fraction" => 0.0, "repeated_unique" => 0}
+    %{
+      "total" => 0,
+      "unique" => 0,
+      "repetition_rate" => 0.0,
+      "hapax_fraction" => 0.0,
+      "repeated_unique" => 0
+    }
   end
 
   defp ngram_stats(tokens, n) do
diff --git a/lib/codeqa/metrics/file/punctuation_density.ex b/lib/codeqa/metrics/file/punctuation_density.ex
new file mode 100644
index 0000000..8b42ee4
--- /dev/null
+++ b/lib/codeqa/metrics/file/punctuation_density.ex
@@ -0,0 +1,96 @@
+defmodule CodeQA.Metrics.File.PunctuationDensity do
+  @moduledoc """
+  Character-level punctuation and structural pattern metrics.
+
+  Captures signals that character-level metrics miss: naming conventions using
+  `?`/`!` suffixes, chained method calls (dots), non-standard bracket adjacency,
+  and numeric bracket pair patterns.
+  """
+
+  @behaviour CodeQA.Metrics.File.FileMetric
+
+  @impl true
+  def name, do: "punctuation_density"
+
+  @impl true
+  def keys do
+    [
+      "question_mark_density",
+      "exclamation_density",
+      "dot_count",
+      "id_nonalpha_suffix_density",
+      "bracket_nonalpha_prefix_count",
+      "bracket_nonalpha_suffix_count",
+      "bracket_number_pair_count",
+      "arrow_density",
+      "colon_suffix_density"
+    ]
+  end
+
+  # identifier-like token (starts with letter/underscore) ending with non-alphanumeric non-whitespace
+  @id_nonalpha_suffix ~r/[a-zA-Z_]\w*[^\w\s]/
+  # opening bracket immediately preceded by non-alphanumeric non-whitespace (e.g. `?(`, `==[`)
+  @bracket_nonalpha_prefix ~r/[^\w\s\(\[\{][\(\[\{]/
+  # closing bracket immediately followed by non-alphanumeric non-whitespace (e.g. `}.`, `)?`)
+  @bracket_nonalpha_suffix ~r/[\)\]\}][^\w\s\)\]\}]/
+  # number (with optional underscores) wrapped in brackets: (42), [1_000], (3.14)
+  @bracket_number_pair ~r/[\(\[]\d[\d_]*(?:\.\d+)?[\)\]]/
+  # arrow operators: -> and =>
+  @arrow ~r/->|=>/
+  # identifier immediately followed by colon (keyword args, dict keys, labels)
+  @colon_suffix ~r/[a-zA-Z_]\w*:/
+
+  @spec analyze(map()) :: map()
+  @impl true
+  def analyze(%{content: content, tokens: tokens}) do
+    total_chars = String.length(content)
+    total_tokens = length(tokens)
+
+    if total_chars == 0 do
+      %{
+        "question_mark_density" => 0.0,
+        "exclamation_density" => 0.0,
+        "dot_count" => 0,
+        "id_nonalpha_suffix_density" => 0.0,
+        "bracket_nonalpha_prefix_count" => 0,
+        "bracket_nonalpha_suffix_count" => 0,
+        "bracket_number_pair_count" => 0,
+        "arrow_density" => 0.0,
+        "colon_suffix_density" => 0.0
+      }
+    else
+      qmarks = count_char(content, "?")
+      excls = count_char(content, "!")
+      dots = count_char(content, ".")
+
+      id_suffix_count = count_matches(content, @id_nonalpha_suffix)
+      bracket_prefix = count_matches(content, @bracket_nonalpha_prefix)
+      bracket_suffix = count_matches(content, @bracket_nonalpha_suffix)
+      bracket_num = count_matches(content, @bracket_number_pair)
+
+      id_denom = max(total_tokens, 1)
+      arrows = count_matches(content, @arrow)
+      colon_suffixes = count_matches(content, @colon_suffix)
+
+      %{
+        "question_mark_density" => Float.round(qmarks / total_chars, 6),
+        "exclamation_density" => Float.round(excls / total_chars, 6),
+        "dot_count" => dots,
+        "id_nonalpha_suffix_density" => Float.round(id_suffix_count / id_denom, 4),
+        "bracket_nonalpha_prefix_count" => bracket_prefix,
+        "bracket_nonalpha_suffix_count" => bracket_suffix,
+        "bracket_number_pair_count" => bracket_num,
+        "arrow_density" => Float.round(arrows / id_denom, 4),
+        "colon_suffix_density" => Float.round(colon_suffixes / id_denom, 4)
+      }
+    end
+  end
+
+  defp count_char(content, char) do
+    content |> String.graphemes() |> Enum.count(&(&1 == char))
+  end
+
+  defp count_matches(content, regex) do
+    regex |> Regex.scan(content) |> length()
+  end
+end
diff --git a/lib/codeqa/metrics/readability.ex b/lib/codeqa/metrics/file/readability.ex
similarity index 89%
rename from lib/codeqa/metrics/readability.ex
rename to lib/codeqa/metrics/file/readability.ex
index 5ffa9e1..3e1bd2c 100644
--- a/lib/codeqa/metrics/readability.ex
+++ b/lib/codeqa/metrics/file/readability.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.Readability do
+defmodule CodeQA.Metrics.File.Readability do
   @moduledoc """
   Computes adapted Flesch and Fog readability indices for source code.
 
@@ -10,17 +10,27 @@ defmodule CodeQA.Metrics.Readability do
   and [Gunning fog index](https://en.wikipedia.org/wiki/Gunning_fog_index).
   """
 
-  @behaviour CodeQA.Metrics.FileMetric
+  @behaviour CodeQA.Metrics.File.FileMetric
 
   @impl true
   def name, do: "readability"
 
+  @impl true
+  def keys,
+    do: [
+      "avg_tokens_per_line",
+      "avg_line_length",
+      "avg_sub_words_per_id",
+      "flesch_adapted",
+      "fog_adapted",
+      "total_lines"
+    ]
+
   @spec analyze(map()) :: map()
   @impl true
   def analyze(ctx) do
     lines =
       ctx.lines
-      |> Tuple.to_list()
       |> Enum.filter(fn line ->
         trimmed = String.trim(line)
         trimmed != "" and not String.starts_with?(trimmed, "#")
@@ -42,11 +52,11 @@ defmodule CodeQA.Metrics.Readability do
 
   defp compute_readability(ctx, lines) do
     total_lines = length(lines)
-    total_tokens = tuple_size(ctx.tokens)
+    total_tokens = length(ctx.tokens)
     avg_tokens = total_tokens / total_lines
     avg_line_length = lines |> Enum.map(&String.length/1) |> Enum.sum() |> Kernel./(total_lines)
 
-    words = Tuple.to_list(ctx.words)
+    words = ctx.words
 
     {avg_sub_words, complex_fraction} =
       if words != [] do
diff --git a/lib/codeqa/metrics/file/rfc.ex b/lib/codeqa/metrics/file/rfc.ex
new file mode 100644
index 0000000..5416c68
--- /dev/null
+++ b/lib/codeqa/metrics/file/rfc.ex
@@ -0,0 +1,81 @@
+defmodule CodeQA.Metrics.File.RFC do
+  @moduledoc """
+  Response For a Class (RFC) — a coupling metric from the Chidamber & Kemerer suite.
+
+  RFC ≈ number of distinct methods/functions reachable from this file, counting
+  both locally-defined functions and distinct external call targets.
+
+  Formula: `RFC = function_def_count + |distinct_call_targets|`
+
+  Computed from the token stream without requiring a real AST:
+  - Function definitions are detected by function-keyword tokens (`def`, `fn`, etc.)
+    followed by an `<ID>` token.
+  - Call targets are detected by `<ID>` tokens immediately followed by `(`.
+    Duplicates are collapsed to a set.
+
+  Higher RFC values indicate a module with more responsibility and more external
+  coupling, correlating empirically with higher fault density.
+
+  See [CK metrics suite](https://en.wikipedia.org/wiki/Programming_complexity#Chidamber_and_Kemerer_metrics).
+  """
+
+  @behaviour CodeQA.Metrics.File.FileMetric
+
+  @func_keywords MapSet.new(~w[
+    def defp defmacro defmacrop defguard defdelegate
+    function func fun fn
+    sub proc method
+  ])
+
+  @impl true
+  def name, do: "rfc"
+
+  @impl true
+  def keys, do: ["rfc_count", "rfc_density", "function_def_count", "distinct_call_count"]
+
+  @impl true
+  def description,
+    do: "Response For a Class: function definitions + distinct call targets (CK suite)"
+
+  @spec analyze(CodeQA.Engine.FileContext.t()) :: map()
+  @impl true
+  def analyze(%{tokens: tokens, line_count: line_count}) do
+    {func_def_count, call_targets} = scan_tokens(tokens)
+
+    distinct_call_count = MapSet.size(call_targets)
+    rfc_count = func_def_count + distinct_call_count
+
+    density =
+      if line_count > 0,
+        do: Float.round(rfc_count / line_count, 4),
+        else: 0.0
+
+    %{
+      "rfc_count" => rfc_count,
+      "rfc_density" => density,
+      "function_def_count" => func_def_count,
+      "distinct_call_count" => distinct_call_count
+    }
+  end
+
+  # Single pass: detect function definitions and call sites simultaneously.
+  # Uses a sliding window of two adjacent tokens.
+  defp scan_tokens(tokens) do
+    tokens
+    |> Enum.zip(Enum.drop(tokens, 1))
+    |> Enum.reduce({0, MapSet.new()}, fn {tok, next}, {defs, calls} ->
+      cond do
+        # Function definition: keyword followed by an identifier
+        MapSet.member?(@func_keywords, tok.content) and next.kind == "<ID>" ->
+          {defs + 1, calls}
+
+        # Call site: identifier followed by open paren
+        tok.kind == "<ID>" and next.content == "(" ->
+          {defs, MapSet.put(calls, tok.content)}
+
+        true ->
+          {defs, calls}
+      end
+    end)
+  end
+end
diff --git a/lib/codeqa/metrics/symbol_density.ex b/lib/codeqa/metrics/file/symbol_density.ex
similarity index 85%
rename from lib/codeqa/metrics/symbol_density.ex
rename to lib/codeqa/metrics/file/symbol_density.ex
index 67459a0..3e71bf3 100644
--- a/lib/codeqa/metrics/symbol_density.ex
+++ b/lib/codeqa/metrics/file/symbol_density.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.SymbolDensity do
+defmodule CodeQA.Metrics.File.SymbolDensity do
   @moduledoc """
   Measures the density of non-word, non-whitespace symbols in source code.
 
@@ -9,11 +9,14 @@ defmodule CodeQA.Metrics.SymbolDensity do
   See [code readability](https://en.wikipedia.org/wiki/Computer_programming#Readability_of_source_code).
   """
 
-  @behaviour CodeQA.Metrics.FileMetric
+  @behaviour CodeQA.Metrics.File.FileMetric
 
   @impl true
   def name, do: "symbol_density"
 
+  @impl true
+  def keys, do: ["density", "symbol_count", "distinct_symbol_types"]
+
   @spec analyze(map()) :: map()
   @impl true
   def analyze(%{content: content}) do
diff --git a/lib/codeqa/metrics/vocabulary.ex b/lib/codeqa/metrics/file/vocabulary.ex
similarity index 91%
rename from lib/codeqa/metrics/vocabulary.ex
rename to lib/codeqa/metrics/file/vocabulary.ex
index d9ef637..496cc68 100644
--- a/lib/codeqa/metrics/vocabulary.ex
+++ b/lib/codeqa/metrics/file/vocabulary.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.Vocabulary do
+defmodule CodeQA.Metrics.File.Vocabulary do
   @moduledoc """
   Analyzes vocabulary diversity using type-token ratio (TTR) and MATTR.
 
@@ -14,19 +14,22 @@ defmodule CodeQA.Metrics.Vocabulary do
   and [MATTR](https://doi.org/10.3758/BRM.42.2.381).
   """
 
-  @behaviour CodeQA.Metrics.FileMetric
+  @behaviour CodeQA.Metrics.File.FileMetric
 
   @impl true
   def name, do: "vocabulary"
 
+  @impl true
+  def keys, do: ["raw_ttr", "mattr", "unique_identifiers", "total_identifiers", "vocabulary"]
+
   @window_size 100
 
   @spec analyze(map()) :: map()
   @impl true
   def analyze(ctx) do
-    identifiers = Tuple.to_list(ctx.identifiers)
+    identifiers = ctx.identifiers
     total = length(identifiers)
-    vocabulary = ctx.words |> Tuple.to_list() |> Enum.uniq() |> Enum.sort()
+    vocabulary = ctx.words |> Enum.uniq() |> Enum.sort()
 
     if total == 0 do
       %{
diff --git a/lib/codeqa/metrics/vowel_density.ex b/lib/codeqa/metrics/file/vowel_density.ex
similarity index 86%
rename from lib/codeqa/metrics/vowel_density.ex
rename to lib/codeqa/metrics/file/vowel_density.ex
index 84ea39e..f3f53de 100644
--- a/lib/codeqa/metrics/vowel_density.ex
+++ b/lib/codeqa/metrics/file/vowel_density.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.VowelDensity do
+defmodule CodeQA.Metrics.File.VowelDensity do
   @moduledoc """
   Measures the density of vowels in identifiers.
 
@@ -9,17 +9,20 @@ defmodule CodeQA.Metrics.VowelDensity do
   See [identifier naming](https://en.wikipedia.org/wiki/Identifier_(computer_languages)).
   """
 
-  @behaviour CodeQA.Metrics.FileMetric
+  @behaviour CodeQA.Metrics.File.FileMetric
 
   @vowels MapSet.new(~c"aeiouyAEIOUY")
 
   @impl true
   def name, do: "vowel_density"
 
+  @impl true
+  def keys, do: ["density", "vowel_count", "total_chars"]
+
   @spec analyze(map()) :: map()
   @impl true
   def analyze(%{identifiers: identifiers}) do
-    list = Tuple.to_list(identifiers)
+    list = identifiers
 
     if list == [] do
       %{"density" => 0.0, "vowel_count" => 0, "total_chars" => 0}
diff --git a/lib/codeqa/metrics/winnowing.ex b/lib/codeqa/metrics/file/winnowing.ex
similarity index 96%
rename from lib/codeqa/metrics/winnowing.ex
rename to lib/codeqa/metrics/file/winnowing.ex
index 9c8961c..d725a38 100644
--- a/lib/codeqa/metrics/winnowing.ex
+++ b/lib/codeqa/metrics/file/winnowing.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.Winnowing do
+defmodule CodeQA.Metrics.File.Winnowing do
   @moduledoc """
   Generates structural fingerprints using k-grams.
 
diff --git a/lib/codeqa/metrics/zipf.ex b/lib/codeqa/metrics/file/zipf.ex
similarity index 86%
rename from lib/codeqa/metrics/zipf.ex
rename to lib/codeqa/metrics/file/zipf.ex
index 4948c3d..b03a07c 100644
--- a/lib/codeqa/metrics/zipf.ex
+++ b/lib/codeqa/metrics/file/zipf.ex
@@ -1,4 +1,4 @@
-defmodule CodeQA.Metrics.Zipf do
+defmodule CodeQA.Metrics.File.Zipf do
   @moduledoc """
   Fits Zipf's law to the token frequency distribution.
 
@@ -9,21 +9,24 @@ defmodule CodeQA.Metrics.Zipf do
   See [Zipf's law](https://en.wikipedia.org/wiki/Zipf%27s_law).
   """
 
-  @behaviour CodeQA.Metrics.FileMetric
+  @behaviour CodeQA.Metrics.File.FileMetric
 
   @impl true
   def name, do: "zipf"
 
+  @impl true
+  def keys, do: ["exponent", "r_squared", "vocab_size", "total_tokens"]
+
   @spec analyze(map()) :: map()
   @impl true
-  def analyze(%{tokens: tokens, token_counts: _token_counts}) when tuple_size(tokens) == 0 do
+  def analyze(%{tokens: [], token_counts: _token_counts}) do
     %{"exponent" => 0.0, "r_squared" => 0.0, "vocab_size" => 0, "total_tokens" => 0}
   end
 
   def analyze(%{tokens: tokens, token_counts: token_counts}) do
     frequencies = token_counts |> Map.values() |> Enum.sort(:desc)
     vocab_size = length(frequencies)
-    total_tokens = tuple_size(tokens)
+    total_tokens = length(tokens)
 
     if vocab_size < 3 do
       %{
diff --git a/lib/codeqa/metrics/post_processing/menzerath.ex b/lib/codeqa/metrics/post_processing/menzerath.ex
new file mode 100644
index 0000000..2d9bd32
--- /dev/null
+++ b/lib/codeqa/metrics/post_processing/menzerath.ex
@@ -0,0 +1,278 @@
+defmodule CodeQA.Metrics.PostProcessing.Menzerath do
+  @moduledoc """
+  Measures structural hierarchy conformance using Menzerath's law.
+
+  ## Block-level score
+
+  For each parsed block in a file, computes:
+
+      ratio = block.line_count / parent.line_count
+
+  Root blocks use the file's line count as parent. Ratio close to 1.0 means the block
+  dominates its parent (poor decomposition). Low ratio means the block is small relative
+  to its parent (good decomposition).
+
+  For internal nodes that have children, also computes `avg_child_ratio` — the mean ratio
+  of direct children. High `avg_child_ratio` means this node failed to decompose its
+  children into small enough pieces.
+
+  ## Codebase-level score
+
+  Collects `{function_count, avg_function_lines}` pairs from all files and computes:
+  - Pearson correlation (negative = law holds across the codebase)
+  - Power-law exponent `b` from `y = a · x^b` fit on log-log scale
+  - R² of the fit
+  """
+
+  @behaviour CodeQA.Metrics.PostProcessing.PostProcessingMetric
+
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.Languages.Unknown
+
+  @violation_threshold 0.6
+
+  @impl true
+  def name, do: "menzerath"
+
+  @impl true
+  def analyze(pipeline_result, files_map, _opts) do
+    file_scores =
+      Map.new(files_map, fn {path, content} ->
+        {path, %{"menzerath" => score_file(content)}}
+      end)
+
+    codebase_score = compute_codebase_score(pipeline_result)
+
+    %{
+      "files" => file_scores,
+      "codebase" => %{"menzerath" => codebase_score}
+    }
+  end
+
+  # --- file-level scoring ---
+
+  defp score_file("") do
+    %{
+      "blocks" => [],
+      "mean_ratio" => 0.0,
+      "max_ratio" => 0.0,
+      "violation_count" => 0,
+      "insight" => "Empty file."
+    }
+  end
+
+  defp score_file(content) do
+    file_lines = content |> String.split("\n") |> length()
+    root_tokens = TokenNormalizer.normalize_structural(content)
+    top_nodes = Parser.detect_blocks(root_tokens, Unknown)
+
+    blocks = Enum.map(top_nodes, &score_node(&1, file_lines))
+    all_ratios = collect_ratios(blocks)
+    n = length(all_ratios)
+
+    mean_ratio = if(n == 0, do: 0.0, else: round4(Enum.sum(all_ratios) / n))
+    max_ratio = if(n == 0, do: 0.0, else: round4(Enum.max(all_ratios)))
+    violation_count = Enum.count(all_ratios, &(&1 >= @violation_threshold))
+
+    %{
+      "blocks" => blocks,
+      "mean_ratio" => mean_ratio,
+      "max_ratio" => max_ratio,
+      "violation_count" => violation_count,
+      "insight" => file_insight(mean_ratio, max_ratio, violation_count, length(top_nodes))
+    }
+  end
+
+  defp file_insight(_mean, _max, _violations, 0),
+    do: "No blocks detected."
+
+  defp file_insight(_mean, _max, 0, _block_count),
+    do: "Well decomposed — all blocks are small relative to their parents."
+
+  defp file_insight(_mean, max_ratio, violations, _block_count) when max_ratio >= 0.9,
+    do:
+      "#{violations} block(s) nearly span the entire file — the file is not decomposed into meaningful pieces."
+
+  defp file_insight(mean_ratio, _max, violations, _block_count) when mean_ratio >= 0.5,
+    do:
+      "#{violations} violation(s); blocks are large on average (mean ratio #{mean_ratio}) — the file likely needs to be split or its blocks extracted."
+
+  defp file_insight(_mean, _max, violations, _block_count),
+    do:
+      "#{violations} block(s) dominate their parent context — consider extracting those into separate functions or modules."
+
+  defp score_node(node, parent_lines) do
+    ratio = if parent_lines > 0, do: round4(node.line_count / parent_lines), else: 0.0
+
+    children = Enum.map(node.children, &score_node(&1, node.line_count))
+
+    base = %{
+      "start_line" => node.start_line,
+      "end_line" => node.end_line,
+      "line_count" => node.line_count,
+      "parent_lines" => parent_lines,
+      "ratio" => ratio,
+      "insight" => block_insight(ratio, []),
+      "children" => children
+    }
+
+    case children do
+      [] ->
+        base
+
+      kids ->
+        child_ratios = Enum.map(kids, & &1["ratio"])
+        avg = round4(Enum.sum(child_ratios) / length(child_ratios))
+
+        base
+        |> Map.put("avg_child_ratio", avg)
+        |> Map.put("insight", block_insight(ratio, avg_child_ratio: avg))
+    end
+  end
+
+  defp block_insight(ratio, opts) do
+    avg_child_ratio = Keyword.get(opts, :avg_child_ratio)
+
+    cond do
+      ratio >= 0.9 ->
+        "Block spans nearly the entire parent — no meaningful decomposition at this level."
+
+      (ratio >= @violation_threshold and avg_child_ratio) &&
+          avg_child_ratio >= @violation_threshold ->
+        "Block is large relative to its parent and its own children are also large — nested decomposition failure."
+
+      ratio >= @violation_threshold ->
+        "Block is large relative to its parent — consider splitting or extracting."
+
+      avg_child_ratio && avg_child_ratio >= @violation_threshold ->
+        "Block is reasonably sized but its children are too large — this block should be broken down further."
+
+      true ->
+        nil
+    end
+  end
+
+  defp collect_ratios(blocks) do
+    Enum.flat_map(blocks, fn block ->
+      [block["ratio"] | collect_ratios(block["children"])]
+    end)
+  end
+
+  # --- codebase-level scoring ---
+
+  defp compute_codebase_score(pipeline_result) do
+    pairs =
+      pipeline_result
+      |> Map.get("files", %{})
+      |> Enum.flat_map(fn {_path, file_data} ->
+        fm = get_in(file_data, ["metrics", "function_metrics"]) || %{}
+        count = fm["function_count"]
+        avg = fm["avg_function_lines"]
+
+        if is_number(count) and is_number(avg) and count > 0 do
+          [{count * 1.0, avg * 1.0}]
+        else
+          []
+        end
+      end)
+
+    n = length(pairs)
+
+    if n < 3 do
+      %{
+        "correlation" => nil,
+        "exponent" => nil,
+        "r_squared" => nil,
+        "sample_size" => n,
+        "insight" =>
+          "Not enough files with function data to compute Menzerath conformance (need ≥ 3, got #{n})."
+      }
+    else
+      xs = Enum.map(pairs, &elem(&1, 0))
+      ys = Enum.map(pairs, &elem(&1, 1))
+      correlation = round4(pearson(xs, ys))
+      {exponent, r_squared} = fit_power_law(xs, ys)
+
+      %{
+        "correlation" => correlation,
+        "exponent" => if(exponent, do: round4(exponent), else: nil),
+        "r_squared" => if(r_squared, do: round4(r_squared), else: nil),
+        "sample_size" => n,
+        "insight" => codebase_insight(correlation, r_squared)
+      }
+    end
+  end
+
+  defp codebase_insight(correlation, r_squared) do
+    fit_quality = if r_squared && r_squared >= 0.5, do: " (strong fit, R²=#{r_squared})", else: ""
+
+    cond do
+      correlation <= -0.3 ->
+        "Menzerath's law holds#{fit_quality} — larger files tend to have shorter functions, indicating healthy decomposition."
+
+      correlation >= 0.3 ->
+        "Menzerath's law violated#{fit_quality} — larger files have longer functions. Files are growing without being decomposed; consider splitting large files or extracting functions."
+
+      true ->
+        "Weak Menzerath signal (correlation #{correlation}) — no clear relationship between file size and function length. Decomposition patterns are inconsistent across the codebase."
+    end
+  end
+
+  defp pearson(xs, ys) do
+    n = length(xs)
+    sum_x = Enum.sum(xs)
+    sum_y = Enum.sum(ys)
+    sum_xy = Enum.zip(xs, ys) |> Enum.reduce(0.0, fn {x, y}, acc -> acc + x * y end)
+    sum_x2 = Enum.reduce(xs, 0.0, fn x, acc -> acc + x * x end)
+    sum_y2 = Enum.reduce(ys, 0.0, fn y, acc -> acc + y * y end)
+
+    num = n * sum_xy - sum_x * sum_y
+    den = :math.sqrt((n * sum_x2 - sum_x * sum_x) * (n * sum_y2 - sum_y * sum_y))
+
+    if den == 0.0, do: 0.0, else: num / den
+  end
+
+  defp fit_power_law(xs, ys) do
+    # Linearize: log(y) = log(a) + b * log(x), fit via OLS on log-log scale
+    pairs =
+      Enum.zip(xs, ys)
+      |> Enum.filter(fn {x, y} -> x > 0 and y > 0 end)
+
+    if length(pairs) < 2 do
+      {nil, nil}
+    else
+      log_xs = Enum.map(pairs, fn {x, _} -> :math.log(x) end)
+      log_ys = Enum.map(pairs, fn {_, y} -> :math.log(y) end)
+
+      n = length(pairs)
+      sum_lx = Enum.sum(log_xs)
+      sum_ly = Enum.sum(log_ys)
+      sum_lx2 = Enum.reduce(log_xs, 0.0, fn x, acc -> acc + x * x end)
+      sum_lxly = Enum.zip(log_xs, log_ys) |> Enum.reduce(0.0, fn {x, y}, acc -> acc + x * y end)
+
+      denom = n * sum_lx2 - sum_lx * sum_lx
+
+      if denom == 0.0 do
+        {nil, nil}
+      else
+        b = (n * sum_lxly - sum_lx * sum_ly) / denom
+        log_a = (sum_ly - b * sum_lx) / n
+        mean_ly = sum_ly / n
+
+        ss_tot = Enum.reduce(log_ys, 0.0, fn ly, acc -> acc + (ly - mean_ly) ** 2 end)
+
+        ss_res =
+          Enum.zip(log_xs, log_ys)
+          |> Enum.reduce(0.0, fn {lx, ly}, acc ->
+            acc + (ly - (log_a + b * lx)) ** 2
+          end)
+
+        r_squared = if ss_tot == 0.0, do: 0.0, else: 1.0 - ss_res / ss_tot
+        {b, r_squared}
+      end
+    end
+  end
+
+  defp round4(v), do: Float.round(v * 1.0, 4)
+end
diff --git a/lib/codeqa/metrics/post_processing/post_processing_metric.ex b/lib/codeqa/metrics/post_processing/post_processing_metric.ex
new file mode 100644
index 0000000..c4b7bc0
--- /dev/null
+++ b/lib/codeqa/metrics/post_processing/post_processing_metric.ex
@@ -0,0 +1,21 @@
+defmodule CodeQA.Metrics.PostProcessing.PostProcessingMetric do
+  @moduledoc """
+  Behaviour for post-processing metrics that derive values from the full pipeline result.
+
+  Post-processing metrics run after both file and codebase metrics complete. They receive
+  the full result tree and the raw files map, and return a partial result map that is
+  deep-merged into the pipeline result.
+  """
+
+  @doc "Unique name used as the key in the output."
+  @callback name() :: String.t()
+
+  @doc """
+  Analyze the pipeline result and return a partial result map to be deep-merged.
+
+  The returned map should use the same top-level structure as the pipeline result:
+  `%{"files" => %{path => additions}, "codebase" => additions}`.
+  Only keys present in the return value are merged; absent keys are left unchanged.
+  """
+  @callback analyze(pipeline_result :: map(), files_map :: map(), opts :: keyword()) :: map()
+end
diff --git a/lib/codeqa/metrics/token_normalizer.ex b/lib/codeqa/metrics/token_normalizer.ex
deleted file mode 100644
index 6967e6a..0000000
--- a/lib/codeqa/metrics/token_normalizer.ex
+++ /dev/null
@@ -1,45 +0,0 @@
-defmodule CodeQA.Metrics.TokenNormalizer do
-  @moduledoc """
-  Abstracts raw source code into language-agnostic structural tokens.
-
-  See [lexical analysis](https://en.wikipedia.org/wiki/Lexical_analysis).
-  """
-
-  # Note for future: This module can be extended with a second parameter
-  # normalize(code, language \\ :agnostic) to load specific regex dictionaries.
-
-  @doc """
-  Normalizes source code into a list of structural tokens.
-
-  Replaces string literals with `<STR>`, numeric literals with `<NUM>`,
-  and identifiers/keywords with `<ID>`. Remaining punctuation is split into
-  individual tokens, with common multi-character operators kept together.
-
-  ## Examples
-
-      iex> CodeQA.Metrics.TokenNormalizer.normalize("x = 42")
-      ["<ID>", "=", "<NUM>"]
-
-  """
-  @spec normalize(String.t()) :: [String.t()]
-  def normalize(code) do
-    code
-    # 1. Strings (single and double quotes, handling escaped quotes)
-    |> String.replace(~r/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/, " <STR> ")
-    # 2. Numbers (integers and floats)
-    |> String.replace(~r/\b\d+(\.\d+)?\b/, " <NUM> ")
-    # 3. Identifiers/Keywords (negative lookbehind/ahead to avoid clobbering <STR>/<NUM>/<ID> tags)
-    |> String.replace(~r/(?<!<)\b[a-zA-Z_]\w*\b(?!>)/, " <ID> ")
-    # 4. Split by whitespace to extract the tokens and remaining structural punctuation
-    |> String.split(~r/\s+/, trim: true)
-    # 5. Further split punctuation, keeping common multi-char operators together
-    |> Enum.flat_map(&split_punctuation/1)
-  end
-
-  defp split_punctuation(token) when token in ["<STR>", "<NUM>", "<ID>"], do: [token]
-
-  defp split_punctuation(text) do
-    Regex.scan(~r/->|=>|<>|\|>|::|\.\.\.|<-|!=|==|<=|>=|\+\+|--|&&|\|\||[^\w\s]/, text)
-    |> List.flatten()
-  end
-end
diff --git a/lib/codeqa/pipeline.ex b/lib/codeqa/pipeline.ex
deleted file mode 100644
index bcd256c..0000000
--- a/lib/codeqa/pipeline.ex
+++ /dev/null
@@ -1,109 +0,0 @@
-defmodule CodeQA.Pipeline do
-  @moduledoc "Pre-computed shared context for file-level metrics."
-
-  defmodule FileContext do
-    @moduledoc "Immutable pre-computed data shared across all file metrics."
-    @enforce_keys [
-      :content,
-      :tokens,
-      :token_counts,
-      :words,
-      :identifiers,
-      :lines,
-      :encoded,
-      :byte_count,
-      :line_count
-    ]
-    defstruct @enforce_keys
-
-    @type t :: %__MODULE__{
-      content: String.t(),
-      tokens: tuple(),
-      token_counts: map(),
-      words: tuple(),
-      identifiers: tuple(),
-      lines: tuple(),
-      encoded: String.t(),
-      byte_count: non_neg_integer(),
-      line_count: non_neg_integer()
-    }
-  end
-
-  @word_re ~r/\b[a-zA-Z_]\w*\b/u
-
-  # Reserved words and keywords for:
-  # Python, Ruby, JavaScript, Elixir, C#,
-  # Java, C++, Go, Rust, PHP, Swift, Shell, Kotlin
-  @keywords MapSet.new(~w[
-    if else elif elsif unless
-    for foreach while until do
-    return break continue yield pass
-    try except finally rescue ensure after catch throw raise begin end throws
-    case when switch cond match default fallthrough
-    with as and or not in is
-    import from require use using alias namespace package
-    class def defp defmodule defmacro defmacrop defprotocol defimpl defguard defdelegate
-    module interface struct enum delegate event protocol extension
-    function fn func fun new delete typeof instanceof void
-    var let val const static public private protected internal
-    sealed override virtual abstract final readonly open
-    async await receive suspend
-    self super this Self
-    extends implements
-    null undefined nil None nullptr
-    true false True False
-    bool int float double long short byte char boolean string decimal object dynamic
-    ref out params get set value inout
-    lambda del global nonlocal assert
-    type typealias
-    synchronized volatile transient native strictfp
-    auto register extern signed unsigned typedef sizeof union
-    template typename operator inline friend explicit mutable constexpr decltype noexcept
-    func chan go select defer range
-    mut impl trait pub mod crate dyn unsafe loop where move
-    echo print array list mixed never
-    actor init deinit lazy open some any rethrows willSet didSet
-    then fi done esac local export source unset declare
-    fun val object data companion reified infix vararg expect actual
-  ])
-
-  @spec build_file_context(String.t(), keyword()) :: FileContext.t()
-  def build_file_context(content, opts \\ []) when is_binary(content) do
-    stopwords = Keyword.get(opts, :word_stopwords, MapSet.new())
-
-    tokens = content |> String.split() |> List.to_tuple()
-    token_list = Tuple.to_list(tokens)
-    token_counts = Enum.frequencies(token_list)
-
-    words =
-      Regex.scan(@word_re, content)
-      |> List.flatten()
-      |> Enum.reject(&MapSet.member?(stopwords, &1))
-      |> List.to_tuple()
-
-    word_list = Tuple.to_list(words)
-    identifiers = word_list |> Enum.reject(&MapSet.member?(@keywords, &1)) |> List.to_tuple()
-    lines = content |> String.split("\n") |> trim_trailing_empty() |> List.to_tuple()
-    encoded = content
-
-    %FileContext{
-      content: content,
-      tokens: tokens,
-      token_counts: token_counts,
-      words: words,
-      identifiers: identifiers,
-      lines: lines,
-      encoded: encoded,
-      byte_count: byte_size(content),
-      line_count: tuple_size(lines)
-    }
-  end
-
-  defp trim_trailing_empty(lines) do
-    # Match Python's str.splitlines() behavior
-    case List.last(lines) do
-      "" -> List.delete_at(lines, -1)
-      _ -> lines
-    end
-  end
-end
diff --git a/lib/codeqa/stopwords.ex b/lib/codeqa/stopwords.ex
deleted file mode 100644
index bd33374..0000000
--- a/lib/codeqa/stopwords.ex
+++ /dev/null
@@ -1,63 +0,0 @@
-defmodule CodeQA.Stopwords do
-  @moduledoc "Finds highly frequent items across a codebase to act as stopwords."
-
-  @doc """
-  Finds items that appear in more than the specified threshold of files.
-  `extractor` is a function that takes a file's content and returns an Enumerable of items.
-  """
-  def find_stopwords(files, extractor, opts \\ []) do
-    threshold_ratio = Keyword.get(opts, :stopwords_threshold, 0.15)
-    total_docs = map_size(files)
-    min_docs = max(1, round(total_docs * threshold_ratio))
-    workers = Keyword.get(opts, :workers, System.schedulers_online())
-    has_progress = Keyword.get(opts, :progress, false)
-    label = Keyword.get(opts, :progress_label, "")
-
-    counter = :counters.new(1, [:atomics])
-    start_time = System.monotonic_time(:millisecond)
-
-    files
-    |> Task.async_stream(
-      fn {_path, content} ->
-        res =
-          content
-          |> extractor.()
-          |> MapSet.new()
-
-        if has_progress do
-          :counters.add(counter, 1, 1)
-          completed = :counters.get(counter, 1)
-          print_progress(completed, total_docs, start_time, label)
-        end
-
-        res
-      end, max_concurrency: workers, timeout: :infinity)
-    |> Enum.reduce(%{}, fn {:ok, unique_items_in_file}, doc_freqs ->
-      Enum.reduce(unique_items_in_file, doc_freqs, fn item, acc ->
-        Map.update(acc, item, 1, &(&1 + 1))
-      end)
-    end)
-    |> Enum.filter(fn {_item, count} -> count >= min_docs end)
-    |> Enum.map(fn {item, _count} -> item end)
-    |> MapSet.new()
-  end
-
-  defp print_progress(completed, total, start_time, label) do
-    now = System.monotonic_time(:millisecond)
-    elapsed = max(now - start_time, 1)
-    avg_time = elapsed / completed
-    eta_ms = round((total - completed) * avg_time)
-
-    output =
-      CodeQA.CLI.UI.progress_bar(completed, total,
-        eta: CodeQA.CLI.UI.format_eta(eta_ms),
-        label: label
-      )
-
-    IO.write(:stderr, "\r" <> output)
-
-    if completed == total do
-      IO.puts(:stderr, "")
-    end
-  end
-end
diff --git a/lib/codeqa/telemetry.ex b/lib/codeqa/telemetry.ex
deleted file mode 100644
index 3f5d22d..0000000
--- a/lib/codeqa/telemetry.ex
+++ /dev/null
@@ -1,68 +0,0 @@
-defmodule CodeQA.Telemetry do
-  @moduledoc "Simple concurrent telemetry tracker using ETS."
-
-  def setup do
-    if :ets.info(:codeqa_telemetry) == :undefined do
-      :ets.new(:codeqa_telemetry, [:named_table, :public, :set, write_concurrency: true])
-    end
-
-    :ok
-  end
-
-  def time(metric_name, fun) do
-    if :ets.info(:codeqa_telemetry) != :undefined do
-      start_time = System.monotonic_time(:microsecond)
-      result = fun.()
-      end_time = System.monotonic_time(:microsecond)
-      duration = end_time - start_time
-
-      :ets.update_counter(:codeqa_telemetry, metric_name, {2, duration}, {metric_name, 0})
-
-      :ets.update_counter(
-        :codeqa_telemetry,
-        "#{metric_name}_count",
-        {2, 1},
-        {"#{metric_name}_count", 0}
-      )
-
-      result
-    else
-      fun.()
-    end
-  end
-
-  defp format_metric_line({name, total_time_us}) do
-    count =
-      case :ets.lookup(:codeqa_telemetry, "#{name}_count") do
-        [{_, c}] -> c
-        _ -> 1
-      end
-
-    total_ms = Float.round(total_time_us / 1000, 2)
-    avg_ms = Float.round(total_ms / count, 2)
-
-    String.pad_trailing(to_string(name), 30) <>
-      " | Total: #{String.pad_trailing(to_string(total_ms) <> "ms", 12)}" <>
-      " | Count: #{String.pad_trailing(to_string(count), 6)}" <>
-      " | Avg: #{avg_ms}ms"
-  end
-
-  def print_report do
-    if :ets.info(:codeqa_telemetry) != :undefined do
-      IO.puts(:stderr, "
---- Telemetry Report (Wall-clock times) ---")
-      metrics = :ets.tab2list(:codeqa_telemetry)
-
-      # Group totals and counts
-      totals =
-        Enum.filter(metrics, fn {k, _} -> not String.ends_with?(to_string(k), "_count") end)
-
-      totals
-      |> Enum.sort_by(fn {_, time} -> time end, :desc)
-      |> Enum.each(&IO.puts(:stderr, format_metric_line(&1)))
-
-      IO.puts(:stderr, "-------------------------------------------
-")
-    end
-  end
-end
diff --git a/test/codeqa/collector_test.exs b/test/codeqa/collector_test.exs
index 0a2a3f5..f2aeb59 100644
--- a/test/codeqa/collector_test.exs
+++ b/test/codeqa/collector_test.exs
@@ -1,7 +1,12 @@
 defmodule CodeQA.CollectorTest do
-  use ExUnit.Case, async: true
+  use ExUnit.Case, async: false
 
-  alias CodeQA.Collector
+  alias CodeQA.Engine.Collector
+
+  setup do
+    CodeQA.Config.reset()
+    on_exit(&CodeQA.Config.reset/0)
+  end
 
   describe "ignored?/2" do
     test "matches simple wildcard pattern" do
@@ -93,7 +98,7 @@ defmodule CodeQA.CollectorTest do
         %{path: "lib/bar.ex", status: "modified"}
       ]
 
-      result = Collector.reject_ignored(items, ["test/*"], & &1.path)
+      result = Collector.reject_ignored(items, & &1.path, ["test/*"])
 
       assert length(result) == 1
       assert hd(result).path == "lib/bar.ex"
@@ -101,7 +106,32 @@ defmodule CodeQA.CollectorTest do
 
     test "empty patterns returns list unchanged" do
       items = [%{path: "test/foo.ex"}]
-      assert Collector.reject_ignored(items, [], & &1.path) == items
+      assert Collector.reject_ignored(items, & &1.path, []) == items
+    end
+  end
+
+  describe "collect_files/2 respects .gitignore" do
+    setup do
+      tmp_dir =
+        Path.join(System.tmp_dir!(), "codeqa_git_collector_#{System.unique_integer([:positive])}")
+
+      File.mkdir_p!(Path.join(tmp_dir, "lib"))
+      System.cmd("git", ["init"], cd: tmp_dir)
+      System.cmd("git", ["config", "user.email", "test@test.com"], cd: tmp_dir)
+      System.cmd("git", ["config", "user.name", "Test"], cd: tmp_dir)
+      File.write!(Path.join(tmp_dir, "lib/app.ex"), "defmodule App do\nend")
+      File.write!(Path.join(tmp_dir, "lib/generated.ex"), "defmodule Gen do\nend")
+      File.write!(Path.join(tmp_dir, ".gitignore"), "lib/generated.ex\n")
+
+      on_exit(fn -> File.rm_rf!(tmp_dir) end)
+
+      %{tmp_dir: tmp_dir}
+    end
+
+    test "excludes files listed in .gitignore", %{tmp_dir: tmp_dir} do
+      files = Collector.collect_files(tmp_dir)
+      assert Map.has_key?(files, "lib/app.ex")
+      refute Map.has_key?(files, "lib/generated.ex")
     end
   end
 
@@ -125,9 +155,21 @@ defmodule CodeQA.CollectorTest do
     end
 
     test "with ignore patterns excludes matching files", %{tmp_dir: tmp_dir} do
-      files = Collector.collect_files(tmp_dir, ignore_patterns: ["test/*"])
+      files = Collector.collect_files(tmp_dir, ["test/*"])
       assert Map.has_key?(files, "lib/app.ex")
       refute Map.has_key?(files, "test/app_test.exs")
     end
+
+    test "respects ignore_paths from .codeqa.yml", %{tmp_dir: tmp_dir} do
+      File.mkdir_p!(Path.join(tmp_dir, "generated"))
+      File.write!(Path.join(tmp_dir, "generated/schema.ex"), "defmodule Schema do\nend")
+      File.write!(Path.join(tmp_dir, ".codeqa.yml"), "ignore_paths:\n  - generated/**\n")
+
+      CodeQA.Config.load(tmp_dir)
+      files = Collector.collect_files(tmp_dir)
+
+      assert Map.has_key?(files, "lib/app.ex")
+      refute Map.has_key?(files, "generated/schema.ex")
+    end
   end
 end
diff --git a/test/codeqa/engine/analyzer_test.exs b/test/codeqa/engine/analyzer_test.exs
new file mode 100644
index 0000000..ccc4a41
--- /dev/null
+++ b/test/codeqa/engine/analyzer_test.exs
@@ -0,0 +1,44 @@
+defmodule CodeQA.Engine.AnalyzerTest do
+  use ExUnit.Case, async: true
+
+  describe "analyze_file/2" do
+    test "returns a metrics map with group keys" do
+      content = "defmodule Foo do\n  def bar, do: :ok\nend\n"
+      result = CodeQA.Engine.Analyzer.analyze_file("lib/foo.ex", content)
+      assert is_map(result)
+      assert map_size(result) > 0
+      # Each value should be a map of metric keys to numbers
+      Enum.each(result, fn {_group, keys} ->
+        assert is_map(keys)
+      end)
+    end
+  end
+
+  describe "analyze_codebase_aggregate/2" do
+    test "returns aggregate map with mean_ keys" do
+      files = %{
+        "lib/a.ex" => "defmodule A do\n  def foo, do: :a\nend\n",
+        "lib/b.ex" => "defmodule B do\n  def bar, do: :b\nend\n"
+      }
+
+      agg = CodeQA.Engine.Analyzer.analyze_codebase_aggregate(files)
+      assert is_map(agg)
+      # At least one group should have mean_ keys
+      Enum.each(agg, fn {_group, keys} ->
+        Enum.each(keys, fn {key, val} ->
+          assert String.starts_with?(key, "mean_") or String.starts_with?(key, "std_") or
+                   String.starts_with?(key, "min_") or String.starts_with?(key, "max_")
+
+          assert is_float(val) or is_integer(val)
+        end)
+      end)
+    end
+
+    test "does not run codebase metrics (returns quickly for large input)" do
+      # Just assert it returns without error for a reasonable input
+      files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: 1\nend\n"}
+      agg = CodeQA.Engine.Analyzer.analyze_codebase_aggregate(files)
+      assert is_map(agg)
+    end
+  end
+end
diff --git a/test/codeqa/formatter_test.exs b/test/codeqa/formatter_test.exs
index ccefca5..de5be57 100644
--- a/test/codeqa/formatter_test.exs
+++ b/test/codeqa/formatter_test.exs
@@ -126,6 +126,7 @@ defmodule CodeQA.FormatterTest do
 
     test "file changes section reflects metric directions from codebase data" do
       result = Formatter.format_github(@sample_comparison)
+
       # halstead.mean_volume drops 100/500 = 20% → "decreased"; readability rises 10/65 ≈ 15% → "increased slightly"
       refute result =~ "File changes — 1 modified — all metrics stable"
     end
diff --git a/test/codeqa/git_test.exs b/test/codeqa/git_test.exs
new file mode 100644
index 0000000..2d1ec2f
--- /dev/null
+++ b/test/codeqa/git_test.exs
@@ -0,0 +1,112 @@
+defmodule CodeQA.GitTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.Git
+
+  describe "gitignored_files/2" do
+    test "returns files that are gitignored" do
+      in_tmp_git_repo(fn repo ->
+        File.write!(Path.join(repo, ".gitignore"), "*.secret\n")
+        File.write!(Path.join(repo, "config.secret"), "password=123")
+        File.write!(Path.join(repo, "app.ex"), "defmodule App do end")
+
+        ignored = Git.gitignored_files(repo, ["config.secret", "app.ex"])
+
+        assert ignored == MapSet.new(["config.secret"])
+      end)
+    end
+
+    test "returns empty set when no files are gitignored" do
+      in_tmp_git_repo(fn repo ->
+        File.write!(Path.join(repo, ".gitignore"), "*.secret\n")
+        File.write!(Path.join(repo, "app.ex"), "defmodule App do end")
+
+        ignored = Git.gitignored_files(repo, ["app.ex"])
+
+        assert ignored == MapSet.new()
+      end)
+    end
+
+    test "handles empty file list" do
+      in_tmp_git_repo(fn repo ->
+        File.write!(Path.join(repo, ".gitignore"), "*.secret\n")
+
+        ignored = Git.gitignored_files(repo, [])
+
+        assert ignored == MapSet.new()
+      end)
+    end
+
+    test "respects nested .gitignore files" do
+      in_tmp_git_repo(fn repo ->
+        File.mkdir_p!(Path.join(repo, "subdir"))
+        File.write!(Path.join(repo, "subdir/.gitignore"), "local.ex\n")
+        File.write!(Path.join(repo, "subdir/local.ex"), "# local")
+        File.write!(Path.join(repo, "subdir/other.ex"), "# other")
+
+        ignored = Git.gitignored_files(repo, ["subdir/local.ex", "subdir/other.ex"])
+
+        assert ignored == MapSet.new(["subdir/local.ex"])
+      end)
+    end
+
+    test "handles more than 1000 paths without ARG_MAX issues" do
+      in_tmp_git_repo(fn repo ->
+        File.write!(Path.join(repo, ".gitignore"), "ignored.ex\n")
+
+        paths = Enum.map(1..1200, fn i -> "file_#{i}.ex" end) ++ ["ignored.ex"]
+
+        ignored = Git.gitignored_files(repo, paths)
+
+        assert ignored == MapSet.new(["ignored.ex"])
+      end)
+    end
+
+    test "filters files inside a gitignored directory" do
+      in_tmp_git_repo(fn repo ->
+        File.write!(Path.join(repo, ".gitignore"), "/docs/\n")
+
+        ignored =
+          Git.gitignored_files(repo, [
+            "docs/readme.md",
+            "docs/guide/intro.md",
+            "lib/app.ex"
+          ])
+
+        assert ignored == MapSet.new(["docs/readme.md", "docs/guide/intro.md"])
+      end)
+    end
+
+    test "filters gitignored-pattern files even when already tracked by git" do
+      in_tmp_git_repo(fn repo ->
+        File.mkdir_p!(Path.join(repo, "docs"))
+        File.mkdir_p!(Path.join(repo, "lib"))
+        File.write!(Path.join(repo, "docs/readme.md"), "# Docs")
+        File.write!(Path.join(repo, "lib/app.ex"), "defmodule App do end")
+
+        System.cmd("git", ["add", "."], cd: repo)
+        System.cmd("git", ["commit", "-m", "initial"], cd: repo)
+
+        File.write!(Path.join(repo, ".gitignore"), "/docs/\n")
+
+        ignored = Git.gitignored_files(repo, ["docs/readme.md", "lib/app.ex"])
+
+        assert ignored == MapSet.new(["docs/readme.md"])
+      end)
+    end
+  end
+
+  defp in_tmp_git_repo(fun) do
+    tmp = Path.join(System.tmp_dir!(), "codeqa_git_test_#{:rand.uniform(999_999)}")
+    File.mkdir_p!(tmp)
+    System.cmd("git", ["init"], cd: tmp)
+    System.cmd("git", ["config", "user.email", "test@test.com"], cd: tmp)
+    System.cmd("git", ["config", "user.name", "Test"], cd: tmp)
+
+    try do
+      fun.(tmp)
+    after
+      File.rm_rf!(tmp)
+    end
+  end
+end
diff --git a/test/codeqa/metrics/codebase/similarity_test.exs b/test/codeqa/metrics/codebase/similarity_test.exs
new file mode 100644
index 0000000..d20dbf1
--- /dev/null
+++ b/test/codeqa/metrics/codebase/similarity_test.exs
@@ -0,0 +1,79 @@
+defmodule CodeQA.Metrics.Codebase.SimilarityTest do
+  use ExUnit.Case, async: true
+  alias CodeQA.Metrics.Codebase.Similarity
+
+  describe "name/0" do
+    test "returns similarity" do
+      assert Similarity.name() == "similarity"
+    end
+  end
+
+  describe "analyze/2 with fewer than 2 files" do
+    test "empty codebase returns zero density" do
+      result = Similarity.analyze(%{})
+      assert result["cross_file_density"] == 0.0
+    end
+
+    test "single file returns zero density" do
+      result = Similarity.analyze(%{"a.ex" => "x = 1"})
+      assert result["cross_file_density"] == 0.0
+    end
+
+    test "fewer than 2 files returns empty ncd_pairs" do
+      result = Similarity.analyze(%{"a.ex" => "x = 1"})
+      assert result["ncd_pairs"] == %{}
+    end
+  end
+
+  describe "analyze/2 cross_file_density" do
+    test "returns a float between 0 and 2" do
+      files = %{"a.ex" => "def foo, do: 1", "b.ex" => "def bar, do: 2"}
+      result = Similarity.analyze(files)
+      assert is_float(result["cross_file_density"])
+      assert result["cross_file_density"] >= 0.0
+    end
+
+    test "identical files produce higher density than dissimilar files" do
+      content = String.duplicate("def foo do\n  x = 1\nend\n", 20)
+      identical = %{"a.ex" => content, "b.ex" => content}
+      dissimilar = %{"a.ex" => content, "b.ex" => String.duplicate("zzz qqq rrr\n", 20)}
+
+      assert Similarity.analyze(identical)["cross_file_density"] >
+               Similarity.analyze(dissimilar)["cross_file_density"]
+    end
+
+    test "does not return ncd_pairs key by default" do
+      files = %{"a.ex" => "x = 1", "b.ex" => "y = 2"}
+      result = Similarity.analyze(files)
+      refute Map.has_key?(result, "ncd_pairs")
+    end
+  end
+
+  describe "analyze/2 with show_ncd: true" do
+    test "returns ncd_pairs key" do
+      files = %{"a.ex" => "x = 1", "b.ex" => "y = 2"}
+      result = Similarity.analyze(files, show_ncd: true)
+      assert Map.has_key?(result, "ncd_pairs")
+    end
+
+    test "identical files have ncd near 0" do
+      content = String.duplicate("def foo do\n  x = 1\nend\n", 10)
+      files = %{"a.ex" => content, "b.ex" => content}
+
+      result = Similarity.analyze(files, show_ncd: true, ncd_paths: ["a.ex"])
+      pairs = result["ncd_pairs"]
+
+      scores = pairs |> Map.values() |> List.flatten() |> Enum.map(& &1["score"])
+      assert Enum.all?(scores, &(&1 < 0.2))
+    end
+
+    test "ncd_paths restricts which files are compared" do
+      files = %{"a.ex" => "x = 1", "b.ex" => "y = 2", "c.ex" => "z = 3"}
+      result = Similarity.analyze(files, show_ncd: true, ncd_paths: ["a.ex"])
+      pairs = result["ncd_pairs"]
+      assert Map.has_key?(pairs, "a.ex")
+      refute Map.has_key?(pairs, "b.ex")
+      refute Map.has_key?(pairs, "c.ex")
+    end
+  end
+end
diff --git a/test/codeqa/metrics/branching_test.exs b/test/codeqa/metrics/file/branching_test.exs
similarity index 79%
rename from test/codeqa/metrics/branching_test.exs
rename to test/codeqa/metrics/file/branching_test.exs
index d794780..d527a60 100644
--- a/test/codeqa/metrics/branching_test.exs
+++ b/test/codeqa/metrics/file/branching_test.exs
@@ -1,8 +1,8 @@
-defmodule CodeQA.Metrics.BranchingTest do
+defmodule CodeQA.Metrics.File.BranchingTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.Metrics.Branching
-  alias CodeQA.Pipeline
+  alias CodeQA.Metrics.File.Branching
+  alias CodeQA.Engine.Pipeline
 
   defp ctx(code), do: Pipeline.build_file_context(code)
   defp density(code), do: Branching.analyze(ctx(code))["branching_density"]
@@ -27,7 +27,9 @@ defmodule CodeQA.Metrics.BranchingTest do
     for keyword <- Branching.branching_keywords() |> MapSet.to_list() |> Enum.sort() do
       test "counts #{keyword} as a branching token" do
         code = "line_before\n#{unquote(keyword)} condition\nline_after"
-        assert density(code) > 0.0, "expected '#{unquote(keyword)}' to be counted as a branching token"
+
+        assert density(code) > 0.0,
+               "expected '#{unquote(keyword)}' to be counted as a branching token"
       end
     end
   end
diff --git a/test/codeqa/metrics/function_metrics_test.exs b/test/codeqa/metrics/file/function_metrics_test.exs
similarity index 77%
rename from test/codeqa/metrics/function_metrics_test.exs
rename to test/codeqa/metrics/file/function_metrics_test.exs
index caa1f6b..eee4bc2 100644
--- a/test/codeqa/metrics/function_metrics_test.exs
+++ b/test/codeqa/metrics/file/function_metrics_test.exs
@@ -1,8 +1,8 @@
-defmodule CodeQA.Metrics.FunctionMetricsTest do
+defmodule CodeQA.Metrics.File.FunctionMetricsTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.Metrics.FunctionMetrics
-  alias CodeQA.Pipeline
+  alias CodeQA.Metrics.File.FunctionMetrics
+  alias CodeQA.Engine.Pipeline
 
   defp ctx(code), do: Pipeline.build_file_context(code)
   defp analyze(code), do: FunctionMetrics.analyze(ctx(code))
@@ -50,8 +50,10 @@ defmodule CodeQA.Metrics.FunctionMetricsTest do
     for keyword <- FunctionMetrics.func_keywords() do
       test "detects function starting with #{keyword}" do
         code = "#{unquote(keyword)} my_func(x) {\n  return x\n}"
-        result = FunctionMetrics.analyze(CodeQA.Pipeline.build_file_context(code))
-        assert result["avg_function_lines"] > 0, "expected '#{unquote(keyword)}' to be detected as function start"
+        result = FunctionMetrics.analyze(CodeQA.Engine.Pipeline.build_file_context(code))
+
+        assert result["avg_function_lines"] > 0,
+               "expected '#{unquote(keyword)}' to be detected as function start"
       end
     end
   end
@@ -60,8 +62,10 @@ defmodule CodeQA.Metrics.FunctionMetricsTest do
     for modifier <- FunctionMetrics.access_modifiers() do
       test "detects method starting with #{modifier}" do
         code = "#{unquote(modifier)} void MyMethod() {\n  return;\n}"
-        result = FunctionMetrics.analyze(CodeQA.Pipeline.build_file_context(code))
-        assert result["avg_function_lines"] > 0, "expected '#{unquote(modifier)}' access modifier to trigger method detection"
+        result = FunctionMetrics.analyze(CodeQA.Engine.Pipeline.build_file_context(code))
+
+        assert result["avg_function_lines"] > 0,
+               "expected '#{unquote(modifier)}' access modifier to trigger method detection"
       end
     end
   end

From 653e8308281cb82c69233c83ebeee91650e6ff7d Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 19 Mar 2026 18:25:50 +0100
Subject: [PATCH 03/71] feat(ast): add AST parsing system with lexing, signals,
 and node classification

Introduce a full AST abstraction layer: token lexing (string, whitespace,
newline tokens), structural and classification signals, parser with signal
stream, node types (function, module, import, doc, etc.), and compound node
builder with enrichment. Enables language-agnostic code structure analysis.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../ast/classification/node_classifier.ex     | 123 +++++++++
 .../ast/classification/node_protocol.ex       |  29 ++
 .../ast/classification/node_type_detector.ex  |  20 ++
 lib/codeqa/ast/enrichment/compound_node.ex    |  41 +++
 .../ast/enrichment/compound_node_builder.ex   | 157 +++++++++++
 lib/codeqa/ast/enrichment/node.ex             |  70 +++++
 lib/codeqa/ast/enrichment/node_analyzer.ex    |  65 +++++
 lib/codeqa/ast/lexing/newline_token.ex        |  29 ++
 lib/codeqa/ast/lexing/string_token.ex         |  49 ++++
 lib/codeqa/ast/lexing/token.ex                |  45 +++
 lib/codeqa/ast/lexing/token_normalizer.ex     | 259 ++++++++++++++++++
 lib/codeqa/ast/lexing/token_protocol.ex       |  59 ++++
 lib/codeqa/ast/lexing/whitespace_token.ex     |  29 ++
 lib/codeqa/ast/nodes/attribute_node.ex        |  65 +++++
 lib/codeqa/ast/nodes/code_node.ex             |  44 +++
 lib/codeqa/ast/nodes/doc_node.ex              |  44 +++
 lib/codeqa/ast/nodes/function_node.ex         |  57 ++++
 lib/codeqa/ast/nodes/import_node.ex           |  45 +++
 lib/codeqa/ast/nodes/module_node.ex           |  46 ++++
 lib/codeqa/ast/nodes/test_node.ex             |  45 +++
 lib/codeqa/ast/parsing/parser.ex              | 233 ++++++++++++++++
 lib/codeqa/ast/parsing/signal.ex              |  44 +++
 lib/codeqa/ast/parsing/signal_registry.ex     |  94 +++++++
 lib/codeqa/ast/parsing/signal_stream.ex       |  54 ++++
 .../classification/attribute_signal.ex        |  66 +++++
 .../classification/comment_density_signal.ex  |  61 +++++
 .../signals/classification/config_signal.ex   |  54 ++++
 .../ast/signals/classification/data_signal.ex |  67 +++++
 .../ast/signals/classification/doc_signal.ex  |  29 ++
 .../signals/classification/function_signal.ex |  72 +++++
 .../signals/classification/import_signal.ex   |  62 +++++
 .../signals/classification/module_signal.ex   |  71 +++++
 .../ast/signals/classification/test_signal.ex |  63 +++++
 .../ast/signals/classification/type_signal.ex |  49 ++++
 .../structural/access_modifier_signal.ex      |  80 ++++++
 .../structural/assignment_function_signal.ex  | 135 +++++++++
 .../signals/structural/blank_line_signal.ex   |  45 +++
 .../ast/signals/structural/bracket_signal.ex  |  51 ++++
 .../signals/structural/branch_split_signal.ex |  58 ++++
 .../signals/structural/colon_indent_signal.ex |  83 ++++++
 .../structural/comment_divider_signal.ex      |  76 +++++
 .../signals/structural/decorator_signal.ex    |  81 ++++++
 .../structural/dedent_to_zero_signal.ex       |  87 ++++++
 .../structural/doc_comment_lead_signal.ex     |  65 +++++
 .../ast/signals/structural/keyword_signal.ex  |  83 ++++++
 .../signals/structural/sql_block_signal.ex    |  55 ++++
 .../signals/structural/triple_quote_signal.ex |  31 +++
 test/support/counter_signal.ex                |  19 ++
 test/support/node_matcher.ex                  |  17 ++
 49 files changed, 3306 insertions(+)
 create mode 100644 lib/codeqa/ast/classification/node_classifier.ex
 create mode 100644 lib/codeqa/ast/classification/node_protocol.ex
 create mode 100644 lib/codeqa/ast/classification/node_type_detector.ex
 create mode 100644 lib/codeqa/ast/enrichment/compound_node.ex
 create mode 100644 lib/codeqa/ast/enrichment/compound_node_builder.ex
 create mode 100644 lib/codeqa/ast/enrichment/node.ex
 create mode 100644 lib/codeqa/ast/enrichment/node_analyzer.ex
 create mode 100644 lib/codeqa/ast/lexing/newline_token.ex
 create mode 100644 lib/codeqa/ast/lexing/string_token.ex
 create mode 100644 lib/codeqa/ast/lexing/token.ex
 create mode 100644 lib/codeqa/ast/lexing/token_normalizer.ex
 create mode 100644 lib/codeqa/ast/lexing/token_protocol.ex
 create mode 100644 lib/codeqa/ast/lexing/whitespace_token.ex
 create mode 100644 lib/codeqa/ast/nodes/attribute_node.ex
 create mode 100644 lib/codeqa/ast/nodes/code_node.ex
 create mode 100644 lib/codeqa/ast/nodes/doc_node.ex
 create mode 100644 lib/codeqa/ast/nodes/function_node.ex
 create mode 100644 lib/codeqa/ast/nodes/import_node.ex
 create mode 100644 lib/codeqa/ast/nodes/module_node.ex
 create mode 100644 lib/codeqa/ast/nodes/test_node.ex
 create mode 100644 lib/codeqa/ast/parsing/parser.ex
 create mode 100644 lib/codeqa/ast/parsing/signal.ex
 create mode 100644 lib/codeqa/ast/parsing/signal_registry.ex
 create mode 100644 lib/codeqa/ast/parsing/signal_stream.ex
 create mode 100644 lib/codeqa/ast/signals/classification/attribute_signal.ex
 create mode 100644 lib/codeqa/ast/signals/classification/comment_density_signal.ex
 create mode 100644 lib/codeqa/ast/signals/classification/config_signal.ex
 create mode 100644 lib/codeqa/ast/signals/classification/data_signal.ex
 create mode 100644 lib/codeqa/ast/signals/classification/doc_signal.ex
 create mode 100644 lib/codeqa/ast/signals/classification/function_signal.ex
 create mode 100644 lib/codeqa/ast/signals/classification/import_signal.ex
 create mode 100644 lib/codeqa/ast/signals/classification/module_signal.ex
 create mode 100644 lib/codeqa/ast/signals/classification/test_signal.ex
 create mode 100644 lib/codeqa/ast/signals/classification/type_signal.ex
 create mode 100644 lib/codeqa/ast/signals/structural/access_modifier_signal.ex
 create mode 100644 lib/codeqa/ast/signals/structural/assignment_function_signal.ex
 create mode 100644 lib/codeqa/ast/signals/structural/blank_line_signal.ex
 create mode 100644 lib/codeqa/ast/signals/structural/bracket_signal.ex
 create mode 100644 lib/codeqa/ast/signals/structural/branch_split_signal.ex
 create mode 100644 lib/codeqa/ast/signals/structural/colon_indent_signal.ex
 create mode 100644 lib/codeqa/ast/signals/structural/comment_divider_signal.ex
 create mode 100644 lib/codeqa/ast/signals/structural/decorator_signal.ex
 create mode 100644 lib/codeqa/ast/signals/structural/dedent_to_zero_signal.ex
 create mode 100644 lib/codeqa/ast/signals/structural/doc_comment_lead_signal.ex
 create mode 100644 lib/codeqa/ast/signals/structural/keyword_signal.ex
 create mode 100644 lib/codeqa/ast/signals/structural/sql_block_signal.ex
 create mode 100644 lib/codeqa/ast/signals/structural/triple_quote_signal.ex
 create mode 100644 test/support/counter_signal.ex
 create mode 100644 test/support/node_matcher.ex

diff --git a/lib/codeqa/ast/classification/node_classifier.ex b/lib/codeqa/ast/classification/node_classifier.ex
new file mode 100644
index 0000000..57c559d
--- /dev/null
+++ b/lib/codeqa/ast/classification/node_classifier.ex
@@ -0,0 +1,123 @@
+defmodule CodeQA.AST.Classification.NodeClassifier do
+  @moduledoc """
+  Classifies a Node into a typed struct by running classification signals
+  over its tokens and weighing their votes.
+
+  ## How it works
+
+  Six classification signals scan the node's token stream in parallel via
+  `SignalStream`. Each signal emits weighted votes (e.g. `{:function_vote, 3}`)
+  when it detects a pattern indicating a node type. The classifier sums weights
+  per type and picks the winner. Ties and no-votes fall back to `:code`.
+
+  ## Signals and votes
+
+  | Signal | Vote key | Patterns detected |
+  |---|---|---|
+  | `DocSignal` | `:doc_vote` | `<DOC>` token anywhere |
+  | `AttributeSignal` | `:attribute_vote` | `@name` at indent 0 |
+  | `FunctionSignal` | `:function_vote` | `def`, `func`, `fn`, etc. at indent 0 |
+  | `ModuleSignal` | `:module_vote` | `defmodule`, `class`, `module`, etc. at indent 0 |
+  | `ImportSignal` | `:import_vote` | `import`, `use`, `alias`, etc. at indent 0 |
+  | `TestSignal` | `:test_vote` | `test`, `describe`, `it`, etc. at indent 0 |
+
+  ## Weights
+
+  Weight 3 = first keyword seen (strong match); weight 1 = keyword later in
+  block (weak match, e.g. after a leading comment). `DocSignal` always emits
+  weight 3 and wins when a `<DOC>` token is present, since triple-quoted strings
+  are unambiguous.
+
+  ## Type-specific fields
+
+  `FunctionNode.name/arity/visibility`, `ModuleNode.name/kind`, etc. all default
+  to `nil`. Population of those fields is left to a future enrichment pass.
+  """
+
+  alias CodeQA.AST.Enrichment.Node
+  alias CodeQA.AST.Parsing.SignalStream
+
+  alias CodeQA.AST.Signals.Classification.{
+    DocSignal,
+    AttributeSignal,
+    FunctionSignal,
+    ModuleSignal,
+    ImportSignal,
+    TestSignal
+  }
+
+  alias CodeQA.AST.Nodes.{
+    CodeNode,
+    DocNode,
+    FunctionNode,
+    ModuleNode,
+    ImportNode,
+    AttributeNode,
+    TestNode
+  }
+
+  @classification_signals [
+    %DocSignal{},
+    %AttributeSignal{},
+    %FunctionSignal{},
+    %ModuleSignal{},
+    %ImportSignal{},
+    %TestSignal{}
+  ]
+
+  @type_modules %{
+    doc: DocNode,
+    attribute: AttributeNode,
+    function: FunctionNode,
+    module: ModuleNode,
+    import: ImportNode,
+    test: TestNode,
+    code: CodeNode
+  }
+
+  @doc """
+  Classify a Node into the most specific typed struct.
+
+  Runs classification signals, weighs votes, and delegates to the winning
+  struct's `cast/1` to build the result. Type-specific fields default to nil.
+  """
+  @spec classify(Node.t(), module()) :: term()
+  def classify(%Node{} = node, lang_mod) do
+    type = vote(node.tokens, lang_mod)
+    @type_modules[type].cast(node)
+  end
+
+  defp vote(tokens, lang_mod) do
+    tokens
+    |> run_signals(lang_mod)
+    |> tally()
+    |> winner()
+  end
+
+  defp run_signals(tokens, lang_mod) do
+    SignalStream.run(tokens, @classification_signals, lang_mod)
+    |> List.flatten()
+    |> Enum.filter(fn {_src, group, _name, _val} -> group == :classification end)
+  end
+
+  defp tally(emissions) do
+    Enum.reduce(emissions, %{}, fn {_src, _grp, name, weight}, acc ->
+      Map.update(acc, name, weight, &(&1 + weight))
+    end)
+  end
+
+  defp winner(votes) when map_size(votes) == 0, do: :code
+
+  defp winner(votes) do
+    {vote_name, _weight} = Enum.max_by(votes, fn {_, w} -> w end)
+    vote_to_type(vote_name)
+  end
+
+  defp vote_to_type(:doc_vote), do: :doc
+  defp vote_to_type(:attribute_vote), do: :attribute
+  defp vote_to_type(:function_vote), do: :function
+  defp vote_to_type(:module_vote), do: :module
+  defp vote_to_type(:import_vote), do: :import
+  defp vote_to_type(:test_vote), do: :test
+  defp vote_to_type(_), do: :code
+end
diff --git a/lib/codeqa/ast/classification/node_protocol.ex b/lib/codeqa/ast/classification/node_protocol.ex
new file mode 100644
index 0000000..fa4943d
--- /dev/null
+++ b/lib/codeqa/ast/classification/node_protocol.ex
@@ -0,0 +1,29 @@
+defprotocol CodeQA.AST.Classification.NodeProtocol do
+  @moduledoc """
+  Common interface for all typed AST node structs.
+
+  All node struct types (CodeNode, DocNode, FunctionNode, etc.) implement this
+  protocol, allowing downstream code to work with any node type uniformly.
+  """
+
+  @spec tokens(t()) :: [term()]
+  def tokens(node)
+
+  @spec flat_tokens(t()) :: [term()]
+  def flat_tokens(node)
+
+  @spec line_count(t()) :: non_neg_integer()
+  def line_count(node)
+
+  @spec children(t()) :: [term()]
+  def children(node)
+
+  @spec start_line(t()) :: non_neg_integer() | nil
+  def start_line(node)
+
+  @spec end_line(t()) :: non_neg_integer() | nil
+  def end_line(node)
+
+  @spec label(t()) :: term() | nil
+  def label(node)
+end
diff --git a/lib/codeqa/ast/classification/node_type_detector.ex b/lib/codeqa/ast/classification/node_type_detector.ex
new file mode 100644
index 0000000..6175968
--- /dev/null
+++ b/lib/codeqa/ast/classification/node_type_detector.ex
@@ -0,0 +1,20 @@
+defmodule CodeQA.AST.Classification.NodeTypeDetector do
+  @moduledoc """
+  Classifies a list of raw `Node` structs (from `Parser`) into typed structs.
+
+  Each node is classified by `NodeClassifier`, which runs classification signals
+  over the node's tokens and picks the highest-voted type. See `NodeClassifier`
+  for the full list of signals and their weights.
+  """
+
+  alias CodeQA.AST.Enrichment.Node
+  alias CodeQA.AST.Classification.NodeClassifier
+
+  @doc """
+  Classify each node in the list into the most specific typed struct.
+  """
+  @spec detect_types([Node.t()], module()) :: [term()]
+  def detect_types(blocks, lang_mod) do
+    Enum.map(blocks, &NodeClassifier.classify(&1, lang_mod))
+  end
+end
diff --git a/lib/codeqa/ast/enrichment/compound_node.ex b/lib/codeqa/ast/enrichment/compound_node.ex
new file mode 100644
index 0000000..88a594c
--- /dev/null
+++ b/lib/codeqa/ast/enrichment/compound_node.ex
@@ -0,0 +1,41 @@
+defmodule CodeQA.AST.Enrichment.CompoundNode do
+  @moduledoc """
+  Groups semantically related typed nodes together.
+
+  A compound node represents a complete "unit" in source code — combining
+  documentation, type annotations, and implementation:
+
+  - `docs`       — [DocNode.t()] (triple-quoted docstrings)
+  - `typespecs`  — [AttributeNode.t()] (@spec, @type, etc.)
+  - `code`       — [Node.t()] with type :code (implementation clauses)
+
+  Boundaries span all constituent nodes in source order (docs → typespecs →
+  code), with leading/trailing whitespace tokens stripped. Column values are
+  read from the `col` field of the relevant Token structs — Node has no col
+  fields.
+
+  A bare code node with no preceding docs/typespecs is still wrapped in a
+  CompoundNode (with empty `docs` and `typespecs`).
+  """
+
+  alias CodeQA.AST.Enrichment.Node
+  alias CodeQA.AST.Nodes.AttributeNode
+
+  defstruct docs: [],
+            typespecs: [],
+            code: [],
+            start_line: nil,
+            start_col: nil,
+            end_line: nil,
+            end_col: nil
+
+  @type t :: %__MODULE__{
+          docs: [Node.t()],
+          typespecs: [AttributeNode.t()],
+          code: [Node.t()],
+          start_line: non_neg_integer() | nil,
+          start_col: non_neg_integer() | nil,
+          end_line: non_neg_integer() | nil,
+          end_col: non_neg_integer() | nil
+        }
+end
diff --git a/lib/codeqa/ast/enrichment/compound_node_builder.ex b/lib/codeqa/ast/enrichment/compound_node_builder.ex
new file mode 100644
index 0000000..f446e72
--- /dev/null
+++ b/lib/codeqa/ast/enrichment/compound_node_builder.ex
@@ -0,0 +1,157 @@
+defmodule CodeQA.AST.Enrichment.CompoundNodeBuilder do
+  @moduledoc """
+  Groups typed nodes into CompoundNode structs.
+
+  A new compound starts when:
+  1. A :doc or :typespec node appears after at least one :code node
+  2. The trailing whitespace of the previous node contains 2+ <NL> tokens
+
+  All consecutive :code nodes with no boundary between them accumulate
+  into the same compound's `code` list.
+
+  Sub-blocks of :code nodes that have type :doc or :typespec are
+  promoted to the compound's `docs`/`typespecs` lists.
+  """
+
+  alias CodeQA.AST.Enrichment.Node
+  alias CodeQA.AST.Enrichment.CompoundNode
+  alias CodeQA.AST.Classification.NodeProtocol
+  alias CodeQA.AST.Nodes.{DocNode, AttributeNode}
+  alias CodeQA.AST.Lexing.{NewlineToken, WhitespaceToken}
+
+  @doc """
+  Groups a list of typed nodes into CompoundNode structs.
+  """
+  @spec build([Node.t()]) :: [CompoundNode.t()]
+  def build([]), do: []
+
+  def build(blocks) do
+    # Accumulator: {current_compound, prev_trailing_ws, finalized_compounds}
+    # prev_trailing_ws carries the trailing <NL>/<WS> tokens stripped from the
+    # PREVIOUS node. Blank-line boundaries are detected on the previous node's
+    # trailing whitespace — BlankLineRule places blank-line <NL> tokens at the
+    # END of the node that precedes the split, not at the start of the new one.
+    {current, _, compounds} =
+      Enum.reduce(blocks, {empty_compound(), [], []}, fn block,
+                                                         {current, prev_trailing_ws, acc} ->
+        {content_tokens, trailing_ws} = split_trailing_whitespace(block.tokens)
+        clean_block = %{block | tokens: content_tokens}
+        # Check the PREVIOUS node's trailing whitespace for blank-line boundary
+        blank_boundary = blank_line_boundary?(prev_trailing_ws)
+
+        cond do
+          # Rule 1: doc/typespec after code → flush and start new compound
+          (is_struct(block, DocNode) or is_struct(block, AttributeNode)) and current.code != [] ->
+            {start_compound(clean_block), trailing_ws, [finalize(current) | acc]}
+
+          # Rule 2: blank-line boundary on previous node → flush and start fresh
+          blank_boundary and not empty_compound?(current) ->
+            {start_compound(clean_block), trailing_ws, [finalize(current) | acc]}
+
+          # No boundary — accumulate into current
+          true ->
+            {add_block(current, clean_block), trailing_ws, acc}
+        end
+      end)
+
+    compounds
+    |> then(fn acc ->
+      if empty_compound?(current), do: acc, else: [finalize(current) | acc]
+    end)
+    |> Enum.reverse()
+  end
+
+  defp empty_compound, do: %CompoundNode{}
+
+  defp empty_compound?(%CompoundNode{docs: [], typespecs: [], code: []}), do: true
+  defp empty_compound?(_), do: false
+
+  defp add_block(%CompoundNode{} = compound, block) when is_struct(block, DocNode) do
+    %CompoundNode{compound | docs: compound.docs ++ [block]}
+  end
+
+  defp add_block(%CompoundNode{} = compound, block) when is_struct(block, AttributeNode) do
+    %CompoundNode{compound | typespecs: compound.typespecs ++ [block]}
+  end
+
+  defp add_block(%CompoundNode{} = compound, block) do
+    {promoted_docs, promoted_specs, clean_children} = promote_sub_blocks(block.children)
+    clean_block = %{block | children: clean_children}
+
+    %CompoundNode{
+      compound
+      | code: compound.code ++ [clean_block],
+        docs: compound.docs ++ promoted_docs,
+        typespecs: compound.typespecs ++ promoted_specs
+    }
+  end
+
+  defp start_compound(new_block) do
+    add_block(empty_compound(), new_block)
+  end
+
+  # Separates children by type — :doc/:typespec go up to the compound level.
+  defp promote_sub_blocks(children) do
+    Enum.reduce(children, {[], [], []}, fn sub, {docs, specs, code} ->
+      case sub.type do
+        :doc -> {docs ++ [sub], specs, code}
+        :typespec -> {docs, specs ++ [sub], code}
+        _ -> {docs, specs, code ++ [sub]}
+      end
+    end)
+  end
+
+  # Strips trailing <WS>/<NL> tokens from a node's token list.
+  # Returns {content_tokens, trailing_ws_tokens}.
+  defp split_trailing_whitespace(tokens) do
+    last_content_idx =
+      tokens
+      |> Enum.with_index()
+      |> Enum.reverse()
+      |> Enum.find_index(fn {t, _} ->
+        not is_map(t) or t.kind not in [WhitespaceToken.kind(), NewlineToken.kind()]
+      end)
+
+    case last_content_idx do
+      nil ->
+        {[], tokens}
+
+      rev_idx ->
+        content_len = length(tokens) - rev_idx
+        {Enum.slice(tokens, 0, content_len), Enum.slice(tokens, content_len..-1//1)}
+    end
+  end
+
+  # A blank-line boundary exists when the trailing whitespace contains 3+ <NL> tokens
+  # (i.e. 2+ blank lines). A single blank line (2 NLs: end-of-line + blank line) is
+  # common within a compound (e.g. between function clauses) and does not split.
+  defp blank_line_boundary?(trailing_ws) do
+    Enum.count(trailing_ws, &(&1.kind == NewlineToken.kind())) >= 3
+  end
+
+  # Computes boundaries from all constituent nodes in source order:
+  # docs → typespecs → code. Reads col directly from Token structs.
+  defp finalize(%CompoundNode{} = compound) do
+    all_blocks = compound.docs ++ compound.typespecs ++ compound.code
+    all_tokens = Enum.flat_map(all_blocks, &NodeProtocol.flat_tokens/1)
+
+    first_token =
+      Enum.find(
+        all_tokens,
+        &(is_map(&1) and &1.kind not in [WhitespaceToken.kind(), NewlineToken.kind()])
+      )
+
+    last_token =
+      all_tokens
+      |> Enum.reverse()
+      |> Enum.find(&(is_map(&1) and &1.kind not in [WhitespaceToken.kind(), NewlineToken.kind()]))
+
+    %CompoundNode{
+      compound
+      | start_line: first_token && first_token.line,
+        start_col: first_token && first_token.col,
+        end_line: last_token && last_token.line,
+        end_col: last_token && last_token.col
+    }
+  end
+end
diff --git a/lib/codeqa/ast/enrichment/node.ex b/lib/codeqa/ast/enrichment/node.ex
new file mode 100644
index 0000000..65e4b23
--- /dev/null
+++ b/lib/codeqa/ast/enrichment/node.ex
@@ -0,0 +1,70 @@
+defmodule CodeQA.AST.Enrichment.Node do
+  @moduledoc """
+  A detected code node with optional nested sub-blocks.
+
+  ## Fields
+
+  - `tokens`      — aggregated code content: for leaf nodes, the original token stream;
+                    for non-leaf nodes, the flat concatenation of all children's `tokens`.
+                    Use this for content comparison and metrics.
+  - `line_count`  — number of source lines spanned by this node: `end_line - start_line + 1`
+                    when both are available, else `1`.
+  - `children`    — nested `Node.t()` structs detected by enclosure rules
+                    (`BracketRule`, `ColonIndentationRule`).
+  - `label`       — arbitrary term attached by the caller. Set to `"path:start_line"`
+                    by `NearDuplicateBlocks.analyze/2` for human-readable pair reporting.
+  - `start_line`  — 1-based line number of the first token in this node, populated by
+                    `Parser` from `List.first(tokens).line`.
+  - `end_line`    — 1-based line number of the last token in this node, populated by
+                    `Parser` from `List.last(tokens).line`.
+
+  `start_line` and `end_line` may be `nil` for synthetic nodes created in tests
+  without line metadata.
+  """
+
+  @enforce_keys [:tokens, :line_count, :children]
+  defstruct [
+    :tokens,
+    :line_count,
+    :children,
+    :label,
+    :start_line,
+    :end_line,
+    type: :code
+  ]
+
+  @type t :: %__MODULE__{
+          tokens: [CodeQA.AST.Lexing.Token.t()],
+          line_count: non_neg_integer(),
+          children: [term()],
+          label: term() | nil,
+          start_line: non_neg_integer() | nil,
+          end_line: non_neg_integer() | nil,
+          type: :code | :doc | :typespec
+        }
+
+  @spec children_count(t()) :: non_neg_integer()
+  def children_count(%__MODULE__{children: ch}), do: length(ch)
+
+  # Keep old name as deprecated alias during transition
+  @spec sub_block_count(t()) :: non_neg_integer()
+  def sub_block_count(%__MODULE__{children: ch}), do: length(ch)
+
+  @spec token_count(t()) :: non_neg_integer()
+  def token_count(%__MODULE__{tokens: tokens}), do: length(tokens)
+end
+
+defimpl CodeQA.AST.Classification.NodeProtocol, for: CodeQA.AST.Enrichment.Node do
+  def tokens(n), do: n.tokens
+  def line_count(n), do: n.line_count
+  def children(n), do: n.children
+  def start_line(n), do: n.start_line
+  def end_line(n), do: n.end_line
+  def label(n), do: n.label
+
+  def flat_tokens(n) do
+    if Enum.empty?(n.children),
+      do: n.tokens,
+      else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+  end
+end
diff --git a/lib/codeqa/ast/enrichment/node_analyzer.ex b/lib/codeqa/ast/enrichment/node_analyzer.ex
new file mode 100644
index 0000000..d506d3d
--- /dev/null
+++ b/lib/codeqa/ast/enrichment/node_analyzer.ex
@@ -0,0 +1,65 @@
+defmodule CodeQA.AST.Enrichment.NodeAnalyzer do
+  @moduledoc """
+  Extracts locally bound variable names from a token list.
+
+  Used by the domain tagger to subtract local bindings from the domain signal —
+  a variable bound within a node (e.g. `user = Repo.get!(id)`) is not a domain
+  reference and should not appear in the node's domain fingerprint.
+  """
+
+  alias CodeQA.AST.Lexing.Token
+  alias CodeQA.AST.Lexing.NewlineToken
+
+  @doc """
+  Returns a MapSet of lowercase identifier names that are locally bound
+  within the given token list.
+
+  Detected patterns:
+  - `<ID> "="` — simple assignment (guards against `==`, `=>`, `=~`, `!=`, `<=`, `>=`)
+  - `<ID> "<-"` — with/for binding (all `<ID>` tokens on the LHS of `<-`)
+
+  Function parameters are NOT extracted here (see `param_variables/1`).
+  """
+  @spec bound_variables([Token.t()]) :: MapSet.t(String.t())
+  def bound_variables(tokens) do
+    MapSet.union(
+      assignment_bindings(tokens),
+      arrow_bindings(tokens)
+    )
+  end
+
+  # Collect `<ID>` immediately before `=`
+  defp assignment_bindings(tokens) do
+    tokens
+    |> Enum.chunk_every(2, 1, :discard)
+    |> Enum.flat_map(fn
+      [%Token{kind: "<ID>", content: name}, %Token{kind: "="}] ->
+        [String.downcase(name)]
+
+      _ ->
+        []
+    end)
+    |> MapSet.new()
+  end
+
+  # Collect all `<ID>` tokens on the LHS of `<-` (within the same line).
+  # Resets the accumulator on `<NL>` so RHS tokens from prior lines don't leak.
+  defp arrow_bindings(tokens) do
+    tokens
+    |> Enum.reduce({[], MapSet.new()}, fn
+      %Token{kind: "<-"}, {lhs_ids, acc} ->
+        new_bindings = lhs_ids |> Enum.map(&String.downcase/1) |> MapSet.new()
+        {[], MapSet.union(acc, new_bindings)}
+
+      %NewlineToken{}, {_, acc} ->
+        {[], acc}
+
+      %Token{kind: "<ID>", content: name}, {lhs_ids, acc} ->
+        {[name | lhs_ids], acc}
+
+      _, {lhs_ids, acc} ->
+        {lhs_ids, acc}
+    end)
+    |> elem(1)
+  end
+end
diff --git a/lib/codeqa/ast/lexing/newline_token.ex b/lib/codeqa/ast/lexing/newline_token.ex
new file mode 100644
index 0000000..2ccb712
--- /dev/null
+++ b/lib/codeqa/ast/lexing/newline_token.ex
@@ -0,0 +1,29 @@
+defmodule CodeQA.AST.Lexing.NewlineToken do
+  @moduledoc """
+  A newline token emitted by `TokenNormalizer.normalize_structural/1`.
+
+  Represents a `\\n` line boundary between two source lines.
+
+  ## Fields
+
+  - `kind`    — always `"<NL>"`.
+  - `content` — the original newline character (`"\\n"`).
+  - `line`    — 1-based line number of the line that ends here.
+  - `col`     — 0-based byte offset of the newline within that line.
+  """
+
+  @kind "<NL>"
+
+  defstruct [:content, :line, :col, kind: @kind]
+
+  @doc "Returns the normalized kind string for newline tokens."
+  @spec kind() :: String.t()
+  def kind, do: @kind
+
+  @type t :: %__MODULE__{
+          kind: String.t(),
+          content: String.t(),
+          line: non_neg_integer() | nil,
+          col: non_neg_integer() | nil
+        }
+end
diff --git a/lib/codeqa/ast/lexing/string_token.ex b/lib/codeqa/ast/lexing/string_token.ex
new file mode 100644
index 0000000..04fc296
--- /dev/null
+++ b/lib/codeqa/ast/lexing/string_token.ex
@@ -0,0 +1,49 @@
+defmodule CodeQA.AST.Lexing.StringToken do
+  @moduledoc """
+  A string token emitted by `TokenNormalizer` for all string literals,
+  including triple-quoted heredocs.
+
+  ## Fields
+
+  - `kind`           — `"<STR>"` for single-line strings, `"<DOC>"` for
+                       triple-quoted heredoc delimiters.
+  - `content`        — original source text (the full quoted literal or delimiter).
+  - `line`, `col`    — source location.
+  - `interpolations` — list of interpolation expressions (`nil` for plain strings).
+  - `multiline`      — `true` for triple-quoted (`\"\"\"` / `'''`) tokens.
+  - `quotes`         — `:double`, `:single`, or `:backtick`.
+  """
+
+  @kind "<STR>"
+  @doc_kind "<DOC>"
+
+  defstruct [
+    :content,
+    :line,
+    :col,
+    kind: @kind,
+    interpolations: nil,
+    multiline: false,
+    quotes: :double
+  ]
+
+  @doc "Returns the normalized kind string for single-line string tokens."
+  @spec kind() :: String.t()
+  def kind, do: @kind
+
+  @doc "Returns the normalized kind string for triple-quoted doc string tokens."
+  @spec doc_kind() :: String.t()
+  def doc_kind, do: @doc_kind
+
+  @type quotes :: :double | :single | :backtick
+
+  @type t :: %__MODULE__{
+          content: String.t(),
+          line: non_neg_integer() | nil,
+          col: non_neg_integer() | nil,
+          kind: String.t(),
+          interpolations: [String.t()] | nil,
+          multiline: boolean(),
+          quotes: quotes()
+        }
+end
diff --git a/lib/codeqa/ast/lexing/token.ex b/lib/codeqa/ast/lexing/token.ex
new file mode 100644
index 0000000..f705f7e
--- /dev/null
+++ b/lib/codeqa/ast/lexing/token.ex
@@ -0,0 +1,45 @@
+defmodule CodeQA.AST.Lexing.Token do
+  @moduledoc """
+  A single token emitted by `TokenNormalizer.normalize_structural/1`.
+
+  ## Fields
+
+  - `value`   — normalized form used for structural comparison: `<ID>`, `<STR>`,
+                `<NUM>`, `<NL>`, `<WS>`, or the literal character(s) for
+                punctuation and operators.
+  - `content` — original source text before normalization. Identical to `value`
+                for punctuation/structural tokens; differs for identifiers,
+                strings, and numbers. Enables source reconstruction and is the
+                correct field to check when matching declaration keywords.
+  - `line`    — 1-based line number in the source file.
+  - `col`     — 0-based byte offset from the start of the line.
+
+  String literals are emitted as `StringToken` structs, not `Token`, so that
+  the `interpolations` field does not pollute the common token shape.
+
+  ## Design notes (from tree-sitter, ctags, lizard)
+
+  - **value vs content split** — mirrors tree-sitter's distinction between a
+    node's `type` (structural kind) and its `text` (original source). `value`
+    is the kind used for pattern matching and comparison; `content` is the
+    original text used for reporting and reconstruction.
+  - **Normalization lives in value, not content** — `content` is never modified.
+    This means two tokens with different `content` but the same `value` (e.g.
+    `"foo"` and `"bar"` both normalizing to `<ID>`) are structurally equivalent
+    for duplicate detection but distinguishable for reporting.
+  - **Line + col for precise location** — ctags records line numbers; tree-sitter
+    records byte ranges. We store both line (for human-readable reporting) and
+    col (for IDE navigation and sub-block start/end precision).
+  - **No enforcement on line/col** — synthetic tokens created in tests may omit
+    line/col. Consumers that need location data should guard for nil.
+  """
+
+  defstruct [:kind, :content, :line, :col]
+
+  @type t :: %__MODULE__{
+          kind: String.t(),
+          content: String.t(),
+          line: non_neg_integer() | nil,
+          col: non_neg_integer() | nil
+        }
+end
diff --git a/lib/codeqa/ast/lexing/token_normalizer.ex b/lib/codeqa/ast/lexing/token_normalizer.ex
new file mode 100644
index 0000000..d2f0016
--- /dev/null
+++ b/lib/codeqa/ast/lexing/token_normalizer.ex
@@ -0,0 +1,259 @@
+defmodule CodeQA.AST.Lexing.TokenNormalizer do
+  @moduledoc """
+  Abstracts raw source code into language-agnostic structural tokens.
+
+  See [lexical analysis](https://en.wikipedia.org/wiki/Lexical_analysis).
+  """
+
+  alias CodeQA.AST.Lexing.Token
+  alias CodeQA.AST.Lexing.StringToken
+  alias CodeQA.AST.Lexing.NewlineToken
+  alias CodeQA.AST.Lexing.WhitespaceToken
+
+  @doc """
+  Normalizes source code into language-agnostic structural tokens, preserving
+  newlines as `<NL>` and leading whitespace as `<WS>` tokens (one per
+  2-space / 1-tab indentation unit).
+
+  Returns `[Token.t()]` where each token carries its normalized `value`,
+  original source `content`, 1-based `line` number, and 0-based `col` offset.
+  Used for structural block detection.
+  """
+  @spec normalize_structural(String.t()) :: [Token.t()]
+  def normalize_structural(code) do
+    code = String.replace(code, ~r/[^\x00-\x7F]/, " ")
+    lines = String.split(code, "\n")
+    last_idx = length(lines) - 1
+
+    lines
+    |> Enum.with_index()
+    |> Enum.flat_map(fn {line, idx} ->
+      line_num = idx + 1
+      {tokens, last_token} = tokenize_line(line, line_num)
+
+      if idx < last_idx do
+        # last_token is tracked during scanning — O(1) vs List.last/1 which is O(N).
+        nl_col =
+          case last_token do
+            nil -> 0
+            t -> t.col + String.length(t.content)
+          end
+
+        tokens ++ [%NewlineToken{content: "\n", line: line_num, col: nl_col}]
+      else
+        tokens
+      end
+    end)
+  end
+
+  # Returns {tokens, last_token} where last_token is the final token on the line
+  # (or nil for an empty line), allowing normalize_structural to compute nl_col
+  # in O(1) without calling List.last/1.
+  defp tokenize_line(line, line_num) do
+    indent_chars =
+      line
+      |> String.graphemes()
+      |> Enum.take_while(&(&1 in [" ", "\t"]))
+
+    indent_units =
+      indent_chars
+      |> Enum.reduce(0, fn
+        "\t", acc -> acc + 2
+        " ", acc -> acc + 1
+      end)
+      |> div(2)
+
+    indent_col_width = length(indent_chars)
+
+    ws_tokens =
+      for i <- 1..indent_units//1 do
+        %WhitespaceToken{content: "  ", line: line_num, col: (i - 1) * 2}
+      end
+
+    content = String.slice(line, indent_col_width..-1//1)
+    {content_tokens, last_content} = scan_content(content, line_num, indent_col_width)
+
+    # Last token on the line: prefer the last content token; fall back to the
+    # last WS token (only possible when the content portion is empty).
+    last_token = last_content || List.last(ws_tokens)
+
+    {ws_tokens ++ content_tokens, last_token}
+  end
+
+  # Multi-char operators matched longest-first so that e.g. `===` beats `==`.
+  # Tagged `:literal` so `next_token` uses the matched text as both value and content
+  # (unlike `<ID>`, `<STR>`, `<NUM>` which normalise content away).
+  @operator_regex ~r/^(?:===|!==|<=>|==|!=|<=|>=|\|>|<>|<-|->|=>|=~|!~|&&|\|\||\?\?|\?\.|:=|::|\.\.\.|\.\.|--|\+\+|\*\*|\/\/|\+=|-=|\*=|\/=|%=)/
+
+  # --- Individual rule atoms so dispatch groups can reference them directly ---
+  @skip_rule {:skip, ~r/^\s+/}
+  @operator_rule {:literal, @operator_regex}
+  @trip_quotes_rule {"<TRIP_QUOTES>", ~r/^"""|^'''/}
+  @str_interp_rule {"<STR_INTERP>", ~r/^"(?=[^"]*#\{)(?:[^"\\#]|\\.|#(?!\{)|#\{[^}]*\})*"/}
+  @str_dollar_interp_rule {"<STR_DOLLAR_INTERP>",
+                           ~r/^"(?=[^"]*\$\{)(?:[^"\\$]|\\.|\\$(?!\{)|\$\{[^}]*\})*"/}
+  @str_swift_interp_rule {"<STR_SWIFT_INTERP>", ~r/^"(?=[^"]*\\\()(?:[^"\\]|\\.)*"/}
+  @str_rule {"<STR>", ~r/^"(?:[^"\\]|\\.)*"|^'(?:[^'\\]|\\.)*'/}
+  @backtick_interp_rule {"<BACKTICK_INTERP>",
+                         ~r/^`(?=[^`]*\$\{)(?:[^`\\$]|\\.|\\$(?!\{)|\$\{[^}]*\})*`/}
+  @backtick_str_rule {"<BACKTICK_STR>", ~r/^`(?:[^`\\]|\\.)*`/}
+  @num_rule {"<NUM>", ~r/^\d+(?:\.\d+)?/}
+  @id_rule {"<ID>", ~r/^[a-zA-Z_]\w*/}
+
+  # Dispatch rule subsets by first character so the common cases (identifiers,
+  # numbers, whitespace, operators) skip irrelevant regex attempts entirely.
+  @double_quote_rules [
+    @trip_quotes_rule,
+    @str_interp_rule,
+    @str_dollar_interp_rule,
+    @str_swift_interp_rule,
+    @str_rule
+  ]
+  @single_quote_rules [@trip_quotes_rule, @str_rule]
+  @backtick_rules [@backtick_interp_rule, @backtick_str_rule]
+
+  # Returns the rule subset for the given first byte (ASCII codepoint).
+  defp dispatch_rules(?"), do: @double_quote_rules
+  defp dispatch_rules(?'), do: @single_quote_rules
+  defp dispatch_rules(?`), do: @backtick_rules
+  defp dispatch_rules(c) when c >= ?0 and c <= ?9, do: [@num_rule]
+
+  defp dispatch_rules(c)
+       when (c >= ?a and c <= ?z) or (c >= ?A and c <= ?Z) or c == ?_,
+       do: [@id_rule]
+
+  defp dispatch_rules(c)
+       when c in [?=, ?!, ?<, ?>, ?|, ?&, ??, ?:, ?., ?-, ?+, ?*, ?/, ?%],
+       do: [@operator_rule]
+
+  defp dispatch_rules(c) when c <= 32, do: [@skip_rule]
+
+  # Unknown first char — no rule applies; caller falls through to single-char token.
+  defp dispatch_rules(_), do: []
+
+  # Returns {tokens, last_token_or_nil} — last_token is tracked during scanning
+  # so callers get O(1) access to the final token without List.last/1.
+  defp scan_content(text, line_num, col_offset) do
+    {reversed, last} = do_scan(text, line_num, col_offset, [], nil)
+    {Enum.reverse(reversed), last}
+  end
+
+  defp do_scan("", _line, _col, acc, last), do: {acc, last}
+
+  defp do_scan(<<first, _::binary>> = text, line, col, acc, last) do
+    case next_token(first, text, line, col) do
+      {:skip, rest, advance} -> do_scan(rest, line, col + advance, acc, last)
+      {token, rest, advance} -> do_scan(rest, line, col + advance, [token | acc], token)
+    end
+  end
+
+  # next_token/4: dispatches on the first byte to select only candidate rules,
+  # avoiding regex attempts for rules whose first-char pattern can't possibly match.
+  defp next_token(first, text, line, col) do
+    rules = dispatch_rules(first)
+
+    result =
+      Enum.find_value(rules, fn {type, regex} ->
+        case Regex.run(regex, text) do
+          [m | _] -> {type, m}
+          nil -> nil
+        end
+      end)
+
+    case result do
+      {:skip, m} ->
+        len = String.length(m)
+        {:skip, String.slice(text, len..-1//1), len}
+
+      {:literal, m} ->
+        len = String.length(m)
+        {%Token{kind: m, content: m, line: line, col: col}, String.slice(text, len..-1//1), len}
+
+      {value, m} ->
+        len = String.length(m)
+        token = postprocess(value, %Token{kind: value, content: m, line: line, col: col})
+        {token, String.slice(text, len..-1//1), len}
+
+      nil ->
+        # No rule matched — emit the first character as a literal single-char token.
+        char = String.first(text)
+        {%Token{kind: char, content: char, line: line, col: col}, String.slice(text, 1..-1//1), 1}
+    end
+  end
+
+  # Extract #{...} interpolation expressions into `interpolations` and strip
+  # them from `content` so downstream consumers see only the static string parts.
+  # Nested braces (e.g. #{foo(%{a: 1})}) are left as-is in content — the
+  # lookahead in the scan rule ensures a match only when simple interpolations
+  # are present.
+  defp postprocess("<STR_INTERP>", token),
+    do: extract_interpolations(token, ~r/#\{([^}]*)\}/, ~r/#\{[^}]*\}/, quotes: :double)
+
+  defp postprocess("<STR_DOLLAR_INTERP>", token),
+    do: extract_interpolations(token, ~r/\$\{([^}]*)\}/, ~r/\$\{[^}]*\}/, quotes: :double)
+
+  defp postprocess("<STR_SWIFT_INTERP>", token),
+    do: extract_interpolations(token, ~r/\\\(([^)]*)\)/, ~r/\\\([^)]*\)/, quotes: :double)
+
+  defp postprocess("<BACKTICK_INTERP>", token),
+    do: extract_interpolations(token, ~r/\$\{([^}]*)\}/, ~r/\$\{[^}]*\}/, quotes: :backtick)
+
+  defp postprocess("<TRIP_QUOTES>", %Token{content: ~s(""")} = token),
+    do: %StringToken{
+      kind: StringToken.doc_kind(),
+      content: token.content,
+      line: token.line,
+      col: token.col,
+      multiline: true,
+      quotes: :double
+    }
+
+  defp postprocess("<TRIP_QUOTES>", token),
+    do: %StringToken{
+      kind: StringToken.doc_kind(),
+      content: token.content,
+      line: token.line,
+      col: token.col,
+      multiline: true,
+      quotes: :single
+    }
+
+  defp postprocess("<BACKTICK_STR>", token),
+    do: %StringToken{
+      kind: StringToken.kind(),
+      content: token.content,
+      line: token.line,
+      col: token.col,
+      quotes: :backtick
+    }
+
+  defp postprocess("<STR>", token) do
+    quotes = if String.starts_with?(token.content, "\""), do: :double, else: :single
+
+    %StringToken{
+      kind: StringToken.kind(),
+      content: token.content,
+      line: token.line,
+      col: token.col,
+      quotes: quotes
+    }
+  end
+
+  defp postprocess(_value, token), do: token
+
+  defp extract_interpolations(token, capture_regex, strip_regex, opts) do
+    quotes = Keyword.get(opts, :quotes, :double)
+
+    interpolations =
+      Regex.scan(capture_regex, token.content, capture: :all_but_first)
+      |> Enum.map(fn [expr] -> String.trim(expr) end)
+
+    %StringToken{
+      content: String.replace(token.content, strip_regex, ""),
+      line: token.line,
+      col: token.col,
+      interpolations: interpolations,
+      quotes: quotes
+    }
+  end
+end
diff --git a/lib/codeqa/ast/lexing/token_protocol.ex b/lib/codeqa/ast/lexing/token_protocol.ex
new file mode 100644
index 0000000..e38458d
--- /dev/null
+++ b/lib/codeqa/ast/lexing/token_protocol.ex
@@ -0,0 +1,59 @@
+defprotocol CodeQA.AST.Lexing.TokenProtocol do
+  @moduledoc """
+  Protocol for token structs emitted by `TokenNormalizer`.
+
+  Both `Token` and `StringToken` implement this protocol, so code that
+  processes token streams does not need to branch on the concrete struct type.
+
+  ## Functions
+
+  - `kind/1`    — normalized structural kind (`<ID>`, `<STR>`, `<NL>`, …)
+  - `content/1` — original source text before normalization
+  - `line/1`    — 1-based line number in the source file (`nil` for synthetic tokens)
+  - `col/1`     — 0-based byte offset from the start of the line (`nil` for synthetic tokens)
+  """
+
+  @doc "Returns the normalized structural kind of the token."
+  @spec kind(t) :: String.t()
+  def kind(token)
+
+  @doc "Returns the original source text of the token."
+  @spec content(t) :: String.t()
+  def content(token)
+
+  @doc "Returns the 1-based line number of the token, or `nil` for synthetic tokens."
+  @spec line(t) :: non_neg_integer() | nil
+  def line(token)
+
+  @doc "Returns the 0-based column offset of the token, or `nil` for synthetic tokens."
+  @spec col(t) :: non_neg_integer() | nil
+  def col(token)
+end
+
+defimpl CodeQA.AST.Lexing.TokenProtocol, for: CodeQA.AST.Lexing.Token do
+  def kind(%CodeQA.AST.Lexing.Token{kind: k}), do: k
+  def content(%CodeQA.AST.Lexing.Token{content: c}), do: c
+  def line(%CodeQA.AST.Lexing.Token{line: l}), do: l
+  def col(%CodeQA.AST.Lexing.Token{col: c}), do: c
+end
+
+defimpl CodeQA.AST.Lexing.TokenProtocol, for: CodeQA.AST.Lexing.StringToken do
+  def kind(%CodeQA.AST.Lexing.StringToken{kind: k}), do: k
+  def content(%CodeQA.AST.Lexing.StringToken{content: c}), do: c
+  def line(%CodeQA.AST.Lexing.StringToken{line: l}), do: l
+  def col(%CodeQA.AST.Lexing.StringToken{col: c}), do: c
+end
+
+defimpl CodeQA.AST.Lexing.TokenProtocol, for: CodeQA.AST.Lexing.NewlineToken do
+  def kind(%CodeQA.AST.Lexing.NewlineToken{kind: k}), do: k
+  def content(%CodeQA.AST.Lexing.NewlineToken{content: c}), do: c
+  def line(%CodeQA.AST.Lexing.NewlineToken{line: l}), do: l
+  def col(%CodeQA.AST.Lexing.NewlineToken{col: c}), do: c
+end
+
+defimpl CodeQA.AST.Lexing.TokenProtocol, for: CodeQA.AST.Lexing.WhitespaceToken do
+  def kind(%CodeQA.AST.Lexing.WhitespaceToken{kind: k}), do: k
+  def content(%CodeQA.AST.Lexing.WhitespaceToken{content: c}), do: c
+  def line(%CodeQA.AST.Lexing.WhitespaceToken{line: l}), do: l
+  def col(%CodeQA.AST.Lexing.WhitespaceToken{col: c}), do: c
+end
diff --git a/lib/codeqa/ast/lexing/whitespace_token.ex b/lib/codeqa/ast/lexing/whitespace_token.ex
new file mode 100644
index 0000000..cb23082
--- /dev/null
+++ b/lib/codeqa/ast/lexing/whitespace_token.ex
@@ -0,0 +1,29 @@
+defmodule CodeQA.AST.Lexing.WhitespaceToken do
+  @moduledoc """
+  A whitespace/indentation token emitted by `TokenNormalizer.normalize_structural/1`.
+
+  Represents one indentation unit (2 spaces or 1 tab) at the start of a line.
+
+  ## Fields
+
+  - `kind`    — always `"<WS>"`.
+  - `content` — the original source text for this indentation unit (`"  "`).
+  - `line`    — 1-based line number in the source file.
+  - `col`     — 0-based byte offset from the start of the line.
+  """
+
+  @kind "<WS>"
+
+  defstruct [:content, :line, :col, kind: @kind]
+
+  @doc "Returns the normalized kind string for whitespace tokens."
+  @spec kind() :: String.t()
+  def kind, do: @kind
+
+  @type t :: %__MODULE__{
+          kind: String.t(),
+          content: String.t(),
+          line: non_neg_integer() | nil,
+          col: non_neg_integer() | nil
+        }
+end
diff --git a/lib/codeqa/ast/nodes/attribute_node.ex b/lib/codeqa/ast/nodes/attribute_node.ex
new file mode 100644
index 0000000..dba171d
--- /dev/null
+++ b/lib/codeqa/ast/nodes/attribute_node.ex
@@ -0,0 +1,65 @@
+defmodule CodeQA.AST.Nodes.AttributeNode do
+  @moduledoc """
+  AST node for fields, constants, decorators, annotations, and typespecs.
+  Subsumes the previous :typespec node type (kind: :typespec).
+  """
+
+  alias CodeQA.AST.Enrichment.Node
+  alias CodeQA.AST.Lexing.{NewlineToken, WhitespaceToken}
+
+  defstruct [:tokens, :line_count, :children, :start_line, :end_line, :label, :name, :kind]
+
+  @type t :: %__MODULE__{
+          tokens: [term()],
+          line_count: non_neg_integer(),
+          children: [term()],
+          start_line: non_neg_integer() | nil,
+          end_line: non_neg_integer() | nil,
+          label: term() | nil,
+          name: String.t() | nil,
+          kind: :field | :constant | :decorator | :annotation | :typespec | nil
+        }
+
+  @typespec_attrs MapSet.new(~w[spec type typep opaque callback macrocallback])
+
+  @doc "Build an AttributeNode from a raw %Node{}, detecting :typespec kind from tokens."
+  @spec cast(Node.t()) :: t()
+  def cast(%Node{} = node) do
+    %__MODULE__{
+      tokens: node.tokens,
+      line_count: node.line_count,
+      children: node.children,
+      start_line: node.start_line,
+      end_line: node.end_line,
+      label: node.label,
+      kind: detect_kind(node.tokens)
+    }
+  end
+
+  defp detect_kind(tokens) do
+    tokens
+    |> Enum.drop_while(&(&1.kind in [WhitespaceToken.kind(), NewlineToken.kind()]))
+    |> case do
+      [%{kind: "@"}, %{kind: "<ID>", content: name} | _] ->
+        if MapSet.member?(@typespec_attrs, name), do: :typespec, else: nil
+
+      _ ->
+        nil
+    end
+  end
+
+  defimpl CodeQA.AST.Classification.NodeProtocol do
+    def tokens(n), do: n.tokens
+    def line_count(n), do: n.line_count
+    def children(n), do: n.children
+    def start_line(n), do: n.start_line
+    def end_line(n), do: n.end_line
+    def label(n), do: n.label
+
+    def flat_tokens(n) do
+      if Enum.empty?(n.children),
+        do: n.tokens,
+        else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+    end
+  end
+end
diff --git a/lib/codeqa/ast/nodes/code_node.ex b/lib/codeqa/ast/nodes/code_node.ex
new file mode 100644
index 0000000..1b26244
--- /dev/null
+++ b/lib/codeqa/ast/nodes/code_node.ex
@@ -0,0 +1,44 @@
+defmodule CodeQA.AST.Nodes.CodeNode do
+  @moduledoc "Catch-all AST node for unclassified code blocks."
+
+  alias CodeQA.AST.Enrichment.Node
+
+  defstruct [:tokens, :line_count, :children, :start_line, :end_line, :label]
+
+  @type t :: %__MODULE__{
+          tokens: [term()],
+          line_count: non_neg_integer(),
+          children: [term()],
+          start_line: non_neg_integer() | nil,
+          end_line: non_neg_integer() | nil,
+          label: term() | nil
+        }
+
+  @doc "Build a CodeNode from a raw %Node{}, copying all base fields."
+  @spec cast(Node.t()) :: t()
+  def cast(%Node{} = node) do
+    %__MODULE__{
+      tokens: node.tokens,
+      line_count: node.line_count,
+      children: node.children,
+      start_line: node.start_line,
+      end_line: node.end_line,
+      label: node.label
+    }
+  end
+
+  defimpl CodeQA.AST.Classification.NodeProtocol do
+    def tokens(n), do: n.tokens
+    def line_count(n), do: n.line_count
+    def children(n), do: n.children
+    def start_line(n), do: n.start_line
+    def end_line(n), do: n.end_line
+    def label(n), do: n.label
+
+    def flat_tokens(n) do
+      if Enum.empty?(n.children),
+        do: n.tokens,
+        else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+    end
+  end
+end
diff --git a/lib/codeqa/ast/nodes/doc_node.ex b/lib/codeqa/ast/nodes/doc_node.ex
new file mode 100644
index 0000000..2b6dbfd
--- /dev/null
+++ b/lib/codeqa/ast/nodes/doc_node.ex
@@ -0,0 +1,44 @@
+defmodule CodeQA.AST.Nodes.DocNode do
+  @moduledoc "AST node for documentation strings and comment blocks."
+
+  alias CodeQA.AST.Enrichment.Node
+
+  defstruct [:tokens, :line_count, :children, :start_line, :end_line, :label]
+
+  @type t :: %__MODULE__{
+          tokens: [term()],
+          line_count: non_neg_integer(),
+          children: [term()],
+          start_line: non_neg_integer() | nil,
+          end_line: non_neg_integer() | nil,
+          label: term() | nil
+        }
+
+  @doc "Build a DocNode from a raw %Node{}, copying all base fields."
+  @spec cast(Node.t()) :: t()
+  def cast(%Node{} = node) do
+    %__MODULE__{
+      tokens: node.tokens,
+      line_count: node.line_count,
+      children: node.children,
+      start_line: node.start_line,
+      end_line: node.end_line,
+      label: node.label
+    }
+  end
+
+  defimpl CodeQA.AST.Classification.NodeProtocol do
+    def tokens(n), do: n.tokens
+    def line_count(n), do: n.line_count
+    def children(n), do: n.children
+    def start_line(n), do: n.start_line
+    def end_line(n), do: n.end_line
+    def label(n), do: n.label
+
+    def flat_tokens(n) do
+      if Enum.empty?(n.children),
+        do: n.tokens,
+        else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+    end
+  end
+end
diff --git a/lib/codeqa/ast/nodes/function_node.ex b/lib/codeqa/ast/nodes/function_node.ex
new file mode 100644
index 0000000..6d91c88
--- /dev/null
+++ b/lib/codeqa/ast/nodes/function_node.ex
@@ -0,0 +1,57 @@
+defmodule CodeQA.AST.Nodes.FunctionNode do
+  @moduledoc "AST node for function, method, or callable definitions."
+
+  alias CodeQA.AST.Enrichment.Node
+
+  defstruct [
+    :tokens,
+    :line_count,
+    :children,
+    :start_line,
+    :end_line,
+    :label,
+    :name,
+    :arity,
+    :visibility
+  ]
+
+  @type t :: %__MODULE__{
+          tokens: [term()],
+          line_count: non_neg_integer(),
+          children: [term()],
+          start_line: non_neg_integer() | nil,
+          end_line: non_neg_integer() | nil,
+          label: term() | nil,
+          name: String.t() | nil,
+          arity: non_neg_integer() | nil,
+          visibility: :public | :private | nil
+        }
+
+  @doc "Build a FunctionNode from a raw %Node{}, copying all base fields. Type-specific fields default to nil."
+  @spec cast(Node.t()) :: t()
+  def cast(%Node{} = node) do
+    %__MODULE__{
+      tokens: node.tokens,
+      line_count: node.line_count,
+      children: node.children,
+      start_line: node.start_line,
+      end_line: node.end_line,
+      label: node.label
+    }
+  end
+
+  defimpl CodeQA.AST.Classification.NodeProtocol do
+    def tokens(n), do: n.tokens
+    def line_count(n), do: n.line_count
+    def children(n), do: n.children
+    def start_line(n), do: n.start_line
+    def end_line(n), do: n.end_line
+    def label(n), do: n.label
+
+    def flat_tokens(n) do
+      if Enum.empty?(n.children),
+        do: n.tokens,
+        else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+    end
+  end
+end
diff --git a/lib/codeqa/ast/nodes/import_node.ex b/lib/codeqa/ast/nodes/import_node.ex
new file mode 100644
index 0000000..999013d
--- /dev/null
+++ b/lib/codeqa/ast/nodes/import_node.ex
@@ -0,0 +1,45 @@
+defmodule CodeQA.AST.Nodes.ImportNode do
+  @moduledoc "AST node for import, require, use, alias, or include statements."
+
+  alias CodeQA.AST.Enrichment.Node
+
+  defstruct [:tokens, :line_count, :children, :start_line, :end_line, :label, :target]
+
+  @type t :: %__MODULE__{
+          tokens: [term()],
+          line_count: non_neg_integer(),
+          children: [term()],
+          start_line: non_neg_integer() | nil,
+          end_line: non_neg_integer() | nil,
+          label: term() | nil,
+          target: String.t() | nil
+        }
+
+  @doc "Build an ImportNode from a raw %Node{}, copying all base fields. Type-specific fields default to nil."
+  @spec cast(Node.t()) :: t()
+  def cast(%Node{} = node) do
+    %__MODULE__{
+      tokens: node.tokens,
+      line_count: node.line_count,
+      children: node.children,
+      start_line: node.start_line,
+      end_line: node.end_line,
+      label: node.label
+    }
+  end
+
+  defimpl CodeQA.AST.Classification.NodeProtocol do
+    def tokens(n), do: n.tokens
+    def line_count(n), do: n.line_count
+    def children(n), do: n.children
+    def start_line(n), do: n.start_line
+    def end_line(n), do: n.end_line
+    def label(n), do: n.label
+
+    def flat_tokens(n) do
+      if Enum.empty?(n.children),
+        do: n.tokens,
+        else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+    end
+  end
+end
diff --git a/lib/codeqa/ast/nodes/module_node.ex b/lib/codeqa/ast/nodes/module_node.ex
new file mode 100644
index 0000000..9ad3efb
--- /dev/null
+++ b/lib/codeqa/ast/nodes/module_node.ex
@@ -0,0 +1,46 @@
+defmodule CodeQA.AST.Nodes.ModuleNode do
+  @moduledoc "AST node for module, class, namespace, or struct definitions."
+
+  alias CodeQA.AST.Enrichment.Node
+
+  defstruct [:tokens, :line_count, :children, :start_line, :end_line, :label, :name, :kind]
+
+  @type t :: %__MODULE__{
+          tokens: [term()],
+          line_count: non_neg_integer(),
+          children: [term()],
+          start_line: non_neg_integer() | nil,
+          end_line: non_neg_integer() | nil,
+          label: term() | nil,
+          name: String.t() | nil,
+          kind: :class | :module | :namespace | :struct | nil
+        }
+
+  @doc "Build a ModuleNode from a raw %Node{}, copying all base fields. Type-specific fields default to nil."
+  @spec cast(Node.t()) :: t()
+  def cast(%Node{} = node) do
+    %__MODULE__{
+      tokens: node.tokens,
+      line_count: node.line_count,
+      children: node.children,
+      start_line: node.start_line,
+      end_line: node.end_line,
+      label: node.label
+    }
+  end
+
+  defimpl CodeQA.AST.Classification.NodeProtocol do
+    def tokens(n), do: n.tokens
+    def line_count(n), do: n.line_count
+    def children(n), do: n.children
+    def start_line(n), do: n.start_line
+    def end_line(n), do: n.end_line
+    def label(n), do: n.label
+
+    def flat_tokens(n) do
+      if Enum.empty?(n.children),
+        do: n.tokens,
+        else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+    end
+  end
+end
diff --git a/lib/codeqa/ast/nodes/test_node.ex b/lib/codeqa/ast/nodes/test_node.ex
new file mode 100644
index 0000000..4fc955c
--- /dev/null
+++ b/lib/codeqa/ast/nodes/test_node.ex
@@ -0,0 +1,45 @@
+defmodule CodeQA.AST.Nodes.TestNode do
+  @moduledoc "AST node for test cases, describe blocks, and it blocks."
+
+  alias CodeQA.AST.Enrichment.Node
+
+  defstruct [:tokens, :line_count, :children, :start_line, :end_line, :label, :description]
+
+  @type t :: %__MODULE__{
+          tokens: [term()],
+          line_count: non_neg_integer(),
+          children: [term()],
+          start_line: non_neg_integer() | nil,
+          end_line: non_neg_integer() | nil,
+          label: term() | nil,
+          description: String.t() | nil
+        }
+
+  @doc "Build a TestNode from a raw %Node{}, copying all base fields. Type-specific fields default to nil."
+  @spec cast(Node.t()) :: t()
+  def cast(%Node{} = node) do
+    %__MODULE__{
+      tokens: node.tokens,
+      line_count: node.line_count,
+      children: node.children,
+      start_line: node.start_line,
+      end_line: node.end_line,
+      label: node.label
+    }
+  end
+
+  defimpl CodeQA.AST.Classification.NodeProtocol do
+    def tokens(n), do: n.tokens
+    def line_count(n), do: n.line_count
+    def children(n), do: n.children
+    def start_line(n), do: n.start_line
+    def end_line(n), do: n.end_line
+    def label(n), do: n.label
+
+    def flat_tokens(n) do
+      if Enum.empty?(n.children),
+        do: n.tokens,
+        else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+    end
+  end
+end
diff --git a/lib/codeqa/ast/parsing/parser.ex b/lib/codeqa/ast/parsing/parser.ex
new file mode 100644
index 0000000..cb23a91
--- /dev/null
+++ b/lib/codeqa/ast/parsing/parser.ex
@@ -0,0 +1,233 @@
+defmodule CodeQA.AST.Parsing.Parser do
+  @moduledoc """
+  Recursively parses a token stream into a nested node tree.
+
+  Top-level nodes are found by splitting on blank lines and declaration keywords.
+  Each node is then recursively subdivided using enclosure rules (brackets,
+  colon-indentation) until no further subdivision is possible — forming an
+  arbitrarily-deep tree rather than a fixed two-level hierarchy.
+
+  ## Recursive parsing algorithm
+
+  `parse_block/3` is the recursive core:
+
+  1. Immediately create a `Node` spanning the whole token stream.
+  2. Apply enclosure rules to find sub-candidate streams.
+  3. **Idempotency check** — reject any enclosure that spans the entire stream
+     (e.g. `BracketRule` re-emitting its own input). This is the termination
+     condition: the node is a leaf when no strictly-smaller sub-candidates exist.
+  4. Recursively call `parse_block/3` on each sub-candidate to produce children.
+  5. Return the node with its children attached as `children`.
+
+  ## Design notes (from tree-sitter, ctags, lizard)
+
+  - **Recursive hierarchy** — replaces the old two-level (top + one level of sub-blocks)
+    model with an N-level tree. Each call to `parse_block/3` mirrors tree-sitter's
+    recursive descent: emit the node, then recurse into its contents.
+  - **Language detection by extension** — `language_from_path/1` follows ctags'
+    convention of inferring language from file extension.
+  - **Rule extensibility** — enclosure rules are selected per language via
+    `sub_block_rules/1`. Rules are composable and order-independent.
+  - **Error recovery** — mismatched brackets and malformed indentation are silently
+    skipped by individual rules. The parser emits partial nodes rather than failing,
+    consistent with tree-sitter's error-recovery philosophy.
+  """
+
+  alias CodeQA.AST.Enrichment.Node
+  alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.Language
+  alias CodeQA.AST.Lexing.{NewlineToken, WhitespaceToken}
+
+  alias CodeQA.AST.Signals.Structural.{
+    BlankLineSignal,
+    BracketSignal,
+    ColonIndentSignal,
+    KeywordSignal,
+    TripleQuoteSignal
+  }
+
+  @spec detect_blocks([CodeQA.AST.Lexing.Token.t()], module()) :: [Node.t()]
+  def detect_blocks([], _lang_mod), do: []
+
+  def detect_blocks(tokens, lang_mod) do
+    all_emissions =
+      SignalStream.run(
+        tokens,
+        [%TripleQuoteSignal{}, %BlankLineSignal{}, %KeywordSignal{}],
+        lang_mod
+      )
+      |> List.flatten()
+
+    triple_splits =
+      for {_, :split, :triple_split, v} <- all_emissions, do: v
+
+    protected_ranges = compute_protected_ranges(triple_splits)
+
+    split_points =
+      for(
+        {_, :split, name, v} <- all_emissions,
+        name in [:blank_split, :keyword_split],
+        not inside_protected?(v, protected_ranges),
+        do: v
+      )
+      |> Enum.concat(triple_splits)
+      |> Enum.uniq()
+      |> Enum.sort()
+
+    tokens
+    |> split_at(split_points)
+    |> Enum.reject(fn s -> Enum.empty?(s) or whitespace_only?(s) end)
+    |> merge_same_line_slices()
+    |> Enum.map(&parse_block(&1, lang_mod))
+  end
+
+  @spec language_module_for_path(String.t()) :: module()
+  def language_module_for_path(path), do: Language.detect(path)
+
+  @spec language_from_path(String.t()) :: atom()
+  def language_from_path(path),
+    do: path |> Language.detect() |> then(& &1.name()) |> String.to_atom()
+
+  # Recursively parse a token stream into a Node with nested children.
+  # Immediately creates a node spanning the whole stream, then attempts to
+  # subdivide it. Terminates when no strictly-smaller sub-candidates are found.
+  defp parse_block(tokens, lang_mod) do
+    start_line = block_start_line(tokens)
+    end_line = block_end_line(tokens)
+    line_count = if start_line && end_line, do: end_line - start_line + 1, else: 1
+
+    block = %Node{
+      tokens: tokens,
+      line_count: line_count,
+      children: [],
+      start_line: start_line,
+      end_line: end_line
+    }
+
+    case find_sub_candidates(tokens, lang_mod) do
+      [] ->
+        block
+
+      candidates ->
+        children = Enum.map(candidates, &parse_block(&1, lang_mod))
+        %{block | children: children}
+    end
+  end
+
+  # Collect enclosure regions from rules.
+  #
+  # If the token stream is itself a bracket pair (e.g. the stream IS `(foo, bar)`),
+  # we unwrap the outer brackets before running rules. Without this, BracketRule
+  # would only find the whole stream as a single enclosure — filtered by the
+  # idempotency check — and recursion would stop prematurely at every bracket level.
+  # Unwrapping lets us see the *inner* structure and keeps the tree growing deeper.
+  #
+  # Idempotency check: after unwrapping, reject any enclosure that still spans the
+  # entire search window (0..n-1), which would produce an infinite loop.
+  defp find_sub_candidates(tokens, lang_mod) do
+    {search_tokens, _} = maybe_unwrap_bracket(tokens)
+    n = length(search_tokens)
+
+    enclosure_signals =
+      if lang_mod.uses_colon_indent?() do
+        [%BracketSignal{}, %ColonIndentSignal{}]
+      else
+        [%BracketSignal{}]
+      end
+
+    SignalStream.run(search_tokens, enclosure_signals, lang_mod)
+    |> List.flatten()
+    |> Enum.filter(fn {_, group, _, _} -> group == :enclosure end)
+    |> Enum.map(fn {_, _, _, {s, e}} -> {s, e} end)
+    |> Enum.uniq()
+    |> Enum.sort()
+    |> Enum.reject(fn {s, e} -> s == 0 and e == n - 1 end)
+    |> Enum.map(fn {s, e} -> Enum.slice(search_tokens, s..e) end)
+    |> Enum.reject(&whitespace_only?/1)
+  end
+
+  @open_brackets MapSet.new(["(", "[", "{"])
+  @matching_close %{"(" => ")", "[" => "]", "{" => "}"}
+
+  # If the stream is a balanced bracket pair, return the inner tokens.
+  # Otherwise return the stream unchanged.
+  defp maybe_unwrap_bracket([first | rest] = tokens) do
+    last = List.last(tokens)
+
+    if last && MapSet.member?(@open_brackets, first.kind) &&
+         Map.get(@matching_close, first.kind) == last.kind do
+      {Enum.drop(rest, -1), 1}
+    else
+      {tokens, 0}
+    end
+  end
+
+  defp maybe_unwrap_bracket([]), do: {[], 0}
+
+  # Pairs consecutive triple-quote split indices into protected interior ranges.
+  # Uses chunk_every with :discard to safely handle odd counts (malformed input).
+  defp compute_protected_ranges(split_indices) do
+    split_indices
+    |> Enum.chunk_every(2, 2, :discard)
+    |> Enum.map(fn [a, b] -> {a + 1, b - 1} end)
+  end
+
+  defp inside_protected?(idx, ranges) do
+    Enum.any?(ranges, fn {lo, hi} -> idx >= lo and idx <= hi end)
+  end
+
+  # When TripleQuoteSignal splits `@doc """` mid-line, the tokens before the
+  # triple-quote land in one slice and the heredoc in the next — both on the same
+  # starting line. Merge adjacent slices that share a line boundary so `@doc """..."""`
+  # becomes a single token stream fed to parse_block rather than two separate nodes.
+  defp merge_same_line_slices([]), do: []
+  defp merge_same_line_slices([single]), do: [single]
+
+  defp merge_same_line_slices([slice_a, slice_b | rest]) do
+    last_line_a =
+      slice_a
+      |> Enum.reverse()
+      |> Enum.find(&(&1.kind not in [WhitespaceToken.kind(), NewlineToken.kind()]))
+      |> then(&(&1 && &1.line))
+
+    first_line_b =
+      slice_b
+      |> Enum.find(&(&1.kind not in [WhitespaceToken.kind(), NewlineToken.kind()]))
+      |> then(&(&1 && &1.line))
+
+    if last_line_a && first_line_b && last_line_a == first_line_b do
+      merge_same_line_slices([slice_a ++ slice_b | rest])
+    else
+      [slice_a | merge_same_line_slices([slice_b | rest])]
+    end
+  end
+
+  defp split_at(tokens, []), do: [tokens]
+
+  defp split_at(tokens, split_points) do
+    boundaries = [0 | split_points] ++ [length(tokens)]
+
+    boundaries
+    |> Enum.chunk_every(2, 1, :discard)
+    |> Enum.map(fn [start, stop] -> Enum.slice(tokens, start..(stop - 1)//1) end)
+  end
+
+  defp whitespace_only?(tokens) do
+    Enum.all?(tokens, &(&1.kind in [WhitespaceToken.kind(), NewlineToken.kind()]))
+  end
+
+  defp block_start_line([%{line: line} | _]), do: line
+  defp block_start_line([]), do: nil
+
+  defp block_end_line([]), do: nil
+
+  defp block_end_line(tokens) do
+    tokens
+    |> Enum.reverse()
+    |> Enum.find(&(&1.kind not in [WhitespaceToken.kind(), NewlineToken.kind()]))
+    |> case do
+      nil -> tokens |> List.last() |> Map.get(:line)
+      token -> token.line
+    end
+  end
+end
diff --git a/lib/codeqa/ast/parsing/signal.ex b/lib/codeqa/ast/parsing/signal.ex
new file mode 100644
index 0000000..dc2d19e
--- /dev/null
+++ b/lib/codeqa/ast/parsing/signal.ex
@@ -0,0 +1,44 @@
+defprotocol CodeQA.AST.Parsing.Signal do
+  @moduledoc """
+  Protocol for token-stream signal emitters.
+
+  A signal is a stateful detector that receives one token at a time and emits
+  zero or more named values. All signals run independently over the same token
+  stream — each gets its own full pass, carrying its own state.
+
+  ## Protocol functions
+
+  - `source/1`  — the implementing module; used for debugging emission traces
+  - `group/1`   — atom grouping this signal's emissions (e.g. `:split`, `:enclosure`)
+  - `init/2`    — returns initial state; called once before the token stream starts
+  - `emit/3`    — called per token; returns `{MapSet.t({name, value}), new_state}`
+
+  ## State
+
+  State is owned externally (in `SignalStream`) as a positionally-aligned list.
+  The signal defines the shape; the orchestrator threads it through unchanged.
+
+  ## No-op emission
+
+  To emit nothing for a token, return `{MapSet.new(), state}`.
+  """
+
+  @doc "The module that implements this signal — for debugging traces."
+  @spec source(t) :: module()
+  def source(signal)
+
+  @doc "Group atom for all emissions from this signal (e.g. :split, :enclosure)."
+  @spec group(t) :: atom()
+  def group(signal)
+
+  @doc "Returns the initial state for this signal."
+  @spec init(t, module()) :: term()
+  def init(signal, lang_mod)
+
+  @doc """
+  Called once per token. Returns a MapSet of `{name, value}` emission pairs
+  and the updated state.
+  """
+  @spec emit(t, token :: term(), state :: term()) :: {MapSet.t(), term()}
+  def emit(signal, token, state)
+end
diff --git a/lib/codeqa/ast/parsing/signal_registry.ex b/lib/codeqa/ast/parsing/signal_registry.ex
new file mode 100644
index 0000000..555de16
--- /dev/null
+++ b/lib/codeqa/ast/parsing/signal_registry.ex
@@ -0,0 +1,94 @@
+defmodule CodeQA.AST.Parsing.SignalRegistry do
+  @moduledoc """
+  Registry for structural and classification signals.
+
+  Use `default/0` for the standard signal set. Compose custom registries
+  with `register_structural/2` and `register_classification/2` for
+  language-specific or analysis-specific configurations.
+  """
+
+  alias CodeQA.AST.Signals.Structural.{
+    AccessModifierSignal,
+    AssignmentFunctionSignal,
+    BlankLineSignal,
+    BranchSplitSignal,
+    BracketSignal,
+    ColonIndentSignal,
+    CommentDividerSignal,
+    DecoratorSignal,
+    DedentToZeroSignal,
+    DocCommentLeadSignal,
+    KeywordSignal,
+    SQLBlockSignal,
+    TripleQuoteSignal
+  }
+
+  alias CodeQA.AST.Signals.Classification.{
+    AttributeSignal,
+    CommentDensitySignal,
+    ConfigSignal,
+    DataSignal,
+    DocSignal,
+    FunctionSignal,
+    ImportSignal,
+    ModuleSignal,
+    TestSignal,
+    TypeSignal
+  }
+
+  defstruct structural: [], classification: []
+
+  @type t :: %__MODULE__{
+          structural: [term()],
+          classification: [term()]
+        }
+
+  @spec new() :: t()
+  def new, do: %__MODULE__{}
+
+  @spec register_structural(t(), term()) :: t()
+  def register_structural(%__MODULE__{} = r, signal),
+    do: %{r | structural: r.structural ++ [signal]}
+
+  @spec register_classification(t(), term()) :: t()
+  def register_classification(%__MODULE__{} = r, signal),
+    do: %{r | classification: r.classification ++ [signal]}
+
+  @spec default() :: t()
+  def default do
+    new()
+    |> register_structural(%TripleQuoteSignal{})
+    |> register_structural(%BlankLineSignal{})
+    |> register_structural(%KeywordSignal{})
+    |> register_structural(%AccessModifierSignal{})
+    |> register_structural(%DecoratorSignal{})
+    |> register_structural(%CommentDividerSignal{})
+    |> register_structural(%DocCommentLeadSignal{})
+    |> register_structural(%AssignmentFunctionSignal{})
+    |> register_structural(%DedentToZeroSignal{})
+    |> register_structural(%BranchSplitSignal{})
+    |> register_structural(%BracketSignal{})
+    |> register_classification(%DocSignal{})
+    |> register_classification(%TestSignal{})
+    |> register_classification(%FunctionSignal{})
+    |> register_classification(%ModuleSignal{})
+    |> register_classification(%ImportSignal{})
+    |> register_classification(%AttributeSignal{})
+    |> register_classification(%TypeSignal{})
+    |> register_classification(%ConfigSignal{})
+    |> register_classification(%DataSignal{})
+    |> register_classification(%CommentDensitySignal{})
+  end
+
+  @spec python() :: t()
+  def python do
+    r = default()
+    %{r | structural: r.structural ++ [%ColonIndentSignal{}]}
+  end
+
+  @spec sql() :: t()
+  def sql do
+    r = default()
+    %{r | structural: r.structural ++ [%SQLBlockSignal{}]}
+  end
+end
diff --git a/lib/codeqa/ast/parsing/signal_stream.ex b/lib/codeqa/ast/parsing/signal_stream.ex
new file mode 100644
index 0000000..935cbc2
--- /dev/null
+++ b/lib/codeqa/ast/parsing/signal_stream.ex
@@ -0,0 +1,54 @@
+defmodule CodeQA.AST.Parsing.SignalStream do
+  @moduledoc """
+  Runs a list of `Signal` implementations over a token stream.
+
+  Each signal receives its own full pass over the token stream and accumulates
+  its own state. Signals are independent — no shared state, no cross-signal
+  coordination.
+
+  ## Return value
+
+  Returns a list of emission lists, one per signal, in the same order as the
+  input signal list. Each emission is a 4-tuple:
+
+      {source, group, name, value}
+
+  ## Usage
+
+      SignalStream.run(tokens, [%BlankLineSignal{}, %KeywordSignal{}], [])
+      # => [[{BlankLineSignal, :split, :blank_split, 5}, ...], [...]]
+  """
+
+  alias CodeQA.AST.Parsing.Signal
+
+  @spec run([term()], [term()], module()) :: [list()]
+  def run(tokens, signals, lang_mod) do
+    prevs = [nil | tokens]
+    nexts = Enum.drop(tokens, 1) ++ [nil]
+    triples = Enum.zip_with([prevs, tokens, nexts], fn [p, c, n] -> {p, c, n} end)
+
+    Enum.map(signals, fn signal ->
+      init_state = Signal.init(signal, lang_mod)
+      source = Signal.source(signal)
+      group = Signal.group(signal)
+
+      {_final_state, emissions} =
+        Enum.reduce_while(triples, {init_state, []}, fn triple, {state, acc} ->
+          {emitted, new_state} = Signal.emit(signal, triple, state)
+
+          new_acc =
+            emitted
+            |> Enum.map(fn {name, value} -> {source, group, name, value} end)
+            |> Enum.reduce(acc, fn e, a -> [e | a] end)
+
+          if new_state == :halt do
+            {:halt, {new_state, new_acc}}
+          else
+            {:cont, {new_state, new_acc}}
+          end
+        end)
+
+      Enum.reverse(emissions)
+    end)
+  end
+end
diff --git a/lib/codeqa/ast/signals/classification/attribute_signal.ex b/lib/codeqa/ast/signals/classification/attribute_signal.ex
new file mode 100644
index 0000000..18a52cd
--- /dev/null
+++ b/lib/codeqa/ast/signals/classification/attribute_signal.ex
@@ -0,0 +1,66 @@
+defmodule CodeQA.AST.Signals.Classification.AttributeSignal do
+  @moduledoc """
+  Classification signal — votes `:attribute` when an `@identifier` pattern
+  appears at indent 0.
+
+  Weights:
+  - 3 for Elixir typespec attributes (@spec, @type, @typep, @opaque, @callback, @macrocallback)
+  - 2 for all other @name attributes
+
+  Skips @doc and @moduledoc — those nodes contain <DOC> tokens and are handled by DocSignal.
+  Emits at most one vote per token stream.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    @nl CodeQA.AST.Lexing.NewlineToken.kind()
+    @ws CodeQA.AST.Lexing.WhitespaceToken.kind()
+    @typespec_attrs MapSet.new(~w[spec type typep opaque callback macrocallback])
+    @skip_attrs MapSet.new(~w[doc moduledoc])
+
+    def source(_), do: CodeQA.AST.Signals.Classification.AttributeSignal
+    def group(_), do: :classification
+
+    def init(_, _lang_mod),
+      do: %{at_line_start: true, indent: 0, saw_at: false, voted: false}
+
+    def emit(_, _, %{voted: true} = state), do: {MapSet.new(), state}
+
+    def emit(_, {_prev, token, _next}, %{at_line_start: als, indent: ind, saw_at: saw_at} = state) do
+      case token.kind do
+        @nl ->
+          {MapSet.new(), %{state | at_line_start: true, indent: 0, saw_at: false}}
+
+        @ws when als ->
+          {MapSet.new(), %{state | indent: ind + 1, at_line_start: true}}
+
+        @ws ->
+          {MapSet.new(), state}
+
+        "@" when ind == 0 ->
+          {MapSet.new(), %{state | saw_at: true, at_line_start: false}}
+
+        "<ID>" when saw_at ->
+          name = token.content
+
+          cond do
+            MapSet.member?(@skip_attrs, name) ->
+              # @doc/@moduledoc: let DocSignal handle via <DOC> tokens
+              {MapSet.new(), %{state | saw_at: false, at_line_start: false, voted: true}}
+
+            MapSet.member?(@typespec_attrs, name) ->
+              {MapSet.new([{:attribute_vote, 3}]),
+               %{state | saw_at: false, at_line_start: false, voted: true}}
+
+            true ->
+              {MapSet.new([{:attribute_vote, 2}]),
+               %{state | saw_at: false, at_line_start: false, voted: true}}
+          end
+
+        _ ->
+          {MapSet.new(), %{state | saw_at: false, at_line_start: false}}
+      end
+    end
+  end
+end
diff --git a/lib/codeqa/ast/signals/classification/comment_density_signal.ex b/lib/codeqa/ast/signals/classification/comment_density_signal.ex
new file mode 100644
index 0000000..cc3614f
--- /dev/null
+++ b/lib/codeqa/ast/signals/classification/comment_density_signal.ex
@@ -0,0 +1,61 @@
+defmodule CodeQA.AST.Signals.Classification.CommentDensitySignal do
+  @moduledoc """
+  Classification signal — votes `:comment` when more than 60% of non-blank
+  lines begin with a comment prefix.
+
+  Requires `comment_prefixes: [String.t()]` in opts (from the language
+  module). Returns no vote if no prefixes are configured.
+
+  Emits at the end of the stream.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    @nl CodeQA.AST.Lexing.NewlineToken.kind()
+    @ws CodeQA.AST.Lexing.WhitespaceToken.kind()
+    def source(_), do: CodeQA.AST.Signals.Classification.CommentDensitySignal
+    def group(_), do: :classification
+
+    def init(_, lang_mod) do
+      prefixes = MapSet.new(lang_mod.comment_prefixes())
+      %{prefixes: prefixes, at_line_start: true, comment_lines: 0, total_lines: 0}
+    end
+
+    def emit(_, {_prev, token, next}, state) do
+      %{prefixes: prefixes, at_line_start: als} = state
+
+      state =
+        case token.kind do
+          @nl ->
+            %{state | at_line_start: true}
+
+          @ws ->
+            state
+
+          _ when als ->
+            is_comment = MapSet.member?(prefixes, token.content)
+
+            %{
+              state
+              | at_line_start: false,
+                total_lines: state.total_lines + 1,
+                comment_lines: state.comment_lines + if(is_comment, do: 1, else: 0)
+            }
+
+          _ ->
+            %{state | at_line_start: false}
+        end
+
+      if next == nil and map_size(prefixes) > 0 and state.total_lines > 0 do
+        if state.comment_lines / state.total_lines > 0.6 do
+          {MapSet.new([{:comment_vote, 2}]), :halt}
+        else
+          {MapSet.new(), state}
+        end
+      else
+        {MapSet.new(), state}
+      end
+    end
+  end
+end
diff --git a/lib/codeqa/ast/signals/classification/config_signal.ex b/lib/codeqa/ast/signals/classification/config_signal.ex
new file mode 100644
index 0000000..d6453b1
--- /dev/null
+++ b/lib/codeqa/ast/signals/classification/config_signal.ex
@@ -0,0 +1,54 @@
+defmodule CodeQA.AST.Signals.Classification.ConfigSignal do
+  @moduledoc """
+  Classification signal — votes `:config` when a configuration keyword
+  appears at indent 0 and bracket depth 0.
+
+  Matches `config` (Elixir Mix.Config), `configure`, `settings`, `options`,
+  `defaults`. Emits at most one vote.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    @nl CodeQA.AST.Lexing.NewlineToken.kind()
+    @ws CodeQA.AST.Lexing.WhitespaceToken.kind()
+    @config_keywords MapSet.new(["config", "configure", "settings", "options", "defaults"])
+    def source(_), do: CodeQA.AST.Signals.Classification.ConfigSignal
+    def group(_), do: :classification
+
+    def init(_, _lang_mod),
+      do: %{at_line_start: true, indent: 0, bracket_depth: 0, is_first: true}
+
+    def emit(_, {_prev, token, _next}, state) do
+      %{at_line_start: als, indent: ind, bracket_depth: bd, is_first: first} = state
+
+      case token.kind do
+        @nl ->
+          {MapSet.new(), %{state | at_line_start: true, indent: 0}}
+
+        @ws when als ->
+          {MapSet.new(), %{state | indent: ind + 1, at_line_start: true}}
+
+        @ws ->
+          {MapSet.new(), state}
+
+        v when v in ["(", "[", "{"] ->
+          {MapSet.new(), %{state | bracket_depth: bd + 1, at_line_start: false, is_first: false}}
+
+        v when v in [")", "]", "}"] ->
+          _ = v
+
+          {MapSet.new(),
+           %{state | bracket_depth: max(0, bd - 1), at_line_start: false, is_first: false}}
+
+        _ ->
+          if ind == 0 and bd == 0 and MapSet.member?(@config_keywords, token.content) do
+            weight = if first, do: 3, else: 1
+            {MapSet.new([{:config_vote, weight}]), :halt}
+          else
+            {MapSet.new(), %{state | at_line_start: false, is_first: false}}
+          end
+      end
+    end
+  end
+end
diff --git a/lib/codeqa/ast/signals/classification/data_signal.ex b/lib/codeqa/ast/signals/classification/data_signal.ex
new file mode 100644
index 0000000..1d6aa77
--- /dev/null
+++ b/lib/codeqa/ast/signals/classification/data_signal.ex
@@ -0,0 +1,67 @@
+defmodule CodeQA.AST.Signals.Classification.DataSignal do
+  @moduledoc """
+  Classification signal — votes `:data` when a token stream consists primarily
+  of literal values (`<STR>`, `<NUM>`) with no control-flow keywords.
+
+  Emits at the end of the stream (when `next == nil`). Votes only when
+  literal ratio > 0.6 and no control-flow keywords were seen.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    @str CodeQA.AST.Lexing.StringToken.kind()
+    @control_flow MapSet.new([
+                    "if",
+                    "else",
+                    "elsif",
+                    "elif",
+                    "unless",
+                    "for",
+                    "while",
+                    "do",
+                    "case",
+                    "when",
+                    "cond",
+                    "switch",
+                    "loop",
+                    "until"
+                  ])
+    def source(_), do: CodeQA.AST.Signals.Classification.DataSignal
+    def group(_), do: :classification
+
+    def init(_, _lang_mod),
+      do: %{literal_count: 0, id_count: 0, has_control_flow: false}
+
+    def emit(_, {_prev, token, next}, state) do
+      state =
+        case token.kind do
+          kind when kind in [@str, "<NUM>"] ->
+            %{state | literal_count: state.literal_count + 1}
+
+          "<ID>" ->
+            if MapSet.member?(@control_flow, token.content) do
+              %{state | has_control_flow: true, id_count: state.id_count + 1}
+            else
+              %{state | id_count: state.id_count + 1}
+            end
+
+          _ ->
+            state
+        end
+
+      if next == nil do
+        total = state.literal_count + state.id_count
+
+        if total > 0 and not state.has_control_flow and
+             state.literal_count / total > 0.6 do
+          {MapSet.new([{:data_vote, 2}]), :halt}
+        else
+          {MapSet.new(), state}
+        end
+      else
+        {MapSet.new(), state}
+      end
+    end
+  end
+end
diff --git a/lib/codeqa/ast/signals/classification/doc_signal.ex b/lib/codeqa/ast/signals/classification/doc_signal.ex
new file mode 100644
index 0000000..615cf55
--- /dev/null
+++ b/lib/codeqa/ast/signals/classification/doc_signal.ex
@@ -0,0 +1,29 @@
+defmodule CodeQA.AST.Signals.Classification.DocSignal do
+  @moduledoc """
+  Classification signal — votes `:doc` when a `<DOC>` (triple-quoted string) token
+  is found anywhere in the node's token stream.
+
+  Weight: 3 (unambiguous — triple-quoted strings are documentation).
+  Emits at most one vote per token stream.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    @doc_kind CodeQA.AST.Lexing.StringToken.doc_kind()
+    def source(_), do: CodeQA.AST.Signals.Classification.DocSignal
+    def group(_), do: :classification
+
+    def init(_, _lang_mod), do: %{voted: false}
+
+    def emit(_, _, %{voted: true} = state), do: {MapSet.new(), state}
+
+    def emit(_, {_prev, token, _next}, state) do
+      if token.kind == @doc_kind do
+        {MapSet.new([{:doc_vote, 3}]), %{state | voted: true}}
+      else
+        {MapSet.new(), state}
+      end
+    end
+  end
+end
diff --git a/lib/codeqa/ast/signals/classification/function_signal.ex b/lib/codeqa/ast/signals/classification/function_signal.ex
new file mode 100644
index 0000000..ca261ce
--- /dev/null
+++ b/lib/codeqa/ast/signals/classification/function_signal.ex
@@ -0,0 +1,72 @@
+defmodule CodeQA.AST.Signals.Classification.FunctionSignal do
+  @moduledoc """
+  Classification signal — votes `:function` when a function definition keyword
+  appears at indent 0 and bracket depth 0.
+
+  Weights:
+  - 3 when it is the first content token of the block (strong match)
+  - 1 when found later in the block (weak match, e.g. after a leading comment)
+
+  Does NOT include module/class/namespace keywords (handled by ModuleSignal) or
+  test macros like `test`/`describe` (handled by TestSignal).
+  Emits at most one vote per token stream.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    @nl CodeQA.AST.Lexing.NewlineToken.kind()
+    @ws CodeQA.AST.Lexing.WhitespaceToken.kind()
+    def source(_), do: CodeQA.AST.Signals.Classification.FunctionSignal
+    def group(_), do: :classification
+
+    def init(_, lang_mod) do
+      %{
+        at_line_start: true,
+        indent: 0,
+        bracket_depth: 0,
+        is_first: true,
+        voted: false,
+        keywords: CodeQA.Language.function_keywords(lang_mod)
+      }
+    end
+
+    def emit(_, _, %{voted: true} = state), do: {MapSet.new(), state}
+
+    def emit(
+          _,
+          {_prev, token, _next},
+          %{at_line_start: als, indent: ind, bracket_depth: bd, is_first: first} = state
+        ) do
+      case token.kind do
+        @nl ->
+          {MapSet.new(), %{state | at_line_start: true, indent: 0}}
+
+        @ws when als ->
+          {MapSet.new(), %{state | indent: ind + 1, at_line_start: true}}
+
+        @ws ->
+          {MapSet.new(), state}
+
+        v when v in ["(", "[", "{"] ->
+          {MapSet.new(), %{state | bracket_depth: bd + 1, is_first: false, at_line_start: false}}
+
+        v when v in [")", "]", "}"] ->
+          _ = v
+
+          {MapSet.new(),
+           %{state | bracket_depth: max(0, bd - 1), is_first: false, at_line_start: false}}
+
+        _ ->
+          if ind == 0 and bd == 0 and MapSet.member?(state.keywords, token.content) do
+            weight = if first, do: 3, else: 1
+
+            {MapSet.new([{:function_vote, weight}]),
+             %{state | is_first: false, at_line_start: false, voted: true}}
+          else
+            {MapSet.new(), %{state | is_first: false, at_line_start: false}}
+          end
+      end
+    end
+  end
+end
diff --git a/lib/codeqa/ast/signals/classification/import_signal.ex b/lib/codeqa/ast/signals/classification/import_signal.ex
new file mode 100644
index 0000000..b6ad524
--- /dev/null
+++ b/lib/codeqa/ast/signals/classification/import_signal.ex
@@ -0,0 +1,62 @@
+defmodule CodeQA.AST.Signals.Classification.ImportSignal do
+  @moduledoc """
+  Classification signal — votes `:import` when an import/require/use/alias keyword
+  appears at indent 0.
+
+  Weights:
+  - 3 when it is the first content token of the block (strong match)
+  - 1 when found later in the block
+
+  Covers: Elixir (import, require, use, alias), Python (import, from),
+  JavaScript/Go (import, package), C# (using), Ruby/Lua (require, include).
+  Emits at most one vote per token stream.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    @nl CodeQA.AST.Lexing.NewlineToken.kind()
+    @ws CodeQA.AST.Lexing.WhitespaceToken.kind()
+    def source(_), do: CodeQA.AST.Signals.Classification.ImportSignal
+    def group(_), do: :classification
+
+    def init(_, lang_mod) do
+      %{
+        at_line_start: true,
+        indent: 0,
+        is_first: true,
+        voted: false,
+        keywords: CodeQA.Language.import_keywords(lang_mod)
+      }
+    end
+
+    def emit(_, _, %{voted: true} = state), do: {MapSet.new(), state}
+
+    def emit(
+          _,
+          {_prev, token, _next},
+          %{at_line_start: als, indent: ind, is_first: first} = state
+        ) do
+      case token.kind do
+        @nl ->
+          {MapSet.new(), %{state | at_line_start: true, indent: 0}}
+
+        @ws when als ->
+          {MapSet.new(), %{state | indent: ind + 1, at_line_start: true}}
+
+        @ws ->
+          {MapSet.new(), state}
+
+        _ ->
+          if ind == 0 and MapSet.member?(state.keywords, token.content) do
+            weight = if first, do: 3, else: 1
+
+            {MapSet.new([{:import_vote, weight}]),
+             %{state | is_first: false, at_line_start: false, voted: true}}
+          else
+            {MapSet.new(), %{state | is_first: false, at_line_start: false}}
+          end
+      end
+    end
+  end
+end
diff --git a/lib/codeqa/ast/signals/classification/module_signal.ex b/lib/codeqa/ast/signals/classification/module_signal.ex
new file mode 100644
index 0000000..e58a150
--- /dev/null
+++ b/lib/codeqa/ast/signals/classification/module_signal.ex
@@ -0,0 +1,71 @@
+defmodule CodeQA.AST.Signals.Classification.ModuleSignal do
+  @moduledoc """
+  Classification signal — votes `:module` when a module/class/namespace definition
+  keyword appears at indent 0 and bracket depth 0.
+
+  Weights:
+  - 3 when it is the first content token of the block (strong match)
+  - 1 when found later in the block
+
+  Keyword set is disjoint from FunctionSignal and TestSignal to avoid conflicts.
+  Emits at most one vote per token stream.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    @nl CodeQA.AST.Lexing.NewlineToken.kind()
+    @ws CodeQA.AST.Lexing.WhitespaceToken.kind()
+    def source(_), do: CodeQA.AST.Signals.Classification.ModuleSignal
+    def group(_), do: :classification
+
+    def init(_, lang_mod) do
+      %{
+        at_line_start: true,
+        indent: 0,
+        bracket_depth: 0,
+        is_first: true,
+        voted: false,
+        keywords: CodeQA.Language.module_keywords(lang_mod)
+      }
+    end
+
+    def emit(_, _, %{voted: true} = state), do: {MapSet.new(), state}
+
+    def emit(
+          _,
+          {_prev, token, _next},
+          %{at_line_start: als, indent: ind, bracket_depth: bd, is_first: first} = state
+        ) do
+      case token.kind do
+        @nl ->
+          {MapSet.new(), %{state | at_line_start: true, indent: 0}}
+
+        @ws when als ->
+          {MapSet.new(), %{state | indent: ind + 1, at_line_start: true}}
+
+        @ws ->
+          {MapSet.new(), state}
+
+        v when v in ["(", "[", "{"] ->
+          {MapSet.new(), %{state | bracket_depth: bd + 1, is_first: false, at_line_start: false}}
+
+        v when v in [")", "]", "}"] ->
+          _ = v
+
+          {MapSet.new(),
+           %{state | bracket_depth: max(0, bd - 1), is_first: false, at_line_start: false}}
+
+        _ ->
+          if ind == 0 and bd == 0 and MapSet.member?(state.keywords, token.content) do
+            weight = if first, do: 3, else: 1
+
+            {MapSet.new([{:module_vote, weight}]),
+             %{state | is_first: false, at_line_start: false, voted: true}}
+          else
+            {MapSet.new(), %{state | is_first: false, at_line_start: false}}
+          end
+      end
+    end
+  end
+end
diff --git a/lib/codeqa/ast/signals/classification/test_signal.ex b/lib/codeqa/ast/signals/classification/test_signal.ex
new file mode 100644
index 0000000..b9d5a8c
--- /dev/null
+++ b/lib/codeqa/ast/signals/classification/test_signal.ex
@@ -0,0 +1,63 @@
+defmodule CodeQA.AST.Signals.Classification.TestSignal do
+  @moduledoc """
+  Classification signal — votes `:test` when a test block keyword appears at
+  indent 0.
+
+  Weights:
+  - 3 when it is the first content token of the block (strong match)
+  - 1 when found later in the block
+
+  Covers: ExUnit (test, describe), RSpec/Jest/Mocha (it, context, describe),
+  Cucumber (scenario, given, feature). `test` takes priority over
+  FunctionSignal — Elixir test macros look like function calls but are test blocks.
+  Emits at most one vote per token stream.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    @nl CodeQA.AST.Lexing.NewlineToken.kind()
+    @ws CodeQA.AST.Lexing.WhitespaceToken.kind()
+    def source(_), do: CodeQA.AST.Signals.Classification.TestSignal
+    def group(_), do: :classification
+
+    def init(_, lang_mod) do
+      %{
+        at_line_start: true,
+        indent: 0,
+        is_first: true,
+        voted: false,
+        keywords: CodeQA.Language.test_keywords(lang_mod)
+      }
+    end
+
+    def emit(_, _, %{voted: true} = state), do: {MapSet.new(), state}
+
+    def emit(
+          _,
+          {_prev, token, _next},
+          %{at_line_start: als, indent: ind, is_first: first} = state
+        ) do
+      case token.kind do
+        @nl ->
+          {MapSet.new(), %{state | at_line_start: true, indent: 0}}
+
+        @ws when als ->
+          {MapSet.new(), %{state | indent: ind + 1, at_line_start: true}}
+
+        @ws ->
+          {MapSet.new(), state}
+
+        _ ->
+          if ind == 0 and MapSet.member?(state.keywords, token.content) do
+            weight = if first, do: 3, else: 1
+
+            {MapSet.new([{:test_vote, weight}]),
+             %{state | is_first: false, at_line_start: false, voted: true}}
+          else
+            {MapSet.new(), %{state | is_first: false, at_line_start: false}}
+          end
+      end
+    end
+  end
+end
diff --git a/lib/codeqa/ast/signals/classification/type_signal.ex b/lib/codeqa/ast/signals/classification/type_signal.ex
new file mode 100644
index 0000000..0acf6ad
--- /dev/null
+++ b/lib/codeqa/ast/signals/classification/type_signal.ex
@@ -0,0 +1,49 @@
+defmodule CodeQA.AST.Signals.Classification.TypeSignal do
+  @moduledoc """
+  Classification signal — votes `:type` when an Elixir type definition
+  attribute (`@type`, `@typep`, `@opaque`) appears at indent 0.
+
+  Emits at most one vote. Complements `AttributeSignal`, which handles
+  `@spec`, `@doc`, and other attributes.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    @nl CodeQA.AST.Lexing.NewlineToken.kind()
+    @ws CodeQA.AST.Lexing.WhitespaceToken.kind()
+    @type_attrs MapSet.new(["type", "typep", "opaque"])
+    def source(_), do: CodeQA.AST.Signals.Classification.TypeSignal
+    def group(_), do: :classification
+
+    def init(_, _lang_mod),
+      do: %{at_line_start: true, indent: 0, saw_at: false, is_first: true}
+
+    def emit(_, {_prev, token, _next}, state) do
+      case token.kind do
+        @nl ->
+          {MapSet.new(), %{state | at_line_start: true, indent: 0, saw_at: false}}
+
+        @ws when state.at_line_start ->
+          {MapSet.new(), %{state | indent: state.indent + 1, at_line_start: true}}
+
+        @ws ->
+          {MapSet.new(), state}
+
+        "@" when state.indent == 0 ->
+          {MapSet.new(), %{state | saw_at: true, at_line_start: false}}
+
+        _ when state.saw_at and state.indent == 0 ->
+          if MapSet.member?(@type_attrs, token.content) do
+            weight = if state.is_first, do: 3, else: 1
+            {MapSet.new([{:type_vote, weight}]), :halt}
+          else
+            {MapSet.new(), %{state | saw_at: false, is_first: false, at_line_start: false}}
+          end
+
+        _ ->
+          {MapSet.new(), %{state | saw_at: false, is_first: false, at_line_start: false}}
+      end
+    end
+  end
+end
diff --git a/lib/codeqa/ast/signals/structural/access_modifier_signal.ex b/lib/codeqa/ast/signals/structural/access_modifier_signal.ex
new file mode 100644
index 0000000..43ed068
--- /dev/null
+++ b/lib/codeqa/ast/signals/structural/access_modifier_signal.ex
@@ -0,0 +1,80 @@
+defmodule CodeQA.AST.Signals.Structural.AccessModifierSignal do
+  alias CodeQA.AST.Lexing.NewlineToken
+  alias CodeQA.AST.Lexing.WhitespaceToken
+
+  @moduledoc """
+  Emits `:access_modifier_split` when an access modifier keyword appears at line
+  start with bracket_depth == 0.
+
+  Unlike `KeywordSignal`, this does NOT require indentation level 0, so it
+  detects class members inside bracket enclosures (e.g. `public void foo()` inside
+  a `class Foo { ... }` body).
+
+  When `opts[:language_module]` is set, uses that language's
+  `access_modifiers/0` callback.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    def source(_), do: CodeQA.AST.Signals.Structural.AccessModifierSignal
+    def group(_), do: :split
+
+    def init(_, lang_mod) do
+      modifiers = CodeQA.Language.access_modifiers(lang_mod)
+      %{idx: 0, bracket_depth: 0, at_line_start: true, seen_content: false, modifiers: modifiers}
+    end
+
+    def emit(_, {_, %NewlineToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, at_line_start: true}}
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx, at_line_start: true} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, at_line_start: true}}
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1}}
+
+    def emit(_, {_, %{kind: k}, _}, %{idx: idx, bracket_depth: bd} = state)
+        when k in ["(", "[", "{"],
+        do:
+          {MapSet.new(),
+           %{
+             state
+             | idx: idx + 1,
+               bracket_depth: bd + 1,
+               seen_content: true,
+               at_line_start: false
+           }}
+
+    def emit(_, {_, %{kind: k}, _}, %{idx: idx, bracket_depth: bd} = state)
+        when k in [")", "]", "}"],
+        do:
+          {MapSet.new(),
+           %{
+             state
+             | idx: idx + 1,
+               bracket_depth: max(0, bd - 1),
+               seen_content: true,
+               at_line_start: false
+           }}
+
+    def emit(_, {_, token, _}, %{idx: idx} = state) do
+      base = %{state | idx: idx + 1, seen_content: true, at_line_start: false}
+
+      emissions =
+        if modifier_split?(state, token),
+          do: MapSet.new([{:access_modifier_split, idx}]),
+          else: MapSet.new()
+
+      {emissions, base}
+    end
+
+    defp modifier_split?(
+           %{seen_content: true, bracket_depth: 0, at_line_start: true, modifiers: m},
+           %{content: c}
+         ),
+         do: MapSet.member?(m, c)
+
+    defp modifier_split?(_, _), do: false
+  end
+end
diff --git a/lib/codeqa/ast/signals/structural/assignment_function_signal.ex b/lib/codeqa/ast/signals/structural/assignment_function_signal.ex
new file mode 100644
index 0000000..a778d55
--- /dev/null
+++ b/lib/codeqa/ast/signals/structural/assignment_function_signal.ex
@@ -0,0 +1,135 @@
+defmodule CodeQA.AST.Signals.Structural.AssignmentFunctionSignal do
+  alias CodeQA.AST.Lexing.NewlineToken
+  alias CodeQA.AST.Lexing.WhitespaceToken
+
+  @moduledoc """
+  Emits `:assignment_function_split` when a top-level assignment to a function
+  is detected at indent 0 and bracket depth 0.
+
+  Covers patterns such as:
+  - `identifier = function(...) {}`
+  - `identifier = async function(...) {}`
+  - `identifier = (...) => {}`
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    def source(_), do: CodeQA.AST.Signals.Structural.AssignmentFunctionSignal
+    def group(_), do: :split
+
+    def init(_, _lang_mod) do
+      %{
+        idx: 0,
+        indent: 0,
+        bracket_depth: 0,
+        at_line_start: true,
+        seen_content: false,
+        phase: :idle
+      }
+    end
+
+    def emit(_, {_, %NewlineToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, indent: 0, at_line_start: true, phase: :idle}}
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx, indent: i, at_line_start: true} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, indent: i + 1, at_line_start: true}}
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1}}
+
+    def emit(_, {_, %{kind: k}, _}, %{idx: idx, bracket_depth: bd, phase: phase} = state)
+        when k in ["(", "[", "{"] do
+      new_bd = bd + 1
+      new_phase = advance_phase_open(phase, k)
+
+      {MapSet.new(),
+       %{
+         state
+         | idx: idx + 1,
+           bracket_depth: new_bd,
+           at_line_start: false,
+           seen_content: true,
+           phase: new_phase
+       }}
+    end
+
+    def emit(_, {_, %{kind: k}, _}, %{idx: idx, bracket_depth: bd, phase: phase} = state)
+        when k in [")", "]", "}"] do
+      new_bd = max(0, bd - 1)
+      new_phase = advance_phase_close(phase, k)
+
+      {MapSet.new(),
+       %{
+         state
+         | idx: idx + 1,
+           bracket_depth: new_bd,
+           at_line_start: false,
+           seen_content: true,
+           phase: new_phase
+       }}
+    end
+
+    def emit(
+          _,
+          {_, token, _},
+          %{
+            idx: idx,
+            seen_content: sc,
+            indent: i,
+            bracket_depth: bd,
+            at_line_start: als,
+            phase: phase
+          } = state
+        ) do
+      {emissions, new_phase} = advance_phase(phase, token, idx, sc, i, bd, als)
+
+      {emissions,
+       %{state | idx: idx + 1, at_line_start: false, seen_content: true, phase: new_phase}}
+    end
+
+    defp advance_phase_open({:in_parens, id_idx, pd}, "("), do: {:in_parens, id_idx, pd + 1}
+    defp advance_phase_open({:in_parens, id_idx, pd}, _), do: {:in_parens, id_idx, pd}
+    defp advance_phase_open({:saw_eq, id_idx}, "("), do: {:in_parens, id_idx, 1}
+    defp advance_phase_open(_, _), do: :idle
+
+    defp advance_phase_close({:in_parens, id_idx, 1}, ")"), do: {:saw_close_paren, id_idx}
+
+    defp advance_phase_close({:in_parens, id_idx, pd}, ")") when pd > 1,
+      do: {:in_parens, id_idx, pd - 1}
+
+    defp advance_phase_close({:in_parens, id_idx, pd}, _), do: {:in_parens, id_idx, pd}
+    defp advance_phase_close(_, _), do: :idle
+
+    defp advance_phase(:idle, %{kind: "<ID>"}, idx, true, 0, 0, true),
+      do: {MapSet.new(), {:saw_id, idx}}
+
+    defp advance_phase(:idle, _, _, _, _, _, _), do: {MapSet.new(), :idle}
+
+    defp advance_phase({:saw_id, id_idx}, %{kind: "="}, _, _, _, _, _),
+      do: {MapSet.new(), {:saw_eq, id_idx}}
+
+    defp advance_phase({:saw_id, _}, %{kind: "<ID>"}, idx, _, _, _, _),
+      do: {MapSet.new(), {:saw_id, idx}}
+
+    defp advance_phase({:saw_id, id_idx}, %{kind: "."}, _, _, _, _, _),
+      do: {MapSet.new(), {:saw_id, id_idx}}
+
+    defp advance_phase({:saw_id, _}, _, _, _, _, _, _), do: {MapSet.new(), :idle}
+
+    defp advance_phase({:saw_eq, id_idx}, %{kind: "<ID>", content: "function"}, _, _, _, _, _),
+      do: {MapSet.new([{:assignment_function_split, id_idx}]), :idle}
+
+    defp advance_phase({:saw_eq, id_idx}, %{kind: "<ID>", content: "async"}, _, _, _, _, _),
+      do: {MapSet.new(), {:saw_eq, id_idx}}
+
+    defp advance_phase({:saw_eq, _}, _, _, _, _, _, _), do: {MapSet.new(), :idle}
+
+    defp advance_phase({:saw_close_paren, id_idx}, %{kind: "=>"}, _, _, _, _, _),
+      do: {MapSet.new([{:assignment_function_split, id_idx}]), :idle}
+
+    defp advance_phase({:saw_close_paren, _}, _, _, _, _, _, _), do: {MapSet.new(), :idle}
+
+    defp advance_phase(_, _, _, _, _, _, _), do: {MapSet.new(), :idle}
+  end
+end
diff --git a/lib/codeqa/ast/signals/structural/blank_line_signal.ex b/lib/codeqa/ast/signals/structural/blank_line_signal.ex
new file mode 100644
index 0000000..c484e1a
--- /dev/null
+++ b/lib/codeqa/ast/signals/structural/blank_line_signal.ex
@@ -0,0 +1,45 @@
+defmodule CodeQA.AST.Signals.Structural.BlankLineSignal do
+  alias CodeQA.AST.Lexing.NewlineToken
+  alias CodeQA.AST.Lexing.WhitespaceToken
+
+  @moduledoc """
+  Emits `:blank_split` at the first substantive token after 2+ consecutive
+  blank lines that follow a known block-end token.
+
+  When `opts[:language_module]` is set, uses that language's
+  `block_end_tokens/0` callback.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    def source(_), do: CodeQA.AST.Signals.Structural.BlankLineSignal
+    def group(_), do: :split
+
+    def init(_, lang_mod) do
+      tokens = CodeQA.Language.block_end_tokens(lang_mod)
+      %{idx: 0, nl_run: 0, seen_content: false, last_content: nil, block_end_tokens: tokens}
+    end
+
+    def emit(_, {_, %NewlineToken{}, _}, %{idx: idx, nl_run: nl} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, nl_run: nl + 1}}
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1}}
+
+    def emit(_, {_, token, _}, %{idx: idx} = state) do
+      base = %{state | idx: idx + 1, nl_run: 0, seen_content: true, last_content: token.content}
+
+      emissions =
+        if blank_split?(state), do: MapSet.new([{:blank_split, idx}]), else: MapSet.new()
+
+      {emissions, base}
+    end
+
+    defp blank_split?(%{seen_content: true, nl_run: nl, block_end_tokens: t, last_content: lc})
+         when nl >= 2,
+         do: MapSet.member?(t, lc)
+
+    defp blank_split?(_), do: false
+  end
+end
diff --git a/lib/codeqa/ast/signals/structural/bracket_signal.ex b/lib/codeqa/ast/signals/structural/bracket_signal.ex
new file mode 100644
index 0000000..201f66e
--- /dev/null
+++ b/lib/codeqa/ast/signals/structural/bracket_signal.ex
@@ -0,0 +1,51 @@
+defmodule CodeQA.AST.Signals.Structural.BracketSignal do
+  @moduledoc """
+  Emits `:bracket_enclosure` for each outermost bracket pair `()`, `[]`, `{}`.
+
+  Replaces `ParseRules.BracketRule`. State tracks: token index, bracket depth,
+  start index of current open bracket, and a stack of open bracket kinds for
+  mismatch detection.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    @close %{")" => "(", "]" => "[", "}" => "{"}
+
+    def source(_), do: CodeQA.AST.Signals.Structural.BracketSignal
+    def group(_), do: :enclosure
+
+    def init(_, _lang_mod), do: %{idx: 0, depth: 0, start_idx: nil, stack: []}
+
+    def emit(_, {_, %{kind: k}, _}, %{idx: idx, depth: 0, stack: stack} = state)
+        when k in ["(", "[", "{"],
+        do: {MapSet.new(), %{state | idx: idx + 1, depth: 1, start_idx: idx, stack: [k | stack]}}
+
+    def emit(_, {_, %{kind: k}, _}, %{idx: idx, depth: d, stack: stack} = state)
+        when k in ["(", "[", "{"],
+        do: {MapSet.new(), %{state | idx: idx + 1, depth: d + 1, stack: [k | stack]}}
+
+    def emit(_, {_, %{kind: k}, _}, %{idx: idx, depth: d, stack: [top | rest]} = state)
+        when k in [")", "]", "}"] do
+      base = %{state | idx: idx + 1}
+
+      if @close[k] == top,
+        do: close_match(base, d, state.start_idx, idx, rest),
+        else: {MapSet.new(), base}
+    end
+
+    def emit(_, {_, %{kind: k}, _}, %{idx: idx} = state) when k in [")", "]", "}"],
+      do: {MapSet.new(), %{state | idx: idx + 1}}
+
+    def emit(_, {_, _, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1}}
+
+    defp close_match(state, 1, start_idx, idx, rest),
+      do:
+        {MapSet.new([{:bracket_enclosure, {start_idx, idx}}]),
+         %{state | depth: 0, start_idx: nil, stack: rest}}
+
+    defp close_match(state, d, _start_idx, _idx, rest),
+      do: {MapSet.new(), %{state | depth: d - 1, stack: rest}}
+  end
+end
diff --git a/lib/codeqa/ast/signals/structural/branch_split_signal.ex b/lib/codeqa/ast/signals/structural/branch_split_signal.ex
new file mode 100644
index 0000000..1d6d264
--- /dev/null
+++ b/lib/codeqa/ast/signals/structural/branch_split_signal.ex
@@ -0,0 +1,58 @@
+defmodule CodeQA.AST.Signals.Structural.BranchSplitSignal do
+  alias CodeQA.AST.Lexing.NewlineToken
+  alias CodeQA.AST.Lexing.WhitespaceToken
+
+  @moduledoc """
+  Emits `:branch_split` when a branch keyword appears at bracket depth 0
+  and at least one token has been seen before it.
+
+  Unlike `KeywordSignal`, there is no indentation constraint — branches inside
+  functions are intentionally split into sibling child blocks by the parser's
+  recursive phase.
+
+  When `opts[:language_module]` is set, uses that language's
+  `branch_keywords/0` callback.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    def source(_), do: CodeQA.AST.Signals.Structural.BranchSplitSignal
+    def group(_), do: :branch_split
+
+    def init(_, lang_mod) do
+      keywords = CodeQA.Language.branch_keywords(lang_mod)
+      %{idx: 0, bracket_depth: 0, seen_content: false, keywords: keywords}
+    end
+
+    def emit(_, {_, %NewlineToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1}}
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1}}
+
+    def emit(_, {_, %{kind: k}, _}, %{idx: idx, bracket_depth: bd} = state)
+        when k in ["(", "[", "{"],
+        do: {MapSet.new(), %{state | idx: idx + 1, bracket_depth: bd + 1, seen_content: true}}
+
+    def emit(_, {_, %{kind: k}, _}, %{idx: idx, bracket_depth: bd} = state)
+        when k in [")", "]", "}"],
+        do:
+          {MapSet.new(),
+           %{state | idx: idx + 1, bracket_depth: max(0, bd - 1), seen_content: true}}
+
+    def emit(_, {_, token, _}, %{idx: idx} = state) do
+      base = %{state | idx: idx + 1, seen_content: true}
+
+      emissions =
+        if branch_split?(state, token), do: MapSet.new([{:branch_split, idx}]), else: MapSet.new()
+
+      {emissions, base}
+    end
+
+    defp branch_split?(%{seen_content: true, bracket_depth: 0, keywords: kw}, %{content: c}),
+      do: MapSet.member?(kw, c)
+
+    defp branch_split?(_, _), do: false
+  end
+end
diff --git a/lib/codeqa/ast/signals/structural/colon_indent_signal.ex b/lib/codeqa/ast/signals/structural/colon_indent_signal.ex
new file mode 100644
index 0000000..9189b79
--- /dev/null
+++ b/lib/codeqa/ast/signals/structural/colon_indent_signal.ex
@@ -0,0 +1,83 @@
+defmodule CodeQA.AST.Signals.Structural.ColonIndentSignal do
+  alias CodeQA.AST.Lexing.NewlineToken
+  alias CodeQA.AST.Lexing.WhitespaceToken
+
+  @moduledoc """
+  Emits `:colon_indent_enclosure` for colon-indented blocks (Python).
+
+  Only active when `opts[:language_module]` returns true for `uses_colon_indent?/0`. Replaces
+  `ParseRules.ColonIndentationRule`.
+
+  ## Limitation
+
+  The original rule flushes open blocks at EOF via `close_all_open/1`. Since
+  `emit/3` has no end-of-stream callback, open blocks are instead flushed at
+  each `<NL>` token. This correctly handles single-statement blocks; multi-line
+  blocks are closed at the first newline (conservative).
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    def source(_), do: CodeQA.AST.Signals.Structural.ColonIndentSignal
+    def group(_), do: :enclosure
+
+    def init(_, lang_mod) do
+      %{
+        enabled: lang_mod.uses_colon_indent?(),
+        idx: 0,
+        ci: 0,
+        last_colon_indent: nil,
+        stack: []
+      }
+    end
+
+    def emit(_, _, %{enabled: false} = state),
+      do: {MapSet.new(), %{state | idx: state.idx + 1}}
+
+    def emit(_, {_, %NewlineToken{}, _}, %{idx: idx} = state) do
+      {emissions, _} = flush_stack(state.stack)
+      {emissions, %{state | idx: idx + 1, ci: 0, stack: []}}
+    end
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx, ci: ci} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, ci: ci + 1}}
+
+    def emit(_, {_, %{kind: ":"}, _}, %{idx: idx, ci: ci} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, last_colon_indent: ci}}
+
+    def emit(_, {_, _, _}, %{idx: idx, ci: ci} = state) do
+      {dedent_emissions, remaining} = close_dedented(state.stack, ci)
+      new_stack = maybe_open_block(remaining, state.last_colon_indent, ci, idx)
+
+      {dedent_emissions,
+       %{state | idx: idx + 1, last_colon_indent: nil, stack: update_top(new_stack, idx)}}
+    end
+
+    defp close_dedented(stack, ci) do
+      {to_close, keep} = Enum.split_while(stack, fn e -> ci <= e.colon_indent end)
+      {build_emissions(to_close), keep}
+    end
+
+    defp flush_stack(stack), do: {build_emissions(stack), []}
+
+    defp maybe_open_block(stack, colon_indent, ci, idx)
+         when colon_indent != nil and ci > colon_indent,
+         do: [%{colon_indent: colon_indent, sub_start: idx, last_content_idx: idx} | stack]
+
+    defp maybe_open_block(stack, _, _, _), do: stack
+
+    defp build_emissions(entries) do
+      Enum.reduce(entries, MapSet.new(), fn
+        %{sub_start: s, last_content_idx: e}, acc when e != nil ->
+          MapSet.put(acc, {:colon_indent_enclosure, {s, e}})
+
+        _entry, acc ->
+          acc
+      end)
+    end
+
+    defp update_top([], _idx), do: []
+    defp update_top([top | rest], idx), do: [Map.put(top, :last_content_idx, idx) | rest]
+  end
+end
diff --git a/lib/codeqa/ast/signals/structural/comment_divider_signal.ex b/lib/codeqa/ast/signals/structural/comment_divider_signal.ex
new file mode 100644
index 0000000..d01e5e8
--- /dev/null
+++ b/lib/codeqa/ast/signals/structural/comment_divider_signal.ex
@@ -0,0 +1,76 @@
+defmodule CodeQA.AST.Signals.Structural.CommentDividerSignal do
+  alias CodeQA.AST.Lexing.NewlineToken
+  alias CodeQA.AST.Lexing.WhitespaceToken
+
+  @moduledoc """
+  Emits `:comment_divider_split` when a line is a "visual divider" comment —
+  a comment prefix at line start followed immediately by repetitive non-word
+  punctuation characters.
+
+  Used to detect section separators like `# ---`, `// ===`, `-- ---`.
+  No split is emitted for the first such line (seen_content must be true).
+
+  When `opts[:language_module]` is set, uses that language's
+  `comment_prefixes/0` callback.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    def source(_), do: CodeQA.AST.Signals.Structural.CommentDividerSignal
+    def group(_), do: :split
+
+    def init(_, lang_mod) do
+      comment_prefixes = MapSet.new(lang_mod.comment_prefixes())
+      divider_indicators = CodeQA.Language.divider_indicators(lang_mod)
+
+      %{
+        idx: 0,
+        at_line_start: true,
+        seen_content: false,
+        indent: 0,
+        comment_prefixes: comment_prefixes,
+        divider_indicators: divider_indicators
+      }
+    end
+
+    def emit(_, {_, %NewlineToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, at_line_start: true, indent: 0}}
+
+    def emit(
+          _,
+          {_, %WhitespaceToken{}, _},
+          %{idx: idx, at_line_start: true, indent: indent} = state
+        ),
+        do: {MapSet.new(), %{state | idx: idx + 1, at_line_start: true, indent: indent + 1}}
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1}}
+
+    def emit(_, {_, token, next}, %{idx: idx} = state) do
+      base = %{state | idx: idx + 1, at_line_start: false, seen_content: true}
+
+      emissions =
+        if divider_split?(state, token, next),
+          do: MapSet.new([{:comment_divider_split, idx}]),
+          else: MapSet.new()
+
+      {emissions, base}
+    end
+
+    defp divider_split?(
+           %{
+             seen_content: true,
+             at_line_start: true,
+             indent: 0,
+             comment_prefixes: cp,
+             divider_indicators: di
+           },
+           %{kind: k},
+           next
+         ),
+         do: MapSet.member?(cp, k) and next != nil and MapSet.member?(di, next.kind)
+
+    defp divider_split?(_, _, _), do: false
+  end
+end
diff --git a/lib/codeqa/ast/signals/structural/decorator_signal.ex b/lib/codeqa/ast/signals/structural/decorator_signal.ex
new file mode 100644
index 0000000..0dc1f5b
--- /dev/null
+++ b/lib/codeqa/ast/signals/structural/decorator_signal.ex
@@ -0,0 +1,81 @@
+defmodule CodeQA.AST.Signals.Structural.DecoratorSignal do
+  alias CodeQA.AST.Lexing.NewlineToken
+  alias CodeQA.AST.Lexing.WhitespaceToken
+
+  @moduledoc """
+  Emits `:decorator_split` when a decorator/annotation marker appears at line
+  start with bracket_depth == 0.
+
+  Detects two patterns:
+  - `@` at line start (Python, TypeScript, Java, Elixir decorators/annotations)
+  - `#[` at line start (Rust attribute syntax)
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    def source(_), do: CodeQA.AST.Signals.Structural.DecoratorSignal
+    def group(_), do: :split
+
+    def init(_, _lang_mod),
+      do: %{idx: 0, bracket_depth: 0, at_line_start: true, seen_content: false}
+
+    def emit(_, {_, %NewlineToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, at_line_start: true}}
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx, at_line_start: true} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, at_line_start: true}}
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1}}
+
+    def emit(_, {_, %{kind: k}, _}, %{idx: idx, bracket_depth: bd} = state)
+        when k in ["(", "[", "{"],
+        do:
+          {MapSet.new(),
+           %{
+             state
+             | idx: idx + 1,
+               bracket_depth: bd + 1,
+               seen_content: true,
+               at_line_start: false
+           }}
+
+    def emit(_, {_, %{kind: k}, _}, %{idx: idx, bracket_depth: bd} = state)
+        when k in [")", "]", "}"],
+        do:
+          {MapSet.new(),
+           %{
+             state
+             | idx: idx + 1,
+               bracket_depth: max(0, bd - 1),
+               seen_content: true,
+               at_line_start: false
+           }}
+
+    def emit(
+          _,
+          {_, %{kind: "@"}, _},
+          %{idx: idx, seen_content: true, bracket_depth: 0, at_line_start: true} = state
+        ),
+        do:
+          {MapSet.new([{:decorator_split, idx}]),
+           %{state | idx: idx + 1, seen_content: true, at_line_start: false}}
+
+    def emit(
+          _,
+          {_, %{kind: "#"}, next},
+          %{idx: idx, seen_content: true, bracket_depth: 0, at_line_start: true} = state
+        ) do
+      emissions =
+        if next != nil and next.kind == "[",
+          do: MapSet.new([{:decorator_split, idx}]),
+          else: MapSet.new()
+
+      {emissions, %{state | idx: idx + 1, seen_content: true, at_line_start: false}}
+    end
+
+    def emit(_, {_, _, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, seen_content: true, at_line_start: false}}
+  end
+end
diff --git a/lib/codeqa/ast/signals/structural/dedent_to_zero_signal.ex b/lib/codeqa/ast/signals/structural/dedent_to_zero_signal.ex
new file mode 100644
index 0000000..d644dad
--- /dev/null
+++ b/lib/codeqa/ast/signals/structural/dedent_to_zero_signal.ex
@@ -0,0 +1,87 @@
+defmodule CodeQA.AST.Signals.Structural.DedentToZeroSignal do
+  alias CodeQA.AST.Lexing.NewlineToken
+  alias CodeQA.AST.Lexing.WhitespaceToken
+
+  @moduledoc """
+  Emits `:dedent_split` when code returns to indent level 0 after having been
+  at indent > 0 on the previous line.
+
+  This is the primary split mechanism for Python and other indentation-significant
+  languages. The split fires at the first substantive token on a line that has no
+  leading `<WS>`, when the previous line did have leading `<WS>`.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    def source(_), do: CodeQA.AST.Signals.Structural.DedentToZeroSignal
+    def group(_), do: :split
+
+    def init(_, _lang_mod) do
+      %{
+        idx: 0,
+        at_line_start: true,
+        seen_content: false,
+        current_line_has_indent: false,
+        current_line_has_content: false,
+        prev_line_had_indent: false
+      }
+    end
+
+    def emit(
+          _,
+          {_, %NewlineToken{}, _},
+          %{
+            idx: idx,
+            current_line_has_content: clhc,
+            current_line_has_indent: clhi,
+            prev_line_had_indent: plhi
+          } = state
+        ) do
+      new_plhi = if clhc, do: clhi, else: plhi
+
+      {MapSet.new(),
+       %{
+         state
+         | idx: idx + 1,
+           at_line_start: true,
+           prev_line_had_indent: new_plhi,
+           current_line_has_indent: false,
+           current_line_has_content: false
+       }}
+    end
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx, at_line_start: true} = state),
+      do:
+        {MapSet.new(),
+         %{state | idx: idx + 1, current_line_has_indent: true, at_line_start: true}}
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1}}
+
+    def emit(_, {_, _, _}, %{idx: idx} = state) do
+      base = %{
+        state
+        | idx: idx + 1,
+          at_line_start: false,
+          seen_content: true,
+          current_line_has_content: true
+      }
+
+      emissions =
+        if dedent_split?(state), do: MapSet.new([{:dedent_split, idx}]), else: MapSet.new()
+
+      {emissions, base}
+    end
+
+    defp dedent_split?(%{
+           at_line_start: true,
+           current_line_has_indent: false,
+           prev_line_had_indent: true,
+           seen_content: true
+         }),
+         do: true
+
+    defp dedent_split?(_), do: false
+  end
+end
diff --git a/lib/codeqa/ast/signals/structural/doc_comment_lead_signal.ex b/lib/codeqa/ast/signals/structural/doc_comment_lead_signal.ex
new file mode 100644
index 0000000..c5e5c4e
--- /dev/null
+++ b/lib/codeqa/ast/signals/structural/doc_comment_lead_signal.ex
@@ -0,0 +1,65 @@
+defmodule CodeQA.AST.Signals.Structural.DocCommentLeadSignal do
+  alias CodeQA.AST.Lexing.NewlineToken
+  alias CodeQA.AST.Lexing.WhitespaceToken
+
+  @moduledoc """
+  Emits `:doc_comment_split` when a doc-comment opener appears at line start.
+
+  Detects:
+  - `///` — Rust/C# XML doc comments: `//` token immediately followed by `/`
+  - `/**` — Java/JS JSDoc: `/` token at line start immediately followed by `*`
+
+  No split is emitted for the first such line (seen_content must be true).
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    def source(_), do: CodeQA.AST.Signals.Structural.DocCommentLeadSignal
+    def group(_), do: :split
+
+    def init(_, _lang_mod), do: %{idx: 0, at_line_start: true, seen_content: false}
+
+    def emit(_, {_, %NewlineToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, at_line_start: true}}
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx, at_line_start: true} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, at_line_start: true}}
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1}}
+
+    def emit(
+          _,
+          {_, %{kind: "//"}, next},
+          %{idx: idx, at_line_start: true, seen_content: true} = state
+        ) do
+      base = %{state | idx: idx + 1, at_line_start: false}
+
+      emissions =
+        if next != nil and next.kind == "/",
+          do: MapSet.new([{:doc_comment_split, idx}]),
+          else: MapSet.new()
+
+      {emissions, base}
+    end
+
+    def emit(
+          _,
+          {_, %{kind: "/"}, next},
+          %{idx: idx, at_line_start: true, seen_content: true} = state
+        ) do
+      base = %{state | idx: idx + 1, at_line_start: false}
+
+      emissions =
+        if next != nil and next.kind in ["*", "**"],
+          do: MapSet.new([{:doc_comment_split, idx}]),
+          else: MapSet.new()
+
+      {emissions, base}
+    end
+
+    def emit(_, {_, _, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, at_line_start: false, seen_content: true}}
+  end
+end
diff --git a/lib/codeqa/ast/signals/structural/keyword_signal.ex b/lib/codeqa/ast/signals/structural/keyword_signal.ex
new file mode 100644
index 0000000..c13d3cf
--- /dev/null
+++ b/lib/codeqa/ast/signals/structural/keyword_signal.ex
@@ -0,0 +1,83 @@
+defmodule CodeQA.AST.Signals.Structural.KeywordSignal do
+  alias CodeQA.AST.Lexing.NewlineToken
+  alias CodeQA.AST.Lexing.WhitespaceToken
+
+  @moduledoc """
+  Emits `:keyword_split` when a declaration keyword appears at bracket depth 0
+  and indentation level 0.
+
+  When `opts[:language_module]` is set, uses that language's
+  `declaration_keywords/0` callback.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    def source(_), do: CodeQA.AST.Signals.Structural.KeywordSignal
+    def group(_), do: :split
+
+    def init(_, lang_mod) do
+      keywords = CodeQA.Language.declaration_keywords(lang_mod)
+
+      %{
+        idx: 0,
+        bracket_depth: 0,
+        indent: 0,
+        at_line_start: true,
+        seen_content: false,
+        keywords: keywords
+      }
+    end
+
+    def emit(_, {_, %NewlineToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, indent: 0, at_line_start: true}}
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx, indent: i, at_line_start: true} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, indent: i + 1, at_line_start: true}}
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1}}
+
+    def emit(_, {_, %{kind: k}, _}, %{idx: idx, bracket_depth: bd} = state)
+        when k in ["(", "[", "{"],
+        do:
+          {MapSet.new(),
+           %{
+             state
+             | idx: idx + 1,
+               bracket_depth: bd + 1,
+               seen_content: true,
+               at_line_start: false
+           }}
+
+    def emit(_, {_, %{kind: k}, _}, %{idx: idx, bracket_depth: bd} = state)
+        when k in [")", "]", "}"],
+        do:
+          {MapSet.new(),
+           %{
+             state
+             | idx: idx + 1,
+               bracket_depth: max(0, bd - 1),
+               seen_content: true,
+               at_line_start: false
+           }}
+
+    def emit(_, {_, token, _}, %{idx: idx} = state) do
+      base = %{state | idx: idx + 1, seen_content: true, at_line_start: false}
+
+      emissions =
+        if keyword_split?(state, token),
+          do: MapSet.new([{:keyword_split, idx}]),
+          else: MapSet.new()
+
+      {emissions, base}
+    end
+
+    defp keyword_split?(%{seen_content: true, bracket_depth: 0, indent: 0, keywords: kw}, %{
+           content: c
+         }),
+         do: MapSet.member?(kw, c)
+
+    defp keyword_split?(_, _), do: false
+  end
+end
diff --git a/lib/codeqa/ast/signals/structural/sql_block_signal.ex b/lib/codeqa/ast/signals/structural/sql_block_signal.ex
new file mode 100644
index 0000000..1e376f5
--- /dev/null
+++ b/lib/codeqa/ast/signals/structural/sql_block_signal.ex
@@ -0,0 +1,55 @@
+defmodule CodeQA.AST.Signals.Structural.SQLBlockSignal do
+  alias CodeQA.AST.Lexing.NewlineToken
+  alias CodeQA.AST.Lexing.WhitespaceToken
+
+  @moduledoc """
+  Emits `:sql_block_split` when a SQL DDL or DML statement keyword appears
+  at line start after prior content has been seen.
+
+  Recognises uppercase and lowercase SQL statement starters:
+  DDL: CREATE, DROP, ALTER, TRUNCATE
+  DML: INSERT, UPDATE, DELETE, SELECT
+  Procedures/transactions: BEGIN, COMMIT, ROLLBACK, CALL, EXECUTE
+
+  When `opts[:language_module]` is set, uses that language's
+  `statement_keywords/0` callback.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    def source(_), do: CodeQA.AST.Signals.Structural.SQLBlockSignal
+    def group(_), do: :split
+
+    def init(_, lang_mod) do
+      keywords = CodeQA.Language.statement_keywords(lang_mod)
+      %{idx: 0, at_line_start: true, seen_content: false, keywords: keywords}
+    end
+
+    def emit(_, {_, %NewlineToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, at_line_start: true}}
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx, at_line_start: true} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, at_line_start: true}}
+
+    def emit(_, {_, %WhitespaceToken{}, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1}}
+
+    def emit(_, {_, %{kind: "<ID>"} = token, _}, %{idx: idx} = state) do
+      base = %{state | idx: idx + 1, at_line_start: false, seen_content: true}
+
+      emissions =
+        if sql_split?(state, token), do: MapSet.new([{:sql_block_split, idx}]), else: MapSet.new()
+
+      {emissions, base}
+    end
+
+    def emit(_, {_, _, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1, at_line_start: false, seen_content: true}}
+
+    defp sql_split?(%{seen_content: true, at_line_start: true, keywords: kw}, %{content: c}),
+      do: MapSet.member?(kw, String.downcase(c))
+
+    defp sql_split?(_, _), do: false
+  end
+end
diff --git a/lib/codeqa/ast/signals/structural/triple_quote_signal.ex b/lib/codeqa/ast/signals/structural/triple_quote_signal.ex
new file mode 100644
index 0000000..ac5808d
--- /dev/null
+++ b/lib/codeqa/ast/signals/structural/triple_quote_signal.ex
@@ -0,0 +1,31 @@
+defmodule CodeQA.AST.Signals.Structural.TripleQuoteSignal do
+  @moduledoc """
+  Emits `:triple_split` at each `<DOC>` token boundary.
+
+  The first of each pair marks the opening of a heredoc; the second marks the
+  token after the closing delimiter. These split values are used by the Parser
+  to compute protected ranges, preventing other signals' splits from being
+  applied inside heredoc content.
+
+  Replaces `ParseRules.TripleQuoteRule`.
+  """
+
+  defstruct []
+
+  defimpl CodeQA.AST.Parsing.Signal do
+    @doc_kind CodeQA.AST.Lexing.StringToken.doc_kind()
+    def source(_), do: CodeQA.AST.Signals.Structural.TripleQuoteSignal
+    def group(_), do: :split
+
+    def init(_, _lang_mod), do: %{idx: 0, inside: false}
+
+    def emit(_, {_, %{kind: @doc_kind}, _}, %{idx: idx, inside: false} = state),
+      do: {MapSet.new([{:triple_split, idx}]), %{state | idx: idx + 1, inside: true}}
+
+    def emit(_, {_, %{kind: @doc_kind}, _}, %{idx: idx, inside: true} = state),
+      do: {MapSet.new([{:triple_split, idx + 1}]), %{state | idx: idx + 1, inside: false}}
+
+    def emit(_, {_, _, _}, %{idx: idx} = state),
+      do: {MapSet.new(), %{state | idx: idx + 1}}
+  end
+end
diff --git a/test/support/counter_signal.ex b/test/support/counter_signal.ex
new file mode 100644
index 0000000..7ffb5d8
--- /dev/null
+++ b/test/support/counter_signal.ex
@@ -0,0 +1,19 @@
+defmodule CodeQA.Support.CounterSignal do
+  @moduledoc false
+  defstruct []
+end
+
+defimpl CodeQA.AST.Parsing.Signal, for: CodeQA.Support.CounterSignal do
+  def source(_), do: CodeQA.Support.CounterSignal
+  def group(_), do: :test
+  def init(_, _), do: %{idx: 0}
+
+  def emit(_, {_prev, token, _next}, %{idx: i} = state) do
+    emissions =
+      if token.kind == "<ID>",
+        do: MapSet.new([{:id_seen, i}]),
+        else: MapSet.new()
+
+    {emissions, %{state | idx: i + 1}}
+  end
+end
diff --git a/test/support/node_matcher.ex b/test/support/node_matcher.ex
new file mode 100644
index 0000000..679dc92
--- /dev/null
+++ b/test/support/node_matcher.ex
@@ -0,0 +1,17 @@
+defmodule Test.NodeMatcher do
+  @moduledoc """
+  Helpers for asserting on tokens within `CompoundNode` structures.
+
+  Returns tagged tuples that can be matched against token fields:
+
+  - `exact(:content, "add")` — token whose `content` equals `"add"` exactly
+  - `partial(:content, "@doc")` — token whose `content` contains `"@doc"` as a substring
+  - `:value` targets the normalized token value instead of raw source content
+  """
+
+  @spec exact(:content | :value, String.t()) :: {:exact, :content | :value, String.t()}
+  def exact(field, value) when field in [:content, :value], do: {:exact, field, value}
+
+  @spec partial(:content | :value, String.t()) :: {:partial, :content | :value, String.t()}
+  def partial(field, value) when field in [:content, :value], do: {:partial, field, value}
+end

From 62ed12dbeb435055d84daff2be88a64c31e2a522 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 19 Mar 2026 18:26:02 +0100
Subject: [PATCH 04/71] feat(languages): add multi-language definitions and
 test fixtures

Add language abstractions for 30+ languages across native (C++, Go, Rust,
Swift, Zig, Haskell, OCaml), scripting (Python, Ruby, JS, PHP, Lua, R, etc.),
VM-based (Elixir, Java, Kotlin, Scala, C#, Dart, etc.), web, config (Docker,
Terraform, Makefile), data (SQL, YAML, GraphQL), and markup formats.
Includes test fixtures for each language family.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/languages/code/native/cpp.ex       |  48 +++++
 lib/codeqa/languages/code/native/go.ex        |  50 +++++
 lib/codeqa/languages/code/native/haskell.ex   |  56 ++++++
 lib/codeqa/languages/code/native/ocaml.ex     |  53 ++++++
 lib/codeqa/languages/code/native/rust.ex      |  53 ++++++
 lib/codeqa/languages/code/native/swift.ex     |  53 ++++++
 lib/codeqa/languages/code/native/zig.ex       |  53 ++++++
 lib/codeqa/languages/code/scripting/julia.ex  |  53 ++++++
 lib/codeqa/languages/code/scripting/lua.ex    |  46 +++++
 lib/codeqa/languages/code/scripting/perl.ex   |  53 ++++++
 lib/codeqa/languages/code/scripting/php.ex    |  54 ++++++
 lib/codeqa/languages/code/scripting/python.ex |  56 ++++++
 lib/codeqa/languages/code/scripting/r.ex      |  48 +++++
 lib/codeqa/languages/code/scripting/ruby.ex   |  57 ++++++
 lib/codeqa/languages/code/scripting/shell.ex  |  46 +++++
 lib/codeqa/languages/code/vm/clojure.ex       |  53 ++++++
 lib/codeqa/languages/code/vm/csharp.ex        |  53 ++++++
 lib/codeqa/languages/code/vm/dart.ex          |  57 ++++++
 lib/codeqa/languages/code/vm/elixir.ex        |  58 ++++++
 lib/codeqa/languages/code/vm/erlang.ex        |  53 ++++++
 lib/codeqa/languages/code/vm/fsharp.ex        |  59 ++++++
 lib/codeqa/languages/code/vm/java.ex          |  51 +++++
 lib/codeqa/languages/code/vm/kotlin.ex        |  54 ++++++
 lib/codeqa/languages/code/vm/scala.ex         |  57 ++++++
 lib/codeqa/languages/code/web/javascript.ex   |  56 ++++++
 lib/codeqa/languages/code/web/typescript.ex   |  59 ++++++
 lib/codeqa/languages/config/dockerfile.ex     |  34 ++++
 lib/codeqa/languages/config/makefile.ex       |  31 +++
 lib/codeqa/languages/config/terraform.ex      |  32 ++++
 lib/codeqa/languages/data/graphql.ex          |  31 +++
 lib/codeqa/languages/data/json.ex             |  30 +++
 lib/codeqa/languages/data/sql.ex              |  39 ++++
 lib/codeqa/languages/data/toml.ex             |  30 +++
 lib/codeqa/languages/data/yaml.ex             |  30 +++
 lib/codeqa/languages/language.ex              | 180 ++++++++++++++++++
 lib/codeqa/languages/markup/css.ex            |  31 +++
 lib/codeqa/languages/markup/html.ex           |  33 ++++
 lib/codeqa/languages/markup/markdown.ex       |  30 +++
 lib/codeqa/languages/markup/xml.ex            |  30 +++
 lib/codeqa/languages/unknown.ex               |  30 +++
 test/fixtures/sample.ex                       |   1 +
 test/support/fixtures/cpp/observer_pattern.ex |  71 +++++++
 test/support/fixtures/cpp/smart_pointer.ex    |  87 +++++++++
 .../fixtures/cpp/template_container.ex        |  90 +++++++++
 .../fixtures/csharp/async_task_manager.ex     |  67 +++++++
 test/support/fixtures/csharp/linq_pipeline.ex |  71 +++++++
 test/support/fixtures/csharp/plugin_system.ex |  72 +++++++
 test/support/fixtures/dart/futures_async.ex   |  78 ++++++++
 .../fixtures/dart/mixin_composition.ex        |  85 +++++++++
 test/support/fixtures/dart/widget_state.ex    |  91 +++++++++
 test/support/fixtures/elixir/calculator.ex    | 125 ++++++++++++
 test/support/fixtures/elixir/event_bus.ex     |  71 +++++++
 test/support/fixtures/elixir/rate_limiter.ex  |  85 +++++++++
 test/support/fixtures/go/calculator.ex        |  53 ++++++
 test/support/fixtures/go/cli_parser.ex        |  77 ++++++++
 test/support/fixtures/go/http_middleware.ex   |  86 +++++++++
 test/support/fixtures/java/builder_pattern.ex |  81 ++++++++
 .../fixtures/java/repository_pattern.ex       |  76 ++++++++
 .../support/fixtures/java/strategy_pattern.ex |  79 ++++++++
 .../support/fixtures/javascript/calculator.ex |  51 +++++
 .../fixtures/javascript/form_validator.ex     | 134 +++++++++++++
 .../fixtures/javascript/shopping_cart.ex      | 100 ++++++++++
 .../support/fixtures/kotlin/coroutine_flow.ex |  64 +++++++
 .../fixtures/kotlin/extension_library.ex      |  55 ++++++
 test/support/fixtures/kotlin/sealed_state.ex  |  63 ++++++
 test/support/fixtures/lua/class_system.ex     |  63 ++++++
 test/support/fixtures/lua/event_system.ex     |  76 ++++++++
 test/support/fixtures/lua/state_machine.ex    |  75 ++++++++
 test/support/fixtures/python/calculator.ex    |  83 ++++++++
 test/support/fixtures/python/config_parser.ex |  89 +++++++++
 test/support/fixtures/python/csv_pipeline.ex  |  95 +++++++++
 test/support/fixtures/ruby/calculator.ex      |  59 ++++++
 .../fixtures/ruby/markdown_renderer.ex        |  79 ++++++++
 test/support/fixtures/ruby/orm_lite.ex        | 106 +++++++++++
 test/support/fixtures/rust/calculator.ex      |  70 +++++++
 test/support/fixtures/rust/ring_buffer.ex     |  86 +++++++++
 test/support/fixtures/rust/tokenizer.ex       | 112 +++++++++++
 test/support/fixtures/scala/actor_messages.ex |  70 +++++++
 .../fixtures/scala/case_class_algebra.ex      |  73 +++++++
 .../fixtures/scala/typeclass_pattern.ex       |  64 +++++++
 test/support/fixtures/swift/actor_model.ex    |  81 ++++++++
 test/support/fixtures/swift/combine_stream.ex |  66 +++++++
 test/support/fixtures/swift/result_type.ex    |  63 ++++++
 .../typescript/dependency_injection.ex        |  66 +++++++
 .../fixtures/typescript/event_emitter.ex      |  68 +++++++
 .../fixtures/typescript/user_profile_store.ex |  72 +++++++
 .../fixtures/zig/allocator_interface.ex       |  72 +++++++
 .../support/fixtures/zig/iterator_protocol.ex |  87 +++++++++
 test/support/fixtures/zig/tagged_union.ex     |  90 +++++++++
 test/support/language_fixture.ex              |  61 ++++++
 90 files changed, 5819 insertions(+)
 create mode 100644 lib/codeqa/languages/code/native/cpp.ex
 create mode 100644 lib/codeqa/languages/code/native/go.ex
 create mode 100644 lib/codeqa/languages/code/native/haskell.ex
 create mode 100644 lib/codeqa/languages/code/native/ocaml.ex
 create mode 100644 lib/codeqa/languages/code/native/rust.ex
 create mode 100644 lib/codeqa/languages/code/native/swift.ex
 create mode 100644 lib/codeqa/languages/code/native/zig.ex
 create mode 100644 lib/codeqa/languages/code/scripting/julia.ex
 create mode 100644 lib/codeqa/languages/code/scripting/lua.ex
 create mode 100644 lib/codeqa/languages/code/scripting/perl.ex
 create mode 100644 lib/codeqa/languages/code/scripting/php.ex
 create mode 100644 lib/codeqa/languages/code/scripting/python.ex
 create mode 100644 lib/codeqa/languages/code/scripting/r.ex
 create mode 100644 lib/codeqa/languages/code/scripting/ruby.ex
 create mode 100644 lib/codeqa/languages/code/scripting/shell.ex
 create mode 100644 lib/codeqa/languages/code/vm/clojure.ex
 create mode 100644 lib/codeqa/languages/code/vm/csharp.ex
 create mode 100644 lib/codeqa/languages/code/vm/dart.ex
 create mode 100644 lib/codeqa/languages/code/vm/elixir.ex
 create mode 100644 lib/codeqa/languages/code/vm/erlang.ex
 create mode 100644 lib/codeqa/languages/code/vm/fsharp.ex
 create mode 100644 lib/codeqa/languages/code/vm/java.ex
 create mode 100644 lib/codeqa/languages/code/vm/kotlin.ex
 create mode 100644 lib/codeqa/languages/code/vm/scala.ex
 create mode 100644 lib/codeqa/languages/code/web/javascript.ex
 create mode 100644 lib/codeqa/languages/code/web/typescript.ex
 create mode 100644 lib/codeqa/languages/config/dockerfile.ex
 create mode 100644 lib/codeqa/languages/config/makefile.ex
 create mode 100644 lib/codeqa/languages/config/terraform.ex
 create mode 100644 lib/codeqa/languages/data/graphql.ex
 create mode 100644 lib/codeqa/languages/data/json.ex
 create mode 100644 lib/codeqa/languages/data/sql.ex
 create mode 100644 lib/codeqa/languages/data/toml.ex
 create mode 100644 lib/codeqa/languages/data/yaml.ex
 create mode 100644 lib/codeqa/languages/language.ex
 create mode 100644 lib/codeqa/languages/markup/css.ex
 create mode 100644 lib/codeqa/languages/markup/html.ex
 create mode 100644 lib/codeqa/languages/markup/markdown.ex
 create mode 100644 lib/codeqa/languages/markup/xml.ex
 create mode 100644 lib/codeqa/languages/unknown.ex
 create mode 100644 test/support/fixtures/cpp/observer_pattern.ex
 create mode 100644 test/support/fixtures/cpp/smart_pointer.ex
 create mode 100644 test/support/fixtures/cpp/template_container.ex
 create mode 100644 test/support/fixtures/csharp/async_task_manager.ex
 create mode 100644 test/support/fixtures/csharp/linq_pipeline.ex
 create mode 100644 test/support/fixtures/csharp/plugin_system.ex
 create mode 100644 test/support/fixtures/dart/futures_async.ex
 create mode 100644 test/support/fixtures/dart/mixin_composition.ex
 create mode 100644 test/support/fixtures/dart/widget_state.ex
 create mode 100644 test/support/fixtures/elixir/calculator.ex
 create mode 100644 test/support/fixtures/elixir/event_bus.ex
 create mode 100644 test/support/fixtures/elixir/rate_limiter.ex
 create mode 100644 test/support/fixtures/go/calculator.ex
 create mode 100644 test/support/fixtures/go/cli_parser.ex
 create mode 100644 test/support/fixtures/go/http_middleware.ex
 create mode 100644 test/support/fixtures/java/builder_pattern.ex
 create mode 100644 test/support/fixtures/java/repository_pattern.ex
 create mode 100644 test/support/fixtures/java/strategy_pattern.ex
 create mode 100644 test/support/fixtures/javascript/calculator.ex
 create mode 100644 test/support/fixtures/javascript/form_validator.ex
 create mode 100644 test/support/fixtures/javascript/shopping_cart.ex
 create mode 100644 test/support/fixtures/kotlin/coroutine_flow.ex
 create mode 100644 test/support/fixtures/kotlin/extension_library.ex
 create mode 100644 test/support/fixtures/kotlin/sealed_state.ex
 create mode 100644 test/support/fixtures/lua/class_system.ex
 create mode 100644 test/support/fixtures/lua/event_system.ex
 create mode 100644 test/support/fixtures/lua/state_machine.ex
 create mode 100644 test/support/fixtures/python/calculator.ex
 create mode 100644 test/support/fixtures/python/config_parser.ex
 create mode 100644 test/support/fixtures/python/csv_pipeline.ex
 create mode 100644 test/support/fixtures/ruby/calculator.ex
 create mode 100644 test/support/fixtures/ruby/markdown_renderer.ex
 create mode 100644 test/support/fixtures/ruby/orm_lite.ex
 create mode 100644 test/support/fixtures/rust/calculator.ex
 create mode 100644 test/support/fixtures/rust/ring_buffer.ex
 create mode 100644 test/support/fixtures/rust/tokenizer.ex
 create mode 100644 test/support/fixtures/scala/actor_messages.ex
 create mode 100644 test/support/fixtures/scala/case_class_algebra.ex
 create mode 100644 test/support/fixtures/scala/typeclass_pattern.ex
 create mode 100644 test/support/fixtures/swift/actor_model.ex
 create mode 100644 test/support/fixtures/swift/combine_stream.ex
 create mode 100644 test/support/fixtures/swift/result_type.ex
 create mode 100644 test/support/fixtures/typescript/dependency_injection.ex
 create mode 100644 test/support/fixtures/typescript/event_emitter.ex
 create mode 100644 test/support/fixtures/typescript/user_profile_store.ex
 create mode 100644 test/support/fixtures/zig/allocator_interface.ex
 create mode 100644 test/support/fixtures/zig/iterator_protocol.ex
 create mode 100644 test/support/fixtures/zig/tagged_union.ex
 create mode 100644 test/support/language_fixture.ex

diff --git a/lib/codeqa/languages/code/native/cpp.ex b/lib/codeqa/languages/code/native/cpp.ex
new file mode 100644
index 0000000..3cc8724
--- /dev/null
+++ b/lib/codeqa/languages/code/native/cpp.ex
@@ -0,0 +1,48 @@
+defmodule CodeQA.Languages.Code.Native.Cpp do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "cpp"
+
+  @impl true
+  def extensions, do: ~w[c cpp cc cxx hpp h hh]
+
+  @impl true
+  def comment_prefixes, do: ~w[//]
+
+  @impl true
+  def block_comments, do: [{"/*", "*/"}]
+
+  @impl true
+  def keywords, do: ~w[
+    if else for while do class struct namespace using include template typename
+    return new delete this public private protected virtual override static
+    const constexpr inline extern try catch throw switch case break continue
+    default auto void true false nullptr
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == != <= >= + - * / % << >> & | ^ ~ && || = += -= *= /= %= -> ::
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ # *
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[class struct namespace template]
+
+  @impl true
+  def branch_keywords, do: ~w[else catch case default]
+
+  @impl true
+  def block_end_tokens, do: ~w[}]
+
+  @impl true
+  def access_modifiers, do: ~w[public private protected static virtual override inline]
+
+  @impl true
+  def module_keywords, do: ~w[class struct namespace enum]
+end
diff --git a/lib/codeqa/languages/code/native/go.ex b/lib/codeqa/languages/code/native/go.ex
new file mode 100644
index 0000000..45ea58d
--- /dev/null
+++ b/lib/codeqa/languages/code/native/go.ex
@@ -0,0 +1,50 @@
+defmodule CodeQA.Languages.Code.Native.Go do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "go"
+
+  @impl true
+  def extensions, do: ~w[go]
+
+  @impl true
+  def comment_prefixes, do: ~w[//]
+
+  @impl true
+  def block_comments, do: [{"/*", "*/"}]
+
+  @impl true
+  def keywords, do: ~w[
+    if else for func type struct interface package import return var const
+    map chan go defer select switch case break continue default fallthrough
+    range make new append len cap close nil true false
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == != <= >= + - * / % << >> & | ^ ~ && || = += -= *= /= %= :=
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ;
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[func type struct interface]
+
+  @impl true
+  def branch_keywords, do: ~w[else case default]
+
+  @impl true
+  def block_end_tokens, do: ~w[}]
+
+  @impl true
+  def access_modifiers, do: []
+
+  @impl true
+  def function_keywords, do: ~w[func]
+
+  @impl true
+  def import_keywords, do: ~w[import package]
+end
diff --git a/lib/codeqa/languages/code/native/haskell.ex b/lib/codeqa/languages/code/native/haskell.ex
new file mode 100644
index 0000000..c0b1075
--- /dev/null
+++ b/lib/codeqa/languages/code/native/haskell.ex
@@ -0,0 +1,56 @@
+defmodule CodeQA.Languages.Code.Native.Haskell do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "haskell"
+
+  @impl true
+  def extensions, do: ~w[hs lhs]
+
+  @impl true
+  def comment_prefixes, do: ~w[--]
+
+  @impl true
+  def block_comments, do: [{"{-", "-}"}]
+
+  @impl true
+  def keywords, do: ~w[
+    if else then for do let in where module import data type newtype class
+    instance deriving case of return True False Nothing Just do
+    infixl infixr infix qualified as hiding
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == /= <= >= + - * / ^ && || ! $ . <$> <*> >>= >> -> <- :: = | @ ~
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; | @ -> <- ::
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[data type newtype class instance]
+
+  @impl true
+  def branch_keywords, do: ~w[else]
+
+  @impl true
+  def block_end_tokens, do: []
+
+  @impl true
+  def function_keywords, do: ~w[where let]
+
+  @impl true
+  def module_keywords, do: ~w[module class instance]
+
+  @impl true
+  def import_keywords, do: ~w[import]
+
+  @impl true
+  def test_keywords, do: ~w[test it describe prop]
+
+  @impl true
+  def uses_colon_indent?, do: true
+end
diff --git a/lib/codeqa/languages/code/native/ocaml.ex b/lib/codeqa/languages/code/native/ocaml.ex
new file mode 100644
index 0000000..6857a5f
--- /dev/null
+++ b/lib/codeqa/languages/code/native/ocaml.ex
@@ -0,0 +1,53 @@
+defmodule CodeQA.Languages.Code.Native.Ocaml do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "ocaml"
+
+  @impl true
+  def extensions, do: ~w[ml mli]
+
+  @impl true
+  def comment_prefixes, do: []
+
+  @impl true
+  def block_comments, do: [{"(*", "*)"}]
+
+  @impl true
+  def keywords, do: ~w[
+    let rec fun if then else for while do done begin end match with type module
+    open struct sig functor val mutable exception raise try when and or not in
+    of as include class object method inherit new virtual
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == = != <> <= >= + - * / mod << >> & | ^ ~ && || @ :: |> -> <- := !
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; | @ ->
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[let type module class]
+
+  @impl true
+  def branch_keywords, do: ~w[else with when]
+
+  @impl true
+  def block_end_tokens, do: ~w[end]
+
+  @impl true
+  def access_modifiers, do: ~w[mutable virtual]
+
+  @impl true
+  def function_keywords, do: ~w[let fun]
+
+  @impl true
+  def module_keywords, do: ~w[module struct functor class]
+
+  @impl true
+  def import_keywords, do: ~w[open include]
+end
diff --git a/lib/codeqa/languages/code/native/rust.ex b/lib/codeqa/languages/code/native/rust.ex
new file mode 100644
index 0000000..4aa7907
--- /dev/null
+++ b/lib/codeqa/languages/code/native/rust.ex
@@ -0,0 +1,53 @@
+defmodule CodeQA.Languages.Code.Native.Rust do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "rust"
+
+  @impl true
+  def extensions, do: ~w[rs]
+
+  @impl true
+  def comment_prefixes, do: ~w[//]
+
+  @impl true
+  def block_comments, do: [{"/*", "*/"}]
+
+  @impl true
+  def keywords, do: ~w[
+    if else for while loop fn struct enum trait impl use mod pub let mut const
+    static return match type where as in ref move async await dyn unsafe extern
+    crate self super true false
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == != <= >= + - * / % << >> & | ^ ~ && || = += -= *= /= %= -> => ::
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ # |
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[fn struct enum trait impl mod]
+
+  @impl true
+  def branch_keywords, do: ~w[else match]
+
+  @impl true
+  def block_end_tokens, do: ~w[}]
+
+  @impl true
+  def access_modifiers, do: ~w[pub]
+
+  @impl true
+  def function_keywords, do: ~w[fn]
+
+  @impl true
+  def module_keywords, do: ~w[impl trait struct enum]
+
+  @impl true
+  def import_keywords, do: ~w[use extern]
+end
diff --git a/lib/codeqa/languages/code/native/swift.ex b/lib/codeqa/languages/code/native/swift.ex
new file mode 100644
index 0000000..1a83b67
--- /dev/null
+++ b/lib/codeqa/languages/code/native/swift.ex
@@ -0,0 +1,53 @@
+defmodule CodeQA.Languages.Code.Native.Swift do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "swift"
+
+  @impl true
+  def extensions, do: ~w[swift]
+
+  @impl true
+  def comment_prefixes, do: ~w[//]
+
+  @impl true
+  def block_comments, do: [{"/*", "*/"}]
+
+  @impl true
+  def keywords, do: ~w[
+    if else for while repeat func class struct enum protocol extension import
+    return let var guard defer do try catch throw switch case break continue
+    default in as is init self super nil true false async await
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == != <= >= + - * / % << >> & | ^ ~ && || ?? = += -= *= /= %= -> =>
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ # |
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[func class struct enum protocol extension]
+
+  @impl true
+  def branch_keywords, do: ~w[else catch case default]
+
+  @impl true
+  def block_end_tokens, do: ~w[}]
+
+  @impl true
+  def access_modifiers, do: ~w[public private internal fileprivate open]
+
+  @impl true
+  def function_keywords, do: ~w[func]
+
+  @impl true
+  def module_keywords, do: ~w[class struct protocol extension enum]
+
+  @impl true
+  def import_keywords, do: ~w[import]
+end
diff --git a/lib/codeqa/languages/code/native/zig.ex b/lib/codeqa/languages/code/native/zig.ex
new file mode 100644
index 0000000..4141a2e
--- /dev/null
+++ b/lib/codeqa/languages/code/native/zig.ex
@@ -0,0 +1,53 @@
+defmodule CodeQA.Languages.Code.Native.Zig do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "zig"
+
+  @impl true
+  def extensions, do: ~w[zig]
+
+  @impl true
+  def comment_prefixes, do: ~w[//]
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    const var fn if else for while switch return pub try catch error defer errdefer
+    comptime inline struct enum union test break continue null undefined unreachable
+    async await suspend resume orelse anytype anyerror bool void noreturn type
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == != <= >= + - * / % << >> & | ^ ~ && || = += -= *= /= %= orelse catch
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[fn struct enum union]
+
+  @impl true
+  def branch_keywords, do: ~w[else]
+
+  @impl true
+  def block_end_tokens, do: ~w[}]
+
+  @impl true
+  def access_modifiers, do: ~w[pub inline comptime]
+
+  @impl true
+  def function_keywords, do: ~w[fn]
+
+  @impl true
+  def module_keywords, do: ~w[struct enum union]
+
+  @impl true
+  def test_keywords, do: ~w[test]
+end
diff --git a/lib/codeqa/languages/code/scripting/julia.ex b/lib/codeqa/languages/code/scripting/julia.ex
new file mode 100644
index 0000000..e99f8e3
--- /dev/null
+++ b/lib/codeqa/languages/code/scripting/julia.ex
@@ -0,0 +1,53 @@
+defmodule CodeQA.Languages.Code.Scripting.Julia do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "julia"
+
+  @impl true
+  def extensions, do: ~w[jl]
+
+  @impl true
+  def comment_prefixes, do: ~w[#]
+
+  @impl true
+  def block_comments, do: [{"#=", "=#"}]
+
+  @impl true
+  def keywords, do: ~w[
+    if else elseif for while do end function return module import using export
+    struct mutable abstract type primitive begin let local global const try catch
+    finally throw macro quote true false nothing
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == != <= >= + - * / % ^ << >> & | ~ && || = += -= *= /= ÷ → ← |>
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ |
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[function struct macro module]
+
+  @impl true
+  def branch_keywords, do: ~w[else elseif catch finally]
+
+  @impl true
+  def block_end_tokens, do: ~w[end]
+
+  @impl true
+  def function_keywords, do: ~w[function macro]
+
+  @impl true
+  def module_keywords, do: ~w[module struct]
+
+  @impl true
+  def import_keywords, do: ~w[import using]
+
+  @impl true
+  def test_keywords, do: ~w[@test @testset]
+end
diff --git a/lib/codeqa/languages/code/scripting/lua.ex b/lib/codeqa/languages/code/scripting/lua.ex
new file mode 100644
index 0000000..e9e94b8
--- /dev/null
+++ b/lib/codeqa/languages/code/scripting/lua.ex
@@ -0,0 +1,46 @@
+defmodule CodeQA.Languages.Code.Scripting.Lua do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "lua"
+
+  @impl true
+  def extensions, do: ~w[lua]
+
+  @impl true
+  def comment_prefixes, do: ~w[--]
+
+  @impl true
+  def block_comments, do: [{"--[[", "]]"}]
+
+  @impl true
+  def keywords, do: ~w[
+    and break do else elseif end false for function goto if in local nil not or
+    repeat return then true until while
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == ~= <= >= + - * / % ^ # & | ~ << >> // .. = and or not
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ;
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[function local]
+
+  @impl true
+  def branch_keywords, do: ~w[else elseif]
+
+  @impl true
+  def block_end_tokens, do: ~w[end]
+
+  @impl true
+  def function_keywords, do: ~w[function]
+
+  @impl true
+  def import_keywords, do: ~w[require]
+end
diff --git a/lib/codeqa/languages/code/scripting/perl.ex b/lib/codeqa/languages/code/scripting/perl.ex
new file mode 100644
index 0000000..5f90eeb
--- /dev/null
+++ b/lib/codeqa/languages/code/scripting/perl.ex
@@ -0,0 +1,53 @@
+defmodule CodeQA.Languages.Code.Scripting.Perl do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "perl"
+
+  @impl true
+  def extensions, do: ~w[pl pm t]
+
+  @impl true
+  def comment_prefixes, do: ~w[#]
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    if else elsif unless for foreach while do until sub my our local use require
+    package return last next redo goto print say die warn eval and or not defined
+    undef true false
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == != <= >= eq ne lt gt le ge + - * / % ** . x = += -= *= /= .= && || ! ~ & |
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ $ %
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[sub package]
+
+  @impl true
+  def branch_keywords, do: ~w[else elsif]
+
+  @impl true
+  def block_end_tokens, do: ~w[}]
+
+  @impl true
+  def function_keywords, do: ~w[sub]
+
+  @impl true
+  def module_keywords, do: ~w[package]
+
+  @impl true
+  def import_keywords, do: ~w[use require]
+
+  @impl true
+  def test_keywords, do: ~w[ok is isnt like unlike cmp_ok]
+end
diff --git a/lib/codeqa/languages/code/scripting/php.ex b/lib/codeqa/languages/code/scripting/php.ex
new file mode 100644
index 0000000..0311e69
--- /dev/null
+++ b/lib/codeqa/languages/code/scripting/php.ex
@@ -0,0 +1,54 @@
+defmodule CodeQA.Languages.Code.Scripting.PHP do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "php"
+
+  @impl true
+  def extensions, do: ~w[php phtml php3 php4 php5 php7 php8]
+
+  @impl true
+  def comment_prefixes, do: ~w[// #]
+
+  @impl true
+  def block_comments, do: [{"/*", "*/"}]
+
+  @impl true
+  def keywords, do: ~w[
+    if else elseif for foreach while do function class interface trait namespace
+    use return new echo print public private protected static abstract final
+    try catch finally throw switch case break continue default include require
+    include_once require_once extends implements null true false
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == === != !== <= >= + - * / % ** << >> & | ^ ~ && || ?? = += -= *= /= %= -> :: =>
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ # $
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[function class interface trait namespace]
+
+  @impl true
+  def branch_keywords, do: ~w[else elseif catch finally case default]
+
+  @impl true
+  def block_end_tokens, do: ~w[} endif endfor endforeach endwhile endswitch]
+
+  @impl true
+  def access_modifiers, do: ~w[public private protected static abstract final]
+
+  @impl true
+  def function_keywords, do: ~w[function fn]
+
+  @impl true
+  def module_keywords, do: ~w[class interface trait namespace]
+
+  @impl true
+  def import_keywords, do: ~w[use namespace]
+end
diff --git a/lib/codeqa/languages/code/scripting/python.ex b/lib/codeqa/languages/code/scripting/python.ex
new file mode 100644
index 0000000..bdb31aa
--- /dev/null
+++ b/lib/codeqa/languages/code/scripting/python.ex
@@ -0,0 +1,56 @@
+defmodule CodeQA.Languages.Code.Scripting.Python do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "python"
+
+  @impl true
+  def extensions, do: ~w[py pyi]
+
+  @impl true
+  def comment_prefixes, do: ~w[#]
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    if else elif for while def class import from return pass break continue
+    not and or in is lambda with as try except finally raise yield async await
+    global nonlocal del assert True False None
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == != <= >= + - * / % ** // << >> & | ^ ~ = += -= *= /= %= **= //=
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ #
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[def class async]
+
+  @impl true
+  def branch_keywords, do: ~w[elif else except finally]
+
+  @impl true
+  def block_end_tokens, do: []
+
+  @impl true
+  def access_modifiers, do: []
+
+  @impl true
+  def function_keywords, do: ~w[def async]
+
+  @impl true
+  def module_keywords, do: ~w[class]
+
+  @impl true
+  def import_keywords, do: ~w[import from]
+
+  @impl true
+  def uses_colon_indent?, do: true
+end
diff --git a/lib/codeqa/languages/code/scripting/r.ex b/lib/codeqa/languages/code/scripting/r.ex
new file mode 100644
index 0000000..c22cb15
--- /dev/null
+++ b/lib/codeqa/languages/code/scripting/r.ex
@@ -0,0 +1,48 @@
+defmodule CodeQA.Languages.Code.Scripting.R do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "r"
+
+  @impl true
+  def extensions, do: ~w[r R Rmd rmd]
+
+  @impl true
+  def comment_prefixes, do: ~w[#]
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    if else for while repeat break next return function TRUE FALSE NULL NA Inf NaN
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == != <= >= + - * / ^ %% %/% %in% <- -> = & | ! && || ~ : ::
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ;
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[function]
+
+  @impl true
+  def branch_keywords, do: ~w[else]
+
+  @impl true
+  def block_end_tokens, do: ~w[}]
+
+  @impl true
+  def function_keywords, do: ~w[function]
+
+  @impl true
+  def import_keywords, do: ~w[library require source]
+
+  @impl true
+  def test_keywords, do: ~w[test_that expect_equal expect_true describe it]
+end
diff --git a/lib/codeqa/languages/code/scripting/ruby.ex b/lib/codeqa/languages/code/scripting/ruby.ex
new file mode 100644
index 0000000..90b17a7
--- /dev/null
+++ b/lib/codeqa/languages/code/scripting/ruby.ex
@@ -0,0 +1,57 @@
+defmodule CodeQA.Languages.Code.Scripting.Ruby do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "ruby"
+
+  @impl true
+  def extensions, do: ~w[rb rake gemspec]
+
+  @impl true
+  def comment_prefixes, do: ~w[#]
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    if else elsif unless for while until def class module do end return begin
+    rescue ensure raise yield include extend require require_relative
+    attr_accessor attr_reader attr_writer then case when next break in
+    and or not true false nil self super
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == != <= >= + - * / % ** << >> & | ^ ~ = += -= *= /= %= **= <=> === =~
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ | # ?
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[def class module]
+
+  @impl true
+  def branch_keywords, do: ~w[else elsif rescue ensure when]
+
+  @impl true
+  def block_end_tokens, do: ~w[end]
+
+  @impl true
+  def access_modifiers, do: []
+
+  @impl true
+  def function_keywords, do: ~w[def]
+
+  @impl true
+  def module_keywords, do: ~w[class module]
+
+  @impl true
+  def import_keywords, do: ~w[require require_relative include]
+
+  @impl true
+  def test_keywords, do: ~w[it describe context scenario feature given]
+end
diff --git a/lib/codeqa/languages/code/scripting/shell.ex b/lib/codeqa/languages/code/scripting/shell.ex
new file mode 100644
index 0000000..acbe37c
--- /dev/null
+++ b/lib/codeqa/languages/code/scripting/shell.ex
@@ -0,0 +1,46 @@
+defmodule CodeQA.Languages.Code.Scripting.Shell do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "shell"
+
+  @impl true
+  def extensions, do: ~w[sh bash zsh fish]
+
+  @impl true
+  def comment_prefixes, do: ~w[#]
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    if else elif fi for while do done case esac function return then in until
+    select break continue exit local export readonly unset
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == != <= >= + - * / % && || | & > < >> << = += -= *= /= %= -eq -ne -lt -gt -le -ge
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ # $ ! ? |
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[function]
+
+  @impl true
+  def branch_keywords, do: ~w[else elif case]
+
+  @impl true
+  def block_end_tokens, do: ~w[fi done esac]
+
+  @impl true
+  def access_modifiers, do: []
+
+  @impl true
+  def function_keywords, do: ~w[function]
+end
diff --git a/lib/codeqa/languages/code/vm/clojure.ex b/lib/codeqa/languages/code/vm/clojure.ex
new file mode 100644
index 0000000..770b280
--- /dev/null
+++ b/lib/codeqa/languages/code/vm/clojure.ex
@@ -0,0 +1,53 @@
+defmodule CodeQA.Languages.Code.Vm.Clojure do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "clojure"
+
+  @impl true
+  def extensions, do: ~w[clj cljs cljc edn]
+
+  @impl true
+  def comment_prefixes, do: ~w[;]
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    def defn defmacro let fn if do when cond case for loop recur ns require use
+    import try catch finally throw quote defprotocol defrecord deftype reify
+    extend-type extend-protocol nil true false and or not
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    = == not= < > <= >= + - * / mod rem quot and or not
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; # @ ^
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[def defn defmacro defprotocol defrecord deftype]
+
+  @impl true
+  def branch_keywords, do: ~w[else]
+
+  @impl true
+  def block_end_tokens, do: ~w[)]
+
+  @impl true
+  def function_keywords, do: ~w[defn fn]
+
+  @impl true
+  def module_keywords, do: ~w[ns defprotocol defrecord]
+
+  @impl true
+  def import_keywords, do: ~w[ns require use import]
+
+  @impl true
+  def test_keywords, do: ~w[deftest is testing]
+end
diff --git a/lib/codeqa/languages/code/vm/csharp.ex b/lib/codeqa/languages/code/vm/csharp.ex
new file mode 100644
index 0000000..b90933f
--- /dev/null
+++ b/lib/codeqa/languages/code/vm/csharp.ex
@@ -0,0 +1,53 @@
+defmodule CodeQA.Languages.Code.Vm.CSharp do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "csharp"
+
+  @impl true
+  def extensions, do: ~w[cs csx]
+
+  @impl true
+  def comment_prefixes, do: ~w[//]
+
+  @impl true
+  def block_comments, do: [{"/*", "*/"}]
+
+  @impl true
+  def keywords, do: ~w[
+    if else for foreach while do class interface struct enum namespace using
+    return var new this base public private protected internal static abstract
+    virtual override sealed async await try catch finally throw switch case
+    break continue default in out ref void true false null readonly const
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == != <= >= + - * / % << >> & | ^ ~ && || ?? = += -= *= /= %=
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ # =>
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[class interface struct enum namespace]
+
+  @impl true
+  def branch_keywords, do: ~w[else catch finally case default]
+
+  @impl true
+  def block_end_tokens, do: ~w[}]
+
+  @impl true
+  def access_modifiers,
+    do:
+      ~w[public private protected internal static abstract virtual override sealed readonly const async]
+
+  @impl true
+  def module_keywords, do: ~w[class interface struct enum namespace]
+
+  @impl true
+  def import_keywords, do: ~w[using namespace]
+end
diff --git a/lib/codeqa/languages/code/vm/dart.ex b/lib/codeqa/languages/code/vm/dart.ex
new file mode 100644
index 0000000..16e29de
--- /dev/null
+++ b/lib/codeqa/languages/code/vm/dart.ex
@@ -0,0 +1,57 @@
+defmodule CodeQA.Languages.Code.Vm.Dart do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "dart"
+
+  @impl true
+  def extensions, do: ~w[dart]
+
+  @impl true
+  def comment_prefixes, do: ~w[//]
+
+  @impl true
+  def block_comments, do: [{"/*", "*/"}]
+
+  @impl true
+  def keywords, do: ~w[
+    if else for while do switch case break continue return class extends implements
+    with new final const var void null true false import export part library
+    abstract static dynamic async await yield try catch finally throw rethrow
+    enum typedef mixin factory is as in
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == != <= >= + - * / % ~/ << >> & | ^ ~ && || ?? = += -= *= /= %= ??= -> =>
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ # =>
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[class enum typedef mixin]
+
+  @impl true
+  def branch_keywords, do: ~w[else catch finally case]
+
+  @impl true
+  def block_end_tokens, do: ~w[}]
+
+  @impl true
+  def access_modifiers, do: ~w[static final const abstract]
+
+  @impl true
+  def function_keywords, do: ~w[void async]
+
+  @impl true
+  def module_keywords, do: ~w[class enum mixin]
+
+  @impl true
+  def import_keywords, do: ~w[import export]
+
+  @impl true
+  def test_keywords, do: ~w[test group setUp tearDown expect]
+end
diff --git a/lib/codeqa/languages/code/vm/elixir.ex b/lib/codeqa/languages/code/vm/elixir.ex
new file mode 100644
index 0000000..401f808
--- /dev/null
+++ b/lib/codeqa/languages/code/vm/elixir.ex
@@ -0,0 +1,58 @@
+defmodule CodeQA.Languages.Code.Vm.Elixir do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "elixir"
+
+  @impl true
+  def extensions, do: ~w[ex exs]
+
+  @impl true
+  def comment_prefixes, do: ~w[#]
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    if else unless for do end def defp defmodule defmacro defmacrop defprotocol
+    defimpl defguard defdelegate defstruct case cond with when fn try rescue
+    catch raise receive in not and or true false nil
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == === != !== <= >= + - * / % << >> & | ^ ~ && || |> <> <- -> = ! not and or in
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ |
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords,
+    do:
+      ~w[def defp defmodule defmacro defmacrop defprotocol defimpl defdelegate defoverridable defguard]
+
+  @impl true
+  def branch_keywords, do: ~w[else rescue catch ensure cond when case]
+
+  @impl true
+  def block_end_tokens, do: ~w[end]
+
+  @impl true
+  def access_modifiers, do: []
+
+  @impl true
+  def function_keywords, do: ~w[def defp defmacro defmacrop defdelegate defguard]
+
+  @impl true
+  def module_keywords, do: ~w[defmodule defprotocol defimpl]
+
+  @impl true
+  def import_keywords, do: ~w[import require use alias]
+
+  @impl true
+  def test_keywords, do: ~w[test describe]
+end
diff --git a/lib/codeqa/languages/code/vm/erlang.ex b/lib/codeqa/languages/code/vm/erlang.ex
new file mode 100644
index 0000000..d390e01
--- /dev/null
+++ b/lib/codeqa/languages/code/vm/erlang.ex
@@ -0,0 +1,53 @@
+defmodule CodeQA.Languages.Code.Vm.Erlang do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "erlang"
+
+  @impl true
+  def extensions, do: ~w[erl hrl]
+
+  @impl true
+  def comment_prefixes, do: ~w[%]
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    if case when of begin end receive after fun try catch throw error exit
+    module export import define record true false ok undefined andalso orelse
+    not band bor bxor bnot bsl bsr div rem
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == /= =< >= =:= =/= + - * / ! <- -> :: | . , ; :
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; | ->
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[-module -record -define]
+
+  @impl true
+  def branch_keywords, do: ~w[of after catch]
+
+  @impl true
+  def block_end_tokens, do: ~w[end]
+
+  @impl true
+  def function_keywords, do: ~w[fun]
+
+  @impl true
+  def module_keywords, do: ~w[-module]
+
+  @impl true
+  def import_keywords, do: ~w[-import -include]
+
+  @impl true
+  def test_keywords, do: ~w[_test_ _test]
+end
diff --git a/lib/codeqa/languages/code/vm/fsharp.ex b/lib/codeqa/languages/code/vm/fsharp.ex
new file mode 100644
index 0000000..e6b12ef
--- /dev/null
+++ b/lib/codeqa/languages/code/vm/fsharp.ex
@@ -0,0 +1,59 @@
+defmodule CodeQA.Languages.Code.Vm.Fsharp do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "fsharp"
+
+  @impl true
+  def extensions, do: ~w[fs fsi fsx]
+
+  @impl true
+  def comment_prefixes, do: ~w[//]
+
+  @impl true
+  def block_comments, do: [{"(*", "*)"}]
+
+  @impl true
+  def keywords, do: ~w[
+    let rec if then else for while do match with type module open namespace val
+    mutable abstract member override new return yield async await try finally
+    raise true false null and or not in when downto to
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == != <= >= + - * / % << >> & | ^ ~ && || = |> <| >> << -> <- :: @ ?
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; | @ # ->
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[let type module]
+
+  @impl true
+  def branch_keywords, do: ~w[else with]
+
+  @impl true
+  def block_end_tokens, do: []
+
+  @impl true
+  def access_modifiers, do: ~w[public private protected internal static abstract override]
+
+  @impl true
+  def function_keywords, do: ~w[let fun]
+
+  @impl true
+  def module_keywords, do: ~w[module namespace type]
+
+  @impl true
+  def import_keywords, do: ~w[open]
+
+  @impl true
+  def test_keywords, do: ~w[testCase test testProperty]
+
+  @impl true
+  def uses_colon_indent?, do: true
+end
diff --git a/lib/codeqa/languages/code/vm/java.ex b/lib/codeqa/languages/code/vm/java.ex
new file mode 100644
index 0000000..151bee1
--- /dev/null
+++ b/lib/codeqa/languages/code/vm/java.ex
@@ -0,0 +1,51 @@
+defmodule CodeQA.Languages.Code.Vm.Java do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "java"
+
+  @impl true
+  def extensions, do: ~w[java]
+
+  @impl true
+  def comment_prefixes, do: ~w[//]
+
+  @impl true
+  def block_comments, do: [{"/*", "*/"}]
+
+  @impl true
+  def keywords, do: ~w[
+    if else for while do class interface extends implements import package
+    return new this super public private protected static abstract final
+    synchronized volatile try catch finally throw throws switch case break
+    continue default void true false null instanceof
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == != <= >= + - * / % << >> >>> & | ^ ~ && || = += -= *= /= %=
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[class interface]
+
+  @impl true
+  def branch_keywords, do: ~w[else catch finally case default]
+
+  @impl true
+  def block_end_tokens, do: ~w[}]
+
+  @impl true
+  def access_modifiers, do: ~w[public private protected static abstract final synchronized]
+
+  @impl true
+  def module_keywords, do: ~w[class interface enum]
+
+  @impl true
+  def import_keywords, do: ~w[import package]
+end
diff --git a/lib/codeqa/languages/code/vm/kotlin.ex b/lib/codeqa/languages/code/vm/kotlin.ex
new file mode 100644
index 0000000..72980a2
--- /dev/null
+++ b/lib/codeqa/languages/code/vm/kotlin.ex
@@ -0,0 +1,54 @@
+defmodule CodeQA.Languages.Code.Vm.Kotlin do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "kotlin"
+
+  @impl true
+  def extensions, do: ~w[kt kts]
+
+  @impl true
+  def comment_prefixes, do: ~w[//]
+
+  @impl true
+  def block_comments, do: [{"/*", "*/"}]
+
+  @impl true
+  def keywords, do: ~w[
+    if else for while do fun class object interface data sealed abstract enum
+    companion import package return val var when is as in out by override open
+    final private protected public internal suspend inline reified crossinline
+    noinline try catch finally throw break continue null true false this super init
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == === != !== <= >= + - * / % << >> & | ^ ~ && || ?: = += -= *= /= %= -> => ::
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ # |
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[fun class object interface data sealed abstract enum]
+
+  @impl true
+  def branch_keywords, do: ~w[else when catch finally]
+
+  @impl true
+  def block_end_tokens, do: ~w[}]
+
+  @impl true
+  def access_modifiers, do: ~w[public private protected internal override open abstract final]
+
+  @impl true
+  def function_keywords, do: ~w[fun]
+
+  @impl true
+  def module_keywords, do: ~w[class interface object]
+
+  @impl true
+  def import_keywords, do: ~w[import package]
+end
diff --git a/lib/codeqa/languages/code/vm/scala.ex b/lib/codeqa/languages/code/vm/scala.ex
new file mode 100644
index 0000000..55a7a00
--- /dev/null
+++ b/lib/codeqa/languages/code/vm/scala.ex
@@ -0,0 +1,57 @@
+defmodule CodeQA.Languages.Code.Vm.Scala do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "scala"
+
+  @impl true
+  def extensions, do: ~w[scala sc]
+
+  @impl true
+  def comment_prefixes, do: ~w[//]
+
+  @impl true
+  def block_comments, do: [{"/*", "*/"}]
+
+  @impl true
+  def keywords, do: ~w[
+    if else for while do def class object trait extends with new return import
+    package val var type match case sealed abstract override final protected
+    private implicit lazy yield try catch finally throw true false null this super
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == != <= >= + - * / % << >> & | ^ ~ && || = += -= *= /= => <- <: >: :
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ # =>
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[def class object trait type]
+
+  @impl true
+  def branch_keywords, do: ~w[else catch case finally]
+
+  @impl true
+  def block_end_tokens, do: ~w[}]
+
+  @impl true
+  def access_modifiers,
+    do: ~w[public private protected override abstract final sealed implicit lazy]
+
+  @impl true
+  def function_keywords, do: ~w[def]
+
+  @impl true
+  def module_keywords, do: ~w[class object trait package]
+
+  @impl true
+  def import_keywords, do: ~w[import package]
+
+  @impl true
+  def test_keywords, do: ~w[test it describe should]
+end
diff --git a/lib/codeqa/languages/code/web/javascript.ex b/lib/codeqa/languages/code/web/javascript.ex
new file mode 100644
index 0000000..38194f1
--- /dev/null
+++ b/lib/codeqa/languages/code/web/javascript.ex
@@ -0,0 +1,56 @@
+defmodule CodeQA.Languages.Code.Web.JavaScript do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "javascript"
+
+  @impl true
+  def extensions, do: ~w[js mjs cjs jsx vue svelte]
+
+  @impl true
+  def comment_prefixes, do: ~w[//]
+
+  @impl true
+  def block_comments, do: [{"/*", "*/"}]
+
+  @impl true
+  def keywords, do: ~w[
+    if else for while function class return var let const import export from
+    new this typeof instanceof try catch finally throw switch case break
+    continue default delete in of async await yield true false null undefined
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == === != !== <= >= + - * / % ** << >> >>> & | ^ ~ && || ?? = += -= *= /= %=
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ # =>
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[function class async]
+
+  @impl true
+  def branch_keywords, do: ~w[else catch finally case default]
+
+  @impl true
+  def block_end_tokens, do: ~w[}]
+
+  @impl true
+  def access_modifiers, do: ~w[export static]
+
+  @impl true
+  def function_keywords, do: ~w[function async]
+
+  @impl true
+  def module_keywords, do: ~w[class]
+
+  @impl true
+  def import_keywords, do: ~w[import]
+
+  @impl true
+  def test_keywords, do: ~w[test it describe context scenario feature given]
+end
diff --git a/lib/codeqa/languages/code/web/typescript.ex b/lib/codeqa/languages/code/web/typescript.ex
new file mode 100644
index 0000000..23ab690
--- /dev/null
+++ b/lib/codeqa/languages/code/web/typescript.ex
@@ -0,0 +1,59 @@
+defmodule CodeQA.Languages.Code.Web.TypeScript do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "typescript"
+
+  @impl true
+  def extensions, do: ~w[ts tsx]
+
+  @impl true
+  def comment_prefixes, do: ~w[//]
+
+  @impl true
+  def block_comments, do: [{"/*", "*/"}]
+
+  @impl true
+  def keywords, do: ~w[
+    if else for while function class return var let const import export from
+    new this typeof instanceof try catch finally throw switch case break
+    continue default delete in of async await yield true false null undefined
+    type interface enum namespace declare abstract override readonly implements
+    extends satisfies as keyof typeof infer never unknown any void
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == === != !== <= >= + - * / % ** << >> >>> & | ^ ~ && || ?? = += -= *= /= %=
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ # => <
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[function class async interface enum namespace type declare]
+
+  @impl true
+  def branch_keywords, do: ~w[else catch finally case default]
+
+  @impl true
+  def block_end_tokens, do: ~w[}]
+
+  @impl true
+  def access_modifiers,
+    do: ~w[export public private protected static abstract override readonly sealed]
+
+  @impl true
+  def function_keywords, do: ~w[function async]
+
+  @impl true
+  def module_keywords, do: ~w[class interface enum namespace]
+
+  @impl true
+  def import_keywords, do: ~w[import]
+
+  @impl true
+  def test_keywords, do: ~w[test it describe context scenario feature given]
+end
diff --git a/lib/codeqa/languages/config/dockerfile.ex b/lib/codeqa/languages/config/dockerfile.ex
new file mode 100644
index 0000000..97373ea
--- /dev/null
+++ b/lib/codeqa/languages/config/dockerfile.ex
@@ -0,0 +1,34 @@
+defmodule CodeQA.Languages.Config.Dockerfile do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "dockerfile"
+
+  @impl true
+  def extensions, do: ~w[Dockerfile]
+
+  @impl true
+  def comment_prefixes, do: ~w[#]
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    FROM RUN CMD LABEL EXPOSE ENV ADD COPY ENTRYPOINT VOLUME USER WORKDIR ARG
+    ONBUILD STOPSIGNAL HEALTHCHECK SHELL AS
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    = \
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) , : #
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def declaration_keywords, do: ~w[FROM]
+end
diff --git a/lib/codeqa/languages/config/makefile.ex b/lib/codeqa/languages/config/makefile.ex
new file mode 100644
index 0000000..6ad3d7b
--- /dev/null
+++ b/lib/codeqa/languages/config/makefile.ex
@@ -0,0 +1,31 @@
+defmodule CodeQA.Languages.Config.Makefile do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "makefile"
+
+  @impl true
+  def extensions, do: ~w[Makefile GNUmakefile mk]
+
+  @impl true
+  def comment_prefixes, do: ~w[#]
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    ifeq ifneq ifdef ifndef else endif define endef include export unexport
+    override private vpath all clean install
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    = := ::= ?= += !=
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; @ $ % # \
+  ] ++ ~w( [ ] )
+end
diff --git a/lib/codeqa/languages/config/terraform.ex b/lib/codeqa/languages/config/terraform.ex
new file mode 100644
index 0000000..bf257bc
--- /dev/null
+++ b/lib/codeqa/languages/config/terraform.ex
@@ -0,0 +1,32 @@
+defmodule CodeQA.Languages.Config.Terraform do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "terraform"
+
+  @impl true
+  def extensions, do: ~w[tf tfvars]
+
+  @impl true
+  def comment_prefixes, do: ~w[# //]
+
+  @impl true
+  def block_comments, do: [{"/*", "*/"}]
+
+  @impl true
+  def keywords, do: ~w[
+    resource data variable output locals module provider terraform
+    required_providers backend for_each count depends_on lifecycle
+    source version true false null for if
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    = == != <= >= && || ! ? :
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    { } ( ) , . : = " # //
+  ] ++ ~w( [ ] )
+end
diff --git a/lib/codeqa/languages/data/graphql.ex b/lib/codeqa/languages/data/graphql.ex
new file mode 100644
index 0000000..70e02e2
--- /dev/null
+++ b/lib/codeqa/languages/data/graphql.ex
@@ -0,0 +1,31 @@
+defmodule CodeQA.Languages.Data.GraphQL do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "graphql"
+
+  @impl true
+  def extensions, do: ~w[graphql gql]
+
+  @impl true
+  def comment_prefixes, do: ~w[#]
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    query mutation subscription fragment on type interface union enum input
+    scalar schema directive extend implements true false null
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    = : ! | &
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    { } ( ) , . : # @ !
+  ] ++ ~w( [ ] )
+end
diff --git a/lib/codeqa/languages/data/json.ex b/lib/codeqa/languages/data/json.ex
new file mode 100644
index 0000000..c0b0589
--- /dev/null
+++ b/lib/codeqa/languages/data/json.ex
@@ -0,0 +1,30 @@
+defmodule CodeQA.Languages.Data.Json do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "json"
+
+  @impl true
+  def extensions, do: ~w[json jsonc]
+
+  @impl true
+  def comment_prefixes, do: []
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    true false null
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    :
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    { } , " '
+  ] ++ ~w( [ ] )
+end
diff --git a/lib/codeqa/languages/data/sql.ex b/lib/codeqa/languages/data/sql.ex
new file mode 100644
index 0000000..9178fe5
--- /dev/null
+++ b/lib/codeqa/languages/data/sql.ex
@@ -0,0 +1,39 @@
+defmodule CodeQA.Languages.Data.Sql do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "sql"
+
+  @impl true
+  def extensions, do: ~w[sql]
+
+  @impl true
+  def comment_prefixes, do: ~w[--]
+
+  @impl true
+  def block_comments, do: [{"/*", "*/"}]
+
+  @impl true
+  def keywords, do: ~w[
+    SELECT FROM WHERE INSERT INTO UPDATE DELETE SET CREATE DROP ALTER TABLE
+    INDEX VIEW JOIN LEFT RIGHT INNER OUTER FULL CROSS ON AND OR NOT IN EXISTS
+    AS GROUP BY ORDER HAVING LIMIT OFFSET DISTINCT NULL TRUE FALSE PRIMARY KEY
+    FOREIGN REFERENCES CASCADE UNIQUE DEFAULT VALUES RETURNING WITH UNION
+    INTERSECT EXCEPT CASE WHEN THEN ELSE END IF BEGIN COMMIT ROLLBACK
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    = != <> <= >= + - * / % LIKE BETWEEN IS IN
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) , . ; ' " -- /*
+  ] ++ ~w( [ ] )
+
+  @impl true
+  def statement_keywords,
+    do:
+      ~w[select insert update delete create drop alter truncate begin commit rollback call execute]
+end
diff --git a/lib/codeqa/languages/data/toml.ex b/lib/codeqa/languages/data/toml.ex
new file mode 100644
index 0000000..9f555a3
--- /dev/null
+++ b/lib/codeqa/languages/data/toml.ex
@@ -0,0 +1,30 @@
+defmodule CodeQA.Languages.Data.Toml do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "toml"
+
+  @impl true
+  def extensions, do: ~w[toml]
+
+  @impl true
+  def comment_prefixes, do: ~w[#]
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    true false
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    =
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    { } , . : # " '
+  ] ++ ~w( [ ] )
+end
diff --git a/lib/codeqa/languages/data/yaml.ex b/lib/codeqa/languages/data/yaml.ex
new file mode 100644
index 0000000..77d8f1f
--- /dev/null
+++ b/lib/codeqa/languages/data/yaml.ex
@@ -0,0 +1,30 @@
+defmodule CodeQA.Languages.Data.Yaml do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "yaml"
+
+  @impl true
+  def extensions, do: ~w[yml yaml]
+
+  @impl true
+  def comment_prefixes, do: ~w[#]
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    true false null yes no on off
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    : | > & * !
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    { } , . # @ ---
+  ] ++ ~w( [ ] )
+end
diff --git a/lib/codeqa/languages/language.ex b/lib/codeqa/languages/language.ex
new file mode 100644
index 0000000..ada7fa1
--- /dev/null
+++ b/lib/codeqa/languages/language.ex
@@ -0,0 +1,180 @@
+defmodule CodeQA.Language do
+  @callback name() :: String.t()
+  @callback extensions() :: [String.t()]
+  @callback comment_prefixes() :: [String.t()]
+  @callback block_comments() :: [{String.t(), String.t()}]
+  @callback keywords() :: [String.t()]
+  @callback operators() :: [String.t()]
+  @callback delimiters() :: [String.t()]
+
+  @callback declaration_keywords() :: [String.t()]
+  @callback branch_keywords() :: [String.t()]
+  @callback block_end_tokens() :: [String.t()]
+  @callback access_modifiers() :: [String.t()]
+  @callback statement_keywords() :: [String.t()]
+
+  @callback function_keywords() :: [String.t()]
+  @callback module_keywords() :: [String.t()]
+  @callback import_keywords() :: [String.t()]
+  @callback test_keywords() :: [String.t()]
+  @callback uses_colon_indent?() :: boolean()
+  @callback divider_indicators() :: [String.t()]
+
+  @optional_callbacks [
+    declaration_keywords: 0,
+    branch_keywords: 0,
+    block_end_tokens: 0,
+    access_modifiers: 0,
+    statement_keywords: 0,
+    function_keywords: 0,
+    module_keywords: 0,
+    import_keywords: 0,
+    test_keywords: 0,
+    uses_colon_indent?: 0,
+    divider_indicators: 0
+  ]
+
+  defmacro __using__(_opts) do
+    quote do
+      @behaviour CodeQA.Language
+      def declaration_keywords, do: []
+      def branch_keywords, do: []
+      def block_end_tokens, do: []
+      def access_modifiers, do: []
+      def statement_keywords, do: []
+      def function_keywords, do: []
+      def module_keywords, do: []
+      def import_keywords, do: []
+      def test_keywords, do: []
+      def uses_colon_indent?, do: false
+      def divider_indicators, do: ~w[-- - == === ~ * ** # // / =]
+
+      defoverridable declaration_keywords: 0,
+                     branch_keywords: 0,
+                     block_end_tokens: 0,
+                     access_modifiers: 0,
+                     statement_keywords: 0,
+                     function_keywords: 0,
+                     module_keywords: 0,
+                     import_keywords: 0,
+                     test_keywords: 0,
+                     uses_colon_indent?: 0,
+                     divider_indicators: 0
+    end
+  end
+
+  @spec all() :: [module()]
+  def all do
+    {:ok, modules} = :application.get_key(:codeqa, :modules)
+    Enum.filter(modules, &implements?/1)
+  end
+
+  @spec all_keywords() :: [String.t()]
+  def all_keywords do
+    all()
+    |> Enum.flat_map(& &1.keywords())
+    |> Enum.uniq()
+  end
+
+  @spec keywords(atom() | String.t()) :: MapSet.t()
+  def keywords(language) do
+    case find(language) do
+      nil -> MapSet.new()
+      mod -> MapSet.new(mod.keywords())
+    end
+  end
+
+  @spec operators(atom() | String.t()) :: MapSet.t()
+  def operators(language) do
+    case find(language) do
+      nil -> MapSet.new()
+      mod -> MapSet.new(mod.operators())
+    end
+  end
+
+  @spec delimiters(atom() | String.t()) :: MapSet.t()
+  def delimiters(language) do
+    case find(language) do
+      nil -> MapSet.new()
+      mod -> MapSet.new(mod.delimiters())
+    end
+  end
+
+  @spec declaration_keywords(module()) :: MapSet.t()
+  def declaration_keywords(mod), do: MapSet.new(mod.declaration_keywords())
+
+  @spec branch_keywords(module()) :: MapSet.t()
+  def branch_keywords(mod), do: MapSet.new(mod.branch_keywords())
+
+  @spec block_end_tokens(module()) :: MapSet.t()
+  def block_end_tokens(mod), do: MapSet.new(mod.block_end_tokens())
+
+  @spec access_modifiers(module()) :: MapSet.t()
+  def access_modifiers(mod), do: MapSet.new(mod.access_modifiers())
+
+  @spec statement_keywords(module()) :: MapSet.t()
+  def statement_keywords(mod), do: MapSet.new(mod.statement_keywords())
+
+  @spec function_keywords(module()) :: MapSet.t()
+  def function_keywords(mod), do: MapSet.new(mod.function_keywords())
+
+  @spec module_keywords(module()) :: MapSet.t()
+  def module_keywords(mod), do: MapSet.new(mod.module_keywords())
+
+  @spec import_keywords(module()) :: MapSet.t()
+  def import_keywords(mod), do: MapSet.new(mod.import_keywords())
+
+  @spec test_keywords(module()) :: MapSet.t()
+  def test_keywords(mod), do: MapSet.new(mod.test_keywords())
+
+  @spec divider_indicators(module()) :: MapSet.t()
+  def divider_indicators(mod), do: MapSet.new(mod.divider_indicators())
+
+  @spec find(atom() | String.t()) :: module()
+  def find(language) do
+    name = to_string(language)
+    Enum.find(all(), fn mod -> mod.name() == name end) || CodeQA.Languages.Unknown
+  end
+
+  @spec detect(String.t()) :: module()
+  def detect(path) do
+    basename = Path.basename(path)
+    ext = path |> Path.extname() |> String.trim_leading(".")
+
+    Enum.find(all(), fn mod ->
+      ext in mod.extensions() or (ext == "" and basename in mod.extensions())
+    end) || CodeQA.Languages.Unknown
+  end
+
+  @spec strip_comments(String.t(), module()) :: String.t()
+  def strip_comments(content, language_mod) do
+    content
+    |> strip_block_comments(language_mod.block_comments())
+    |> strip_line_comments(language_mod.comment_prefixes())
+  end
+
+  defp strip_block_comments(content, []), do: content
+
+  defp strip_block_comments(content, pairs) do
+    Enum.reduce(pairs, content, fn {open, close}, acc ->
+      regex = Regex.compile!(Regex.escape(open) <> ".*?" <> Regex.escape(close), [:dotall])
+
+      Regex.replace(regex, acc, fn match ->
+        String.replace(match, ~r/[^\n]/, "")
+      end)
+    end)
+  end
+
+  defp strip_line_comments(content, []), do: content
+
+  defp strip_line_comments(content, prefixes) do
+    pattern = prefixes |> Enum.map(&Regex.escape/1) |> Enum.join("|")
+    Regex.replace(Regex.compile!("(#{pattern}).*$", [:multiline]), content, "")
+  end
+
+  defp implements?(module) do
+    CodeQA.Language in (module.__info__(:attributes)[:behaviour] || [])
+  rescue
+    _ -> false
+  end
+end
diff --git a/lib/codeqa/languages/markup/css.ex b/lib/codeqa/languages/markup/css.ex
new file mode 100644
index 0000000..81a8e7c
--- /dev/null
+++ b/lib/codeqa/languages/markup/css.ex
@@ -0,0 +1,31 @@
+defmodule CodeQA.Languages.Markup.Css do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "css"
+
+  @impl true
+  def extensions, do: ~w[css scss sass less]
+
+  @impl true
+  def comment_prefixes, do: []
+
+  @impl true
+  def block_comments, do: [{"/*", "*/"}]
+
+  @impl true
+  def keywords, do: ~w[
+    media keyframes import charset supports layer font-face from to
+    auto none inherit initial unset normal bold italic
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    : ; > + ~ * = ^= $= *= ~= |=
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    { } ( ) , . # : ; @
+  ] ++ ~w( [ ] )
+end
diff --git a/lib/codeqa/languages/markup/html.ex b/lib/codeqa/languages/markup/html.ex
new file mode 100644
index 0000000..4835835
--- /dev/null
+++ b/lib/codeqa/languages/markup/html.ex
@@ -0,0 +1,33 @@
+defmodule CodeQA.Languages.Markup.Html do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "html"
+
+  @impl true
+  def extensions, do: ~w[html htm heex eex leex erb htmlbars hbs mustache jinja jinja2 njk liquid]
+
+  @impl true
+  def comment_prefixes, do: []
+
+  @impl true
+  def block_comments, do: [{"<!--", "-->"}]
+
+  @impl true
+  def keywords, do: ~w[
+    html head body div span p a img input form button select option textarea
+    script style link meta title h1 h2 h3 h4 h5 h6 ul ol li table tr td th
+    header footer nav main section article aside figure figcaption
+    class id href src type name value rel action method placeholder
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    < > / = &
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { } , . : ; " ' # ! ?
+  ] ++ ~w( [ ] )
+end
diff --git a/lib/codeqa/languages/markup/markdown.ex b/lib/codeqa/languages/markup/markdown.ex
new file mode 100644
index 0000000..1e81a8c
--- /dev/null
+++ b/lib/codeqa/languages/markup/markdown.ex
@@ -0,0 +1,30 @@
+defmodule CodeQA.Languages.Markup.Markdown do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "markdown"
+
+  @impl true
+  def extensions, do: ~w[md mdx]
+
+  @impl true
+  def comment_prefixes, do: []
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    TODO NOTE FIXME WARNING IMPORTANT
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    # ## ### #### ##### ###### > ``` ** * _ __ ~~
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) . ! ? ` * _ ~
+  ] ++ ~w( [ ] )
+end
diff --git a/lib/codeqa/languages/markup/xml.ex b/lib/codeqa/languages/markup/xml.ex
new file mode 100644
index 0000000..8c136c9
--- /dev/null
+++ b/lib/codeqa/languages/markup/xml.ex
@@ -0,0 +1,30 @@
+defmodule CodeQA.Languages.Markup.Xml do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "xml"
+
+  @impl true
+  def extensions, do: ~w[xml svg xsl xslt xsd wsdl plist]
+
+  @impl true
+  def comment_prefixes, do: []
+
+  @impl true
+  def block_comments, do: [{"<!--", "-->"}]
+
+  @impl true
+  def keywords, do: ~w[
+    xmlns version encoding standalone
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    < > / = &
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) , . : ; " ' # ! ?
+  ] ++ ~w( [ ] )
+end
diff --git a/lib/codeqa/languages/unknown.ex b/lib/codeqa/languages/unknown.ex
new file mode 100644
index 0000000..9873a86
--- /dev/null
+++ b/lib/codeqa/languages/unknown.ex
@@ -0,0 +1,30 @@
+defmodule CodeQA.Languages.Unknown do
+  use CodeQA.Language
+
+  @impl true
+  def name, do: "unknown"
+
+  @impl true
+  def extensions, do: []
+
+  @impl true
+  def comment_prefixes, do: []
+
+  @impl true
+  def block_comments, do: []
+
+  @impl true
+  def keywords, do: ~w[
+    if else
+  ]
+
+  @impl true
+  def operators, do: ~w[
+    == !=
+  ]
+
+  @impl true
+  def delimiters, do: ~w[
+    ( ) { }
+  ]
+end
diff --git a/test/fixtures/sample.ex b/test/fixtures/sample.ex
index 16d90fc..625d9cb 100644
--- a/test/fixtures/sample.ex
+++ b/test/fixtures/sample.ex
@@ -1,4 +1,5 @@
 defmodule Sample do
+  @moduledoc false
   def hello do
     IO.puts("Hello, world!")
   end
diff --git a/test/support/fixtures/cpp/observer_pattern.ex b/test/support/fixtures/cpp/observer_pattern.ex
new file mode 100644
index 0000000..b536d35
--- /dev/null
+++ b/test/support/fixtures/cpp/observer_pattern.ex
@@ -0,0 +1,71 @@
+defmodule Test.Fixtures.Cpp.ObserverPattern do
+  @moduledoc false
+  use Test.LanguageFixture, language: "cpp observer_pattern"
+
+  @code ~S'''
+  #include <vector>
+  #include <functional>
+
+  template<typename Event>
+  class Observer {
+  public:
+    virtual void onEvent(const Event& event) = 0;
+
+    virtual ~Observer() = default;
+  };
+
+  template<typename Event>
+  class Subject {
+    std::vector<Observer<Event>*> observers;
+
+  public:
+    void attach(Observer<Event>* observer) { observers.push_back(observer); }
+
+    void detach(Observer<Event>* observer) {
+      observers.erase(
+        std::remove(observers.begin(), observers.end(), observer),
+        observers.end()
+      );
+    }
+
+    void notify(const Event& event) {
+      for (auto* obs : observers) obs->onEvent(event);
+    }
+  };
+
+  struct StockEvent {
+    std::string symbol;
+    double price;
+    double previousPrice;
+
+    double change() const { return price - previousPrice; }
+
+    double changePercent() const { return previousPrice > 0 ? change() / previousPrice * 100.0 : 0.0; }
+  };
+
+  class StockTicker : public Subject<StockEvent> {
+    std::map<std::string, double> prices;
+
+  public:
+    void updatePrice(const std::string& symbol, double newPrice) {
+      double prev = prices.count(symbol) ? prices[symbol] : newPrice;
+      prices[symbol] = newPrice;
+      notify(StockEvent{symbol, newPrice, prev});
+    }
+
+    double getPrice(const std::string& symbol) const {
+      auto it = prices.find(symbol);
+      return it != prices.end() ? it->second : 0.0;
+    }
+  };
+
+  class AlertObserver : public Observer<StockEvent> {
+    double threshold;
+
+  public:
+    explicit AlertObserver(double threshold) : threshold(threshold) {}
+
+    void onEvent(const StockEvent& event) override {}
+  };
+  '''
+end
diff --git a/test/support/fixtures/cpp/smart_pointer.ex b/test/support/fixtures/cpp/smart_pointer.ex
new file mode 100644
index 0000000..6e91c9b
--- /dev/null
+++ b/test/support/fixtures/cpp/smart_pointer.ex
@@ -0,0 +1,87 @@
+defmodule Test.Fixtures.Cpp.SmartPointer do
+  @moduledoc false
+  use Test.LanguageFixture, language: "cpp smart_pointer"
+
+  @code ~S'''
+  #include <memory>
+  #include <functional>
+
+  template<typename T>
+  class UniquePtr {
+    T* ptr;
+    std::function<void(T*)> deleter;
+
+  public:
+    explicit UniquePtr(T* p = nullptr, std::function<void(T*)> d = std::default_delete<T>())
+      : ptr(p), deleter(d) {}
+
+    ~UniquePtr() { if (ptr) deleter(ptr); }
+
+    UniquePtr(const UniquePtr&) = delete;
+
+    UniquePtr& operator=(const UniquePtr&) = delete;
+
+    UniquePtr(UniquePtr&& other) noexcept : ptr(other.ptr), deleter(std::move(other.deleter)) { other.ptr = nullptr; }
+
+    UniquePtr& operator=(UniquePtr&& other) noexcept {
+      if (this != &other) { if (ptr) deleter(ptr); ptr = other.ptr; other.ptr = nullptr; }
+      return *this;
+    }
+
+    T* get() const { return ptr; }
+
+    T& operator*() const { return *ptr; }
+
+    T* operator->() const { return ptr; }
+
+    explicit operator bool() const { return ptr != nullptr; }
+
+    T* release() { T* p = ptr; ptr = nullptr; return p; }
+
+    void reset(T* p = nullptr) { if (ptr) deleter(ptr); ptr = p; }
+  };
+
+  template<typename T>
+  struct SharedControl {
+    T* ptr;
+    int refCount;
+
+    SharedControl(T* p) : ptr(p), refCount(1) {}
+
+    ~SharedControl() { delete ptr; }
+  };
+
+  template<typename T>
+  class SharedPtr {
+    SharedControl<T>* ctrl;
+
+  public:
+    explicit SharedPtr(T* p = nullptr) : ctrl(p ? new SharedControl<T>(p) : nullptr) {}
+
+    SharedPtr(const SharedPtr& other) : ctrl(other.ctrl) { if (ctrl) ++ctrl->refCount; }
+
+    SharedPtr& operator=(const SharedPtr& other) {
+      if (this != &other) { release(); ctrl = other.ctrl; if (ctrl) ++ctrl->refCount; }
+      return *this;
+    }
+
+    ~SharedPtr() { release(); }
+
+    T* get() const { return ctrl ? ctrl->ptr : nullptr; }
+
+    T& operator*() const { return *ctrl->ptr; }
+
+    T* operator->() const { return ctrl->ptr; }
+
+    int useCount() const { return ctrl ? ctrl->refCount : 0; }
+
+  private:
+    void release() { if (ctrl && --ctrl->refCount == 0) { delete ctrl; ctrl = nullptr; } }
+  };
+
+  template<typename T, typename... Args>
+  UniquePtr<T> makeUnique(Args&&... args) {
+    return UniquePtr<T>(new T(std::forward<Args>(args)...));
+  }
+  '''
+end
diff --git a/test/support/fixtures/cpp/template_container.ex b/test/support/fixtures/cpp/template_container.ex
new file mode 100644
index 0000000..6ff7bdb
--- /dev/null
+++ b/test/support/fixtures/cpp/template_container.ex
@@ -0,0 +1,90 @@
+defmodule Test.Fixtures.Cpp.TemplateContainer do
+  @moduledoc false
+  use Test.LanguageFixture, language: "cpp template_container"
+
+  @code ~S'''
+  #include <stdexcept>
+
+  template<typename T>
+  class Stack {
+    T* data;
+    int capacity;
+    int topIdx;
+
+  public:
+    explicit Stack(int cap = 16) : capacity(cap), topIdx(-1) { data = new T[cap]; }
+
+    ~Stack() { delete[] data; }
+
+    Stack(const Stack&) = delete;
+
+    Stack& operator=(const Stack&) = delete;
+
+    void push(const T& value) {
+      if (topIdx + 1 >= capacity) throw std::overflow_error("Stack overflow");
+      data[++topIdx] = value;
+    }
+
+    T pop() {
+      if (empty()) throw std::underflow_error("Stack underflow");
+      return data[topIdx--];
+    }
+
+    T& top() {
+      if (empty()) throw std::underflow_error("Stack is empty");
+      return data[topIdx];
+    }
+
+    bool empty() const { return topIdx < 0; }
+
+    int size() const { return topIdx + 1; }
+
+    int maxCapacity() const { return capacity; }
+  };
+
+  template<typename T>
+  class Queue {
+    T* data;
+    int capacity;
+    int head;
+    int tail;
+    int count;
+
+  public:
+    explicit Queue(int cap = 16) : capacity(cap), head(0), tail(0), count(0) { data = new T[cap]; }
+
+    ~Queue() { delete[] data; }
+
+    void enqueue(const T& value) {
+      if (count >= capacity) throw std::overflow_error("Queue overflow");
+      data[tail] = value;
+      tail = (tail + 1) % capacity;
+      ++count;
+    }
+
+    T dequeue() {
+      if (empty()) throw std::underflow_error("Queue underflow");
+      T value = data[head];
+      head = (head + 1) % capacity;
+      --count;
+      return value;
+    }
+
+    T& front() { if (empty()) throw std::underflow_error("Queue is empty"); return data[head]; }
+
+    bool empty() const { return count == 0; }
+
+    int size() const { return count; }
+  };
+
+  template<typename T>
+  struct Pair {
+    T first;
+    T second;
+
+    Pair(T a, T b) : first(a), second(b) {}
+
+    bool operator==(const Pair& other) const { return first == other.first && second == other.second; }
+  };
+  '''
+end
diff --git a/test/support/fixtures/csharp/async_task_manager.ex b/test/support/fixtures/csharp/async_task_manager.ex
new file mode 100644
index 0000000..6dd9db7
--- /dev/null
+++ b/test/support/fixtures/csharp/async_task_manager.ex
@@ -0,0 +1,67 @@
+defmodule Test.Fixtures.CSharp.AsyncTaskManager do
+  @moduledoc false
+  use Test.LanguageFixture, language: "csharp async_task_manager"
+
+  @code ~S'''
+  // TaskManagement namespace — async task scheduling with bounded concurrency
+  using System.Threading.Tasks;
+  using System.Collections.Generic;
+
+  interface ITaskScheduler
+  {
+    Task ScheduleAsync(System.Func<Task> work, System.Threading.CancellationToken ct);
+    Task<T> ScheduleAsync<T>(System.Func<Task<T>> work, System.Threading.CancellationToken ct);
+  }
+
+  interface IWorkQueue
+  {
+    void Enqueue(System.Func<Task> work);
+    Task DrainAsync(System.Threading.CancellationToken ct);
+    int Count { get; }
+  }
+
+  class BoundedTaskScheduler : ITaskScheduler
+  {
+    private readonly System.Threading.SemaphoreSlim semaphore;
+
+    public BoundedTaskScheduler(int maxConcurrency)
+    {
+      semaphore = new System.Threading.SemaphoreSlim(maxConcurrency, maxConcurrency);
+    }
+
+    public async Task ScheduleAsync(System.Func<Task> work, System.Threading.CancellationToken ct)
+    {
+      await semaphore.WaitAsync(ct);
+      try { await work(); }
+      finally { semaphore.Release(); }
+    }
+
+    public async Task<T> ScheduleAsync<T>(System.Func<Task<T>> work, System.Threading.CancellationToken ct)
+    {
+      await semaphore.WaitAsync(ct);
+      try { return await work(); }
+      finally { semaphore.Release(); }
+    }
+  }
+
+  class InMemoryWorkQueue : IWorkQueue
+  {
+    private readonly Queue<System.Func<Task>> queue = new Queue<System.Func<Task>>();
+
+    public void Enqueue(System.Func<Task> work) { queue.Enqueue(work); }
+
+    public int Count => queue.Count;
+
+    public async Task DrainAsync(System.Threading.CancellationToken ct)
+    {
+      while (queue.Count > 0 && !ct.IsCancellationRequested)
+      {
+        var work = queue.Dequeue();
+        await work();
+      }
+    }
+  }
+
+  enum TaskState { Pending, Running, Completed, Failed, Cancelled }
+  '''
+end
diff --git a/test/support/fixtures/csharp/linq_pipeline.ex b/test/support/fixtures/csharp/linq_pipeline.ex
new file mode 100644
index 0000000..677c6eb
--- /dev/null
+++ b/test/support/fixtures/csharp/linq_pipeline.ex
@@ -0,0 +1,71 @@
+defmodule Test.Fixtures.CSharp.LinqPipeline do
+  @moduledoc false
+  use Test.LanguageFixture, language: "csharp linq_pipeline"
+
+  @code ~S'''
+  // DataPipeline namespace — LINQ-style transformation pipeline
+  using System.Collections.Generic;
+  using System.Linq;
+
+  interface ITransform<TIn, TOut>
+  {
+    IEnumerable<TOut> Apply(IEnumerable<TIn> input);
+  }
+
+  interface IPipeline<T>
+  {
+    IPipeline<TOut> Pipe<TOut>(ITransform<T, TOut> transform);
+    IEnumerable<T> Execute();
+  }
+
+  class FilterTransform<T> : ITransform<T, T>
+  {
+    private readonly System.Func<T, bool> predicate;
+
+    public FilterTransform(System.Func<T, bool> predicate)
+    {
+      this.predicate = predicate;
+    }
+
+    public IEnumerable<T> Apply(IEnumerable<T> input)
+    {
+      return input.Where(predicate);
+    }
+  }
+
+  class MapTransform<TIn, TOut> : ITransform<TIn, TOut>
+  {
+    private readonly System.Func<TIn, TOut> selector;
+
+    public MapTransform(System.Func<TIn, TOut> selector)
+    {
+      this.selector = selector;
+    }
+
+    public IEnumerable<TOut> Apply(IEnumerable<TIn> input)
+    {
+      return input.Select(selector);
+    }
+  }
+
+  class DataPipeline<T> : IPipeline<T>
+  {
+    private readonly IEnumerable<T> source;
+
+    public DataPipeline(IEnumerable<T> source)
+    {
+      this.source = source;
+    }
+
+    public IPipeline<TOut> Pipe<TOut>(ITransform<T, TOut> transform)
+    {
+      return new DataPipeline<TOut>(transform.Apply(source));
+    }
+
+    public IEnumerable<T> Execute()
+    {
+      return source.ToList();
+    }
+  }
+  '''
+end
diff --git a/test/support/fixtures/csharp/plugin_system.ex b/test/support/fixtures/csharp/plugin_system.ex
new file mode 100644
index 0000000..ebf7e7f
--- /dev/null
+++ b/test/support/fixtures/csharp/plugin_system.ex
@@ -0,0 +1,72 @@
+defmodule Test.Fixtures.CSharp.PluginSystem do
+  @moduledoc false
+  use Test.LanguageFixture, language: "csharp plugin_system"
+
+  @code ~S'''
+  // PluginSystem namespace — plugin registry with lifecycle management
+  using System.Collections.Generic;
+
+  interface IPlugin
+  {
+    string Name { get; }
+    string Version { get; }
+    void Initialize(IPluginContext context);
+    void Shutdown();
+  }
+
+  interface IPluginContext
+  {
+    void RegisterService<T>(T service) where T : class;
+    T ResolveService<T>() where T : class;
+    void Log(string message);
+  }
+
+  interface IPluginRegistry
+  {
+    void Register(IPlugin plugin);
+    void Unregister(string name);
+    IPlugin Find(string name);
+    IEnumerable<IPlugin> All();
+  }
+
+  class PluginContext : IPluginContext
+  {
+    private readonly Dictionary<System.Type, object> services = new Dictionary<System.Type, object>();
+
+    public void RegisterService<T>(T service) where T : class { services[typeof(T)] = service; }
+
+    public T ResolveService<T>() where T : class
+    {
+      if (services.TryGetValue(typeof(T), out var svc)) return (T)svc;
+      throw new System.InvalidOperationException("Service not found: " + typeof(T).Name);
+    }
+
+    public void Log(string message) { System.Console.WriteLine("[Plugin] " + message); }
+  }
+
+  class PluginRegistry : IPluginRegistry
+  {
+    private readonly Dictionary<string, IPlugin> plugins = new Dictionary<string, IPlugin>();
+    private readonly IPluginContext context;
+
+    public PluginRegistry(IPluginContext context) { this.context = context; }
+
+    public void Register(IPlugin plugin)
+    {
+      plugin.Initialize(context);
+      plugins[plugin.Name] = plugin;
+    }
+
+    public void Unregister(string name)
+    {
+      if (plugins.TryGetValue(name, out var plugin)) { plugin.Shutdown(); plugins.Remove(name); }
+    }
+
+    public IPlugin Find(string name) { plugins.TryGetValue(name, out var p); return p; }
+
+    public IEnumerable<IPlugin> All() { return plugins.Values; }
+  }
+
+  enum PluginState { Unloaded, Initializing, Active, ShuttingDown }
+  '''
+end
diff --git a/test/support/fixtures/dart/futures_async.ex b/test/support/fixtures/dart/futures_async.ex
new file mode 100644
index 0000000..ff5317a
--- /dev/null
+++ b/test/support/fixtures/dart/futures_async.ex
@@ -0,0 +1,78 @@
+defmodule Test.Fixtures.Dart.FuturesAsync do
+  @moduledoc false
+  use Test.LanguageFixture, language: "dart futures_async"
+
+  @code ~S'''
+  abstract class AsyncTask<T> {
+  Future<T> execute();
+
+  void cancel();
+
+  bool get isCancelled;
+  }
+
+  abstract class TaskScheduler {
+  Future<T> schedule<T>(AsyncTask<T> task);
+
+  Future<List<T>> scheduleAll<T>(List<AsyncTask<T>> tasks);
+
+  void shutdown();
+  }
+
+  class RetryPolicy {
+  final int maxAttempts;
+  final Duration delay;
+  final double backoffMultiplier;
+
+  const RetryPolicy({
+    this.maxAttempts = 3,
+    this.delay = const Duration(milliseconds: 500),
+    this.backoffMultiplier = 2.0,
+  });
+
+  Duration delayForAttempt(int attempt) {
+    final ms = delay.inMilliseconds * (backoffMultiplier * attempt).ceil();
+    return Duration(milliseconds: ms);
+  }
+  }
+
+  class SimpleTaskScheduler implements TaskScheduler {
+  bool _shutdown = false;
+  final List<Future<dynamic>> _pending = [];
+
+  Future<T> schedule<T>(AsyncTask<T> task) async {
+    if (_shutdown) throw StateError("Scheduler is shut down");
+    final future = task.execute();
+    _pending.add(future);
+    return future;
+  }
+
+  Future<List<T>> scheduleAll<T>(List<AsyncTask<T>> tasks) {
+    return Future.wait(tasks.map((t) => schedule(t)).toList());
+  }
+
+  void shutdown() {
+    _shutdown = true;
+    _pending.clear();
+  }
+  }
+
+  enum TaskStatus {
+  pending,
+  running,
+  completed,
+  failed,
+  cancelled
+  }
+
+  class TaskResult<T> {
+  final T? value;
+  final Object? error;
+  final TaskStatus status;
+
+  const TaskResult.success(this.value) : error = null, status = TaskStatus.completed;
+
+  const TaskResult.failure(this.error) : value = null, status = TaskStatus.failed;
+  }
+  '''
+end
diff --git a/test/support/fixtures/dart/mixin_composition.ex b/test/support/fixtures/dart/mixin_composition.ex
new file mode 100644
index 0000000..05013b4
--- /dev/null
+++ b/test/support/fixtures/dart/mixin_composition.ex
@@ -0,0 +1,85 @@
+defmodule Test.Fixtures.Dart.MixinComposition do
+  @moduledoc false
+  use Test.LanguageFixture, language: "dart mixin_composition"
+
+  @code ~S'''
+  abstract class Serializable {
+  Map<String, dynamic> toJson();
+
+  String toJsonString() {
+    final map = toJson();
+    return map.entries.map((e) => '"${e.key}": "${e.value}"').join(', ');
+  }
+  }
+
+  abstract class Validatable {
+  List<String> validate();
+
+  bool get isValid => validate().isEmpty;
+
+  void assertValid() {
+    final errors = validate();
+    if (errors.isNotEmpty) throw ArgumentError(errors.join(', '));
+  }
+  }
+
+  abstract class Equatable {
+  List<Object?> get props;
+
+  bool equalsTo(Object other) {
+    if (identical(this, other)) return true;
+    if (other.runtimeType != runtimeType) return false;
+    final otherEquatable = other as Equatable;
+    for (int i = 0; i < props.length; i++) {
+      if (props[i] != otherEquatable.props[i]) return false;
+    }
+    return true;
+  }
+  }
+
+  class Address extends Serializable implements Validatable {
+  final String street;
+  final String city;
+  final String country;
+
+  Address({required this.street, required this.city, required this.country});
+
+  Map<String, dynamic> toJson() => {'street': street, 'city': city, 'country': country};
+
+  List<String> validate() {
+    final errors = <String>[];
+    if (street.isEmpty) errors.add('street is required');
+    if (city.isEmpty) errors.add('city is required');
+    if (country.isEmpty) errors.add('country is required');
+    return errors;
+  }
+
+  List<Object?> get props => [street, city, country];
+  }
+
+  enum AddressType {
+  home,
+  work,
+  billing,
+  shipping
+  }
+
+  class Contact extends Serializable implements Validatable {
+  final String name;
+  final String email;
+  final Address address;
+
+  Contact({required this.name, required this.email, required this.address});
+
+  Map<String, dynamic> toJson() => {'name': name, 'email': email, 'address': address.toJson()};
+
+  List<String> validate() {
+    final errors = <String>[];
+    if (name.isEmpty) errors.add('name is required');
+    if (!email.contains('@')) errors.add('invalid email');
+    errors.addAll(address.validate());
+    return errors;
+  }
+  }
+  '''
+end
diff --git a/test/support/fixtures/dart/widget_state.ex b/test/support/fixtures/dart/widget_state.ex
new file mode 100644
index 0000000..d4a1b04
--- /dev/null
+++ b/test/support/fixtures/dart/widget_state.ex
@@ -0,0 +1,91 @@
+defmodule Test.Fixtures.Dart.WidgetState do
+  @moduledoc false
+  use Test.LanguageFixture, language: "dart widget_state"
+
+  @code ~S'''
+  abstract class Widget {
+  String get key;
+
+  Element createElement();
+  }
+
+  abstract class StatefulWidget extends Widget {
+  State createState();
+  }
+
+  abstract class State<T extends StatefulWidget> {
+  T widget;
+
+  State(this.widget);
+
+  void setState(void Function() fn) {
+    fn();
+    markNeedsBuild();
+  }
+
+  void markNeedsBuild() {}
+
+  Widget build();
+
+  void initState() {}
+
+  void dispose() {}
+  }
+
+  class Element {
+  Widget widget;
+  State? state;
+
+  Element(this.widget);
+
+  void mount() {
+    if (widget is StatefulWidget) {
+      state = (widget as StatefulWidget).createState();
+      state!.initState();
+    }
+  }
+
+  void unmount() {
+    state?.dispose();
+  }
+  }
+
+  abstract class BuildContext {
+  Widget get widget;
+
+  Element get element;
+  }
+
+  enum WidgetLifecycle {
+  created,
+  mounted,
+  active,
+  inactive,
+  disposed
+  }
+
+  class RenderObject {
+  double x = 0;
+  double y = 0;
+  double width = 0;
+  double height = 0;
+  bool needsLayout = true;
+  bool needsPaint = true;
+  RenderObject? parent;
+  List<RenderObject> children = [];
+
+  void layout() {
+    needsLayout = false;
+  }
+
+  void paint() {
+    needsPaint = false;
+  }
+
+  void addChild(RenderObject child) {
+    children.add(child);
+    child.parent = this;
+  }
+  }
+  '''
+end
diff --git a/test/support/fixtures/elixir/calculator.ex b/test/support/fixtures/elixir/calculator.ex
new file mode 100644
index 0000000..7657b88
--- /dev/null
+++ b/test/support/fixtures/elixir/calculator.ex
@@ -0,0 +1,125 @@
+defmodule Test.Fixtures.Elixir.Calculator do
+  @moduledoc false
+  use Test.LanguageFixture, language: "elixir calculator"
+  import Test.NodeMatcher
+
+  @code ~S'''
+  defmodule Calculator.Behaviour do
+    @moduledoc "Contract for all calculator implementations."
+    @callback add(number, number) :: number
+    @callback subtract(number, number) :: number
+    @callback multiply(number, number) :: number
+    @callback divide(number, number) :: {:ok, float} | {:error, :division_by_zero}
+  end
+
+  defprotocol Calculator.Displayable do
+    @doc "Converts a result to a human-readable string."
+    def display(value)
+  end
+
+  defmodule Calculator.Basic do
+    @moduledoc "Basic arithmetic calculator."
+    @behaviour Calculator.Behaviour
+
+    @doc "Adds two numbers."
+    @spec add(number, number) :: number
+    def add(a, b), do: a + b
+
+    @doc "Subtracts b from a."
+    @spec subtract(number, number) :: number
+    def subtract(a, b), do: a - b
+
+    @doc "Multiplies two numbers."
+    @spec multiply(number, number) :: number
+    def multiply(a, b), do: a * b
+
+    @doc "Divides a by b, returns error for zero divisor."
+    @spec divide(number, number) :: {:ok, float} | {:error, :division_by_zero}
+    def divide(_a, 0), do: {:error, :division_by_zero}
+    def divide(a, b), do: {:ok, a / b}
+
+    @doc "Absolute value of n."
+    @spec abs_val(number) :: number
+    def abs_val(n) when n < 0, do: -n
+    def abs_val(n), do: n
+  end
+
+  defimpl Calculator.Displayable, for: Integer do
+    def display(value), do: Integer.to_string(value)
+  end
+
+  defimpl Calculator.Displayable, for: Float do
+    def display(value), do: :erlang.float_to_binary(value, [decimals: 4])
+  end
+
+  defmodule Calculator.Scientific do
+    @moduledoc "Scientific calculator with extended math operations."
+    @behaviour Calculator.Behaviour
+
+    @doc "Adds two numbers."
+    @spec add(number, number) :: number
+    def add(a, b), do: a + b
+
+    @doc "Subtracts b from a."
+    @spec subtract(number, number) :: number
+    def subtract(a, b), do: a - b
+
+    @doc "Multiplies two numbers."
+    @spec multiply(number, number) :: number
+    def multiply(a, b), do: a * b
+
+    @doc "Divides, returning an error on zero divisor."
+    @spec divide(number, number) :: {:ok, float} | {:error, :division_by_zero}
+    def divide(_a, 0), do: {:error, :division_by_zero}
+    def divide(a, b), do: {:ok, a / b}
+
+    @doc "Raises a to the power of b."
+    @spec power(number, number) :: number
+    def power(a, b), do: :math.pow(a, b)
+
+    @doc "Returns the square root or an error for negative input."
+    @spec sqrt(number) :: {:ok, float} | {:error, :negative_input}
+    def sqrt(n) when n < 0, do: {:error, :negative_input}
+    def sqrt(n), do: {:ok, :math.sqrt(n)}
+
+    @doc "Natural logarithm, error for non-positive input."
+    @spec log(number) :: {:ok, float} | {:error, :non_positive_input}
+    def log(n) when n <= 0, do: {:error, :non_positive_input}
+    def log(n), do: {:ok, :math.log(n)}
+
+    defp validate_positive(n) when n > 0, do: {:ok, n}
+    defp validate_positive(_n), do: {:error, :non_positive_input}
+  end
+
+  defmodule Calculator.History do
+    @moduledoc "Tracks a history of calculator operations."
+    @type entry :: {atom, list}
+    @type t :: list
+
+    @doc "Creates an empty history."
+    @spec new() :: t
+    def new(), do: []
+
+    @doc "Records an operation entry."
+    @spec record(t, atom, list) :: t
+    def record(history, op, args) when is_list(args), do: [{op, args} | history]
+
+    @doc "Returns the last n entries."
+    @spec last(t, non_neg_integer) :: t
+    def last(history, n \\ 5), do: Enum.take(history, n)
+
+    @doc "Clears the history."
+    @spec clear(t) :: t
+    def clear(_history), do: []
+
+    defp format_entry({op, args}), do: "#{op}(#{Enum.join(args, ", ")})"
+  end
+  '''
+
+  @block_assertions [
+    %{
+      description: "a compound block containing add with doc and spec annotations",
+      all_of: [exact(:content, "add"), exact(:content, "doc"), exact(:content, "spec")]
+    }
+  ]
+end
diff --git a/test/support/fixtures/elixir/event_bus.ex b/test/support/fixtures/elixir/event_bus.ex
new file mode 100644
index 0000000..e196e09
--- /dev/null
+++ b/test/support/fixtures/elixir/event_bus.ex
@@ -0,0 +1,71 @@
+defmodule Test.Fixtures.Elixir.EventBus do
+  @moduledoc false
+  use Test.LanguageFixture, language: "elixir event_bus"
+
+  @code ~S'''
+  defmodule EventBus.Behaviour do
+    @moduledoc "Contract for event bus implementations."
+    @callback subscribe(topic :: String.t(), pid :: pid()) :: :ok | {:error, term()}
+    @callback unsubscribe(topic :: String.t(), pid :: pid()) :: :ok
+    @callback publish(topic :: String.t(), event :: term()) :: :ok
+    @callback topics() :: [String.t()]
+  end
+
+  defprotocol EventBus.Serializable do
+    @doc "Encodes an event to a binary payload."
+    @spec encode(t()) :: binary()
+    def encode(event)
+
+    @doc "Decodes a binary payload back to an event."
+    @spec decode(t(), binary()) :: term()
+    def decode(schema, payload)
+  end
+
+  defmodule EventBus.Topic do
+    @moduledoc "Represents a named event topic with subscriber tracking."
+    @enforce_keys [:name]
+    defstruct [:name, subscribers: []]
+
+    @doc "Creates a new topic."
+    @spec new(String.t()) :: t()
+    def new(name) when is_binary(name), do: %__MODULE__{name: name}
+
+    @doc "Adds a subscriber pid to the topic."
+    @spec add_subscriber(t(), pid()) :: t()
+    def add_subscriber(%__MODULE__{subscribers: subs} = topic, pid) do
+      %{topic | subscribers: [pid | subs]}
+    end
+
+    @doc "Removes a subscriber pid from the topic."
+    @spec remove_subscriber(t(), pid()) :: t()
+    def remove_subscriber(%__MODULE__{subscribers: subs} = topic, pid) do
+      %{topic | subscribers: List.delete(subs, pid)}
+    end
+
+    @doc "Returns all current subscribers."
+    @spec subscribers(t()) :: [pid()]
+    def subscribers(%__MODULE__{subscribers: subs}), do: subs
+  end
+
+  defmodule EventBus.Dispatcher do
+    @moduledoc "Dispatches events to all topic subscribers."
+
+    @doc "Broadcasts an event to every subscriber of the given topic."
+    @spec broadcast(EventBus.Topic.t(), term()) :: :ok
+    def broadcast(%EventBus.Topic{} = topic, event) do
+      topic
+      |> EventBus.Topic.subscribers()
+      |> Enum.each(&send(&1, {:event, topic.name, event}))
+    end
+
+    @doc "Dispatches to subscribers matching a predicate."
+    @spec dispatch_filtered(EventBus.Topic.t(), term(), (pid() -> boolean())) :: :ok
+    def dispatch_filtered(%EventBus.Topic{} = topic, event, filter_fn) do
+      topic
+      |> EventBus.Topic.subscribers()
+      |> Enum.filter(filter_fn)
+      |> Enum.each(&send(&1, {:event, topic.name, event}))
+    end
+  end
+  '''
+end
diff --git a/test/support/fixtures/elixir/rate_limiter.ex b/test/support/fixtures/elixir/rate_limiter.ex
new file mode 100644
index 0000000..580a2b4
--- /dev/null
+++ b/test/support/fixtures/elixir/rate_limiter.ex
@@ -0,0 +1,85 @@
+defmodule Test.Fixtures.Elixir.RateLimiter do
+  @moduledoc false
+  use Test.LanguageFixture, language: "elixir rate_limiter"
+
+  @code ~S'''
+  defmodule RateLimiter.Behaviour do
+    @moduledoc "Contract for rate limiter backends."
+    @callback allow?(key :: term(), cost :: pos_integer()) :: boolean()
+    @callback reset(key :: term()) :: :ok
+    @callback stats(key :: term()) :: {:ok, map()} | {:error, :not_found}
+  end
+
+  defmodule RateLimiter.Bucket do
+    @moduledoc "Token bucket state for a single rate-limited key."
+    @enforce_keys [:capacity, :tokens, :refill_rate]
+    defstruct [:capacity, :tokens, :refill_rate, last_refill: nil]
+
+    @doc "Creates a new bucket with full capacity."
+    @spec new(pos_integer(), pos_integer()) :: t()
+    def new(capacity, refill_rate) when capacity > 0 and refill_rate > 0 do
+      %__MODULE__{capacity: capacity, tokens: capacity, refill_rate: refill_rate, last_refill: System.monotonic_time(:millisecond)}
+    end
+
+    @doc "Consumes tokens from the bucket. Returns updated bucket or error."
+    @spec consume(t(), pos_integer()) :: {:ok, t()} | {:error, :rate_limited}
+    def consume(%__MODULE__{tokens: tokens} = bucket, cost) when tokens >= cost do
+      {:ok, %{bucket | tokens: tokens - cost}}
+    end
+    def consume(%__MODULE__{}, _cost), do: {:error, :rate_limited}
+
+    @doc "Refills the bucket based on elapsed time."
+    @spec refill(t()) :: t()
+    def refill(%__MODULE__{tokens: t, capacity: cap, refill_rate: rate, last_refill: last} = bucket) do
+      now = System.monotonic_time(:millisecond)
+      elapsed_ms = now - last
+      new_tokens = min(cap, t + div(elapsed_ms * rate, 1000))
+      %{bucket | tokens: new_tokens, last_refill: now}
+    end
+  end
+
+  defmodule RateLimiter.Server do
+    @moduledoc "GenServer-backed rate limiter with configurable buckets."
+    @behaviour RateLimiter.Behaviour
+    use GenServer
+
+    @doc "Starts the rate limiter server."
+    @spec start_link(keyword()) :: GenServer.on_start()
+    def start_link(opts), do: GenServer.start_link(__MODULE__, opts, name: __MODULE__)
+
+    @impl RateLimiter.Behaviour
+    @spec allow?(term(), pos_integer()) :: boolean()
+    def allow?(key, cost \\ 1), do: GenServer.call(__MODULE__, {:allow, key, cost})
+
+    @impl RateLimiter.Behaviour
+    @spec reset(term()) :: :ok
+    def reset(key), do: GenServer.cast(__MODULE__, {:reset, key})
+
+    @impl RateLimiter.Behaviour
+    @spec stats(term()) :: {:ok, map()} | {:error, :not_found}
+    def stats(key), do: GenServer.call(__MODULE__, {:stats, key})
+
+    @impl GenServer
+    def init(opts) do
+      capacity = Keyword.get(opts, :capacity, 100)
+      refill_rate = Keyword.get(opts, :refill_rate, 10)
+      {:ok, %{buckets: %{}, capacity: capacity, refill_rate: refill_rate}}
+    end
+
+    @impl GenServer
+    def handle_call({:allow, key, cost}, _from, state) do
+      bucket = Map.get_lazy(state.buckets, key, fn -> RateLimiter.Bucket.new(state.capacity, state.refill_rate) end)
+      bucket = RateLimiter.Bucket.refill(bucket)
+      case RateLimiter.Bucket.consume(bucket, cost) do
+        {:ok, updated} -> {:reply, true, %{state | buckets: Map.put(state.buckets, key, updated)}}
+        {:error, :rate_limited} -> {:reply, false, %{state | buckets: Map.put(state.buckets, key, bucket)}}
+      end
+    end
+
+    @impl GenServer
+    def handle_cast({:reset, key}, state), do: {:noreply, %{state | buckets: Map.delete(state.buckets, key)}}
+
+    defp default_bucket(state), do: RateLimiter.Bucket.new(state.capacity, state.refill_rate)
+  end
+  '''
+end
diff --git a/test/support/fixtures/go/calculator.ex b/test/support/fixtures/go/calculator.ex
new file mode 100644
index 0000000..e55100a
--- /dev/null
+++ b/test/support/fixtures/go/calculator.ex
@@ -0,0 +1,53 @@
+defmodule Test.Fixtures.Go.Calculator do
+  @moduledoc false
+  use Test.LanguageFixture, language: "go calculator"
+
+  @code ~S'''
+  func Add(a, b float64) float64 {
+  	return a + b
+  }
+
+  func Subtract(a, b float64) float64 {
+  	return a - b
+  }
+
+  func Multiply(a, b float64) float64 {
+  	return a * b
+  }
+
+  func Divide(a, b float64) (float64, error) {
+  	if b == 0 {
+  		return 0, fmt.Errorf("division by zero")
+  	}
+  	return a / b, nil
+  }
+
+  func Power(base, exp float64) float64 {
+  	return math.Pow(base, exp)
+  }
+
+  func Sqrt(n float64) (float64, error) {
+  	if n < 0 {
+  		return 0, fmt.Errorf("cannot take sqrt of negative number")
+  	}
+  	return math.Sqrt(n), nil
+  }
+
+  func Abs(n float64) float64 {
+  	if n < 0 {
+  		return -n
+  	}
+  	return n
+  }
+
+  func Clamp(n, min, max float64) float64 {
+  	if n < min {
+  		return min
+  	}
+  	if n > max {
+  		return max
+  	}
+  	return n
+  }
+  '''
+end
diff --git a/test/support/fixtures/go/cli_parser.ex b/test/support/fixtures/go/cli_parser.ex
new file mode 100644
index 0000000..c97c14a
--- /dev/null
+++ b/test/support/fixtures/go/cli_parser.ex
@@ -0,0 +1,77 @@
+defmodule Test.Fixtures.Go.CliParser do
+  @moduledoc false
+  use Test.LanguageFixture, language: "go cli_parser"
+
+  @code ~S'''
+  type Flag struct {
+      Name string
+      Short string
+      Description string
+      Required bool
+      Value interface{}
+  }
+
+  type Command struct {
+      Name string
+      Description string
+      flags []*Flag
+      subcommands []*Command
+      action func(args []string, flags map[string]interface{}) error
+  }
+
+  func NewCommand(name, description string) *Command {
+      return &Command{Name: name, Description: description, flags: []*Flag{}, subcommands: []*Command{}}
+  }
+
+  func (c *Command) AddFlag(name, short, description string, required bool) *Flag {
+      f := &Flag{Name: name, Short: short, Description: description, Required: required}
+      c.flags = append(c.flags, f)
+      return f
+  }
+
+  func (c *Command) AddSubcommand(sub *Command) *Command {
+      c.subcommands = append(c.subcommands, sub)
+      return c
+  }
+
+  func (c *Command) Action(fn func(args []string, flags map[string]interface{}) error) {
+      c.action = fn
+  }
+
+  func (c *Command) Execute(args []string) error {
+      if len(args) > 0 {
+          for _, sub := range c.subcommands {
+              if sub.Name == args[0] {
+                  return sub.Execute(args[1:])
+              }
+          }
+      }
+      flags, remaining, err := c.parseFlags(args)
+      if err != nil {
+          return err
+      }
+      if c.action != nil {
+          return c.action(remaining, flags)
+      }
+      return nil
+  }
+
+  func (c *Command) parseFlags(args []string) (map[string]interface{}, []string, error) {
+      result := make(map[string]interface{})
+      remaining := []string{}
+      for i := 0; i < len(args); i++ {
+          arg := args[i]
+          if len(arg) > 2 && arg[:2] == "--" {
+              key := arg[2:]
+              if i+1 < len(args) {
+                  result[key] = args[i+1]
+                  i++
+              }
+          } else {
+              remaining = append(remaining, arg)
+          }
+      }
+      return result, remaining, nil
+  }
+  '''
+end
diff --git a/test/support/fixtures/go/http_middleware.ex b/test/support/fixtures/go/http_middleware.ex
new file mode 100644
index 0000000..e759c85
--- /dev/null
+++ b/test/support/fixtures/go/http_middleware.ex
@@ -0,0 +1,86 @@
+defmodule Test.Fixtures.Go.HttpMiddleware do
+  @moduledoc false
+  use Test.LanguageFixture, language: "go http_middleware"
+
+  @code ~S'''
+  type Handler func(w ResponseWriter, r *Request)
+
+  type Middleware func(Handler) Handler
+
+  type ResponseWriter interface {
+      Write([]byte) (int, error)
+      WriteHeader(statusCode int)
+      Header() map[string][]string
+  }
+
+  type Request struct {
+      Method string
+      Path string
+      Headers map[string]string
+      Body []byte
+  }
+
+  type Router struct {
+      routes map[string]Handler
+      middlewares []Middleware
+  }
+
+  func NewRouter() *Router {
+      return &Router{routes: make(map[string]Handler), middlewares: []Middleware{}}
+  }
+
+  func (r *Router) Use(m Middleware) {
+      r.middlewares = append(r.middlewares, m)
+  }
+
+  func (r *Router) Handle(path string, h Handler) {
+      r.routes[path] = r.wrap(h)
+  }
+
+  func (r *Router) ServeHTTP(w ResponseWriter, req *Request) {
+      h, ok := r.routes[req.Path]
+      if !ok {
+          w.WriteHeader(404)
+          return
+      }
+      h(w, req)
+  }
+
+  func (r *Router) wrap(h Handler) Handler {
+      for i := len(r.middlewares) - 1; i >= 0; i-- {
+          h = r.middlewares[i](h)
+      }
+      return h
+  }
+
+  func LoggingMiddleware(next Handler) Handler {
+      return func(w ResponseWriter, r *Request) {
+          next(w, r)
+      }
+  }
+
+  func RecoveryMiddleware(next Handler) Handler {
+      return func(w ResponseWriter, r *Request) {
+          defer func() {
+              if rec := recover(); rec != nil {
+                  w.WriteHeader(500)
+              }
+          }()
+          next(w, r)
+      }
+  }
+
+  func AuthMiddleware(secret string) Middleware {
+      return func(next Handler) Handler {
+          return func(w ResponseWriter, r *Request) {
+              token, ok := r.Headers["Authorization"]
+              if !ok || token != secret {
+                  w.WriteHeader(401)
+                  return
+              }
+              next(w, r)
+          }
+      }
+  }
+  '''
+end
diff --git a/test/support/fixtures/java/builder_pattern.ex b/test/support/fixtures/java/builder_pattern.ex
new file mode 100644
index 0000000..15cd00d
--- /dev/null
+++ b/test/support/fixtures/java/builder_pattern.ex
@@ -0,0 +1,81 @@
+defmodule Test.Fixtures.Java.BuilderPattern do
+  @moduledoc false
+  use Test.LanguageFixture, language: "java builder_pattern"
+
+  @code ~S'''
+  interface Validatable {
+    boolean isValid();
+    String validationError();
+  }
+
+  interface Buildable<T> {
+    T build();
+  }
+
+  class Address implements Validatable {
+    private final String street;
+    private final String city;
+    private final String country;
+    private final String postalCode;
+
+    private Address(Builder b) {
+      this.street = b.street;
+      this.city = b.city;
+      this.country = b.country;
+      this.postalCode = b.postalCode;
+    }
+
+    public boolean isValid() {
+      return street != null && !street.isEmpty() && city != null && country != null;
+    }
+
+    public String validationError() {
+      if (street == null || street.isEmpty()) return "street is required";
+      if (city == null) return "city is required";
+      return null;
+    }
+
+    public String getStreet() { return street; }
+
+    public String getCity() { return city; }
+
+    public String getCountry() { return country; }
+
+    public String getPostalCode() { return postalCode; }
+
+    public static class Builder implements Buildable<Address> {
+      private String street;
+      private String city;
+      private String country;
+      private String postalCode;
+
+      public Builder street(String street) { this.street = street; return this; }
+
+      public Builder city(String city) { this.city = city; return this; }
+
+      public Builder country(String country) { this.country = country; return this; }
+
+      public Builder postalCode(String postalCode) { this.postalCode = postalCode; return this; }
+
+      public Address build() {
+        Address a = new Address(this);
+        if (!a.isValid()) throw new IllegalStateException(a.validationError());
+        return a;
+      }
+    }
+  }
+
+  enum Country {
+    US("United States"),
+    DE("Germany"),
+    JP("Japan"),
+    BR("Brazil");
+
+    private final String displayName;
+
+    Country(String displayName) { this.displayName = displayName; }
+
+    public String getDisplayName() { return displayName; }
+  }
+  '''
+end
diff --git a/test/support/fixtures/java/repository_pattern.ex b/test/support/fixtures/java/repository_pattern.ex
new file mode 100644
index 0000000..487b526
--- /dev/null
+++ b/test/support/fixtures/java/repository_pattern.ex
@@ -0,0 +1,76 @@
+defmodule Test.Fixtures.Java.RepositoryPattern do
+  @moduledoc false
+  use Test.LanguageFixture, language: "java repository_pattern"
+
+  @code ~S'''
+  interface Entity<ID> {
+    ID getId();
+  }
+
+  interface Repository<T extends Entity<ID>, ID> {
+    T findById(ID id);
+    java.util.List<T> findAll();
+    T save(T entity);
+    void delete(ID id);
+    boolean exists(ID id);
+  }
+
+  interface UserRepository extends Repository<User, Long> {
+    java.util.Optional<User> findByEmail(String email);
+    java.util.List<User> findByRole(String role);
+  }
+
+  class User implements Entity<Long> {
+    private Long id;
+    private String name;
+    private String email;
+    private String role;
+
+    public User(Long id, String name, String email, String role) {
+      this.id = id;
+      this.name = name;
+      this.email = email;
+      this.role = role;
+    }
+
+    public Long getId() { return id; }
+
+    public String getName() { return name; }
+
+    public String getEmail() { return email; }
+
+    public String getRole() { return role; }
+  }
+
+  class InMemoryUserRepository implements UserRepository {
+    private final java.util.Map<Long, User> store = new java.util.HashMap<>();
+    private long nextId = 1L;
+
+    public User findById(Long id) { return store.get(id); }
+
+    public java.util.List<User> findAll() { return new java.util.ArrayList<>(store.values()); }
+
+    public User save(User user) {
+      if (user.getId() == null) {
+        User saved = new User(nextId++, user.getName(), user.getEmail(), user.getRole());
+        store.put(saved.getId(), saved);
+        return saved;
+      }
+      store.put(user.getId(), user);
+      return user;
+    }
+
+    public void delete(Long id) { store.remove(id); }
+
+    public boolean exists(Long id) { return store.containsKey(id); }
+
+    public java.util.Optional<User> findByEmail(String email) {
+      return store.values().stream().filter(u -> u.getEmail().equals(email)).findFirst();
+    }
+
+    public java.util.List<User> findByRole(String role) {
+      return store.values().stream().filter(u -> u.getRole().equals(role)).collect(java.util.stream.Collectors.toList());
+    }
+  }
+  '''
+end
diff --git a/test/support/fixtures/java/strategy_pattern.ex b/test/support/fixtures/java/strategy_pattern.ex
new file mode 100644
index 0000000..0d129f1
--- /dev/null
+++ b/test/support/fixtures/java/strategy_pattern.ex
@@ -0,0 +1,79 @@
+defmodule Test.Fixtures.Java.StrategyPattern do
+  @moduledoc false
+  use Test.LanguageFixture, language: "java strategy_pattern"
+
+  @code ~S'''
+  interface PaymentStrategy {
+    boolean validate(double amount);
+    String process(double amount, String currency);
+    String getName();
+  }
+
+  interface TransactionLogger {
+    void log(String strategy, double amount, String result);
+  }
+
+  class CreditCardStrategy implements PaymentStrategy {
+    private final String cardNumber;
+    private final String expiry;
+    private final String cvv;
+
+    public CreditCardStrategy(String cardNumber, String expiry, String cvv) {
+      this.cardNumber = cardNumber;
+      this.expiry = expiry;
+      this.cvv = cvv;
+    }
+
+    public boolean validate(double amount) {
+      return amount > 0 && cardNumber != null && cardNumber.length() == 16;
+    }
+
+    public String process(double amount, String currency) {
+      return "Charged " + amount + " " + currency + " to card ending " + cardNumber.substring(12);
+    }
+
+    public String getName() { return "credit_card"; }
+  }
+
+  class BankTransferStrategy implements PaymentStrategy {
+    private final String accountNumber;
+    private final String routingNumber;
+
+    public BankTransferStrategy(String accountNumber, String routingNumber) {
+      this.accountNumber = accountNumber;
+      this.routingNumber = routingNumber;
+    }
+
+    public boolean validate(double amount) { return amount >= 1.0; }
+
+    public String process(double amount, String currency) {
+      return "Transferred " + amount + " " + currency + " from account " + accountNumber;
+    }
+
+    public String getName() { return "bank_transfer"; }
+  }
+
+  class PaymentProcessor {
+    private PaymentStrategy strategy;
+    private final TransactionLogger logger;
+
+    public PaymentProcessor(PaymentStrategy strategy, TransactionLogger logger) {
+      this.strategy = strategy;
+      this.logger = logger;
+    }
+
+    public void setStrategy(PaymentStrategy strategy) { this.strategy = strategy; }
+
+    public String pay(double amount, String currency) {
+      if (!strategy.validate(amount)) throw new IllegalArgumentException("Invalid payment");
+      String result = strategy.process(amount, currency);
+      logger.log(strategy.getName(), amount, result);
+      return result;
+    }
+  }
+
+  enum PaymentStatus {
+    PENDING, PROCESSING, COMPLETED, FAILED, REFUNDED
+  }
+  '''
+end
diff --git a/test/support/fixtures/javascript/calculator.ex b/test/support/fixtures/javascript/calculator.ex
new file mode 100644
index 0000000..b6d67a5
--- /dev/null
+++ b/test/support/fixtures/javascript/calculator.ex
@@ -0,0 +1,51 @@
+defmodule Test.Fixtures.JavaScript.Calculator do
+  @moduledoc false
+  use Test.LanguageFixture, language: "javascript calculator"
+
+  @code ~S'''
+  function add(a, b) {
+    return a + b;
+  }
+
+  function subtract(a, b) {
+    return a - b;
+  }
+
+  function multiply(a, b) {
+    return a * b;
+  }
+
+  function divide(a, b) {
+    if (b === 0) throw new Error("Cannot divide by zero");
+    return a / b;
+  }
+
+  function power(base, exp) {
+    return Math.pow(base, exp);
+  }
+
+  function sqrt(n) {
+    if (n < 0) throw new Error("Cannot take sqrt of negative number");
+    return Math.sqrt(n);
+  }
+
+  function abs(n) {
+    return Math.abs(n);
+  }
+
+  function clamp(n, min, max) {
+    return Math.min(Math.max(n, min), max);
+  }
+
+  function roundTo(n, decimals) {
+    var factor = Math.pow(10, decimals);
+    return Math.round(n * factor) / factor;
+  }
+
+  function average(values) {
+    if (values.length === 0) return 0;
+    var sum = values.reduce(function(acc, v) { return acc + v; }, 0);
+    return sum / values.length;
+  }
+  '''
+end
diff --git a/test/support/fixtures/javascript/form_validator.ex b/test/support/fixtures/javascript/form_validator.ex
new file mode 100644
index 0000000..017ed52
--- /dev/null
+++ b/test/support/fixtures/javascript/form_validator.ex
@@ -0,0 +1,134 @@
+defmodule Test.Fixtures.JavaScript.FormValidator do
+  @moduledoc false
+  use Test.LanguageFixture, language: "javascript form_validator"
+
+  @code ~S'''
+  class ValidationError {
+    constructor(field, message) {
+      this.field = field;
+      this.message = message;
+    }
+
+    toString() {
+      return `${this.field}: ${this.message}`;
+    }
+  }
+
+  class ValidationResult {
+    constructor() {
+      this.errors = [];
+    }
+
+    addError(field, message) {
+      this.errors.push(new ValidationError(field, message));
+      return this;
+    }
+
+    isValid() {
+      return this.errors.length === 0;
+    }
+
+    getErrors(field) {
+      return this.errors.filter(function(e) { return e.field === field; });
+    }
+  }
+
+  class FieldValidator {
+    constructor(field, value) {
+      this.field = field;
+      this.value = value;
+      this._rules = [];
+    }
+
+    required() {
+      this._rules.push(function(v) {
+        if (v === null || v === undefined || v === "") {
+          return "is required";
+        }
+        return null;
+      });
+      return this;
+    }
+
+    minLength(n) {
+      this._rules.push(function(v) {
+        if (typeof v === "string" && v.length < n) {
+          return "is too short (minimum " + n + " characters)";
+        }
+        return null;
+      });
+      return this;
+    }
+
+    maxLength(n) {
+      this._rules.push(function(v) {
+        if (typeof v === "string" && v.length > n) {
+          return "is too long (maximum " + n + " characters)";
+        }
+        return null;
+      });
+      return this;
+    }
+
+    matches(pattern, message) {
+      this._rules.push(function(v) {
+        if (typeof v === "string" && !pattern.test(v)) {
+          return message || "is invalid";
+        }
+        return null;
+      });
+      return this;
+    }
+
+    validate() {
+      var errors = [];
+      for (var i = 0; i < this._rules.length; i++) {
+        var error = this._rules[i](this.value);
+        if (error !== null) {
+          errors.push(error);
+        }
+      }
+      return errors;
+    }
+  }
+
+  class FormValidator {
+    constructor(data) {
+      this._data = data;
+      this._fields = [];
+    }
+
+    field(name) {
+      var validator = new FieldValidator(name, this._data[name]);
+      this._fields.push(validator);
+      return validator;
+    }
+
+    validate() {
+      var result = new ValidationResult();
+      for (var i = 0; i < this._fields.length; i++) {
+        var f = this._fields[i];
+        var errors = f.validate();
+        for (var j = 0; j < errors.length; j++) {
+          result.addError(f.field, errors[j]);
+        }
+      }
+      return result;
+    }
+  }
+
+  function validateEmail(value) {
+    var pattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return pattern.test(value);
+  }
+
+  function validateUrl(value) {
+    try {
+      new URL(value);
+      return true;
+    } catch (_) {
+      return false;
+    }
+  }
+  '''
+end
diff --git a/test/support/fixtures/javascript/shopping_cart.ex b/test/support/fixtures/javascript/shopping_cart.ex
new file mode 100644
index 0000000..e7d8600
--- /dev/null
+++ b/test/support/fixtures/javascript/shopping_cart.ex
@@ -0,0 +1,100 @@
+defmodule Test.Fixtures.JavaScript.ShoppingCart do
+  @moduledoc false
+  use Test.LanguageFixture, language: "javascript shopping_cart"
+
+  @code ~S'''
+  class CartItem {
+    constructor(id, name, price, quantity) {
+      this.id = id;
+      this.name = name;
+      this.price = price;
+      this.quantity = quantity;
+    }
+
+    get subtotal() {
+      return this.price * this.quantity;
+    }
+
+    withQuantity(quantity) {
+      return new CartItem(this.id, this.name, this.price, quantity);
+    }
+  }
+
+  class Discount {
+    constructor(code, type, value) {
+      this.code = code;
+      this.type = type;
+      this.value = value;
+    }
+
+    apply(subtotal) {
+      if (this.type === "percent") {
+        return subtotal * (1 - this.value / 100);
+      }
+      if (this.type === "fixed") {
+        return Math.max(0, subtotal - this.value);
+      }
+      return subtotal;
+    }
+  }
+
+  class ShoppingCart {
+    constructor() {
+      this._items = new Map();
+      this._discount = null;
+      this._listeners = [];
+    }
+
+    addItem(item) {
+      var existing = this._items.get(item.id);
+      if (existing) {
+        this._items.set(item.id, existing.withQuantity(existing.quantity + item.quantity));
+      } else {
+        this._items.set(item.id, item);
+      }
+      this._emit("item:added", item);
+      return this;
+    }
+
+    removeItem(id) {
+      this._items.delete(id);
+      this._emit("item:removed", { id: id });
+      return this;
+    }
+
+    applyDiscount(discount) {
+      this._discount = discount;
+      this._emit("discount:applied", discount);
+      return this;
+    }
+
+    get subtotal() {
+      var total = 0;
+      this._items.forEach(function(item) { total += item.subtotal; });
+      return total;
+    }
+
+    get total() {
+      var sub = this.subtotal;
+      return this._discount ? this._discount.apply(sub) : sub;
+    }
+
+    get itemCount() {
+      var count = 0;
+      this._items.forEach(function(item) { count += item.quantity; });
+      return count;
+    }
+
+    on(event, handler) {
+      this._listeners.push({ event: event, handler: handler });
+      return this;
+    }
+
+    _emit(event, data) {
+      this._listeners
+        .filter(function(l) { return l.event === event; })
+        .forEach(function(l) { l.handler(data); });
+    }
+  }
+  '''
+end
diff --git a/test/support/fixtures/kotlin/coroutine_flow.ex b/test/support/fixtures/kotlin/coroutine_flow.ex
new file mode 100644
index 0000000..efd8f80
--- /dev/null
+++ b/test/support/fixtures/kotlin/coroutine_flow.ex
@@ -0,0 +1,64 @@
+defmodule Test.Fixtures.Kotlin.CoroutineFlow do
+  @moduledoc false
+  use Test.LanguageFixture, language: "kotlin coroutine_flow"
+
+  @code ~S'''
+  interface FlowCollector<T> {
+    suspend fun emit(value: T)
+  }
+
+  interface Flow<T> {
+    suspend fun collect(collector: FlowCollector<T>)
+  }
+
+  interface Channel<T> {
+    suspend fun send(value: T)
+    suspend fun receive(): T
+    fun close()
+    val isClosedForSend: Boolean
+  }
+
+  class SimpleFlow<T>(private val block: suspend FlowCollector<T>.() -> Unit) : Flow<T> {
+    override suspend fun collect(collector: FlowCollector<T>) {
+      collector.block()
+    }
+  }
+
+  class TransformFlow<T, R>(
+    private val upstream: Flow<T>,
+    private val transform: suspend (T) -> R
+  ) : Flow<R> {
+    override suspend fun collect(collector: FlowCollector<R>) {
+      upstream.collect(object : FlowCollector<T> {
+        override suspend fun emit(value: T) {
+          collector.emit(transform(value))
+        }
+      })
+    }
+  }
+
+  class FilterFlow<T>(
+    private val upstream: Flow<T>,
+    private val predicate: suspend (T) -> Boolean
+  ) : Flow<T> {
+    override suspend fun collect(collector: FlowCollector<T>) {
+      upstream.collect(object : FlowCollector<T> {
+        override suspend fun emit(value: T) {
+          if (predicate(value)) collector.emit(value)
+        }
+      })
+    }
+  }
+
+  class BufferedChannel<T>(private val capacity: Int) : Channel<T> {
+    private val buffer: ArrayDeque<T> = ArrayDeque()
+    override val isClosedForSend: Boolean get() = false
+
+    override suspend fun send(value: T) { buffer.addLast(value) }
+
+    override suspend fun receive(): T = buffer.removeFirst()
+
+    override fun close() { buffer.clear() }
+  }
+  '''
+end
diff --git a/test/support/fixtures/kotlin/extension_library.ex b/test/support/fixtures/kotlin/extension_library.ex
new file mode 100644
index 0000000..8d0ad7e
--- /dev/null
+++ b/test/support/fixtures/kotlin/extension_library.ex
@@ -0,0 +1,55 @@
+defmodule Test.Fixtures.Kotlin.ExtensionLibrary do
+  @moduledoc false
+  use Test.LanguageFixture, language: "kotlin extension_library"
+
+  @code ~S'''
+  interface StringValidator {
+    fun validate(value: String): Boolean
+    fun errorMessage(): String
+  }
+
+  interface Transformer<T, R> {
+    fun transform(value: T): R
+  }
+
+  interface Pipeline<T> {
+    fun pipe(step: Transformer<T, T>): Pipeline<T>
+    fun execute(input: T): T
+  }
+
+  class EmailValidator : StringValidator {
+    override fun validate(value: String): Boolean = value.contains("@") && value.contains(".")
+
+    override fun errorMessage(): String = "Invalid email format"
+  }
+
+  class LengthValidator(private val min: Int, private val max: Int) : StringValidator {
+    override fun validate(value: String): Boolean = value.length in min..max
+
+    override fun errorMessage(): String = "Length must be between $min and $max"
+  }
+
+  class TrimTransformer : Transformer<String, String> {
+    override fun transform(value: String): String = value.trim()
+  }
+
+  class LowercaseTransformer : Transformer<String, String> {
+    override fun transform(value: String): String = value.lowercase()
+  }
+
+  class StringPipeline : Pipeline<String> {
+    private val steps: MutableList<Transformer<String, String>> = mutableListOf()
+
+    override fun pipe(step: Transformer<String, String>): Pipeline<String> {
+      steps.add(step)
+      return this
+    }
+
+    override fun execute(input: String): String = steps.fold(input) { acc, step -> step.transform(acc) }
+  }
+
+  enum class ValidationMode {
+    STRICT, LENIENT, DISABLED
+  }
+  '''
+end
diff --git a/test/support/fixtures/kotlin/sealed_state.ex b/test/support/fixtures/kotlin/sealed_state.ex
new file mode 100644
index 0000000..fd0b1fa
--- /dev/null
+++ b/test/support/fixtures/kotlin/sealed_state.ex
@@ -0,0 +1,63 @@
+defmodule Test.Fixtures.Kotlin.SealedState do
+  @moduledoc false
+  use Test.LanguageFixture, language: "kotlin sealed_state"
+
+  @code ~S'''
+  interface Action
+
+  interface State
+
+  interface Reducer<S : State, A : Action> {
+    fun reduce(state: S, action: A): S
+  }
+
+  class ScreenState {
+    class Loading : ScreenState()
+    class Success(val data: List<String>) : ScreenState()
+    class Error(val message: String, val cause: Throwable?) : ScreenState()
+    class Empty : ScreenState()
+  }
+
+  class ScreenAction {
+    class Load : ScreenAction()
+    class LoadSuccess(val data: List<String>) : ScreenAction()
+    class LoadError(val message: String, val cause: Throwable?) : ScreenAction()
+    class Refresh : ScreenAction()
+    class Clear : ScreenAction()
+  }
+
+  class ScreenReducer : Reducer<ScreenState, ScreenAction> {
+    override fun reduce(state: ScreenState, action: ScreenAction): ScreenState {
+      return when (action) {
+        is ScreenAction.Load -> ScreenState.Loading()
+        is ScreenAction.LoadSuccess -> if (action.data.isEmpty()) ScreenState.Empty() else ScreenState.Success(action.data)
+        is ScreenAction.LoadError -> ScreenState.Error(action.message, action.cause)
+        is ScreenAction.Refresh -> ScreenState.Loading()
+        is ScreenAction.Clear -> ScreenState.Empty()
+        else -> state
+      }
+    }
+  }
+
+  enum class LoadStrategy {
+    EAGER, LAZY, PREFETCH, BACKGROUND
+  }
+
+  class StateStore<S : State, A : Action>(private val reducer: Reducer<S, A>, initialState: S) {
+    private var state: S = initialState
+    private val listeners: MutableList<(S) -> Unit> = mutableListOf()
+
+    fun getState(): S = state
+
+    fun dispatch(action: A) {
+      state = reducer.reduce(state, action)
+      listeners.forEach { it(state) }
+    }
+
+    fun subscribe(listener: (S) -> Unit): () -> Unit {
+      listeners.add(listener)
+      return { listeners.remove(listener) }
+    }
+  }
+  '''
+end
diff --git a/test/support/fixtures/lua/class_system.ex b/test/support/fixtures/lua/class_system.ex
new file mode 100644
index 0000000..d96769d
--- /dev/null
+++ b/test/support/fixtures/lua/class_system.ex
@@ -0,0 +1,63 @@
+defmodule Test.Fixtures.Lua.ClassSystem do
+  @moduledoc false
+  use Test.LanguageFixture, language: "lua class_system"
+
+  @code ~S'''
+  function class(parent)
+  local cls = {}
+  cls.__index = cls
+  if parent then
+    setmetatable(cls, { __index = parent })
+  end
+  cls.new = function(...)
+    local instance = setmetatable({}, cls)
+    if instance.init then
+      instance:init(...)
+    end
+    return instance
+  end
+  cls.isInstanceOf = function(self, klass)
+    local mt = getmetatable(self)
+    while mt do
+      if mt == klass then return true end
+      mt = getmetatable(mt)
+    end
+    return false
+  end
+  return cls
+  end
+
+  function mixin(target, source)
+  for key, value in pairs(source) do
+    if type(value) == "function" and not target[key] then
+      target[key] = value
+    end
+  end
+  return target
+  end
+
+  function interface(...)
+  local methods = { ... }
+  return function(obj)
+    for _, method in ipairs(methods) do
+      if type(obj[method]) ~= "function" then
+        error("Missing method: " .. method)
+      end
+    end
+    return true
+  end
+  end
+
+  function extend(parent, definition)
+  local cls = class(parent)
+  for k, v in pairs(definition) do
+    cls[k] = v
+  end
+  return cls
+  end
+
+  function implements(obj, iface)
+  return pcall(iface, obj)
+  end
+  '''
+end
diff --git a/test/support/fixtures/lua/event_system.ex b/test/support/fixtures/lua/event_system.ex
new file mode 100644
index 0000000..4c50cf8
--- /dev/null
+++ b/test/support/fixtures/lua/event_system.ex
@@ -0,0 +1,76 @@
+defmodule Test.Fixtures.Lua.EventSystem do
+  @moduledoc false
+  use Test.LanguageFixture, language: "lua event_system"
+
+  @code ~S'''
+  function EventEmitter()
+  local self = { listeners = {}, onceListeners = {} }
+
+  function self:on(event, callback)
+    if not self.listeners[event] then
+      self.listeners[event] = {}
+    end
+    table.insert(self.listeners[event], callback)
+    return self
+  end
+
+  function self:once(event, callback)
+    if not self.onceListeners[event] then
+      self.onceListeners[event] = {}
+    end
+    table.insert(self.onceListeners[event], callback)
+    return self
+  end
+
+  function self:off(event, callback)
+    if self.listeners[event] then
+      for i, cb in ipairs(self.listeners[event]) do
+        if cb == callback then
+          table.remove(self.listeners[event], i)
+          return self
+        end
+      end
+    end
+    return self
+  end
+
+  function self:emit(event, ...)
+    local listeners = self.listeners[event] or {}
+    for _, cb in ipairs(listeners) do
+      cb(...)
+    end
+    local onceListeners = self.onceListeners[event] or {}
+    self.onceListeners[event] = {}
+    for _, cb in ipairs(onceListeners) do
+      cb(...)
+    end
+    return self
+  end
+
+  function self:removeAllListeners(event)
+    if event then
+      self.listeners[event] = nil
+      self.onceListeners[event] = nil
+    else
+      self.listeners = {}
+      self.onceListeners = {}
+    end
+    return self
+  end
+
+  return self
+  end
+
+  function pipe(emitter1, event, emitter2, targetEvent)
+  emitter1:on(event, function(...)
+    emitter2:emit(targetEvent or event, ...)
+  end)
+  end
+
+  function broadcast(emitters, event, ...)
+  for _, emitter in ipairs(emitters) do
+    emitter:emit(event, ...)
+  end
+  end
+  '''
+end
diff --git a/test/support/fixtures/lua/state_machine.ex b/test/support/fixtures/lua/state_machine.ex
new file mode 100644
index 0000000..cba47b8
--- /dev/null
+++ b/test/support/fixtures/lua/state_machine.ex
@@ -0,0 +1,75 @@
+defmodule Test.Fixtures.Lua.StateMachine do
+  @moduledoc false
+  use Test.LanguageFixture, language: "lua state_machine"
+
+  @code ~S'''
+  function StateMachine(config)
+  local self = {
+    current = config.initial,
+    states = config.states or {},
+    transitions = config.transitions or {},
+    history = {},
+    listeners = {},
+  }
+
+  function self:can(event)
+    local key = self.current .. ":" .. event
+    return self.transitions[key] ~= nil
+  end
+
+  function self:transition(event, data)
+    local key = self.current .. ":" .. event
+    local target = self.transitions[key]
+    if not target then
+      error("No transition from '" .. self.current .. "' on event '" .. event .. "'")
+    end
+    local from = self.current
+    local stateConfig = self.states[from] or {}
+    if stateConfig.onExit then stateConfig.onExit(from, event, data) end
+    table.insert(self.history, { state = from, event = event })
+    self.current = target
+    local targetConfig = self.states[target] or {}
+    if targetConfig.onEnter then targetConfig.onEnter(target, event, data) end
+    for _, cb in ipairs(self.listeners) do
+      cb(from, event, target, data)
+    end
+    return self
+  end
+
+  function self:onTransition(callback)
+    table.insert(self.listeners, callback)
+    return self
+  end
+
+  function self:getHistory()
+    return self.history
+  end
+
+  function self:reset()
+    self.current = config.initial
+    self.history = {}
+    return self
+  end
+
+  return self
+  end
+
+  function buildTransitionTable(transitions)
+  local tbl = {}
+  for _, t in ipairs(transitions) do
+    local key = t.from .. ":" .. t.event
+    tbl[key] = t.to
+  end
+  return tbl
+  end
+
+  function validateMachine(machine, requiredStates)
+  for _, state in ipairs(requiredStates) do
+    if not machine.states[state] then
+      return false, "Missing state: " .. state
+    end
+  end
+  return true, nil
+  end
+  '''
+end
diff --git a/test/support/fixtures/python/calculator.ex b/test/support/fixtures/python/calculator.ex
new file mode 100644
index 0000000..47c9029
--- /dev/null
+++ b/test/support/fixtures/python/calculator.ex
@@ -0,0 +1,83 @@
+defmodule Test.Fixtures.Python.Calculator do
+  @moduledoc false
+  use Test.LanguageFixture, language: "python calculator"
+
+  @code ~S'''
+  class Calculator:
+      """A calculator supporting basic arithmetic operations."""
+
+      def add(self, a, b):
+          """Returns the sum of a and b."""
+          return a + b
+
+      def subtract(self, a, b):
+          """Returns a minus b."""
+          return a - b
+
+      def multiply(self, a, b):
+          """Returns the product of a and b."""
+          return a * b
+
+      def divide(self, a, b):
+          """Divides a by b. Raises for zero divisor."""
+          if b == 0:
+              raise ValueError("Cannot divide by zero")
+          return a / b
+
+      def power(self, base, exp):
+          """Returns base to the power of exp."""
+          return base ** exp
+
+      def sqrt(self, n):
+          """Returns the square root. Raises for negative input."""
+          if n < 0:
+              raise ValueError("Cannot take sqrt of negative number")
+          return n ** 0.5
+
+      def abs_val(self, n):
+          """Returns the absolute value of n."""
+          if n < 0:
+              return -n
+          return n
+
+
+  class ScientificCalculator(Calculator):
+      """Extended scientific calculator."""
+
+      def log(self, n, base=10):
+          """Returns log base of n. Raises for non-positive n."""
+          if n <= 0:
+              raise ValueError("Logarithm undefined for non-positive values")
+          import math
+          return math.log(n, base)
+
+      def factorial(self, n):
+          """Returns n factorial. Raises for negative n."""
+          if n < 0:
+              raise ValueError("Factorial undefined for negative numbers")
+          if n == 0:
+              return 1
+          result = 1
+          for i in range(1, n + 1):
+              result *= i
+          return result
+
+
+  def add(a, b):
+      return a + b
+
+
+  def subtract(a, b):
+      return a - b
+
+
+  def multiply(a, b):
+      return a * b
+
+
+  def divide(a, b):
+      if b == 0:
+          raise ValueError("Cannot divide by zero")
+      return a / b
+  '''
+end
diff --git a/test/support/fixtures/python/config_parser.ex b/test/support/fixtures/python/config_parser.ex
new file mode 100644
index 0000000..a58516e
--- /dev/null
+++ b/test/support/fixtures/python/config_parser.ex
@@ -0,0 +1,89 @@
+defmodule Test.Fixtures.Python.ConfigParser do
+  @moduledoc false
+  use Test.LanguageFixture, language: "python config_parser"
+
+  @code ~S'''
+  from dataclasses import dataclass, field
+  from typing import ClassVar, Optional
+
+
+  @dataclass
+  class DatabaseConfig:
+      """Database connection configuration."""
+
+      host: str = "localhost"
+      port: int = 5432
+      name: str = "app"
+      pool_size: int = 10
+      VALID_PORTS: ClassVar[range] = range(1, 65536)
+
+      def __post_init__(self):
+          """Validates configuration after initialisation."""
+          if self.port not in self.VALID_PORTS:
+              raise ValueError(f"Invalid port: {self.port}")
+          if not self.host:
+              raise ValueError("host must not be empty")
+          if self.pool_size < 1:
+              raise ValueError("pool_size must be at least 1")
+
+      def url(self) -> str:
+          """Returns the database connection URL."""
+          return f"postgres://{self.host}:{self.port}/{self.name}"
+
+
+  @dataclass
+  class LoggingConfig:
+      """Logging configuration."""
+
+      level: str = "info"
+      format: str = "text"
+      output: str = "stdout"
+      VALID_LEVELS: ClassVar[list] = ["debug", "info", "warning", "error"]
+      VALID_FORMATS: ClassVar[list] = ["text", "json"]
+
+      def __post_init__(self):
+          """Validates level and format."""
+          if self.level not in self.VALID_LEVELS:
+              raise ValueError(f"Invalid log level: {self.level}")
+          if self.format not in self.VALID_FORMATS:
+              raise ValueError(f"Invalid log format: {self.format}")
+
+
+  @dataclass
+  class AppConfig:
+      """Top-level application configuration."""
+
+      database: DatabaseConfig = field(default_factory=DatabaseConfig)
+      logging: LoggingConfig = field(default_factory=LoggingConfig)
+      debug: bool = False
+      version: str = "1.0.0"
+
+      def is_production(self) -> bool:
+          """Returns True when debug mode is disabled."""
+          return not self.debug
+
+      @classmethod
+      def from_dict(cls, data: dict) -> "AppConfig":
+          """Builds an AppConfig from a plain dictionary."""
+          db_data = data.get("database", {})
+          log_data = data.get("logging", {})
+          return cls(
+              database=DatabaseConfig(**db_data),
+              logging=LoggingConfig(**log_data),
+              debug=data.get("debug", False),
+              version=data.get("version", "1.0.0"),
+          )
+
+      @classmethod
+      def from_env(cls, prefix: str = "APP") -> "AppConfig":
+          """Builds an AppConfig from environment variables."""
+          import os
+          return cls(
+              database=DatabaseConfig(
+                  host=os.getenv(f"{prefix}_DB_HOST", "localhost"),
+                  port=int(os.getenv(f"{prefix}_DB_PORT", "5432")),
+              ),
+              debug=os.getenv(f"{prefix}_DEBUG", "false").lower() == "true",
+          )
+  '''
+end
diff --git a/test/support/fixtures/python/csv_pipeline.ex b/test/support/fixtures/python/csv_pipeline.ex
new file mode 100644
index 0000000..459acf8
--- /dev/null
+++ b/test/support/fixtures/python/csv_pipeline.ex
@@ -0,0 +1,95 @@
+defmodule Test.Fixtures.Python.CsvPipeline do
+  @moduledoc false
+  use Test.LanguageFixture, language: "python csv_pipeline"
+
+  @code ~S'''
+  from dataclasses import dataclass, field
+  from typing import Iterator, Protocol
+
+
+  @dataclass
+  class CsvRow:
+      """Represents one row of parsed CSV data."""
+
+      fields: dict
+      line_number: int
+
+      def get(self, key: str, default=None):
+          """Returns the value for key or default."""
+          return self.fields.get(key, default)
+
+      def keys(self) -> list:
+          """Returns all field names."""
+          return list(self.fields.keys())
+
+
+  class RowTransformer(Protocol):
+      """Protocol for CSV row transformation steps."""
+
+      def transform(self, row: CsvRow) -> CsvRow:
+          """Transforms a single row."""
+          ...
+
+
+  @dataclass
+  class ColumnRenamer:
+      """Renames columns according to a mapping."""
+
+      mapping: dict = field(default_factory=dict)
+
+      def transform(self, row: CsvRow) -> CsvRow:
+          """Applies column rename mapping to a row."""
+          new_fields = {self.mapping.get(k, k): v for k, v in row.fields.items()}
+          return CsvRow(fields=new_fields, line_number=row.line_number)
+
+
+  @dataclass
+  class TypeCoercer:
+      """Coerces column values to specified types."""
+
+      types: dict = field(default_factory=dict)
+
+      def transform(self, row: CsvRow) -> CsvRow:
+          """Coerces field values using the types mapping."""
+          coerced = {}
+          for key, value in row.fields.items():
+              target_type = self.types.get(key)
+              if target_type is not None:
+                  try:
+                      coerced[key] = target_type(value)
+                  except (ValueError, TypeError):
+                      coerced[key] = value
+              else:
+                  coerced[key] = value
+          return CsvRow(fields=coerced, line_number=row.line_number)
+
+
+  class CsvPipeline:
+      """Streaming CSV pipeline with pluggable transformation steps."""
+
+      def __init__(self, path: str):
+          """Initialises the pipeline for the given CSV file path."""
+          self._path = path
+          self._steps: list = []
+
+      def add_step(self, step: RowTransformer) -> "CsvPipeline":
+          """Adds a transformation step and returns self for chaining."""
+          self._steps.append(step)
+          return self
+
+      def run(self) -> Iterator[CsvRow]:
+          """Yields processed rows from the CSV file."""
+          with open(self._path, "r", newline="") as fh:
+              import csv
+              reader = csv.DictReader(fh)
+              for line_number, raw in enumerate(reader, start=1):
+                  row = CsvRow(fields=dict(raw), line_number=line_number)
+                  for step in self._steps:
+                      row = step.transform(row)
+                  yield row
+
+      def collect(self) -> list:
+          """Collects all processed rows into a list."""
+          return list(self.run())
+  '''
+end
diff --git a/test/support/fixtures/ruby/calculator.ex b/test/support/fixtures/ruby/calculator.ex
new file mode 100644
index 0000000..df46955
--- /dev/null
+++ b/test/support/fixtures/ruby/calculator.ex
@@ -0,0 +1,59 @@
+defmodule Test.Fixtures.Ruby.Calculator do
+  @moduledoc false
+  use Test.LanguageFixture, language: "ruby calculator"
+
+  @code ~S'''
+  module Calculable
+    def abs_val(n)
+      n < 0 ? -n : n
+    end
+
+    def clamp(n, min, max)
+      [[n, min].max, max].min
+    end
+  end
+
+  class BasicCalculator
+    include Calculable
+
+    def add(a, b)
+      a + b
+    end
+
+    def subtract(a, b)
+      a - b
+    end
+
+    def multiply(a, b)
+      a * b
+    end
+
+    def divide(a, b)
+      raise ArgumentError, "Cannot divide by zero" if b.zero?
+      a.to_f / b
+    end
+
+    def power(a, b)
+      a ** b
+    end
+  end
+
+  class ScientificCalculator < BasicCalculator
+    def sqrt(n)
+      raise ArgumentError, "Cannot take sqrt of negative number" if n < 0
+      Math.sqrt(n)
+    end
+
+    def log(n, base = 10)
+      raise ArgumentError, "Logarithm undefined for non-positive values" if n <= 0
+      Math.log(n) / Math.log(base)
+    end
+
+    def factorial(n)
+      raise ArgumentError, "Factorial undefined for negative numbers" if n < 0
+      return 1 if n == 0
+      (1..n).reduce(1, :*)
+    end
+  end
+  '''
+end
diff --git a/test/support/fixtures/ruby/markdown_renderer.ex b/test/support/fixtures/ruby/markdown_renderer.ex
new file mode 100644
index 0000000..2e70d26
--- /dev/null
+++ b/test/support/fixtures/ruby/markdown_renderer.ex
@@ -0,0 +1,79 @@
+defmodule Test.Fixtures.Ruby.MarkdownRenderer do
+  @moduledoc false
+  use Test.LanguageFixture, language: "ruby markdown_renderer"
+
+  @code ~S'''
+  module Markdown
+    Token = Struct.new(:type, :content, :level)
+  end
+
+  module Markdown::Tokenizer
+    HEADING_RE = /^(#{1,6})\s+(.+)$/
+    CODE_BLOCK_RE = /^```(\w*)$/
+    BOLD_RE = /\*\*(.+?)\*\*/
+    ITALIC_RE = /\*(.+?)\*/
+    LINK_RE = /\[(.+?)\]\((.+?)\)/
+
+    def tokenize_line(line)
+      case line
+      when HEADING_RE
+        Markdown::Token.new(:heading, Regexp.last_match(2), Regexp.last_match(1).length)
+      when /^\s*[-*]\s+(.+)/
+        Markdown::Token.new(:list_item, Regexp.last_match(1), 0)
+      when /^\s*$/
+        Markdown::Token.new(:blank, "", 0)
+      else
+        Markdown::Token.new(:paragraph, line, 0)
+      end
+    end
+
+    def inline_format(text)
+      text
+        .gsub(LINK_RE) { "<a href=\"#{Regexp.last_match(2)}\">#{Regexp.last_match(1)}</a>" }
+        .gsub(BOLD_RE) { "<strong>#{Regexp.last_match(1)}</strong>" }
+        .gsub(ITALIC_RE) { "<em>#{Regexp.last_match(1)}</em>" }
+    end
+  end
+
+  module Markdown::Renderer
+    include Markdown::Tokenizer
+
+    def render_token(token)
+      case token.type
+      when :heading
+        "<h#{token.level}>#{inline_format(token.content)}</h#{token.level}>"
+      when :list_item
+        "<li>#{inline_format(token.content)}</li>"
+      when :paragraph
+        "<p>#{inline_format(token.content)}</p>"
+      when :blank
+        ""
+      end
+    end
+
+    def render(markdown)
+      markdown.lines.map { |line| tokenize_line(line.chomp) }.map { |token| render_token(token) }.reject(&:empty?).join("\n")
+    end
+  end
+
+  class Markdown::Document
+    include Markdown::Renderer
+
+    def initialize(source)
+      @source = source
+    end
+
+    def to_html
+      render(@source)
+    end
+
+    def word_count
+      @source.split(/\s+/).length
+    end
+
+    def heading_count
+      @source.lines.count { |l| l.match?(HEADING_RE) }
+    end
+  end
+  '''
+end
diff --git a/test/support/fixtures/ruby/orm_lite.ex b/test/support/fixtures/ruby/orm_lite.ex
new file mode 100644
index 0000000..672b668
--- /dev/null
+++ b/test/support/fixtures/ruby/orm_lite.ex
@@ -0,0 +1,106 @@
+defmodule Test.Fixtures.Ruby.OrmLite do
+  @moduledoc false
+  use Test.LanguageFixture, language: "ruby orm_lite"
+
+  @code ~S'''
+  module OrmLite
+    module Persistence
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.instance_variable_set(:@columns, [])
+        base.instance_variable_set(:@validations, [])
+      end
+
+      module ClassMethods
+        def column(name, type = :string)
+          @columns << { name: name, type: type }
+          attr_accessor name
+        end
+
+        def validates(name, **rules)
+          @validations << { name: name, rules: rules }
+        end
+
+        def columns
+          @columns
+        end
+
+        def validations
+          @validations
+        end
+
+        def find(id)
+          new(id: id)
+        end
+      end
+
+      def initialize(attrs = {})
+        attrs.each do |key, value|
+          send(:"#{key}=", value) if respond_to?(:"#{key}=")
+        end
+      end
+
+      def valid?
+        @errors = []
+        self.class.validations.each do |v|
+          value = send(v[:name])
+          @errors << "#{v[:name]} can't be blank" if v[:rules][:presence] && (value.nil? || value.to_s.empty?)
+          @errors << "#{v[:name]} is too short" if v[:rules][:min_length] && value.to_s.length < v[:rules][:min_length]
+        end
+        @errors.empty?
+      end
+
+      def errors
+        @errors ||= []
+      end
+
+      def save
+        return false unless valid?
+        true
+      end
+    end
+
+    module Associations
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def has_many(name)
+          define_method(name) do
+            []
+          end
+        end
+
+        def belongs_to(name)
+          attr_accessor :"#{name}_id"
+          define_method(name) do
+            nil
+          end
+        end
+      end
+    end
+  end
+
+  class User
+    include OrmLite::Persistence
+    include OrmLite::Associations
+    column :name, :string
+    column :email, :string
+    column :age, :integer
+    has_many :posts
+    validates :name, presence: true, min_length: 2
+    validates :email, presence: true
+  end
+
+  class Post
+    include OrmLite::Persistence
+    include OrmLite::Associations
+    column :title, :string
+    column :body, :text
+    belongs_to :user
+    validates :title, presence: true
+    validates :body, presence: true
+  end
+  '''
+end
diff --git a/test/support/fixtures/rust/calculator.ex b/test/support/fixtures/rust/calculator.ex
new file mode 100644
index 0000000..a47df57
--- /dev/null
+++ b/test/support/fixtures/rust/calculator.ex
@@ -0,0 +1,70 @@
+defmodule Test.Fixtures.Rust.Calculator do
+  @moduledoc false
+  use Test.LanguageFixture, language: "rust calculator"
+
+  @code ~S'''
+  trait Calculator {
+      fn add(&self, a: f64, b: f64) -> f64;
+      fn subtract(&self, a: f64, b: f64) -> f64;
+      fn multiply(&self, a: f64, b: f64) -> f64;
+      fn divide(&self, a: f64, b: f64) -> Option<f64>;
+  }
+
+  struct BasicCalculator;
+
+  impl Calculator for BasicCalculator {
+      fn add(&self, a: f64, b: f64) -> f64 {
+          a + b
+      }
+
+      fn subtract(&self, a: f64, b: f64) -> f64 {
+          a - b
+      }
+
+      fn multiply(&self, a: f64, b: f64) -> f64 {
+          a * b
+      }
+
+      fn divide(&self, a: f64, b: f64) -> Option<f64> {
+          if b == 0.0 { return None; }
+          Some(a / b)
+      }
+  }
+
+  impl BasicCalculator {
+      fn new() -> Self {
+          BasicCalculator
+      }
+
+      fn power(&self, base: f64, exp: f64) -> f64 {
+          base.powf(exp)
+      }
+
+      fn sqrt(&self, n: f64) -> Option<f64> {
+          if n < 0.0 { return None; }
+          Some(n.sqrt())
+      }
+
+      fn abs(&self, n: f64) -> f64 {
+          n.abs()
+      }
+  }
+
+  fn add(a: f64, b: f64) -> f64 {
+      a + b
+  }
+
+  fn subtract(a: f64, b: f64) -> f64 {
+      a - b
+  }
+
+  fn multiply(a: f64, b: f64) -> f64 {
+      a * b
+  }
+
+  fn divide(a: f64, b: f64) -> Option<f64> {
+      if b == 0.0 { return None; }
+      Some(a / b)
+  }
+  '''
+end
diff --git a/test/support/fixtures/rust/ring_buffer.ex b/test/support/fixtures/rust/ring_buffer.ex
new file mode 100644
index 0000000..eba5a76
--- /dev/null
+++ b/test/support/fixtures/rust/ring_buffer.ex
@@ -0,0 +1,86 @@
+defmodule Test.Fixtures.Rust.RingBuffer do
+  @moduledoc false
+  use Test.LanguageFixture, language: "rust ring_buffer"
+
+  @code ~S'''
+  struct RingBuffer<T> {
+      data: Vec<Option<T>>,
+      head: usize,
+      tail: usize,
+      len: usize,
+      capacity: usize,
+  }
+
+  impl<T> RingBuffer<T> {
+      fn new(capacity: usize) -> Self {
+          let data = (0..capacity).map(|_| None).collect();
+          RingBuffer { data, head: 0, tail: 0, len: 0, capacity }
+      }
+
+      fn push(&mut self, value: T) -> bool {
+          if self.len == self.capacity {
+              return false;
+          }
+          self.data[self.tail] = Some(value);
+          self.tail = (self.tail + 1) % self.capacity;
+          self.len += 1;
+          true
+      }
+
+      fn pop(&mut self) -> Option<T> {
+          if self.len == 0 {
+              return None;
+          }
+          let value = self.data[self.head].take();
+          self.head = (self.head + 1) % self.capacity;
+          self.len -= 1;
+          value
+      }
+
+      fn peek(&self) -> Option<&T> {
+          if self.len == 0 { None } else { self.data[self.head].as_ref() }
+      }
+
+      fn is_empty(&self) -> bool {
+          self.len == 0
+      }
+
+      fn is_full(&self) -> bool {
+          self.len == self.capacity
+      }
+
+      fn len(&self) -> usize {
+          self.len
+      }
+
+      fn capacity(&self) -> usize {
+          self.capacity
+      }
+
+      fn clear(&mut self) {
+          for slot in self.data.iter_mut() {
+              *slot = None;
+          }
+          self.head = 0;
+          self.tail = 0;
+          self.len = 0;
+      }
+  }
+
+  impl<T: Clone> RingBuffer<T> {
+      fn to_vec(&self) -> Vec<T> {
+          (0..self.len)
+              .filter_map(|i| self.data[(self.head + i) % self.capacity].clone())
+              .collect()
+      }
+  }
+
+  fn fill_buffer<T: Clone>(items: &[T], capacity: usize) -> RingBuffer<T> {
+      let mut buf = RingBuffer::new(capacity);
+      for item in items {
+          buf.push(item.clone());
+      }
+      buf
+  }
+  '''
+end
diff --git a/test/support/fixtures/rust/tokenizer.ex b/test/support/fixtures/rust/tokenizer.ex
new file mode 100644
index 0000000..0925774
--- /dev/null
+++ b/test/support/fixtures/rust/tokenizer.ex
@@ -0,0 +1,112 @@
+defmodule Test.Fixtures.Rust.Tokenizer do
+  @moduledoc false
+  use Test.LanguageFixture, language: "rust tokenizer"
+
+  @code ~S'''
+  #[derive(Debug, PartialEq, Clone)]
+  enum TokenKind {
+      Number(f64),
+      Plus,
+      Minus,
+      Star,
+      Slash,
+      LParen,
+      RParen,
+      Eof,
+  }
+
+  #[derive(Debug, Clone)]
+  struct Token {
+      kind: TokenKind,
+      lexeme: String,
+      line: usize,
+  }
+
+  impl Token {
+      fn new(kind: TokenKind, lexeme: &str, line: usize) -> Self {
+          Token { kind, lexeme: lexeme.to_string(), line }
+      }
+
+      fn is_operator(&self) -> bool {
+          matches!(self.kind, TokenKind::Plus | TokenKind::Minus | TokenKind::Star | TokenKind::Slash)
+      }
+  }
+
+  impl std::fmt::Display for Token {
+      fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+          write!(f, "{:?}({})", self.kind, self.lexeme)
+      }
+  }
+
+  struct Lexer {
+      source: Vec<char>,
+      pos: usize,
+      line: usize,
+  }
+
+  impl Lexer {
+      fn new(source: &str) -> Self {
+          Lexer { source: source.chars().collect(), pos: 0, line: 1 }
+      }
+
+      fn peek(&self) -> Option<char> {
+          self.source.get(self.pos).copied()
+      }
+
+      fn advance(&mut self) -> Option<char> {
+          let ch = self.source.get(self.pos).copied();
+          self.pos += 1;
+          ch
+      }
+
+      fn skip_whitespace(&mut self) {
+          while let Some(c) = self.peek() {
+              if c == '\n' { self.line += 1; self.pos += 1; }
+              else if c.is_whitespace() { self.pos += 1; }
+              else { break; }
+          }
+      }
+
+      fn read_number(&mut self) -> Token {
+          let start = self.pos;
+          while let Some(c) = self.peek() {
+              if c.is_ascii_digit() || c == '.' { self.pos += 1; }
+              else { break; }
+          }
+          let lexeme: String = self.source[start..self.pos].iter().collect();
+          let value: f64 = lexeme.parse().unwrap_or(0.0);
+          Token::new(TokenKind::Number(value), &lexeme, self.line)
+      }
+
+      fn next_token(&mut self) -> Token {
+          self.skip_whitespace();
+          match self.advance() {
+              Some('+') => Token::new(TokenKind::Plus, "+", self.line),
+              Some('-') => Token::new(TokenKind::Minus, "-", self.line),
+              Some('*') => Token::new(TokenKind::Star, "*", self.line),
+              Some('/') => Token::new(TokenKind::Slash, "/", self.line),
+              Some('(') => Token::new(TokenKind::LParen, "(", self.line),
+              Some(')') => Token::new(TokenKind::RParen, ")", self.line),
+              Some(c) if c.is_ascii_digit() => { self.pos -= 1; self.read_number() }
+              None => Token::new(TokenKind::Eof, "", self.line),
+              _ => Token::new(TokenKind::Eof, "", self.line),
+          }
+      }
+
+      fn tokenize(&mut self) -> Vec<Token> {
+          let mut tokens = Vec::new();
+          loop {
+              let t = self.next_token();
+              let done = t.kind == TokenKind::Eof;
+              tokens.push(t);
+              if done { break; }
+          }
+          tokens
+      }
+  }
+
+  fn tokenize(source: &str) -> Vec<Token> {
+      Lexer::new(source).tokenize()
+  }
+  '''
+end
diff --git a/test/support/fixtures/scala/actor_messages.ex b/test/support/fixtures/scala/actor_messages.ex
new file mode 100644
index 0000000..73f150c
--- /dev/null
+++ b/test/support/fixtures/scala/actor_messages.ex
@@ -0,0 +1,70 @@
+defmodule Test.Fixtures.Scala.ActorMessages do
+  @moduledoc false
+  use Test.LanguageFixture, language: "scala actor_messages"
+
+  @code ~S'''
+  trait Message
+
+  class Request(val id: String, val payload: Map[String, String]) extends Message
+
+  class Response(val id: String, val status: Int, val body: String) extends Message
+
+  class Broadcast(val topic: String, val data: String) extends Message
+
+  class Shutdown(val reason: String) extends Message
+
+  trait ActorState
+
+  class Active(val processedCount: Int) extends ActorState
+
+  class Paused(val since: Long, val reason: String) extends ActorState
+
+  class Stopped(val at: Long) extends ActorState
+
+  trait Behaviour {
+  def receive(message: Message, state: ActorState): (List[Message], ActorState)
+
+  def onStart(): ActorState
+
+  def onStop(state: ActorState): Unit
+  }
+
+  class EchoBehaviour extends Behaviour {
+  def receive(message: Message, state: ActorState): (List[Message], ActorState) =
+    message match {
+      case req: Request =>
+        val reply = new Response(req.id, 200, req.payload.mkString(","))
+        val newState = state match {
+          case a: Active => new Active(a.processedCount + 1)
+          case other => other
+        }
+        (List(reply), newState)
+      case _: Shutdown => (List.empty, new Stopped(System.currentTimeMillis()))
+      case _ => (List.empty, state)
+    }
+
+  def onStart(): ActorState = new Active(0)
+
+  def onStop(state: ActorState): Unit = {}
+  }
+
+  class Supervisor {
+  private var actors: Map[String, Behaviour] = Map.empty
+  private var states: Map[String, ActorState] = Map.empty
+
+  def spawn(id: String, behaviour: Behaviour): Unit = {
+    actors = actors + (id -> behaviour)
+    states = states + (id -> behaviour.onStart())
+  }
+
+  def send(id: String, message: Message): List[Message] =
+    actors.get(id).map { b =>
+      val (replies, newState) = b.receive(message, states(id))
+      states = states + (id -> newState)
+      replies
+    }.getOrElse(List.empty)
+
+  def stop(id: String): Unit = actors.get(id).foreach { b => b.onStop(states(id)); actors = actors - id }
+  }
+  '''
+end
diff --git a/test/support/fixtures/scala/case_class_algebra.ex b/test/support/fixtures/scala/case_class_algebra.ex
new file mode 100644
index 0000000..7a2f002
--- /dev/null
+++ b/test/support/fixtures/scala/case_class_algebra.ex
@@ -0,0 +1,73 @@
+defmodule Test.Fixtures.Scala.CaseClassAlgebra do
+  @moduledoc false
+  use Test.LanguageFixture, language: "scala case_class_algebra"
+
+  @code ~S'''
+  trait Expr
+
+  class Num(val value: Double) extends Expr
+
+  class Add(val left: Expr, val right: Expr) extends Expr
+
+  class Sub(val left: Expr, val right: Expr) extends Expr
+
+  class Mul(val left: Expr, val right: Expr) extends Expr
+
+  class Div(val left: Expr, val right: Expr) extends Expr
+
+  class Neg(val expr: Expr) extends Expr
+
+  trait EvalResult
+
+  class EvalOk(val value: Double) extends EvalResult
+
+  class EvalError(val message: String) extends EvalResult
+
+  trait Evaluator {
+  def eval(expr: Expr): EvalResult
+  }
+
+  class SafeEvaluator extends Evaluator {
+  def eval(expr: Expr): EvalResult = expr match {
+    case n: Num => new EvalOk(n.value)
+    case neg: Neg => eval(neg.expr) match {
+      case ok: EvalOk => new EvalOk(-ok.value)
+      case err => err
+    }
+    case add: Add => combine(add.left, add.right)(_ + _)
+    case sub: Sub => combine(sub.left, sub.right)(_ - _)
+    case mul: Mul => combine(mul.left, mul.right)(_ * _)
+    case div: Div => eval(div.right) match {
+      case ok: EvalOk if ok.value == 0.0 => new EvalError("Division by zero")
+      case ok: EvalOk => eval(div.left) match {
+        case lOk: EvalOk => new EvalOk(lOk.value / ok.value)
+        case err => err
+      }
+      case err => err
+    }
+  }
+
+  private def combine(l: Expr, r: Expr)(op: (Double, Double) => Double): EvalResult =
+    (eval(l), eval(r)) match {
+      case (lv: EvalOk, rv: EvalOk) => new EvalOk(op(lv.value, rv.value))
+      case (err: EvalError, _) => err
+      case (_, err: EvalError) => err
+    }
+  }
+
+  trait Printer {
+  def print(expr: Expr): String
+  }
+
+  class InfixPrinter extends Printer {
+  def print(expr: Expr): String = expr match {
+    case n: Num => n.value.toString
+    case neg: Neg => s"-${print(neg.expr)}"
+    case add: Add => s"(${print(add.left)} + ${print(add.right)})"
+    case sub: Sub => s"(${print(sub.left)} - ${print(sub.right)})"
+    case mul: Mul => s"(${print(mul.left)} * ${print(mul.right)})"
+    case div: Div => s"(${print(div.left)} / ${print(div.right)})"
+  }
+  }
+  '''
+end
diff --git a/test/support/fixtures/scala/typeclass_pattern.ex b/test/support/fixtures/scala/typeclass_pattern.ex
new file mode 100644
index 0000000..0a14c37
--- /dev/null
+++ b/test/support/fixtures/scala/typeclass_pattern.ex
@@ -0,0 +1,64 @@
+defmodule Test.Fixtures.Scala.TypeclassPattern do
+  @moduledoc false
+  use Test.LanguageFixture, language: "scala typeclass_pattern"
+
+  @code ~S'''
+  trait Show[A] {
+  def show(value: A): String
+  }
+
+  trait Eq[A] {
+  def eqv(a: A, b: A): Boolean
+
+  def neqv(a: A, b: A): Boolean = !eqv(a, b)
+  }
+
+  trait Ord[A] extends Eq[A] {
+  def compare(a: A, b: A): Int
+
+  def lt(a: A, b: A): Boolean = compare(a, b) < 0
+
+  def lte(a: A, b: A): Boolean = compare(a, b) <= 0
+
+  def gt(a: A, b: A): Boolean = compare(a, b) > 0
+
+  def gte(a: A, b: A): Boolean = compare(a, b) >= 0
+
+  def eqv(a: A, b: A): Boolean = compare(a, b) == 0
+  }
+
+  trait Functor[F[_]] {
+  def map[A, B](fa: F[A])(f: A => B): F[B]
+  }
+
+  class Identity[A](val value: A)
+
+  class IdentityInstances {
+  val identityFunctor: Functor[Identity] = new Functor[Identity] {
+    def map[A, B](fa: Identity[A])(f: A => B): Identity[B] = new Identity(f(fa.value))
+  }
+
+  val identityShow: Show[Identity[String]] = new Show[Identity[String]] {
+    def show(value: Identity[String]): String = s"Identity(${value.value})"
+  }
+  }
+
+  class ShowSyntax[A](value: A, ev: Show[A]) {
+  def show: String = ev.show(value)
+  }
+
+  class OrdSyntax[A](value: A, ev: Ord[A]) {
+  def <(other: A): Boolean = ev.lt(value, other)
+
+  def >(other: A): Boolean = ev.gt(value, other)
+
+  def ===(other: A): Boolean = ev.eqv(value, other)
+  }
+
+  trait Monoid[A] {
+  def empty: A
+
+  def combine(a: A, b: A): A
+  }
+  '''
+end
diff --git a/test/support/fixtures/swift/actor_model.ex b/test/support/fixtures/swift/actor_model.ex
new file mode 100644
index 0000000..3e65174
--- /dev/null
+++ b/test/support/fixtures/swift/actor_model.ex
@@ -0,0 +1,81 @@
+defmodule Test.Fixtures.Swift.ActorModel do
+  @moduledoc false
+  use Test.LanguageFixture, language: "swift actor_model"
+
+  @code ~S'''
+  enum ActorMessage {
+    case ping(replyTo: String)
+    case pong(from: String)
+    case shutdown
+    case updateState(key: String, value: String)
+  }
+
+  protocol ActorBehaviour {
+    var id: String { get }
+    func receive(_ message: ActorMessage) -> [ActorMessage]
+    func preStart()
+    func postStop()
+  }
+
+  struct ActorRef {
+    let id: String
+    private let mailbox: [ActorMessage]
+
+    init(id: String) {
+      self.id = id
+      self.mailbox = []
+    }
+  }
+
+  class ActorSystem {
+    private var actors: [String: ActorBehaviour] = [:]
+    private var mailboxes: [String: [ActorMessage]] = [:]
+
+    func spawn(id: String, behaviour: ActorBehaviour) {
+      actors[id] = behaviour
+      mailboxes[id] = []
+      behaviour.preStart()
+    }
+
+    func send(to id: String, message: ActorMessage) {
+      mailboxes[id, default: []].append(message)
+    }
+
+    func process(actorId: String) {
+      guard let actor = actors[actorId] else { return }
+      let messages = mailboxes[actorId] ?? []
+      mailboxes[actorId] = []
+      for message in messages {
+        let replies = actor.receive(message)
+        for reply in replies { self.processReply(reply) }
+      }
+    }
+
+    func stop(actorId: String) {
+      actors[actorId]?.postStop()
+      actors.removeValue(forKey: actorId)
+      mailboxes.removeValue(forKey: actorId)
+    }
+
+    private func processReply(_ message: ActorMessage) {}
+  }
+
+  struct StateActor: ActorBehaviour {
+    let id: String
+    private var state: [String: String] = [:]
+
+    func receive(_ message: ActorMessage) -> [ActorMessage] {
+      switch message {
+      case .ping(let replyTo): return [.pong(from: id)]
+      case .updateState(let key, let value): return []
+      case .shutdown: return []
+      default: return []
+      }
+    }
+
+    func preStart() {}
+
+    func postStop() {}
+  }
+  '''
+end
diff --git a/test/support/fixtures/swift/combine_stream.ex b/test/support/fixtures/swift/combine_stream.ex
new file mode 100644
index 0000000..1faf9e4
--- /dev/null
+++ b/test/support/fixtures/swift/combine_stream.ex
@@ -0,0 +1,66 @@
+defmodule Test.Fixtures.Swift.CombineStream do
+  @moduledoc false
+  use Test.LanguageFixture, language: "swift combine_stream"
+
+  @code ~S'''
+  protocol Publisher {
+    associatedtype Output
+    associatedtype Failure: Error
+    func subscribe(_ subscriber: AnySubscriber<Output, Failure>)
+  }
+
+  protocol Subscriber {
+    associatedtype Input
+    associatedtype Failure: Error
+    func receive(_ input: Input)
+    func receiveCompletion(_ completion: Completion<Failure>)
+  }
+
+  enum Completion<Failure: Error> {
+    case finished
+    case failure(Failure)
+  }
+
+  struct AnySubscriber<Input, Failure: Error> {
+    private let receiveValue: (Input) -> Void
+    private let receiveCompletion: (Completion<Failure>) -> Void
+
+    init(receiveValue: @escaping (Input) -> Void, receiveCompletion: @escaping (Completion<Failure>) -> Void) {
+      self.receiveValue = receiveValue
+      self.receiveCompletion = receiveCompletion
+    }
+
+    func receive(_ input: Input) { receiveValue(input) }
+
+    func receiveCompletion(_ completion: Completion<Failure>) { self.receiveCompletion(completion) }
+  }
+
+  struct Just<Output>: Publisher {
+    typealias Failure = Never
+    let value: Output
+
+    func subscribe(_ subscriber: AnySubscriber<Output, Never>) {
+      subscriber.receive(value)
+      subscriber.receiveCompletion(.finished)
+    }
+  }
+
+  struct MapPublisher<Upstream: Publisher, Output>: Publisher {
+    typealias Failure = Upstream.Failure
+    let upstream: Upstream
+    let transform: (Upstream.Output) -> Output
+
+    func subscribe(_ subscriber: AnySubscriber<Output, Failure>) {
+      let mapped = AnySubscriber<Upstream.Output, Failure>(
+        receiveValue: { self.upstream.subscribe(AnySubscriber(receiveValue: { _ in }, receiveCompletion: { _ in })); subscriber.receive(self.transform($0)) },
+        receiveCompletion: subscriber.receiveCompletion
+      )
+      upstream.subscribe(mapped)
+    }
+  }
+
+  func sink<T>(receiveValue: @escaping (T) -> Void) -> AnySubscriber<T, Never> {
+    return AnySubscriber(receiveValue: receiveValue, receiveCompletion: { _ in })
+  }
+  '''
+end
diff --git a/test/support/fixtures/swift/result_type.ex b/test/support/fixtures/swift/result_type.ex
new file mode 100644
index 0000000..5ce1179
--- /dev/null
+++ b/test/support/fixtures/swift/result_type.ex
@@ -0,0 +1,63 @@
+defmodule Test.Fixtures.Swift.ResultType do
+  @moduledoc false
+  use Test.LanguageFixture, language: "swift result_type"
+
+  @code ~S'''
+  enum ValidationError: Error {
+    case empty(field: String)
+    case tooShort(field: String, minimum: Int)
+    case tooLong(field: String, maximum: Int)
+    case invalidFormat(field: String, pattern: String)
+  }
+
+  enum ParseError: Error {
+    case invalidJSON
+    case missingField(String)
+    case typeMismatch(field: String, expected: String)
+  }
+
+  struct Email {
+    let value: String
+
+    static func parse(_ raw: String) -> Result<Email, ValidationError> {
+      guard !raw.isEmpty else { return .failure(.empty(field: "email")) }
+      guard raw.contains("@") else { return .failure(.invalidFormat(field: "email", pattern: "must contain @")) }
+      return .success(Email(value: raw.lowercased()))
+    }
+  }
+
+  struct Username {
+    let value: String
+
+    static func parse(_ raw: String) -> Result<Username, ValidationError> {
+      guard !raw.isEmpty else { return .failure(.empty(field: "username")) }
+      guard raw.count >= 3 else { return .failure(.tooShort(field: "username", minimum: 3)) }
+      guard raw.count <= 32 else { return .failure(.tooLong(field: "username", maximum: 32)) }
+      return .success(Username(value: raw))
+    }
+  }
+
+  struct UserRegistration {
+    let email: Email
+    let username: Username
+
+    static func validate(email rawEmail: String, username rawUsername: String) -> Result<UserRegistration, ValidationError> {
+      switch Email.parse(rawEmail) {
+      case .failure(let e): return .failure(e)
+      case .success(let email):
+        switch Username.parse(rawUsername) {
+        case .failure(let e): return .failure(e)
+        case .success(let username): return .success(UserRegistration(email: email, username: username))
+        }
+      }
+    }
+  }
+
+  func mapResult<T, U, E: Error>(_ result: Result<T, E>, _ transform: (T) -> U) -> Result<U, E> {
+    switch result {
+    case .success(let value): return .success(transform(value))
+    case .failure(let error): return .failure(error)
+    }
+  }
+  '''
+end
diff --git a/test/support/fixtures/typescript/dependency_injection.ex b/test/support/fixtures/typescript/dependency_injection.ex
new file mode 100644
index 0000000..38bb9b8
--- /dev/null
+++ b/test/support/fixtures/typescript/dependency_injection.ex
@@ -0,0 +1,66 @@
+defmodule Test.Fixtures.TypeScript.DependencyInjection do
+  @moduledoc false
+  use Test.LanguageFixture, language: "typescript dependency_injection"
+
+  @code ~S'''
+  interface Token<T> {
+    readonly name: string;
+  }
+
+  interface Provider<T> {
+    token: Token<T>;
+    factory: (container: Container) => T;
+    singleton: boolean;
+  }
+
+  interface Container {
+    register<T>(provider: Provider<T>): void;
+    resolve<T>(token: Token<T>): T;
+    has<T>(token: Token<T>): boolean;
+  }
+
+  class DIContainer implements Container {
+    private providers: Map<string, Provider<unknown>>;
+    private singletons: Map<string, unknown>;
+
+    constructor() {
+      this.providers = new Map();
+      this.singletons = new Map();
+    }
+
+    register<T>(provider: Provider<T>): void {
+      this.providers.set(provider.token.name, provider as Provider<unknown>);
+    }
+
+    resolve<T>(token: Token<T>): T {
+      const provider = this.providers.get(token.name);
+      if (!provider) {
+        throw new Error("No provider registered for token: " + token.name);
+      }
+      if (provider.singleton) {
+        if (!this.singletons.has(token.name)) {
+          this.singletons.set(token.name, provider.factory(this));
+        }
+        return this.singletons.get(token.name) as T;
+      }
+      return provider.factory(this) as T;
+    }
+
+    has<T>(token: Token<T>): boolean {
+      return this.providers.has(token.name);
+    }
+  }
+
+  function createToken<T>(name: string): Token<T> {
+    return { name };
+  }
+
+  function singleton<T>(token: Token<T>, factory: (c: Container) => T): Provider<T> {
+    return { token, factory, singleton: true };
+  }
+
+  function transient<T>(token: Token<T>, factory: (c: Container) => T): Provider<T> {
+    return { token, factory, singleton: false };
+  }
+  '''
+end
diff --git a/test/support/fixtures/typescript/event_emitter.ex b/test/support/fixtures/typescript/event_emitter.ex
new file mode 100644
index 0000000..8f1fed3
--- /dev/null
+++ b/test/support/fixtures/typescript/event_emitter.ex
@@ -0,0 +1,68 @@
+defmodule Test.Fixtures.TypeScript.EventEmitter do
+  @moduledoc false
+  use Test.LanguageFixture, language: "typescript event_emitter"
+
+  @code ~S'''
+  interface EventMap {
+    [event: string]: unknown;
+  }
+
+  interface Listener<T> {
+    callback: (data: T) => void;
+    once: boolean;
+  }
+
+  class EventEmitter<T extends EventMap> {
+    private listeners: Map<keyof T, Array<Listener<unknown>>>;
+
+    constructor() {
+      this.listeners = new Map();
+    }
+
+    on<K extends keyof T>(event: K, callback: (data: T[K]) => void): this {
+      if (!this.listeners.has(event)) {
+        this.listeners.set(event, []);
+      }
+      this.listeners.get(event)!.push({ callback: callback as (data: unknown) => void, once: false });
+      return this;
+    }
+
+    once<K extends keyof T>(event: K, callback: (data: T[K]) => void): this {
+      if (!this.listeners.has(event)) {
+        this.listeners.set(event, []);
+      }
+      this.listeners.get(event)!.push({ callback: callback as (data: unknown) => void, once: true });
+      return this;
+    }
+
+    off<K extends keyof T>(event: K, callback: (data: T[K]) => void): this {
+      const list = this.listeners.get(event);
+      if (list) {
+        this.listeners.set(event, list.filter(function(l) { return l.callback !== callback; }));
+      }
+      return this;
+    }
+
+    emit<K extends keyof T>(event: K, data: T[K]): boolean {
+      const list = this.listeners.get(event);
+      if (!list || list.length === 0) return false;
+      list.forEach(function(listener) { listener.callback(data); });
+      this.listeners.set(event, list.filter(function(l) { return !l.once; }));
+      return true;
+    }
+
+    removeAllListeners(event?: keyof T): this {
+      if (event) {
+        this.listeners.delete(event);
+      } else {
+        this.listeners.clear();
+      }
+      return this;
+    }
+  }
+
+  function createEmitter<T extends EventMap>(): EventEmitter<T> {
+    return new EventEmitter<T>();
+  }
+  '''
+end
diff --git a/test/support/fixtures/typescript/user_profile_store.ex b/test/support/fixtures/typescript/user_profile_store.ex
new file mode 100644
index 0000000..2242e43
--- /dev/null
+++ b/test/support/fixtures/typescript/user_profile_store.ex
@@ -0,0 +1,72 @@
+defmodule Test.Fixtures.TypeScript.UserProfileStore do
+  @moduledoc false
+  use Test.LanguageFixture, language: "typescript user_profile_store"
+
+  @code ~S'''
+  interface UserProfile {
+    id: string;
+    name: string;
+    email: string;
+    role: "admin" | "member" | "guest";
+  }
+
+  interface StoreState {
+    users: Record<string, UserProfile>;
+    loading: boolean;
+    error: string | null;
+  }
+
+  interface Action {
+    type: string;
+    payload?: unknown;
+  }
+
+  class UserProfileStore {
+    private state: StoreState;
+    private subscribers: Array<(state: StoreState) => void>;
+
+    constructor() {
+      this.state = { users: {}, loading: false, error: null };
+      this.subscribers = [];
+    }
+
+    getState(): StoreState {
+      return this.state;
+    }
+
+    dispatch(action: Action): void {
+      this.state = this.reduce(this.state, action);
+      this.notify();
+    }
+
+    subscribe(listener: (state: StoreState) => void): () => void {
+      this.subscribers.push(listener);
+      return () => {
+        this.subscribers = this.subscribers.filter(function(s) { return s !== listener; });
+      };
+    }
+
+    private reduce(state: StoreState, action: Action): StoreState {
+      switch (action.type) {
+        case "SET_LOADING":
+          return { ...state, loading: action.payload as boolean };
+        case "SET_ERROR":
+          return { ...state, error: action.payload as string };
+        case "UPSERT_USER":
+          const user = action.payload as UserProfile;
+          return { ...state, users: { ...state.users, [user.id]: user } };
+        default:
+          return state;
+      }
+    }
+
+    private notify(): void {
+      this.subscribers.forEach(function(listener) { listener(this.state); }.bind(this));
+    }
+  }
+
+  function createUserProfileStore(): UserProfileStore {
+    return new UserProfileStore();
+  }
+  '''
+end
diff --git a/test/support/fixtures/zig/allocator_interface.ex b/test/support/fixtures/zig/allocator_interface.ex
new file mode 100644
index 0000000..f11d680
--- /dev/null
+++ b/test/support/fixtures/zig/allocator_interface.ex
@@ -0,0 +1,72 @@
+defmodule Test.Fixtures.Zig.AllocatorInterface do
+  @moduledoc false
+  use Test.LanguageFixture, language: "zig allocator_interface"
+
+  @code ~S'''
+  const Allocator = struct {
+  ptr: *anyopaque,
+  vtable: *const VTable,
+
+  pub const VTable = struct {
+    alloc: *const fn (ctx: *anyopaque, len: usize, alignment: u8) ?[*]u8,
+    free: *const fn (ctx: *anyopaque, buf: [*]u8, len: usize) void,
+    resize: *const fn (ctx: *anyopaque, buf: [*]u8, old_len: usize, new_len: usize) bool,
+  };
+
+  pub fn alloc(self: Allocator, comptime T: type, n: usize) ![]T {
+    const ptr = self.vtable.alloc(self.ptr, @sizeOf(T) * n, @alignOf(T)) orelse return error.OutOfMemory;
+    return @as([*]T, @ptrCast(@alignCast(ptr)))[0..n];
+  }
+
+  pub fn free(self: Allocator, slice: anytype) void {
+    const T = @TypeOf(slice[0]);
+    self.vtable.free(self.ptr, @as([*]u8, @ptrCast(slice.ptr)), slice.len * @sizeOf(T));
+  }
+  };
+
+  const ArenaAllocator = struct {
+  backing: Allocator,
+  buffer: []u8,
+  pos: usize,
+
+  pub fn init(backing: Allocator, size: usize) !ArenaAllocator {
+    const buf = try backing.alloc(u8, size);
+    return ArenaAllocator{ .backing = backing, .buffer = buf, .pos = 0 };
+  }
+
+  pub fn deinit(self: *ArenaAllocator) void {
+    self.backing.free(self.buffer);
+  }
+
+  pub fn alloc(self: *ArenaAllocator, comptime T: type, n: usize) ![]T {
+    const size = @sizeOf(T) * n;
+    if (self.pos + size > self.buffer.len) return error.OutOfMemory;
+    const slice = self.buffer[self.pos .. self.pos + size];
+    self.pos += size;
+    return @as([*]T, @ptrCast(@alignCast(slice.ptr)))[0..n];
+  }
+
+  pub fn reset(self: *ArenaAllocator) void {
+    self.pos = 0;
+  }
+  };
+
+  const AllocError = error{
+  OutOfMemory,
+  AlignmentError,
+  InvalidSize,
+  };
+
+  fn alignForward(addr: usize, alignment: usize) usize {
+  return (addr + alignment - 1) & ~(alignment - 1);
+  }
+
+  fn isPowerOfTwo(n: usize) bool {
+  return n > 0 and (n & (n - 1)) == 0;
+  }
+
+  fn sizeOf(comptime T: type) comptime_int {
+  return @sizeOf(T);
+  }
+  '''
+end
diff --git a/test/support/fixtures/zig/iterator_protocol.ex b/test/support/fixtures/zig/iterator_protocol.ex
new file mode 100644
index 0000000..52848ef
--- /dev/null
+++ b/test/support/fixtures/zig/iterator_protocol.ex
@@ -0,0 +1,87 @@
+defmodule Test.Fixtures.Zig.IteratorProtocol do
+  @moduledoc false
+  use Test.LanguageFixture, language: "zig iterator_protocol"
+
+  @code ~S'''
+  fn Iterator(comptime T: type) type {
+  return struct {
+    const Self = @This();
+    pub const Item = T;
+    ptr: *anyopaque,
+    nextFn: *const fn (ptr: *anyopaque) ?T,
+
+    pub fn next(self: *Self) ?T {
+      return self.nextFn(self.ptr);
+    }
+
+    pub fn count(self: *Self) usize {
+      var n: usize = 0;
+      while (self.next() != null) n += 1;
+      return n;
+    }
+
+    pub fn forEach(self: *Self, callback: fn (T) void) void {
+      while (self.next()) |item| callback(item);
+    }
+  };
+  }
+
+  fn RangeIterator(comptime T: type) type {
+  return struct {
+    current: T,
+    end: T,
+    step: T,
+
+    pub fn init(start: T, end: T, step: T) @This() {
+      return .{ .current = start, .end = end, .step = step };
+    }
+
+    pub fn next(self: *@This()) ?T {
+      if (self.current >= self.end) return null;
+      const value = self.current;
+      self.current += self.step;
+      return value;
+    }
+  };
+  }
+
+  fn SliceIterator(comptime T: type) type {
+  return struct {
+    slice: []const T,
+    index: usize,
+
+    pub fn init(slice: []const T) @This() {
+      return .{ .slice = slice, .index = 0 };
+    }
+
+    pub fn next(self: *@This()) ?T {
+      if (self.index >= self.slice.len) return null;
+      const item = self.slice[self.index];
+      self.index += 1;
+      return item;
+    }
+
+    pub fn reset(self: *@This()) void {
+      self.index = 0;
+    }
+  };
+  }
+
+  fn MapIterator(comptime In: type, comptime Out: type) type {
+  return struct {
+    inner: SliceIterator(In),
+    transform: *const fn (In) Out,
+
+    pub fn next(self: *@This()) ?Out {
+      const item = self.inner.next() orelse return null;
+      return self.transform(item);
+    }
+  };
+  }
+
+  fn take(comptime T: type, iter: *SliceIterator(T), n: usize) []const T {
+  _ = n;
+  return iter.slice;
+  }
+  '''
+end
diff --git a/test/support/fixtures/zig/tagged_union.ex b/test/support/fixtures/zig/tagged_union.ex
new file mode 100644
index 0000000..fed8b31
--- /dev/null
+++ b/test/support/fixtures/zig/tagged_union.ex
@@ -0,0 +1,90 @@
+defmodule Test.Fixtures.Zig.TaggedUnion do
+  @moduledoc false
+  use Test.LanguageFixture, language: "zig tagged_union"
+
+  @code ~S'''
+  const TokenKind = enum {
+  identifier,
+  integer,
+  float,
+  string_literal,
+  operator,
+  keyword,
+  comment,
+  eof,
+  };
+
+  const Token = struct {
+  kind: TokenKind,
+  start: usize,
+  end: usize,
+  line: u32,
+  column: u32,
+
+  pub fn length(self: Token) usize {
+    return self.end - self.start;
+  }
+
+  pub fn isLiteral(self: Token) bool {
+    return self.kind == .integer or self.kind == .float or self.kind == .string_literal;
+  }
+  };
+
+  const Value = union(enum) {
+  int: i64,
+  float: f64,
+  boolean: bool,
+  string: []const u8,
+  null_value: void,
+
+  pub fn typeName(self: Value) []const u8 {
+    return switch (self) {
+      .int => "int",
+      .float => "float",
+      .boolean => "boolean",
+      .string => "string",
+      .null_value => "null",
+    };
+  }
+
+  pub fn isTruthy(self: Value) bool {
+    return switch (self) {
+      .int => |v| v != 0,
+      .float => |v| v != 0.0,
+      .boolean => |v| v,
+      .string => |v| v.len > 0,
+      .null_value => false,
+    };
+  }
+  };
+
+  const ParseError = error{
+  UnexpectedToken,
+  UnexpectedEof,
+  InvalidLiteral,
+  StackOverflow,
+  };
+
+  fn parseInteger(source: []const u8) !i64 {
+  var result: i64 = 0;
+  for (source) |ch| {
+    if (ch < '0' or ch > '9') return ParseError.InvalidLiteral;
+    result = result * 10 + @as(i64, ch - '0');
+  }
+  return result;
+  }
+
+  fn parseFloat(source: []const u8) !f64 {
+  var result: f64 = 0;
+  var decimal = false;
+  var scale: f64 = 1;
+  for (source) |ch| {
+    if (ch == '.') { decimal = true; continue; }
+    if (ch < '0' or ch > '9') return ParseError.InvalidLiteral;
+    if (decimal) { scale /= 10; result += @as(f64, ch - '0') * scale; }
+    else { result = result * 10 + @as(f64, ch - '0'); }
+  }
+  return result;
+  }
+  '''
+end
diff --git a/test/support/language_fixture.ex b/test/support/language_fixture.ex
new file mode 100644
index 0000000..b83b44a
--- /dev/null
+++ b/test/support/language_fixture.ex
@@ -0,0 +1,61 @@
+defmodule Test.LanguageFixture do
+  @moduledoc """
+  Macro for defining per-language, per-domain code fixtures.
+
+  ## In a fixture module
+
+      defmodule Test.Fixtures.Elixir.EventBus do
+        use Test.LanguageFixture, language: "elixir event bus"
+
+        @code ~S'''
+        defmodule EventBus do
+          ...
+        end
+        '''
+      end
+
+  ## In a test module
+
+      defmodule MyTest do
+        Module.register_attribute(__MODULE__, :fixture, accumulate: true, persist: false)
+        use Test.Fixtures.Elixir.EventBus
+        use Test.Fixtures.Python.CsvPipeline
+      end
+  """
+
+  defmacro __using__(opts) do
+    language = Keyword.fetch!(opts, :language)
+
+    quote do
+      @language unquote(language)
+      @before_compile Test.LanguageFixture
+    end
+  end
+
+  defmacro __before_compile__(env) do
+    mod = env.module
+    code = Module.get_attribute(mod, :code)
+    language = Module.get_attribute(mod, :language)
+    block_assertions = Module.get_attribute(mod, :block_assertions) || []
+
+    unless code do
+      raise CompileError,
+        file: env.file,
+        line: env.line,
+        description: "#{mod} uses Test.LanguageFixture but @code is not set"
+    end
+
+    quote do
+      defmacro __using__(_opts) do
+        fixture_language = unquote(language)
+        fixture_code = unquote(code)
+        fixture_block_assertions = unquote(Macro.escape(block_assertions))
+
+        quote do
+          @fixture {unquote(fixture_language), unquote(fixture_code),
+                    unquote(Macro.escape(fixture_block_assertions))}
+        end
+      end
+    end
+  end
+end

From fb4135eedcda1a3e8a79ae6ed7fc3d5826c3cd26 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 19 Mar 2026 18:26:16 +0100
Subject: [PATCH 05/71] feat(analysis): add OTP-based analysis run context and
 servers

Introduce supervised GenServer processes for managing analysis runs:
BehaviorConfigServer, FileContextServer, FileMetricsServer, RunContext,
and RunSupervisor. Enables concurrent per-file metric collection with
shared configuration state.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/analysis/behavior_config_server.ex | 117 ++++++++++++++++++
 lib/codeqa/analysis/file_context_server.ex    |  85 +++++++++++++
 lib/codeqa/analysis/file_metrics_server.ex    | 107 ++++++++++++++++
 lib/codeqa/analysis/run_context.ex            |  16 +++
 lib/codeqa/analysis/run_supervisor.ex         |  54 ++++++++
 5 files changed, 379 insertions(+)
 create mode 100644 lib/codeqa/analysis/behavior_config_server.ex
 create mode 100644 lib/codeqa/analysis/file_context_server.ex
 create mode 100644 lib/codeqa/analysis/file_metrics_server.ex
 create mode 100644 lib/codeqa/analysis/run_context.ex
 create mode 100644 lib/codeqa/analysis/run_supervisor.ex

diff --git a/lib/codeqa/analysis/behavior_config_server.ex b/lib/codeqa/analysis/behavior_config_server.ex
new file mode 100644
index 0000000..f526b20
--- /dev/null
+++ b/lib/codeqa/analysis/behavior_config_server.ex
@@ -0,0 +1,117 @@
+defmodule CodeQA.Analysis.BehaviorConfigServer do
+  @moduledoc """
+  Per-run GenServer that loads all YAML behavior configs once and serves them
+  from an anonymous ETS table.
+
+  Eliminates repeated disk reads in `SampleRunner.diagnose_aggregate/2` by
+  loading `priv/combined_metrics/*.yml` on startup and keeping data in memory
+  for the duration of the analysis run.
+
+  ETS layout: `{category, behavior} => behavior_data`
+  where `behavior_data` is the raw YAML map for that behavior.
+  """
+
+  use GenServer
+
+  @yaml_dir "priv/combined_metrics"
+
+  # --- Public API ---
+
+  @spec start_link(keyword()) :: GenServer.on_start()
+  def start_link(opts \\ []) do
+    GenServer.start_link(__MODULE__, opts)
+  end
+
+  @doc "Returns the ETS table id. Callers may read directly from it."
+  @spec get_tid(pid()) :: :ets.tid()
+  def get_tid(pid), do: GenServer.call(pid, :get_tid)
+
+  @doc """
+  Returns all behaviors grouped by category.
+
+      %{"function_design" => [{"no_boolean_parameter", behavior_data}, ...], ...}
+  """
+  @spec get_all_behaviors(pid()) :: %{String.t() => [{String.t(), map()}]}
+  def get_all_behaviors(pid) do
+    tid = get_tid(pid)
+
+    tid
+    |> :ets.tab2list()
+    |> Enum.reduce(%{}, fn {{cat, beh}, data}, acc ->
+      Map.update(acc, cat, [{beh, data}], &[{beh, data} | &1])
+    end)
+  end
+
+  @doc "Returns the scalar weight map for a given category + behavior."
+  @spec get_scalars(pid(), String.t(), String.t()) :: %{{String.t(), String.t()} => float()}
+  def get_scalars(pid, category, behavior) do
+    tid = get_tid(pid)
+
+    case :ets.lookup(tid, {category, behavior}) do
+      [{_, data}] -> scalars_from_behavior_data(data)
+      [] -> %{}
+    end
+  end
+
+  @doc "Returns the `_log_baseline` value for a given category + behavior."
+  @spec get_log_baseline(pid(), String.t(), String.t()) :: float()
+  def get_log_baseline(pid, category, behavior) do
+    tid = get_tid(pid)
+
+    case :ets.lookup(tid, {category, behavior}) do
+      [{_, data}] -> Map.get(data, "_log_baseline", 0.0) / 1.0
+      [] -> 0.0
+    end
+  end
+
+  # --- GenServer callbacks ---
+
+  @impl true
+  def init(_opts) do
+    tid = :ets.new(:behavior_config, [:set, :public, read_concurrency: true])
+    load_configs(tid)
+    {:ok, %{tid: tid}}
+  end
+
+  @impl true
+  def handle_call(:get_tid, _from, state) do
+    {:reply, state.tid, state}
+  end
+
+  # --- Private helpers ---
+
+  defp load_configs(tid) do
+    case File.ls(@yaml_dir) do
+      {:ok, files} ->
+        files
+        |> Enum.filter(&String.ends_with?(&1, ".yml"))
+        |> Enum.each(fn yml_file ->
+          category = String.trim_trailing(yml_file, ".yml")
+          yaml_path = Path.join(@yaml_dir, yml_file)
+          {:ok, data} = YamlElixir.read_from_file(yaml_path)
+
+          data
+          |> Enum.filter(fn {_k, v} -> is_map(v) end)
+          |> Enum.each(fn {behavior, behavior_data} ->
+            :ets.insert(tid, {{category, behavior}, behavior_data})
+          end)
+        end)
+
+      {:error, _} ->
+        :ok
+    end
+  end
+
+  @doc false
+  def scalars_from_behavior_data(behavior_data) do
+    behavior_data
+    |> Enum.flat_map(fn
+      {group, keys} when is_map(keys) ->
+        Enum.map(keys, fn {key, scalar} -> {{group, key}, scalar / 1.0} end)
+
+      _ ->
+        []
+    end)
+    |> Map.new()
+  end
+end
diff --git a/lib/codeqa/analysis/file_context_server.ex b/lib/codeqa/analysis/file_context_server.ex
new file mode 100644
index 0000000..28f9670
--- /dev/null
+++ b/lib/codeqa/analysis/file_context_server.ex
@@ -0,0 +1,85 @@
+defmodule CodeQA.Analysis.FileContextServer do
+  @moduledoc """
+  Per-run GenServer that memoizes `Pipeline.build_file_context/2` by
+  `{MD5(content), language_name}`.
+
+  Cache key includes the resolved language name because different languages
+  produce different keyword/operator sets, yielding different identifiers from
+  the same content.
+
+  ETS layout: `{md5_binary, language_name} => FileContext.t()`
+
+  On a cache miss, the calling process builds the context directly and inserts
+  it into the shared ETS table — no GenServer mailbox round-trip for the
+  computation itself.
+  """
+
+  use GenServer
+
+  alias CodeQA.Engine.{FileContext, Pipeline}
+
+  # --- Public API ---
+
+  @spec start_link(keyword()) :: GenServer.on_start()
+  def start_link(opts \\ []) do
+    GenServer.start_link(__MODULE__, opts)
+  end
+
+  @doc "Returns the ETS table id. Callers may read directly from it."
+  @spec get_tid(pid()) :: :ets.tid()
+  def get_tid(pid), do: GenServer.call(pid, :get_tid)
+
+  @doc """
+  Returns a cached (or freshly built) `FileContext` for `content`.
+
+  The language is resolved from `opts` (`:language` or `:path`); defaults to
+  `Unknown`, consistent with how `FileImpact` calls `build_file_context/2`.
+  """
+  @spec get(pid(), String.t(), keyword()) :: FileContext.t()
+  def get(pid, content, opts \\ []) do
+    tid = get_tid(pid)
+    language_name = resolve_language_name(opts)
+    key = {md5(content), language_name}
+
+    case :ets.lookup(tid, key) do
+      [{_, ctx}] ->
+        ctx
+
+      [] ->
+        ctx = Pipeline.build_file_context(content, opts)
+        :ets.insert(tid, {key, ctx})
+        ctx
+    end
+  end
+
+  # --- GenServer callbacks ---
+
+  @impl true
+  def init(_opts) do
+    tid = :ets.new(:file_context, [:set, :public, read_concurrency: true])
+    {:ok, %{tid: tid}}
+  end
+
+  @impl true
+  def handle_call(:get_tid, _from, state) do
+    {:reply, state.tid, state}
+  end
+
+  # --- Private helpers ---
+
+  defp md5(content), do: :crypto.hash(:md5, content)
+
+  defp resolve_language_name(opts) do
+    cond do
+      lang = Keyword.get(opts, :language) ->
+        mod = CodeQA.Language.find(lang) || CodeQA.Languages.Unknown
+        mod.name()
+
+      path = Keyword.get(opts, :path) ->
+        CodeQA.Language.detect(path).name()
+
+      true ->
+        CodeQA.Languages.Unknown.name()
+    end
+  end
+end
diff --git a/lib/codeqa/analysis/file_metrics_server.ex b/lib/codeqa/analysis/file_metrics_server.ex
new file mode 100644
index 0000000..579a63d
--- /dev/null
+++ b/lib/codeqa/analysis/file_metrics_server.ex
@@ -0,0 +1,107 @@
+defmodule CodeQA.Analysis.FileMetricsServer do
+  @moduledoc """
+  Per-run GenServer that caches `Registry.run_file_metrics/2` results.
+
+  Pre-populated from `pipeline_result` before block analysis starts so baseline
+  metrics are served directly from ETS without recomputation.
+
+  ETS layout:
+  - `{:path, path}` => metrics map   (baseline for existing files)
+  - `{:hash, md5_binary}` => metrics map  (computed on demand for reconstructed content)
+  """
+
+  use GenServer
+
+  alias CodeQA.Engine.Pipeline
+  alias CodeQA.Engine.Registry
+
+  # --- Public API ---
+
+  @spec start_link(keyword()) :: GenServer.on_start()
+  def start_link(opts \\ []) do
+    GenServer.start_link(__MODULE__, opts)
+  end
+
+  @doc "Returns the ETS table id. Callers may read directly from it."
+  @spec get_tid(pid()) :: :ets.tid()
+  def get_tid(pid), do: GenServer.call(pid, :get_tid)
+
+  @doc """
+  Bulk-inserts all baseline metrics from `pipeline_result` and cross-indexes by
+  content hash for each path present in `files_map`.
+
+  Call once after starting the supervisor, before beginning block analysis.
+  """
+  @spec populate(pid(), map(), map()) :: :ok
+  def populate(pid, pipeline_result, files_map) do
+    tid = get_tid(pid)
+    files_data = Map.get(pipeline_result, "files", %{})
+
+    Enum.each(files_data, fn {path, file_data} ->
+      metrics = Map.get(file_data, "metrics", %{})
+      :ets.insert(tid, {{:path, path}, metrics})
+    end)
+
+    Enum.each(files_map, fn {path, content} ->
+      hash = md5(content)
+
+      case :ets.lookup(tid, {:path, path}) do
+        [{_, metrics}] -> :ets.insert(tid, {{:hash, hash}, metrics})
+        [] -> :ok
+      end
+    end)
+
+    :ok
+  end
+
+  @doc "Returns pre-populated baseline metrics for `path`, or `nil` if not found."
+  @spec get_by_path(pid(), String.t()) :: map() | nil
+  def get_by_path(pid, path) do
+    tid = get_tid(pid)
+
+    case :ets.lookup(tid, {:path, path}) do
+      [{_, metrics}] -> metrics
+      [] -> nil
+    end
+  end
+
+  @doc """
+  Returns metrics for `content`, using the hash cache.
+
+  On a cache miss, builds the file context and runs metrics in the calling
+  process, then inserts the result into ETS for future lookups.
+  """
+  @spec get_for_content(pid(), Registry.t(), String.t(), keyword()) :: map()
+  def get_for_content(pid, registry, content, opts \\ []) do
+    tid = get_tid(pid)
+    hash = md5(content)
+
+    case :ets.lookup(tid, {:hash, hash}) do
+      [{_, metrics}] ->
+        metrics
+
+      [] ->
+        ctx = Pipeline.build_file_context(content, opts)
+        metrics = Registry.run_file_metrics(registry, ctx)
+        :ets.insert(tid, {{:hash, hash}, metrics})
+        metrics
+    end
+  end
+
+  # --- GenServer callbacks ---
+
+  @impl true
+  def init(_opts) do
+    tid = :ets.new(:file_metrics, [:set, :public, read_concurrency: true])
+    {:ok, %{tid: tid}}
+  end
+
+  @impl true
+  def handle_call(:get_tid, _from, state) do
+    {:reply, state.tid, state}
+  end
+
+  # --- Private helpers ---
+
+  defp md5(content), do: :crypto.hash(:md5, content)
+end
diff --git a/lib/codeqa/analysis/run_context.ex b/lib/codeqa/analysis/run_context.ex
new file mode 100644
index 0000000..e9e4aae
--- /dev/null
+++ b/lib/codeqa/analysis/run_context.ex
@@ -0,0 +1,16 @@
+defmodule CodeQA.Analysis.RunContext do
+  @moduledoc """
+  Holds PIDs for the per-run GenServers started under `RunSupervisor`.
+
+  Passed through the analysis call chain so all callers can access
+  cached state without named process registration.
+  """
+
+  defstruct [:behavior_config_pid, :file_context_pid, :file_metrics_pid]
+
+  @type t :: %__MODULE__{
+          behavior_config_pid: pid(),
+          file_context_pid: pid(),
+          file_metrics_pid: pid()
+        }
+end
diff --git a/lib/codeqa/analysis/run_supervisor.ex b/lib/codeqa/analysis/run_supervisor.ex
new file mode 100644
index 0000000..687e58c
--- /dev/null
+++ b/lib/codeqa/analysis/run_supervisor.ex
@@ -0,0 +1,54 @@
+defmodule CodeQA.Analysis.RunSupervisor do
+  @moduledoc """
+  One-shot supervisor for the per-analysis-run GenServers.
+
+  Started at the top of `BlockImpactAnalyzer.analyze/3` and stopped (via
+  `Supervisor.stop/1`) in an `after` block when the run completes.
+
+  Servers are not registered by name, preventing collisions when multiple
+  analysis runs share the same BEAM node (e.g. parallel tests).
+  """
+
+  use Supervisor
+
+  alias CodeQA.Analysis.{BehaviorConfigServer, FileContextServer, FileMetricsServer, RunContext}
+
+  @spec start_link(keyword()) :: Supervisor.on_start()
+  def start_link(opts \\ []) do
+    Supervisor.start_link(__MODULE__, opts)
+  end
+
+  @doc """
+  Queries child PIDs from `sup` and returns a `RunContext` struct.
+
+  Call once after `start_link/1` succeeds, before beginning analysis.
+  """
+  @spec run_context(pid()) :: RunContext.t()
+  def run_context(sup) do
+    children = Supervisor.which_children(sup)
+
+    %RunContext{
+      behavior_config_pid: find_pid(children, BehaviorConfigServer),
+      file_context_pid: find_pid(children, FileContextServer),
+      file_metrics_pid: find_pid(children, FileMetricsServer)
+    }
+  end
+
+  @impl true
+  def init(_opts) do
+    children = [
+      {BehaviorConfigServer, []},
+      {FileContextServer, []},
+      {FileMetricsServer, []}
+    ]
+
+    Supervisor.init(children, strategy: :one_for_one)
+  end
+
+  defp find_pid(children, module) do
+    {_id, pid, _type, _modules} =
+      Enum.find(children, fn {id, _pid, _type, _modules} -> id == module end)
+
+    pid
+  end
+end

From 110ffd2eef908ee9dfd70032cd4e2711c852d854 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 19 Mar 2026 18:26:30 +0100
Subject: [PATCH 06/71] feat(combined-metrics): add combined metrics scoring
 framework

Add a YAML-driven scoring framework that evaluates code quality across
categories (code smells, consistency, dependencies, documentation, error
handling, file structure, function design, naming conventions, etc.).
Each category loads behaviors from YAML config with per-language sample
validation. Includes FileSCorer, Scorer, SampleRunner, and mix tasks for
running sample reports and debugging signals.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/combined_metrics/category.ex       |   38 +
 lib/codeqa/combined_metrics/code_smells.ex    |   28 +
 lib/codeqa/combined_metrics/consistency.ex    |   29 +
 lib/codeqa/combined_metrics/dependencies.ex   |   28 +
 lib/codeqa/combined_metrics/documentation.ex  |   28 +
 lib/codeqa/combined_metrics/error_handling.ex |   28 +
 lib/codeqa/combined_metrics/file_scorer.ex    |   97 ++
 lib/codeqa/combined_metrics/file_structure.ex |   28 +
 .../combined_metrics/function_design.ex       |   28 +
 .../combined_metrics/naming_conventions.ex    |   30 +
 lib/codeqa/combined_metrics/sample_runner.ex  |  499 +++++++
 .../combined_metrics/scope_and_assignment.ex  |   28 +
 lib/codeqa/combined_metrics/scorer.ex         |   83 ++
 lib/codeqa/combined_metrics/testing.ex        |   28 +
 lib/codeqa/combined_metrics/type_and_value.ex |   28 +
 .../combined_metrics/variable_naming.ex       |   28 +
 lib/mix/tasks/codeqa/sample_report.ex         |  192 +++
 lib/mix/tasks/codeqa/signal_debug.ex          |  183 +++
 priv/combined_metrics/code_smells.yml         |  540 ++++++++
 priv/combined_metrics/consistency.yml         |  310 +++++
 priv/combined_metrics/dependencies.yml        |  319 +++++
 priv/combined_metrics/documentation.yml       |  634 +++++++++
 priv/combined_metrics/error_handling.yml      |  325 +++++
 priv/combined_metrics/file_structure.yml      |  503 +++++++
 priv/combined_metrics/function_design.yml     |  820 +++++++++++
 priv/combined_metrics/naming_conventions.yml  |  266 ++++
 .../bad/notifications.ex                      |   84 ++
 .../consistent_string_quote_style/config.yml  |    1 +
 .../good/notifications.ex                     |   82 ++
 .../bad/fetcher.go                            |   64 +
 .../good/fetcher.go                           |   61 +
 .../bad/worker.rs                             |   51 +
 .../good/worker.rs                            |   51 +
 .../bad/cache.rs                              |   59 +
 .../good/cache.rs                             |   61 +
 .../bad/buffer.rs                             |   44 +
 .../good/buffer.rs                            |   61 +
 .../bad/registry.rs                           |   56 +
 .../good/registry.rs                          |   52 +
 .../bad/pipeline.rs                           |   53 +
 .../good/pipeline.rs                          |   48 +
 .../bad/queue.rs                              |   52 +
 .../good/queue.rs                             |   50 +
 .../bad/importer.go                           |   53 +
 .../good/importer.go                          |   58 +
 .../bad/worker.go                             |   45 +
 .../good/worker.go                            |   52 +
 .../bad/DocumentStorage.cs                    |   63 +
 .../good/DocumentStorage.cs                   |   60 +
 .../bad/price_calculator.py                   |   47 +
 .../good/price_calculator.py                  |   64 +
 .../bad/shipping.ex                           |   67 +
 .../good/shipping.ex                          |   61 +
 .../bad/matrix_utils.js                       |   59 +
 .../good/matrix_utils.js                      |   53 +
 .../bad/notification_handler.ts               |   67 +
 .../good/notification_handler.ts              |   64 +
 .../no_auto_ptr/bad/Connection.cpp            |   73 +
 .../no_auto_ptr/good/Connection.cpp           |   73 +
 .../bad/NotificationService.cs                |   74 +
 .../good/NotificationService.cs               |   61 +
 .../no_class_variables/bad/account.rb         |   46 +
 .../no_class_variables/good/account.rb        |   47 +
 .../no_const_enum/bad/product_repository.ts   |   70 +
 .../no_const_enum/good/product_repository.ts  |   69 +
 .../bad/order_service.ex                      |   96 ++
 .../no_dead_code_after_return/config.yml      |    1 +
 .../good/order_service.ex                     |   58 +
 .../no_debug_print_statements/bad/payment.ex  |   97 ++
 .../no_debug_print_statements/config.yml      |    1 +
 .../no_debug_print_statements/good/payment.ex |   66 +
 .../no_double_negation/bad/cart.rb            |   45 +
 .../no_double_negation/good/cart.rb           |   44 +
 .../bad/DatabaseConnection.java               |   67 +
 .../good/DatabaseConnection.java              |   77 ++
 .../no_fixme_comments/bad/importer.ex         |   77 ++
 .../code_smells/no_fixme_comments/config.yml  |    1 +
 .../no_fixme_comments/good/importer.ex        |   88 ++
 .../bad/analytics_tracker.js                  |   59 +
 .../good/analytics_tracker.js                 |   68 +
 .../bad/billing.ex                            |   58 +
 .../good/billing.ex                           |   53 +
 .../bad/task_runner.py                        |   61 +
 .../good/task_runner.py                       |   76 ++
 .../no_long_parameter_list/bad/accounts.ex    |   62 +
 .../no_long_parameter_list/good/accounts.ex   |   66 +
 .../bad/OrderService.php                      |   57 +
 .../good/OrderService.php                     |   63 +
 .../no_namespace_trespassing/bad/catalog.ex   |   58 +
 .../no_namespace_trespassing/good/catalog.ex  |   61 +
 .../bad/subscription.rb                       |   39 +
 .../good/subscription.rb                      |   48 +
 .../no_nested_ternary/bad/pricing.ex          |  105 ++
 .../code_smells/no_nested_ternary/config.yml  |    1 +
 .../no_nested_ternary/good/pricing.ex         |   54 +
 .../bad/form_validator.js                     |   68 +
 .../good/form_validator.js                    |   64 +
 .../no_private_inheritance/bad/Connection.cpp |   75 +
 .../good/Connection.cpp                       |   75 +
 .../bad/Widget.cpp                            |   58 +
 .../good/Widget.cpp                           |   72 +
 .../bad/inventory.ex                          |   71 +
 .../good/inventory.ex                         |   58 +
 .../bad/data_store.js                         |   63 +
 .../good/data_store.js                        |   67 +
 .../bad/UserRepository.php                    |   58 +
 .../good/UserRepository.php                   |   69 +
 .../bad/FileImportService.kt                  |   54 +
 .../good/FileImportService.kt                 |   51 +
 .../bad/UserRepository.php                    |   55 +
 .../good/UserRepository.php                   |   84 ++
 .../bad/order_service.ts                      |   68 +
 .../good/order_service.ts                     |   46 +
 .../bad/Matrix.cpp                            |   75 +
 .../good/Matrix.cpp                           |   72 +
 .../bad/Widget.cpp                            |   72 +
 .../good/Widget.cpp                           |   77 ++
 .../no_with_statement/bad/report_builder.js   |   54 +
 .../no_with_statement/good/report_builder.js  |   49 +
 .../bad/counter.go                            |   39 +
 .../good/counter.go                           |   55 +
 .../bad/Parser.cpp                            |   97 ++
 .../good/Parser.cpp                           |   93 ++
 .../bad/analytics.ex                          |   65 +
 .../good/analytics.ex                         |   74 +
 .../bad/notification_router.js                |   58 +
 .../good/notification_router.js               |   52 +
 .../bad/AnalyticsProcessor.kt                 |   54 +
 .../good/AnalyticsProcessor.kt                |   54 +
 .../bad/pool.rs                               |   52 +
 .../good/pool.rs                              |   55 +
 .../bad/payment.rb                            |   58 +
 .../good/payment.rb                           |   39 +
 .../bad/database_manager.py                   |   62 +
 .../good/database_manager.py                  |   67 +
 .../uses_copied_on_copy_types/bad/metrics.rs  |   48 +
 .../uses_copied_on_copy_types/good/metrics.rs |   47 +
 .../bad/ProductCatalog.php                    |   62 +
 .../good/ProductCatalog.php                   |   66 +
 .../bad/UserProfile.swift                     |   60 +
 .../good/UserProfile.swift                    |   57 +
 .../bad/server.go                             |   46 +
 .../good/server.go                            |   58 +
 .../bad/AccessPolicy.cs                       |   56 +
 .../good/AccessPolicy.cs                      |   54 +
 .../bad/Buffer.cpp                            |   77 ++
 .../good/Buffer.cpp                           |   63 +
 .../bad/geometry.rs                           |   51 +
 .../good/geometry.rs                          |   55 +
 .../bad/HtmlRenderer.cs                       |   61 +
 .../good/HtmlRenderer.cs                      |   72 +
 .../bad/DataSyncService.kt                    |   47 +
 .../good/DataSyncService.kt                   |   49 +
 .../bad/ReportExporter.cs                     |   81 ++
 .../good/ReportExporter.cs                    |   66 +
 .../bad/PaymentGateway.php                    |   70 +
 .../good/PaymentGateway.php                   |   73 +
 .../bad/OrderService.php                      |   70 +
 .../good/OrderService.php                     |   79 ++
 .../bad/analytics.ex                          |   78 ++
 .../consistent_casing_within_file/config.yml  |    1 +
 .../good/analytics.ex                         |   78 ++
 .../bad/accounts.ex                           |  102 ++
 .../consistent_error_return_shape/config.yml  |    1 +
 .../good/accounts.ex                          |   94 ++
 .../bad/formatter.ex                          |   66 +
 .../consistent_function_style/config.yml      |    1 +
 .../good/formatter.ex                         |   96 ++
 .../bad/subscriptions.ex                      |   58 +
 .../good/subscriptions.ex                     |   67 +
 .../bad/PaymentProcessor.java                 |   62 +
 .../good/PaymentProcessor.java                |   59 +
 .../bad/UserRepository.java                   |   88 ++
 .../good/UserRepository.java                  |   92 ++
 .../bad/sessions.ex                           |   60 +
 .../good/sessions.ex                          |   76 ++
 .../bad/PaymentProcessor.swift                |   53 +
 .../good/PaymentProcessor.swift               |   51 +
 .../same_concept_same_name/bad/auth.ex        |  102 ++
 .../same_concept_same_name/config.yml         |    1 +
 .../same_concept_same_name/good/auth.ex       |  102 ++
 .../bad/ProductCatalog.java                   |   63 +
 .../good/ProductCatalog.java                  |   62 +
 .../bad/OrderService.php                      |   71 +
 .../good/OrderService.php                     |   78 ++
 .../import_count_under_10/bad/dashboard.ex    |   80 ++
 .../import_count_under_10/config.yml          |    1 +
 .../import_count_under_10/good/dashboard.ex   |   80 ++
 .../low_coupling/bad/order_controller.ex      |   91 ++
 .../dependencies/low_coupling/config.yml      |    1 +
 .../low_coupling/good/order_controller.ex     |   57 +
 .../no_default_exports/bad/payment_gateway.ts |   68 +
 .../good/payment_gateway.ts                   |   63 +
 .../bad/product_repository.ts                 |   46 +
 .../good/product_repository.ts                |   57 +
 .../no_wildcard_imports/bad/query_helpers.ex  |   74 +
 .../no_wildcard_imports/config.yml            |    1 +
 .../no_wildcard_imports/good/query_helpers.ex |   73 +
 .../bad/user_service.ts                       |   47 +
 .../good/user_service.ts                      |   47 +
 .../docstring_is_nonempty/bad/cache.ex        |   78 ++
 .../docstring_is_nonempty/config.yml          |    1 +
 .../docstring_is_nonempty/good/cache.ex       |   96 ++
 .../doctests_validate_examples/bad/billing.ex |   59 +
 .../good/billing.ex                           |   73 +
 .../bad/ShippingService.swift                 |   57 +
 .../good/ShippingService.swift                |   85 ++
 .../bad/cache.go                              |   67 +
 .../good/cache.go                             |   72 +
 .../file_has_license_header/bad/core.ex       |   74 +
 .../file_has_license_header/config.yml        |    1 +
 .../file_has_license_header/good/core.ex      |   76 ++
 .../file_has_module_docstring/bad/shipping.ex |   73 +
 .../file_has_module_docstring/config.yml      |    1 +
 .../good/shipping.ex                          |   88 ++
 .../bad/legacy_importer.ex                    |   91 ++
 .../file_has_no_commented_out_code/config.yml |    1 +
 .../good/legacy_importer.ex                   |   83 ++
 .../function_has_docstring/bad/tax.ex         |   73 +
 .../function_has_docstring/config.yml         |    1 +
 .../function_has_docstring/good/tax.ex        |  105 ++
 .../function_todo_comment_in_body/bad/sync.ex |   95 ++
 .../function_todo_comment_in_body/config.yml  |    1 +
 .../good/sync.ex                              |  104 ++
 .../bad/payments.ex                           |   81 ++
 .../good/payments.ex                          |  109 ++
 .../bad/file_importer.py                      |   66 +
 .../good/file_importer.py                     |   69 +
 .../bad/PaymentGateway.php                    |   62 +
 .../good/PaymentGateway.php                   |   62 +
 .../bad/processor.go                          |   61 +
 .../good/processor.go                         |   63 +
 .../bad/validator_test.rs                     |   50 +
 .../good/validator_test.rs                    |   50 +
 .../bad/FileImporter.swift                    |   58 +
 .../good/FileImporter.swift                   |   66 +
 .../bad/OrderProcessor.cs                     |   73 +
 .../good/OrderProcessor.cs                    |   68 +
 .../does_not_discard_errors/bad/handler.go    |   50 +
 .../does_not_discard_errors/good/handler.go   |   60 +
 .../bad/gateway.go                            |   50 +
 .../good/gateway.go                           |   50 +
 .../bad/NetworkClient.swift                   |   57 +
 .../good/NetworkClient.swift                  |   66 +
 .../bad/UserRepository.cs                     |   98 ++
 .../good/UserRepository.cs                    |   78 ++
 .../bad/file_processor.ex                     |   85 ++
 .../does_not_swallow_errors/config.yml        |    1 +
 .../good/file_processor.ex                    |   98 ++
 .../bad/event_bus.js                          |   61 +
 .../good/event_bus.js                         |   66 +
 .../bad/OrderService.java                     |   69 +
 .../good/OrderService.java                    |   73 +
 .../bad/FileProcessor.cs                      |   81 ++
 .../good/FileProcessor.cs                     |   84 ++
 .../bad/ProductCatalog.cs                     |   94 ++
 .../good/ProductCatalog.cs                    |   67 +
 .../bad/DataLoader.swift                      |   49 +
 .../good/DataLoader.swift                     |   60 +
 .../bad/store.go                              |   53 +
 .../good/store.go                             |   56 +
 .../bad/client.rs                             |   48 +
 .../good/client.rs                            |   64 +
 .../bad/billing.ex                            |   83 ++
 .../error_message_is_descriptive/config.yml   |    1 +
 .../good/billing.ex                           |   93 ++
 .../bad/service.go                            |   54 +
 .../good/service.go                           |   51 +
 .../error_type_includes_context/bad/client.go |   47 +
 .../good/client.go                            |   56 +
 .../no_bare_except/bad/api_client.py          |   60 +
 .../no_bare_except/good/api_client.py         |   71 +
 .../no_blind_rescue/bad/cart.rb               |   45 +
 .../no_blind_rescue/good/cart.rb              |   53 +
 .../no_empty_rescue_block/bad/payment.rb      |   42 +
 .../no_empty_rescue_block/good/payment.rb     |   49 +
 .../bad/ProductCatalog.php                    |   62 +
 .../good/ProductCatalog.php                   |   77 ++
 .../bad/template_engine.js                    |   48 +
 .../good/template_engine.js                   |   58 +
 .../bad/billing.ex                            |   68 +
 .../good/billing.ex                           |   84 ++
 .../no_floating_promises/bad/order_service.js |   55 +
 .../no_floating_promises/bad/user_service.ts  |   68 +
 .../good/order_service.js                     |   59 +
 .../no_floating_promises/good/user_service.ts |   86 ++
 .../bad/product_repository.ts                 |   64 +
 .../good/product_repository.ts                |   55 +
 .../no_rescue_as_flow_control/bad/invoice.rb  |   65 +
 .../no_rescue_as_flow_control/good/invoice.rb |   59 +
 .../no_return_from_ensure/bad/subscription.rb |   49 +
 .../good/subscription.rb                      |   52 +
 .../rescue_most_specific_first/bad/account.rb |   55 +
 .../good/account.rb                           |   57 +
 .../returns_typed_error/bad/repository.ex     |   92 ++
 .../returns_typed_error/config.yml            |    1 +
 .../returns_typed_error/good/repository.ex    |   96 ++
 .../bad/api_client.js                         |   64 +
 .../good/api_client.js                        |   69 +
 .../bad/payment_processor.py                  |   73 +
 .../good/payment_processor.py                 |   78 ++
 .../uses_checked_arithmetic/bad/invoice.rs    |   41 +
 .../uses_checked_arithmetic/good/invoice.rs   |   69 +
 .../bad/store.rs                              |   51 +
 .../good/store.rs                             |   70 +
 .../bad/router.go                             |   44 +
 .../good/router.go                            |   46 +
 .../bad/middleware.go                         |   42 +
 .../good/middleware.go                        |   42 +
 .../bad/OrderService.php                      |   66 +
 .../good/OrderService.php                     |   72 +
 .../bad/loader.rs                             |   58 +
 .../good/loader.rs                            |   63 +
 .../uses_raise_from/bad/config_loader.py      |   68 +
 .../uses_raise_from/good/config_loader.py     |   72 +
 .../bad/parser.rs                             |   50 +
 .../good/parser.rs                            |   74 +
 .../bad/AuthService.swift                     |   65 +
 .../good/AuthService.swift                    |   70 +
 .../bad/repository.go                         |   50 +
 .../good/repository.go                        |   49 +
 .../has_consistent_indentation/bad/worker.ex  |   73 +
 .../has_consistent_indentation/config.yml     |    1 +
 .../has_consistent_indentation/good/worker.ex |   67 +
 .../bad/Parser.cpp                            |  121 ++
 .../good/Parser.cpp                           |  116 ++
 .../line_count_under_300/bad/mega_service.ex  |  130 ++
 .../line_count_under_300/config.yml           |    1 +
 .../good/order_service.ex                     |   68 +
 .../bad/query_builder.ex                      |   46 +
 .../line_length_under_120/config.yml          |    1 +
 .../good/query_builder.ex                     |   89 ++
 .../no_magic_numbers/bad/rate_limiter.ex      |   91 ++
 .../no_magic_numbers/config.yml               |    1 +
 .../no_magic_numbers/good/rate_limiter.ex     |  114 ++
 .../bad/InvoiceService.java                   |   55 +
 .../good/InvoiceService.java                  |   63 +
 .../single_responsibility/bad/user_handler.ex |  110 ++
 .../single_responsibility/config.yml          |    1 +
 .../good/user_registration.ex                 |   53 +
 .../bad/mailer.ex                             |   86 ++
 .../config.yml                                |    1 +
 .../good/mailer.ex                            |   88 ++
 .../bad/user_service.ts                       |   68 +
 .../good/user_service.ts                      |   61 +
 .../bad/payment_gateway.ts                    |   69 +
 .../good/payment_gateway.ts                   |   75 +
 .../bad/EmailDispatcher.cs                    |   59 +
 .../good/EmailDispatcher.cs                   |   59 +
 .../bad/guards.ex                             |   41 +
 .../config.yml                                |    1 +
 .../good/guards.ex                            |   41 +
 .../bad/EventHandler.swift                    |   56 +
 .../good/EventHandler.swift                   |   56 +
 .../context_is_first_parameter/bad/mailer.go  |   60 +
 .../context_is_first_parameter/good/mailer.go |   57 +
 .../bad/order_processor.ex                    |   52 +
 .../cyclomatic_complexity_under_10/config.yml |    1 +
 .../good/order_processor.ex                   |   50 +
 .../bad/EmailComposer.swift                   |   64 +
 .../good/EmailComposer.swift                  |   64 +
 .../bad/reports.ex                            |   64 +
 .../good/reports.ex                           |   69 +
 .../has_verb_in_name/bad/api.ex               |   54 +
 .../has_verb_in_name/config.yml               |    1 +
 .../has_verb_in_name/good/api.ex              |   54 +
 .../bad/Matrix.cpp                            |   64 +
 .../good/Matrix.cpp                           |   53 +
 .../bad/storage.go                            |   43 +
 .../good/storage.go                           |   53 +
 .../bad/report_generator.ex                   |   53 +
 .../is_less_than_20_lines/config.yml          |    1 +
 .../good/report_generator.ex                  |   55 +
 .../bad/Buffer.cpp                            |   82 ++
 .../good/Buffer.cpp                           |   79 ++
 .../bad/parser.go                             |   56 +
 .../good/parser.go                            |   58 +
 .../nesting_depth_under_4/bad/validator.ex    |   59 +
 .../nesting_depth_under_4/config.yml          |    1 +
 .../nesting_depth_under_4/good/validator.ex   |   49 +
 .../no_arguments_object/bad/query_builder.js  |   57 +
 .../no_arguments_object/good/query_builder.js |   49 +
 .../bad/BackgroundSync.cs                     |   61 +
 .../good/BackgroundSync.cs                    |   74 +
 .../no_boolean_parameter/bad/notifications.ex |   49 +
 .../no_boolean_parameter/config.yml           |    1 +
 .../good/notifications.ex                     |   52 +
 .../bad/Widget.cpp                            |   63 +
 .../good/Widget.cpp                           |   56 +
 .../no_magic_numbers/bad/discounter.ex        |   58 +
 .../no_magic_numbers/config.yml               |    1 +
 .../no_magic_numbers/good/discounter.ex       |   54 +
 .../bad/report_builder.py                     |   60 +
 .../good/report_builder.py                    |   72 +
 .../bad/notification_sender.py                |   48 +
 .../good/notification_sender.py               |   78 ++
 .../bad/date_utils.ts                         |   62 +
 .../good/date_utils.ts                        |   58 +
 .../bad/string_utils.js                       |   52 +
 .../good/string_utils.js                      |   48 +
 .../bad/notifications.ex                      |   51 +
 .../good/notifications.ex                     |   46 +
 .../bad/email_sender.ex                       |   35 +
 .../parameter_count_under_4/config.yml        |    1 +
 .../good/email_sender.ex                      |   48 +
 .../bad/validator.go                          |   54 +
 .../good/validator.go                         |   53 +
 .../bad/notification_handler.ts               |   63 +
 .../good/notification_handler.ts              |   62 +
 .../bad/Parser.cpp                            |   76 ++
 .../good/Parser.cpp                           |   68 +
 .../uses_assertive_map_access/bad/shipping.ex |   71 +
 .../good/shipping.ex                          |   80 ++
 .../bad/inventory.ex                          |   62 +
 .../good/inventory.ex                         |   67 +
 .../bad/EmailSender.kt                        |   48 +
 .../good/EmailSender.kt                       |   49 +
 .../uses_defer_for_cleanup/bad/filestore.go   |   75 +
 .../uses_defer_for_cleanup/good/filestore.go  |   68 +
 .../bad/item_processor.py                     |   64 +
 .../good/item_processor.py                    |   64 +
 .../bad/data_pipeline.py                      |   52 +
 .../good/data_pipeline.py                     |   60 +
 .../bad/invoice.rb                            |   62 +
 .../good/invoice.rb                           |   58 +
 .../bad/SubscriptionService.kt                |   39 +
 .../good/SubscriptionService.kt               |   57 +
 .../bad/orders.ex                             |   70 +
 .../good/orders.ex                            |   57 +
 .../uses_ternary_expression/bad/formatter.ex  |   65 +
 .../uses_ternary_expression/config.yml        |    1 +
 .../uses_ternary_expression/good/formatter.ex |   32 +
 .../bad/ShippingCalculator.kt                 |   62 +
 .../good/ShippingCalculator.kt                |   47 +
 .../bad/payments.ex                           |   59 +
 .../good/payments.ex                          |   59 +
 .../zero_value_is_usable/bad/buffer.go        |   55 +
 .../zero_value_is_usable/good/buffer.go       |   43 +
 .../bad/PaymentGateway.cs                     |   63 +
 .../good/PaymentGateway.cs                    |   60 +
 .../bad/accounts.ex                           |   68 +
 .../config.yml                                |    1 +
 .../good/accounts.ex                          |   83 ++
 .../bad/ProductCatalog.swift                  |   52 +
 .../good/ProductCatalog.swift                 |   50 +
 .../class_name_is_noun/bad/modules.ex         |   45 +
 .../class_name_is_noun/config.yml             |    1 +
 .../class_name_is_noun/good/modules.ex        |   45 +
 .../bad/OrderService.php                      |   64 +
 .../good/OrderService.php                     |   68 +
 .../bad/payment.rb                            |   54 +
 .../good/payment.rb                           |   54 +
 .../bad/ProductCatalog.php                    |   61 +
 .../good/ProductCatalog.php                   |   57 +
 .../bad/session.rs                            |   58 +
 .../good/session.rs                           |   48 +
 .../bad/invoice.rb                            |   66 +
 .../good/invoice.rb                           |   70 +
 .../bad/payment.rs                            |   61 +
 .../good/payment.rs                           |   62 +
 .../bad/SubscriptionManager.swift             |   53 +
 .../good/SubscriptionManager.swift            |   48 +
 .../bad/order.go                              |   67 +
 .../good/order.go                             |   64 +
 .../bad/InventoryService.swift                |   56 +
 .../good/InventoryService.swift               |   50 +
 .../bad/product.go                            |   48 +
 .../good/product.go                           |   54 +
 .../bad/ReportBuilder.swift                   |   79 ++
 .../good/ReportBuilder.swift                  |   75 +
 .../bad/helpers.ex                            |   50 +
 .../config.yml                                |    1 +
 .../good/user_manager.ex                      |   50 +
 .../bad/worker.ex                             |   46 +
 .../config.yml                                |    1 +
 .../good/worker.ex                            |   46 +
 .../bad/queries.ex                            |   46 +
 .../config.yml                                |    1 +
 .../good/queries.ex                           |   46 +
 .../bad/sessions.ex                           |   53 +
 .../good/sessions.ex                          |   78 ++
 .../getter_has_no_prefix/bad/user.rs          |   45 +
 .../getter_has_no_prefix/good/user.rs         |   51 +
 .../bad/account.go                            |   50 +
 .../good/account.go                           |   49 +
 .../bad/api.go                                |   40 +
 .../good/api.go                               |   41 +
 .../bad/notification.go                       |   31 +
 .../good/notification.go                      |   32 +
 .../bad/PaymentGateway.php                    |   67 +
 .../good/PaymentGateway.php                   |   65 +
 .../bad/ShoppingCart.swift                    |   51 +
 .../good/ShoppingCart.swift                   |   53 +
 .../bad/OrderManager.swift                    |   69 +
 .../good/OrderManager.swift                   |   59 +
 .../bad/SubscriptionManager.cs                |   71 +
 .../good/SubscriptionManager.cs               |   63 +
 .../bad/ShipmentTracker.cs                    |   65 +
 .../good/ShipmentTracker.cs                   |   67 +
 .../bad/InventoryService.cs                   |   57 +
 .../good/InventoryService.cs                  |   57 +
 .../bad/CustomerAccount.java                  |   62 +
 .../good/CustomerAccount.java                 |   58 +
 .../bad/account.rb                            |   49 +
 .../good/account.rb                           |   55 +
 .../bad/matrix_transform.py                   |   55 +
 .../good/matrix_transform.py                  |   62 +
 .../bad/UserRepository.php                    |   92 ++
 .../good/UserRepository.php                   |   98 ++
 .../bad/PriceFormatter.kt                     |   52 +
 .../good/PriceFormatter.kt                    |   46 +
 .../bad/user.go                               |   50 +
 .../good/user.go                              |   48 +
 .../bad/subscriptions.ex                      |   46 +
 .../good/subscriptions.ex                     |   65 +
 .../bad/subscription.rb                       |   52 +
 .../good/subscription.rb                      |   51 +
 .../predicate_prefixed_with_is/bad/order.rs   |   59 +
 .../predicate_prefixed_with_is/good/order.rs  |   55 +
 .../bad/DocumentPipeline.swift                |   60 +
 .../good/DocumentPipeline.swift               |   56 +
 .../bad/session.go                            |   47 +
 .../good/session.go                           |   48 +
 .../bad/catalog.ex                            |   51 +
 .../good/catalog.ex                           |   61 +
 .../bad/user_test.ex                          |   54 +
 .../test_name_starts_with_verb/config.yml     |    1 +
 .../good/user_test.ex                         |   54 +
 .../bad/CacheStore.swift                      |   56 +
 .../good/CacheStore.swift                     |   54 +
 .../bad/session_manager.py                    |   69 +
 .../good/session_manager.py                   |   73 +
 .../bad/invoice_handler.py                    |   74 +
 .../good/invoice_handler.py                   |   82 ++
 .../uses_snake_case_for_methods/bad/cart.rb   |   54 +
 .../uses_snake_case_for_methods/good/cart.rb  |   53 +
 .../bad/ProductInventory.kt                   |   39 +
 .../good/ProductInventory.kt                  |   39 +
 .../declared_close_to_use/bad/processor.ex    |   94 ++
 .../declared_close_to_use/config.yml          |    1 +
 .../declared_close_to_use/good/processor.ex   |   76 ++
 .../bad/aggregator.ex                         |   75 +
 .../config.yml                                |    1 +
 .../good/aggregator.ex                        |   55 +
 .../no_var_declarations/bad/search_index.js   |   64 +
 .../no_var_declarations/good/search_index.js  |   57 +
 .../bad/ReportGenerator.kt                    |   61 +
 .../good/ReportGenerator.kt                   |   54 +
 .../bad/transformer.ex                        |   49 +
 .../reassigned_multiple_times/config.yml      |    1 +
 .../good/transformer.ex                       |   47 +
 .../scope_is_minimal/bad/handler.ex           |   71 +
 .../scope_is_minimal/config.yml               |    1 +
 .../scope_is_minimal/good/handler.ex          |   62 +
 .../shadowed_by_inner_scope/bad/nested.ex     |   66 +
 .../shadowed_by_inner_scope/config.yml        |    1 +
 .../shadowed_by_inner_scope/good/nested.ex    |   52 +
 .../used_only_once/bad/builder.ex             |   57 +
 .../used_only_once/config.yml                 |    1 +
 .../used_only_once/good/builder.ex            |   49 +
 .../bad/invoice_calculator.js                 |   62 +
 .../good/invoice_calculator.js                |   58 +
 .../bad/sparse_test.ex                        |   58 +
 .../reasonable_test_to_code_ratio/config.yml  |    1 +
 .../good/thorough_test.ex                     |  100 ++
 .../bad/empty_assertions_test.ex              |   62 +
 .../testing/test_has_assertion/config.yml     |    1 +
 .../good/proper_assertions_test.ex            |   50 +
 .../bad/vague_test.ex                         |   49 +
 .../test_name_describes_behavior/config.yml   |    1 +
 .../good/descriptive_test.ex                  |   62 +
 .../bad/kitchen_sink_test.ex                  |   62 +
 .../testing/test_single_concept/config.yml    |    1 +
 .../test_single_concept/good/focused_test.ex  |   99 ++
 .../bad/checker.ex                            |   76 ++
 .../config.yml                                |    1 +
 .../good/checker.ex                           |   31 +
 .../bad/OrderDraft.kt                         |   45 +
 .../good/OrderDraft.kt                        |   47 +
 .../bad/Matrix.cpp                            |   64 +
 .../good/Matrix.cpp                           |   79 ++
 .../bad/converter.rs                          |   40 +
 .../good/converter.rs                         |   69 +
 .../bad/session_manager.js                    |   84 ++
 .../good/session_manager.js                   |   76 ++
 .../hardcoded_url_or_path/bad/client.ex       |   53 +
 .../hardcoded_url_or_path/config.yml          |    1 +
 .../hardcoded_url_or_path/good/client.ex      |   55 +
 .../bad/order_handler.py                      |   72 +
 .../good/order_handler.py                     |   82 ++
 .../no_boolean_obsession/bad/notifications.ex |   62 +
 .../good/notifications.ex                     |   51 +
 .../no_c_style_casts/bad/Buffer.cpp           |   65 +
 .../no_c_style_casts/good/Buffer.cpp          |   60 +
 .../bad/feature_flags.py                      |   69 +
 .../good/feature_flags.py                     |   61 +
 .../bad/user_service.ts                       |   44 +
 .../good/user_service.ts                      |   67 +
 .../bad/notification_handler.ts               |   51 +
 .../good/notification_handler.ts              |   58 +
 .../bad/analytics.ex                          |   46 +
 .../good/analytics.ex                         |   53 +
 .../no_empty_string_initial/bad/builder.ex    |   88 ++
 .../no_empty_string_initial/config.yml        |    1 +
 .../no_empty_string_initial/good/builder.ex   |   48 +
 .../no_explicit_any/bad/user_service.ts       |   55 +
 .../no_explicit_any/good/user_service.ts      |   75 +
 .../no_implicit_null_initial/bad/loader.ex    |   89 ++
 .../no_implicit_null_initial/config.yml       |    1 +
 .../no_implicit_null_initial/good/loader.ex   |   68 +
 .../no_magic_value_assigned/bad/roles.ex      |   64 +
 .../no_magic_value_assigned/config.yml        |    1 +
 .../no_magic_value_assigned/good/roles.ex     |   57 +
 .../bad/feature_flags.js                      |   50 +
 .../good/feature_flags.js                     |   43 +
 .../bad/notification_handler.ts               |   57 +
 .../good/notification_handler.ts              |   61 +
 .../bad/UserProfile.kt                        |   48 +
 .../good/UserProfile.kt                       |   49 +
 .../no_primitive_obsession/bad/payments.ex    |   48 +
 .../no_primitive_obsession/good/payments.ex   |   63 +
 .../type_and_value/no_rtti/bad/Connection.cpp |   69 +
 .../no_rtti/good/Connection.cpp               |   69 +
 .../bad/product_service.py                    |   65 +
 .../good/product_service.py                   |   80 ++
 .../bad/product_repository.ts                 |   56 +
 .../good/product_repository.ts                |   63 +
 .../no_unsafe_return/bad/payment_gateway.ts   |   58 +
 .../no_unsafe_return/good/payment_gateway.ts  |   73 +
 .../bad/PaymentGateway.php                    |   56 +
 .../good/PaymentGateway.php                   |   59 +
 .../bad/NotificationHandler.kt                |   50 +
 .../good/NotificationHandler.kt               |   53 +
 .../bad/product_repository.ts                 |   61 +
 .../good/product_repository.ts                |   61 +
 .../bad/PaymentStatus.kt                      |   47 +
 .../good/PaymentStatus.kt                     |   40 +
 .../struct_under_32_fields/bad/orders.ex      |   60 +
 .../struct_under_32_fields/good/orders.ex     |   67 +
 .../bad/payment_gateway.ts                    |   66 +
 .../good/payment_gateway.ts                   |   80 ++
 .../bad/SearchResult.kt                       |   41 +
 .../good/SearchResult.kt                      |   46 +
 .../bad/PaymentService.kt                     |   69 +
 .../good/PaymentService.kt                    |   57 +
 .../bad/cart_service.js                       |   62 +
 .../good/cart_service.js                      |   62 +
 .../bad/ShoppingCart.kt                       |   47 +
 .../good/ShoppingCart.kt                      |   50 +
 .../bad/event_dispatcher.py                   |   62 +
 .../good/event_dispatcher.py                  |   65 +
 .../bad/user_repository.py                    |   70 +
 .../good/user_repository.py                   |   72 +
 .../bad/OrderService.php                      |   86 ++
 .../good/OrderService.php                     |   91 ++
 .../bad/OrderManager.kt                       |   61 +
 .../good/OrderManager.kt                      |   40 +
 .../bad/ProductCatalog.php                    |   71 +
 .../good/ProductCatalog.php                   |   72 +
 .../bad/UserRepository.php                    |  108 ++
 .../good/UserRepository.php                   |  106 ++
 .../boolean_has_is_has_prefix/bad/users.ex    |   75 +
 .../boolean_has_is_has_prefix/bad/users.js    |   69 +
 .../boolean_has_is_has_prefix/bad/users.rb    |   69 +
 .../boolean_has_is_has_prefix/config.yml      |    1 +
 .../boolean_has_is_has_prefix/good/users.ex   |   75 +
 .../boolean_has_is_has_prefix/good/users.js   |   69 +
 .../boolean_has_is_has_prefix/good/users.rb   |   69 +
 .../collection_name_is_plural/bad/catalog.ex  |   68 +
 .../collection_name_is_plural/bad/catalog.js  |   72 +
 .../collection_name_is_plural/bad/catalog.rb  |   65 +
 .../collection_name_is_plural/config.yml      |    1 +
 .../collection_name_is_plural/good/catalog.ex |   68 +
 .../collection_name_is_plural/good/catalog.js |   72 +
 .../collection_name_is_plural/good/catalog.rb |   65 +
 .../loop_var_is_single_letter/bad/matrix.ex   |   81 ++
 .../loop_var_is_single_letter/bad/matrix.js   |   92 ++
 .../loop_var_is_single_letter/bad/matrix.rb   |   89 ++
 .../loop_var_is_single_letter/config.yml      |    1 +
 .../loop_var_is_single_letter/good/matrix.ex  |   81 ++
 .../loop_var_is_single_letter/good/matrix.js  |   92 ++
 .../loop_var_is_single_letter/good/matrix.rb  |   88 ++
 .../name_contains_and/bad/checkout.ex         |   76 ++
 .../name_contains_and/bad/checkout.js         |   94 ++
 .../name_contains_and/bad/checkout.rb         |   83 ++
 .../name_contains_and/config.yml              |    1 +
 .../name_contains_and/good/checkout.ex        |   78 ++
 .../name_contains_and/good/checkout.js        |   89 ++
 .../name_contains_and/good/checkout.rb        |   89 ++
 .../name_contains_type_suffix/bad/report.ex   |   87 ++
 .../name_contains_type_suffix/bad/report.js   |   84 ++
 .../name_contains_type_suffix/bad/report.rb   |   82 ++
 .../name_contains_type_suffix/config.yml      |    1 +
 .../name_contains_type_suffix/good/report.ex  |   87 ++
 .../name_contains_type_suffix/good/report.js  |   84 ++
 .../name_contains_type_suffix/good/report.rb  |   82 ++
 .../name_is_abbreviation/bad/api_client.ex    |   88 ++
 .../name_is_abbreviation/bad/api_client.js    |   98 ++
 .../name_is_abbreviation/bad/api_client.rb    |   91 ++
 .../name_is_abbreviation/config.yml           |    1 +
 .../name_is_abbreviation/good/api_client.ex   |   88 ++
 .../name_is_abbreviation/good/api_client.js   |   98 ++
 .../name_is_abbreviation/good/api_client.rb   |   91 ++
 .../name_is_generic/bad/orders.ex             |   96 ++
 .../name_is_generic/bad/orders.js             |   94 ++
 .../name_is_generic/bad/orders.rb             |   87 ++
 .../name_is_generic/config.yml                |    1 +
 .../name_is_generic/good/orders.ex            |  122 ++
 .../name_is_generic/good/orders.js            |   96 ++
 .../name_is_generic/good/orders.rb            |   89 ++
 .../name_is_number_like/bad/pipeline.ex       |   86 ++
 .../name_is_number_like/bad/pipeline.js       |   84 ++
 .../name_is_number_like/bad/pipeline.rb       |   87 ++
 .../name_is_number_like/config.yml            |    1 +
 .../name_is_number_like/good/pipeline.ex      |   86 ++
 .../name_is_number_like/good/pipeline.js      |   84 ++
 .../name_is_number_like/good/pipeline.rb      |   87 ++
 .../name_is_single_letter/bad/calculator.ex   |   72 +
 .../name_is_single_letter/bad/calculator.js   |   69 +
 .../name_is_single_letter/bad/calculator.rb   |   73 +
 .../name_is_single_letter/config.yml          |    1 +
 .../name_is_single_letter/good/calculator.ex  |   72 +
 .../name_is_single_letter/good/calculator.js  |   72 +
 .../name_is_single_letter/good/calculator.rb  |   75 +
 .../name_is_too_long/bad/session.ex           |   72 +
 .../name_is_too_long/bad/session.js           |   81 ++
 .../name_is_too_long/bad/session.rb           |   80 ++
 .../name_is_too_long/config.yml               |    1 +
 .../name_is_too_long/good/session.ex          |   76 ++
 .../name_is_too_long/good/session.js          |   63 +
 .../name_is_too_long/good/session.rb          |   61 +
 .../name_is_too_short/bad/contact.ex          |   78 ++
 .../name_is_too_short/bad/contact.js          |   87 ++
 .../name_is_too_short/bad/contact.rb          |   82 ++
 .../name_is_too_short/config.yml              |    1 +
 .../name_is_too_short/good/contact.ex         |   78 ++
 .../name_is_too_short/good/contact.js         |   88 ++
 .../name_is_too_short/good/contact.rb         |   82 ++
 .../negated_boolean_name/bad/validator.ex     |   84 ++
 .../negated_boolean_name/bad/validator.js     |   86 ++
 .../negated_boolean_name/bad/validator.rb     |   88 ++
 .../negated_boolean_name/config.yml           |    1 +
 .../negated_boolean_name/good/validator.ex    |   84 ++
 .../negated_boolean_name/good/validator.js    |   86 ++
 .../negated_boolean_name/good/validator.rb    |   88 ++
 .../no_hungarian_notation/bad/inventory.ex    |   87 ++
 .../no_hungarian_notation/bad/inventory.js    |   83 ++
 .../no_hungarian_notation/bad/inventory.rb    |   79 ++
 .../no_hungarian_notation/config.yml          |    1 +
 .../no_hungarian_notation/good/inventory.ex   |   87 ++
 .../no_hungarian_notation/good/inventory.js   |   83 ++
 .../no_hungarian_notation/good/inventory.rb   |   79 ++
 .../bad/config.ex                             |   90 ++
 .../bad/config.js                             |  105 ++
 .../bad/config.rb                             |  107 ++
 .../screaming_snake_for_constants/config.yml  |    1 +
 .../good/config.ex                            |   90 ++
 .../good/config.js                            |  105 ++
 .../good/config.rb                            |   99 ++
 .../combined_metrics/scope_and_assignment.yml |  625 +++++++++
 priv/combined_metrics/testing.yml             |  420 ++++++
 priv/combined_metrics/type_and_value.yml      |  528 +++++++
 priv/combined_metrics/variable_naming.yml     | 1209 +++++++++++++++++
 .../combined_metrics/file_scorer_test.exs     |  268 ++++
 .../combined_metrics/sample_runner_test.exs   |   34 +
 765 files changed, 51643 insertions(+)
 create mode 100644 lib/codeqa/combined_metrics/category.ex
 create mode 100644 lib/codeqa/combined_metrics/code_smells.ex
 create mode 100644 lib/codeqa/combined_metrics/consistency.ex
 create mode 100644 lib/codeqa/combined_metrics/dependencies.ex
 create mode 100644 lib/codeqa/combined_metrics/documentation.ex
 create mode 100644 lib/codeqa/combined_metrics/error_handling.ex
 create mode 100644 lib/codeqa/combined_metrics/file_scorer.ex
 create mode 100644 lib/codeqa/combined_metrics/file_structure.ex
 create mode 100644 lib/codeqa/combined_metrics/function_design.ex
 create mode 100644 lib/codeqa/combined_metrics/naming_conventions.ex
 create mode 100644 lib/codeqa/combined_metrics/sample_runner.ex
 create mode 100644 lib/codeqa/combined_metrics/scope_and_assignment.ex
 create mode 100644 lib/codeqa/combined_metrics/scorer.ex
 create mode 100644 lib/codeqa/combined_metrics/testing.ex
 create mode 100644 lib/codeqa/combined_metrics/type_and_value.ex
 create mode 100644 lib/codeqa/combined_metrics/variable_naming.ex
 create mode 100644 lib/mix/tasks/codeqa/sample_report.ex
 create mode 100644 lib/mix/tasks/codeqa/signal_debug.ex
 create mode 100644 priv/combined_metrics/code_smells.yml
 create mode 100644 priv/combined_metrics/consistency.yml
 create mode 100644 priv/combined_metrics/dependencies.yml
 create mode 100644 priv/combined_metrics/documentation.yml
 create mode 100644 priv/combined_metrics/error_handling.yml
 create mode 100644 priv/combined_metrics/file_structure.yml
 create mode 100644 priv/combined_metrics/function_design.yml
 create mode 100644 priv/combined_metrics/naming_conventions.yml
 create mode 100644 priv/combined_metrics/samples/code_smells/consistent_string_quote_style/bad/notifications.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/consistent_string_quote_style/config.yml
 create mode 100644 priv/combined_metrics/samples/code_smells/consistent_string_quote_style/good/notifications.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/context_not_stored_in_struct/bad/fetcher.go
 create mode 100644 priv/combined_metrics/samples/code_smells/context_not_stored_in_struct/good/fetcher.go
 create mode 100644 priv/combined_metrics/samples/code_smells/does_not_accept_box_ref_parameter/bad/worker.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/does_not_accept_box_ref_parameter/good/worker.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/does_not_box_collections_unnecessarily/bad/cache.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/does_not_box_collections_unnecessarily/good/cache.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/does_not_cast_ref_to_mut_ptr/bad/buffer.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/does_not_cast_ref_to_mut_ptr/good/buffer.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/does_not_clone_for_comparison/bad/registry.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/does_not_clone_for_comparison/good/registry.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/does_not_declare_unused_mut/bad/pipeline.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/does_not_declare_unused_mut/good/pipeline.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/does_not_hold_mutex_across_await/bad/queue.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/does_not_hold_mutex_across_await/good/queue.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/does_not_spawn_unbounded_goroutines/bad/importer.go
 create mode 100644 priv/combined_metrics/samples/code_smells/does_not_spawn_unbounded_goroutines/good/importer.go
 create mode 100644 priv/combined_metrics/samples/code_smells/goroutine_has_clear_exit_condition/bad/worker.go
 create mode 100644 priv/combined_metrics/samples/code_smells/goroutine_has_clear_exit_condition/good/worker.go
 create mode 100644 priv/combined_metrics/samples/code_smells/io_bound_uses_async_await_not_task_run/bad/DocumentStorage.cs
 create mode 100644 priv/combined_metrics/samples/code_smells/io_bound_uses_async_await_not_task_run/good/DocumentStorage.cs
 create mode 100644 priv/combined_metrics/samples/code_smells/lambda_not_assigned_to_variable/bad/price_calculator.py
 create mode 100644 priv/combined_metrics/samples/code_smells/lambda_not_assigned_to_variable/good/price_calculator.py
 create mode 100644 priv/combined_metrics/samples/code_smells/minimizes_data_in_messages/bad/shipping.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/minimizes_data_in_messages/good/shipping.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_array_constructor_with_arguments/bad/matrix_utils.js
 create mode 100644 priv/combined_metrics/samples/code_smells/no_array_constructor_with_arguments/good/matrix_utils.js
 create mode 100644 priv/combined_metrics/samples/code_smells/no_array_delete/bad/notification_handler.ts
 create mode 100644 priv/combined_metrics/samples/code_smells/no_array_delete/good/notification_handler.ts
 create mode 100644 priv/combined_metrics/samples/code_smells/no_auto_ptr/bad/Connection.cpp
 create mode 100644 priv/combined_metrics/samples/code_smells/no_auto_ptr/good/Connection.cpp
 create mode 100644 priv/combined_metrics/samples/code_smells/no_blocking_on_async_code/bad/NotificationService.cs
 create mode 100644 priv/combined_metrics/samples/code_smells/no_blocking_on_async_code/good/NotificationService.cs
 create mode 100644 priv/combined_metrics/samples/code_smells/no_class_variables/bad/account.rb
 create mode 100644 priv/combined_metrics/samples/code_smells/no_class_variables/good/account.rb
 create mode 100644 priv/combined_metrics/samples/code_smells/no_const_enum/bad/product_repository.ts
 create mode 100644 priv/combined_metrics/samples/code_smells/no_const_enum/good/product_repository.ts
 create mode 100644 priv/combined_metrics/samples/code_smells/no_dead_code_after_return/bad/order_service.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_dead_code_after_return/config.yml
 create mode 100644 priv/combined_metrics/samples/code_smells/no_dead_code_after_return/good/order_service.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_debug_print_statements/bad/payment.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_debug_print_statements/config.yml
 create mode 100644 priv/combined_metrics/samples/code_smells/no_debug_print_statements/good/payment.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_double_negation/bad/cart.rb
 create mode 100644 priv/combined_metrics/samples/code_smells/no_double_negation/good/cart.rb
 create mode 100644 priv/combined_metrics/samples/code_smells/no_finalize_override/bad/DatabaseConnection.java
 create mode 100644 priv/combined_metrics/samples/code_smells/no_finalize_override/good/DatabaseConnection.java
 create mode 100644 priv/combined_metrics/samples/code_smells/no_fixme_comments/bad/importer.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_fixme_comments/config.yml
 create mode 100644 priv/combined_metrics/samples/code_smells/no_fixme_comments/good/importer.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_global_scope_pollution/bad/analytics_tracker.js
 create mode 100644 priv/combined_metrics/samples/code_smells/no_global_scope_pollution/good/analytics_tracker.js
 create mode 100644 priv/combined_metrics/samples/code_smells/no_library_global_application_config/bad/billing.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_library_global_application_config/good/billing.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_list_comprehension_for_side_effects/bad/task_runner.py
 create mode 100644 priv/combined_metrics/samples/code_smells/no_list_comprehension_for_side_effects/good/task_runner.py
 create mode 100644 priv/combined_metrics/samples/code_smells/no_long_parameter_list/bad/accounts.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_long_parameter_list/good/accounts.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_magic_method_abuse/bad/OrderService.php
 create mode 100644 priv/combined_metrics/samples/code_smells/no_magic_method_abuse/good/OrderService.php
 create mode 100644 priv/combined_metrics/samples/code_smells/no_namespace_trespassing/bad/catalog.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_namespace_trespassing/good/catalog.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_nested_method_definition/bad/subscription.rb
 create mode 100644 priv/combined_metrics/samples/code_smells/no_nested_method_definition/good/subscription.rb
 create mode 100644 priv/combined_metrics/samples/code_smells/no_nested_ternary/bad/pricing.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_nested_ternary/config.yml
 create mode 100644 priv/combined_metrics/samples/code_smells/no_nested_ternary/good/pricing.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_primitive_wrapper_constructors/bad/form_validator.js
 create mode 100644 priv/combined_metrics/samples/code_smells/no_primitive_wrapper_constructors/good/form_validator.js
 create mode 100644 priv/combined_metrics/samples/code_smells/no_private_inheritance/bad/Connection.cpp
 create mode 100644 priv/combined_metrics/samples/code_smells/no_private_inheritance/good/Connection.cpp
 create mode 100644 priv/combined_metrics/samples/code_smells/no_problematic_operator_overloads/bad/Widget.cpp
 create mode 100644 priv/combined_metrics/samples/code_smells/no_problematic_operator_overloads/good/Widget.cpp
 create mode 100644 priv/combined_metrics/samples/code_smells/no_process_for_code_organization/bad/inventory.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_process_for_code_organization/good/inventory.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/no_prototype_modification/bad/data_store.js
 create mode 100644 priv/combined_metrics/samples/code_smells/no_prototype_modification/good/data_store.js
 create mode 100644 priv/combined_metrics/samples/code_smells/no_raw_sql_string_concatenation/bad/UserRepository.php
 create mode 100644 priv/combined_metrics/samples/code_smells/no_raw_sql_string_concatenation/good/UserRepository.php
 create mode 100644 priv/combined_metrics/samples/code_smells/no_runblocking_in_coroutines/bad/FileImportService.kt
 create mode 100644 priv/combined_metrics/samples/code_smells/no_runblocking_in_coroutines/good/FileImportService.kt
 create mode 100644 priv/combined_metrics/samples/code_smells/no_side_effects_in_declaration_file/bad/UserRepository.php
 create mode 100644 priv/combined_metrics/samples/code_smells/no_side_effects_in_declaration_file/good/UserRepository.php
 create mode 100644 priv/combined_metrics/samples/code_smells/no_unnecessary_conditions/bad/order_service.ts
 create mode 100644 priv/combined_metrics/samples/code_smells/no_unnecessary_conditions/good/order_service.ts
 create mode 100644 priv/combined_metrics/samples/code_smells/no_using_namespace_directives/bad/Matrix.cpp
 create mode 100644 priv/combined_metrics/samples/code_smells/no_using_namespace_directives/good/Matrix.cpp
 create mode 100644 priv/combined_metrics/samples/code_smells/no_virtual_calls_in_constructors/bad/Widget.cpp
 create mode 100644 priv/combined_metrics/samples/code_smells/no_virtual_calls_in_constructors/good/Widget.cpp
 create mode 100644 priv/combined_metrics/samples/code_smells/no_with_statement/bad/report_builder.js
 create mode 100644 priv/combined_metrics/samples/code_smells/no_with_statement/good/report_builder.js
 create mode 100644 priv/combined_metrics/samples/code_smells/shares_memory_by_communicating/bad/counter.go
 create mode 100644 priv/combined_metrics/samples/code_smells/shares_memory_by_communicating/good/counter.go
 create mode 100644 priv/combined_metrics/samples/code_smells/single_argument_constructors_are_explicit/bad/Parser.cpp
 create mode 100644 priv/combined_metrics/samples/code_smells/single_argument_constructors_are_explicit/good/Parser.cpp
 create mode 100644 priv/combined_metrics/samples/code_smells/supervised_processes_in_supervision_tree/bad/analytics.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/supervised_processes_in_supervision_tree/good/analytics.ex
 create mode 100644 priv/combined_metrics/samples/code_smells/switch_has_default_case/bad/notification_router.js
 create mode 100644 priv/combined_metrics/samples/code_smells/switch_has_default_case/good/notification_router.js
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_appropriate_dispatcher/bad/AnalyticsProcessor.kt
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_appropriate_dispatcher/good/AnalyticsProcessor.kt
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_arc_only_with_send_sync_types/bad/pool.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_arc_only_with_send_sync_types/good/pool.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_attr_accessor_not_manual_getter_setter/bad/payment.rb
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_attr_accessor_not_manual_getter_setter/good/payment.rb
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_context_manager_for_resources/bad/database_manager.py
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_context_manager_for_resources/good/database_manager.py
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_copied_on_copy_types/bad/metrics.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_copied_on_copy_types/good/metrics.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_mb_string_functions_for_unicode/bad/ProductCatalog.php
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_mb_string_functions_for_unicode/good/ProductCatalog.php
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_optionals_not_sentinel_values/bad/UserProfile.swift
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_optionals_not_sentinel_values/good/UserProfile.swift
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_recover_in_long_running_goroutines/bad/server.go
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_recover_in_long_running_goroutines/good/server.go
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_short_circuit_operators/bad/AccessPolicy.cs
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_short_circuit_operators/good/AccessPolicy.cs
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_smart_pointers_for_ownership/bad/Buffer.cpp
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_smart_pointers_for_ownership/good/Buffer.cpp
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_standard_library_constants/bad/geometry.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_standard_library_constants/good/geometry.rs
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_string_builder_for_loop_concatenation/bad/HtmlRenderer.cs
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_string_builder_for_loop_concatenation/good/HtmlRenderer.cs
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_structured_concurrency/bad/DataSyncService.kt
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_structured_concurrency/good/DataSyncService.kt
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_using_statement_for_disposables/bad/ReportExporter.cs
 create mode 100644 priv/combined_metrics/samples/code_smells/uses_using_statement_for_disposables/good/ReportExporter.cs
 create mode 100644 priv/combined_metrics/samples/consistency/all_methods_declare_visibility/bad/PaymentGateway.php
 create mode 100644 priv/combined_metrics/samples/consistency/all_methods_declare_visibility/good/PaymentGateway.php
 create mode 100644 priv/combined_metrics/samples/consistency/all_properties_declare_visibility/bad/OrderService.php
 create mode 100644 priv/combined_metrics/samples/consistency/all_properties_declare_visibility/good/OrderService.php
 create mode 100644 priv/combined_metrics/samples/consistency/consistent_casing_within_file/bad/analytics.ex
 create mode 100644 priv/combined_metrics/samples/consistency/consistent_casing_within_file/config.yml
 create mode 100644 priv/combined_metrics/samples/consistency/consistent_casing_within_file/good/analytics.ex
 create mode 100644 priv/combined_metrics/samples/consistency/consistent_error_return_shape/bad/accounts.ex
 create mode 100644 priv/combined_metrics/samples/consistency/consistent_error_return_shape/config.yml
 create mode 100644 priv/combined_metrics/samples/consistency/consistent_error_return_shape/good/accounts.ex
 create mode 100644 priv/combined_metrics/samples/consistency/consistent_function_style/bad/formatter.ex
 create mode 100644 priv/combined_metrics/samples/consistency/consistent_function_style/config.yml
 create mode 100644 priv/combined_metrics/samples/consistency/consistent_function_style/good/formatter.ex
 create mode 100644 priv/combined_metrics/samples/consistency/doc_vs_comment_separation/bad/subscriptions.ex
 create mode 100644 priv/combined_metrics/samples/consistency/doc_vs_comment_separation/good/subscriptions.ex
 create mode 100644 priv/combined_metrics/samples/consistency/overloads_are_contiguous/bad/PaymentProcessor.java
 create mode 100644 priv/combined_metrics/samples/consistency/overloads_are_contiguous/good/PaymentProcessor.java
 create mode 100644 priv/combined_metrics/samples/consistency/override_annotation_present/bad/UserRepository.java
 create mode 100644 priv/combined_metrics/samples/consistency/override_annotation_present/good/UserRepository.java
 create mode 100644 priv/combined_metrics/samples/consistency/process_interactions_centralized/bad/sessions.ex
 create mode 100644 priv/combined_metrics/samples/consistency/process_interactions_centralized/good/sessions.ex
 create mode 100644 priv/combined_metrics/samples/consistency/protocol_conformance_in_separate_extension/bad/PaymentProcessor.swift
 create mode 100644 priv/combined_metrics/samples/consistency/protocol_conformance_in_separate_extension/good/PaymentProcessor.swift
 create mode 100644 priv/combined_metrics/samples/consistency/same_concept_same_name/bad/auth.ex
 create mode 100644 priv/combined_metrics/samples/consistency/same_concept_same_name/config.yml
 create mode 100644 priv/combined_metrics/samples/consistency/same_concept_same_name/good/auth.ex
 create mode 100644 priv/combined_metrics/samples/consistency/static_member_via_class_name/bad/ProductCatalog.java
 create mode 100644 priv/combined_metrics/samples/consistency/static_member_via_class_name/good/ProductCatalog.java
 create mode 100644 priv/combined_metrics/samples/consistency/switch_fallthrough_has_comment/bad/OrderService.php
 create mode 100644 priv/combined_metrics/samples/consistency/switch_fallthrough_has_comment/good/OrderService.php
 create mode 100644 priv/combined_metrics/samples/dependencies/import_count_under_10/bad/dashboard.ex
 create mode 100644 priv/combined_metrics/samples/dependencies/import_count_under_10/config.yml
 create mode 100644 priv/combined_metrics/samples/dependencies/import_count_under_10/good/dashboard.ex
 create mode 100644 priv/combined_metrics/samples/dependencies/low_coupling/bad/order_controller.ex
 create mode 100644 priv/combined_metrics/samples/dependencies/low_coupling/config.yml
 create mode 100644 priv/combined_metrics/samples/dependencies/low_coupling/good/order_controller.ex
 create mode 100644 priv/combined_metrics/samples/dependencies/no_default_exports/bad/payment_gateway.ts
 create mode 100644 priv/combined_metrics/samples/dependencies/no_default_exports/good/payment_gateway.ts
 create mode 100644 priv/combined_metrics/samples/dependencies/no_mutable_exports/bad/product_repository.ts
 create mode 100644 priv/combined_metrics/samples/dependencies/no_mutable_exports/good/product_repository.ts
 create mode 100644 priv/combined_metrics/samples/dependencies/no_wildcard_imports/bad/query_helpers.ex
 create mode 100644 priv/combined_metrics/samples/dependencies/no_wildcard_imports/config.yml
 create mode 100644 priv/combined_metrics/samples/dependencies/no_wildcard_imports/good/query_helpers.ex
 create mode 100644 priv/combined_metrics/samples/dependencies/uses_import_type_for_type_only_imports/bad/user_service.ts
 create mode 100644 priv/combined_metrics/samples/dependencies/uses_import_type_for_type_only_imports/good/user_service.ts
 create mode 100644 priv/combined_metrics/samples/documentation/docstring_is_nonempty/bad/cache.ex
 create mode 100644 priv/combined_metrics/samples/documentation/docstring_is_nonempty/config.yml
 create mode 100644 priv/combined_metrics/samples/documentation/docstring_is_nonempty/good/cache.ex
 create mode 100644 priv/combined_metrics/samples/documentation/doctests_validate_examples/bad/billing.ex
 create mode 100644 priv/combined_metrics/samples/documentation/doctests_validate_examples/good/billing.ex
 create mode 100644 priv/combined_metrics/samples/documentation/every_declaration_has_doc_comment/bad/ShippingService.swift
 create mode 100644 priv/combined_metrics/samples/documentation/every_declaration_has_doc_comment/good/ShippingService.swift
 create mode 100644 priv/combined_metrics/samples/documentation/exported_symbol_has_doc_comment/bad/cache.go
 create mode 100644 priv/combined_metrics/samples/documentation/exported_symbol_has_doc_comment/good/cache.go
 create mode 100644 priv/combined_metrics/samples/documentation/file_has_license_header/bad/core.ex
 create mode 100644 priv/combined_metrics/samples/documentation/file_has_license_header/config.yml
 create mode 100644 priv/combined_metrics/samples/documentation/file_has_license_header/good/core.ex
 create mode 100644 priv/combined_metrics/samples/documentation/file_has_module_docstring/bad/shipping.ex
 create mode 100644 priv/combined_metrics/samples/documentation/file_has_module_docstring/config.yml
 create mode 100644 priv/combined_metrics/samples/documentation/file_has_module_docstring/good/shipping.ex
 create mode 100644 priv/combined_metrics/samples/documentation/file_has_no_commented_out_code/bad/legacy_importer.ex
 create mode 100644 priv/combined_metrics/samples/documentation/file_has_no_commented_out_code/config.yml
 create mode 100644 priv/combined_metrics/samples/documentation/file_has_no_commented_out_code/good/legacy_importer.ex
 create mode 100644 priv/combined_metrics/samples/documentation/function_has_docstring/bad/tax.ex
 create mode 100644 priv/combined_metrics/samples/documentation/function_has_docstring/config.yml
 create mode 100644 priv/combined_metrics/samples/documentation/function_has_docstring/good/tax.ex
 create mode 100644 priv/combined_metrics/samples/documentation/function_todo_comment_in_body/bad/sync.ex
 create mode 100644 priv/combined_metrics/samples/documentation/function_todo_comment_in_body/config.yml
 create mode 100644 priv/combined_metrics/samples/documentation/function_todo_comment_in_body/good/sync.ex
 create mode 100644 priv/combined_metrics/samples/documentation/public_api_has_moduledoc_and_doc/bad/payments.ex
 create mode 100644 priv/combined_metrics/samples/documentation/public_api_has_moduledoc_and_doc/good/payments.ex
 create mode 100644 priv/combined_metrics/samples/error_handling/catches_specific_exception/bad/file_importer.py
 create mode 100644 priv/combined_metrics/samples/error_handling/catches_specific_exception/good/file_importer.py
 create mode 100644 priv/combined_metrics/samples/error_handling/catches_typed_exception/bad/PaymentGateway.php
 create mode 100644 priv/combined_metrics/samples/error_handling/catches_typed_exception/good/PaymentGateway.php
 create mode 100644 priv/combined_metrics/samples/error_handling/custom_error_type_implements_unwrap/bad/processor.go
 create mode 100644 priv/combined_metrics/samples/error_handling/custom_error_type_implements_unwrap/good/processor.go
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_assert_result_without_value/bad/validator_test.rs
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_assert_result_without_value/good/validator_test.rs
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_catch_and_suppress_errors/bad/FileImporter.swift
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_catch_and_suppress_errors/good/FileImporter.swift
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_catch_general_exception/bad/OrderProcessor.cs
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_catch_general_exception/good/OrderProcessor.cs
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_discard_errors/bad/handler.go
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_discard_errors/good/handler.go
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_expose_implementation_errors/bad/gateway.go
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_expose_implementation_errors/good/gateway.go
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_force_unwrap_optionals/bad/NetworkClient.swift
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_force_unwrap_optionals/good/NetworkClient.swift
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_return_error_codes/bad/UserRepository.cs
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_return_error_codes/good/UserRepository.cs
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_swallow_errors/bad/file_processor.ex
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_swallow_errors/config.yml
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_swallow_errors/good/file_processor.ex
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_swallow_errors_silently/bad/event_bus.js
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_swallow_errors_silently/good/event_bus.js
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_swallow_exceptions/bad/OrderService.java
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_swallow_exceptions/good/OrderService.java
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_throw_from_finally_block/bad/FileProcessor.cs
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_throw_from_finally_block/good/FileProcessor.cs
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_use_exceptions_for_control_flow/bad/ProductCatalog.cs
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_use_exceptions_for_control_flow/good/ProductCatalog.cs
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_use_force_try/bad/DataLoader.swift
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_use_force_try/good/DataLoader.swift
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_use_inband_error_values/bad/store.go
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_use_inband_error_values/good/store.go
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_use_unwrap_in_production/bad/client.rs
 create mode 100644 priv/combined_metrics/samples/error_handling/does_not_use_unwrap_in_production/good/client.rs
 create mode 100644 priv/combined_metrics/samples/error_handling/error_message_is_descriptive/bad/billing.ex
 create mode 100644 priv/combined_metrics/samples/error_handling/error_message_is_descriptive/config.yml
 create mode 100644 priv/combined_metrics/samples/error_handling/error_message_is_descriptive/good/billing.ex
 create mode 100644 priv/combined_metrics/samples/error_handling/error_string_not_capitalized/bad/service.go
 create mode 100644 priv/combined_metrics/samples/error_handling/error_string_not_capitalized/good/service.go
 create mode 100644 priv/combined_metrics/samples/error_handling/error_type_includes_context/bad/client.go
 create mode 100644 priv/combined_metrics/samples/error_handling/error_type_includes_context/good/client.go
 create mode 100644 priv/combined_metrics/samples/error_handling/no_bare_except/bad/api_client.py
 create mode 100644 priv/combined_metrics/samples/error_handling/no_bare_except/good/api_client.py
 create mode 100644 priv/combined_metrics/samples/error_handling/no_blind_rescue/bad/cart.rb
 create mode 100644 priv/combined_metrics/samples/error_handling/no_blind_rescue/good/cart.rb
 create mode 100644 priv/combined_metrics/samples/error_handling/no_empty_rescue_block/bad/payment.rb
 create mode 100644 priv/combined_metrics/samples/error_handling/no_empty_rescue_block/good/payment.rb
 create mode 100644 priv/combined_metrics/samples/error_handling/no_error_suppression_operator/bad/ProductCatalog.php
 create mode 100644 priv/combined_metrics/samples/error_handling/no_error_suppression_operator/good/ProductCatalog.php
 create mode 100644 priv/combined_metrics/samples/error_handling/no_eval_or_dynamic_code_execution/bad/template_engine.js
 create mode 100644 priv/combined_metrics/samples/error_handling/no_eval_or_dynamic_code_execution/good/template_engine.js
 create mode 100644 priv/combined_metrics/samples/error_handling/no_exceptions_for_control_flow/bad/billing.ex
 create mode 100644 priv/combined_metrics/samples/error_handling/no_exceptions_for_control_flow/good/billing.ex
 create mode 100644 priv/combined_metrics/samples/error_handling/no_floating_promises/bad/order_service.js
 create mode 100644 priv/combined_metrics/samples/error_handling/no_floating_promises/bad/user_service.ts
 create mode 100644 priv/combined_metrics/samples/error_handling/no_floating_promises/good/order_service.js
 create mode 100644 priv/combined_metrics/samples/error_handling/no_floating_promises/good/user_service.ts
 create mode 100644 priv/combined_metrics/samples/error_handling/no_misused_promises/bad/product_repository.ts
 create mode 100644 priv/combined_metrics/samples/error_handling/no_misused_promises/good/product_repository.ts
 create mode 100644 priv/combined_metrics/samples/error_handling/no_rescue_as_flow_control/bad/invoice.rb
 create mode 100644 priv/combined_metrics/samples/error_handling/no_rescue_as_flow_control/good/invoice.rb
 create mode 100644 priv/combined_metrics/samples/error_handling/no_return_from_ensure/bad/subscription.rb
 create mode 100644 priv/combined_metrics/samples/error_handling/no_return_from_ensure/good/subscription.rb
 create mode 100644 priv/combined_metrics/samples/error_handling/rescue_most_specific_first/bad/account.rb
 create mode 100644 priv/combined_metrics/samples/error_handling/rescue_most_specific_first/good/account.rb
 create mode 100644 priv/combined_metrics/samples/error_handling/returns_typed_error/bad/repository.ex
 create mode 100644 priv/combined_metrics/samples/error_handling/returns_typed_error/config.yml
 create mode 100644 priv/combined_metrics/samples/error_handling/returns_typed_error/good/repository.ex
 create mode 100644 priv/combined_metrics/samples/error_handling/throws_error_objects_not_primitives/bad/api_client.js
 create mode 100644 priv/combined_metrics/samples/error_handling/throws_error_objects_not_primitives/good/api_client.js
 create mode 100644 priv/combined_metrics/samples/error_handling/try_block_is_minimal/bad/payment_processor.py
 create mode 100644 priv/combined_metrics/samples/error_handling/try_block_is_minimal/good/payment_processor.py
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_checked_arithmetic/bad/invoice.rs
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_checked_arithmetic/good/invoice.rs
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_custom_error_type_with_context/bad/store.rs
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_custom_error_type_with_context/good/store.rs
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_errors_as_for_type_assertion/bad/router.go
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_errors_as_for_type_assertion/good/router.go
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_errors_is_for_sentinel_comparison/bad/middleware.go
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_errors_is_for_sentinel_comparison/good/middleware.go
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_exceptions_not_error_codes/bad/OrderService.php
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_exceptions_not_error_codes/good/OrderService.php
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_question_mark_for_propagation/bad/loader.rs
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_question_mark_for_propagation/good/loader.rs
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_raise_from/bad/config_loader.py
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_raise_from/good/config_loader.py
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_result_for_recoverable_errors/bad/parser.rs
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_result_for_recoverable_errors/good/parser.rs
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_throws_for_recoverable_errors/bad/AuthService.swift
 create mode 100644 priv/combined_metrics/samples/error_handling/uses_throws_for_recoverable_errors/good/AuthService.swift
 create mode 100644 priv/combined_metrics/samples/error_handling/wraps_errors_with_context/bad/repository.go
 create mode 100644 priv/combined_metrics/samples/error_handling/wraps_errors_with_context/good/repository.go
 create mode 100644 priv/combined_metrics/samples/file_structure/has_consistent_indentation/bad/worker.ex
 create mode 100644 priv/combined_metrics/samples/file_structure/has_consistent_indentation/config.yml
 create mode 100644 priv/combined_metrics/samples/file_structure/has_consistent_indentation/good/worker.ex
 create mode 100644 priv/combined_metrics/samples/file_structure/headers_have_include_guards/bad/Parser.cpp
 create mode 100644 priv/combined_metrics/samples/file_structure/headers_have_include_guards/good/Parser.cpp
 create mode 100644 priv/combined_metrics/samples/file_structure/line_count_under_300/bad/mega_service.ex
 create mode 100644 priv/combined_metrics/samples/file_structure/line_count_under_300/config.yml
 create mode 100644 priv/combined_metrics/samples/file_structure/line_count_under_300/good/order_service.ex
 create mode 100644 priv/combined_metrics/samples/file_structure/line_length_under_120/bad/query_builder.ex
 create mode 100644 priv/combined_metrics/samples/file_structure/line_length_under_120/config.yml
 create mode 100644 priv/combined_metrics/samples/file_structure/line_length_under_120/good/query_builder.ex
 create mode 100644 priv/combined_metrics/samples/file_structure/no_magic_numbers/bad/rate_limiter.ex
 create mode 100644 priv/combined_metrics/samples/file_structure/no_magic_numbers/config.yml
 create mode 100644 priv/combined_metrics/samples/file_structure/no_magic_numbers/good/rate_limiter.ex
 create mode 100644 priv/combined_metrics/samples/file_structure/one_top_level_class_per_file/bad/InvoiceService.java
 create mode 100644 priv/combined_metrics/samples/file_structure/one_top_level_class_per_file/good/InvoiceService.java
 create mode 100644 priv/combined_metrics/samples/file_structure/single_responsibility/bad/user_handler.ex
 create mode 100644 priv/combined_metrics/samples/file_structure/single_responsibility/config.yml
 create mode 100644 priv/combined_metrics/samples/file_structure/single_responsibility/good/user_registration.ex
 create mode 100644 priv/combined_metrics/samples/file_structure/uses_standard_indentation_width/bad/mailer.ex
 create mode 100644 priv/combined_metrics/samples/file_structure/uses_standard_indentation_width/config.yml
 create mode 100644 priv/combined_metrics/samples/file_structure/uses_standard_indentation_width/good/mailer.ex
 create mode 100644 priv/combined_metrics/samples/function_design/arrow_functions_as_callbacks/bad/user_service.ts
 create mode 100644 priv/combined_metrics/samples/function_design/arrow_functions_as_callbacks/good/user_service.ts
 create mode 100644 priv/combined_metrics/samples/function_design/async_functions_contain_await/bad/payment_gateway.ts
 create mode 100644 priv/combined_metrics/samples/function_design/async_functions_contain_await/good/payment_gateway.ts
 create mode 100644 priv/combined_metrics/samples/function_design/async_method_has_await/bad/EmailDispatcher.cs
 create mode 100644 priv/combined_metrics/samples/function_design/async_method_has_await/good/EmailDispatcher.cs
 create mode 100644 priv/combined_metrics/samples/function_design/boolean_function_has_question_mark/bad/guards.ex
 create mode 100644 priv/combined_metrics/samples/function_design/boolean_function_has_question_mark/config.yml
 create mode 100644 priv/combined_metrics/samples/function_design/boolean_function_has_question_mark/good/guards.ex
 create mode 100644 priv/combined_metrics/samples/function_design/call_site_forms_grammatical_phrase/bad/EventHandler.swift
 create mode 100644 priv/combined_metrics/samples/function_design/call_site_forms_grammatical_phrase/good/EventHandler.swift
 create mode 100644 priv/combined_metrics/samples/function_design/context_is_first_parameter/bad/mailer.go
 create mode 100644 priv/combined_metrics/samples/function_design/context_is_first_parameter/good/mailer.go
 create mode 100644 priv/combined_metrics/samples/function_design/cyclomatic_complexity_under_10/bad/order_processor.ex
 create mode 100644 priv/combined_metrics/samples/function_design/cyclomatic_complexity_under_10/config.yml
 create mode 100644 priv/combined_metrics/samples/function_design/cyclomatic_complexity_under_10/good/order_processor.ex
 create mode 100644 priv/combined_metrics/samples/function_design/default_parameters_placed_at_end/bad/EmailComposer.swift
 create mode 100644 priv/combined_metrics/samples/function_design/default_parameters_placed_at_end/good/EmailComposer.swift
 create mode 100644 priv/combined_metrics/samples/function_design/function_does_not_change_return_type_via_options/bad/reports.ex
 create mode 100644 priv/combined_metrics/samples/function_design/function_does_not_change_return_type_via_options/good/reports.ex
 create mode 100644 priv/combined_metrics/samples/function_design/has_verb_in_name/bad/api.ex
 create mode 100644 priv/combined_metrics/samples/function_design/has_verb_in_name/config.yml
 create mode 100644 priv/combined_metrics/samples/function_design/has_verb_in_name/good/api.ex
 create mode 100644 priv/combined_metrics/samples/function_design/input_parameters_before_output_parameters/bad/Matrix.cpp
 create mode 100644 priv/combined_metrics/samples/function_design/input_parameters_before_output_parameters/good/Matrix.cpp
 create mode 100644 priv/combined_metrics/samples/function_design/interface_has_one_or_two_methods/bad/storage.go
 create mode 100644 priv/combined_metrics/samples/function_design/interface_has_one_or_two_methods/good/storage.go
 create mode 100644 priv/combined_metrics/samples/function_design/is_less_than_20_lines/bad/report_generator.ex
 create mode 100644 priv/combined_metrics/samples/function_design/is_less_than_20_lines/config.yml
 create mode 100644 priv/combined_metrics/samples/function_design/is_less_than_20_lines/good/report_generator.ex
 create mode 100644 priv/combined_metrics/samples/function_design/move_constructors_are_noexcept/bad/Buffer.cpp
 create mode 100644 priv/combined_metrics/samples/function_design/move_constructors_are_noexcept/good/Buffer.cpp
 create mode 100644 priv/combined_metrics/samples/function_design/named_return_values_used_for_documentation/bad/parser.go
 create mode 100644 priv/combined_metrics/samples/function_design/named_return_values_used_for_documentation/good/parser.go
 create mode 100644 priv/combined_metrics/samples/function_design/nesting_depth_under_4/bad/validator.ex
 create mode 100644 priv/combined_metrics/samples/function_design/nesting_depth_under_4/config.yml
 create mode 100644 priv/combined_metrics/samples/function_design/nesting_depth_under_4/good/validator.ex
 create mode 100644 priv/combined_metrics/samples/function_design/no_arguments_object/bad/query_builder.js
 create mode 100644 priv/combined_metrics/samples/function_design/no_arguments_object/good/query_builder.js
 create mode 100644 priv/combined_metrics/samples/function_design/no_async_void_outside_event_handlers/bad/BackgroundSync.cs
 create mode 100644 priv/combined_metrics/samples/function_design/no_async_void_outside_event_handlers/good/BackgroundSync.cs
 create mode 100644 priv/combined_metrics/samples/function_design/no_boolean_parameter/bad/notifications.ex
 create mode 100644 priv/combined_metrics/samples/function_design/no_boolean_parameter/config.yml
 create mode 100644 priv/combined_metrics/samples/function_design/no_boolean_parameter/good/notifications.ex
 create mode 100644 priv/combined_metrics/samples/function_design/no_default_arguments_on_virtual_functions/bad/Widget.cpp
 create mode 100644 priv/combined_metrics/samples/function_design/no_default_arguments_on_virtual_functions/good/Widget.cpp
 create mode 100644 priv/combined_metrics/samples/function_design/no_magic_numbers/bad/discounter.ex
 create mode 100644 priv/combined_metrics/samples/function_design/no_magic_numbers/config.yml
 create mode 100644 priv/combined_metrics/samples/function_design/no_magic_numbers/good/discounter.ex
 create mode 100644 priv/combined_metrics/samples/function_design/no_mutable_default_argument/bad/report_builder.py
 create mode 100644 priv/combined_metrics/samples/function_design/no_mutable_default_argument/good/report_builder.py
 create mode 100644 priv/combined_metrics/samples/function_design/no_star_args_abuse/bad/notification_sender.py
 create mode 100644 priv/combined_metrics/samples/function_design/no_star_args_abuse/good/notification_sender.py
 create mode 100644 priv/combined_metrics/samples/function_design/no_static_class_for_namespacing/bad/date_utils.ts
 create mode 100644 priv/combined_metrics/samples/function_design/no_static_class_for_namespacing/good/date_utils.ts
 create mode 100644 priv/combined_metrics/samples/function_design/no_static_only_container_classes/bad/string_utils.js
 create mode 100644 priv/combined_metrics/samples/function_design/no_static_only_container_classes/good/string_utils.js
 create mode 100644 priv/combined_metrics/samples/function_design/no_unrelated_clauses_in_multi_clause_function/bad/notifications.ex
 create mode 100644 priv/combined_metrics/samples/function_design/no_unrelated_clauses_in_multi_clause_function/good/notifications.ex
 create mode 100644 priv/combined_metrics/samples/function_design/parameter_count_under_4/bad/email_sender.ex
 create mode 100644 priv/combined_metrics/samples/function_design/parameter_count_under_4/config.yml
 create mode 100644 priv/combined_metrics/samples/function_design/parameter_count_under_4/good/email_sender.ex
 create mode 100644 priv/combined_metrics/samples/function_design/prefers_synchronous_functions/bad/validator.go
 create mode 100644 priv/combined_metrics/samples/function_design/prefers_synchronous_functions/good/validator.go
 create mode 100644 priv/combined_metrics/samples/function_design/promise_returning_functions_are_async/bad/notification_handler.ts
 create mode 100644 priv/combined_metrics/samples/function_design/promise_returning_functions_are_async/good/notification_handler.ts
 create mode 100644 priv/combined_metrics/samples/function_design/return_values_over_output_parameters/bad/Parser.cpp
 create mode 100644 priv/combined_metrics/samples/function_design/return_values_over_output_parameters/good/Parser.cpp
 create mode 100644 priv/combined_metrics/samples/function_design/uses_assertive_map_access/bad/shipping.ex
 create mode 100644 priv/combined_metrics/samples/function_design/uses_assertive_map_access/good/shipping.ex
 create mode 100644 priv/combined_metrics/samples/function_design/uses_assertive_pattern_matching/bad/inventory.ex
 create mode 100644 priv/combined_metrics/samples/function_design/uses_assertive_pattern_matching/good/inventory.ex
 create mode 100644 priv/combined_metrics/samples/function_design/uses_default_parameters_over_overloads/bad/EmailSender.kt
 create mode 100644 priv/combined_metrics/samples/function_design/uses_default_parameters_over_overloads/good/EmailSender.kt
 create mode 100644 priv/combined_metrics/samples/function_design/uses_defer_for_cleanup/bad/filestore.go
 create mode 100644 priv/combined_metrics/samples/function_design/uses_defer_for_cleanup/good/filestore.go
 create mode 100644 priv/combined_metrics/samples/function_design/uses_enumerate_not_range_len/bad/item_processor.py
 create mode 100644 priv/combined_metrics/samples/function_design/uses_enumerate_not_range_len/good/item_processor.py
 create mode 100644 priv/combined_metrics/samples/function_design/uses_generator_over_list_comprehension/bad/data_pipeline.py
 create mode 100644 priv/combined_metrics/samples/function_design/uses_generator_over_list_comprehension/good/data_pipeline.py
 create mode 100644 priv/combined_metrics/samples/function_design/uses_keyword_arguments_over_option_hash/bad/invoice.rb
 create mode 100644 priv/combined_metrics/samples/function_design/uses_keyword_arguments_over_option_hash/good/invoice.rb
 create mode 100644 priv/combined_metrics/samples/function_design/uses_named_arguments_for_multiple_same_type_params/bad/SubscriptionService.kt
 create mode 100644 priv/combined_metrics/samples/function_design/uses_named_arguments_for_multiple_same_type_params/good/SubscriptionService.kt
 create mode 100644 priv/combined_metrics/samples/function_design/uses_pattern_matching_over_conditionals/bad/orders.ex
 create mode 100644 priv/combined_metrics/samples/function_design/uses_pattern_matching_over_conditionals/good/orders.ex
 create mode 100644 priv/combined_metrics/samples/function_design/uses_ternary_expression/bad/formatter.ex
 create mode 100644 priv/combined_metrics/samples/function_design/uses_ternary_expression/config.yml
 create mode 100644 priv/combined_metrics/samples/function_design/uses_ternary_expression/good/formatter.ex
 create mode 100644 priv/combined_metrics/samples/function_design/uses_when_for_three_or_more_branches/bad/ShippingCalculator.kt
 create mode 100644 priv/combined_metrics/samples/function_design/uses_when_for_three_or_more_branches/good/ShippingCalculator.kt
 create mode 100644 priv/combined_metrics/samples/function_design/with_expression_handles_happy_path_only/bad/payments.ex
 create mode 100644 priv/combined_metrics/samples/function_design/with_expression_handles_happy_path_only/good/payments.ex
 create mode 100644 priv/combined_metrics/samples/function_design/zero_value_is_usable/bad/buffer.go
 create mode 100644 priv/combined_metrics/samples/function_design/zero_value_is_usable/good/buffer.go
 create mode 100644 priv/combined_metrics/samples/naming_conventions/async_method_named_with_async_suffix/bad/PaymentGateway.cs
 create mode 100644 priv/combined_metrics/samples/naming_conventions/async_method_named_with_async_suffix/good/PaymentGateway.cs
 create mode 100644 priv/combined_metrics/samples/naming_conventions/bang_function_raises_on_failure/bad/accounts.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/bang_function_raises_on_failure/config.yml
 create mode 100644 priv/combined_metrics/samples/naming_conventions/bang_function_raises_on_failure/good/accounts.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/boolean_reads_as_assertion/bad/ProductCatalog.swift
 create mode 100644 priv/combined_metrics/samples/naming_conventions/boolean_reads_as_assertion/good/ProductCatalog.swift
 create mode 100644 priv/combined_metrics/samples/naming_conventions/class_name_is_noun/bad/modules.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/class_name_is_noun/config.yml
 create mode 100644 priv/combined_metrics/samples/naming_conventions/class_name_is_noun/good/modules.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/classes_use_studly_caps/bad/OrderService.php
 create mode 100644 priv/combined_metrics/samples/naming_conventions/classes_use_studly_caps/good/OrderService.php
 create mode 100644 priv/combined_metrics/samples/naming_conventions/constants_are_screaming_snake_or_caps_words/bad/payment.rb
 create mode 100644 priv/combined_metrics/samples/naming_conventions/constants_are_screaming_snake_or_caps_words/good/payment.rb
 create mode 100644 priv/combined_metrics/samples/naming_conventions/constants_are_upper_case_with_underscores/bad/ProductCatalog.php
 create mode 100644 priv/combined_metrics/samples/naming_conventions/constants_are_upper_case_with_underscores/good/ProductCatalog.php
 create mode 100644 priv/combined_metrics/samples/naming_conventions/constructor_named_new_or_with/bad/session.rs
 create mode 100644 priv/combined_metrics/samples/naming_conventions/constructor_named_new_or_with/good/session.rs
 create mode 100644 priv/combined_metrics/samples/naming_conventions/dangerous_method_ends_with_bang/bad/invoice.rb
 create mode 100644 priv/combined_metrics/samples/naming_conventions/dangerous_method_ends_with_bang/good/invoice.rb
 create mode 100644 priv/combined_metrics/samples/naming_conventions/does_not_repeat_module_name_in_type/bad/payment.rs
 create mode 100644 priv/combined_metrics/samples/naming_conventions/does_not_repeat_module_name_in_type/good/payment.rs
 create mode 100644 priv/combined_metrics/samples/naming_conventions/does_not_use_abbreviated_names/bad/SubscriptionManager.swift
 create mode 100644 priv/combined_metrics/samples/naming_conventions/does_not_use_abbreviated_names/good/SubscriptionManager.swift
 create mode 100644 priv/combined_metrics/samples/naming_conventions/does_not_use_generic_package_names/bad/order.go
 create mode 100644 priv/combined_metrics/samples/naming_conventions/does_not_use_generic_package_names/good/order.go
 create mode 100644 priv/combined_metrics/samples/naming_conventions/does_not_use_get_prefix_for_accessors/bad/InventoryService.swift
 create mode 100644 priv/combined_metrics/samples/naming_conventions/does_not_use_get_prefix_for_accessors/good/InventoryService.swift
 create mode 100644 priv/combined_metrics/samples/naming_conventions/exported_name_not_redundant_with_package/bad/product.go
 create mode 100644 priv/combined_metrics/samples/naming_conventions/exported_name_not_redundant_with_package/good/product.go
 create mode 100644 priv/combined_metrics/samples/naming_conventions/factory_method_starts_with_make/bad/ReportBuilder.swift
 create mode 100644 priv/combined_metrics/samples/naming_conventions/factory_method_starts_with_make/good/ReportBuilder.swift
 create mode 100644 priv/combined_metrics/samples/naming_conventions/file_name_matches_primary_export/bad/helpers.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/file_name_matches_primary_export/config.yml
 create mode 100644 priv/combined_metrics/samples/naming_conventions/file_name_matches_primary_export/good/user_manager.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/function_name_is_not_single_word/bad/worker.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/function_name_is_not_single_word/config.yml
 create mode 100644 priv/combined_metrics/samples/naming_conventions/function_name_is_not_single_word/good/worker.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/function_name_matches_return_type/bad/queries.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/function_name_matches_return_type/config.yml
 create mode 100644 priv/combined_metrics/samples/naming_conventions/function_name_matches_return_type/good/queries.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/get_fetch_fetch_bang_contract_is_consistent/bad/sessions.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/get_fetch_fetch_bang_contract_is_consistent/good/sessions.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/getter_has_no_prefix/bad/user.rs
 create mode 100644 priv/combined_metrics/samples/naming_conventions/getter_has_no_prefix/good/user.rs
 create mode 100644 priv/combined_metrics/samples/naming_conventions/getter_not_prefixed_with_get/bad/account.go
 create mode 100644 priv/combined_metrics/samples/naming_conventions/getter_not_prefixed_with_get/good/account.go
 create mode 100644 priv/combined_metrics/samples/naming_conventions/initialism_uses_consistent_casing/bad/api.go
 create mode 100644 priv/combined_metrics/samples/naming_conventions/initialism_uses_consistent_casing/good/api.go
 create mode 100644 priv/combined_metrics/samples/naming_conventions/interface_named_with_er_suffix/bad/notification.go
 create mode 100644 priv/combined_metrics/samples/naming_conventions/interface_named_with_er_suffix/good/notification.go
 create mode 100644 priv/combined_metrics/samples/naming_conventions/methods_use_camel_case/bad/PaymentGateway.php
 create mode 100644 priv/combined_metrics/samples/naming_conventions/methods_use_camel_case/good/PaymentGateway.php
 create mode 100644 priv/combined_metrics/samples/naming_conventions/mutating_method_uses_imperative_verb/bad/ShoppingCart.swift
 create mode 100644 priv/combined_metrics/samples/naming_conventions/mutating_method_uses_imperative_verb/good/ShoppingCart.swift
 create mode 100644 priv/combined_metrics/samples/naming_conventions/name_reflects_role_not_type/bad/OrderManager.swift
 create mode 100644 priv/combined_metrics/samples/naming_conventions/name_reflects_role_not_type/good/OrderManager.swift
 create mode 100644 priv/combined_metrics/samples/naming_conventions/name_reflects_semantics_not_type/bad/SubscriptionManager.cs
 create mode 100644 priv/combined_metrics/samples/naming_conventions/name_reflects_semantics_not_type/good/SubscriptionManager.cs
 create mode 100644 priv/combined_metrics/samples/naming_conventions/no_abbreviations_in_identifiers/bad/ShipmentTracker.cs
 create mode 100644 priv/combined_metrics/samples/naming_conventions/no_abbreviations_in_identifiers/good/ShipmentTracker.cs
 create mode 100644 priv/combined_metrics/samples/naming_conventions/no_hungarian_notation/bad/InventoryService.cs
 create mode 100644 priv/combined_metrics/samples/naming_conventions/no_hungarian_notation/good/InventoryService.cs
 create mode 100644 priv/combined_metrics/samples/naming_conventions/no_member_name_prefixes_suffixes/bad/CustomerAccount.java
 create mode 100644 priv/combined_metrics/samples/naming_conventions/no_member_name_prefixes_suffixes/good/CustomerAccount.java
 create mode 100644 priv/combined_metrics/samples/naming_conventions/no_predicate_method_with_is_prefix/bad/account.rb
 create mode 100644 priv/combined_metrics/samples/naming_conventions/no_predicate_method_with_is_prefix/good/account.rb
 create mode 100644 priv/combined_metrics/samples/naming_conventions/no_single_char_variable_ambiguous/bad/matrix_transform.py
 create mode 100644 priv/combined_metrics/samples/naming_conventions/no_single_char_variable_ambiguous/good/matrix_transform.py
 create mode 100644 priv/combined_metrics/samples/naming_conventions/no_underscore_visibility_prefix/bad/UserRepository.php
 create mode 100644 priv/combined_metrics/samples/naming_conventions/no_underscore_visibility_prefix/good/UserRepository.php
 create mode 100644 priv/combined_metrics/samples/naming_conventions/no_util_or_meaningless_class_names/bad/PriceFormatter.kt
 create mode 100644 priv/combined_metrics/samples/naming_conventions/no_util_or_meaningless_class_names/good/PriceFormatter.kt
 create mode 100644 priv/combined_metrics/samples/naming_conventions/package_name_is_single_lowercase_word/bad/user.go
 create mode 100644 priv/combined_metrics/samples/naming_conventions/package_name_is_single_lowercase_word/good/user.go
 create mode 100644 priv/combined_metrics/samples/naming_conventions/predicate_function_ends_with_question_mark/bad/subscriptions.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/predicate_function_ends_with_question_mark/good/subscriptions.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/predicate_method_ends_with_question_mark/bad/subscription.rb
 create mode 100644 priv/combined_metrics/samples/naming_conventions/predicate_method_ends_with_question_mark/good/subscription.rb
 create mode 100644 priv/combined_metrics/samples/naming_conventions/predicate_prefixed_with_is/bad/order.rs
 create mode 100644 priv/combined_metrics/samples/naming_conventions/predicate_prefixed_with_is/good/order.rs
 create mode 100644 priv/combined_metrics/samples/naming_conventions/protocol_capability_uses_able_ible_ing_suffix/bad/DocumentPipeline.swift
 create mode 100644 priv/combined_metrics/samples/naming_conventions/protocol_capability_uses_able_ible_ing_suffix/good/DocumentPipeline.swift
 create mode 100644 priv/combined_metrics/samples/naming_conventions/receiver_name_is_short_type_abbreviation/bad/session.go
 create mode 100644 priv/combined_metrics/samples/naming_conventions/receiver_name_is_short_type_abbreviation/good/session.go
 create mode 100644 priv/combined_metrics/samples/naming_conventions/size_vs_length_naming_is_consistent/bad/catalog.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/size_vs_length_naming_is_consistent/good/catalog.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/test_name_starts_with_verb/bad/user_test.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/test_name_starts_with_verb/config.yml
 create mode 100644 priv/combined_metrics/samples/naming_conventions/test_name_starts_with_verb/good/user_test.ex
 create mode 100644 priv/combined_metrics/samples/naming_conventions/type_parameter_is_descriptive_or_single_letter/bad/CacheStore.swift
 create mode 100644 priv/combined_metrics/samples/naming_conventions/type_parameter_is_descriptive_or_single_letter/good/CacheStore.swift
 create mode 100644 priv/combined_metrics/samples/naming_conventions/uses_caps_words_for_classes/bad/session_manager.py
 create mode 100644 priv/combined_metrics/samples/naming_conventions/uses_caps_words_for_classes/good/session_manager.py
 create mode 100644 priv/combined_metrics/samples/naming_conventions/uses_snake_case_for_functions/bad/invoice_handler.py
 create mode 100644 priv/combined_metrics/samples/naming_conventions/uses_snake_case_for_functions/good/invoice_handler.py
 create mode 100644 priv/combined_metrics/samples/naming_conventions/uses_snake_case_for_methods/bad/cart.rb
 create mode 100644 priv/combined_metrics/samples/naming_conventions/uses_snake_case_for_methods/good/cart.rb
 create mode 100644 priv/combined_metrics/samples/naming_conventions/verb_phrase_distinguishes_mutation_vs_return/bad/ProductInventory.kt
 create mode 100644 priv/combined_metrics/samples/naming_conventions/verb_phrase_distinguishes_mutation_vs_return/good/ProductInventory.kt
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/declared_close_to_use/bad/processor.ex
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/declared_close_to_use/config.yml
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/declared_close_to_use/good/processor.ex
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/mutated_after_initial_assignment/bad/aggregator.ex
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/mutated_after_initial_assignment/config.yml
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/mutated_after_initial_assignment/good/aggregator.ex
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/no_var_declarations/bad/search_index.js
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/no_var_declarations/good/search_index.js
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/prefers_val_over_var/bad/ReportGenerator.kt
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/prefers_val_over_var/good/ReportGenerator.kt
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/reassigned_multiple_times/bad/transformer.ex
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/reassigned_multiple_times/config.yml
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/reassigned_multiple_times/good/transformer.ex
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/scope_is_minimal/bad/handler.ex
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/scope_is_minimal/config.yml
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/scope_is_minimal/good/handler.ex
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/shadowed_by_inner_scope/bad/nested.ex
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/shadowed_by_inner_scope/config.yml
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/shadowed_by_inner_scope/good/nested.ex
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/used_only_once/bad/builder.ex
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/used_only_once/config.yml
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/used_only_once/good/builder.ex
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/uses_const_by_default/bad/invoice_calculator.js
 create mode 100644 priv/combined_metrics/samples/scope_and_assignment/uses_const_by_default/good/invoice_calculator.js
 create mode 100644 priv/combined_metrics/samples/testing/reasonable_test_to_code_ratio/bad/sparse_test.ex
 create mode 100644 priv/combined_metrics/samples/testing/reasonable_test_to_code_ratio/config.yml
 create mode 100644 priv/combined_metrics/samples/testing/reasonable_test_to_code_ratio/good/thorough_test.ex
 create mode 100644 priv/combined_metrics/samples/testing/test_has_assertion/bad/empty_assertions_test.ex
 create mode 100644 priv/combined_metrics/samples/testing/test_has_assertion/config.yml
 create mode 100644 priv/combined_metrics/samples/testing/test_has_assertion/good/proper_assertions_test.ex
 create mode 100644 priv/combined_metrics/samples/testing/test_name_describes_behavior/bad/vague_test.ex
 create mode 100644 priv/combined_metrics/samples/testing/test_name_describes_behavior/config.yml
 create mode 100644 priv/combined_metrics/samples/testing/test_name_describes_behavior/good/descriptive_test.ex
 create mode 100644 priv/combined_metrics/samples/testing/test_single_concept/bad/kitchen_sink_test.ex
 create mode 100644 priv/combined_metrics/samples/testing/test_single_concept/config.yml
 create mode 100644 priv/combined_metrics/samples/testing/test_single_concept/good/focused_test.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/boolean_assigned_from_comparison/bad/checker.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/boolean_assigned_from_comparison/config.yml
 create mode 100644 priv/combined_metrics/samples/type_and_value/boolean_assigned_from_comparison/good/checker.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/copy_not_assumed_to_be_deep/bad/OrderDraft.kt
 create mode 100644 priv/combined_metrics/samples/type_and_value/copy_not_assumed_to_be_deep/good/OrderDraft.kt
 create mode 100644 priv/combined_metrics/samples/type_and_value/copyability_is_explicitly_declared/bad/Matrix.cpp
 create mode 100644 priv/combined_metrics/samples/type_and_value/copyability_is_explicitly_declared/good/Matrix.cpp
 create mode 100644 priv/combined_metrics/samples/type_and_value/does_not_use_lossy_numeric_cast/bad/converter.rs
 create mode 100644 priv/combined_metrics/samples/type_and_value/does_not_use_lossy_numeric_cast/good/converter.rs
 create mode 100644 priv/combined_metrics/samples/type_and_value/fields_defined_in_constructor/bad/session_manager.js
 create mode 100644 priv/combined_metrics/samples/type_and_value/fields_defined_in_constructor/good/session_manager.js
 create mode 100644 priv/combined_metrics/samples/type_and_value/hardcoded_url_or_path/bad/client.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/hardcoded_url_or_path/config.yml
 create mode 100644 priv/combined_metrics/samples/type_and_value/hardcoded_url_or_path/good/client.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_any_type_annotation/bad/order_handler.py
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_any_type_annotation/good/order_handler.py
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_boolean_obsession/bad/notifications.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_boolean_obsession/good/notifications.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_c_style_casts/bad/Buffer.cpp
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_c_style_casts/good/Buffer.cpp
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_comparison_to_true_false/bad/feature_flags.py
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_comparison_to_true_false/good/feature_flags.py
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_double_type_assertion/bad/user_service.ts
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_double_type_assertion/good/user_service.ts
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_duplicate_enum_values/bad/notification_handler.ts
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_duplicate_enum_values/good/notification_handler.ts
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_dynamic_atom_creation_from_external_input/bad/analytics.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_dynamic_atom_creation_from_external_input/good/analytics.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_empty_string_initial/bad/builder.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_empty_string_initial/config.yml
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_empty_string_initial/good/builder.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_explicit_any/bad/user_service.ts
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_explicit_any/good/user_service.ts
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_implicit_null_initial/bad/loader.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_implicit_null_initial/config.yml
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_implicit_null_initial/good/loader.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_magic_value_assigned/bad/roles.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_magic_value_assigned/config.yml
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_magic_value_assigned/good/roles.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_mutable_exported_variables/bad/feature_flags.js
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_mutable_exported_variables/good/feature_flags.js
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_non_null_assertion/bad/notification_handler.ts
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_non_null_assertion/good/notification_handler.ts
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_non_null_assertion_operator/bad/UserProfile.kt
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_non_null_assertion_operator/good/UserProfile.kt
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_primitive_obsession/bad/payments.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_primitive_obsession/good/payments.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_rtti/bad/Connection.cpp
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_rtti/good/Connection.cpp
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_unparameterized_generic/bad/product_service.py
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_unparameterized_generic/good/product_service.py
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_unsafe_assignment/bad/product_repository.ts
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_unsafe_assignment/good/product_repository.ts
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_unsafe_return/bad/payment_gateway.ts
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_unsafe_return/good/payment_gateway.ts
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_var_keyword_for_properties/bad/PaymentGateway.php
 create mode 100644 priv/combined_metrics/samples/type_and_value/no_var_keyword_for_properties/good/PaymentGateway.php
 create mode 100644 priv/combined_metrics/samples/type_and_value/nullable_boolean_compared_explicitly/bad/NotificationHandler.kt
 create mode 100644 priv/combined_metrics/samples/type_and_value/nullable_boolean_compared_explicitly/good/NotificationHandler.kt
 create mode 100644 priv/combined_metrics/samples/type_and_value/readonly_for_never_reassigned_fields/bad/product_repository.ts
 create mode 100644 priv/combined_metrics/samples/type_and_value/readonly_for_never_reassigned_fields/good/product_repository.ts
 create mode 100644 priv/combined_metrics/samples/type_and_value/sealed_class_when_is_exhaustive/bad/PaymentStatus.kt
 create mode 100644 priv/combined_metrics/samples/type_and_value/sealed_class_when_is_exhaustive/good/PaymentStatus.kt
 create mode 100644 priv/combined_metrics/samples/type_and_value/struct_under_32_fields/bad/orders.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/struct_under_32_fields/good/orders.ex
 create mode 100644 priv/combined_metrics/samples/type_and_value/switch_covers_all_union_members/bad/payment_gateway.ts
 create mode 100644 priv/combined_metrics/samples/type_and_value/switch_covers_all_union_members/good/payment_gateway.ts
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_data_class_over_pair_triple/bad/SearchResult.kt
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_data_class_over_pair_triple/good/SearchResult.kt
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_elvis_for_nullable_default/bad/PaymentService.kt
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_elvis_for_nullable_default/good/PaymentService.kt
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_identity_operators/bad/cart_service.js
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_identity_operators/good/cart_service.js
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_immutable_collection_interfaces/bad/ShoppingCart.kt
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_immutable_collection_interfaces/good/ShoppingCart.kt
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_isinstance_not_type_comparison/bad/event_dispatcher.py
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_isinstance_not_type_comparison/good/event_dispatcher.py
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_optional_for_nullable_param/bad/user_repository.py
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_optional_for_nullable_param/good/user_repository.py
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_return_type_declaration/bad/OrderService.php
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_return_type_declaration/good/OrderService.php
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_safe_call_over_null_check/bad/OrderManager.kt
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_safe_call_over_null_check/good/OrderManager.kt
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_short_type_keywords/bad/ProductCatalog.php
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_short_type_keywords/good/ProductCatalog.php
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_type_declarations_on_parameters/bad/UserRepository.php
 create mode 100644 priv/combined_metrics/samples/type_and_value/uses_type_declarations_on_parameters/good/UserRepository.php
 create mode 100644 priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/bad/users.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/bad/users.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/bad/users.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/config.yml
 create mode 100644 priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/good/users.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/good/users.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/good/users.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/collection_name_is_plural/bad/catalog.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/collection_name_is_plural/bad/catalog.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/collection_name_is_plural/bad/catalog.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/collection_name_is_plural/config.yml
 create mode 100644 priv/combined_metrics/samples/variable_naming/collection_name_is_plural/good/catalog.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/collection_name_is_plural/good/catalog.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/collection_name_is_plural/good/catalog.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/bad/matrix.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/bad/matrix.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/bad/matrix.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/config.yml
 create mode 100644 priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/good/matrix.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/good/matrix.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/good/matrix.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_contains_and/bad/checkout.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_contains_and/bad/checkout.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_contains_and/bad/checkout.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_contains_and/config.yml
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_contains_and/good/checkout.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_contains_and/good/checkout.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_contains_and/good/checkout.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/bad/report.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/bad/report.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/bad/report.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/config.yml
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/good/report.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/good/report.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/good/report.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_abbreviation/bad/api_client.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_abbreviation/bad/api_client.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_abbreviation/bad/api_client.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_abbreviation/config.yml
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_abbreviation/good/api_client.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_abbreviation/good/api_client.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_abbreviation/good/api_client.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_generic/bad/orders.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_generic/bad/orders.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_generic/bad/orders.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_generic/config.yml
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_generic/good/orders.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_generic/good/orders.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_generic/good/orders.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_number_like/bad/pipeline.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_number_like/bad/pipeline.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_number_like/bad/pipeline.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_number_like/config.yml
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_number_like/good/pipeline.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_number_like/good/pipeline.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_number_like/good/pipeline.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_single_letter/bad/calculator.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_single_letter/bad/calculator.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_single_letter/bad/calculator.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_single_letter/config.yml
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_single_letter/good/calculator.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_single_letter/good/calculator.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_single_letter/good/calculator.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_too_long/bad/session.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_too_long/bad/session.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_too_long/bad/session.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_too_long/config.yml
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_too_long/good/session.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_too_long/good/session.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_too_long/good/session.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_too_short/bad/contact.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_too_short/bad/contact.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_too_short/bad/contact.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_too_short/config.yml
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_too_short/good/contact.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_too_short/good/contact.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/name_is_too_short/good/contact.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/negated_boolean_name/bad/validator.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/negated_boolean_name/bad/validator.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/negated_boolean_name/bad/validator.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/negated_boolean_name/config.yml
 create mode 100644 priv/combined_metrics/samples/variable_naming/negated_boolean_name/good/validator.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/negated_boolean_name/good/validator.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/negated_boolean_name/good/validator.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/no_hungarian_notation/bad/inventory.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/no_hungarian_notation/bad/inventory.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/no_hungarian_notation/bad/inventory.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/no_hungarian_notation/config.yml
 create mode 100644 priv/combined_metrics/samples/variable_naming/no_hungarian_notation/good/inventory.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/no_hungarian_notation/good/inventory.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/no_hungarian_notation/good/inventory.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/bad/config.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/bad/config.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/bad/config.rb
 create mode 100644 priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/config.yml
 create mode 100644 priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/good/config.ex
 create mode 100644 priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/good/config.js
 create mode 100644 priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/good/config.rb
 create mode 100644 priv/combined_metrics/scope_and_assignment.yml
 create mode 100644 priv/combined_metrics/testing.yml
 create mode 100644 priv/combined_metrics/type_and_value.yml
 create mode 100644 priv/combined_metrics/variable_naming.yml
 create mode 100644 test/codeqa/combined_metrics/file_scorer_test.exs
 create mode 100644 test/codeqa/combined_metrics/sample_runner_test.exs

diff --git a/lib/codeqa/combined_metrics/category.ex b/lib/codeqa/combined_metrics/category.ex
new file mode 100644
index 0000000..2467969
--- /dev/null
+++ b/lib/codeqa/combined_metrics/category.ex
@@ -0,0 +1,38 @@
+defmodule CodeQA.CombinedMetrics.Category do
+  @moduledoc """
+  Macro helper for defining combined-metric category modules.
+
+  Each category module (e.g. `VariableNaming`, `Documentation`) calls
+  `use CodeQA.CombinedMetrics.Category, yaml_path: "priv/..."`.
+
+  This injects:
+  - `@callback score(metrics :: map()) :: float()` — making the caller a behaviour
+  - `compute_score/2` — delegates to `Scorer` with the baked-in yaml path
+
+  ## Example
+
+      defmodule CodeQA.CombinedMetrics.VariableNaming do
+        use CodeQA.CombinedMetrics.Category,
+          yaml_path: "priv/combined_metrics/variable_naming.yml"
+      end
+
+  Leaf modules then declare `@behaviour CodeQA.CombinedMetrics.VariableNaming`
+  and call `VariableNaming.compute_score("key", metrics)`.
+  """
+
+  defmacro __using__(yaml_path: yaml_path) do
+    quote do
+      @callback score(metrics :: map()) :: float()
+
+      @doc """
+      Computes the score for `metric_name` using scalars from this category's YAML file.
+
+      Delegates to `CodeQA.CombinedMetrics.Scorer.compute_score/3`.
+      """
+      @spec compute_score(String.t(), map()) :: float()
+      def compute_score(metric_name, metrics) do
+        CodeQA.CombinedMetrics.Scorer.compute_score(unquote(yaml_path), metric_name, metrics)
+      end
+    end
+  end
+end
diff --git a/lib/codeqa/combined_metrics/code_smells.ex b/lib/codeqa/combined_metrics/code_smells.ex
new file mode 100644
index 0000000..5b5678a
--- /dev/null
+++ b/lib/codeqa/combined_metrics/code_smells.ex
@@ -0,0 +1,28 @@
+defmodule CodeQA.CombinedMetrics.CodeSmells do
+  @moduledoc """
+  Behaviour and submodule registry for code smell detection metrics.
+
+  Scalar weights are defined in `priv/combined_metrics/code_smells.yml`.
+  See `CodeQA.CombinedMetrics.Category` for the scoring model.
+  """
+
+  @yaml_path "priv/combined_metrics/code_smells.yml"
+
+  use CodeQA.CombinedMetrics.Category, yaml_path: @yaml_path
+
+  @behaviors @yaml_path
+             |> YamlElixir.read_from_file!()
+             |> Enum.filter(fn {_k, v} -> is_map(v) end)
+             |> Enum.map(fn {key, groups} -> {key, Map.get(groups, "_doc")} end)
+
+  for {key, doc} <- @behaviors do
+    defmodule Module.concat(CodeQA.CombinedMetrics.CodeSmells, Macro.camelize(key)) do
+      @moduledoc doc
+      @behaviour CodeQA.CombinedMetrics.CodeSmells
+      @score_key key
+      @impl true
+      def score(metrics),
+        do: CodeQA.CombinedMetrics.CodeSmells.compute_score(@score_key, metrics)
+    end
+  end
+end
diff --git a/lib/codeqa/combined_metrics/consistency.ex b/lib/codeqa/combined_metrics/consistency.ex
new file mode 100644
index 0000000..6a1474e
--- /dev/null
+++ b/lib/codeqa/combined_metrics/consistency.ex
@@ -0,0 +1,29 @@
+defmodule CodeQA.CombinedMetrics.Consistency do
+  @moduledoc """
+  Behaviour and submodule registry for codebase consistency metrics.
+
+  Covers naming style uniformity, structural patterns, and cross-file coherence.
+  Scalar weights are defined in `priv/combined_metrics/consistency.yml`.
+  See `CodeQA.CombinedMetrics.Category` for the scoring model.
+  """
+
+  @yaml_path "priv/combined_metrics/consistency.yml"
+
+  use CodeQA.CombinedMetrics.Category, yaml_path: @yaml_path
+
+  @behaviors @yaml_path
+             |> YamlElixir.read_from_file!()
+             |> Enum.filter(fn {_k, v} -> is_map(v) end)
+             |> Enum.map(fn {key, groups} -> {key, Map.get(groups, "_doc")} end)
+
+  for {key, doc} <- @behaviors do
+    defmodule Module.concat(CodeQA.CombinedMetrics.Consistency, Macro.camelize(key)) do
+      @moduledoc doc
+      @behaviour CodeQA.CombinedMetrics.Consistency
+      @score_key key
+      @impl true
+      def score(metrics),
+        do: CodeQA.CombinedMetrics.Consistency.compute_score(@score_key, metrics)
+    end
+  end
+end
diff --git a/lib/codeqa/combined_metrics/dependencies.ex b/lib/codeqa/combined_metrics/dependencies.ex
new file mode 100644
index 0000000..0cde033
--- /dev/null
+++ b/lib/codeqa/combined_metrics/dependencies.ex
@@ -0,0 +1,28 @@
+defmodule CodeQA.CombinedMetrics.Dependencies do
+  @moduledoc """
+  Behaviour and submodule registry for dependency and coupling quality metrics.
+
+  Scalar weights are defined in `priv/combined_metrics/dependencies.yml`.
+  See `CodeQA.CombinedMetrics.Category` for the scoring model.
+  """
+
+  @yaml_path "priv/combined_metrics/dependencies.yml"
+
+  use CodeQA.CombinedMetrics.Category, yaml_path: @yaml_path
+
+  @behaviors @yaml_path
+             |> YamlElixir.read_from_file!()
+             |> Enum.filter(fn {_k, v} -> is_map(v) end)
+             |> Enum.map(fn {key, groups} -> {key, Map.get(groups, "_doc")} end)
+
+  for {key, doc} <- @behaviors do
+    defmodule Module.concat(CodeQA.CombinedMetrics.Dependencies, Macro.camelize(key)) do
+      @moduledoc doc
+      @behaviour CodeQA.CombinedMetrics.Dependencies
+      @score_key key
+      @impl true
+      def score(metrics),
+        do: CodeQA.CombinedMetrics.Dependencies.compute_score(@score_key, metrics)
+    end
+  end
+end
diff --git a/lib/codeqa/combined_metrics/documentation.ex b/lib/codeqa/combined_metrics/documentation.ex
new file mode 100644
index 0000000..31abd0e
--- /dev/null
+++ b/lib/codeqa/combined_metrics/documentation.ex
@@ -0,0 +1,28 @@
+defmodule CodeQA.CombinedMetrics.Documentation do
+  @moduledoc """
+  Behaviour and submodule registry for documentation quality metrics.
+
+  Scalar weights are defined in `priv/combined_metrics/documentation.yml`.
+  See `CodeQA.CombinedMetrics.Category` for the scoring model.
+  """
+
+  @yaml_path "priv/combined_metrics/documentation.yml"
+
+  use CodeQA.CombinedMetrics.Category, yaml_path: @yaml_path
+
+  @behaviors @yaml_path
+             |> YamlElixir.read_from_file!()
+             |> Enum.filter(fn {_k, v} -> is_map(v) end)
+             |> Enum.map(fn {key, groups} -> {key, Map.get(groups, "_doc")} end)
+
+  for {key, doc} <- @behaviors do
+    defmodule Module.concat(CodeQA.CombinedMetrics.Documentation, Macro.camelize(key)) do
+      @moduledoc doc
+      @behaviour CodeQA.CombinedMetrics.Documentation
+      @score_key key
+      @impl true
+      def score(metrics),
+        do: CodeQA.CombinedMetrics.Documentation.compute_score(@score_key, metrics)
+    end
+  end
+end
diff --git a/lib/codeqa/combined_metrics/error_handling.ex b/lib/codeqa/combined_metrics/error_handling.ex
new file mode 100644
index 0000000..62e2032
--- /dev/null
+++ b/lib/codeqa/combined_metrics/error_handling.ex
@@ -0,0 +1,28 @@
+defmodule CodeQA.CombinedMetrics.ErrorHandling do
+  @moduledoc """
+  Behaviour and submodule registry for error handling quality metrics.
+
+  Scalar weights are defined in `priv/combined_metrics/error_handling.yml`.
+  See `CodeQA.CombinedMetrics.Category` for the scoring model.
+  """
+
+  @yaml_path "priv/combined_metrics/error_handling.yml"
+
+  use CodeQA.CombinedMetrics.Category, yaml_path: @yaml_path
+
+  @behaviors @yaml_path
+             |> YamlElixir.read_from_file!()
+             |> Enum.filter(fn {_k, v} -> is_map(v) end)
+             |> Enum.map(fn {key, groups} -> {key, Map.get(groups, "_doc")} end)
+
+  for {key, doc} <- @behaviors do
+    defmodule Module.concat(CodeQA.CombinedMetrics.ErrorHandling, Macro.camelize(key)) do
+      @moduledoc doc
+      @behaviour CodeQA.CombinedMetrics.ErrorHandling
+      @score_key key
+      @impl true
+      def score(metrics),
+        do: CodeQA.CombinedMetrics.ErrorHandling.compute_score(@score_key, metrics)
+    end
+  end
+end
diff --git a/lib/codeqa/combined_metrics/file_scorer.ex b/lib/codeqa/combined_metrics/file_scorer.ex
new file mode 100644
index 0000000..368d163
--- /dev/null
+++ b/lib/codeqa/combined_metrics/file_scorer.ex
@@ -0,0 +1,97 @@
+defmodule CodeQA.CombinedMetrics.FileScorer do
+  @moduledoc """
+  Scores individual files against combined metric behaviors.
+
+  Converts per-file raw metric maps to aggregate-compatible format and
+  identifies which behaviors each file most likely exhibits.
+  """
+
+  alias CodeQA.CombinedMetrics.SampleRunner
+
+  @doc """
+  Converts a single file's raw metric map to aggregate format.
+
+  Wraps each key in each group with the `mean_` prefix so the resulting
+  map is compatible with `SampleRunner.diagnose_aggregate/2`.
+
+  ## Example
+
+      iex> CodeQA.CombinedMetrics.FileScorer.file_to_aggregate(%{"halstead" => %{"tokens" => 42.0}})
+      %{"halstead" => %{"mean_tokens" => 42.0}}
+  """
+  @spec file_to_aggregate(map()) :: map()
+  def file_to_aggregate(metrics) do
+    Map.new(metrics, fn {group, keys} ->
+      prefixed_keys = Map.new(keys, fn {key, value} -> {"mean_" <> key, value} end)
+      {group, prefixed_keys}
+    end)
+  end
+
+  @doc """
+  Identifies the worst files per combined metric behavior.
+
+  For each file in `files_map`, converts its metrics to aggregate format and
+  runs `SampleRunner.diagnose_aggregate/2`. The results are collected per
+  behavior and sorted ascending by cosine similarity (most negative = worst first),
+  then truncated to `combined_top` entries.
+
+  ## Options
+
+    * `:combined_top` - number of worst files to keep per behavior (default: 2)
+
+  ## Result shape
+
+      %{
+        "function_design.no_boolean_parameter" => [
+          %{file: "lib/foo/bar.ex", cosine: -0.71},
+          %{file: "lib/foo/baz.ex", cosine: -0.44}
+        ],
+        ...
+      }
+  """
+  @spec worst_files_per_behavior(map(), keyword()) ::
+          %{
+            String.t() => [
+              %{file: String.t(), cosine: float(), top_metrics: list(), top_nodes: list()}
+            ]
+          }
+  def worst_files_per_behavior(files_map, opts \\ []) do
+    # TODO(option-c): cosine similarity is computed at file level; a line-level mapping would require computing a separate cosine score for each AST node by projecting that node's metric vector against the behavior's feature-weight vector. This is not currently possible because serialized nodes do not carry their own metric values.
+    top_n = Keyword.get(opts, :combined_top, 2)
+
+    files_map
+    |> Enum.reject(fn {_path, file_data} ->
+      file_data |> Map.get("metrics", %{}) |> map_size() == 0
+    end)
+    |> Enum.reduce(%{}, fn {path, file_data}, acc ->
+      top_nodes = CodeQA.HealthReport.Grader.top_3_nodes(Map.get(file_data, "nodes"))
+
+      file_data
+      |> Map.get("metrics", %{})
+      |> file_to_aggregate()
+      |> SampleRunner.diagnose_aggregate(top: 99_999)
+      |> Enum.reduce(acc, fn %{
+                               category: category,
+                               behavior: behavior,
+                               cosine: cosine,
+                               top_metrics: top_metrics
+                             },
+                             inner_acc ->
+        key = "#{category}.#{behavior}"
+        entry = %{file: path, cosine: cosine, top_metrics: top_metrics, top_nodes: top_nodes}
+        Map.update(inner_acc, key, [entry], &[entry | &1])
+      end)
+    end)
+    |> Map.new(fn {key, entries} ->
+      threshold = CodeQA.Config.cosine_significance_threshold()
+
+      sorted =
+        entries
+        |> Enum.filter(fn e -> e.cosine <= -threshold end)
+        |> Enum.sort_by(& &1.cosine)
+        |> Enum.take(top_n)
+
+      {key, sorted}
+    end)
+  end
+end
diff --git a/lib/codeqa/combined_metrics/file_structure.ex b/lib/codeqa/combined_metrics/file_structure.ex
new file mode 100644
index 0000000..164d3c9
--- /dev/null
+++ b/lib/codeqa/combined_metrics/file_structure.ex
@@ -0,0 +1,28 @@
+defmodule CodeQA.CombinedMetrics.FileStructure do
+  @moduledoc """
+  Behaviour and submodule registry for file structure quality metrics.
+
+  Scalar weights are defined in `priv/combined_metrics/file_structure.yml`.
+  See `CodeQA.CombinedMetrics.Category` for the scoring model.
+  """
+
+  @yaml_path "priv/combined_metrics/file_structure.yml"
+
+  use CodeQA.CombinedMetrics.Category, yaml_path: @yaml_path
+
+  @behaviors @yaml_path
+             |> YamlElixir.read_from_file!()
+             |> Enum.filter(fn {_k, v} -> is_map(v) end)
+             |> Enum.map(fn {key, groups} -> {key, Map.get(groups, "_doc")} end)
+
+  for {key, doc} <- @behaviors do
+    defmodule Module.concat(CodeQA.CombinedMetrics.FileStructure, Macro.camelize(key)) do
+      @moduledoc doc
+      @behaviour CodeQA.CombinedMetrics.FileStructure
+      @score_key key
+      @impl true
+      def score(metrics),
+        do: CodeQA.CombinedMetrics.FileStructure.compute_score(@score_key, metrics)
+    end
+  end
+end
diff --git a/lib/codeqa/combined_metrics/function_design.ex b/lib/codeqa/combined_metrics/function_design.ex
new file mode 100644
index 0000000..3e2e5e9
--- /dev/null
+++ b/lib/codeqa/combined_metrics/function_design.ex
@@ -0,0 +1,28 @@
+defmodule CodeQA.CombinedMetrics.FunctionDesign do
+  @moduledoc """
+  Behaviour and submodule registry for function design quality metrics.
+
+  Scalar weights are defined in `priv/combined_metrics/function_design.yml`.
+  See `CodeQA.CombinedMetrics.Category` for the scoring model.
+  """
+
+  @yaml_path "priv/combined_metrics/function_design.yml"
+
+  use CodeQA.CombinedMetrics.Category, yaml_path: @yaml_path
+
+  @behaviors @yaml_path
+             |> YamlElixir.read_from_file!()
+             |> Enum.filter(fn {_k, v} -> is_map(v) end)
+             |> Enum.map(fn {key, groups} -> {key, Map.get(groups, "_doc")} end)
+
+  for {key, doc} <- @behaviors do
+    defmodule Module.concat(CodeQA.CombinedMetrics.FunctionDesign, Macro.camelize(key)) do
+      @moduledoc doc
+      @behaviour CodeQA.CombinedMetrics.FunctionDesign
+      @score_key key
+      @impl true
+      def score(metrics),
+        do: CodeQA.CombinedMetrics.FunctionDesign.compute_score(@score_key, metrics)
+    end
+  end
+end
diff --git a/lib/codeqa/combined_metrics/naming_conventions.ex b/lib/codeqa/combined_metrics/naming_conventions.ex
new file mode 100644
index 0000000..f463b85
--- /dev/null
+++ b/lib/codeqa/combined_metrics/naming_conventions.ex
@@ -0,0 +1,30 @@
+defmodule CodeQA.CombinedMetrics.NamingConventions do
+  @moduledoc """
+  Behaviour and submodule registry for broader naming convention metrics.
+
+  Covers class, file, and function naming patterns not captured by
+  `VariableNaming`. Scalar weights are defined in
+  `priv/combined_metrics/naming_conventions.yml`.
+  See `CodeQA.CombinedMetrics.Category` for the scoring model.
+  """
+
+  @yaml_path "priv/combined_metrics/naming_conventions.yml"
+
+  use CodeQA.CombinedMetrics.Category, yaml_path: @yaml_path
+
+  @behaviors @yaml_path
+             |> YamlElixir.read_from_file!()
+             |> Enum.filter(fn {_k, v} -> is_map(v) end)
+             |> Enum.map(fn {key, groups} -> {key, Map.get(groups, "_doc")} end)
+
+  for {key, doc} <- @behaviors do
+    defmodule Module.concat(CodeQA.CombinedMetrics.NamingConventions, Macro.camelize(key)) do
+      @moduledoc doc
+      @behaviour CodeQA.CombinedMetrics.NamingConventions
+      @score_key key
+      @impl true
+      def score(metrics),
+        do: CodeQA.CombinedMetrics.NamingConventions.compute_score(@score_key, metrics)
+    end
+  end
+end
diff --git a/lib/codeqa/combined_metrics/sample_runner.ex b/lib/codeqa/combined_metrics/sample_runner.ex
new file mode 100644
index 0000000..4bd078c
--- /dev/null
+++ b/lib/codeqa/combined_metrics/sample_runner.ex
@@ -0,0 +1,499 @@
+defmodule CodeQA.CombinedMetrics.SampleRunner do
+  @moduledoc """
+  Discovers sample directories, analyzes them, and scores each behavior formula.
+
+  Returns structured results suitable for rendering a separation table, enabling
+  manual scalar tuning of combined metric formulas.
+  """
+
+  alias CodeQA.CombinedMetrics.Scorer
+
+  @samples_root "priv/combined_metrics/samples"
+  @yaml_dir "priv/combined_metrics"
+  @deadzone_low 0.995
+  @deadzone_high 1.005
+
+  @doc """
+  Runs all behaviors found in sample directories, optionally filtered by category.
+
+  ## Options
+
+    * `:category` - restrict to one category (e.g. `"variable_naming"`)
+    * `:verbose`  - when `true`, populates `:metric_detail` in each result
+
+  ## Result shape
+
+      %{
+        category:     "variable_naming",
+        behavior:     "name_is_generic",
+        bad_score:    0.074,
+        good_score:   0.550,
+        ratio:        7.43,
+        direction_ok: true,
+        metric_detail: [...]   # empty unless verbose: true
+      }
+  """
+  @spec run(keyword()) :: [map()]
+  def run(opts \\ []) do
+    filter_category = opts[:category]
+
+    @samples_root
+    |> File.ls!()
+    |> Enum.flat_map(fn category ->
+      Path.join([@samples_root, category])
+      |> File.ls!()
+      |> Enum.map(&{category, &1})
+    end)
+    |> Enum.filter(fn {category, behavior} ->
+      (filter_category == nil or category == filter_category) and
+        has_both_dirs?(category, behavior)
+    end)
+    |> Enum.map(fn {category, behavior} ->
+      score_behavior(category, behavior, opts)
+    end)
+  end
+
+  defp has_both_dirs?(category, behavior) do
+    File.dir?(sample_path(category, behavior, "bad")) and
+      File.dir?(sample_path(category, behavior, "good"))
+  end
+
+  defp score_behavior(category, behavior, opts) do
+    yaml_path = "priv/combined_metrics/#{category}.yml"
+    bad_agg = analyze(sample_path(category, behavior, "bad"))
+    good_agg = analyze(sample_path(category, behavior, "good"))
+
+    bad_score = Scorer.compute_score(yaml_path, behavior, bad_agg)
+    good_score = Scorer.compute_score(yaml_path, behavior, good_agg)
+    ratio = if bad_score > 0, do: good_score / bad_score, else: 0.0
+
+    base = %{
+      category: category,
+      behavior: behavior,
+      bad_score: bad_score,
+      good_score: good_score,
+      ratio: Float.round(ratio, 2),
+      direction_ok: good_score >= bad_score
+    }
+
+    if opts[:verbose] do
+      Map.put(base, :metric_detail, metric_detail(yaml_path, behavior, bad_agg, good_agg))
+    else
+      Map.put(base, :metric_detail, [])
+    end
+  end
+
+  defp analyze(dir) do
+    dir
+    |> CodeQA.Engine.Collector.collect_files()
+    |> CodeQA.Engine.Analyzer.analyze_codebase()
+    |> get_in(["codebase", "aggregate"])
+  end
+
+  defp metric_detail(yaml_path, behavior, bad_agg, good_agg) do
+    Scorer.scalars_for(yaml_path, behavior)
+    |> Enum.map(fn {{group, key}, scalar} ->
+      bad_val = Scorer.get(bad_agg, group, key)
+      good_val = Scorer.get(good_agg, group, key)
+      ratio = if bad_val > 0, do: Float.round(good_val / bad_val, 2), else: 0.0
+
+      %{
+        group: group,
+        key: key,
+        scalar: scalar,
+        bad: bad_val,
+        good: good_val,
+        ratio: ratio
+      }
+    end)
+    |> Enum.sort_by(&abs(&1.ratio - 1.0), :desc)
+  end
+
+  @doc """
+  Builds a per-behavior metric correlation report for scalar tuning.
+
+  For each behavior with sample data, computes all `mean_*` metric values for
+  both good and bad samples, then suggests normalized scalars in [-2, 2] using
+  the log-linear method:
+
+      log_diff = log(good_val) - log(bad_val)
+      suggested_scalar = 2.0 * log_diff / max(|all log_diffs| for this behavior)
+
+  The strongest signal for each behavior maps to ±2.0; all others scale
+  proportionally. This lets you paste the suggested scalars into the YAML as a
+  starting point and refine from there.
+
+  ## Result shape (keyed by "category.behavior")
+
+      %{
+        "variable_naming.name_is_generic" => %{
+          "identifier_length_variance.mean_variance" => %{
+            bad: 5.131, good: 25.109,
+            log_bad: 1.635, log_good: 3.224,
+            ratio: 4.895,
+            suggested_scalar: 2.0
+          },
+          ...
+        }
+      }
+  """
+  @spec build_metric_report(keyword()) :: map()
+  def build_metric_report(opts \\ []) do
+    filter_category = opts[:category]
+
+    @samples_root
+    |> File.ls!()
+    |> Enum.flat_map(fn category ->
+      Path.join([@samples_root, category])
+      |> File.ls!()
+      |> Enum.map(&{category, &1})
+    end)
+    |> Enum.filter(fn {category, behavior} ->
+      (filter_category == nil or category == filter_category) and
+        has_both_dirs?(category, behavior)
+    end)
+    |> Map.new(fn {category, behavior} ->
+      {"#{category}.#{behavior}", behavior_metric_table(category, behavior)}
+    end)
+  end
+
+  defp behavior_metric_table(category, behavior) do
+    bad_agg = analyze(sample_path(category, behavior, "bad"))
+    good_agg = analyze(sample_path(category, behavior, "good"))
+
+    entries =
+      Scorer.default_scalars()
+      |> Map.keys()
+      |> Enum.map(fn {group, key} ->
+        bad_val = Scorer.get(bad_agg, group, key)
+        good_val = Scorer.get(good_agg, group, key)
+        log_bad = :math.log(bad_val)
+        log_good = :math.log(good_val)
+        ratio = good_val / bad_val
+        log_diff = log_good - log_bad
+        {"#{group}.#{key}", bad_val, good_val, log_bad, log_good, ratio, log_diff}
+      end)
+
+    max_abs_log_diff =
+      entries
+      |> Enum.map(fn {_, _, _, _, _, _, ld} -> abs(ld) end)
+      |> Enum.max(fn -> 1.0 end)
+      |> max(1.0e-10)
+
+    Map.new(entries, fn {metric_key, bad_val, good_val, log_bad, log_good, ratio, log_diff} ->
+      suggested_scalar = Float.round(2.0 * log_diff / max_abs_log_diff, 4)
+
+      {metric_key,
+       %{
+         bad: r4(bad_val),
+         good: r4(good_val),
+         log_bad: r4(log_bad),
+         log_good: r4(log_good),
+         ratio: r4(ratio),
+         suggested_scalar: suggested_scalar
+       }}
+    end)
+  end
+
+  @doc """
+  Scores all combined metric behaviors against the given codebase aggregate map.
+
+  Reads all YAML config files from `priv/combined_metrics/` and returns one entry
+  per YAML category, each containing the scores for all behaviors within it.
+  Behaviors are sorted ascending by score so the lowest-scoring (worst) appear first.
+
+  ## Result shape
+
+      [
+        %{
+          category: "variable_naming",
+          name: "Variable Naming",
+          behaviors: [
+            %{behavior: "name_is_generic", score: 3.45},
+            ...
+          ]
+        },
+        ...
+      ]
+  """
+  @spec score_aggregate(map()) :: [map()]
+  def score_aggregate(aggregate) do
+    Scorer.all_yamls()
+    |> Enum.sort_by(fn {path, _} -> path end)
+    |> Enum.map(fn {yaml_path, data} ->
+      category = yaml_path |> Path.basename() |> String.trim_trailing(".yml")
+
+      behaviors =
+        data
+        |> Enum.filter(fn {_k, v} -> is_map(v) end)
+        |> Enum.map(fn {behavior, behavior_data} ->
+          log_baseline = Map.get(behavior_data, "_log_baseline", 0.0) / 1.0
+          raw_score = Scorer.compute_score(yaml_path, behavior, aggregate)
+          calibrated = :math.log(max(raw_score, 1.0e-300)) - log_baseline
+          %{behavior: behavior, score: Float.round(calibrated, 4)}
+        end)
+        |> Enum.sort_by(& &1.score)
+
+      %{category: category, name: humanize(category), behaviors: behaviors}
+    end)
+  end
+
+  defp humanize(slug) do
+    slug
+    |> String.split("_")
+    |> Enum.map_join(" ", &String.capitalize/1)
+  end
+
+  @doc """
+  Identifies the most likely code quality issues in an aggregate by cosine similarity.
+
+  For each behavior, computes the cosine similarity between its scalar weight vector
+  `s` and the file's log-metric vector `v`:
+
+      cos_sim = (s · v) / (|s| × |v|)
+
+  A negative cosine means the file's metric profile anti-aligns with what good code
+  looks like for that behavior — i.e. the file likely exhibits that anti-pattern.
+
+  Results are sorted by cosine similarity ascending (most negative = most likely
+  issue). Behaviors with no non-zero scalars (no sample data) are excluded.
+
+  ## Options
+
+    * `:top` - number of results to return (default 15)
+
+  ## Result shape
+
+      %{
+        category:  "function_design",
+        behavior:  "no_boolean_parameter",
+        cosine:    -0.83,
+        score:     -13.54,
+        top_metrics: [%{metric: "branching.mean_branching_density", contribution: -4.1}, ...]
+      }
+  """
+  @spec diagnose_aggregate(map(), keyword()) :: [map()]
+  def diagnose_aggregate(aggregate, opts \\ []) do
+    top_n = Keyword.get(opts, :top, 15)
+
+    Scorer.all_yamls()
+    |> Enum.sort_by(fn {path, _} -> path end)
+    |> Enum.flat_map(fn {yaml_path, data} ->
+      category = yaml_path |> Path.basename() |> String.trim_trailing(".yml")
+
+      data
+      |> Enum.filter(fn {_k, v} -> is_map(v) end)
+      |> Enum.flat_map(fn {behavior, behavior_data} ->
+        scalars = Scorer.scalars_for(yaml_path, behavior)
+
+        if map_size(scalars) == 0 do
+          []
+        else
+          log_baseline = Map.get(behavior_data, "_log_baseline", 0.0) / 1.0
+
+          {dot, norm_s_sq, norm_v_sq, contributions} =
+            Enum.reduce(scalars, {0.0, 0.0, 0.0, []}, fn {{group, key}, scalar},
+                                                         {d, ns, nv, contribs} ->
+              log_m = :math.log(Scorer.get(aggregate, group, key))
+              contrib = scalar * log_m
+
+              {d + contrib, ns + scalar * scalar, nv + log_m * log_m,
+               [{:"#{group}.#{key}", contrib} | contribs]}
+            end)
+
+          cos_sim =
+            if norm_s_sq > 0 and norm_v_sq > 0,
+              do: dot / (:math.sqrt(norm_s_sq) * :math.sqrt(norm_v_sq)),
+              else: 0.0
+
+          raw_score = Scorer.compute_score(yaml_path, behavior, aggregate)
+          calibrated = :math.log(max(raw_score, 1.0e-300)) - log_baseline
+
+          top_metrics =
+            contributions
+            |> Enum.sort_by(fn {_, c} -> c end)
+            |> Enum.take(5)
+            |> Enum.map(fn {metric, contribution} ->
+              %{metric: to_string(metric), contribution: Float.round(contribution, 4)}
+            end)
+
+          [
+            %{
+              category: category,
+              behavior: behavior,
+              cosine: Float.round(cos_sim, 4),
+              score: Float.round(calibrated, 4),
+              top_metrics: top_metrics
+            }
+          ]
+        end
+      end)
+    end)
+    |> Enum.sort_by(& &1.cosine)
+    |> Enum.take(top_n)
+  end
+
+  @doc """
+  Applies suggested scalars from sample analysis back to the YAML config files.
+
+  For each behavior that has sample data, rewrites its scalar entries using the
+  log-linear suggestion method. Metrics whose ratio falls in the deadzone
+  (#{@deadzone_low} ≤ ratio ≤ #{@deadzone_high}) are excluded. All non-deadzoned
+  metrics are written, even if they were not previously present in the YAML.
+
+  Behaviors without sample data are left unchanged.
+
+  Returns a list of per-category stats maps.
+  """
+  @spec apply_scalars(keyword()) :: [map()]
+  def apply_scalars(opts \\ []) do
+    report = build_metric_report(opts)
+    filter_category = opts[:category]
+
+    @yaml_dir
+    |> File.ls!()
+    |> Enum.filter(&String.ends_with?(&1, ".yml"))
+    |> Enum.filter(fn yml_file ->
+      filter_category == nil or String.trim_trailing(yml_file, ".yml") == filter_category
+    end)
+    |> Enum.sort()
+    |> Enum.map(fn yml_file ->
+      category = String.trim_trailing(yml_file, ".yml")
+      yaml_path = Path.join(@yaml_dir, yml_file)
+      {:ok, existing} = YamlElixir.read_from_file(yaml_path)
+
+      {updated_yaml, stats} = apply_to_category(existing, category, report)
+      File.write!(yaml_path, format_yaml(updated_yaml))
+
+      Map.put(stats, :category, category)
+    end)
+  end
+
+  defp apply_to_category(existing, category, report) do
+    existing
+    |> Enum.filter(fn {_k, v} -> is_map(v) end)
+    |> Enum.reduce({%{}, %{updated: 0, deadzoned: 0, skipped: 0}}, fn
+      {behavior, current_groups}, {acc_yaml, stats} ->
+        report_key = "#{category}.#{behavior}"
+        doc = read_behavior_doc(category, behavior)
+
+        case Map.get(report, report_key) do
+          nil ->
+            groups = maybe_put_doc(current_groups, doc)
+            {Map.put(acc_yaml, behavior, groups), Map.update!(stats, :skipped, &(&1 + 1))}
+
+          metrics ->
+            {new_groups, log_baseline, n_updated, n_deadzoned} = groups_from_report(metrics)
+            # Fall back to current groups if everything was deadzoned
+            groups =
+              if(map_size(new_groups) > 0, do: new_groups, else: current_groups)
+              |> Map.put("_log_baseline", Float.round(log_baseline, 6))
+              |> maybe_put_doc(doc)
+
+            {Map.put(acc_yaml, behavior, groups),
+             %{
+               stats
+               | updated: stats.updated + n_updated,
+                 deadzoned: stats.deadzoned + n_deadzoned
+             }}
+        end
+    end)
+  end
+
+  defp read_behavior_doc(category, behavior) do
+    config_path = Path.join([@samples_root, category, behavior, "config.yml"])
+
+    case File.read(config_path) do
+      {:ok, content} ->
+        case YamlElixir.read_from_string(content) do
+          {:ok, %{"doc" => doc}} when is_binary(doc) -> doc
+          _ -> nil
+        end
+
+      _ ->
+        nil
+    end
+  end
+
+  defp maybe_put_doc(groups, nil), do: groups
+  defp maybe_put_doc(groups, doc), do: Map.put(groups, "_doc", doc)
+
+  defp groups_from_report(metrics) do
+    Enum.reduce(metrics, {%{}, 0.0, 0, 0}, fn {metric_key, data},
+                                              {groups, log_baseline, n_updated, n_deadzoned} ->
+      [group, key] = String.split(metric_key, ".", parts: 2)
+
+      if deadzone?(data.ratio) do
+        {groups, log_baseline, n_updated, n_deadzoned + 1}
+      else
+        new_groups =
+          Map.update(
+            groups,
+            group,
+            %{key => data.suggested_scalar},
+            &Map.put(&1, key, data.suggested_scalar)
+          )
+
+        # Baseline: expected log score at the geometric mean of good/bad sample values
+        geo_mean = :math.sqrt(max(data.bad, 1.0e-10) * max(data.good, 1.0e-10))
+        new_baseline = log_baseline + data.suggested_scalar * :math.log(geo_mean)
+        {new_groups, new_baseline, n_updated + 1, n_deadzoned}
+      end
+    end)
+  end
+
+  defp deadzone?(ratio), do: ratio >= @deadzone_low and ratio <= @deadzone_high
+
+  defp format_yaml(data) do
+    lines =
+      data
+      |> Enum.sort_by(fn {behavior, _} -> behavior end)
+      |> Enum.flat_map(fn {behavior, groups} ->
+        doc_line =
+          case Map.get(groups, "_doc") do
+            nil -> []
+            doc -> ["  _doc: #{inspect(doc)}"]
+          end
+
+        baseline_line =
+          case Map.get(groups, "_log_baseline") do
+            nil -> []
+            val -> ["  _log_baseline: #{fmt_scalar(val)}"]
+          end
+
+        fix_hint_line =
+          case Map.get(groups, "_fix_hint") do
+            nil -> []
+            hint -> ["  _fix_hint: #{inspect(hint)}"]
+          end
+
+        group_lines =
+          groups
+          |> Enum.filter(fn {k, v} ->
+            k not in ["_doc", "_log_baseline", "_fix_hint"] and is_map(v)
+          end)
+          |> Enum.sort_by(fn {group, _} -> group end)
+          |> Enum.flat_map(fn {group, keys} ->
+            key_lines =
+              keys
+              |> Enum.sort_by(fn {key, _} -> key end)
+              |> Enum.map(fn {key, scalar} -> "    #{key}: #{fmt_scalar(scalar)}" end)
+
+            ["  #{group}:" | key_lines]
+          end)
+
+        ["#{behavior}:" | doc_line] ++ fix_hint_line ++ baseline_line ++ group_lines ++ [""]
+      end)
+
+    Enum.join(lines, "\n") <> "\n"
+  end
+
+  defp fmt_scalar(f) when is_float(f), do: :erlang.float_to_binary(f, decimals: 4)
+  defp fmt_scalar(n) when is_integer(n), do: "#{n}.0"
+
+  defp r4(f), do: Float.round(f / 1.0, 4)
+
+  defp sample_path(category, behavior, kind) do
+    Path.join([@samples_root, category, behavior, kind])
+  end
+end
diff --git a/lib/codeqa/combined_metrics/scope_and_assignment.ex b/lib/codeqa/combined_metrics/scope_and_assignment.ex
new file mode 100644
index 0000000..ddb1d11
--- /dev/null
+++ b/lib/codeqa/combined_metrics/scope_and_assignment.ex
@@ -0,0 +1,28 @@
+defmodule CodeQA.CombinedMetrics.ScopeAndAssignment do
+  @moduledoc """
+  Behaviour and submodule registry for variable scope and assignment quality metrics.
+
+  Scalar weights are defined in `priv/combined_metrics/scope_and_assignment.yml`.
+  See `CodeQA.CombinedMetrics.Category` for the scoring model.
+  """
+
+  @yaml_path "priv/combined_metrics/scope_and_assignment.yml"
+
+  use CodeQA.CombinedMetrics.Category, yaml_path: @yaml_path
+
+  @behaviors @yaml_path
+             |> YamlElixir.read_from_file!()
+             |> Enum.filter(fn {_k, v} -> is_map(v) end)
+             |> Enum.map(fn {key, groups} -> {key, Map.get(groups, "_doc")} end)
+
+  for {key, doc} <- @behaviors do
+    defmodule Module.concat(CodeQA.CombinedMetrics.ScopeAndAssignment, Macro.camelize(key)) do
+      @moduledoc doc
+      @behaviour CodeQA.CombinedMetrics.ScopeAndAssignment
+      @score_key key
+      @impl true
+      def score(metrics),
+        do: CodeQA.CombinedMetrics.ScopeAndAssignment.compute_score(@score_key, metrics)
+    end
+  end
+end
diff --git a/lib/codeqa/combined_metrics/scorer.ex b/lib/codeqa/combined_metrics/scorer.ex
new file mode 100644
index 0000000..29b6d2f
--- /dev/null
+++ b/lib/codeqa/combined_metrics/scorer.ex
@@ -0,0 +1,83 @@
+defmodule CodeQA.CombinedMetrics.Scorer do
+  @moduledoc """
+  Pure computation engine for combined metric formulas.
+
+  Loads scalar weights from a YAML file and computes a score as a product of
+  metric powers:
+
+      score = metric_a ^ s_a  *  metric_b ^ s_b  *  ...
+
+  Scalars of 0.0 contribute nothing (x^0 = 1.0) and are the default for all
+  metric keys not listed in the YAML. Negative scalars penalise a metric
+  (higher raw value → lower score).
+  """
+
+  @doc """
+  Computes the score for `metric_name` using scalars from `yaml_path`.
+
+  `metrics` is the `codebase.aggregate` map returned by `codeqa analyze`.
+  """
+  @spec compute_score(String.t(), String.t(), map()) :: float()
+  def compute_score(yaml_path, metric_name, metrics) do
+    default_scalars()
+    |> Map.merge(scalars_for(yaml_path, metric_name))
+    |> Enum.reduce(1.0, fn {{group, key}, scalar}, acc ->
+      acc * pow(get(metrics, group, key), scalar)
+    end)
+  end
+
+  @doc "Returns the non-zero scalar overrides for `metric_name` from `yaml_path`."
+  @spec scalars_for(String.t(), String.t()) :: %{{String.t(), String.t()} => float()}
+  def scalars_for(yaml_path, metric_name) do
+    yaml_path
+    |> yaml_data()
+    |> Map.get(metric_name, %{})
+    |> Enum.flat_map(fn
+      {group, keys} when is_map(keys) ->
+        Enum.map(keys, fn {key, scalar} -> {{group, key}, scalar / 1.0} end)
+
+      _ ->
+        []
+    end)
+    |> Map.new()
+  end
+
+  @doc "Returns the full default scalar map: all registered file metric keys mapped to 0.0."
+  @spec default_scalars() :: %{{String.t(), String.t()} => float()}
+  def default_scalars do
+    CodeQA.Engine.Analyzer.build_registry().file_metrics
+    |> Enum.flat_map(fn mod ->
+      Enum.map(mod.keys(), fn key -> {{mod.name(), "mean_" <> key}, 0.0} end)
+    end)
+    |> Map.new()
+  end
+
+  @doc "Safely fetches a nested metric value, returning 1.0 if missing or non-positive."
+  @spec get(map(), String.t(), String.t()) :: float()
+  def get(metrics, group, key) do
+    case get_in(metrics, [group, key]) do
+      val when is_number(val) and val > 0 -> val / 1.0
+      _ -> 1.0
+    end
+  end
+
+  @doc "Computes `base ^ scalar`, returning 1.0 for non-positive bases."
+  @spec pow(float(), float()) :: float()
+  def pow(base, scalar) when base > 0, do: :math.pow(base, scalar)
+  def pow(_base, _scalar), do: 1.0
+
+  @yaml_dir "priv/combined_metrics"
+  @yaml_paths Path.wildcard(Path.join(@yaml_dir, "*.yml"))
+  for path <- @yaml_paths, do: @external_resource(path)
+
+  @compiled_yamls Map.new(@yaml_paths, fn path ->
+                    {:ok, data} = YamlElixir.read_from_file(path)
+                    {path, data}
+                  end)
+
+  @doc "Returns all compiled YAML data as `%{path => parsed_map}`."
+  @spec all_yamls() :: %{String.t() => map()}
+  def all_yamls, do: @compiled_yamls
+
+  defp yaml_data(yaml_path), do: Map.get(@compiled_yamls, yaml_path, %{})
+end
diff --git a/lib/codeqa/combined_metrics/testing.ex b/lib/codeqa/combined_metrics/testing.ex
new file mode 100644
index 0000000..8876453
--- /dev/null
+++ b/lib/codeqa/combined_metrics/testing.ex
@@ -0,0 +1,28 @@
+defmodule CodeQA.CombinedMetrics.Testing do
+  @moduledoc """
+  Behaviour and submodule registry for test quality metrics.
+
+  Scalar weights are defined in `priv/combined_metrics/testing.yml`.
+  See `CodeQA.CombinedMetrics.Category` for the scoring model.
+  """
+
+  @yaml_path "priv/combined_metrics/testing.yml"
+
+  use CodeQA.CombinedMetrics.Category, yaml_path: @yaml_path
+
+  @behaviors @yaml_path
+             |> YamlElixir.read_from_file!()
+             |> Enum.filter(fn {_k, v} -> is_map(v) end)
+             |> Enum.map(fn {key, groups} -> {key, Map.get(groups, "_doc")} end)
+
+  for {key, doc} <- @behaviors do
+    defmodule Module.concat(CodeQA.CombinedMetrics.Testing, Macro.camelize(key)) do
+      @moduledoc doc
+      @behaviour CodeQA.CombinedMetrics.Testing
+      @score_key key
+      @impl true
+      def score(metrics),
+        do: CodeQA.CombinedMetrics.Testing.compute_score(@score_key, metrics)
+    end
+  end
+end
diff --git a/lib/codeqa/combined_metrics/type_and_value.ex b/lib/codeqa/combined_metrics/type_and_value.ex
new file mode 100644
index 0000000..5f76a8a
--- /dev/null
+++ b/lib/codeqa/combined_metrics/type_and_value.ex
@@ -0,0 +1,28 @@
+defmodule CodeQA.CombinedMetrics.TypeAndValue do
+  @moduledoc """
+  Behaviour and submodule registry for type safety and value assignment quality metrics.
+
+  Scalar weights are defined in `priv/combined_metrics/type_and_value.yml`.
+  See `CodeQA.CombinedMetrics.Category` for the scoring model.
+  """
+
+  @yaml_path "priv/combined_metrics/type_and_value.yml"
+
+  use CodeQA.CombinedMetrics.Category, yaml_path: @yaml_path
+
+  @behaviors @yaml_path
+             |> YamlElixir.read_from_file!()
+             |> Enum.filter(fn {_k, v} -> is_map(v) end)
+             |> Enum.map(fn {key, groups} -> {key, Map.get(groups, "_doc")} end)
+
+  for {key, doc} <- @behaviors do
+    defmodule Module.concat(CodeQA.CombinedMetrics.TypeAndValue, Macro.camelize(key)) do
+      @moduledoc doc
+      @behaviour CodeQA.CombinedMetrics.TypeAndValue
+      @score_key key
+      @impl true
+      def score(metrics),
+        do: CodeQA.CombinedMetrics.TypeAndValue.compute_score(@score_key, metrics)
+    end
+  end
+end
diff --git a/lib/codeqa/combined_metrics/variable_naming.ex b/lib/codeqa/combined_metrics/variable_naming.ex
new file mode 100644
index 0000000..c846414
--- /dev/null
+++ b/lib/codeqa/combined_metrics/variable_naming.ex
@@ -0,0 +1,28 @@
+defmodule CodeQA.CombinedMetrics.VariableNaming do
+  @moduledoc """
+  Behaviour and submodule registry for variable naming quality metrics.
+
+  Scalar weights are defined in `priv/combined_metrics/variable_naming.yml`.
+  See `CodeQA.CombinedMetrics.Category` for the scoring model.
+  """
+
+  @yaml_path "priv/combined_metrics/variable_naming.yml"
+
+  use CodeQA.CombinedMetrics.Category, yaml_path: @yaml_path
+
+  @behaviors @yaml_path
+             |> YamlElixir.read_from_file!()
+             |> Enum.filter(fn {_k, v} -> is_map(v) end)
+             |> Enum.map(fn {key, groups} -> {key, Map.get(groups, "_doc")} end)
+
+  for {key, doc} <- @behaviors do
+    defmodule Module.concat(CodeQA.CombinedMetrics.VariableNaming, Macro.camelize(key)) do
+      @moduledoc doc
+      @behaviour CodeQA.CombinedMetrics.VariableNaming
+      @score_key key
+      @impl true
+      def score(metrics),
+        do: CodeQA.CombinedMetrics.VariableNaming.compute_score(@score_key, metrics)
+    end
+  end
+end
diff --git a/lib/mix/tasks/codeqa/sample_report.ex b/lib/mix/tasks/codeqa/sample_report.ex
new file mode 100644
index 0000000..0246777
--- /dev/null
+++ b/lib/mix/tasks/codeqa/sample_report.ex
@@ -0,0 +1,192 @@
+defmodule Mix.Tasks.Codeqa.SampleReport do
+  use Mix.Task
+
+  @shortdoc "Evaluates combined metric formulas against good/bad sample code"
+
+  @moduledoc """
+  Runs combined metric formulas against sample files and prints a separation table.
+
+      mix codeqa.sample_report
+      mix codeqa.sample_report --category variable_naming
+      mix codeqa.sample_report --verbose
+      mix codeqa.sample_report --output results.json
+      mix codeqa.sample_report --apply-scalars
+      mix codeqa.sample_report --file path/to/file.ex
+
+  A ratio ≥ 2x means the formula meaningfully separates good from bad code.
+  A ratio < 1.5x is flagged as weak; < 1.0x is marked ✗ (wrong direction).
+
+  `--apply-scalars` rewrites the YAML config files with suggested scalars derived
+  from the sample data. Metrics with ratio in the deadzone (0.995–1.005) are
+  excluded. All non-deadzoned metrics are written, including ones not previously
+  in the YAML.
+
+  `--file` analyzes a single file or directory and prints all combined metric
+  behavior scores, grouped by category, sorted worst-first.
+  """
+
+  @switches [
+    category: :string,
+    verbose: :boolean,
+    output: :string,
+    report: :string,
+    apply_scalars: :boolean,
+    file: :string,
+    top: :integer
+  ]
+
+  def run(args) do
+    Mix.Task.run("app.start")
+    {opts, _, _} = OptionParser.parse(args, switches: @switches)
+
+    results = CodeQA.CombinedMetrics.SampleRunner.run(opts)
+
+    results
+    |> Enum.group_by(& &1.category)
+    |> Enum.each(&print_category(&1, opts))
+
+    if path = opts[:output] do
+      File.write!(path, Jason.encode!(results, pretty: true))
+      IO.puts("\nResults written to #{path}")
+    end
+
+    if path = opts[:report] do
+      report = CodeQA.CombinedMetrics.SampleRunner.build_metric_report(opts)
+      File.write!(path, Jason.encode!(report, pretty: true))
+      IO.puts("\nMetric report written to #{path}")
+    end
+
+    if opts[:apply_scalars] do
+      stats = CodeQA.CombinedMetrics.SampleRunner.apply_scalars(opts)
+      IO.puts("\nApplied scalars to YAML configs:")
+      Enum.each(stats, &print_scalar_stats/1)
+    end
+
+    if path = opts[:file] do
+      print_file_scores(path, opts)
+    end
+  end
+
+  defp print_category({category, results}, opts) do
+    IO.puts("\n#{category}")
+    IO.puts(String.duplicate("-", 75))
+
+    IO.puts(
+      "  " <>
+        pad("behavior", 35) <>
+        pad("bad", 9) <>
+        pad("good", 9) <>
+        pad("ratio", 13) <>
+        "ok?"
+    )
+
+    Enum.each(results, &print_row(&1, opts))
+  end
+
+  defp print_row(r, opts) do
+    ratio_str =
+      "#{r.ratio}x" <>
+        cond do
+          not r.direction_ok -> ""
+          r.ratio < 1.5 -> " (weak)"
+          true -> ""
+        end
+
+    ok = if r.direction_ok, do: "✓", else: "✗"
+
+    IO.puts(
+      "  " <>
+        pad(r.behavior, 35) <>
+        pad(fmt(r.bad_score), 9) <>
+        pad(fmt(r.good_score), 9) <>
+        pad(ratio_str, 13) <>
+        ok
+    )
+
+    if opts[:verbose] do
+      Enum.each(r.metric_detail, fn m ->
+        scalar_str = if m.scalar >= 0, do: "+#{m.scalar}", else: "#{m.scalar}"
+
+        IO.puts(
+          "      " <>
+            pad("#{m.group}.#{m.key}", 45) <>
+            pad(scalar_str, 7) <>
+            pad(fmt(m.bad), 8) <>
+            pad(fmt(m.good), 8) <>
+            "#{m.ratio}x"
+        )
+      end)
+    end
+  end
+
+  defp print_file_scores(path, opts) do
+    expanded = Path.expand(path)
+
+    files =
+      cond do
+        File.dir?(expanded) ->
+          CodeQA.Engine.Collector.collect_files(expanded)
+
+        File.regular?(expanded) ->
+          %{Path.basename(expanded) => File.read!(expanded)}
+
+        true ->
+          IO.puts("\nPath not found: #{path}")
+          nil
+      end
+
+    if files && map_size(files) > 0 do
+      IO.puts("\nAnalyzing #{map_size(files)} file(s) at: #{path}")
+
+      aggregate =
+        files
+        |> CodeQA.Engine.Analyzer.analyze_codebase()
+        |> get_in(["codebase", "aggregate"])
+
+      top_n = opts[:top] || 15
+      issues = CodeQA.CombinedMetrics.SampleRunner.diagnose_aggregate(aggregate, top: top_n)
+      IO.puts("\nTop #{top_n} likely issues (by cosine similarity):")
+      IO.puts(String.duplicate("-", 75))
+      IO.puts("  " <> pad("behavior", 38) <> pad("cosine", 9) <> "score")
+      Enum.each(issues, &print_issue_row/1)
+
+      IO.puts("\nFull breakdown by category:")
+      combined = CodeQA.CombinedMetrics.SampleRunner.score_aggregate(aggregate)
+      IO.puts("")
+      Enum.each(combined, &print_combined_category/1)
+    else
+      IO.puts("\nNo supported files found at: #{path}")
+    end
+  end
+
+  defp print_issue_row(%{category: cat, behavior: b, cosine: cos, score: s, top_metrics: metrics}) do
+    IO.puts("  " <> pad("#{cat}.#{b}", 38) <> pad(fmt(cos), 9) <> fmt(s))
+
+    Enum.each(metrics, fn %{metric: m, contribution: c} ->
+      IO.puts("      " <> pad(m, 44) <> fmt(c))
+    end)
+  end
+
+  defp print_combined_category(%{name: name, behaviors: behaviors}) do
+    IO.puts(name)
+    IO.puts(String.duplicate("-", 60))
+
+    IO.puts("  " <> pad("behavior", 40) <> "score")
+
+    behaviors
+    |> Enum.sort_by(& &1.score)
+    |> Enum.each(fn %{behavior: b, score: s} ->
+      flag = if s < 0.0, do: "  ⚠", else: ""
+      IO.puts("  " <> pad(b, 40) <> fmt(s) <> flag)
+    end)
+
+    IO.puts("")
+  end
+
+  defp print_scalar_stats(%{category: cat, updated: u, deadzoned: d, skipped: s}) do
+    IO.puts("  #{pad(cat, 30)}  #{u} written  #{d} deadzoned  #{s} skipped (no samples)")
+  end
+
+  defp fmt(f), do: :erlang.float_to_binary(f / 1, decimals: 4)
+  defp pad(s, n), do: String.pad_trailing(to_string(s), n)
+end
diff --git a/lib/mix/tasks/codeqa/signal_debug.ex b/lib/mix/tasks/codeqa/signal_debug.ex
new file mode 100644
index 0000000..3852dec
--- /dev/null
+++ b/lib/mix/tasks/codeqa/signal_debug.ex
@@ -0,0 +1,183 @@
+defmodule Mix.Tasks.Codeqa.SignalDebug do
+  use Mix.Task
+
+  @shortdoc "Shows structural signal emissions when splitting a file into blocks"
+
+  @moduledoc """
+  Runs each structural signal over a file and prints its emissions step by step.
+
+      mix codeqa.signal_debug path/to/file.ex
+      mix codeqa.signal_debug path/to/file.py --signal keyword
+      mix codeqa.signal_debug path/to/file.ex --show-tokens
+
+  Options:
+    --signal <name>    Only show a specific signal (e.g. keyword, blank, bracket)
+    --show-tokens      Print the full token list before signal output
+  """
+
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.Language
+
+  alias CodeQA.AST.Signals.Structural.{
+    AccessModifierSignal,
+    BlankLineSignal,
+    BracketSignal,
+    BranchSplitSignal,
+    ColonIndentSignal,
+    CommentDividerSignal,
+    KeywordSignal,
+    SQLBlockSignal,
+    TripleQuoteSignal
+  }
+
+  @switches [signal: :string, show_tokens: :boolean]
+
+  @all_signals [
+    %TripleQuoteSignal{},
+    %BlankLineSignal{},
+    %KeywordSignal{},
+    %BranchSplitSignal{},
+    %AccessModifierSignal{},
+    %CommentDividerSignal{},
+    %SQLBlockSignal{},
+    %BracketSignal{},
+    %ColonIndentSignal{}
+  ]
+
+  @impl Mix.Task
+  def run(args) do
+    {opts, positional, _} = OptionParser.parse(args, strict: @switches)
+
+    path =
+      case positional do
+        [p | _] -> p
+        [] -> Mix.raise("Usage: mix codeqa.signal_debug <file> [--signal <name>] [--show-tokens]")
+      end
+
+    unless File.exists?(path), do: Mix.raise("File not found: #{path}")
+
+    content = File.read!(path)
+    lang_mod = Language.detect(path)
+    tokens = TokenNormalizer.normalize_structural(content)
+    lines = String.split(content, "\n")
+
+    Mix.shell().info("File: #{path}")
+    Mix.shell().info("Language: #{lang_mod.name()}")
+    Mix.shell().info("Tokens: #{length(tokens)}")
+    Mix.shell().info("Lines: #{length(lines)}")
+    Mix.shell().info("")
+
+    if opts[:show_tokens] do
+      print_tokens(tokens)
+    end
+
+    signals = filter_signals(@all_signals, opts[:signal])
+
+    emissions_per_signal =
+      SignalStream.run(tokens, signals, lang_mod)
+
+    Enum.zip(signals, emissions_per_signal)
+    |> Enum.each(fn {signal, emissions} ->
+      print_signal_section(signal, emissions, tokens, lines)
+    end)
+  end
+
+  defp filter_signals(signals, nil), do: signals
+
+  defp filter_signals(signals, name_filter) do
+    Enum.filter(signals, fn signal ->
+      module_name =
+        signal.__struct__
+        |> Module.split()
+        |> List.last()
+        |> String.downcase()
+
+      String.contains?(module_name, String.downcase(name_filter))
+    end)
+  end
+
+  defp print_tokens(tokens) do
+    Mix.shell().info("=== TOKEN LIST ===")
+
+    tokens
+    |> Enum.with_index()
+    |> Enum.each(fn {token, idx} ->
+      Mix.shell().info(
+        "  [#{idx}] line #{token.line} col #{token.col}  #{inspect(token.kind)}  #{inspect(token.content)}"
+      )
+    end)
+
+    Mix.shell().info("")
+  end
+
+  defp print_signal_section(signal, emissions, tokens, lines) do
+    name = signal.__struct__ |> Module.split() |> List.last()
+    separator = String.duplicate("─", 60)
+
+    Mix.shell().info(separator)
+    Mix.shell().info("SIGNAL: #{name}")
+    Mix.shell().info("Emissions: #{length(emissions)}")
+    Mix.shell().info("")
+
+    if Enum.empty?(emissions) do
+      Mix.shell().info("  (no emissions)")
+    else
+      Enum.each(emissions, fn {_source, group, emission_name, value} ->
+        print_emission(group, emission_name, value, tokens, lines)
+      end)
+    end
+
+    Mix.shell().info("")
+  end
+
+  defp print_emission(:split, name, token_idx, tokens, lines) do
+    token = Enum.at(tokens, token_idx)
+
+    line_num = token && token.line
+    line_src = line_num && Enum.at(lines, line_num - 1)
+
+    Mix.shell().info("  [SPLIT :#{name}]  token[#{token_idx}] → line #{line_num}")
+
+    if line_src do
+      Mix.shell().info("    #{String.trim_trailing(line_src)}")
+    end
+
+    if token do
+      Mix.shell().info("    ^ #{inspect(token.kind)} #{inspect(token.content)}")
+    end
+
+    Mix.shell().info("")
+  end
+
+  defp print_emission(:enclosure, name, {start_idx, end_idx}, tokens, lines) do
+    start_token = Enum.at(tokens, start_idx)
+    end_token = Enum.at(tokens, end_idx)
+
+    start_line = start_token && start_token.line
+    end_line = end_token && end_token.line
+
+    Mix.shell().info(
+      "  [ENCLOSURE :#{name}]  tokens[#{start_idx}..#{end_idx}]  lines #{start_line}–#{end_line}"
+    )
+
+    if start_line do
+      Mix.shell().info(
+        "    open:  #{inspect(Enum.at(lines, start_line - 1) |> String.trim_trailing())}"
+      )
+    end
+
+    if end_line && end_line != start_line do
+      Mix.shell().info(
+        "    close: #{inspect(Enum.at(lines, end_line - 1) |> String.trim_trailing())}"
+      )
+    end
+
+    Mix.shell().info("")
+  end
+
+  defp print_emission(group, name, value, _tokens, _lines) do
+    Mix.shell().info("  [:#{group} :#{name}]  #{inspect(value)}")
+    Mix.shell().info("")
+  end
+end
diff --git a/priv/combined_metrics/code_smells.yml b/priv/combined_metrics/code_smells.yml
new file mode 100644
index 0000000..d8fe1b8
--- /dev/null
+++ b/priv/combined_metrics/code_smells.yml
@@ -0,0 +1,540 @@
+consistent_string_quote_style:
+  _doc: "Files should use a single, consistent string quoting style throughout."
+  _fix_hint: "Use a single quote style (e.g., double quotes) consistently throughout the file"
+  _log_baseline: -18.9505
+  branching:
+    mean_branching_density: 0.0243
+    mean_non_blank_count: -0.0248
+  brevity:
+    mean_sample_size: -0.0656
+  casing_entropy:
+    mean_entropy: -0.0493
+    mean_pascal_case_count: -0.1743
+    mean_snake_case_count: -0.0451
+  compression:
+    mean_raw_bytes: -0.0672
+    mean_redundancy: 0.0207
+    mean_unique_line_ratio: -0.0338
+    mean_zlib_bytes: -0.1085
+    mean_zlib_ratio: 0.0413
+  entropy:
+    mean_char_max_entropy: -0.0077
+    mean_token_entropy: -0.0178
+    mean_token_max_entropy: -0.0141
+    mean_total_tokens: -0.0783
+    mean_vocab_size: -0.0656
+  function_metrics:
+    mean_avg_function_lines: -0.0226
+    mean_max_function_lines: -0.0644
+  halstead:
+    mean_N1_total_operators: -0.1087
+    mean_N2_total_operands: -0.2297
+    mean_difficulty: -0.1017
+    mean_effort: -0.2949
+    mean_estimated_bugs: -0.1934
+    mean_length: -0.1541
+    mean_n1_unique_operators: -0.0790
+    mean_n2_unique_operands: -0.2071
+    mean_time_to_implement_seconds: -0.2949
+    mean_vocabulary: -0.1721
+    mean_volume: -0.1933
+  heaps:
+    mean_k: -0.0368
+    mean_r_squared: -0.0080
+  identifier_length_variance:
+    mean_mean: 0.0058
+    mean_std_dev: 0.0158
+    mean_variance: 0.0316
+  indentation:
+    mean_blank_line_ratio: 0.0205
+    mean_variance: 0.0246
+  line_patterns:
+    mean_blank_line_ratio: 0.0205
+    mean_string_literal_ratio: -0.1616
+    mean_unique_line_ratio: -0.0365
+  magic_number_density:
+    mean_string_literal_ratio: 0.3018
+  near_duplicate_blocks_file:
+    mean_sub_block_count: -0.1804
+  ngram:
+    mean_bigram_hapax_fraction: -0.0101
+    mean_bigram_repeated_unique: -0.0915
+    mean_bigram_repetition_rate: 0.0277
+    mean_bigram_total: -0.0785
+    mean_bigram_unique: -0.1146
+    mean_trigram_repeated_unique: -0.1104
+    mean_trigram_repetition_rate: 0.0499
+    mean_trigram_total: -0.0787
+    mean_trigram_unique: -0.1182
+  punctuation_density:
+    mean_arrow_density: 0.0674
+    mean_bracket_nonalpha_prefix_count: 1.0103
+    mean_bracket_nonalpha_suffix_count: 2.0000
+    mean_colon_suffix_density: 0.0458
+    mean_dot_count: -0.1743
+    mean_exclamation_density: 0.0424
+    mean_id_nonalpha_suffix_density: 0.0783
+  readability:
+    mean_avg_line_length: -0.0444
+    mean_avg_tokens_per_line: -0.0535
+    mean_flesch_adapted: 0.0046
+    mean_fog_adapted: -0.0301
+    mean_total_lines: -0.0248
+  symbol_density:
+    mean_density: -0.0325
+    mean_distinct_symbol_types: -0.0966
+    mean_symbol_count: -0.0999
+  vocabulary:
+    mean_mattr: -0.0304
+    mean_raw_ttr: -0.0079
+    mean_total_identifiers: -0.0589
+    mean_unique_identifiers: -0.0668
+  vowel_density:
+    mean_total_chars: -0.0531
+  zipf:
+    mean_total_tokens: -0.0783
+    mean_vocab_size: -0.0656
+
+no_dead_code_after_return:
+  _doc: "There should be no unreachable statements after a return or early exit."
+  _fix_hint: "Remove unreachable statements after return/raise/exit — they can never execute"
+  _log_baseline: -57.2281
+  branching:
+    mean_branch_count: -2.0000
+    mean_branching_density: -1.4201
+    mean_non_blank_count: -0.5815
+  brevity:
+    mean_sample_size: -0.2610
+  casing_entropy:
+    mean_entropy: -0.2355
+    mean_other_count: -0.8708
+    mean_pascal_case_count: -0.5752
+    mean_snake_case_count: -0.3869
+  compression:
+    mean_raw_bytes: -0.4531
+    mean_redundancy: -0.0467
+    mean_zlib_bytes: -0.3558
+    mean_zlib_ratio: -0.0974
+  entropy:
+    mean_char_entropy: 0.0250
+    mean_char_max_entropy: -0.0205
+    mean_char_normalized: 0.0455
+    mean_token_entropy: -0.0475
+    mean_token_max_entropy: -0.0575
+    mean_token_normalized: 0.0099
+    mean_total_tokens: -0.3093
+    mean_vocab_size: -0.2610
+  function_metrics:
+    mean_avg_function_lines: -0.4255
+    mean_avg_param_count: 0.1143
+    mean_function_count: -0.1143
+    mean_max_function_lines: -0.5062
+  halstead:
+    mean_N1_total_operators: -0.2185
+    mean_N2_total_operands: -0.4051
+    mean_difficulty: -0.1769
+    mean_effort: -0.5126
+    mean_estimated_bugs: -0.3357
+    mean_length: -0.2795
+    mean_n1_unique_operators: -0.0857
+    mean_n2_unique_operands: -0.3139
+    mean_time_to_implement_seconds: -0.5126
+    mean_vocabulary: -0.2525
+    mean_volume: -0.3357
+  heaps:
+    mean_k: -0.1169
+  identifier_length_variance:
+    mean_max: -0.4367
+    mean_mean: 0.0078
+    mean_std_dev: -0.2478
+    mean_variance: -0.4957
+  indentation:
+    mean_blank_line_ratio: 0.2883
+    mean_mean_depth: -0.4448
+    mean_variance: -0.6173
+  line_patterns:
+    mean_blank_line_ratio: 0.2883
+    mean_string_literal_ratio: -0.8289
+    mean_unique_line_ratio: -0.0289
+  magic_number_density:
+    mean_density: 0.2821
+    mean_string_literal_ratio: -0.8289
+  near_duplicate_blocks_file:
+    mean_sub_block_count: -0.3612
+  ngram:
+    mean_bigram_hapax_fraction: 0.0142
+    mean_bigram_repeated_unique: -0.3335
+    mean_bigram_repetition_rate: -0.0114
+    mean_bigram_total: -0.3100
+    mean_bigram_unique: -0.3022
+    mean_trigram_hapax_fraction: -0.0576
+    mean_trigram_repeated_unique: -0.0894
+    mean_trigram_repetition_rate: 0.0890
+    mean_trigram_total: -0.3107
+    mean_trigram_unique: -0.3313
+  punctuation_density:
+    mean_arrow_density: -1.1156
+    mean_bracket_nonalpha_prefix_count: 1.0397
+    mean_bracket_nonalpha_suffix_count: -0.4541
+    mean_colon_suffix_density: 0.3588
+    mean_dot_count: -1.0081
+    mean_id_nonalpha_suffix_density: 0.0111
+  readability:
+    mean_avg_line_length: 0.1309
+    mean_avg_sub_words_per_id: -0.0415
+    mean_avg_tokens_per_line: 0.2722
+    mean_flesch_adapted: 0.0243
+    mean_fog_adapted: -0.3299
+    mean_total_lines: -0.5815
+  symbol_density:
+    mean_density: 0.2141
+    mean_symbol_count: -0.2386
+  vocabulary:
+    mean_mattr: -0.0870
+    mean_raw_ttr: 0.0851
+    mean_total_identifiers: -0.4256
+    mean_unique_identifiers: -0.3406
+  vowel_density:
+    mean_total_chars: -0.4179
+  zipf:
+    mean_exponent: -0.0067
+    mean_total_tokens: -0.3093
+    mean_vocab_size: -0.2610
+
+no_debug_print_statements:
+  _doc: "Debug output (`console.log`, `IO.inspect`, `fmt.Println`) must not be left in committed code."
+  _fix_hint: "Remove IO.inspect/IO.puts/console.log debug output — use Logger or remove entirely"
+  _log_baseline: -86.5160
+  branching:
+    mean_branch_count: -0.3540
+    mean_branching_density: 0.0181
+    mean_max_nesting_depth: -0.4025
+    mean_non_blank_count: -0.3719
+  brevity:
+    mean_sample_size: -0.2128
+  casing_entropy:
+    mean_entropy: 0.0285
+    mean_other_count: 0.1169
+    mean_pascal_case_count: -1.0141
+    mean_snake_case_count: -0.5844
+  compression:
+    mean_raw_bytes: -0.4490
+    mean_redundancy: -0.0518
+    mean_unique_line_ratio: -0.0864
+    mean_zlib_bytes: -0.3414
+    mean_zlib_ratio: -0.1076
+  entropy:
+    mean_char_entropy: -0.0058
+    mean_char_normalized: -0.0059
+    mean_token_entropy: -0.0215
+    mean_token_max_entropy: -0.0460
+    mean_token_normalized: 0.0245
+    mean_total_tokens: -0.5168
+    mean_vocab_size: -0.2128
+  function_metrics:
+    mean_avg_function_lines: -0.4292
+    mean_max_function_lines: -0.4243
+  halstead:
+    mean_N1_total_operators: -0.3780
+    mean_N2_total_operands: -0.4000
+    mean_difficulty: -0.2494
+    mean_effort: -0.6911
+    mean_estimated_bugs: -0.4418
+    mean_length: -0.3857
+    mean_n1_unique_operators: -0.1473
+    mean_n2_unique_operands: -0.2979
+    mean_time_to_implement_seconds: -0.6911
+    mean_vocabulary: -0.2559
+    mean_volume: -0.4417
+  heaps:
+    mean_beta: 0.0307
+    mean_k: 0.0324
+    mean_r_squared: -0.0077
+  identifier_length_variance:
+    mean_mean: 0.1266
+    mean_std_dev: 0.0871
+    mean_variance: 0.1743
+  indentation:
+    mean_blank_line_ratio: -0.0499
+    mean_max_depth: -0.2215
+    mean_mean_depth: -0.1903
+    mean_variance: -0.2218
+  line_patterns:
+    mean_blank_line_ratio: -0.0499
+    mean_max_nesting_depth: -0.4025
+    mean_string_literal_ratio: -1.0798
+    mean_unique_line_ratio: -0.0602
+  magic_number_density:
+    mean_density: 0.5227
+    mean_string_literal_ratio: -1.0798
+  near_duplicate_blocks_file:
+    mean_sub_block_count: -0.4114
+  ngram:
+    mean_bigram_hapax_fraction: -0.0183
+    mean_bigram_repeated_unique: -0.3069
+    mean_bigram_repetition_rate: -0.0758
+    mean_bigram_total: -0.5178
+    mean_bigram_unique: -0.3466
+    mean_trigram_hapax_fraction: -0.0225
+    mean_trigram_repeated_unique: -0.3221
+    mean_trigram_repetition_rate: -0.0929
+    mean_trigram_total: -0.5188
+    mean_trigram_unique: -0.4061
+  punctuation_density:
+    mean_arrow_density: 0.4321
+    mean_bracket_nonalpha_prefix_count: -2.0000
+    mean_bracket_nonalpha_suffix_count: -1.2715
+    mean_colon_suffix_density: -0.1696
+    mean_dot_count: -0.9095
+    mean_id_nonalpha_suffix_density: -0.0078
+  readability:
+    mean_avg_line_length: -0.0795
+    mean_avg_sub_words_per_id: 0.0617
+    mean_avg_tokens_per_line: -0.1449
+    mean_flesch_adapted: -0.0473
+    mean_fog_adapted: -0.0298
+    mean_total_lines: -0.3719
+  symbol_density:
+    mean_density: -0.0878
+    mean_distinct_symbol_types: -0.1242
+    mean_symbol_count: -0.5369
+  vocabulary:
+    mean_mattr: 0.2274
+    mean_raw_ttr: 0.3523
+    mean_total_identifiers: -0.5867
+    mean_unique_identifiers: -0.2346
+  vowel_density:
+    mean_total_chars: -0.4601
+  zipf:
+    mean_exponent: -0.1196
+    mean_r_squared: 0.0127
+    mean_total_tokens: -0.5168
+    mean_vocab_size: -0.2128
+
+no_fixme_comments:
+  _doc: "FIXME, XXX, and HACK comments indicate known problems that should be resolved before merging."
+  _fix_hint: "Resolve FIXME/XXX/HACK comments before merging — they indicate known unresolved issues"
+  _log_baseline: -2.1522
+  branching:
+    mean_branch_count: 0.1755
+    mean_branching_density: 0.1504
+    mean_non_blank_count: 0.0252
+  brevity:
+    mean_sample_size: -0.0887
+  casing_entropy:
+    mean_entropy: -0.0225
+    mean_pascal_case_count: -0.0769
+    mean_snake_case_count: -0.0130
+  comment_structure:
+    mean_comment_line_count: -0.6667
+    mean_comment_line_ratio: 0.5464
+    mean_todo_fixme_count: -0.7195
+  compression:
+    mean_raw_bytes: 0.0176
+    mean_redundancy: 0.0275
+    mean_unique_line_ratio: -0.0049
+    mean_zlib_bytes: -0.0211
+    mean_zlib_ratio: 0.0387
+  entropy:
+    mean_char_entropy: 0.0020
+    mean_char_max_entropy: -0.0054
+    mean_char_normalized: 0.0074
+    mean_token_entropy: -0.0266
+    mean_token_max_entropy: -0.0180
+    mean_token_normalized: -0.0086
+    mean_total_tokens: 0.0600
+    mean_vocab_size: -0.0887
+  function_metrics:
+    mean_avg_function_lines: 0.0209
+    mean_avg_param_count: 0.0155
+    mean_function_count: 0.0232
+    mean_max_function_lines: 0.1330
+  halstead:
+    mean_N1_total_operators: 0.1156
+    mean_N2_total_operands: 0.0046
+    mean_difficulty: 0.0964
+    mean_effort: 0.1556
+    mean_estimated_bugs: 0.0592
+    mean_length: 0.0745
+    mean_n1_unique_operators: -0.0082
+    mean_n2_unique_operands: -0.1000
+    mean_time_to_implement_seconds: 0.1556
+    mean_vocabulary: -0.0750
+    mean_volume: 0.0591
+  heaps:
+    mean_beta: -0.0665
+    mean_k: 0.1089
+  identifier_length_variance:
+    mean_mean: 0.0027
+    mean_std_dev: 0.0259
+    mean_variance: 0.0517
+  indentation:
+    mean_blank_line_ratio: 0.0697
+    mean_max_depth: 0.0646
+    mean_mean_depth: 0.0482
+    mean_variance: 0.1889
+  line_patterns:
+    mean_blank_line_ratio: 0.0697
+    mean_string_literal_ratio: -0.0060
+    mean_unique_line_ratio: -0.0041
+  magic_number_density:
+    mean_density: -0.0646
+    mean_string_literal_ratio: 0.0564
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.1090
+  ngram:
+    mean_bigram_hapax_fraction: -0.0378
+    mean_bigram_repeated_unique: 0.0858
+    mean_bigram_repetition_rate: 0.0747
+    mean_bigram_total: 0.0601
+    mean_bigram_unique: -0.0026
+    mean_trigram_hapax_fraction: -0.0202
+    mean_trigram_repeated_unique: 0.1423
+    mean_trigram_repetition_rate: 0.1085
+    mean_trigram_total: 0.0602
+    mean_trigram_unique: 0.0286
+  punctuation_density:
+    mean_arrow_density: 0.0123
+    mean_bracket_nonalpha_prefix_count: 0.1755
+    mean_bracket_nonalpha_suffix_count: 0.2840
+    mean_colon_suffix_density: -0.1540
+    mean_dot_count: 0.1361
+    mean_exclamation_density: 2.0000
+    mean_id_nonalpha_suffix_density: 0.0200
+    mean_question_mark_density: 0.2981
+  readability:
+    mean_avg_line_length: 0.0494
+    mean_avg_sub_words_per_id: 0.0089
+    mean_avg_tokens_per_line: -0.0127
+    mean_flesch_adapted: -0.0070
+    mean_fog_adapted: -0.0103
+    mean_total_lines: 0.0728
+  symbol_density:
+    mean_density: 0.1041
+    mean_symbol_count: 0.1218
+  vocabulary:
+    mean_mattr: -0.1086
+    mean_raw_ttr: -0.1007
+    mean_total_identifiers: -0.0217
+    mean_unique_identifiers: -0.1224
+  vowel_density:
+    mean_total_chars: -0.0190
+  zipf:
+    mean_exponent: 0.0584
+    mean_r_squared: 0.0015
+    mean_total_tokens: 0.0600
+    mean_vocab_size: -0.0887
+
+no_nested_ternary:
+  _doc: "Nested conditional expressions (ternary-within-ternary) are harder to read than a plain if-else."
+  _fix_hint: "Replace nested ternary/conditional expressions with if-else blocks or pattern matching"
+  _log_baseline: 7.2208
+  branching:
+    mean_branch_count: -0.5662
+    mean_branching_density: -0.3441
+    mean_max_nesting_depth: 0.1824
+    mean_non_blank_count: -0.2221
+  brevity:
+    mean_sample_size: 0.0486
+  casing_entropy:
+    mean_entropy: 0.2495
+    mean_other_count: 0.7455
+    mean_pascal_case_count: 0.1237
+    mean_snake_case_count: 0.0885
+  compression:
+    mean_raw_bytes: -0.0141
+    mean_redundancy: -0.0117
+    mean_unique_line_ratio: 0.1154
+    mean_zlib_bytes: 0.0170
+    mean_zlib_ratio: -0.0312
+  entropy:
+    mean_char_entropy: 0.0689
+    mean_char_max_entropy: 0.0024
+    mean_char_normalized: 0.0665
+    mean_token_entropy: -0.0014
+    mean_token_max_entropy: 0.0110
+    mean_token_normalized: -0.0124
+    mean_total_tokens: 0.1324
+    mean_vocab_size: 0.0486
+  function_metrics:
+    mean_avg_function_lines: -0.7403
+    mean_avg_param_count: -0.0277
+    mean_function_count: 0.5579
+    mean_max_function_lines: -0.4954
+  halstead:
+    mean_N1_total_operators: 0.1382
+    mean_N2_total_operands: 0.1252
+    mean_difficulty: 0.0773
+    mean_effort: 0.2218
+    mean_estimated_bugs: 0.1445
+    mean_length: 0.1335
+    mean_n1_unique_operators: 0.0128
+    mean_n2_unique_operands: 0.0608
+    mean_time_to_implement_seconds: 0.2218
+    mean_vocabulary: 0.0480
+    mean_volume: 0.1445
+  heaps:
+    mean_beta: -0.0334
+    mean_k: 0.0563
+  identifier_length_variance:
+    mean_max: 0.0170
+    mean_std_dev: -0.0032
+    mean_variance: -0.0065
+  indentation:
+    mean_blank_line_ratio: 0.3825
+    mean_max_depth: -0.2891
+    mean_mean_depth: -0.2922
+    mean_variance: -0.5254
+  line_patterns:
+    mean_blank_line_ratio: 0.3825
+    mean_max_nesting_depth: 0.1824
+    mean_string_literal_ratio: 0.0146
+    mean_unique_line_ratio: 0.1591
+  magic_number_density:
+    mean_density: -0.1634
+    mean_magic_number_count: -0.0310
+    mean_string_literal_ratio: 0.0146
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.5472
+  ngram:
+    mean_bigram_hapax_fraction: -0.0464
+    mean_bigram_repeated_unique: 0.1405
+    mean_bigram_repetition_rate: 0.0564
+    mean_bigram_total: 0.1327
+    mean_bigram_unique: 0.0600
+    mean_trigram_hapax_fraction: -0.0321
+    mean_trigram_repeated_unique: 0.1699
+    mean_trigram_repetition_rate: 0.1003
+    mean_trigram_total: 0.1331
+    mean_trigram_unique: 0.0704
+  punctuation_density:
+    mean_bracket_nonalpha_prefix_count: 0.5781
+    mean_bracket_nonalpha_suffix_count: 0.7295
+    mean_colon_suffix_density: -0.6851
+    mean_dot_count: -0.1824
+    mean_exclamation_density: 2.0000
+    mean_id_nonalpha_suffix_density: 0.2589
+  readability:
+    mean_avg_line_length: 0.2148
+    mean_avg_sub_words_per_id: 0.0173
+    mean_avg_tokens_per_line: 0.3545
+    mean_flesch_adapted: -0.0367
+    mean_fog_adapted: 0.3545
+    mean_total_lines: -0.2221
+  symbol_density:
+    mean_density: 0.2615
+    mean_distinct_symbol_types: 0.0377
+    mean_symbol_count: 0.2475
+  vocabulary:
+    mean_mattr: -0.0453
+    mean_raw_ttr: -0.0380
+    mean_total_identifiers: 0.1302
+    mean_unique_identifiers: 0.0921
+  vowel_density:
+    mean_total_chars: 0.1293
+  zipf:
+    mean_exponent: 0.0240
+    mean_r_squared: 0.0111
+    mean_total_tokens: 0.1324
+    mean_vocab_size: 0.0486
+
diff --git a/priv/combined_metrics/consistency.yml b/priv/combined_metrics/consistency.yml
new file mode 100644
index 0000000..8dbd172
--- /dev/null
+++ b/priv/combined_metrics/consistency.yml
@@ -0,0 +1,310 @@
+consistent_casing_within_file:
+  _doc: "A file should use one naming convention throughout — no mixing of camelCase and snake_case for the same kind of identifier."
+  _fix_hint: "Pick one casing convention (snake_case or camelCase) and apply it uniformly"
+  _log_baseline: -2.4622
+  brevity:
+    mean_sample_size: -0.0471
+  casing_entropy:
+    mean_camel_case_count: -2.0000
+    mean_entropy: -0.4219
+    mean_snake_case_count: 0.2745
+  compression:
+    mean_raw_bytes: 0.0213
+    mean_redundancy: 0.0219
+    mean_zlib_bytes: -0.0194
+    mean_zlib_ratio: 0.0407
+  entropy:
+    mean_char_entropy: -0.0126
+    mean_char_max_entropy: -0.0170
+    mean_char_normalized: 0.0044
+    mean_token_entropy: -0.0090
+    mean_token_max_entropy: -0.0101
+    mean_vocab_size: -0.0471
+  halstead:
+    mean_difficulty: 0.0629
+    mean_effort: 0.0530
+    mean_estimated_bugs: -0.0099
+    mean_n2_unique_operands: -0.0629
+    mean_time_to_implement_seconds: 0.0530
+    mean_vocabulary: -0.0456
+    mean_volume: -0.0099
+  heaps:
+    mean_beta: -0.0232
+    mean_k: 0.0253
+  identifier_length_variance:
+    mean_mean: 0.0342
+    mean_std_dev: 0.0123
+    mean_variance: 0.0246
+  ngram:
+    mean_bigram_hapax_fraction: -0.0071
+    mean_bigram_repetition_rate: 0.0267
+    mean_bigram_unique: -0.0197
+    mean_trigram_hapax_fraction: -0.0122
+    mean_trigram_repeated_unique: 0.0698
+    mean_trigram_repetition_rate: 0.0874
+    mean_trigram_unique: -0.0172
+  readability:
+    mean_avg_line_length: 0.0221
+  symbol_density:
+    mean_density: -0.0214
+  vocabulary:
+    mean_mattr: -0.0679
+    mean_raw_ttr: -0.0715
+    mean_unique_identifiers: -0.0714
+  vowel_density:
+    mean_total_chars: 0.0342
+  zipf:
+    mean_exponent: 0.0265
+    mean_vocab_size: -0.0471
+
+consistent_error_return_shape:
+  _doc: "All functions in a module should return errors in the same shape — mixed `nil`, `false`, and `{:error, _}` returns are confusing."
+  _fix_hint: "Use a single error return format (e.g., {:error, reason}) consistently throughout"
+  _log_baseline: 31.6243
+  branching:
+    mean_branch_count: -0.2178
+    mean_branching_density: -0.1258
+    mean_non_blank_count: -0.0921
+  brevity:
+    mean_sample_size: 0.0231
+  casing_entropy:
+    mean_entropy: -0.0372
+    mean_snake_case_count: 0.0582
+  compression:
+    mean_raw_bytes: -0.0234
+    mean_redundancy: 0.0058
+    mean_unique_line_ratio: 0.0576
+    mean_zlib_bytes: -0.0378
+    mean_zlib_ratio: 0.0144
+  entropy:
+    mean_char_entropy: 0.0159
+    mean_char_normalized: 0.0160
+    mean_token_entropy: -0.0277
+    mean_token_normalized: -0.0328
+    mean_total_tokens: 0.0361
+    mean_vocab_size: 0.0231
+  function_metrics:
+    mean_avg_function_lines: -0.0914
+  halstead:
+    mean_N1_total_operators: 0.1217
+    mean_N2_total_operands: 0.0275
+    mean_difficulty: 0.0936
+    mean_effort: 0.1918
+    mean_estimated_bugs: 0.0982
+    mean_length: 0.0900
+    mean_n1_unique_operators: 0.0835
+    mean_n2_unique_operands: 0.0174
+    mean_time_to_implement_seconds: 0.1918
+    mean_vocabulary: 0.0368
+    mean_volume: 0.0982
+  heaps:
+    mean_beta: -0.0402
+    mean_k: 0.0903
+  identifier_length_variance:
+    mean_std_dev: 0.0324
+    mean_variance: 0.0648
+  indentation:
+    mean_blank_line_ratio: 0.0185
+    mean_mean_depth: -0.0638
+    mean_variance: -0.0831
+  line_patterns:
+    mean_blank_line_ratio: 0.0185
+    mean_string_literal_ratio: -2.0000
+    mean_unique_line_ratio: 0.0559
+  magic_number_density:
+    mean_density: -0.0557
+    mean_string_literal_ratio: -2.0000
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.1553
+  ngram:
+    mean_bigram_hapax_fraction: -0.0430
+    mean_bigram_repeated_unique: 0.0136
+    mean_bigram_repetition_rate: 0.0601
+    mean_bigram_total: 0.0362
+    mean_bigram_unique: -0.0667
+    mean_trigram_hapax_fraction: -0.0176
+    mean_trigram_repeated_unique: 0.0150
+    mean_trigram_repetition_rate: 0.0920
+    mean_trigram_total: 0.0363
+    mean_trigram_unique: -0.0443
+  punctuation_density:
+    mean_arrow_density: -0.3821
+    mean_bracket_nonalpha_suffix_count: 0.0804
+    mean_colon_suffix_density: -0.0384
+    mean_id_nonalpha_suffix_density: 0.0720
+  readability:
+    mean_avg_line_length: 0.0716
+    mean_avg_sub_words_per_id: 0.0302
+    mean_avg_tokens_per_line: 0.1283
+    mean_flesch_adapted: -0.0449
+    mean_fog_adapted: 0.0827
+    mean_total_lines: -0.0921
+  symbol_density:
+    mean_density: 0.1360
+    mean_symbol_count: 0.1121
+  vocabulary:
+    mean_mattr: 0.0268
+    mean_raw_ttr: -0.0151
+    mean_total_identifiers: 0.0519
+    mean_unique_identifiers: 0.0368
+  vowel_density:
+    mean_total_chars: 0.0479
+  zipf:
+    mean_exponent: 0.0181
+    mean_total_tokens: 0.0361
+    mean_vocab_size: 0.0231
+
+consistent_function_style:
+  _doc: "A module should not mix one-liner and multi-clause function definitions for the same concern."
+  _fix_hint: "Use a consistent function definition style — all def or all defp, one-liner or block form"
+  _log_baseline: -2.0498
+  branching:
+    mean_branch_count: -0.1610
+    mean_branching_density: -0.3349
+    mean_max_nesting_depth: -0.1610
+    mean_non_blank_count: 0.1738
+  brevity:
+    mean_sample_size: 0.0028
+  casing_entropy:
+    mean_entropy: -0.0562
+    mean_other_count: -0.2753
+    mean_pascal_case_count: -0.0379
+    mean_snake_case_count: 0.0228
+  compression:
+    mean_raw_bytes: 0.0313
+    mean_redundancy: 0.0188
+    mean_unique_line_ratio: -0.0440
+    mean_zlib_bytes: 0.0037
+    mean_zlib_ratio: 0.0276
+  entropy:
+    mean_char_entropy: -0.0072
+    mean_char_normalized: -0.0071
+    mean_token_entropy: 0.0058
+    mean_token_normalized: 0.0052
+    mean_vocab_size: 0.0028
+  function_metrics:
+    mean_avg_function_lines: 0.0608
+    mean_avg_param_count: -0.0099
+    mean_function_count: 0.0939
+    mean_max_function_lines: -0.0797
+  halstead:
+    mean_N2_total_operands: 0.0471
+    mean_difficulty: 0.0186
+    mean_effort: 0.0362
+    mean_estimated_bugs: 0.0176
+    mean_length: 0.0157
+    mean_n1_unique_operators: -0.0122
+    mean_n2_unique_operands: 0.0162
+    mean_time_to_implement_seconds: 0.0362
+    mean_vocabulary: 0.0091
+    mean_volume: 0.0176
+  heaps:
+    mean_beta: 0.0024
+  identifier_length_variance:
+    mean_mean: 0.0040
+    mean_std_dev: 0.0053
+    mean_variance: 0.0106
+  indentation:
+    mean_blank_line_ratio: -0.0991
+    mean_max_depth: -0.1143
+    mean_mean_depth: -0.0203
+    mean_variance: -0.1730
+  line_patterns:
+    mean_blank_line_ratio: -0.0991
+    mean_max_nesting_depth: -0.1610
+    mean_unique_line_ratio: -0.0456
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.0594
+  ngram:
+    mean_bigram_hapax_fraction: 0.0037
+    mean_bigram_repeated_unique: -0.0041
+    mean_bigram_repetition_rate: -0.0091
+    mean_bigram_unique: 0.0065
+    mean_trigram_repeated_unique: -0.0058
+  punctuation_density:
+    mean_arrow_density: 2.0000
+    mean_bracket_nonalpha_suffix_count: -0.0781
+    mean_colon_suffix_density: -0.1318
+    mean_dot_count: -0.0204
+    mean_id_nonalpha_suffix_density: -0.0132
+  readability:
+    mean_avg_line_length: -0.1471
+    mean_avg_sub_words_per_id: 0.0030
+    mean_avg_tokens_per_line: -0.1751
+    mean_flesch_adapted: 0.0147
+    mean_fog_adapted: -0.1412
+    mean_total_lines: 0.1738
+  symbol_density:
+    mean_density: -0.0473
+    mean_symbol_count: -0.0159
+  vocabulary:
+    mean_mattr: -0.0035
+    mean_raw_ttr: -0.0090
+    mean_total_identifiers: 0.0133
+    mean_unique_identifiers: 0.0042
+  vowel_density:
+    mean_total_chars: 0.0173
+  zipf:
+    mean_exponent: -0.0054
+    mean_vocab_size: 0.0028
+
+same_concept_same_name:
+  _doc: "The same domain concept should use the same name throughout a file — mixing `user`, `usr`, and `u` for the same thing harms readability."
+  _fix_hint: "Use the same name for the same concept everywhere — avoid synonyms like user/account/member"
+  _log_baseline: -10.7039
+  brevity:
+    mean_sample_size: -1.3837
+  compression:
+    mean_raw_bytes: 0.1823
+    mean_redundancy: 0.4046
+    mean_unique_line_ratio: -0.3343
+    mean_zlib_bytes: -0.8496
+    mean_zlib_ratio: 1.0316
+  entropy:
+    mean_char_entropy: -0.1859
+    mean_char_normalized: -0.1851
+    mean_token_entropy: -0.3646
+    mean_token_max_entropy: -0.2981
+    mean_vocab_size: -1.3837
+  halstead:
+    mean_difficulty: 1.9192
+    mean_effort: 1.6104
+    mean_estimated_bugs: -0.3082
+    mean_n2_unique_operands: -1.9192
+    mean_time_to_implement_seconds: 1.6104
+    mean_vocabulary: -1.4248
+    mean_volume: -0.3088
+  heaps:
+    mean_beta: -0.6035
+    mean_k: 0.5246
+  identifier_length_variance:
+    mean_mean: 0.3369
+    mean_std_dev: -0.2793
+    mean_variance: -0.5589
+  line_patterns:
+    mean_unique_line_ratio: -0.7135
+  ngram:
+    mean_bigram_hapax_fraction: -0.6648
+    mean_bigram_repeated_unique: -0.2150
+    mean_bigram_repetition_rate: 0.6714
+    mean_bigram_unique: -1.2077
+    mean_trigram_hapax_fraction: -0.6812
+    mean_trigram_repeated_unique: 1.3250
+    mean_trigram_repetition_rate: 1.6604
+    mean_trigram_unique: -1.0154
+  readability:
+    mean_avg_line_length: 0.1889
+    mean_avg_sub_words_per_id: -0.1821
+    mean_flesch_adapted: 0.2414
+  symbol_density:
+    mean_density: -0.1858
+  vocabulary:
+    mean_mattr: -1.7927
+    mean_raw_ttr: -2.0000
+    mean_unique_identifiers: -1.9992
+  vowel_density:
+    mean_total_chars: 0.3371
+  zipf:
+    mean_exponent: 0.7915
+    mean_vocab_size: -1.3837
+
diff --git a/priv/combined_metrics/dependencies.yml b/priv/combined_metrics/dependencies.yml
new file mode 100644
index 0000000..000ecbf
--- /dev/null
+++ b/priv/combined_metrics/dependencies.yml
@@ -0,0 +1,319 @@
+import_count_under_10:
+  _doc: "Files should import fewer than 10 modules; high import counts signal excessive coupling."
+  _fix_hint: "Reduce imports — split large modules or use fully-qualified names for rarely-used deps"
+  _log_baseline: 7.0687
+  branching:
+    mean_branch_count: 0.2110
+    mean_branching_density: -1.0683
+    mean_max_nesting_depth: 0.1234
+    mean_non_blank_count: -0.0219
+  brevity:
+    mean_sample_size: 0.0119
+  casing_entropy:
+    mean_entropy: -0.0396
+    mean_pascal_case_count: -0.1657
+    mean_snake_case_count: 0.0025
+  comment_structure:
+    mean_comment_line_ratio: -1.2802
+  compression:
+    mean_raw_bytes: -0.0133
+    mean_redundancy: -0.0135
+    mean_unique_line_ratio: -0.0046
+    mean_zlib_bytes: 0.0144
+    mean_zlib_ratio: -0.0277
+  entropy:
+    mean_char_entropy: 0.0035
+    mean_char_max_entropy: 0.0088
+    mean_char_normalized: -0.0053
+    mean_token_entropy: -0.0040
+    mean_token_max_entropy: 0.0026
+    mean_token_normalized: -0.0066
+    mean_total_tokens: -0.0251
+    mean_vocab_size: 0.0119
+  function_metrics:
+    mean_avg_function_lines: -0.0688
+    mean_avg_param_count: -0.0555
+    mean_function_count: 0.1234
+    mean_max_function_lines: 0.0944
+    mean_max_param_count: -0.1234
+  halstead:
+    mean_N1_total_operators: -0.0138
+    mean_N2_total_operands: -0.0464
+    mean_difficulty: -0.0353
+    mean_effort: -0.0606
+    mean_estimated_bugs: -0.0253
+    mean_length: -0.0260
+    mean_n1_unique_operators: 0.0111
+    mean_time_to_implement_seconds: -0.0606
+    mean_vocabulary: 0.0032
+    mean_volume: -0.0253
+  heaps:
+    mean_beta: -0.0893
+    mean_k: 0.3293
+    mean_r_squared: 0.0101
+  identifier_length_variance:
+    mean_max: 0.0679
+    mean_mean: 0.0712
+    mean_std_dev: 0.0609
+    mean_variance: 0.1218
+  indentation:
+    mean_blank_line_ratio: 0.1478
+    mean_max_depth: -0.0876
+    mean_mean_depth: -0.0397
+    mean_variance: -0.2328
+  line_patterns:
+    mean_blank_line_ratio: 0.1478
+    mean_max_nesting_depth: 0.1234
+    mean_string_literal_ratio: 0.0265
+    mean_unique_line_ratio: -0.0050
+  magic_number_density:
+    mean_density: 0.5219
+    mean_magic_number_count: 0.4898
+    mean_string_literal_ratio: 0.0265
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.1110
+  ngram:
+    mean_bigram_repeated_unique: 0.0034
+    mean_bigram_repetition_rate: -0.0129
+    mean_bigram_total: -0.0252
+    mean_bigram_unique: 0.0024
+    mean_trigram_hapax_fraction: -0.0051
+    mean_trigram_repeated_unique: 0.0257
+    mean_trigram_repetition_rate: -0.0296
+    mean_trigram_total: -0.0252
+    mean_trigram_unique: 0.0062
+  punctuation_density:
+    mean_bracket_nonalpha_prefix_count: 0.5922
+    mean_bracket_nonalpha_suffix_count: 0.1086
+    mean_colon_suffix_density: -0.1389
+    mean_dot_count: -0.1234
+    mean_id_nonalpha_suffix_density: -0.0141
+    mean_question_mark_density: -2.0000
+  readability:
+    mean_avg_line_length: 0.0110
+    mean_avg_sub_words_per_id: 0.0173
+    mean_flesch_adapted: -0.0204
+    mean_fog_adapted: 0.2028
+    mean_total_lines: -0.0265
+  symbol_density:
+    mean_density: 0.0223
+    mean_distinct_symbol_types: 0.0643
+    mean_symbol_count: 0.0087
+  vocabulary:
+    mean_mattr: 0.0037
+    mean_raw_ttr: 0.0453
+    mean_total_identifiers: -0.0543
+    mean_unique_identifiers: -0.0090
+  vowel_density:
+    mean_total_chars: 0.0169
+  zipf:
+    mean_exponent: -0.0152
+    mean_r_squared: 0.0050
+    mean_total_tokens: -0.0251
+    mean_vocab_size: 0.0119
+
+low_coupling:
+  _doc: "Modules should depend on few external symbols — a low unique-operand count relative to total is a proxy for tight coupling."
+  _fix_hint: "Reduce dependencies between modules — introduce interfaces or narrow the public API"
+  _log_baseline: -38.4249
+  branching:
+    mean_branch_count: 0.0745
+    mean_branching_density: 0.2097
+    mean_max_nesting_depth: -0.1353
+    mean_non_blank_count: -0.1353
+  brevity:
+    mean_sample_size: -0.1276
+  casing_entropy:
+    mean_entropy: -0.0947
+    mean_pascal_case_count: -0.3722
+    mean_snake_case_count: -0.1208
+  compression:
+    mean_raw_bytes: -0.1657
+    mean_redundancy: 0.0126
+    mean_unique_line_ratio: -0.0296
+    mean_zlib_bytes: -0.1918
+    mean_zlib_ratio: 0.0262
+  entropy:
+    mean_char_entropy: -0.0044
+    mean_char_max_entropy: -0.0152
+    mean_char_normalized: 0.0108
+    mean_token_entropy: -0.0215
+    mean_token_max_entropy: -0.0285
+    mean_token_normalized: 0.0070
+    mean_total_tokens: -0.1602
+    mean_vocab_size: -0.1276
+  function_metrics:
+    mean_avg_function_lines: -0.3103
+    mean_function_count: 0.1353
+    mean_max_function_lines: -0.3573
+  halstead:
+    mean_N1_total_operators: -0.1645
+    mean_N2_total_operands: -0.1785
+    mean_difficulty: -0.1429
+    mean_effort: -0.3500
+    mean_estimated_bugs: -0.2072
+    mean_length: -0.1700
+    mean_n1_unique_operators: -0.1406
+    mean_n2_unique_operands: -0.1763
+    mean_time_to_implement_seconds: -0.3500
+    mean_vocabulary: -0.1655
+    mean_volume: -0.2072
+  heaps:
+    mean_beta: -0.0557
+    mean_k: 0.1362
+    mean_r_squared: -0.0234
+  identifier_length_variance:
+    mean_max: -0.0427
+    mean_std_dev: -0.0173
+    mean_variance: -0.0345
+  indentation:
+    mean_blank_line_ratio: -0.0752
+    mean_max_depth: -0.0352
+    mean_mean_depth: -0.1381
+    mean_variance: -0.2519
+  line_patterns:
+    mean_blank_line_ratio: -0.0752
+    mean_max_nesting_depth: -0.1353
+    mean_string_literal_ratio: 0.1282
+    mean_unique_line_ratio: -0.0312
+  magic_number_density:
+    mean_density: -2.0000
+    mean_string_literal_ratio: 0.1282
+  near_duplicate_blocks_file:
+    mean_sub_block_count: -0.0902
+  ngram:
+    mean_bigram_hapax_fraction: -0.0247
+    mean_bigram_repeated_unique: -0.1792
+    mean_bigram_repetition_rate: 0.0301
+    mean_bigram_total: -0.1605
+    mean_bigram_unique: -0.2135
+    mean_trigram_hapax_fraction: -0.0265
+    mean_trigram_repeated_unique: -0.1784
+    mean_trigram_repetition_rate: 0.0750
+    mean_trigram_total: -0.1608
+    mean_trigram_unique: -0.2352
+  punctuation_density:
+    mean_arrow_density: -0.0373
+    mean_bracket_nonalpha_prefix_count: -0.4412
+    mean_bracket_nonalpha_suffix_count: 0.2314
+    mean_colon_suffix_density: -0.0705
+    mean_dot_count: -0.2609
+    mean_exclamation_density: 1.8877
+    mean_id_nonalpha_suffix_density: -0.0113
+  readability:
+    mean_avg_line_length: -0.0307
+    mean_avg_sub_words_per_id: 0.0032
+    mean_avg_tokens_per_line: -0.0248
+    mean_fog_adapted: 0.0082
+    mean_total_lines: -0.1353
+  symbol_density:
+    mean_density: -0.0137
+    mean_distinct_symbol_types: -0.0960
+    mean_symbol_count: -0.1794
+  vocabulary:
+    mean_mattr: -0.0983
+    mean_raw_ttr: 0.0304
+    mean_total_identifiers: -0.1705
+    mean_unique_identifiers: -0.1402
+  vowel_density:
+    mean_total_chars: -0.1694
+  zipf:
+    mean_exponent: 0.0065
+    mean_r_squared: -0.0205
+    mean_total_tokens: -0.1602
+    mean_vocab_size: -0.1276
+
+no_wildcard_imports:
+  _doc: "Wildcard imports (`import *`, `using Module`) pollute the local namespace and hide dependencies."
+  _fix_hint: "Replace wildcard imports with explicit named imports for clarity and reduced scope pollution"
+  _log_baseline: -9.4788
+  branching:
+    mean_branching_density: 0.0249
+    mean_non_blank_count: -0.0268
+  brevity:
+    mean_sample_size: -0.0077
+  casing_entropy:
+    mean_entropy: -0.0070
+    mean_snake_case_count: 0.0189
+  compression:
+    mean_raw_bytes: 0.0310
+    mean_unique_line_ratio: -0.0046
+    mean_zlib_bytes: 0.0331
+  entropy:
+    mean_total_tokens: 0.0131
+    mean_vocab_size: -0.0077
+  function_metrics:
+    mean_avg_function_lines: -0.0263
+  halstead:
+    mean_N1_total_operators: 0.0202
+    mean_N2_total_operands: 0.0271
+    mean_difficulty: 0.0600
+    mean_effort: 0.0778
+    mean_estimated_bugs: 0.0179
+    mean_length: 0.0228
+    mean_n2_unique_operands: -0.0329
+    mean_time_to_implement_seconds: 0.0778
+    mean_vocabulary: -0.0230
+    mean_volume: 0.0178
+  heaps:
+    mean_beta: -0.0537
+    mean_k: 0.1998
+    mean_r_squared: -0.0155
+  identifier_length_variance:
+    mean_mean: 0.0387
+    mean_std_dev: 0.0490
+    mean_variance: 0.0979
+  indentation:
+    mean_blank_line_ratio: 0.0763
+    mean_mean_depth: -0.0117
+    mean_variance: 0.0042
+  line_patterns:
+    mean_blank_line_ratio: 0.0763
+    mean_string_literal_ratio: -0.3463
+    mean_unique_line_ratio: -0.0053
+  magic_number_density:
+    mean_density: 1.1035
+    mean_magic_number_count: 1.1312
+    mean_string_literal_ratio: -0.3463
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.0355
+  ngram:
+    mean_bigram_hapax_fraction: 0.0182
+    mean_bigram_repeated_unique: -0.0089
+    mean_bigram_repetition_rate: -0.0149
+    mean_bigram_total: 0.0131
+    mean_bigram_unique: 0.0308
+    mean_trigram_hapax_fraction: 0.0094
+    mean_trigram_repeated_unique: -0.0263
+    mean_trigram_repetition_rate: -0.0255
+    mean_trigram_total: 0.0132
+    mean_trigram_unique: 0.0274
+  punctuation_density:
+    mean_arrow_density: -0.0139
+    mean_bracket_nonalpha_prefix_count: -0.5656
+    mean_bracket_nonalpha_suffix_count: -0.0908
+    mean_colon_suffix_density: 2.0000
+    mean_dot_count: -0.0137
+    mean_id_nonalpha_suffix_density: 0.0143
+  readability:
+    mean_avg_line_length: 0.0591
+    mean_avg_sub_words_per_id: 0.0084
+    mean_avg_tokens_per_line: 0.0399
+    mean_flesch_adapted: -0.0142
+    mean_fog_adapted: 0.0290
+    mean_total_lines: -0.0268
+  symbol_density:
+    mean_density: -0.0266
+    mean_distinct_symbol_types: -0.0817
+    mean_symbol_count: 0.0042
+  vocabulary:
+    mean_mattr: 0.0212
+    mean_raw_ttr: -0.0140
+    mean_total_identifiers: 0.0140
+  vowel_density:
+    mean_total_chars: 0.0527
+  zipf:
+    mean_exponent: -0.0270
+    mean_total_tokens: 0.0131
+    mean_vocab_size: -0.0077
+
diff --git a/priv/combined_metrics/documentation.yml b/priv/combined_metrics/documentation.yml
new file mode 100644
index 0000000..75b19fd
--- /dev/null
+++ b/priv/combined_metrics/documentation.yml
@@ -0,0 +1,634 @@
+docstring_is_nonempty:
+  _doc: "Docstrings must contain meaningful content, not just a placeholder or empty string."
+  _fix_hint: "Replace placeholder docstrings with a real description of what the function does"
+  _log_baseline: 29.4288
+  branching:
+    mean_branch_count: 0.3089
+    mean_branching_density: 0.2652
+    mean_non_blank_count: 0.0437
+  brevity:
+    mean_sample_size: 0.1931
+  casing_entropy:
+    mean_entropy: 0.0560
+    mean_other_count: 0.0709
+    mean_pascal_case_count: 0.3089
+    mean_snake_case_count: 0.1585
+  compression:
+    mean_raw_bytes: 0.1245
+    mean_redundancy: -0.0198
+    mean_unique_line_ratio: 0.0053
+    mean_zlib_bytes: 0.1557
+    mean_zlib_ratio: -0.0312
+  entropy:
+    mean_char_entropy: 0.0065
+    mean_char_max_entropy: 0.0102
+    mean_char_normalized: -0.0036
+    mean_token_entropy: 0.0408
+    mean_token_max_entropy: 0.0400
+    mean_total_tokens: 0.1038
+    mean_vocab_size: 0.1931
+  function_metrics:
+    mean_avg_function_lines: 0.0357
+    mean_avg_param_count: 0.0131
+    mean_function_count: -0.0290
+    mean_max_function_lines: 0.0329
+  halstead:
+    mean_N1_total_operators: 0.0456
+    mean_N2_total_operands: -0.0027
+    mean_difficulty: 0.0706
+    mean_effort: 0.1098
+    mean_estimated_bugs: 0.0392
+    mean_length: 0.0289
+    mean_n1_unique_operators: 0.0913
+    mean_n2_unique_operands: 0.0179
+    mean_time_to_implement_seconds: 0.1098
+    mean_vocabulary: 0.0465
+    mean_volume: 0.0392
+  heaps:
+    mean_beta: 0.0242
+    mean_k: 0.0556
+  identifier_length_variance:
+    mean_mean: -0.0039
+    mean_std_dev: -0.0154
+    mean_variance: -0.0307
+  indentation:
+    mean_blank_line_ratio: 0.0413
+    mean_mean_depth: -0.0330
+    mean_variance: -0.0309
+  line_patterns:
+    mean_blank_line_ratio: 0.0413
+    mean_string_literal_ratio: 0.1078
+    mean_unique_line_ratio: 0.0072
+  magic_number_density:
+    mean_density: 0.0693
+    mean_magic_number_count: 0.1709
+    mean_string_literal_ratio: 0.1078
+  near_duplicate_blocks_file:
+    mean_block_count: 0.5417
+    mean_near_dup_block_d8: 0.2709
+    mean_sub_block_count: -0.0061
+  ngram:
+    mean_bigram_hapax_fraction: 0.0378
+    mean_bigram_repeated_unique: 0.0767
+    mean_bigram_repetition_rate: -0.0528
+    mean_bigram_total: 0.1039
+    mean_bigram_unique: 0.1635
+    mean_trigram_hapax_fraction: 0.0158
+    mean_trigram_repeated_unique: 0.0692
+    mean_trigram_repetition_rate: -0.0615
+    mean_trigram_total: 0.1041
+    mean_trigram_unique: 0.1386
+  punctuation_density:
+    mean_arrow_density: -0.0651
+    mean_bracket_nonalpha_prefix_count: 0.0450
+    mean_bracket_nonalpha_suffix_count: 0.1000
+    mean_colon_suffix_density: -0.0260
+    mean_dot_count: 0.1435
+    mean_exclamation_density: -2.0000
+    mean_id_nonalpha_suffix_density: -0.0474
+  readability:
+    mean_avg_line_length: 0.0834
+    mean_avg_sub_words_per_id: -0.0071
+    mean_avg_tokens_per_line: 0.0601
+    mean_fog_adapted: 0.0452
+    mean_total_lines: 0.0437
+  symbol_density:
+    mean_density: -0.0578
+    mean_distinct_symbol_types: 0.0505
+    mean_symbol_count: 0.0664
+  vocabulary:
+    mean_mattr: 0.1408
+    mean_raw_ttr: 0.0942
+    mean_total_identifiers: 0.1709
+    mean_unique_identifiers: 0.2651
+  vowel_density:
+    mean_total_chars: 0.1670
+  zipf:
+    mean_exponent: -0.0353
+    mean_r_squared: 0.0037
+    mean_total_tokens: 0.1038
+    mean_vocab_size: 0.1931
+
+file_has_license_header:
+  _doc: "Source files should begin with a license or copyright header."
+  _fix_hint: "Add a license header comment at the top of the file"
+  _log_baseline: 5.7261
+  branching:
+    mean_branching_density: -0.0081
+    mean_non_blank_count: 0.0080
+  brevity:
+    mean_sample_size: 0.0263
+  casing_entropy:
+    mean_entropy: 0.0312
+    mean_pascal_case_count: 0.0957
+    mean_snake_case_count: 0.0036
+  comment_structure:
+    mean_comment_line_ratio: -2.0000
+  compression:
+    mean_raw_bytes: 0.0104
+    mean_redundancy: -0.0059
+    mean_zlib_bytes: 0.0200
+    mean_zlib_ratio: -0.0095
+  entropy:
+    mean_char_entropy: 0.0028
+    mean_char_max_entropy: 0.0052
+    mean_token_entropy: 0.0042
+    mean_token_max_entropy: 0.0054
+    mean_total_tokens: 0.0091
+    mean_vocab_size: 0.0263
+  halstead:
+    mean_N1_total_operators: 0.0051
+    mean_N2_total_operands: 0.0185
+    mean_difficulty: -0.0273
+    mean_effort: -0.0113
+    mean_estimated_bugs: 0.0159
+    mean_length: 0.0095
+    mean_n2_unique_operands: 0.0458
+    mean_time_to_implement_seconds: -0.0113
+    mean_vocabulary: 0.0306
+    mean_volume: 0.0160
+  heaps:
+    mean_beta: -0.0113
+    mean_k: 0.0614
+  identifier_length_variance:
+    mean_mean: -0.0037
+    mean_variance: -0.0031
+  indentation:
+    mean_blank_line_ratio: 0.0206
+    mean_mean_depth: -0.0080
+    mean_variance: 0.0154
+  line_patterns:
+    mean_blank_line_ratio: 0.0206
+    mean_string_literal_ratio: -0.0104
+  magic_number_density:
+    mean_density: 0.1920
+    mean_magic_number_count: 0.1973
+    mean_string_literal_ratio: -0.0104
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.0089
+  ngram:
+    mean_bigram_hapax_fraction: 0.0086
+    mean_bigram_repetition_rate: -0.0091
+    mean_bigram_total: 0.0091
+    mean_bigram_unique: 0.0182
+    mean_trigram_hapax_fraction: 0.0031
+    mean_trigram_repetition_rate: -0.0091
+    mean_trigram_total: 0.0091
+    mean_trigram_unique: 0.0133
+  punctuation_density:
+    mean_arrow_density: -0.0105
+    mean_colon_suffix_density: -0.0104
+    mean_dot_count: 0.0423
+  readability:
+    mean_avg_tokens_per_line: 0.0091
+    mean_fog_adapted: 0.0060
+  symbol_density:
+    mean_density: -0.0042
+    mean_symbol_count: 0.0065
+  vocabulary:
+    mean_mattr: 0.0121
+    mean_raw_ttr: 0.0200
+    mean_total_identifiers: 0.0175
+    mean_unique_identifiers: 0.0374
+  vowel_density:
+    mean_total_chars: 0.0138
+  zipf:
+    mean_exponent: -0.0055
+    mean_total_tokens: 0.0091
+    mean_vocab_size: 0.0263
+
+file_has_module_docstring:
+  _doc: "Files should have a module-level docstring explaining purpose and usage."
+  _fix_hint: "Add a @moduledoc string describing the module's purpose"
+  _log_baseline: 24.2268
+  branching:
+    mean_branch_count: 0.3854
+    mean_branching_density: -2.0000
+    mean_non_blank_count: 0.0908
+  brevity:
+    mean_sample_size: 0.2219
+  casing_entropy:
+    mean_entropy: -0.0217
+    mean_pascal_case_count: 0.0929
+    mean_snake_case_count: 0.1492
+  compression:
+    mean_raw_bytes: 0.1161
+    mean_redundancy: -0.0256
+    mean_unique_line_ratio: 0.0122
+    mean_zlib_bytes: 0.1676
+    mean_zlib_ratio: -0.0514
+  entropy:
+    mean_char_max_entropy: 0.0126
+    mean_char_normalized: -0.0120
+    mean_token_entropy: 0.0441
+    mean_token_max_entropy: 0.0457
+    mean_total_tokens: 0.0837
+    mean_vocab_size: 0.2219
+  function_metrics:
+    mean_avg_function_lines: 0.0166
+    mean_max_function_lines: 0.1014
+  halstead:
+    mean_N1_total_operators: 0.0448
+    mean_N2_total_operands: 0.0268
+    mean_difficulty: 0.0971
+    mean_effort: 0.1486
+    mean_estimated_bugs: 0.0515
+    mean_length: 0.0387
+    mean_n1_unique_operators: 0.1116
+    mean_n2_unique_operands: 0.0412
+    mean_time_to_implement_seconds: 0.1486
+    mean_vocabulary: 0.0602
+    mean_volume: 0.0515
+  heaps:
+    mean_beta: -0.0925
+    mean_k: 0.5760
+    mean_r_squared: -0.0049
+  identifier_length_variance:
+    mean_mean: -0.0059
+    mean_std_dev: -0.0462
+    mean_variance: -0.0924
+  indentation:
+    mean_blank_line_ratio: 0.0686
+    mean_mean_depth: -0.0240
+    mean_variance: -0.0634
+  line_patterns:
+    mean_blank_line_ratio: 0.0686
+    mean_string_literal_ratio: 0.1425
+    mean_unique_line_ratio: 0.0141
+  magic_number_density:
+    mean_density: 0.0812
+    mean_magic_number_count: 0.1599
+    mean_string_literal_ratio: 0.1425
+  near_duplicate_blocks_file:
+    mean_block_count: 0.3854
+    mean_sub_block_count: 0.0098
+  ngram:
+    mean_bigram_hapax_fraction: 0.0500
+    mean_bigram_repeated_unique: 0.0539
+    mean_bigram_repetition_rate: -0.0497
+    mean_bigram_total: 0.0838
+    mean_bigram_unique: 0.1493
+    mean_trigram_hapax_fraction: 0.0283
+    mean_trigram_repeated_unique: 0.0225
+    mean_trigram_repetition_rate: -0.0657
+    mean_trigram_total: 0.0839
+    mean_trigram_unique: 0.1235
+  punctuation_density:
+    mean_colon_suffix_density: 0.0341
+    mean_dot_count: 0.0777
+    mean_exclamation_density: -0.1014
+    mean_id_nonalpha_suffix_density: -0.0339
+  readability:
+    mean_avg_line_length: 0.0257
+    mean_avg_sub_words_per_id: -0.0181
+    mean_avg_tokens_per_line: -0.0071
+    mean_flesch_adapted: 0.0205
+    mean_fog_adapted: -0.0266
+    mean_total_lines: 0.0908
+  symbol_density:
+    mean_density: -0.0727
+    mean_distinct_symbol_types: 0.0618
+    mean_symbol_count: 0.0433
+  vocabulary:
+    mean_mattr: 0.0527
+    mean_raw_ttr: 0.1365
+    mean_total_identifiers: 0.1309
+    mean_unique_identifiers: 0.2674
+  vowel_density:
+    mean_total_chars: 0.1250
+  zipf:
+    mean_exponent: -0.0467
+    mean_total_tokens: 0.0837
+    mean_vocab_size: 0.2219
+
+file_has_no_commented_out_code:
+  _doc: "Files should not contain commented-out code blocks left from development."
+  _fix_hint: "Remove commented-out code — use version control to track deleted code"
+  _log_baseline: -8.1616
+  branching:
+    mean_branching_density: 0.0368
+    mean_non_blank_count: -0.0367
+  brevity:
+    mean_sample_size: -0.0046
+  casing_entropy:
+    mean_entropy: -0.0252
+    mean_pascal_case_count: -0.0657
+    mean_snake_case_count: 0.0160
+  comment_structure:
+    mean_comment_line_count: -0.9901
+    mean_comment_line_ratio: 0.3578
+  compression:
+    mean_raw_bytes: -0.0068
+    mean_redundancy: 0.0077
+    mean_zlib_bytes: -0.0179
+    mean_zlib_ratio: 0.0111
+  entropy:
+    mean_char_entropy: -0.0026
+    mean_char_max_entropy: -0.0061
+    mean_char_normalized: 0.0035
+    mean_total_tokens: -0.0158
+    mean_vocab_size: -0.0046
+  function_metrics:
+    mean_avg_function_lines: -0.0992
+    mean_function_count: 0.0686
+    mean_max_function_lines: -0.1247
+  halstead:
+    mean_N1_total_operators: -0.0058
+    mean_N2_total_operands: -0.0546
+    mean_difficulty: 0.0608
+    mean_effort: 0.0253
+    mean_estimated_bugs: -0.0355
+    mean_length: -0.0224
+    mean_n1_unique_operators: 0.0171
+    mean_n2_unique_operands: -0.0984
+    mean_time_to_implement_seconds: 0.0253
+    mean_vocabulary: -0.0628
+    mean_volume: -0.0356
+  heaps:
+    mean_beta: -0.0499
+    mean_k: 0.1958
+    mean_r_squared: -0.0200
+  identifier_length_variance:
+    mean_mean: 0.0074
+    mean_std_dev: 0.0252
+    mean_variance: 0.0503
+  indentation:
+    mean_blank_line_ratio: 0.0551
+    mean_max_depth: 0.0324
+    mean_mean_depth: 0.0564
+    mean_variance: 0.0552
+  line_patterns:
+    mean_blank_line_ratio: 0.0551
+    mean_string_literal_ratio: -0.0818
+    mean_unique_line_ratio: -0.0077
+  magic_number_density:
+    mean_density: 2.0000
+    mean_string_literal_ratio: -0.0818
+  near_duplicate_blocks_file:
+    mean_sub_block_count: -0.0454
+  ngram:
+    mean_bigram_hapax_fraction: 0.0101
+    mean_bigram_repeated_unique: -0.0414
+    mean_bigram_repetition_rate: -0.0019
+    mean_bigram_total: -0.0158
+    mean_bigram_unique: -0.0223
+    mean_trigram_hapax_fraction: -0.0019
+    mean_trigram_repeated_unique: -0.0273
+    mean_trigram_repetition_rate: 0.0258
+    mean_trigram_total: -0.0159
+    mean_trigram_unique: -0.0338
+  punctuation_density:
+    mean_arrow_density: 0.1869
+    mean_bracket_nonalpha_prefix_count: -0.1247
+    mean_bracket_nonalpha_suffix_count: -0.0885
+    mean_colon_suffix_density: -0.1285
+    mean_dot_count: -0.0411
+    mean_exclamation_density: -0.1956
+    mean_id_nonalpha_suffix_density: 0.0028
+    mean_question_mark_density: -0.2494
+  readability:
+    mean_avg_line_length: 0.0371
+    mean_avg_sub_words_per_id: -0.0018
+    mean_avg_tokens_per_line: -0.0943
+    mean_flesch_adapted: 0.0114
+    mean_fog_adapted: -0.0779
+    mean_total_lines: 0.0785
+  symbol_density:
+    mean_density: -0.0172
+    mean_symbol_count: -0.0237
+  vocabulary:
+    mean_mattr: -0.0404
+    mean_raw_ttr: -0.0140
+    mean_total_identifiers: -0.0030
+    mean_unique_identifiers: -0.0170
+  vowel_density:
+    mean_total_chars: 0.0044
+  zipf:
+    mean_exponent: -0.0043
+    mean_total_tokens: -0.0158
+    mean_vocab_size: -0.0046
+
+function_has_docstring:
+  _doc: "Public functions should have a docstring describing behaviour, params, and return value."
+  _fix_hint: "Add @doc strings to public functions describing parameters, return value, and purpose"
+  _log_baseline: 43.0440
+  branching:
+    mean_branch_count: 0.5279
+    mean_branching_density: 0.3832
+    mean_non_blank_count: 0.1446
+  brevity:
+    mean_sample_size: 0.2608
+  casing_entropy:
+    mean_entropy: -0.0193
+    mean_other_count: 0.3105
+    mean_pascal_case_count: 0.1852
+    mean_snake_case_count: 0.3052
+  comment_structure:
+    mean_comment_line_ratio: -2.0000
+  compression:
+    mean_raw_bytes: 0.2251
+    mean_redundancy: -0.0242
+    mean_unique_line_ratio: -0.0264
+    mean_zlib_bytes: 0.2718
+    mean_zlib_ratio: -0.0468
+  entropy:
+    mean_char_entropy: 0.0081
+    mean_char_max_entropy: 0.0163
+    mean_char_normalized: -0.0082
+    mean_token_entropy: 0.0517
+    mean_token_max_entropy: 0.0557
+    mean_token_normalized: -0.0040
+    mean_total_tokens: 0.2284
+    mean_vocab_size: 0.2608
+  function_metrics:
+    mean_avg_function_lines: 0.0289
+    mean_avg_param_count: 0.0202
+    mean_function_count: 0.0999
+    mean_max_function_lines: 0.1368
+  halstead:
+    mean_N1_total_operators: 0.1175
+    mean_N2_total_operands: 0.0799
+    mean_difficulty: 0.0232
+    mean_effort: 0.1555
+    mean_estimated_bugs: 0.1324
+    mean_length: 0.1035
+    mean_n1_unique_operators: 0.0939
+    mean_n2_unique_operands: 0.1507
+    mean_time_to_implement_seconds: 0.1555
+    mean_vocabulary: 0.1288
+    mean_volume: 0.1324
+  heaps:
+    mean_beta: 0.0660
+    mean_k: -0.0612
+    mean_r_squared: -0.0041
+  identifier_length_variance:
+    mean_mean: -0.0412
+    mean_std_dev: -0.0363
+    mean_variance: -0.0727
+  indentation:
+    mean_blank_line_ratio: 0.1003
+    mean_max_depth: -0.1288
+    mean_mean_depth: -0.0904
+    mean_variance: -0.2118
+  line_patterns:
+    mean_blank_line_ratio: 0.1003
+    mean_string_literal_ratio: 0.5931
+    mean_unique_line_ratio: -0.0135
+  magic_number_density:
+    mean_density: 0.1744
+    mean_magic_number_count: 0.4104
+    mean_string_literal_ratio: 0.5931
+  near_duplicate_blocks_file:
+    mean_block_count: 0.6209
+    mean_near_dup_block_d6: 0.3105
+    mean_near_dup_block_d8: 0.3105
+    mean_sub_block_count: 0.0349
+  ngram:
+    mean_bigram_hapax_fraction: 0.0560
+    mean_bigram_repeated_unique: 0.1917
+    mean_bigram_repetition_rate: -0.0476
+    mean_bigram_total: 0.2288
+    mean_bigram_unique: 0.2856
+    mean_trigram_hapax_fraction: 0.0480
+    mean_trigram_repeated_unique: 0.1175
+    mean_trigram_repetition_rate: -0.1025
+    mean_trigram_total: 0.2292
+    mean_trigram_unique: 0.2807
+  punctuation_density:
+    mean_arrow_density: -0.3619
+    mean_bracket_nonalpha_prefix_count: 0.0999
+    mean_bracket_nonalpha_suffix_count: 0.2024
+    mean_colon_suffix_density: -0.0297
+    mean_dot_count: 0.1816
+    mean_exclamation_density: -0.3105
+    mean_id_nonalpha_suffix_density: -0.1019
+    mean_question_mark_density: -0.2377
+  readability:
+    mean_avg_line_length: 0.0861
+    mean_avg_sub_words_per_id: -0.0113
+    mean_avg_tokens_per_line: 0.0890
+    mean_flesch_adapted: 0.0026
+    mean_fog_adapted: 0.0948
+    mean_total_lines: 0.1394
+  symbol_density:
+    mean_density: -0.0353
+    mean_distinct_symbol_types: 0.0427
+    mean_symbol_count: 0.1896
+  vocabulary:
+    mean_mattr: 0.1771
+    mean_raw_ttr: 0.0544
+    mean_total_identifiers: 0.2819
+    mean_unique_identifiers: 0.3363
+  vowel_density:
+    mean_total_chars: 0.2407
+  zipf:
+    mean_exponent: 0.0025
+    mean_total_tokens: 0.2284
+    mean_vocab_size: 0.2608
+
+function_todo_comment_in_body:
+  _doc: "Functions should not contain TODO/FIXME comments indicating unfinished work."
+  _fix_hint: "Resolve or extract TODO comments — create a tracked issue instead of leaving them inline"
+  _log_baseline: 7.0511
+  branching:
+    mean_branch_count: -0.0287
+    mean_branching_density: -0.0435
+    mean_non_blank_count: 0.0147
+  brevity:
+    mean_sample_size: -0.0084
+  casing_entropy:
+    mean_entropy: 0.0039
+    mean_pascal_case_count: 0.0055
+    mean_snake_case_count: -0.0047
+  comment_structure:
+    mean_comment_line_count: -0.5392
+    mean_comment_line_ratio: 0.7796
+    mean_todo_fixme_count: -0.5392
+  compression:
+    mean_raw_bytes: 0.0082
+    mean_unique_line_ratio: 0.0028
+    mean_zlib_bytes: 0.0074
+  entropy:
+    mean_char_entropy: 0.0026
+    mean_char_normalized: 0.0026
+    mean_token_max_entropy: -0.0017
+    mean_token_normalized: 0.0020
+    mean_total_tokens: 0.0157
+    mean_vocab_size: -0.0084
+  function_metrics:
+    mean_avg_function_lines: -0.0250
+    mean_avg_param_count: -0.0354
+    mean_function_count: 0.0354
+    mean_max_function_lines: -0.0182
+  halstead:
+    mean_N1_total_operators: 0.0224
+    mean_N2_total_operands: -0.0309
+    mean_difficulty: 0.0451
+    mean_effort: 0.0375
+    mean_estimated_bugs: -0.0076
+    mean_length: 0.0035
+    mean_n2_unique_operands: -0.0761
+    mean_time_to_implement_seconds: 0.0375
+    mean_vocabulary: -0.0540
+    mean_volume: -0.0076
+  heaps:
+    mean_beta: -0.0498
+    mean_k: 0.1608
+    mean_r_squared: -0.0095
+  identifier_length_variance:
+    mean_mean: 0.0058
+    mean_std_dev: 0.0154
+    mean_variance: 0.0309
+  indentation:
+    mean_blank_line_ratio: 0.0593
+    mean_mean_depth: -0.0184
+    mean_variance: -0.0277
+  line_patterns:
+    mean_blank_line_ratio: 0.0593
+    mean_string_literal_ratio: -0.0151
+    mean_unique_line_ratio: 0.0033
+  magic_number_density:
+    mean_density: -2.0000
+    mean_string_literal_ratio: -0.0151
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.0281
+  ngram:
+    mean_bigram_hapax_fraction: -0.0187
+    mean_bigram_repeated_unique: 0.0464
+    mean_bigram_repetition_rate: 0.0098
+    mean_bigram_total: 0.0157
+    mean_bigram_unique: 0.0136
+    mean_trigram_hapax_fraction: -0.0109
+    mean_trigram_repeated_unique: 0.0479
+    mean_trigram_repetition_rate: 0.0123
+    mean_trigram_total: 0.0157
+    mean_trigram_unique: 0.0149
+  punctuation_density:
+    mean_arrow_density: -0.0161
+    mean_bracket_nonalpha_prefix_count: -0.0287
+    mean_colon_suffix_density: -0.0293
+    mean_dot_count: 0.0485
+    mean_id_nonalpha_suffix_density: 0.0062
+    mean_question_mark_density: -0.0287
+  readability:
+    mean_avg_line_length: 0.0123
+    mean_avg_sub_words_per_id: 0.0073
+    mean_avg_tokens_per_line: -0.0224
+    mean_flesch_adapted: -0.0053
+    mean_fog_adapted: -0.0109
+    mean_total_lines: 0.0381
+  symbol_density:
+    mean_density: 0.0116
+    mean_distinct_symbol_types: -0.0140
+    mean_symbol_count: 0.0200
+  vocabulary:
+    mean_mattr: -0.0437
+    mean_raw_ttr: -0.0159
+    mean_total_identifiers: -0.0024
+    mean_unique_identifiers: -0.0182
+  vowel_density:
+    mean_total_chars: 0.0035
+  zipf:
+    mean_total_tokens: 0.0157
+    mean_vocab_size: -0.0084
+
diff --git a/priv/combined_metrics/error_handling.yml b/priv/combined_metrics/error_handling.yml
new file mode 100644
index 0000000..1398a3d
--- /dev/null
+++ b/priv/combined_metrics/error_handling.yml
@@ -0,0 +1,325 @@
+does_not_swallow_errors:
+  _doc: "Errors must be handled or re-raised — empty rescue/catch blocks silently hide failures."
+  _fix_hint: "Propagate or log errors — do not silently discard {:error, _} tuples or rescue clauses"
+  _log_baseline: 87.3594
+  branching:
+    mean_branch_count: -0.1041
+    mean_branching_density: -0.2095
+    mean_max_nesting_depth: 0.5405
+    mean_non_blank_count: 0.1054
+  brevity:
+    mean_sample_size: 0.2830
+  casing_entropy:
+    mean_entropy: -0.1673
+    mean_other_count: -1.6214
+    mean_pascal_case_count: 0.8391
+    mean_snake_case_count: 0.5551
+  compression:
+    mean_raw_bytes: 0.3818
+    mean_redundancy: 0.0202
+    mean_unique_line_ratio: 0.1028
+    mean_zlib_bytes: 0.3399
+    mean_zlib_ratio: 0.0419
+  entropy:
+    mean_char_entropy: 0.0445
+    mean_char_max_entropy: 0.0347
+    mean_char_normalized: 0.0098
+    mean_token_entropy: 0.0223
+    mean_token_max_entropy: 0.0620
+    mean_token_normalized: -0.0397
+    mean_total_tokens: 0.4926
+    mean_vocab_size: 0.2830
+  function_metrics:
+    mean_avg_function_lines: 0.1005
+    mean_max_function_lines: 0.2243
+  halstead:
+    mean_N1_total_operators: 0.4699
+    mean_N2_total_operands: 0.2900
+    mean_difficulty: 0.2395
+    mean_effort: 0.6960
+    mean_estimated_bugs: 0.4564
+    mean_length: 0.4072
+    mean_n1_unique_operators: 0.1859
+    mean_n2_unique_operands: 0.2364
+    mean_time_to_implement_seconds: 0.6960
+    mean_vocabulary: 0.2190
+    mean_volume: 0.4565
+  heaps:
+    mean_beta: -0.0869
+    mean_k: 0.2466
+  identifier_length_variance:
+    mean_mean: -0.0142
+    mean_std_dev: -0.1252
+    mean_variance: -0.2505
+  indentation:
+    mean_blank_line_ratio: 0.0451
+    mean_max_depth: 0.1740
+    mean_mean_depth: 0.1043
+    mean_variance: 0.3416
+  line_patterns:
+    mean_blank_line_ratio: 0.0451
+    mean_max_nesting_depth: 0.5405
+    mean_string_literal_ratio: 0.2524
+    mean_unique_line_ratio: 0.1413
+  magic_number_density:
+    mean_string_literal_ratio: 0.2524
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.3065
+  ngram:
+    mean_bigram_hapax_fraction: -0.0373
+    mean_bigram_repeated_unique: 0.4011
+    mean_bigram_repetition_rate: 0.0995
+    mean_bigram_total: 0.4937
+    mean_bigram_unique: 0.3266
+    mean_trigram_hapax_fraction: -0.0651
+    mean_trigram_repeated_unique: 0.5672
+    mean_trigram_repetition_rate: 0.2299
+    mean_trigram_total: 0.4949
+    mean_trigram_unique: 0.3376
+  punctuation_density:
+    mean_arrow_density: -0.3177
+    mean_bracket_nonalpha_prefix_count: 0.7888
+    mean_bracket_nonalpha_suffix_count: 2.0000
+    mean_colon_suffix_density: 0.2150
+    mean_dot_count: 0.5172
+    mean_exclamation_density: -0.5217
+    mean_id_nonalpha_suffix_density: 0.0181
+    mean_question_mark_density: -0.4364
+  readability:
+    mean_avg_line_length: 0.2905
+    mean_avg_sub_words_per_id: 0.0219
+    mean_avg_tokens_per_line: 0.3872
+    mean_flesch_adapted: -0.0373
+    mean_fog_adapted: 0.3019
+    mean_total_lines: 0.1054
+  symbol_density:
+    mean_density: 0.2563
+    mean_distinct_symbol_types: 0.0400
+    mean_symbol_count: 0.6378
+  vocabulary:
+    mean_mattr: 0.0190
+    mean_raw_ttr: -0.1464
+    mean_total_identifiers: 0.5481
+    mean_unique_identifiers: 0.4017
+  vowel_density:
+    mean_total_chars: 0.5339
+  zipf:
+    mean_exponent: 0.0933
+    mean_total_tokens: 0.4926
+    mean_vocab_size: 0.2830
+
+error_message_is_descriptive:
+  _doc: "Error values should carry a meaningful message, not just a bare atom or empty string."
+  _fix_hint: "Include context in error messages — describe what failed, not just that it failed"
+  _log_baseline: 52.7594
+  branching:
+    mean_branch_count: 0.0664
+    mean_branching_density: -0.0540
+    mean_max_nesting_depth: 0.3900
+    mean_non_blank_count: 0.1204
+  brevity:
+    mean_sample_size: 0.3136
+  casing_entropy:
+    mean_entropy: 0.1513
+    mean_pascal_case_count: 2.0000
+    mean_snake_case_count: 0.4347
+  compression:
+    mean_raw_bytes: 0.3028
+    mean_redundancy: 0.0104
+    mean_unique_line_ratio: -0.0126
+    mean_zlib_bytes: 0.2771
+    mean_zlib_ratio: 0.0257
+  entropy:
+    mean_char_entropy: 0.0161
+    mean_char_max_entropy: 0.0487
+    mean_char_normalized: -0.0326
+    mean_token_entropy: 0.0596
+    mean_token_max_entropy: 0.0685
+    mean_token_normalized: -0.0089
+    mean_total_tokens: 0.3002
+    mean_vocab_size: 0.3136
+  function_metrics:
+    mean_avg_function_lines: 0.1160
+    mean_max_function_lines: 0.0713
+  halstead:
+    mean_N1_total_operators: 0.1787
+    mean_N2_total_operands: 0.0463
+    mean_difficulty: 0.0136
+    mean_effort: 0.1822
+    mean_estimated_bugs: 0.1686
+    mean_length: 0.1370
+    mean_n1_unique_operators: 0.1179
+    mean_n2_unique_operands: 0.1506
+    mean_time_to_implement_seconds: 0.1822
+    mean_vocabulary: 0.1415
+    mean_volume: 0.1686
+  heaps:
+    mean_beta: 0.0120
+    mean_k: 0.1259
+    mean_r_squared: 0.0073
+  identifier_length_variance:
+    mean_mean: -0.0598
+    mean_std_dev: -0.0787
+    mean_variance: -0.1573
+  indentation:
+    mean_blank_line_ratio: -0.1098
+    mean_max_depth: 0.1754
+    mean_mean_depth: 0.1108
+    mean_variance: 0.1967
+  line_patterns:
+    mean_blank_line_ratio: -0.1098
+    mean_max_nesting_depth: 0.3900
+    mean_string_literal_ratio: 0.3673
+    mean_unique_line_ratio: 0.0304
+  magic_number_density:
+    mean_string_literal_ratio: 0.3673
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.0621
+  ngram:
+    mean_bigram_hapax_fraction: -0.0059
+    mean_bigram_repeated_unique: 0.3150
+    mean_bigram_total: 0.3008
+    mean_bigram_unique: 0.3055
+    mean_trigram_hapax_fraction: -0.0298
+    mean_trigram_repeated_unique: 0.4104
+    mean_trigram_repetition_rate: 0.0227
+    mean_trigram_total: 0.3014
+    mean_trigram_unique: 0.3075
+  punctuation_density:
+    mean_arrow_density: -0.0591
+    mean_bracket_nonalpha_prefix_count: 1.4250
+    mean_bracket_nonalpha_suffix_count: 0.3350
+    mean_colon_suffix_density: -0.0854
+    mean_id_nonalpha_suffix_density: -0.0694
+  readability:
+    mean_avg_line_length: 0.1895
+    mean_avg_tokens_per_line: 0.1798
+    mean_flesch_adapted: -0.0175
+    mean_fog_adapted: 0.1420
+    mean_total_lines: 0.1204
+  symbol_density:
+    mean_distinct_symbol_types: 0.0664
+    mean_symbol_count: 0.3056
+  vocabulary:
+    mean_mattr: 0.0721
+    mean_raw_ttr: -0.0454
+    mean_total_identifiers: 0.4472
+    mean_unique_identifiers: 0.4018
+  vowel_density:
+    mean_total_chars: 0.3874
+  zipf:
+    mean_r_squared: 0.0056
+    mean_total_tokens: 0.3002
+    mean_vocab_size: 0.3136
+
+returns_typed_error:
+  _doc: "Functions should signal failure via a typed return (e.g. `{:error, reason}`) rather than returning `nil` or `false`."
+  _fix_hint: "Return typed errors like {:error, :not_found} instead of bare :error or nil"
+  _log_baseline: 208.7673
+  branching:
+    mean_branch_count: -0.2092
+    mean_branching_density: -0.3081
+    mean_max_nesting_depth: 1.8360
+    mean_non_blank_count: 0.0989
+  brevity:
+    mean_sample_size: 0.3776
+  casing_entropy:
+    mean_entropy: -0.7806
+    mean_other_count: -0.4385
+    mean_pascal_case_count: 1.1584
+    mean_snake_case_count: 1.2656
+  compression:
+    mean_raw_bytes: 0.7114
+    mean_redundancy: 0.0542
+    mean_unique_line_ratio: 0.2391
+    mean_zlib_bytes: 0.5668
+    mean_zlib_ratio: 0.1446
+  entropy:
+    mean_char_entropy: 0.1388
+    mean_char_max_entropy: 0.0695
+    mean_char_normalized: 0.0692
+    mean_token_entropy: -0.0195
+    mean_token_max_entropy: 0.0863
+    mean_token_normalized: -0.1059
+    mean_total_tokens: 1.0937
+    mean_vocab_size: 0.3776
+  function_metrics:
+    mean_avg_function_lines: 0.1470
+    mean_avg_param_count: 0.0087
+    mean_function_count: -0.0904
+    mean_max_function_lines: 0.1338
+  halstead:
+    mean_N1_total_operators: 1.2868
+    mean_N2_total_operands: 0.8935
+    mean_difficulty: 0.7343
+    mean_effort: 2.0000
+    mean_estimated_bugs: 1.2657
+    mean_length: 1.1609
+    mean_n1_unique_operators: 0.3422
+    mean_n2_unique_operands: 0.5015
+    mean_time_to_implement_seconds: 2.0000
+    mean_vocabulary: 0.4467
+    mean_volume: 1.2657
+  heaps:
+    mean_beta: -0.3791
+    mean_k: 0.7841
+    mean_r_squared: 0.0178
+  identifier_length_variance:
+    mean_max: 0.3245
+    mean_std_dev: 0.3851
+    mean_variance: 0.7704
+  indentation:
+    mean_blank_line_ratio: -0.2464
+    mean_mean_depth: -0.0466
+    mean_variance: 0.0604
+  line_patterns:
+    mean_blank_line_ratio: -0.2464
+    mean_max_nesting_depth: 1.8360
+    mean_string_literal_ratio: -1.0976
+    mean_unique_line_ratio: 0.2365
+  magic_number_density:
+    mean_string_literal_ratio: -1.0976
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 1.2007
+  ngram:
+    mean_bigram_hapax_fraction: -0.2293
+    mean_bigram_repeated_unique: 0.7952
+    mean_bigram_repetition_rate: 0.2117
+    mean_bigram_total: 1.0959
+    mean_bigram_unique: 0.5042
+    mean_trigram_hapax_fraction: -0.0889
+    mean_trigram_repeated_unique: 0.8135
+    mean_trigram_repetition_rate: 0.3853
+    mean_trigram_total: 1.0981
+    mean_trigram_unique: 0.5821
+  punctuation_density:
+    mean_arrow_density: -1.3061
+    mean_bracket_nonalpha_prefix_count: -0.3047
+    mean_colon_suffix_density: -1.3955
+    mean_dot_count: 1.8360
+    mean_id_nonalpha_suffix_density: 0.1318
+    mean_question_mark_density: -1.0680
+  readability:
+    mean_avg_line_length: 0.6431
+    mean_avg_sub_words_per_id: 0.1542
+    mean_avg_tokens_per_line: 0.9948
+    mean_flesch_adapted: -0.2067
+    mean_fog_adapted: 1.0791
+    mean_total_lines: 0.0989
+  symbol_density:
+    mean_density: 0.9451
+    mean_distinct_symbol_types: 0.3470
+    mean_symbol_count: 1.6563
+  vocabulary:
+    mean_mattr: -0.4659
+    mean_raw_ttr: -0.6552
+    mean_total_identifiers: 1.1152
+    mean_unique_identifiers: 0.4603
+  vowel_density:
+    mean_total_chars: 1.1198
+  zipf:
+    mean_exponent: 0.1702
+    mean_r_squared: 0.0411
+    mean_total_tokens: 1.0937
+    mean_vocab_size: 0.3776
+
diff --git a/priv/combined_metrics/file_structure.yml b/priv/combined_metrics/file_structure.yml
new file mode 100644
index 0000000..19418d4
--- /dev/null
+++ b/priv/combined_metrics/file_structure.yml
@@ -0,0 +1,503 @@
+has_consistent_indentation:
+  _doc: "Files should use a single, consistent indentation style with no mixed tabs and spaces."
+  _fix_hint: "Use a consistent indentation width throughout the file (2 or 4 spaces, not mixed)"
+  _log_baseline: -12.7016
+  branching:
+    mean_branching_density: 0.1994
+    mean_non_blank_count: -0.2001
+  compression:
+    mean_raw_bytes: -0.1617
+    mean_redundancy: -0.0442
+    mean_unique_line_ratio: -0.1671
+    mean_zlib_bytes: -0.0805
+    mean_zlib_ratio: -0.0812
+  entropy:
+    mean_char_entropy: 0.0876
+    mean_char_normalized: 0.0877
+  function_metrics:
+    mean_avg_function_lines: -0.1622
+    mean_max_function_lines: -0.1528
+  indentation:
+    mean_blank_line_ratio: 0.3569
+    mean_max_depth: -0.9827
+    mean_mean_depth: -0.6193
+    mean_variance: -2.0000
+  line_patterns:
+    mean_blank_line_ratio: 0.3569
+    mean_unique_line_ratio: -0.0830
+  readability:
+    mean_avg_line_length: 0.0378
+    mean_avg_tokens_per_line: 0.2001
+    mean_flesch_adapted: -0.0112
+    mean_fog_adapted: 0.1818
+    mean_total_lines: -0.2001
+  symbol_density:
+    mean_density: 0.1620
+
+line_count_under_300:
+  _doc: "Files should be under 300 lines; longer files typically violate single responsibility."
+  _fix_hint: "Split large files — extract cohesive groups of functions into separate modules"
+  _log_baseline: -49.2655
+  branching:
+    mean_branch_count: -0.4508
+    mean_branching_density: -0.2446
+    mean_non_blank_count: -0.2063
+  brevity:
+    mean_sample_size: -0.2062
+  casing_entropy:
+    mean_entropy: 0.0366
+    mean_other_count: -0.6011
+    mean_pascal_case_count: 0.1036
+    mean_snake_case_count: -0.1860
+  compression:
+    mean_raw_bytes: -0.2263
+    mean_redundancy: -0.0026
+    mean_unique_line_ratio: 0.0519
+    mean_zlib_bytes: -0.2194
+    mean_zlib_ratio: -0.0069
+  entropy:
+    mean_char_entropy: -0.0072
+    mean_char_max_entropy: -0.0245
+    mean_char_normalized: 0.0173
+    mean_token_entropy: -0.0264
+    mean_token_max_entropy: -0.0433
+    mean_token_normalized: 0.0169
+    mean_total_tokens: -0.1807
+    mean_vocab_size: -0.2062
+  function_metrics:
+    mean_avg_function_lines: 0.1338
+    mean_avg_param_count: -0.0931
+    mean_function_count: -0.3274
+    mean_max_function_lines: 0.0222
+    mean_max_param_count: -0.1036
+  halstead:
+    mean_N1_total_operators: -0.1746
+    mean_N2_total_operands: -0.1868
+    mean_difficulty: 0.0070
+    mean_effort: -0.2194
+    mean_estimated_bugs: -0.2264
+    mean_length: -0.1785
+    mean_n1_unique_operators: -0.0814
+    mean_n2_unique_operands: -0.2752
+    mean_time_to_implement_seconds: -0.2194
+    mean_vocabulary: -0.2238
+    mean_volume: -0.2264
+  heaps:
+    mean_beta: -0.0687
+    mean_k: 0.0978
+    mean_r_squared: -0.0094
+  identifier_length_variance:
+    mean_max: -0.0671
+    mean_mean: -0.0670
+    mean_std_dev: 0.0028
+    mean_variance: 0.0055
+  indentation:
+    mean_blank_line_ratio: -0.4899
+    mean_max_depth: 0.0301
+    mean_mean_depth: 0.0114
+    mean_variance: 0.1685
+  line_patterns:
+    mean_blank_line_ratio: -0.4899
+    mean_string_literal_ratio: 0.0039
+    mean_unique_line_ratio: 0.0561
+  magic_number_density:
+    mean_density: 1.4051
+    mean_magic_number_count: -0.4114
+    mean_string_literal_ratio: 0.0039
+  near_duplicate_blocks_file:
+    mean_block_count: 0.1772
+    mean_sub_block_count: -0.1378
+  ngram:
+    mean_bigram_hapax_fraction: -0.0655
+    mean_bigram_repeated_unique: -0.1356
+    mean_bigram_repetition_rate: 0.0296
+    mean_bigram_total: -0.1809
+    mean_bigram_unique: -0.2260
+    mean_trigram_hapax_fraction: -0.0366
+    mean_trigram_repeated_unique: -0.1208
+    mean_trigram_repetition_rate: 0.0506
+    mean_trigram_total: -0.1812
+    mean_trigram_unique: -0.2220
+  punctuation_density:
+    mean_arrow_density: -0.2511
+    mean_bracket_nonalpha_prefix_count: -0.2342
+    mean_bracket_nonalpha_suffix_count: -0.3472
+    mean_bracket_number_pair_count: -0.1772
+    mean_colon_suffix_density: -0.2045
+    mean_dot_count: -0.0341
+    mean_exclamation_density: 2.0000
+    mean_id_nonalpha_suffix_density: -0.0125
+  readability:
+    mean_avg_line_length: -0.0217
+    mean_avg_sub_words_per_id: -0.0148
+    mean_avg_tokens_per_line: 0.0256
+    mean_flesch_adapted: 0.0146
+    mean_fog_adapted: 0.0323
+    mean_total_lines: -0.2063
+  symbol_density:
+    mean_density: 0.0758
+    mean_distinct_symbol_types: -0.0604
+    mean_symbol_count: -0.1504
+  vocabulary:
+    mean_mattr: -0.1338
+    mean_raw_ttr: -0.0761
+    mean_total_identifiers: -0.1689
+    mean_unique_identifiers: -0.2450
+  vowel_density:
+    mean_total_chars: -0.2359
+  zipf:
+    mean_exponent: 0.0102
+    mean_r_squared: -0.0067
+    mean_total_tokens: -0.1807
+    mean_vocab_size: -0.2062
+
+line_length_under_120:
+  _doc: "Lines should be under 120 characters to avoid horizontal scrolling."
+  _fix_hint: "Wrap lines at 80–120 characters — break long expressions into multiple lines"
+  _log_baseline: -6.2404
+  branching:
+    mean_branching_density: -0.1942
+    mean_non_blank_count: 0.1944
+  brevity:
+    mean_sample_size: -0.0200
+  casing_entropy:
+    mean_entropy: -0.0025
+    mean_snake_case_count: 0.0039
+  compression:
+    mean_raw_bytes: 0.0170
+    mean_redundancy: 0.0140
+    mean_unique_line_ratio: 0.0133
+    mean_zlib_bytes: -0.0077
+    mean_zlib_ratio: 0.0247
+  entropy:
+    mean_char_entropy: -0.0087
+    mean_char_normalized: -0.0076
+    mean_token_entropy: -0.0022
+    mean_token_max_entropy: -0.0041
+    mean_token_normalized: 0.0019
+    mean_total_tokens: -0.0030
+    mean_vocab_size: -0.0200
+  function_metrics:
+    mean_avg_function_lines: 0.2084
+    mean_avg_param_count: -0.0276
+    mean_max_function_lines: 0.2570
+    mean_max_param_count: -0.0944
+  halstead:
+    mean_N1_total_operators: -0.0033
+    mean_N2_total_operands: 0.0022
+    mean_difficulty: 0.0219
+    mean_effort: 0.0160
+    mean_estimated_bugs: -0.0059
+    mean_n1_unique_operators: -0.0081
+    mean_n2_unique_operands: -0.0278
+    mean_time_to_implement_seconds: 0.0160
+    mean_vocabulary: -0.0228
+    mean_volume: -0.0059
+  heaps:
+    mean_beta: -0.0068
+    mean_k: 0.0086
+  identifier_length_variance:
+    mean_mean: -0.0176
+    mean_std_dev: -0.0468
+    mean_variance: -0.0936
+  indentation:
+    mean_blank_line_ratio: -0.0420
+    mean_max_depth: 0.1137
+    mean_mean_depth: 0.1254
+    mean_variance: 0.2595
+  line_patterns:
+    mean_blank_line_ratio: -0.0420
+    mean_string_literal_ratio: -0.0264
+    mean_unique_line_ratio: 0.0181
+  magic_number_density:
+    mean_density: 0.0052
+    mean_string_literal_ratio: -0.0264
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.0477
+  ngram:
+    mean_bigram_hapax_fraction: -0.0141
+    mean_bigram_repeated_unique: 0.0257
+    mean_bigram_repetition_rate: 0.0141
+    mean_bigram_total: -0.0030
+    mean_bigram_unique: -0.0113
+    mean_trigram_hapax_fraction: 0.0017
+    mean_trigram_repeated_unique: -0.0134
+    mean_trigram_total: -0.0030
+    mean_trigram_unique: -0.0043
+  punctuation_density:
+    mean_bracket_nonalpha_prefix_count: -0.0807
+    mean_bracket_nonalpha_suffix_count: -0.1362
+    mean_colon_suffix_density: 0.0705
+    mean_dot_count: -0.0069
+    mean_id_nonalpha_suffix_density: 0.0093
+    mean_question_mark_density: 2.0000
+  readability:
+    mean_avg_line_length: -0.1816
+    mean_avg_sub_words_per_id: -0.0066
+    mean_avg_tokens_per_line: -0.1974
+    mean_flesch_adapted: 0.0402
+    mean_fog_adapted: -0.2009
+    mean_total_lines: 0.1944
+  symbol_density:
+    mean_density: -0.0247
+    mean_distinct_symbol_types: -0.0130
+    mean_symbol_count: -0.0078
+  vocabulary:
+    mean_mattr: -0.0207
+    mean_raw_ttr: -0.0312
+    mean_total_identifiers: 0.0036
+    mean_unique_identifiers: -0.0276
+  vowel_density:
+    mean_total_chars: -0.0140
+  zipf:
+    mean_exponent: 0.0039
+    mean_total_tokens: -0.0030
+    mean_vocab_size: -0.0200
+
+no_magic_numbers:
+  _doc: "Numeric literals should be extracted to named constants rather than used inline."
+  _fix_hint: "Replace literal numbers with named constants or module attributes"
+  _log_baseline: 107.5222
+  branching:
+    mean_branch_count: -0.4352
+    mean_branching_density: -0.9103
+    mean_non_blank_count: 0.4762
+  brevity:
+    mean_sample_size: 0.3955
+  casing_entropy:
+    mean_entropy: -0.4640
+    mean_snake_case_count: 0.7640
+  compression:
+    mean_raw_bytes: 0.7713
+    mean_redundancy: 0.1328
+    mean_unique_line_ratio: 0.1073
+    mean_zlib_bytes: 0.5072
+    mean_zlib_ratio: 0.2642
+  entropy:
+    mean_char_entropy: 0.0481
+    mean_char_normalized: 0.0481
+    mean_token_entropy: 0.0769
+    mean_token_max_entropy: 0.0825
+    mean_total_tokens: 0.4877
+    mean_vocab_size: 0.3955
+  function_metrics:
+    mean_avg_function_lines: -0.5888
+    mean_avg_param_count: -0.1339
+    mean_function_count: 0.5327
+    mean_max_function_lines: -0.2655
+  halstead:
+    mean_N1_total_operators: 0.1749
+    mean_N2_total_operands: 0.4966
+    mean_difficulty: -0.0338
+    mean_effort: 0.3387
+    mean_estimated_bugs: 0.3723
+    mean_length: 0.3056
+    mean_n1_unique_operators: -0.0901
+    mean_n2_unique_operands: 0.4402
+    mean_time_to_implement_seconds: 0.3387
+    mean_vocabulary: 0.3159
+    mean_volume: 0.3724
+  heaps:
+    mean_beta: -0.1294
+    mean_k: 0.7952
+    mean_r_squared: -0.0645
+  identifier_length_variance:
+    mean_max: 0.2172
+    mean_mean: 0.5105
+    mean_std_dev: 0.5395
+    mean_variance: 1.0791
+  indentation:
+    mean_blank_line_ratio: 0.3137
+    mean_mean_depth: -0.4612
+    mean_variance: -0.5503
+  line_patterns:
+    mean_blank_line_ratio: 0.3137
+    mean_string_literal_ratio: -0.5060
+    mean_unique_line_ratio: 0.1502
+  magic_number_density:
+    mean_density: -1.2903
+    mean_magic_number_count: -0.8032
+    mean_string_literal_ratio: -0.5060
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.3466
+  ngram:
+    mean_bigram_hapax_fraction: -0.1520
+    mean_bigram_repeated_unique: 0.7630
+    mean_bigram_repetition_rate: 0.1469
+    mean_bigram_total: 0.4887
+    mean_bigram_unique: 0.4248
+    mean_trigram_hapax_fraction: 0.0849
+    mean_trigram_repeated_unique: 0.0415
+    mean_trigram_repetition_rate: -0.2233
+    mean_trigram_total: 0.4896
+    mean_trigram_unique: 0.5215
+  punctuation_density:
+    mean_arrow_density: -1.4573
+    mean_bracket_nonalpha_suffix_count: 0.5999
+    mean_colon_suffix_density: 0.5811
+    mean_id_nonalpha_suffix_density: -0.1238
+    mean_question_mark_density: -0.8032
+  readability:
+    mean_avg_line_length: 0.3048
+    mean_avg_sub_words_per_id: 0.3883
+    mean_flesch_adapted: -0.7069
+    mean_fog_adapted: 2.0000
+    mean_total_lines: 0.4762
+  symbol_density:
+    mean_density: -0.3071
+    mean_symbol_count: 0.4654
+  vocabulary:
+    mean_mattr: 0.3317
+    mean_total_identifiers: 0.6600
+    mean_unique_identifiers: 0.6581
+  vowel_density:
+    mean_total_chars: 1.1705
+  zipf:
+    mean_exponent: -0.1353
+    mean_r_squared: -0.0320
+    mean_total_tokens: 0.4877
+    mean_vocab_size: 0.3955
+
+single_responsibility:
+  _doc: "Each file should have one primary concern — low complexity spread across few, focused functions."
+  _fix_hint: "Split the module — each file should have one primary purpose"
+  _log_baseline: -35.4996
+  branching:
+    mean_branch_count: -0.0678
+    mean_branching_density: 0.1364
+    mean_max_nesting_depth: -0.1093
+    mean_non_blank_count: -0.2043
+  brevity:
+    mean_sample_size: -0.0864
+  casing_entropy:
+    mean_other_count: -0.7475
+    mean_pascal_case_count: 0.0470
+    mean_snake_case_count: -0.1816
+  compression:
+    mean_raw_bytes: -0.1908
+    mean_redundancy: -0.0351
+    mean_unique_line_ratio: 0.0316
+    mean_zlib_bytes: -0.1293
+    mean_zlib_ratio: -0.0616
+  entropy:
+    mean_char_entropy: 0.0078
+    mean_char_max_entropy: -0.0021
+    mean_char_normalized: 0.0099
+    mean_token_entropy: 0.0014
+    mean_token_max_entropy: -0.0182
+    mean_token_normalized: 0.0196
+    mean_total_tokens: -0.1489
+    mean_vocab_size: -0.0864
+  function_metrics:
+    mean_avg_function_lines: 0.1696
+    mean_avg_param_count: -0.0805
+    mean_function_count: -0.4114
+    mean_max_param_count: -0.2962
+  halstead:
+    mean_N1_total_operators: -0.1395
+    mean_N2_total_operands: -0.1701
+    mean_difficulty: 0.0527
+    mean_effort: -0.1183
+    mean_estimated_bugs: -0.1710
+    mean_length: -0.1498
+    mean_n1_unique_operators: 0.0541
+    mean_n2_unique_operands: -0.1687
+    mean_time_to_implement_seconds: -0.1183
+    mean_vocabulary: -0.0965
+    mean_volume: -0.1710
+  heaps:
+    mean_beta: -0.0154
+    mean_k: 0.0801
+    mean_r_squared: -0.0163
+  identifier_length_variance:
+    mean_max: -0.0836
+    mean_mean: -0.0346
+    mean_std_dev: -0.0825
+    mean_variance: -0.1650
+  indentation:
+    mean_blank_line_ratio: 0.0458
+    mean_mean_depth: -0.0476
+    mean_variance: -0.0931
+  line_patterns:
+    mean_blank_line_ratio: 0.0458
+    mean_max_nesting_depth: -0.1093
+    mean_string_literal_ratio: -0.1759
+    mean_unique_line_ratio: 0.0324
+  magic_number_density:
+    mean_density: 0.1469
+    mean_string_literal_ratio: -0.1759
+  near_duplicate_blocks_file:
+    mean_sub_block_count: -0.1348
+  ngram:
+    mean_bigram_hapax_fraction: 0.0075
+    mean_bigram_repeated_unique: -0.1303
+    mean_bigram_repetition_rate: -0.0207
+    mean_bigram_total: -0.1492
+    mean_bigram_unique: -0.1162
+    mean_trigram_hapax_fraction: 0.0132
+    mean_trigram_repeated_unique: -0.1793
+    mean_trigram_repetition_rate: -0.0466
+    mean_trigram_total: -0.1495
+    mean_trigram_unique: -0.1273
+  punctuation_density:
+    mean_arrow_density: -0.1462
+    mean_bracket_nonalpha_prefix_count: -0.0859
+    mean_bracket_nonalpha_suffix_count: -0.4201
+    mean_colon_suffix_density: -0.4720
+    mean_dot_count: -0.0630
+    mean_exclamation_density: 2.0000
+    mean_id_nonalpha_suffix_density: -0.0499
+    mean_question_mark_density: 0.4596
+  readability:
+    mean_avg_line_length: 0.0137
+    mean_avg_sub_words_per_id: -0.0377
+    mean_avg_tokens_per_line: 0.0553
+    mean_flesch_adapted: 0.0348
+    mean_fog_adapted: -0.0587
+    mean_total_lines: -0.2043
+  symbol_density:
+    mean_density: 0.0683
+    mean_distinct_symbol_types: 0.0284
+    mean_symbol_count: -0.1225
+  vocabulary:
+    mean_mattr: -0.0474
+    mean_raw_ttr: 0.0249
+    mean_total_identifiers: -0.1662
+    mean_unique_identifiers: -0.1414
+  vowel_density:
+    mean_total_chars: -0.2009
+  zipf:
+    mean_exponent: -0.0209
+    mean_r_squared: -0.0043
+    mean_total_tokens: -0.1489
+    mean_vocab_size: -0.0864
+
+uses_standard_indentation_width:
+  _doc: "Indentation should use consistent multiples of 2 or 4 spaces throughout the file."
+  _fix_hint: "Use the project-standard 2-space indentation throughout"
+  _log_baseline: -17.9172
+  compression:
+    mean_raw_bytes: -0.2512
+    mean_redundancy: -0.0906
+    mean_zlib_bytes: -0.0351
+    mean_zlib_ratio: -0.2161
+  entropy:
+    mean_char_entropy: 0.1510
+    mean_char_normalized: 0.1510
+  function_metrics:
+    mean_avg_function_lines: 0.0361
+  indentation:
+    mean_blank_line_ratio: 0.2077
+    mean_max_depth: -1.0000
+    mean_mean_depth: -1.0000
+    mean_variance: -2.0000
+  line_patterns:
+    mean_blank_line_ratio: 0.2077
+  punctuation_density:
+    mean_exclamation_density: 0.2630
+    mean_question_mark_density: 0.2630
+  readability:
+    mean_avg_line_length: -0.2644
+  symbol_density:
+    mean_density: 0.2512
+
diff --git a/priv/combined_metrics/function_design.yml b/priv/combined_metrics/function_design.yml
new file mode 100644
index 0000000..6824ebb
--- /dev/null
+++ b/priv/combined_metrics/function_design.yml
@@ -0,0 +1,820 @@
+boolean_function_has_question_mark:
+  _doc: "Functions returning a boolean should end with `?` (Elixir/Ruby) or start with `is_`/`has_` (JS/Python)."
+  _fix_hint: "Add a ? suffix to boolean-returning functions (e.g., valid? instead of is_valid)"
+  _log_baseline: 7.0991
+  brevity:
+    mean_sample_size: 0.0085
+  compression:
+    mean_raw_bytes: 0.0063
+    mean_zlib_bytes: 0.0085
+  entropy:
+    mean_char_entropy: 0.0045
+    mean_char_max_entropy: 0.0028
+    mean_token_entropy: 0.0034
+    mean_total_tokens: 0.0248
+    mean_vocab_size: 0.0085
+  heaps:
+    mean_beta: -0.0104
+    mean_k: 0.0270
+  ngram:
+    mean_bigram_hapax_fraction: -0.0039
+    mean_bigram_repeated_unique: 0.0190
+    mean_bigram_repetition_rate: 0.0261
+    mean_bigram_total: 0.0250
+    mean_bigram_unique: 0.0039
+    mean_trigram_repeated_unique: 0.0300
+    mean_trigram_repetition_rate: 0.0180
+    mean_trigram_total: 0.0251
+    mean_trigram_unique: 0.0207
+  punctuation_density:
+    mean_bracket_nonalpha_prefix_count: 1.0697
+    mean_exclamation_density: -0.0344
+    mean_id_nonalpha_suffix_density: -0.0248
+    mean_question_mark_density: -2.0000
+  readability:
+    mean_avg_line_length: 0.0067
+    mean_avg_tokens_per_line: 0.0248
+    mean_fog_adapted: 0.0248
+  symbol_density:
+    mean_density: 0.0490
+    mean_distinct_symbol_types: 0.0404
+    mean_symbol_count: 0.0554
+  zipf:
+    mean_exponent: 0.0072
+    mean_total_tokens: 0.0248
+    mean_vocab_size: 0.0085
+
+cyclomatic_complexity_under_10:
+  _doc: "Functions should have a cyclomatic complexity under 10."
+  _fix_hint: "Reduce branching — extract complex conditionals into helper functions"
+  _log_baseline: -1.6476
+  branching:
+    mean_branch_count: -0.2373
+    mean_branching_density: -0.1952
+    mean_non_blank_count: -0.0421
+  casing_entropy:
+    mean_entropy: 0.1030
+    mean_other_count: 0.3306
+    mean_snake_case_count: 0.0284
+  compression:
+    mean_raw_bytes: -0.0162
+    mean_redundancy: -0.0172
+    mean_unique_line_ratio: -0.0305
+    mean_zlib_bytes: 0.0186
+    mean_zlib_ratio: -0.0347
+  entropy:
+    mean_char_entropy: 0.0349
+    mean_char_max_entropy: 0.0016
+    mean_char_normalized: 0.0333
+    mean_token_entropy: -0.0050
+    mean_token_normalized: -0.0050
+    mean_total_tokens: 0.0437
+  function_metrics:
+    mean_avg_function_lines: -0.4757
+    mean_function_count: 0.4636
+    mean_max_function_lines: -0.5038
+  halstead:
+    mean_N1_total_operators: 0.0708
+    mean_N2_total_operands: 0.0358
+    mean_difficulty: 0.0472
+    mean_effort: 0.1087
+    mean_estimated_bugs: 0.0615
+    mean_length: 0.0605
+    mean_n1_unique_operators: 0.0114
+    mean_time_to_implement_seconds: 0.1087
+    mean_vocabulary: 0.0043
+    mean_volume: 0.0615
+  heaps:
+    mean_beta: -0.0367
+    mean_k: 0.0672
+    mean_r_squared: 0.0049
+  identifier_length_variance:
+    mean_mean: 0.0092
+    mean_std_dev: 0.0209
+    mean_variance: 0.0418
+  indentation:
+    mean_blank_line_ratio: 0.1655
+    mean_max_depth: -0.2086
+    mean_mean_depth: -0.2901
+    mean_variance: -0.4637
+  line_patterns:
+    mean_blank_line_ratio: 0.1655
+    mean_string_literal_ratio: -0.0439
+    mean_unique_line_ratio: 0.0055
+  magic_number_density:
+    mean_density: -0.0329
+    mean_string_literal_ratio: -0.0439
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.0994
+  ngram:
+    mean_bigram_hapax_fraction: -0.0068
+    mean_bigram_repeated_unique: 0.0301
+    mean_bigram_repetition_rate: 0.0115
+    mean_bigram_total: 0.0438
+    mean_bigram_unique: 0.0192
+    mean_trigram_hapax_fraction: -0.0027
+    mean_trigram_repeated_unique: 0.0456
+    mean_trigram_repetition_rate: 0.0055
+    mean_trigram_total: 0.0440
+    mean_trigram_unique: 0.0388
+  punctuation_density:
+    mean_arrow_density: -0.4960
+    mean_bracket_nonalpha_prefix_count: 0.2488
+    mean_bracket_nonalpha_suffix_count: 0.3306
+    mean_colon_suffix_density: 0.2760
+    mean_dot_count: -0.3005
+    mean_exclamation_density: 2.0000
+    mean_id_nonalpha_suffix_density: 0.0616
+  readability:
+    mean_avg_line_length: 0.0257
+    mean_avg_sub_words_per_id: 0.0067
+    mean_avg_tokens_per_line: 0.0858
+    mean_flesch_adapted: -0.0140
+    mean_fog_adapted: 0.1035
+    mean_total_lines: -0.0421
+  symbol_density:
+    mean_density: 0.0552
+    mean_distinct_symbol_types: -0.0172
+    mean_symbol_count: 0.0391
+  vocabulary:
+    mean_mattr: -0.0325
+    mean_raw_ttr: -0.0309
+    mean_total_identifiers: 0.0382
+    mean_unique_identifiers: 0.0074
+  vowel_density:
+    mean_total_chars: 0.0474
+  zipf:
+    mean_exponent: 0.0120
+    mean_r_squared: 0.0057
+    mean_total_tokens: 0.0437
+
+has_verb_in_name:
+  _doc: "Function names should contain a verb describing the action performed."
+  _fix_hint: "Start function names with a verb (get_, fetch_, build_, compute_, validate_)"
+  _log_baseline: 15.9117
+  compression:
+    mean_raw_bytes: 0.0990
+    mean_redundancy: -0.0473
+    mean_zlib_bytes: 0.2439
+    mean_zlib_ratio: -0.1449
+  identifier_length_variance:
+    mean_max: 0.9396
+    mean_mean: 0.1989
+    mean_std_dev: 1.0001
+    mean_variance: 2.0000
+  punctuation_density:
+    mean_exclamation_density: -0.1305
+  readability:
+    mean_avg_line_length: 0.1026
+    mean_avg_sub_words_per_id: 0.1614
+    mean_flesch_adapted: -0.1605
+    mean_fog_adapted: 1.6084
+  symbol_density:
+    mean_density: -0.1005
+  vowel_density:
+    mean_total_chars: 0.1989
+
+is_less_than_20_lines:
+  _doc: "Functions should be 20 lines or fewer."
+  _fix_hint: "Split long functions — each function should fit on one screen (under 20 lines)"
+  _log_baseline: 23.1945
+  branching:
+    mean_branch_count: -0.0820
+    mean_branching_density: -0.1010
+    mean_max_nesting_depth: -0.1156
+    mean_non_blank_count: 0.0188
+  brevity:
+    mean_sample_size: 0.0165
+  casing_entropy:
+    mean_entropy: 0.0640
+    mean_other_count: 0.6266
+    mean_pascal_case_count: 0.0440
+    mean_snake_case_count: 0.0800
+  compression:
+    mean_raw_bytes: 0.0746
+    mean_redundancy: 0.0227
+    mean_unique_line_ratio: -0.0334
+    mean_zlib_bytes: 0.0366
+    mean_zlib_ratio: 0.0379
+  entropy:
+    mean_char_entropy: 0.0020
+    mean_token_entropy: -0.0041
+    mean_token_max_entropy: 0.0035
+    mean_token_normalized: -0.0076
+    mean_total_tokens: 0.0759
+    mean_vocab_size: 0.0165
+  function_metrics:
+    mean_avg_function_lines: -0.3598
+    mean_avg_param_count: 0.1156
+    mean_function_count: 0.3705
+    mean_max_function_lines: -0.4532
+    mean_max_param_count: 0.0820
+  halstead:
+    mean_N1_total_operators: 0.0857
+    mean_N2_total_operands: 0.0965
+    mean_difficulty: 0.0624
+    mean_effort: 0.1550
+    mean_estimated_bugs: 0.0926
+    mean_length: 0.0895
+    mean_n1_unique_operators: -0.0097
+    mean_n2_unique_operands: 0.0245
+    mean_time_to_implement_seconds: 0.1550
+    mean_vocabulary: 0.0143
+    mean_volume: 0.0926
+  heaps:
+    mean_k: -0.0254
+  identifier_length_variance:
+    mean_mean: 0.0149
+    mean_std_dev: 0.0313
+    mean_variance: 0.0625
+  indentation:
+    mean_blank_line_ratio: -0.0440
+    mean_mean_depth: -0.0962
+    mean_variance: -0.1115
+  line_patterns:
+    mean_blank_line_ratio: -0.0440
+    mean_max_nesting_depth: -0.1156
+    mean_string_literal_ratio: -0.0774
+    mean_unique_line_ratio: -0.0188
+  magic_number_density:
+    mean_density: 0.0389
+    mean_magic_number_count: 0.1156
+    mean_string_literal_ratio: -0.0774
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.1886
+  ngram:
+    mean_bigram_hapax_fraction: -0.0508
+    mean_bigram_repeated_unique: 0.1067
+    mean_bigram_repetition_rate: 0.0562
+    mean_bigram_total: 0.0760
+    mean_bigram_unique: 0.0228
+    mean_trigram_hapax_fraction: -0.0300
+    mean_trigram_repeated_unique: 0.1516
+    mean_trigram_repetition_rate: 0.1014
+    mean_trigram_total: 0.0761
+    mean_trigram_unique: 0.0386
+  punctuation_density:
+    mean_arrow_density: -0.3892
+    mean_bracket_nonalpha_prefix_count: 0.0418
+    mean_bracket_nonalpha_suffix_count: 0.0476
+    mean_colon_suffix_density: 0.0941
+    mean_dot_count: 0.0717
+    mean_exclamation_density: -0.0820
+    mean_id_nonalpha_suffix_density: 0.0518
+    mean_question_mark_density: -2.0000
+  readability:
+    mean_avg_line_length: 0.0576
+    mean_avg_sub_words_per_id: -0.0034
+    mean_avg_tokens_per_line: 0.0570
+    mean_flesch_adapted: -0.0039
+    mean_fog_adapted: 0.0868
+    mean_total_lines: 0.0188
+  symbol_density:
+    mean_density: -0.0084
+    mean_distinct_symbol_types: 0.0127
+    mean_symbol_count: 0.0662
+  vocabulary:
+    mean_mattr: -0.0368
+    mean_raw_ttr: -0.0647
+    mean_total_identifiers: 0.0864
+    mean_unique_identifiers: 0.0218
+  vowel_density:
+    mean_total_chars: 0.1013
+  zipf:
+    mean_exponent: 0.0225
+    mean_r_squared: 0.0030
+    mean_total_tokens: 0.0759
+    mean_vocab_size: 0.0165
+
+nesting_depth_under_4:
+  _doc: "Code should not nest deeper than 4 levels."
+  _fix_hint: "Reduce nesting — use early returns, guards, or extract inner blocks"
+  _log_baseline: 1.1322
+  branching:
+    mean_branch_count: -0.3267
+    mean_branching_density: -0.2061
+    mean_max_nesting_depth: 0.2061
+    mean_non_blank_count: -0.1206
+  brevity:
+    mean_sample_size: 0.0178
+  casing_entropy:
+    mean_entropy: -0.0358
+    mean_other_count: 0.2917
+    mean_pascal_case_count: -0.2725
+    mean_snake_case_count: 0.1015
+  compression:
+    mean_raw_bytes: -0.0069
+    mean_redundancy: -0.0076
+    mean_unique_line_ratio: -0.0028
+    mean_zlib_bytes: 0.0117
+    mean_zlib_ratio: -0.0186
+  entropy:
+    mean_char_entropy: 0.0715
+    mean_char_max_entropy: -0.0017
+    mean_char_normalized: 0.0732
+    mean_token_entropy: -0.0118
+    mean_token_max_entropy: 0.0042
+    mean_token_normalized: -0.0161
+    mean_total_tokens: 0.1047
+    mean_vocab_size: 0.0178
+  function_metrics:
+    mean_avg_function_lines: -0.6349
+    mean_function_count: 0.5787
+    mean_max_function_lines: -0.3375
+  halstead:
+    mean_N1_total_operators: 0.1525
+    mean_N2_total_operands: 0.0950
+    mean_difficulty: 0.0991
+    mean_effort: 0.2385
+    mean_estimated_bugs: 0.1394
+    mean_length: 0.1347
+    mean_n1_unique_operators: 0.0229
+    mean_n2_unique_operands: 0.0188
+    mean_time_to_implement_seconds: 0.2385
+    mean_vocabulary: 0.0202
+    mean_volume: 0.1394
+  heaps:
+    mean_beta: -0.0464
+    mean_k: 0.0845
+  identifier_length_variance:
+    mean_mean: 0.0488
+    mean_std_dev: 0.1849
+    mean_variance: 0.3698
+  indentation:
+    mean_blank_line_ratio: 0.5622
+    mean_max_depth: -0.3155
+    mean_mean_depth: -0.3651
+    mean_variance: -0.6050
+  line_patterns:
+    mean_blank_line_ratio: 0.5622
+    mean_max_nesting_depth: 0.2061
+    mean_string_literal_ratio: -0.1046
+    mean_unique_line_ratio: 0.0786
+  magic_number_density:
+    mean_string_literal_ratio: -0.1046
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.1999
+  ngram:
+    mean_bigram_hapax_fraction: -0.0645
+    mean_bigram_repeated_unique: 0.1420
+    mean_bigram_repetition_rate: 0.0534
+    mean_bigram_total: 0.1049
+    mean_bigram_unique: 0.0292
+    mean_trigram_hapax_fraction: -0.0170
+    mean_trigram_repeated_unique: 0.1274
+    mean_trigram_repetition_rate: 0.0457
+    mean_trigram_total: 0.1052
+    mean_trigram_unique: 0.0686
+  punctuation_density:
+    mean_arrow_density: 0.9701
+    mean_bracket_nonalpha_prefix_count: 0.1748
+    mean_bracket_nonalpha_suffix_count: 0.9451
+    mean_colon_suffix_density: 0.8804
+    mean_dot_count: -0.2520
+    mean_exclamation_density: 2.0000
+    mean_id_nonalpha_suffix_density: 0.0946
+    mean_question_mark_density: -0.1977
+  readability:
+    mean_avg_line_length: 0.1152
+    mean_avg_sub_words_per_id: 0.0220
+    mean_avg_tokens_per_line: 0.2252
+    mean_flesch_adapted: -0.0374
+    mean_fog_adapted: 0.2252
+    mean_total_lines: -0.1206
+  symbol_density:
+    mean_density: 0.1426
+    mean_symbol_count: 0.1355
+  vocabulary:
+    mean_mattr: -0.0321
+    mean_raw_ttr: -0.0555
+    mean_total_identifiers: 0.0987
+    mean_unique_identifiers: 0.0432
+  vowel_density:
+    mean_total_chars: 0.1475
+  zipf:
+    mean_exponent: 0.0250
+    mean_r_squared: 0.0156
+    mean_total_tokens: 0.1047
+    mean_vocab_size: 0.0178
+
+no_boolean_parameter:
+  _doc: "Functions should not take boolean parameters — a flag usually means the function does two things."
+  _fix_hint: "Replace boolean parameters with two separate functions or use an options map"
+  _log_baseline: 3.0928
+  branching:
+    mean_branch_count: -2.0000
+    mean_branching_density: 1.0271
+    mean_max_nesting_depth: -0.3263
+    mean_non_blank_count: -0.0383
+  brevity:
+    mean_sample_size: -0.0253
+  casing_entropy:
+    mean_entropy: 0.0155
+    mean_pascal_case_count: 0.1180
+    mean_snake_case_count: 0.0762
+  compression:
+    mean_raw_bytes: 0.0435
+    mean_redundancy: 0.0777
+    mean_unique_line_ratio: -0.0656
+    mean_zlib_bytes: -0.1055
+    mean_zlib_ratio: 0.1490
+  entropy:
+    mean_char_entropy: 0.0152
+    mean_char_normalized: 0.0153
+    mean_token_entropy: -0.0129
+    mean_token_max_entropy: -0.0055
+    mean_token_normalized: -0.0073
+    mean_total_tokens: 0.0692
+    mean_vocab_size: -0.0253
+  function_metrics:
+    mean_avg_function_lines: -0.3850
+    mean_avg_param_count: -0.2935
+    mean_function_count: 0.4338
+    mean_max_function_lines: -0.5579
+  halstead:
+    mean_N1_total_operators: 0.0393
+    mean_N2_total_operands: 0.0832
+    mean_difficulty: 0.0207
+    mean_effort: 0.0660
+    mean_estimated_bugs: 0.0453
+    mean_length: 0.0543
+    mean_n1_unique_operators: -0.0806
+    mean_n2_unique_operands: -0.0181
+    mean_time_to_implement_seconds: 0.0660
+    mean_vocabulary: -0.0374
+    mean_volume: 0.0453
+  heaps:
+    mean_beta: -0.0314
+    mean_k: 0.0620
+  identifier_length_variance:
+    mean_mean: 0.0178
+    mean_std_dev: 0.1693
+    mean_variance: 0.3386
+  indentation:
+    mean_blank_line_ratio: 0.4402
+    mean_max_depth: -0.5579
+    mean_mean_depth: -0.2880
+    mean_variance: -0.8414
+  line_patterns:
+    mean_blank_line_ratio: 0.4402
+    mean_max_nesting_depth: -0.3263
+    mean_string_literal_ratio: 0.0206
+    mean_unique_line_ratio: 0.0101
+  magic_number_density:
+    mean_string_literal_ratio: 0.0206
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.2775
+  ngram:
+    mean_bigram_hapax_fraction: -0.1940
+    mean_bigram_repeated_unique: 0.1467
+    mean_bigram_repetition_rate: 0.1504
+    mean_bigram_total: 0.0694
+    mean_bigram_unique: -0.1127
+    mean_trigram_hapax_fraction: -0.2208
+    mean_trigram_repeated_unique: 0.3783
+    mean_trigram_repetition_rate: 0.3150
+    mean_trigram_total: 0.0695
+    mean_trigram_unique: -0.1019
+  punctuation_density:
+    mean_bracket_nonalpha_prefix_count: 0.1152
+    mean_bracket_nonalpha_suffix_count: 0.1075
+    mean_colon_suffix_density: -0.2793
+    mean_dot_count: 0.1538
+    mean_exclamation_density: -0.0435
+    mean_id_nonalpha_suffix_density: 0.0357
+  readability:
+    mean_avg_line_length: 0.0817
+    mean_avg_sub_words_per_id: 0.0160
+    mean_avg_tokens_per_line: 0.1075
+    mean_flesch_adapted: -0.0254
+    mean_fog_adapted: 0.2928
+    mean_total_lines: -0.0383
+  symbol_density:
+    mean_density: 0.0479
+    mean_symbol_count: 0.0916
+  vocabulary:
+    mean_mattr: -0.0611
+    mean_raw_ttr: -0.0924
+    mean_total_identifiers: 0.0811
+    mean_unique_identifiers: -0.0114
+  vowel_density:
+    mean_total_chars: 0.0989
+  zipf:
+    mean_exponent: 0.0374
+    mean_total_tokens: 0.0692
+    mean_vocab_size: -0.0253
+
+no_magic_numbers:
+  _doc: "Numeric literals should be named constants, not inline magic numbers."
+  _fix_hint: "Replace magic numbers inside functions with named module attributes or constants"
+  _log_baseline: 48.6069
+  branching:
+    mean_branch_count: -0.2708
+    mean_branching_density: -0.1682
+    mean_non_blank_count: -0.1029
+  brevity:
+    mean_sample_size: 0.1527
+  casing_entropy:
+    mean_entropy: -0.2876
+    mean_snake_case_count: 0.4222
+  compression:
+    mean_raw_bytes: 0.3823
+    mean_redundancy: 0.0584
+    mean_unique_line_ratio: 0.2269
+    mean_zlib_bytes: 0.2473
+    mean_zlib_ratio: 0.1350
+  entropy:
+    mean_char_entropy: 0.0661
+    mean_char_normalized: 0.0624
+    mean_token_entropy: 0.0148
+    mean_token_max_entropy: 0.0355
+    mean_token_normalized: -0.0207
+    mean_total_tokens: 0.2834
+    mean_vocab_size: 0.1527
+  function_metrics:
+    mean_avg_function_lines: -0.8758
+    mean_function_count: 0.4111
+  halstead:
+    mean_N1_total_operators: 0.1953
+    mean_N2_total_operands: 0.2960
+    mean_difficulty: 0.0408
+    mean_effort: 0.3105
+    mean_estimated_bugs: 0.2698
+    mean_length: 0.2359
+    mean_n1_unique_operators: -0.0413
+    mean_n2_unique_operands: 0.2139
+    mean_time_to_implement_seconds: 0.3105
+    mean_vocabulary: 0.1447
+    mean_volume: 0.2697
+  heaps:
+    mean_beta: -0.1129
+    mean_k: 0.5236
+    mean_r_squared: -0.0256
+  identifier_length_variance:
+    mean_max: 0.0987
+    mean_mean: 0.3701
+    mean_std_dev: 0.3918
+    mean_variance: 0.7835
+  indentation:
+    mean_blank_line_ratio: 0.2374
+    mean_mean_depth: -0.3518
+    mean_variance: -0.4760
+  line_patterns:
+    mean_blank_line_ratio: 0.2374
+    mean_string_literal_ratio: -0.2880
+    mean_unique_line_ratio: 0.2337
+  magic_number_density:
+    mean_density: -0.2831
+    mean_string_literal_ratio: -0.2880
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.2708
+  ngram:
+    mean_bigram_hapax_fraction: -0.1437
+    mean_bigram_repeated_unique: 0.4787
+    mean_bigram_repetition_rate: 0.1545
+    mean_bigram_total: 0.2844
+    mean_bigram_unique: 0.1437
+    mean_trigram_hapax_fraction: -0.0207
+    mean_trigram_repeated_unique: 0.2787
+    mean_trigram_repetition_rate: 0.1465
+    mean_trigram_total: 0.2854
+    mean_trigram_unique: 0.1843
+  punctuation_density:
+    mean_arrow_density: -1.1699
+    mean_bracket_nonalpha_suffix_count: 2.0000
+    mean_colon_suffix_density: 1.9476
+    mean_id_nonalpha_suffix_density: 0.3448
+  readability:
+    mean_avg_line_length: 0.5035
+    mean_avg_sub_words_per_id: 0.2699
+    mean_avg_tokens_per_line: 0.3863
+    mean_flesch_adapted: -0.3819
+    mean_fog_adapted: 1.0656
+    mean_total_lines: -0.1029
+  symbol_density:
+    mean_density: -0.0314
+    mean_distinct_symbol_types: 0.0644
+    mean_symbol_count: 0.3512
+  vocabulary:
+    mean_mattr: 0.0054
+    mean_raw_ttr: -0.0161
+    mean_total_identifiers: 0.3860
+    mean_unique_identifiers: 0.3699
+  vowel_density:
+    mean_total_chars: 0.7561
+  zipf:
+    mean_exponent: 0.0164
+    mean_r_squared: 0.0321
+    mean_total_tokens: 0.2834
+    mean_vocab_size: 0.1527
+
+parameter_count_under_4:
+  _doc: "Functions should take fewer than 4 parameters."
+  _fix_hint: "Reduce parameter count — group related params into a struct or options map"
+  _log_baseline: 1.6218
+  branching:
+    mean_non_blank_count: 0.0967
+  brevity:
+    mean_sample_size: 0.0261
+  casing_entropy:
+    mean_entropy: 0.5987
+    mean_other_count: 0.5408
+    mean_pascal_case_count: 0.2329
+    mean_snake_case_count: -0.0580
+  compression:
+    mean_raw_bytes: -0.0343
+    mean_redundancy: -0.0308
+    mean_unique_line_ratio: -0.0166
+    mean_zlib_bytes: 0.0291
+    mean_zlib_ratio: -0.0634
+  entropy:
+    mean_char_entropy: 0.0082
+    mean_char_max_entropy: 0.0175
+    mean_char_normalized: -0.0093
+    mean_token_entropy: 0.0206
+    mean_token_max_entropy: 0.0063
+    mean_token_normalized: 0.0144
+    mean_total_tokens: -0.0335
+    mean_vocab_size: 0.0261
+  function_metrics:
+    mean_avg_function_lines: 0.1262
+    mean_avg_param_count: -0.3179
+    mean_function_count: -0.0320
+    mean_max_function_lines: 0.2037
+    mean_max_param_count: -0.2847
+  halstead:
+    mean_N1_total_operators: -0.0264
+    mean_N2_total_operands: -0.0507
+    mean_difficulty: 0.0180
+    mean_effort: -0.0147
+    mean_estimated_bugs: -0.0326
+    mean_length: -0.0353
+    mean_n1_unique_operators: 0.0613
+    mean_n2_unique_operands: -0.0074
+    mean_time_to_implement_seconds: -0.0147
+    mean_vocabulary: 0.0108
+    mean_volume: -0.0327
+  heaps:
+    mean_beta: 0.0179
+    mean_k: -0.0082
+    mean_r_squared: -0.0062
+  identifier_length_variance:
+    mean_mean: -0.0044
+    mean_std_dev: -0.0221
+    mean_variance: -0.0442
+  indentation:
+    mean_blank_line_ratio: 0.0518
+    mean_max_depth: 0.1362
+    mean_mean_depth: 0.0506
+    mean_variance: 0.1451
+  line_patterns:
+    mean_blank_line_ratio: 0.0518
+    mean_string_literal_ratio: 0.1674
+    mean_unique_line_ratio: -0.0137
+  magic_number_density:
+    mean_density: -2.0000
+    mean_string_literal_ratio: 0.1674
+  ngram:
+    mean_bigram_hapax_fraction: 0.0479
+    mean_bigram_repeated_unique: -0.0222
+    mean_bigram_repetition_rate: -0.0480
+    mean_bigram_total: -0.0336
+    mean_bigram_unique: 0.0376
+    mean_trigram_hapax_fraction: 0.0610
+    mean_trigram_repeated_unique: -0.1263
+    mean_trigram_repetition_rate: -0.1619
+    mean_trigram_total: -0.0337
+    mean_trigram_unique: 0.0524
+  punctuation_density:
+    mean_bracket_nonalpha_prefix_count: -0.0967
+    mean_bracket_nonalpha_suffix_count: -0.1131
+    mean_colon_suffix_density: 0.0056
+    mean_dot_count: 0.9099
+    mean_id_nonalpha_suffix_density: -0.0434
+  readability:
+    mean_avg_line_length: -0.1345
+    mean_avg_sub_words_per_id: -0.0093
+    mean_avg_tokens_per_line: -0.1302
+    mean_flesch_adapted: 0.0271
+    mean_fog_adapted: -0.1290
+    mean_total_lines: 0.0967
+  symbol_density:
+    mean_density: 0.0124
+    mean_distinct_symbol_types: 0.1042
+    mean_symbol_count: -0.0218
+  vocabulary:
+    mean_mattr: 0.0175
+    mean_raw_ttr: 0.0416
+    mean_total_identifiers: -0.0416
+  vowel_density:
+    mean_total_chars: -0.0460
+  zipf:
+    mean_exponent: 0.0101
+    mean_r_squared: -0.0074
+    mean_total_tokens: -0.0335
+    mean_vocab_size: 0.0261
+
+uses_ternary_expression:
+  _doc: "Simple conditional assignments should use inline expressions rather than full if-blocks."
+  _fix_hint: "Replace verbose if-else blocks with concise ternary/conditional expressions where readable"
+  _log_baseline: -0.3649
+  branching:
+    mean_branch_count: -0.4693
+    mean_branching_density: 0.1280
+    mean_non_blank_count: -0.5975
+  brevity:
+    mean_sample_size: 0.0107
+  casing_entropy:
+    mean_entropy: -0.0141
+    mean_snake_case_count: 0.0271
+  compression:
+    mean_raw_bytes: -0.0924
+    mean_redundancy: -0.0709
+    mean_unique_line_ratio: 0.1809
+    mean_zlib_bytes: 0.0167
+    mean_zlib_ratio: -0.1090
+  entropy:
+    mean_char_entropy: 0.0749
+    mean_char_normalized: 0.0717
+    mean_token_entropy: -0.0088
+    mean_token_normalized: -0.0114
+    mean_total_tokens: 0.0969
+    mean_vocab_size: 0.0107
+  function_metrics:
+    mean_avg_function_lines: -0.7654
+    mean_function_count: 0.2745
+    mean_max_function_lines: -0.4693
+  halstead:
+    mean_N1_total_operators: 0.1767
+    mean_N2_total_operands: 0.0622
+    mean_difficulty: 0.0952
+    mean_effort: 0.2409
+    mean_estimated_bugs: 0.1456
+    mean_length: 0.1429
+    mean_n1_unique_operators: 0.0330
+    mean_time_to_implement_seconds: 0.2409
+    mean_vocabulary: 0.0114
+    mean_volume: 0.1457
+  heaps:
+    mean_beta: -0.0340
+    mean_k: 0.0670
+  identifier_length_variance:
+    mean_mean: 0.0616
+    mean_std_dev: 0.0617
+    mean_variance: 0.1234
+  indentation:
+    mean_blank_line_ratio: 0.5702
+    mean_max_depth: -0.2745
+    mean_mean_depth: -0.3658
+    mean_variance: -0.6153
+  line_patterns:
+    mean_blank_line_ratio: 0.5702
+    mean_string_literal_ratio: -0.0964
+    mean_unique_line_ratio: 0.1839
+  magic_number_density:
+    mean_density: -0.0969
+    mean_string_literal_ratio: -0.0964
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.2745
+  ngram:
+    mean_bigram_hapax_fraction: -0.0616
+    mean_bigram_repeated_unique: 0.2415
+    mean_bigram_repetition_rate: 0.0886
+    mean_bigram_total: 0.0973
+    mean_bigram_unique: 0.0487
+    mean_trigram_hapax_fraction: -0.0186
+    mean_trigram_repeated_unique: 0.1511
+    mean_trigram_repetition_rate: 0.1328
+    mean_trigram_total: 0.0977
+    mean_trigram_unique: 0.0452
+  punctuation_density:
+    mean_bracket_nonalpha_prefix_count: 0.3060
+    mean_bracket_nonalpha_suffix_count: 0.5928
+    mean_bracket_number_pair_count: 0.4693
+    mean_colon_suffix_density: 2.0000
+    mean_dot_count: -1.3176
+    mean_id_nonalpha_suffix_density: 0.2152
+  readability:
+    mean_avg_line_length: 0.5254
+    mean_avg_sub_words_per_id: 0.0352
+    mean_avg_tokens_per_line: 0.6944
+    mean_flesch_adapted: -0.0769
+    mean_fog_adapted: 0.6047
+    mean_total_lines: -0.5975
+  symbol_density:
+    mean_density: 0.3573
+    mean_distinct_symbol_types: 0.0410
+    mean_symbol_count: 0.2651
+  vocabulary:
+    mean_mattr: -0.0421
+    mean_raw_ttr: -0.0421
+    mean_total_identifiers: 0.0230
+    mean_unique_identifiers: -0.0191
+  vowel_density:
+    mean_total_chars: 0.0845
+  zipf:
+    mean_exponent: 0.0361
+    mean_r_squared: 0.0150
+    mean_total_tokens: 0.0969
+    mean_vocab_size: 0.0107
+
diff --git a/priv/combined_metrics/naming_conventions.yml b/priv/combined_metrics/naming_conventions.yml
new file mode 100644
index 0000000..33e5d8a
--- /dev/null
+++ b/priv/combined_metrics/naming_conventions.yml
@@ -0,0 +1,266 @@
+class_name_is_noun:
+  _doc: "Class and module names should be nouns describing what they represent, not verbs or gerunds."
+  _fix_hint: "Name modules/classes with nouns (User, OrderProcessor) not verbs"
+  _log_baseline: 4.2909
+  brevity:
+    mean_sample_size: 0.7106
+  compression:
+    mean_raw_bytes: 0.1346
+    mean_redundancy: -0.0605
+    mean_zlib_bytes: 0.2139
+    mean_zlib_ratio: -0.0794
+  entropy:
+    mean_token_entropy: 0.1236
+    mean_token_max_entropy: 0.1716
+    mean_token_normalized: -0.0484
+    mean_vocab_size: 0.7106
+  halstead:
+    mean_difficulty: -1.1493
+    mean_effort: -0.9669
+    mean_estimated_bugs: 0.1818
+    mean_n2_unique_operands: 1.1492
+    mean_time_to_implement_seconds: -0.9669
+    mean_vocabulary: 0.7462
+    mean_volume: 0.1823
+  heaps:
+    mean_beta: 0.4086
+    mean_k: -0.6266
+  identifier_length_variance:
+    mean_max: -0.4031
+    mean_mean: 0.3059
+    mean_std_dev: -0.5093
+    mean_variance: -1.0187
+  ngram:
+    mean_bigram_hapax_fraction: 0.2542
+    mean_bigram_repeated_unique: -0.5967
+    mean_bigram_repetition_rate: -0.9599
+    mean_bigram_unique: 0.6173
+    mean_trigram_hapax_fraction: 0.2449
+    mean_trigram_repeated_unique: -2.0000
+    mean_trigram_repetition_rate: -1.9547
+    mean_trigram_unique: 0.6002
+  punctuation_density:
+    mean_exclamation_density: -0.3314
+  readability:
+    mean_avg_line_length: 0.1418
+  symbol_density:
+    mean_density: -0.1381
+  vocabulary:
+    mean_mattr: 1.2109
+    mean_raw_ttr: 1.2109
+    mean_unique_identifiers: 1.2116
+  vowel_density:
+    mean_total_chars: 0.3059
+  zipf:
+    mean_exponent: -0.2180
+    mean_vocab_size: 0.7106
+
+file_name_matches_primary_export:
+  _doc: "The file name should match the primary class or module it exports (e.g. `user.js` exports `User`)."
+  _fix_hint: "Rename the file to match the primary module it defines"
+  _log_baseline: 0.0000
+  casing_entropy:
+    mean_pascal_case_count: 0.0000
+  vocabulary:
+    mean_unique_identifiers: 0.0000
+
+function_name_is_not_single_word:
+  _doc: "Single-word function names like `run`, `process`, or `handle` are too vague to convey intent."
+  _fix_hint: "Use at least two words in function names to convey intent (e.g., fetch_user not fetch)"
+  _log_baseline: 17.4874
+  compression:
+    mean_raw_bytes: 0.2480
+    mean_redundancy: 0.0791
+    mean_zlib_bytes: 0.1049
+    mean_zlib_ratio: 0.1431
+  entropy:
+    mean_char_entropy: 0.0245
+    mean_char_normalized: 0.0246
+  identifier_length_variance:
+    mean_max: 0.7830
+    mean_mean: 0.5357
+    mean_std_dev: 1.0000
+    mean_variance: 2.0000
+  readability:
+    mean_avg_line_length: 0.2607
+    mean_avg_sub_words_per_id: 0.3141
+    mean_flesch_adapted: -0.3241
+    mean_fog_adapted: 1.3508
+  symbol_density:
+    mean_density: -0.2477
+  vowel_density:
+    mean_total_chars: 0.5357
+
+function_name_matches_return_type:
+  _doc: "Functions prefixed with `get_`, `fetch_`, or `find_` should return the thing they name."
+  _fix_hint: "Align the function name with what it returns (get_ for values, is_/has_ for booleans)"
+  _log_baseline: 7.9532
+  branching:
+    mean_max_nesting_depth: 0.1335
+  brevity:
+    mean_sample_size: 0.0257
+  casing_entropy:
+    mean_entropy: 0.0452
+    mean_other_count: 0.0347
+    mean_snake_case_count: -0.0493
+  compression:
+    mean_raw_bytes: -0.0190
+    mean_redundancy: -0.0180
+    mean_unique_line_ratio: -0.0104
+    mean_zlib_bytes: 0.0143
+    mean_zlib_ratio: -0.0332
+  entropy:
+    mean_char_entropy: 0.0079
+    mean_char_max_entropy: 0.0071
+    mean_token_max_entropy: 0.0059
+    mean_token_normalized: -0.0045
+    mean_total_tokens: 0.0030
+    mean_vocab_size: 0.0257
+  halstead:
+    mean_N1_total_operators: 0.0392
+    mean_N2_total_operands: -0.0539
+    mean_difficulty: 0.0029
+    mean_effort: 0.0080
+    mean_estimated_bugs: 0.0050
+    mean_n1_unique_operators: 0.0629
+    mean_n2_unique_operands: 0.0060
+    mean_time_to_implement_seconds: 0.0080
+    mean_vocabulary: 0.0218
+    mean_volume: 0.0050
+  heaps:
+    mean_beta: 0.0291
+    mean_k: -0.0519
+    mean_r_squared: 0.0038
+  identifier_length_variance:
+    mean_max: 0.1082
+    mean_mean: 0.0200
+    mean_std_dev: 0.0081
+    mean_variance: 0.0162
+  line_patterns:
+    mean_max_nesting_depth: 0.1335
+    mean_string_literal_ratio: -0.0027
+    mean_unique_line_ratio: -0.0108
+  magic_number_density:
+    mean_density: -0.0108
+    mean_string_literal_ratio: -0.0027
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.0314
+  ngram:
+    mean_bigram_hapax_fraction: 0.0106
+    mean_bigram_repeated_unique: 0.0095
+    mean_bigram_repetition_rate: -0.0167
+    mean_bigram_total: 0.0030
+    mean_bigram_unique: 0.0261
+    mean_trigram_hapax_fraction: 0.0174
+    mean_trigram_repeated_unique: -0.0297
+    mean_trigram_repetition_rate: -0.0444
+    mean_trigram_total: 0.0030
+    mean_trigram_unique: 0.0245
+  punctuation_density:
+    mean_bracket_nonalpha_prefix_count: 0.1048
+    mean_colon_suffix_density: -0.0027
+    mean_dot_count: 0.1335
+    mean_id_nonalpha_suffix_density: 0.0266
+    mean_question_mark_density: -2.0000
+  readability:
+    mean_avg_line_length: 0.0175
+    mean_avg_sub_words_per_id: 0.0087
+    mean_avg_tokens_per_line: 0.0030
+    mean_flesch_adapted: -0.0107
+    mean_fog_adapted: 0.0058
+  symbol_density:
+    mean_density: 0.0633
+    mean_distinct_symbol_types: 0.0639
+    mean_symbol_count: 0.0442
+  vocabulary:
+    mean_mattr: 0.0228
+    mean_raw_ttr: 0.0478
+    mean_total_identifiers: -0.0410
+    mean_unique_identifiers: 0.0068
+  vowel_density:
+    mean_total_chars: -0.0210
+  zipf:
+    mean_exponent: -0.0047
+    mean_r_squared: 0.0105
+    mean_total_tokens: 0.0030
+    mean_vocab_size: 0.0257
+
+test_name_starts_with_verb:
+  _doc: "Test descriptions should start with a verb: `creates`, `raises`, `returns`, not a noun phrase."
+  _fix_hint: "Start test descriptions with a verb (returns, raises, creates, validates)"
+  _log_baseline: 7.8702
+  branching:
+    mean_branch_count: 1.9977
+    mean_branching_density: 2.0000
+  brevity:
+    mean_sample_size: 0.0694
+  casing_entropy:
+    mean_entropy: -0.0749
+    mean_snake_case_count: 0.1317
+  compression:
+    mean_raw_bytes: 0.0914
+    mean_redundancy: 0.0182
+    mean_zlib_bytes: 0.0482
+    mean_zlib_ratio: 0.0431
+  entropy:
+    mean_char_max_entropy: 0.0064
+    mean_char_normalized: -0.0121
+    mean_token_entropy: 0.0259
+    mean_token_max_entropy: 0.0155
+    mean_token_normalized: 0.0104
+    mean_total_tokens: 0.0600
+    mean_vocab_size: 0.0694
+  halstead:
+    mean_N1_total_operators: 0.0411
+    mean_difficulty: 0.0577
+    mean_effort: 0.0855
+    mean_estimated_bugs: 0.0277
+    mean_length: 0.0240
+    mean_n1_unique_operators: 0.0577
+    mean_time_to_implement_seconds: 0.0855
+    mean_vocabulary: 0.0164
+    mean_volume: 0.0278
+  heaps:
+    mean_beta: -0.0149
+    mean_k: 0.0795
+    mean_r_squared: -0.0081
+  identifier_length_variance:
+    mean_std_dev: -0.0221
+    mean_variance: -0.0441
+  line_patterns:
+    mean_string_literal_ratio: -0.0611
+  magic_number_density:
+    mean_string_literal_ratio: -0.0611
+  ngram:
+    mean_bigram_hapax_fraction: -0.0506
+    mean_bigram_repeated_unique: 0.1209
+    mean_bigram_repetition_rate: 0.0150
+    mean_bigram_total: 0.0602
+    mean_bigram_unique: 0.0621
+    mean_trigram_hapax_fraction: -0.0206
+    mean_trigram_repeated_unique: 0.0961
+    mean_trigram_repetition_rate: 0.0117
+    mean_trigram_total: 0.0603
+    mean_trigram_unique: 0.0596
+  punctuation_density:
+    mean_arrow_density: -0.1129
+    mean_colon_suffix_density: -0.0591
+    mean_id_nonalpha_suffix_density: -0.0602
+  readability:
+    mean_avg_line_length: 0.0943
+    mean_avg_tokens_per_line: 0.0600
+    mean_fog_adapted: 0.0600
+  symbol_density:
+    mean_density: -0.0912
+  vocabulary:
+    mean_mattr: 0.0427
+    mean_raw_ttr: -0.0298
+    mean_total_identifiers: 0.1126
+    mean_unique_identifiers: 0.0828
+  vowel_density:
+    mean_total_chars: 0.1150
+  zipf:
+    mean_exponent: -0.0239
+    mean_total_tokens: 0.0600
+    mean_vocab_size: 0.0694
+
diff --git a/priv/combined_metrics/samples/code_smells/consistent_string_quote_style/bad/notifications.ex b/priv/combined_metrics/samples/code_smells/consistent_string_quote_style/bad/notifications.ex
new file mode 100644
index 0000000..71bbb89
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/consistent_string_quote_style/bad/notifications.ex
@@ -0,0 +1,84 @@
+defmodule Notifications do
+  @moduledoc 'Handles sending notifications and emails to users'
+
+  @default_sender 'noreply@example.com'
+  @support_email "support@example.com"
+
+  def send_welcome_email(user) do
+    subject = "Welcome to the platform"
+    body = 'Hi ' <> user.name <> ", welcome aboard!"
+    sender = @default_sender
+
+    deliver_email(%{
+      to: user.email,
+      from: sender,
+      subject: subject,
+      body: body,
+      reply_to: 'noreply@example.com'
+    })
+  end
+
+  def send_password_reset(user, token) do
+    link = "https://example.com/reset/" <> token
+    subject = 'Reset your password'
+    body = "Click the link to reset your password: " <> link
+
+    deliver_email(%{
+      to: user.email,
+      from: @default_sender,
+      subject: subject,
+      body: body
+    })
+  end
+
+  def send_order_confirmation(user, order) do
+    subject = 'Order #' <> Integer.to_string(order.id) <> " confirmed"
+    body = "Thank you for your order, " <> user.name <> "!"
+
+    deliver_email(%{
+      to: user.email,
+      from: "orders@example.com",
+      subject: subject,
+      body: body,
+      cc: 'orders@example.com'
+    })
+  end
+
+  def send_invoice(user, invoice) do
+    subject = "Invoice " <> invoice.number
+    body = 'Please find your invoice attached.'
+
+    deliver_email(%{
+      to: user.email,
+      from: @default_sender,
+      subject: subject,
+      body: body,
+      attachment: invoice.pdf_path
+    })
+  end
+
+  def send_support_reply(ticket, message) do
+    subject = 'Re: Support Ticket #' <> Integer.to_string(ticket.id)
+    body = "Hello,\n\n" <> message <> '\n\nBest regards,\nSupport Team'
+
+    deliver_email(%{
+      to: ticket.user_email,
+      from: @support_email,
+      subject: subject,
+      body: body
+    })
+  end
+
+  def format_greeting(name, locale) do
+    case locale do
+      "en" -> 'Hello, ' <> name <> "!"
+      "de" -> "Hallo, " <> name <> '!'
+      _ -> "Hi, " <> name
+    end
+  end
+
+  defp deliver_email(params) do
+    IO.puts("Sending email to: " <> params.to)
+    {:ok, params}
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/consistent_string_quote_style/config.yml b/priv/combined_metrics/samples/code_smells/consistent_string_quote_style/config.yml
new file mode 100644
index 0000000..ffdf597
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/consistent_string_quote_style/config.yml
@@ -0,0 +1 @@
+doc: "Files should use a single, consistent string quoting style throughout."
diff --git a/priv/combined_metrics/samples/code_smells/consistent_string_quote_style/good/notifications.ex b/priv/combined_metrics/samples/code_smells/consistent_string_quote_style/good/notifications.ex
new file mode 100644
index 0000000..2b8d576
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/consistent_string_quote_style/good/notifications.ex
@@ -0,0 +1,82 @@
+defmodule Notifications do
+  @moduledoc "Handles sending notifications and emails to users"
+
+  @default_sender "noreply@example.com"
+  @support_email "support@example.com"
+
+  def send_welcome_email(user) do
+    subject = "Welcome to the platform"
+    body = "Hi #{user.name}, welcome aboard!"
+
+    deliver_email(%{
+      to: user.email,
+      from: @default_sender,
+      subject: subject,
+      body: body,
+      reply_to: "noreply@example.com"
+    })
+  end
+
+  def send_password_reset(user, token) do
+    link = "https://example.com/reset/#{token}"
+    subject = "Reset your password"
+    body = "Click the link to reset your password: #{link}"
+
+    deliver_email(%{
+      to: user.email,
+      from: @default_sender,
+      subject: subject,
+      body: body
+    })
+  end
+
+  def send_order_confirmation(user, order) do
+    subject = "Order ##{order.id} confirmed"
+    body = "Thank you for your order, #{user.name}!"
+
+    deliver_email(%{
+      to: user.email,
+      from: "orders@example.com",
+      subject: subject,
+      body: body,
+      cc: "orders@example.com"
+    })
+  end
+
+  def send_invoice(user, invoice) do
+    subject = "Invoice #{invoice.number}"
+    body = "Please find your invoice attached."
+
+    deliver_email(%{
+      to: user.email,
+      from: @default_sender,
+      subject: subject,
+      body: body,
+      attachment: invoice.pdf_path
+    })
+  end
+
+  def send_support_reply(ticket, message) do
+    subject = "Re: Support Ticket ##{ticket.id}"
+    body = "Hello,\n\n#{message}\n\nBest regards,\nSupport Team"
+
+    deliver_email(%{
+      to: ticket.user_email,
+      from: @support_email,
+      subject: subject,
+      body: body
+    })
+  end
+
+  def format_greeting(name, locale) do
+    case locale do
+      "en" -> "Hello, #{name}!"
+      "de" -> "Hallo, #{name}!"
+      _ -> "Hi, #{name}"
+    end
+  end
+
+  defp deliver_email(params) do
+    {:ok, params}
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/context_not_stored_in_struct/bad/fetcher.go b/priv/combined_metrics/samples/code_smells/context_not_stored_in_struct/bad/fetcher.go
new file mode 100644
index 0000000..fb8b2cc
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/context_not_stored_in_struct/bad/fetcher.go
@@ -0,0 +1,64 @@
+package fetcher
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+// Article represents a remote article resource.
+type Article struct {
+	ID    string
+	Title string
+	Body  string
+}
+
+// ArticleFetcher retrieves articles from a remote API.
+// Context is stored as a struct field — an anti-pattern that ties the instance
+// to a single request lifetime and makes cancellation hard to reason about.
+type ArticleFetcher struct {
+	base   string
+	client *http.Client
+	ctx    context.Context // anti-pattern: context stored in struct
+}
+
+func New(ctx context.Context, base string) *ArticleFetcher {
+	return &ArticleFetcher{base: base, client: &http.Client{}, ctx: ctx}
+}
+
+// FetchByID retrieves an article by ID using the stored context.
+// Callers cannot supply per-call cancellation.
+func (f *ArticleFetcher) FetchByID(id string) (*Article, error) {
+	url := fmt.Sprintf("%s/articles/%s", f.base, id)
+	// Uses f.ctx from the struct — callers cannot override it.
+	req, err := http.NewRequestWithContext(f.ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return nil, fmt.Errorf("fetch article %q: %w", id, err)
+	}
+
+	resp, err := f.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("fetch article %q: %w", id, err)
+	}
+	defer resp.Body.Close()
+
+	var a Article
+	if err := json.NewDecoder(resp.Body).Decode(&a); err != nil {
+		return nil, fmt.Errorf("fetch article %q: decode: %w", id, err)
+	}
+	return &a, nil
+}
+
+// FetchAll retrieves multiple articles using the struct's stored context.
+func (f *ArticleFetcher) FetchAll(ids []string) ([]*Article, error) {
+	out := make([]*Article, 0, len(ids))
+	for _, id := range ids {
+		a, err := f.FetchByID(id)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, a)
+	}
+	return out, nil
+}
diff --git a/priv/combined_metrics/samples/code_smells/context_not_stored_in_struct/good/fetcher.go b/priv/combined_metrics/samples/code_smells/context_not_stored_in_struct/good/fetcher.go
new file mode 100644
index 0000000..ce3182e
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/context_not_stored_in_struct/good/fetcher.go
@@ -0,0 +1,61 @@
+package fetcher
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+// Article represents a remote article resource.
+type Article struct {
+	ID    string
+	Title string
+	Body  string
+}
+
+// ArticleFetcher retrieves articles from a remote API.
+// Context is accepted as a function parameter, not stored in the struct.
+type ArticleFetcher struct {
+	base   string
+	client *http.Client
+}
+
+func New(base string) *ArticleFetcher {
+	return &ArticleFetcher{base: base, client: &http.Client{}}
+}
+
+// FetchByID retrieves an article by ID using the provided context for cancellation.
+// Context is passed explicitly — it is not stored on ArticleFetcher.
+func (f *ArticleFetcher) FetchByID(ctx context.Context, id string) (*Article, error) {
+	url := fmt.Sprintf("%s/articles/%s", f.base, id)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return nil, fmt.Errorf("fetch article %q: build request: %w", id, err)
+	}
+
+	resp, err := f.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("fetch article %q: %w", id, err)
+	}
+	defer resp.Body.Close()
+
+	var a Article
+	if err := json.NewDecoder(resp.Body).Decode(&a); err != nil {
+		return nil, fmt.Errorf("fetch article %q: decode: %w", id, err)
+	}
+	return &a, nil
+}
+
+// FetchAll retrieves multiple articles using the provided context.
+func (f *ArticleFetcher) FetchAll(ctx context.Context, ids []string) ([]*Article, error) {
+	out := make([]*Article, 0, len(ids))
+	for _, id := range ids {
+		a, err := f.FetchByID(ctx, id)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, a)
+	}
+	return out, nil
+}
diff --git a/priv/combined_metrics/samples/code_smells/does_not_accept_box_ref_parameter/bad/worker.rs b/priv/combined_metrics/samples/code_smells/does_not_accept_box_ref_parameter/bad/worker.rs
new file mode 100644
index 0000000..b8b6111
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/does_not_accept_box_ref_parameter/bad/worker.rs
@@ -0,0 +1,51 @@
+use std::fmt;
+
+pub trait Task: fmt::Debug + Send {
+    fn name(&self) -> &str;
+    fn execute(&self) -> Result<String, String>;
+}
+
+#[derive(Debug)]
+pub struct EmailTask {
+    pub recipient: String,
+    pub subject: String,
+}
+
+impl Task for EmailTask {
+    fn name(&self) -> &str { "email" }
+    fn execute(&self) -> Result<String, String> {
+        Ok(format!("sent email to {}", self.recipient))
+    }
+}
+
+#[derive(Debug)]
+pub struct ReportTask {
+    pub report_id: u64,
+}
+
+impl Task for ReportTask {
+    fn name(&self) -> &str { "report" }
+    fn execute(&self) -> Result<String, String> {
+        Ok(format!("generated report #{}", self.report_id))
+    }
+}
+
+// Bad: &Box<dyn Task> forces callers to have an owned Box — cannot pass a
+// plain reference; also adds an extra level of indirection unnecessarily.
+pub fn run_task(task: &Box<dyn Task>) -> Result<String, String> {
+    println!("running task: {}", task.name());
+    task.execute()
+}
+
+pub fn run_all(tasks: &[Box<dyn Task>]) -> Vec<Result<String, String>> {
+    tasks.iter().map(run_task).collect()
+}
+
+// Same anti-pattern with a concrete generic type
+pub fn log_task_name(task: &Box<EmailTask>) {
+    println!("[worker] task name: {}", task.name());
+}
+
+pub fn describe(task: &Box<dyn Task>) -> String {
+    format!("Task({})", task.name())
+}
diff --git a/priv/combined_metrics/samples/code_smells/does_not_accept_box_ref_parameter/good/worker.rs b/priv/combined_metrics/samples/code_smells/does_not_accept_box_ref_parameter/good/worker.rs
new file mode 100644
index 0000000..5979a98
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/does_not_accept_box_ref_parameter/good/worker.rs
@@ -0,0 +1,51 @@
+use std::fmt;
+
+pub trait Task: fmt::Debug + Send {
+    fn name(&self) -> &str;
+    fn execute(&self) -> Result<String, String>;
+}
+
+#[derive(Debug)]
+pub struct EmailTask {
+    pub recipient: String,
+    pub subject: String,
+}
+
+impl Task for EmailTask {
+    fn name(&self) -> &str {
+        "email"
+    }
+    fn execute(&self) -> Result<String, String> {
+        Ok(format!("sent email to {} re: {}", self.recipient, self.subject))
+    }
+}
+
+#[derive(Debug)]
+pub struct ReportTask {
+    pub report_id: u64,
+}
+
+impl Task for ReportTask {
+    fn name(&self) -> &str {
+        "report"
+    }
+    fn execute(&self) -> Result<String, String> {
+        Ok(format!("generated report #{}", self.report_id))
+    }
+}
+
+// Accept &dyn Task (or &T) rather than &Box<dyn Task> — works with
+// both owned Box<dyn Task> and references to stack-allocated types
+pub fn run_task(task: &dyn Task) -> Result<String, String> {
+    println!("running task: {}", task.name());
+    task.execute()
+}
+
+pub fn run_all(tasks: &[Box<dyn Task>]) -> Vec<Result<String, String>> {
+    // Dereference each Box to get &dyn Task — clean, no Box leaking into API
+    tasks.iter().map(|t| run_task(t.as_ref())).collect()
+}
+
+pub fn log_task_name(task: &dyn Task) {
+    println!("[worker] task name: {}", task.name());
+}
diff --git a/priv/combined_metrics/samples/code_smells/does_not_box_collections_unnecessarily/bad/cache.rs b/priv/combined_metrics/samples/code_smells/does_not_box_collections_unnecessarily/bad/cache.rs
new file mode 100644
index 0000000..46fe6b8
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/does_not_box_collections_unnecessarily/bad/cache.rs
@@ -0,0 +1,59 @@
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+
+#[derive(Debug, Clone)]
+pub struct CacheEntry<V: Clone> {
+    pub value: V,
+    pub inserted_at: Instant,
+    pub ttl: Duration,
+}
+
+// Bad: Vec and HashMap are wrapped in Box — adds heap indirection with no benefit
+pub struct TtlCache<K: Clone + std::hash::Hash + Eq, V: Clone> {
+    // Box<HashMap<...>> adds an extra pointer hop for every lookup
+    store: Box<HashMap<K, CacheEntry<V>>>,
+    // Box<Vec<...>> is redundant — Vec already lives on the heap
+    eviction_order: Box<Vec<K>>,
+    max_size: usize,
+}
+
+impl<K, V> TtlCache<K, V>
+where
+    K: std::hash::Hash + Eq + Clone,
+    V: Clone,
+{
+    pub fn new(max_size: usize) -> Self {
+        Self {
+            store: Box::new(HashMap::new()),
+            eviction_order: Box::new(Vec::new()),
+            max_size,
+        }
+    }
+
+    pub fn insert(&mut self, key: K, value: V, ttl: Duration) {
+        if self.store.len() >= self.max_size {
+            self.evict_oldest();
+        }
+        let entry = CacheEntry { value, inserted_at: Instant::now(), ttl };
+        self.store.insert(key.clone(), entry);
+        self.eviction_order.push(key);
+    }
+
+    pub fn get(&self, key: &K) -> Option<&V> {
+        self.store.get(key).and_then(|e| {
+            if e.inserted_at.elapsed() > e.ttl { None } else { Some(&e.value) }
+        })
+    }
+
+    // Returning Box<Vec<...>> — caller must dereference to get slice behavior
+    pub fn snapshot_keys(&self) -> Box<Vec<K>> {
+        Box::new(self.eviction_order.iter().cloned().collect())
+    }
+
+    fn evict_oldest(&mut self) {
+        if let Some(oldest) = self.eviction_order.first().cloned() {
+            self.store.remove(&oldest);
+            self.eviction_order.remove(0);
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/does_not_box_collections_unnecessarily/good/cache.rs b/priv/combined_metrics/samples/code_smells/does_not_box_collections_unnecessarily/good/cache.rs
new file mode 100644
index 0000000..2e5ceb6
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/does_not_box_collections_unnecessarily/good/cache.rs
@@ -0,0 +1,61 @@
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+
+#[derive(Debug, Clone)]
+pub struct CacheEntry<V> {
+    pub value: V,
+    pub inserted_at: Instant,
+    pub ttl: Duration,
+}
+
+impl<V> CacheEntry<V> {
+    pub fn is_expired(&self) -> bool {
+        self.inserted_at.elapsed() > self.ttl
+    }
+}
+
+// Vec<K> and HashMap are used directly — no unnecessary Box wrapping
+pub struct TtlCache<K, V> {
+    store: HashMap<K, CacheEntry<V>>,
+    eviction_order: Vec<K>,
+    max_size: usize,
+}
+
+impl<K, V> TtlCache<K, V>
+where
+    K: std::hash::Hash + Eq + Clone,
+{
+    pub fn new(max_size: usize) -> Self {
+        Self {
+            store: HashMap::new(),
+            eviction_order: Vec::new(),
+            max_size,
+        }
+    }
+
+    pub fn insert(&mut self, key: K, value: V, ttl: Duration) {
+        if self.store.len() >= self.max_size {
+            self.evict_oldest();
+        }
+        let entry = CacheEntry { value, inserted_at: Instant::now(), ttl };
+        self.store.insert(key.clone(), entry);
+        self.eviction_order.push(key);
+    }
+
+    pub fn get(&self, key: &K) -> Option<&V> {
+        self.store.get(key).and_then(|e| {
+            if e.is_expired() { None } else { Some(&e.value) }
+        })
+    }
+
+    pub fn keys(&self) -> Vec<&K> {
+        self.eviction_order.iter().collect()
+    }
+
+    fn evict_oldest(&mut self) {
+        if let Some(oldest) = self.eviction_order.first().cloned() {
+            self.store.remove(&oldest);
+            self.eviction_order.remove(0);
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/does_not_cast_ref_to_mut_ptr/bad/buffer.rs b/priv/combined_metrics/samples/code_smells/does_not_cast_ref_to_mut_ptr/bad/buffer.rs
new file mode 100644
index 0000000..14d5808
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/does_not_cast_ref_to_mut_ptr/bad/buffer.rs
@@ -0,0 +1,44 @@
+/// Bad: uses raw pointer casts to mutate through shared references,
+/// violating Rust's aliasing rules and causing undefined behavior.
+pub struct RingBuffer {
+    data: Vec<u8>,
+    capacity: usize,
+}
+
+impl RingBuffer {
+    pub fn new(capacity: usize) -> Self {
+        Self { data: Vec::with_capacity(capacity), capacity }
+    }
+
+    // BAD: casts an immutable reference to a mutable pointer to bypass borrow rules.
+    // This is undefined behavior — multiple callers can hold &RingBuffer and mutate
+    // the same Vec simultaneously.
+    pub fn write_bypass(&self, byte: u8) {
+        let data_ptr = &self.data as *const Vec<u8> as *mut Vec<u8>;
+        unsafe {
+            (*data_ptr).push(byte);
+        }
+    }
+
+    // BAD: same pattern — casting &[u8] pointer to *mut u8 to overwrite bytes
+    pub fn patch_byte(&self, index: usize, value: u8) {
+        if index < self.data.len() {
+            let ptr = self.data.as_ptr() as *mut u8;
+            unsafe {
+                *ptr.add(index) = value;
+            }
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    // BAD: capacity field mutated through a const-cast pointer
+    pub fn resize_limit(&self, new_capacity: usize) {
+        let cap_ptr = &self.capacity as *const usize as *mut usize;
+        unsafe {
+            *cap_ptr = new_capacity;
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/does_not_cast_ref_to_mut_ptr/good/buffer.rs b/priv/combined_metrics/samples/code_smells/does_not_cast_ref_to_mut_ptr/good/buffer.rs
new file mode 100644
index 0000000..0119ace
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/does_not_cast_ref_to_mut_ptr/good/buffer.rs
@@ -0,0 +1,61 @@
+use std::sync::Mutex;
+
+/// A shared ring buffer with interior mutability via Mutex.
+/// Mutations go through &mut self or Mutex — no raw pointer casting.
+pub struct RingBuffer {
+    data: Mutex<Vec<u8>>,
+    capacity: usize,
+}
+
+impl RingBuffer {
+    pub fn new(capacity: usize) -> Self {
+        Self {
+            data: Mutex::new(Vec::with_capacity(capacity)),
+            capacity,
+        }
+    }
+
+    pub fn write(&self, chunk: &[u8]) -> usize {
+        let mut data = self.data.lock().expect("mutex poisoned");
+        let remaining = self.capacity.saturating_sub(data.len());
+        let to_write = chunk.len().min(remaining);
+        data.extend_from_slice(&chunk[..to_write]);
+        to_write
+    }
+
+    pub fn read_all(&self) -> Vec<u8> {
+        let mut data = self.data.lock().expect("mutex poisoned");
+        std::mem::take(&mut *data)
+    }
+
+    pub fn len(&self) -> usize {
+        self.data.lock().expect("mutex poisoned").len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+pub struct OwnedBuffer {
+    data: Vec<u8>,
+}
+
+impl OwnedBuffer {
+    pub fn new() -> Self {
+        Self { data: Vec::new() }
+    }
+
+    // Mutation via &mut self — safe, no raw pointers
+    pub fn append(&mut self, bytes: &[u8]) {
+        self.data.extend_from_slice(bytes);
+    }
+
+    pub fn clear(&mut self) {
+        self.data.clear();
+    }
+
+    pub fn as_slice(&self) -> &[u8] {
+        &self.data
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/does_not_clone_for_comparison/bad/registry.rs b/priv/combined_metrics/samples/code_smells/does_not_clone_for_comparison/bad/registry.rs
new file mode 100644
index 0000000..8b55b41
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/does_not_clone_for_comparison/bad/registry.rs
@@ -0,0 +1,56 @@
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ServiceId(pub String);
+
+#[derive(Debug, Clone)]
+pub struct ServiceEntry {
+    pub id: ServiceId,
+    pub endpoint: String,
+    pub healthy: bool,
+}
+
+pub struct Registry {
+    entries: HashMap<ServiceId, ServiceEntry>,
+    primary_id: Option<ServiceId>,
+}
+
+impl Registry {
+    pub fn new() -> Self {
+        Self { entries: HashMap::new(), primary_id: None }
+    }
+
+    pub fn register(&mut self, entry: ServiceEntry) {
+        self.entries.insert(entry.id.clone(), entry);
+    }
+
+    pub fn set_primary(&mut self, id: ServiceId) {
+        self.primary_id = Some(id);
+    }
+
+    // Bad: clones primary_id solely to compare — &ServiceId comparison suffices
+    pub fn is_primary(&self, id: &ServiceId) -> bool {
+        self.primary_id.clone() == Some(id.clone())
+    }
+
+    // Bad: clones candidate endpoint just to compare strings
+    pub fn find_by_endpoint(&self, endpoint: &str) -> Option<&ServiceEntry> {
+        self.entries
+            .values()
+            .find(|e| e.endpoint.clone() == endpoint.to_string())
+    }
+
+    pub fn healthy_ids(&self) -> Vec<ServiceId> {
+        self.entries
+            .values()
+            .filter(|e| e.healthy)
+            // Bad: clones every healthy id even though callers may only iterate
+            .map(|e| e.id.clone())
+            .collect()
+    }
+
+    // Bad: clones the key just to check membership
+    pub fn contains(&self, id: &ServiceId) -> bool {
+        self.entries.contains_key(&id.clone())
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/does_not_clone_for_comparison/good/registry.rs b/priv/combined_metrics/samples/code_smells/does_not_clone_for_comparison/good/registry.rs
new file mode 100644
index 0000000..1bfb365
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/does_not_clone_for_comparison/good/registry.rs
@@ -0,0 +1,52 @@
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ServiceId(pub String);
+
+#[derive(Debug, Clone)]
+pub struct ServiceEntry {
+    pub id: ServiceId,
+    pub endpoint: String,
+    pub healthy: bool,
+}
+
+pub struct Registry {
+    entries: HashMap<ServiceId, ServiceEntry>,
+    primary_id: Option<ServiceId>,
+}
+
+impl Registry {
+    pub fn new() -> Self {
+        Self { entries: HashMap::new(), primary_id: None }
+    }
+
+    pub fn register(&mut self, entry: ServiceEntry) {
+        self.entries.insert(entry.id.clone(), entry);
+    }
+
+    pub fn set_primary(&mut self, id: ServiceId) {
+        self.primary_id = Some(id);
+    }
+
+    // Compare by reference — no clone needed
+    pub fn is_primary(&self, id: &ServiceId) -> bool {
+        self.primary_id.as_ref() == Some(id)
+    }
+
+    // Find without cloning the candidate
+    pub fn find_by_endpoint(&self, endpoint: &str) -> Option<&ServiceEntry> {
+        self.entries.values().find(|e| e.endpoint == endpoint)
+    }
+
+    pub fn healthy_ids(&self) -> Vec<&ServiceId> {
+        self.entries
+            .values()
+            .filter(|e| e.healthy)
+            .map(|e| &e.id)
+            .collect()
+    }
+
+    pub fn contains(&self, id: &ServiceId) -> bool {
+        self.entries.contains_key(id)
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/does_not_declare_unused_mut/bad/pipeline.rs b/priv/combined_metrics/samples/code_smells/does_not_declare_unused_mut/bad/pipeline.rs
new file mode 100644
index 0000000..83d575c
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/does_not_declare_unused_mut/bad/pipeline.rs
@@ -0,0 +1,53 @@
+pub struct Record {
+    pub id: u64,
+    pub value: f64,
+    pub tags: Vec<String>,
+}
+
+pub struct Pipeline {
+    steps: Vec<Box<dyn Fn(Record) -> Record>>,
+}
+
+impl Pipeline {
+    pub fn new() -> Self {
+        Self { steps: Vec::new() }
+    }
+
+    // BAD: record is declared mut but never actually mutated — fold returns new value
+    pub fn run(&self, mut record: Record) -> Record {
+        self.steps.iter().fold(record, |acc, step| step(acc))
+    }
+}
+
+// BAD: scale is declared mut but the parameter is never reassigned
+pub fn normalize(records: &mut Vec<Record>, mut scale: f64) {
+    for r in records.iter_mut() {
+        r.value *= scale;
+    }
+}
+
+pub fn summarize(records: &[Record]) -> (f64, f64) {
+    // BAD: count is declared mut but assigned once and never incremented explicitly
+    let mut count: usize = records.len();
+    let mut sum = 0.0f64;
+
+    // sum is mutated — but count is used as a constant after assignment
+    for r in records {
+        sum += r.value;
+    }
+
+    if count == 0 {
+        return (0.0, 0.0);
+    }
+    (sum, sum / count as f64)
+}
+
+// BAD: result is declared mut but never reassigned after initialization
+pub fn find_max(records: &[Record]) -> Option<f64> {
+    let mut result = records.iter().map(|r| r.value).fold(f64::NEG_INFINITY, f64::max);
+    if result == f64::NEG_INFINITY {
+        None
+    } else {
+        Some(result)
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/does_not_declare_unused_mut/good/pipeline.rs b/priv/combined_metrics/samples/code_smells/does_not_declare_unused_mut/good/pipeline.rs
new file mode 100644
index 0000000..8b65a19
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/does_not_declare_unused_mut/good/pipeline.rs
@@ -0,0 +1,48 @@
+pub struct Record {
+    pub id: u64,
+    pub value: f64,
+    pub tags: Vec<String>,
+}
+
+pub struct Pipeline {
+    steps: Vec<Box<dyn Fn(Record) -> Record>>,
+}
+
+impl Pipeline {
+    pub fn new() -> Self {
+        // steps will be mutated — mut is needed here
+        let mut steps: Vec<Box<dyn Fn(Record) -> Record>> = Vec::new();
+        steps.push(Box::new(|r| r)); // identity step
+        Self { steps }
+    }
+
+    // No mut needed on record — we return a new one via fold
+    pub fn run(&self, record: Record) -> Record {
+        self.steps.iter().fold(record, |acc, step| step(acc))
+    }
+
+    pub fn add_step(&mut self, step: impl Fn(Record) -> Record + 'static) {
+        self.steps.push(Box::new(step));
+    }
+}
+
+pub fn normalize(records: &mut Vec<Record>, scale: f64) {
+    // records is genuinely mutated via iter_mut
+    for r in records.iter_mut() {
+        r.value *= scale;
+    }
+}
+
+pub fn summarize(records: &[Record]) -> (f64, f64) {
+    // sum and count are mutated by the loop
+    let mut sum = 0.0f64;
+    let mut count = 0usize;
+    for r in records {
+        sum += r.value;
+        count += 1;
+    }
+    if count == 0 {
+        return (0.0, 0.0);
+    }
+    (sum, sum / count as f64)
+}
diff --git a/priv/combined_metrics/samples/code_smells/does_not_hold_mutex_across_await/bad/queue.rs b/priv/combined_metrics/samples/code_smells/does_not_hold_mutex_across_await/bad/queue.rs
new file mode 100644
index 0000000..d52641c
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/does_not_hold_mutex_across_await/bad/queue.rs
@@ -0,0 +1,52 @@
+use std::collections::VecDeque;
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug, Clone)]
+pub struct Job {
+    pub id: u64,
+    pub payload: String,
+}
+
+pub struct JobQueue {
+    inner: Arc<Mutex<VecDeque<Job>>>,
+}
+
+impl JobQueue {
+    pub fn new() -> Self {
+        Self { inner: Arc::new(Mutex::new(VecDeque::new())) }
+    }
+
+    pub fn push(&self, job: Job) {
+        self.inner.lock().expect("mutex poisoned").push_back(job);
+    }
+
+    // BAD: the MutexGuard is held across an .await point.
+    // This can deadlock (tokio Mutex panics) or block other tasks from
+    // acquiring the lock while the async work runs.
+    pub async fn process_next_bad(&self) -> Option<String> {
+        let mut q = self.inner.lock().expect("mutex poisoned");
+        // MutexGuard is still live here — held across the await below
+        let job = q.pop_front()?;
+
+        // Awaiting while holding the guard — deadlock risk
+        let result = self.handle_job(&job).await;
+        // Guard finally dropped when this function returns, after all awaits
+        Some(result)
+    }
+
+    // BAD: returns while guard is in scope after an await
+    pub async fn peek_and_log(&self) {
+        let q = self.inner.lock().expect("mutex poisoned");
+        if let Some(job) = q.front() {
+            println!("next job: {}", job.id);
+        }
+        // MutexGuard q is still in scope
+        tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+        // q dropped here — after the await
+    }
+
+    async fn handle_job(&self, job: &Job) -> String {
+        tokio::time::sleep(std::time::Duration::from_millis(1)).await;
+        format!("processed job #{}: {}", job.id, job.payload)
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/does_not_hold_mutex_across_await/good/queue.rs b/priv/combined_metrics/samples/code_smells/does_not_hold_mutex_across_await/good/queue.rs
new file mode 100644
index 0000000..0d73408
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/does_not_hold_mutex_across_await/good/queue.rs
@@ -0,0 +1,50 @@
+use std::collections::VecDeque;
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug, Clone)]
+pub struct Job {
+    pub id: u64,
+    pub payload: String,
+}
+
+pub struct JobQueue {
+    inner: Arc<Mutex<VecDeque<Job>>>,
+}
+
+impl JobQueue {
+    pub fn new() -> Self {
+        Self { inner: Arc::new(Mutex::new(VecDeque::new())) }
+    }
+
+    pub fn push(&self, job: Job) {
+        let mut q = self.inner.lock().expect("mutex poisoned");
+        q.push_back(job);
+        // Guard dropped at end of block — not held across await
+    }
+
+    // Good: release the lock before awaiting, then use the extracted value
+    pub async fn process_next(&self) -> Option<String> {
+        // Extract the job while holding the lock...
+        let job = {
+            let mut q = self.inner.lock().expect("mutex poisoned");
+            q.pop_front()
+            // MutexGuard dropped here — before any await point
+        };
+
+        // ...then await without holding the lock
+        match job {
+            Some(j) => Some(self.handle_job(j).await),
+            None => None,
+        }
+    }
+
+    async fn handle_job(&self, job: Job) -> String {
+        // Simulated async work (e.g., HTTP call, DB write)
+        tokio::time::sleep(std::time::Duration::from_millis(1)).await;
+        format!("processed job #{}: {}", job.id, job.payload)
+    }
+
+    pub fn len(&self) -> usize {
+        self.inner.lock().expect("mutex poisoned").len()
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/does_not_spawn_unbounded_goroutines/bad/importer.go b/priv/combined_metrics/samples/code_smells/does_not_spawn_unbounded_goroutines/bad/importer.go
new file mode 100644
index 0000000..a708ed1
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/does_not_spawn_unbounded_goroutines/bad/importer.go
@@ -0,0 +1,53 @@
+package importer
+
+import (
+	"context"
+	"fmt"
+	"sync"
+)
+
+type Record struct {
+	ID   string
+	Data string
+}
+
+type Storer interface {
+	Store(ctx context.Context, r Record) error
+}
+
+// BulkImporter processes records by spawning one goroutine per record.
+// With a large input slice this creates an unbounded number of goroutines,
+// exhausting memory and file descriptors.
+type BulkImporter struct {
+	store Storer
+}
+
+func New(store Storer) *BulkImporter {
+	return &BulkImporter{store: store}
+}
+
+// Import spawns one goroutine per record with no concurrency limit.
+func (b *BulkImporter) Import(ctx context.Context, records []Record) error {
+	errs := make(chan error, len(records))
+	var wg sync.WaitGroup
+
+	for _, r := range records {
+		r := r
+		wg.Add(1)
+		// One goroutine per record — can spawn thousands simultaneously.
+		go func() {
+			defer wg.Done()
+			if err := b.store.Store(ctx, r); err != nil {
+				errs <- fmt.Errorf("store record %s: %w", r.ID, err)
+			}
+		}()
+	}
+
+	wg.Wait()
+	close(errs)
+
+	for err := range errs {
+		return err
+	}
+	return nil
+}
diff --git a/priv/combined_metrics/samples/code_smells/does_not_spawn_unbounded_goroutines/good/importer.go b/priv/combined_metrics/samples/code_smells/does_not_spawn_unbounded_goroutines/good/importer.go
new file mode 100644
index 0000000..7f118e2
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/does_not_spawn_unbounded_goroutines/good/importer.go
@@ -0,0 +1,58 @@
+package importer
+
+import (
+	"context"
+	"fmt"
+	"sync"
+)
+
+type Record struct {
+	ID   string
+	Data string
+}
+
+type Storer interface {
+	Store(ctx context.Context, r Record) error
+}
+
+// BulkImporter processes records using a fixed-size worker pool.
+// The number of concurrent goroutines is bounded by concurrency.
+type BulkImporter struct {
+	store       Storer
+	concurrency int
+}
+
+func New(store Storer, concurrency int) *BulkImporter {
+	if concurrency <= 0 {
+		concurrency = 4
+	}
+	return &BulkImporter{store: store, concurrency: concurrency}
+}
+
+// Import processes all records with at most concurrency goroutines running simultaneously.
+func (b *BulkImporter) Import(ctx context.Context, records []Record) error {
+	sem := make(chan struct{}, b.concurrency)
+	errs := make(chan error, len(records))
+	var wg sync.WaitGroup
+
+	for _, r := range records {
+		r := r
+		sem <- struct{}{} // acquire slot
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			defer func() { <-sem }() // release slot
+			if err := b.store.Store(ctx, r); err != nil {
+				errs <- fmt.Errorf("store record %s: %w", r.ID, err)
+			}
+		}()
+	}
+
+	wg.Wait()
+	close(errs)
+
+	for err := range errs {
+		return err // return first error
+	}
+	return nil
+}
diff --git a/priv/combined_metrics/samples/code_smells/goroutine_has_clear_exit_condition/bad/worker.go b/priv/combined_metrics/samples/code_smells/goroutine_has_clear_exit_condition/bad/worker.go
new file mode 100644
index 0000000..fe8afab
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/goroutine_has_clear_exit_condition/bad/worker.go
@@ -0,0 +1,45 @@
+package worker
+
+import (
+	"log"
+	"time"
+)
+
+type EmailJob struct {
+	To      string
+	Subject string
+	Body    string
+}
+
+type Mailer interface {
+	Send(job EmailJob) error
+}
+
+// EmailWorker drains jobs from a channel.
+// The goroutine has no exit condition — it leaks forever.
+type EmailWorker struct {
+	mailer Mailer
+	jobs   <-chan EmailJob
+	logger *log.Logger
+}
+
+func NewEmailWorker(mailer Mailer, jobs <-chan EmailJob, logger *log.Logger) *EmailWorker {
+	return &EmailWorker{mailer: mailer, jobs: jobs, logger: logger}
+}
+
+// Run starts the worker in a goroutine with no way to stop it.
+func (w *EmailWorker) Run() {
+	// No context, no stop channel — this goroutine runs forever with no exit path.
+	go func() {
+		for {
+			select {
+			case job := <-w.jobs:
+				if err := w.mailer.Send(job); err != nil {
+					w.logger.Printf("failed to send email to %s: %v", job.To, err)
+				}
+			default:
+				time.Sleep(100 * time.Millisecond)
+			}
+		}
+	}()
+}
diff --git a/priv/combined_metrics/samples/code_smells/goroutine_has_clear_exit_condition/good/worker.go b/priv/combined_metrics/samples/code_smells/goroutine_has_clear_exit_condition/good/worker.go
new file mode 100644
index 0000000..046ed7b
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/goroutine_has_clear_exit_condition/good/worker.go
@@ -0,0 +1,52 @@
+package worker
+
+import (
+	"context"
+	"log"
+	"time"
+)
+
+type EmailJob struct {
+	To      string
+	Subject string
+	Body    string
+}
+
+type Mailer interface {
+	Send(job EmailJob) error
+}
+
+// EmailWorker drains jobs from a channel until the context is cancelled.
+// The goroutine has a clear exit condition: ctx.Done().
+type EmailWorker struct {
+	mailer Mailer
+	jobs   <-chan EmailJob
+	logger *log.Logger
+}
+
+func NewEmailWorker(mailer Mailer, jobs <-chan EmailJob, logger *log.Logger) *EmailWorker {
+	return &EmailWorker{mailer: mailer, jobs: jobs, logger: logger}
+}
+
+// Run starts the worker and blocks until ctx is cancelled or jobs is closed.
+func (w *EmailWorker) Run(ctx context.Context) {
+	for {
+		select {
+		case <-ctx.Done():
+			// Clear exit: context cancelled — drain stops.
+			w.logger.Println("email worker shutting down")
+			return
+		case job, ok := <-w.jobs:
+			if !ok {
+				// Clear exit: channel closed — no more work.
+				w.logger.Println("jobs channel closed, email worker exiting")
+				return
+			}
+			if err := w.mailer.Send(job); err != nil {
+				w.logger.Printf("failed to send email to %s: %v", job.To, err)
+			}
+		case <-time.After(30 * time.Second):
+			w.logger.Println("email worker idle heartbeat")
+		}
+	}
+}
diff --git a/priv/combined_metrics/samples/code_smells/io_bound_uses_async_await_not_task_run/bad/DocumentStorage.cs b/priv/combined_metrics/samples/code_smells/io_bound_uses_async_await_not_task_run/bad/DocumentStorage.cs
new file mode 100644
index 0000000..6bc1279
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/io_bound_uses_async_await_not_task_run/bad/DocumentStorage.cs
@@ -0,0 +1,63 @@
+using System.IO;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Storage
+{
+    public class DocumentStorage
+    {
+        private readonly HttpClient _httpClient;
+        private readonly string _storageRoot;
+
+        public DocumentStorage(HttpClient httpClient, string storageRoot)
+        {
+            _httpClient = httpClient;
+            _storageRoot = storageRoot;
+        }
+
+        // I/O-bound but wrapped in Task.Run — wastes a thread pool thread
+        public async Task<string> ReadDocumentAsync(string documentId)
+        {
+            var path = BuildPath(documentId);
+            return await Task.Run(() => File.ReadAllText(path));
+        }
+
+        // I/O-bound write wrapped in Task.Run unnecessarily
+        public async Task SaveDocumentAsync(string documentId, string content)
+        {
+            var path = BuildPath(documentId);
+            await Task.Run(() =>
+            {
+                Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+                File.WriteAllText(path, content, Encoding.UTF8);
+            });
+        }
+
+        // Network I/O inside Task.Run — HttpClient is already async, Task.Run adds no value
+        public async Task<string> FetchFromRemoteAsync(string url)
+        {
+            return await Task.Run(async () =>
+            {
+                var response = await _httpClient.GetAsync(url);
+                response.EnsureSuccessStatusCode();
+                return await response.Content.ReadAsStringAsync();
+            });
+        }
+
+        // Streaming wrapped in Task.Run — unnecessary thread pool hop for I/O
+        public async Task DownloadToFileAsync(string url, string destinationPath)
+        {
+            await Task.Run(async () =>
+            {
+                var response = await _httpClient.GetAsync(url);
+                response.EnsureSuccessStatusCode();
+                var bytes = await response.Content.ReadAsByteArrayAsync();
+                File.WriteAllBytes(destinationPath, bytes);
+            });
+        }
+
+        private string BuildPath(string documentId) =>
+            Path.Combine(_storageRoot, documentId[..2], documentId + ".txt");
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/io_bound_uses_async_await_not_task_run/good/DocumentStorage.cs b/priv/combined_metrics/samples/code_smells/io_bound_uses_async_await_not_task_run/good/DocumentStorage.cs
new file mode 100644
index 0000000..8c6a734
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/io_bound_uses_async_await_not_task_run/good/DocumentStorage.cs
@@ -0,0 +1,60 @@
+using System.IO;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Storage
+{
+    public class DocumentStorage
+    {
+        private readonly HttpClient _httpClient;
+        private readonly string _storageRoot;
+
+        public DocumentStorage(HttpClient httpClient, string storageRoot)
+        {
+            _httpClient = httpClient;
+            _storageRoot = storageRoot;
+        }
+
+        // I/O-bound: reads directly with async file API, no Task.Run needed
+        public async Task<string> ReadDocumentAsync(string documentId)
+        {
+            var path = BuildPath(documentId);
+            return await File.ReadAllTextAsync(path);
+        }
+
+        // I/O-bound: writes via async file API
+        public async Task SaveDocumentAsync(string documentId, string content)
+        {
+            var path = BuildPath(documentId);
+            Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+            await File.WriteAllTextAsync(path, content, Encoding.UTF8);
+        }
+
+        // I/O-bound: uses async HttpClient, not Task.Run
+        public async Task<string> FetchFromRemoteAsync(string url)
+        {
+            var response = await _httpClient.GetAsync(url);
+            response.EnsureSuccessStatusCode();
+            return await response.Content.ReadAsStringAsync();
+        }
+
+        // I/O-bound: streams large file without blocking
+        public async Task DownloadToFileAsync(string url, string destinationPath)
+        {
+            using var response = await _httpClient.GetAsync(
+                url, System.Net.Http.HttpCompletionOption.ResponseHeadersRead);
+            response.EnsureSuccessStatusCode();
+
+            using var contentStream = await response.Content.ReadAsStreamAsync();
+            using var fileStream = new FileStream(
+                destinationPath, FileMode.Create, FileAccess.Write, FileShare.None,
+                bufferSize: 8192, useAsync: true);
+
+            await contentStream.CopyToAsync(fileStream);
+        }
+
+        private string BuildPath(string documentId) =>
+            Path.Combine(_storageRoot, documentId[..2], documentId + ".txt");
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/lambda_not_assigned_to_variable/bad/price_calculator.py b/priv/combined_metrics/samples/code_smells/lambda_not_assigned_to_variable/bad/price_calculator.py
new file mode 100644
index 0000000..939b8de
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/lambda_not_assigned_to_variable/bad/price_calculator.py
@@ -0,0 +1,47 @@
+"""Price calculator with pluggable discount and tax strategies."""
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Callable
+
+
+PriceTransform = Callable[[Decimal], Decimal]
+
+
+# lambdas assigned to names — should be def statements
+apply_percentage_discount = lambda percent: (  # noqa: E731
+    lambda price: price * (1 - Decimal(percent) / 100)
+)
+
+apply_flat_discount = lambda amount: (         # noqa: E731
+    lambda price: max(price - amount, Decimal(0))
+)
+
+apply_tax = lambda rate: (                     # noqa: E731
+    lambda price: price * (1 + rate)
+)
+
+
+def chain_transforms(*transforms: PriceTransform) -> PriceTransform:
+    # lambda assigned to a local name — should be a nested def
+    apply_all = lambda price: [t(price) for t in transforms][-1]  # noqa: E731
+    return apply_all
+
+
+# Module-level strategy functions replaced by named lambdas
+member_price = lambda price: price * Decimal("0.90")   # noqa: E731 — use def
+
+vip_price = lambda price: (                             # noqa: E731 — use def
+    price * Decimal("0.80") * Decimal("1.08")
+)
+
+format_price = lambda price: f"${price:.2f}"           # noqa: E731 — use def
+
+
+def calculate(
+    base_price: Decimal,
+    transform: PriceTransform,
+) -> str:
+    """Apply a transform to a base price and return the formatted result."""
+    final = transform(base_price)
+    return format_price(final)
diff --git a/priv/combined_metrics/samples/code_smells/lambda_not_assigned_to_variable/good/price_calculator.py b/priv/combined_metrics/samples/code_smells/lambda_not_assigned_to_variable/good/price_calculator.py
new file mode 100644
index 0000000..7aa46c8
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/lambda_not_assigned_to_variable/good/price_calculator.py
@@ -0,0 +1,64 @@
+"""Price calculator with pluggable discount and tax strategies."""
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Callable
+
+
+PriceTransform = Callable[[Decimal], Decimal]
+
+
+def apply_percentage_discount(percent: int) -> PriceTransform:
+    """Return a function that applies a percentage discount to a price."""
+    def discount(price: Decimal) -> Decimal:
+        return price * (1 - Decimal(percent) / 100)
+    return discount
+
+
+def apply_flat_discount(amount: Decimal) -> PriceTransform:
+    """Return a function that subtracts a flat amount from a price."""
+    def discount(price: Decimal) -> Decimal:
+        return max(price - amount, Decimal(0))
+    return discount
+
+
+def apply_tax(rate: Decimal) -> PriceTransform:
+    """Return a function that adds a tax rate to a price."""
+    def add_tax(price: Decimal) -> Decimal:
+        return price * (1 + rate)
+    return add_tax
+
+
+def chain_transforms(*transforms: PriceTransform) -> PriceTransform:
+    """Combine multiple price transforms into a single function."""
+    def apply_all(price: Decimal) -> Decimal:
+        for transform in transforms:
+            price = transform(price)
+        return price
+    return apply_all
+
+
+def format_price(price: Decimal) -> str:
+    """Format a Decimal price as a currency string."""
+    return f"${price:.2f}"
+
+
+def calculate(
+    base_price: Decimal,
+    transform: PriceTransform,
+) -> str:
+    """Apply a transform to a base price and return the formatted result."""
+    final = transform(base_price)
+    return format_price(final)
+
+
+# Module-level strategies defined as proper named functions, not lambdas
+def member_price(price: Decimal) -> Decimal:
+    """10 % member discount."""
+    return price * Decimal("0.90")
+
+
+def vip_price(price: Decimal) -> Decimal:
+    """20 % VIP discount followed by 8 % tax."""
+    discounted = price * Decimal("0.80")
+    return discounted * Decimal("1.08")
diff --git a/priv/combined_metrics/samples/code_smells/minimizes_data_in_messages/bad/shipping.ex b/priv/combined_metrics/samples/code_smells/minimizes_data_in_messages/bad/shipping.ex
new file mode 100644
index 0000000..b658fe6
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/minimizes_data_in_messages/bad/shipping.ex
@@ -0,0 +1,67 @@
+defmodule MyApp.Shipping.LabelWorker do
+  @moduledoc """
+  Generates shipping labels asynchronously.
+  """
+
+  use GenServer
+
+  alias MyApp.Orders.Order
+  alias MyApp.Shipping
+
+  def start_link(opts) do
+    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
+  end
+
+  # Bad: enqueues the entire Order struct in the message.
+  # This copies the full struct (including all its associations) into the
+  # worker's mailbox, wasting memory and defeating the purpose of async work.
+  @spec enqueue(Order.t()) :: :ok
+  def enqueue(%Order{} = order) do
+    GenServer.cast(__MODULE__, {:generate_label, order})
+  end
+
+  @impl true
+  def init(_opts), do: {:ok, %{}}
+
+  @impl true
+  # Bad: entire order struct is in the message payload — large copy
+  def handle_cast({:generate_label, %Order{} = order}, state) do
+    # The worker already received a (potentially stale) full struct
+    Task.start(fn -> Shipping.generate_label(order) end)
+    {:noreply, state}
+  end
+end
+
+defmodule MyApp.Shipping.BatchNotifier do
+  @moduledoc """
+  Broadcasts shipping updates.
+  """
+
+  alias MyApp.Shipping.Shipment
+
+  # Bad: broadcasts the full Shipment struct to all subscribers.
+  # If 100 processes subscribe, this full struct is copied 100 times.
+  @spec notify_dispatched(Shipment.t()) :: :ok | {:error, term()}
+  def notify_dispatched(%Shipment{} = shipment) do
+    Phoenix.PubSub.broadcast(
+      MyApp.PubSub,
+      "shipments",
+      # Bad: sending the entire struct with all fields
+      {:shipment_dispatched, shipment}
+    )
+  end
+
+  # Bad: spawning a closure that captures the full struct
+  @spec process_async(Shipment.t()) :: :ok
+  def process_async(%Shipment{} = shipment) do
+    # Bad: the full shipment struct is captured in the closure
+    # and copied into the new process's heap
+    spawn(fn ->
+      Shipping.finalize(shipment)
+      Shipping.archive(shipment)
+      Shipping.notify_customer(shipment)
+    end)
+
+    :ok
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/minimizes_data_in_messages/good/shipping.ex b/priv/combined_metrics/samples/code_smells/minimizes_data_in_messages/good/shipping.ex
new file mode 100644
index 0000000..9b415e0
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/minimizes_data_in_messages/good/shipping.ex
@@ -0,0 +1,61 @@
+defmodule MyApp.Shipping.LabelWorker do
+  @moduledoc """
+  Generates shipping labels asynchronously. Sends only the order ID
+  in the message — the worker re-fetches the data it needs from the
+  database, avoiding large struct serialisation over process boundaries.
+  """
+
+  use GenServer
+
+  alias MyApp.Orders
+  alias MyApp.Shipping
+
+  def start_link(opts) do
+    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
+  end
+
+  @doc """
+  Enqueues label generation for the given order ID.
+  Sends only the integer ID — not the full order struct.
+  """
+  @spec enqueue(integer()) :: :ok
+  def enqueue(order_id) when is_integer(order_id) do
+    GenServer.cast(__MODULE__, {:generate_label, order_id})
+  end
+
+  @impl true
+  def init(_opts), do: {:ok, %{}}
+
+  @impl true
+  # Good: message carries only the order_id.
+  # The handler fetches the full record inside the worker process.
+  def handle_cast({:generate_label, order_id}, state) do
+    Task.start(fn -> do_generate(order_id) end)
+    {:noreply, state}
+  end
+
+  defp do_generate(order_id) do
+    # Re-fetch only the fields needed for label generation
+    order = Orders.get_order!(order_id)
+    Shipping.generate_label(order)
+  end
+end
+
+defmodule MyApp.Shipping.BatchNotifier do
+  @moduledoc """
+  Broadcasts shipping updates. Sends only the shipment ID in PubSub
+  messages; subscribers fetch full details on demand.
+  """
+
+  @doc """
+  Publishes a shipment-dispatched event with only the shipment ID.
+  """
+  @spec notify_dispatched(integer()) :: :ok | {:error, term()}
+  def notify_dispatched(shipment_id) when is_integer(shipment_id) do
+    Phoenix.PubSub.broadcast(
+      MyApp.PubSub,
+      "shipments",
+      {:shipment_dispatched, shipment_id}
+    )
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_array_constructor_with_arguments/bad/matrix_utils.js b/priv/combined_metrics/samples/code_smells/no_array_constructor_with_arguments/bad/matrix_utils.js
new file mode 100644
index 0000000..e624438
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_array_constructor_with_arguments/bad/matrix_utils.js
@@ -0,0 +1,59 @@
+function createMatrix(rows, cols, fillValue = 0) {
+  const matrix = new Array(rows);
+  for (let r = 0; r < rows; r++) {
+    matrix[r] = new Array(cols).fill(fillValue);
+  }
+  return matrix;
+}
+
+function createRange(start, end, step = 1) {
+  const count = Math.ceil((end - start) / step);
+  const result = new Array(count);
+  for (let i = 0; i < count; i++) {
+    result[i] = start + i * step;
+  }
+  return result;
+}
+
+function createFilledArray(length, valueFn) {
+  const arr = new Array(length);
+  for (let i = 0; i < length; i++) {
+    arr[i] = valueFn(i);
+  }
+  return arr;
+}
+
+function transposeMatrix(matrix) {
+  const rows = matrix.length;
+  const cols = matrix[0].length;
+  const result = new Array(cols);
+
+  for (let c = 0; c < cols; c++) {
+    result[c] = new Array(rows);
+    for (let r = 0; r < rows; r++) {
+      result[c][r] = matrix[r][c];
+    }
+  }
+
+  return result;
+}
+
+function multiplyMatrices(a, b) {
+  const rows = a.length;
+  const cols = b[0].length;
+  const inner = b.length;
+
+  const result = new Array(rows);
+  for (let r = 0; r < rows; r++) {
+    result[r] = new Array(cols).fill(0);
+    for (let c = 0; c < cols; c++) {
+      for (let k = 0; k < inner; k++) {
+        result[r][c] += a[r][k] * b[k][c];
+      }
+    }
+  }
+
+  return result;
+}
+
+export { createMatrix, createRange, createFilledArray, transposeMatrix, multiplyMatrices };
diff --git a/priv/combined_metrics/samples/code_smells/no_array_constructor_with_arguments/good/matrix_utils.js b/priv/combined_metrics/samples/code_smells/no_array_constructor_with_arguments/good/matrix_utils.js
new file mode 100644
index 0000000..d7bdf20
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_array_constructor_with_arguments/good/matrix_utils.js
@@ -0,0 +1,53 @@
+function createMatrix(rows, cols, fillValue = 0) {
+  return Array.from({ length: rows }, () => Array.from({ length: cols }, () => fillValue));
+}
+
+function createRange(start, end, step = 1) {
+  const result = [];
+  for (let i = start; i < end; i += step) {
+    result.push(i);
+  }
+  return result;
+}
+
+function createFilledArray(length, valueFn) {
+  return Array.from({ length }, (_, index) => valueFn(index));
+}
+
+function transposeMatrix(matrix) {
+  const rows = matrix.length;
+  const cols = matrix[0].length;
+  const result = Array.from({ length: cols }, () => Array.from({ length: rows }, () => 0));
+
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      result[c][r] = matrix[r][c];
+    }
+  }
+
+  return result;
+}
+
+function multiplyMatrices(a, b) {
+  const rows = a.length;
+  const cols = b[0].length;
+  const inner = b.length;
+
+  const result = Array.from({ length: rows }, () => Array.from({ length: cols }, () => 0));
+
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      for (let k = 0; k < inner; k++) {
+        result[r][c] += a[r][k] * b[k][c];
+      }
+    }
+  }
+
+  return result;
+}
+
+function flattenMatrix(matrix) {
+  return matrix.flat();
+}
+
+export { createMatrix, createRange, createFilledArray, transposeMatrix, multiplyMatrices, flattenMatrix };
diff --git a/priv/combined_metrics/samples/code_smells/no_array_delete/bad/notification_handler.ts b/priv/combined_metrics/samples/code_smells/no_array_delete/bad/notification_handler.ts
new file mode 100644
index 0000000..7a13f77
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_array_delete/bad/notification_handler.ts
@@ -0,0 +1,67 @@
+interface Notification {
+  id: string;
+  userId: string;
+  type: string;
+  title: string;
+  readAt: string | null;
+}
+
+function removeNotificationById(
+  notifications: Notification[],
+  id: string
+): Notification[] {
+  const index = notifications.findIndex((n) => n.id === id);
+  if (index !== -1) {
+    // delete leaves a hole (undefined) in the array instead of removing the element
+    delete notifications[index];
+  }
+  return notifications;
+}
+
+function removeReadNotifications(notifications: Notification[]): Notification[] {
+  for (let i = 0; i < notifications.length; i++) {
+    if (notifications[i].readAt !== null) {
+      delete notifications[i];
+    }
+  }
+  return notifications;
+}
+
+function clearBulk(notifications: Notification[], ids: Set<string>): Notification[] {
+  for (let i = 0; i < notifications.length; i++) {
+    if (ids.has(notifications[i].id)) {
+      delete notifications[i];
+    }
+  }
+  return notifications;
+}
+
+class NotificationQueue {
+  private items: Notification[];
+
+  constructor(initial: Notification[] = []) {
+    this.items = [...initial];
+  }
+
+  enqueue(notification: Notification): void {
+    this.items.push(notification);
+  }
+
+  remove(id: string): void {
+    const index = this.items.findIndex((n) => n.id === id);
+    if (index !== -1) {
+      delete this.items[index];
+    }
+  }
+
+  getAll(): Notification[] {
+    return [...this.items];
+  }
+
+  get length(): number {
+    return this.items.length;
+  }
+}
+
+export { removeNotificationById, removeReadNotifications, clearBulk, NotificationQueue };
+export type { Notification };
diff --git a/priv/combined_metrics/samples/code_smells/no_array_delete/good/notification_handler.ts b/priv/combined_metrics/samples/code_smells/no_array_delete/good/notification_handler.ts
new file mode 100644
index 0000000..942650c
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_array_delete/good/notification_handler.ts
@@ -0,0 +1,64 @@
+interface Notification {
+  id: string;
+  userId: string;
+  type: string;
+  title: string;
+  readAt: string | null;
+}
+
+function removeNotificationById(
+  notifications: Notification[],
+  id: string
+): Notification[] {
+  return notifications.filter((n) => n.id !== id);
+}
+
+function removeNotificationsByType(
+  notifications: Notification[],
+  type: string
+): Notification[] {
+  return notifications.filter((n) => n.type !== type);
+}
+
+function removeReadNotifications(notifications: Notification[]): Notification[] {
+  return notifications.filter((n) => n.readAt === null);
+}
+
+function removeAtIndex(notifications: Notification[], index: number): Notification[] {
+  return [...notifications.slice(0, index), ...notifications.slice(index + 1)];
+}
+
+function clearBulk(notifications: Notification[], ids: Set<string>): Notification[] {
+  return notifications.filter((n) => !ids.has(n.id));
+}
+
+class NotificationQueue {
+  private items: Notification[];
+
+  constructor(initial: Notification[] = []) {
+    this.items = [...initial];
+  }
+
+  enqueue(notification: Notification): void {
+    this.items.push(notification);
+  }
+
+  remove(id: string): void {
+    this.items = this.items.filter((n) => n.id !== id);
+  }
+
+  removeFirst(): Notification | undefined {
+    return this.items.shift();
+  }
+
+  getAll(): Notification[] {
+    return [...this.items];
+  }
+
+  get length(): number {
+    return this.items.length;
+  }
+}
+
+export { removeNotificationById, removeNotificationsByType, removeReadNotifications, removeAtIndex, clearBulk, NotificationQueue };
+export type { Notification };
diff --git a/priv/combined_metrics/samples/code_smells/no_auto_ptr/bad/Connection.cpp b/priv/combined_metrics/samples/code_smells/no_auto_ptr/bad/Connection.cpp
new file mode 100644
index 0000000..2cbdc89
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_auto_ptr/bad/Connection.cpp
@@ -0,0 +1,73 @@
+#include <memory>
+#include <string>
+#include <vector>
+#include <stdexcept>
+
+class Socket {
+public:
+    explicit Socket(const std::string& host, int port)
+        : host_(host), port_(port), connected_(false) {}
+
+    void connect() { connected_ = true; }
+    void disconnect() { connected_ = false; }
+    bool isConnected() const { return connected_; }
+    std::string host() const { return host_; }
+    int port() const { return port_; }
+
+private:
+    std::string host_;
+    int port_;
+    bool connected_;
+};
+
+class Connection {
+public:
+    explicit Connection(const std::string& host, int port)
+        : socket_(new Socket(host, port)) // std::auto_ptr — deprecated and removed in C++17
+    {
+        socket_->connect();
+    }
+
+    ~Connection() {
+        if (socket_.get() && socket_->isConnected())
+            socket_->disconnect();
+        // auto_ptr deletes automatically, but transfer semantics are broken
+    }
+
+    // auto_ptr copy "moves" ownership silently — source becomes null after copy
+    // This causes bugs when connection is put into a container or passed by value
+    Connection(const Connection& other) : socket_(other.socket_) {} // silently steals!
+
+    bool isAlive() const {
+        return socket_.get() && socket_->isConnected();
+    }
+
+    std::string endpoint() const {
+        return socket_->host() + ":" + std::to_string(socket_->port());
+    }
+
+private:
+    std::auto_ptr<Socket> socket_; // std::auto_ptr: deprecated since C++11, removed in C++17
+};
+
+class ConnectionPool {
+public:
+    explicit ConnectionPool(const std::string& host, int port, std::size_t poolSize) {
+        for (std::size_t i = 0; i < poolSize; ++i) {
+            // Storing auto_ptr in a vector is undefined behavior —
+            // std::vector requires copyable elements; auto_ptr's copy transfers ownership
+            connections_.push_back(std::auto_ptr<Connection>(new Connection(host, port)));
+        }
+    }
+
+    Connection* acquire() {
+        for (auto& conn : connections_) {
+            if (conn.get() && conn->isAlive())
+                return conn.get();
+        }
+        throw std::runtime_error("No available connections");
+    }
+
+private:
+    std::vector<std::auto_ptr<Connection>> connections_; // undefined behavior
+};
diff --git a/priv/combined_metrics/samples/code_smells/no_auto_ptr/good/Connection.cpp b/priv/combined_metrics/samples/code_smells/no_auto_ptr/good/Connection.cpp
new file mode 100644
index 0000000..7c2ecc4
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_auto_ptr/good/Connection.cpp
@@ -0,0 +1,73 @@
+#include <memory>
+#include <string>
+#include <vector>
+#include <stdexcept>
+
+class Socket {
+public:
+    explicit Socket(const std::string& host, int port)
+        : host_(host), port_(port), connected_(false) {}
+
+    void connect() { connected_ = true; }
+    void disconnect() noexcept { connected_ = false; }
+    bool isConnected() const noexcept { return connected_; }
+    std::string host() const { return host_; }
+    int port() const { return port_; }
+
+private:
+    std::string host_;
+    int port_;
+    bool connected_;
+};
+
+class Connection {
+public:
+    explicit Connection(const std::string& host, int port)
+        : socket_(std::make_unique<Socket>(host, port)) // unique_ptr — clear ownership
+    {
+        socket_->connect();
+    }
+
+    ~Connection() {
+        if (socket_ && socket_->isConnected())
+            socket_->disconnect();
+    }
+
+    // Move is well-defined with unique_ptr
+    Connection(Connection&&) noexcept = default;
+    Connection& operator=(Connection&&) noexcept = default;
+
+    Connection(const Connection&) = delete;
+    Connection& operator=(const Connection&) = delete;
+
+    bool isAlive() const noexcept {
+        return socket_ && socket_->isConnected();
+    }
+
+    std::string endpoint() const {
+        return socket_->host() + ":" + std::to_string(socket_->port());
+    }
+
+private:
+    std::unique_ptr<Socket> socket_;
+};
+
+class ConnectionPool {
+public:
+    explicit ConnectionPool(const std::string& host, int port, std::size_t size) {
+        connections_.reserve(size);
+        for (std::size_t i = 0; i < size; ++i)
+            connections_.push_back(std::make_unique<Connection>(host, port));
+    }
+
+    Connection* acquire() {
+        for (auto& conn : connections_) {
+            if (conn && conn->isAlive())
+                return conn.get();
+        }
+        throw std::runtime_error("No available connections in pool");
+    }
+
+private:
+    std::vector<std::unique_ptr<Connection>> connections_;
+};
diff --git a/priv/combined_metrics/samples/code_smells/no_blocking_on_async_code/bad/NotificationService.cs b/priv/combined_metrics/samples/code_smells/no_blocking_on_async_code/bad/NotificationService.cs
new file mode 100644
index 0000000..7380910
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_blocking_on_async_code/bad/NotificationService.cs
@@ -0,0 +1,74 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace Notifications
+{
+    public class NotificationService
+    {
+        private readonly HttpClient _httpClient;
+        private readonly string _baseUrl;
+
+        public NotificationService(HttpClient httpClient, string baseUrl)
+        {
+            _httpClient = httpClient;
+            _baseUrl = baseUrl;
+        }
+
+        public void Send(Notification notification)
+        {
+            var payload = JsonSerializer.Serialize(notification);
+            var content = new StringContent(payload, System.Text.Encoding.UTF8, "application/json");
+
+            // .Result blocks the calling thread and can cause deadlocks in ASP.NET contexts
+            var response = _httpClient.PostAsync($"{_baseUrl}/notify", content).Result;
+            response.EnsureSuccessStatusCode();
+        }
+
+        public IReadOnlyList<Notification> GetPending(string recipientId)
+        {
+            // .Result blocks the thread; deadlock-prone in synchronization contexts
+            var response = _httpClient.GetAsync(
+                $"{_baseUrl}/notifications/pending?recipientId={recipientId}").Result;
+            response.EnsureSuccessStatusCode();
+
+            // Another .Result to block on the content read
+            var json = response.Content.ReadAsStringAsync().Result;
+            var notifications = JsonSerializer.Deserialize<List<Notification>>(json);
+            return notifications?.AsReadOnly() ?? new List<Notification>().AsReadOnly();
+        }
+
+        public void DispatchBatch(IEnumerable<Notification> notifications)
+        {
+            var tasks = new List<Task>();
+            foreach (var notification in notifications)
+                tasks.Add(SendAsync(notification));
+
+            // Task.WaitAll blocks the calling thread
+            Task.WaitAll(tasks.ToArray());
+        }
+
+        public bool IsReachable()
+        {
+            try
+            {
+                // .Wait() blocks and can deadlock
+                var responseTask = _httpClient.GetAsync($"{_baseUrl}/health");
+                responseTask.Wait();
+                return responseTask.Result.IsSuccessStatusCode;
+            }
+            catch (AggregateException)
+            {
+                return false;
+            }
+        }
+
+        private Task SendAsync(Notification notification)
+        {
+            var payload = JsonSerializer.Serialize(notification);
+            var content = new StringContent(payload, System.Text.Encoding.UTF8, "application/json");
+            return _httpClient.PostAsync($"{_baseUrl}/notify", content);
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/no_blocking_on_async_code/good/NotificationService.cs b/priv/combined_metrics/samples/code_smells/no_blocking_on_async_code/good/NotificationService.cs
new file mode 100644
index 0000000..cd4ea22
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_blocking_on_async_code/good/NotificationService.cs
@@ -0,0 +1,61 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace Notifications
+{
+    public class NotificationService
+    {
+        private readonly HttpClient _httpClient;
+        private readonly string _baseUrl;
+
+        public NotificationService(HttpClient httpClient, string baseUrl)
+        {
+            _httpClient = httpClient;
+            _baseUrl = baseUrl;
+        }
+
+        public async Task SendAsync(Notification notification)
+        {
+            var payload = JsonSerializer.Serialize(notification);
+            var content = new StringContent(payload, System.Text.Encoding.UTF8, "application/json");
+
+            var response = await _httpClient.PostAsync($"{_baseUrl}/notify", content);
+            response.EnsureSuccessStatusCode();
+        }
+
+        public async Task<IReadOnlyList<Notification>> GetPendingAsync(string recipientId)
+        {
+            var response = await _httpClient.GetAsync(
+                $"{_baseUrl}/notifications/pending?recipientId={recipientId}");
+            response.EnsureSuccessStatusCode();
+
+            var json = await response.Content.ReadAsStringAsync();
+            var notifications = JsonSerializer.Deserialize<List<Notification>>(json);
+            return notifications?.AsReadOnly() ?? new List<Notification>().AsReadOnly();
+        }
+
+        public async Task DispatchBatchAsync(IEnumerable<Notification> notifications)
+        {
+            var tasks = new List<Task>();
+            foreach (var notification in notifications)
+                tasks.Add(SendAsync(notification));
+
+            await Task.WhenAll(tasks);
+        }
+
+        public async Task<bool> IsReachableAsync()
+        {
+            try
+            {
+                var response = await _httpClient.GetAsync($"{_baseUrl}/health");
+                return response.IsSuccessStatusCode;
+            }
+            catch (HttpRequestException)
+            {
+                return false;
+            }
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/no_class_variables/bad/account.rb b/priv/combined_metrics/samples/code_smells/no_class_variables/bad/account.rb
new file mode 100644
index 0000000..4abf9fa
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_class_variables/bad/account.rb
@@ -0,0 +1,46 @@
+class Account
+  # @@var is shared across the entire inheritance hierarchy
+  @@default_plan = :free
+  @@max_team_size = 5
+  @@registered_count = 0
+
+  def self.default_plan
+    @@default_plan
+  end
+
+  def self.default_plan=(plan)
+    @@default_plan = plan
+  end
+
+  def self.max_team_size
+    @@max_team_size
+  end
+
+  def self.registered_count
+    @@registered_count
+  end
+
+  attr_reader :email, :plan, :team_size
+
+  def initialize(email:, plan: @@default_plan, team_size: 1)
+    @email = email
+    @plan = plan
+    @team_size = team_size
+    @@registered_count += 1
+  end
+
+  def upgrade_plan(new_plan)
+    @plan = new_plan
+  end
+
+  def within_team_limit?
+    team_size <= @@max_team_size
+  end
+end
+
+class EnterpriseAccount < Account
+  # Attempting to set subclass defaults, but @@vars are shared with Account
+  # Setting @@default_plan here also changes Account.default_plan — a surprise
+  @@default_plan = :enterprise
+  @@max_team_size = 500
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_class_variables/good/account.rb b/priv/combined_metrics/samples/code_smells/no_class_variables/good/account.rb
new file mode 100644
index 0000000..c4f4de8
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_class_variables/good/account.rb
@@ -0,0 +1,47 @@
+class Account
+  # Use instance variables on the class object instead of @@
+  @default_plan = :free
+  @max_team_size = 5
+  @registered_count = 0
+
+  class << self
+    attr_accessor :default_plan, :max_team_size
+
+    def registered_count
+      @registered_count
+    end
+
+    def increment_registered_count
+      @registered_count += 1
+    end
+
+    def reset_registered_count
+      @registered_count = 0
+    end
+  end
+
+  attr_reader :email, :plan, :team_size
+
+  def initialize(email:, plan: Account.default_plan, team_size: 1)
+    @email = email
+    @plan = plan
+    @team_size = team_size
+    self.class.increment_registered_count
+  end
+
+  def upgrade_plan(new_plan)
+    @plan = new_plan
+  end
+
+  def within_team_limit?
+    team_size <= self.class.max_team_size
+  end
+end
+
+class EnterpriseAccount < Account
+  @default_plan = :enterprise
+  @max_team_size = 500
+
+  # Enterprise subclass has its own independent class-level state
+  # This would not be possible with @@ which leaks across the hierarchy
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_const_enum/bad/product_repository.ts b/priv/combined_metrics/samples/code_smells/no_const_enum/bad/product_repository.ts
new file mode 100644
index 0000000..aed9efc
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_const_enum/bad/product_repository.ts
@@ -0,0 +1,70 @@
+// const enum is inlined at compile time, breaking at runtime when used
+// from JavaScript or with isolatedModules / bundlers
+const enum ProductStatus {
+  Draft = "draft",
+  Active = "active",
+  Archived = "archived",
+  OutOfStock = "out_of_stock",
+}
+
+const enum ProductCategory {
+  Electronics = "electronics",
+  Clothing = "clothing",
+  Food = "food",
+  Books = "books",
+  Other = "other",
+}
+
+const enum SortOrder {
+  PriceAsc = "price_asc",
+  PriceDesc = "price_desc",
+  NameAsc = "name_asc",
+  Newest = "newest",
+}
+
+interface Product {
+  id: string;
+  name: string;
+  price: number;
+  status: ProductStatus;
+  category: ProductCategory;
+  stock: number;
+  createdAt: string;
+}
+
+interface ProductQuery {
+  category?: ProductCategory;
+  status?: ProductStatus;
+  sortOrder?: SortOrder;
+  page?: number;
+  pageSize?: number;
+}
+
+async function fetchProducts(query: ProductQuery = {}): Promise<Product[]> {
+  const params = new URLSearchParams();
+  if (query.category) params.set("category", query.category);
+  if (query.status) params.set("status", query.status);
+  if (query.sortOrder) params.set("sort", query.sortOrder);
+  if (query.page) params.set("page", String(query.page));
+  if (query.pageSize) params.set("pageSize", String(query.pageSize));
+
+  const response = await fetch(`/api/products?${params}`);
+  if (!response.ok) throw new Error(`Failed to fetch products: ${response.status}`);
+  return response.json() as Promise<Product[]>;
+}
+
+function isAvailable(product: Product): boolean {
+  return product.status === ProductStatus.Active && product.stock > 0;
+}
+
+function getStatusLabel(status: ProductStatus): string {
+  switch (status) {
+    case ProductStatus.Draft: return "Draft";
+    case ProductStatus.Active: return "Active";
+    case ProductStatus.Archived: return "Archived";
+    case ProductStatus.OutOfStock: return "Out of Stock";
+  }
+}
+
+export { fetchProducts, isAvailable, getStatusLabel, ProductStatus, ProductCategory, SortOrder };
+export type { Product, ProductQuery };
diff --git a/priv/combined_metrics/samples/code_smells/no_const_enum/good/product_repository.ts b/priv/combined_metrics/samples/code_smells/no_const_enum/good/product_repository.ts
new file mode 100644
index 0000000..c68ffe9
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_const_enum/good/product_repository.ts
@@ -0,0 +1,69 @@
+enum ProductStatus {
+  Draft = "draft",
+  Active = "active",
+  Archived = "archived",
+  OutOfStock = "out_of_stock",
+}
+
+enum ProductCategory {
+  Electronics = "electronics",
+  Clothing = "clothing",
+  Food = "food",
+  Books = "books",
+  Other = "other",
+}
+
+enum SortOrder {
+  PriceAsc = "price_asc",
+  PriceDesc = "price_desc",
+  NameAsc = "name_asc",
+  Newest = "newest",
+}
+
+interface Product {
+  id: string;
+  name: string;
+  price: number;
+  status: ProductStatus;
+  category: ProductCategory;
+  stock: number;
+  createdAt: string;
+}
+
+interface ProductQuery {
+  category?: ProductCategory;
+  status?: ProductStatus;
+  sortOrder?: SortOrder;
+  page?: number;
+  pageSize?: number;
+}
+
+async function fetchProducts(query: ProductQuery = {}): Promise<Product[]> {
+  const params = new URLSearchParams();
+  if (query.category) params.set("category", query.category);
+  if (query.status) params.set("status", query.status);
+  if (query.sortOrder) params.set("sort", query.sortOrder);
+  if (query.page) params.set("page", String(query.page));
+  if (query.pageSize) params.set("pageSize", String(query.pageSize));
+
+  const response = await fetch(`/api/products?${params}`);
+  if (!response.ok) throw new Error(`Failed to fetch products: ${response.status}`);
+  return response.json() as Promise<Product[]>;
+}
+
+function isAvailable(product: Product): boolean {
+  return product.status === ProductStatus.Active && product.stock > 0;
+}
+
+function getStatusLabel(status: ProductStatus): string {
+  const labels: Record<ProductStatus, string> = {
+    [ProductStatus.Draft]: "Draft",
+    [ProductStatus.Active]: "Active",
+    [ProductStatus.Archived]: "Archived",
+    [ProductStatus.OutOfStock]: "Out of Stock",
+  };
+  return labels[status];
+}
+
+export { fetchProducts, isAvailable, getStatusLabel, ProductStatus, ProductCategory, SortOrder };
+export type { Product, ProductQuery };
diff --git a/priv/combined_metrics/samples/code_smells/no_dead_code_after_return/bad/order_service.ex b/priv/combined_metrics/samples/code_smells/no_dead_code_after_return/bad/order_service.ex
new file mode 100644
index 0000000..c501350
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_dead_code_after_return/bad/order_service.ex
@@ -0,0 +1,96 @@
+defmodule OrderService do
+  @moduledoc "Handles order creation, validation, and fulfillment"
+
+  def create_order(user, items) do
+    if user == nil do
+      {:error, :user_required}
+      IO.puts("This will never run")
+      log_attempt(nil)
+    end
+
+    if items == [] do
+      {:error, :items_required}
+      notify_empty_cart(user)
+    end
+
+    total = calculate_total(items)
+    {:ok, %{user_id: user.id, items: items, total: total}}
+  end
+
+  def cancel_order(order) do
+    case order.status do
+      :pending ->
+        {:ok, %{order | status: :cancelled}}
+        send_cancellation_email(order.user_id)
+        update_inventory(order.items)
+
+      :shipped ->
+        {:error, :already_shipped}
+        log_cancel_attempt(order.id)
+        notify_support(order)
+
+      _ ->
+        {:error, :invalid_status}
+        IO.inspect(order, label: "unexpected order")
+    end
+  end
+
+  def apply_discount(order, code) do
+    case lookup_discount(code) do
+      nil ->
+        {:error, :invalid_code}
+        track_invalid_code(code)
+        {:error, :not_found}
+
+      discount ->
+        new_total = order.total * (1 - discount.rate)
+        {:ok, %{order | total: new_total}}
+    end
+  end
+
+  def validate_address(address) do
+    if address.zip == nil do
+      {:error, :zip_required}
+      flag_incomplete_address(address)
+    end
+
+    if address.city == nil do
+      {:error, :city_required}
+      flag_incomplete_address(address)
+    end
+
+    {:ok, address}
+  end
+
+  def fulfill_order(order) do
+    case order.payment_status do
+      :paid ->
+        {:ok, %{order | status: :fulfilling}}
+        schedule_shipment(order)
+        notify_warehouse(order)
+
+      :pending ->
+        {:error, :payment_pending}
+        retry_payment(order)
+
+      :failed ->
+        {:error, :payment_failed}
+        notify_user_payment_failed(order.user_id)
+    end
+  end
+
+  defp calculate_total(items), do: Enum.sum(Enum.map(items, & &1.price))
+  defp lookup_discount(_code), do: nil
+  defp send_cancellation_email(_user_id), do: :ok
+  defp update_inventory(_items), do: :ok
+  defp log_cancel_attempt(_id), do: :ok
+  defp notify_support(_order), do: :ok
+  defp track_invalid_code(_code), do: :ok
+  defp flag_incomplete_address(_address), do: :ok
+  defp schedule_shipment(_order), do: :ok
+  defp notify_warehouse(_order), do: :ok
+  defp retry_payment(_order), do: :ok
+  defp notify_user_payment_failed(_user_id), do: :ok
+  defp log_attempt(_user), do: :ok
+  defp notify_empty_cart(_user), do: :ok
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_dead_code_after_return/config.yml b/priv/combined_metrics/samples/code_smells/no_dead_code_after_return/config.yml
new file mode 100644
index 0000000..9132452
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_dead_code_after_return/config.yml
@@ -0,0 +1 @@
+doc: "There should be no unreachable statements after a return or early exit."
diff --git a/priv/combined_metrics/samples/code_smells/no_dead_code_after_return/good/order_service.ex b/priv/combined_metrics/samples/code_smells/no_dead_code_after_return/good/order_service.ex
new file mode 100644
index 0000000..8262780
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_dead_code_after_return/good/order_service.ex
@@ -0,0 +1,58 @@
+defmodule OrderService do
+  @moduledoc "Handles order creation, validation, and fulfillment"
+
+  def create_order(nil, _items), do: {:error, :user_required}
+  def create_order(_user, []), do: {:error, :items_required}
+
+  def create_order(user, items) do
+    total = calculate_total(items)
+    {:ok, %{user_id: user.id, items: items, total: total}}
+  end
+
+  def cancel_order(%{status: :pending} = order) do
+    {:ok, %{order | status: :cancelled}}
+  end
+
+  def cancel_order(%{status: :shipped}) do
+    {:error, :already_shipped}
+  end
+
+  def cancel_order(_order) do
+    {:error, :invalid_status}
+  end
+
+  def apply_discount(order, code) do
+    case lookup_discount(code) do
+      nil ->
+        {:error, :invalid_code}
+
+      discount ->
+        new_total = order.total * (1 - discount.rate)
+        {:ok, %{order | total: new_total}}
+    end
+  end
+
+  def validate_address(%{zip: nil}), do: {:error, :zip_required}
+  def validate_address(%{city: nil}), do: {:error, :city_required}
+  def validate_address(address), do: {:ok, address}
+
+  def fulfill_order(%{payment_status: :paid} = order) do
+    updated = %{order | status: :fulfilling}
+    schedule_shipment(updated)
+    notify_warehouse(updated)
+    {:ok, updated}
+  end
+
+  def fulfill_order(%{payment_status: :pending}) do
+    {:error, :payment_pending}
+  end
+
+  def fulfill_order(%{payment_status: :failed}) do
+    {:error, :payment_failed}
+  end
+
+  defp calculate_total(items), do: Enum.sum(Enum.map(items, & &1.price))
+  defp lookup_discount(_code), do: nil
+  defp schedule_shipment(_order), do: :ok
+  defp notify_warehouse(_order), do: :ok
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_debug_print_statements/bad/payment.ex b/priv/combined_metrics/samples/code_smells/no_debug_print_statements/bad/payment.ex
new file mode 100644
index 0000000..2c75241
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_debug_print_statements/bad/payment.ex
@@ -0,0 +1,97 @@
+defmodule Payment do
+  @moduledoc "Handles payment processing and refunds"
+
+  def charge(user, amount, card) do
+    IO.puts("charging user: #{user.id}")
+    IO.inspect(card, label: "card details")
+    IO.inspect(amount, label: "amount")
+
+    case validate_card(card) do
+      {:ok, validated} ->
+        IO.puts("card validated successfully")
+        IO.inspect(validated, label: "validated card")
+        result = call_payment_gateway(validated, amount)
+        IO.inspect(result, label: "gateway result")
+        result
+
+      {:error, reason} ->
+        IO.puts("card validation failed: #{inspect(reason)}")
+        {:error, reason}
+    end
+  end
+
+  def refund(transaction_id, amount) do
+    IO.puts("starting refund for transaction: #{transaction_id}")
+
+    case fetch_transaction(transaction_id) do
+      {:ok, transaction} ->
+        IO.inspect(transaction, label: "found transaction")
+
+        if transaction.amount < amount do
+          IO.puts("refund amount exceeds original")
+          {:error, :exceeds_original}
+        else
+          IO.puts("processing refund of #{amount}")
+          result = call_refund_api(transaction, amount)
+          IO.inspect(result, label: "refund result")
+          result
+        end
+
+      {:error, :not_found} ->
+        IO.puts("transaction not found: #{transaction_id}")
+        {:error, :not_found}
+    end
+  end
+
+  def calculate_fee(amount, method) do
+    IO.inspect({amount, method}, label: "fee calculation input")
+
+    fee =
+      case method do
+        :credit_card -> amount * 0.029 + 0.30
+        :debit_card -> amount * 0.015
+        :bank_transfer -> 0.25
+        _ -> amount * 0.035
+      end
+
+    IO.puts("calculated fee: #{fee}")
+    fee
+  end
+
+  def authorize(user, amount) do
+    IO.inspect(user, label: "authorizing user")
+    IO.puts("checking balance for #{user.id}, amount: #{amount}")
+
+    cond do
+      user.balance >= amount ->
+        IO.puts("authorization approved")
+        {:ok, :authorized}
+
+      true ->
+        IO.puts("insufficient funds: #{user.balance} < #{amount}")
+        {:error, :insufficient_funds}
+    end
+  end
+
+  def apply_coupon(total, coupon_code) do
+    IO.puts("applying coupon: #{coupon_code}")
+
+    case lookup_coupon(coupon_code) do
+      {:ok, coupon} ->
+        IO.inspect(coupon, label: "coupon found")
+        discounted = total - coupon.discount
+        IO.puts("new total after coupon: #{discounted}")
+        {:ok, discounted}
+
+      {:error, _} ->
+        IO.puts("coupon not found: #{coupon_code}")
+        {:error, :invalid_coupon}
+    end
+  end
+
+  defp validate_card(card), do: {:ok, card}
+  defp call_payment_gateway(_card, _amount), do: {:ok, %{transaction_id: "txn_123"}}
+  defp fetch_transaction(_id), do: {:ok, %{amount: 100.0}}
+  defp call_refund_api(_transaction, _amount), do: {:ok, :refunded}
+  defp lookup_coupon(_code), do: {:error, :not_found}
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_debug_print_statements/config.yml b/priv/combined_metrics/samples/code_smells/no_debug_print_statements/config.yml
new file mode 100644
index 0000000..5f85825
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_debug_print_statements/config.yml
@@ -0,0 +1 @@
+doc: "Debug output (`console.log`, `IO.inspect`, `fmt.Println`) must not be left in committed code."
diff --git a/priv/combined_metrics/samples/code_smells/no_debug_print_statements/good/payment.ex b/priv/combined_metrics/samples/code_smells/no_debug_print_statements/good/payment.ex
new file mode 100644
index 0000000..b9b5b1c
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_debug_print_statements/good/payment.ex
@@ -0,0 +1,66 @@
+defmodule Payment do
+  @moduledoc "Handles payment processing and refunds"
+
+  require Logger
+
+  def charge(user, amount, card) do
+    case validate_card(card) do
+      {:ok, validated} ->
+        result = call_payment_gateway(validated, amount)
+        Logger.info("Payment charged", user_id: user.id, amount: amount)
+        result
+
+      {:error, reason} ->
+        Logger.warning("Card validation failed", user_id: user.id, reason: inspect(reason))
+        {:error, reason}
+    end
+  end
+
+  def refund(transaction_id, amount) do
+    case fetch_transaction(transaction_id) do
+      {:ok, transaction} when transaction.amount >= amount ->
+        result = call_refund_api(transaction, amount)
+        Logger.info("Refund processed", transaction_id: transaction_id, amount: amount)
+        result
+
+      {:ok, _transaction} ->
+        {:error, :exceeds_original}
+
+      {:error, :not_found} ->
+        {:error, :not_found}
+    end
+  end
+
+  def calculate_fee(amount, method) do
+    case method do
+      :credit_card -> amount * 0.029 + 0.30
+      :debit_card -> amount * 0.015
+      :bank_transfer -> 0.25
+      _ -> amount * 0.035
+    end
+  end
+
+  def authorize(user, amount) do
+    if user.balance >= amount do
+      {:ok, :authorized}
+    else
+      {:error, :insufficient_funds}
+    end
+  end
+
+  def apply_coupon(total, coupon_code) do
+    case lookup_coupon(coupon_code) do
+      {:ok, coupon} ->
+        {:ok, total - coupon.discount}
+
+      {:error, _} ->
+        {:error, :invalid_coupon}
+    end
+  end
+
+  defp validate_card(card), do: {:ok, card}
+  defp call_payment_gateway(_card, _amount), do: {:ok, %{transaction_id: "txn_123"}}
+  defp fetch_transaction(_id), do: {:ok, %{amount: 100.0}}
+  defp call_refund_api(_transaction, _amount), do: {:ok, :refunded}
+  defp lookup_coupon(_code), do: {:error, :not_found}
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_double_negation/bad/cart.rb b/priv/combined_metrics/samples/code_smells/no_double_negation/bad/cart.rb
new file mode 100644
index 0000000..44e3fb0
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_double_negation/bad/cart.rb
@@ -0,0 +1,45 @@
+class CartPresenter
+  attr_reader :cart, :user
+
+  def initialize(cart, user)
+    @cart = cart
+    @user = user
+  end
+
+  def has_items?
+    !!cart.line_items.any?
+  end
+
+  def has_coupon?
+    !!cart.coupon_code
+  end
+
+  # !! is unnecessary — nil? already returns a boolean
+  def user_authenticated?
+    !!user
+  end
+
+  def show_guest_prompt?
+    !!user.nil?
+  end
+
+  def checkout_enabled?
+    !!(has_items? && user_authenticated?)
+  end
+
+  def discount_applied?
+    !!(has_coupon? && cart.discount_amount.to_f > 0)
+  end
+
+  def to_h
+    {
+      has_items: !!has_items?,
+      has_coupon: !!has_coupon?,
+      authenticated: !!user_authenticated?,
+      checkout_enabled: !!checkout_enabled?,
+      discount_applied: !!discount_applied?,
+      item_count: cart.line_items.size,
+      total: cart.total
+    }
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_double_negation/good/cart.rb b/priv/combined_metrics/samples/code_smells/no_double_negation/good/cart.rb
new file mode 100644
index 0000000..42f421a
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_double_negation/good/cart.rb
@@ -0,0 +1,44 @@
+class CartPresenter
+  attr_reader :cart, :user
+
+  def initialize(cart, user)
+    @cart = cart
+    @user = user
+  end
+
+  def has_items?
+    cart.line_items.any?
+  end
+
+  def has_coupon?
+    cart.coupon_code.present?
+  end
+
+  def user_authenticated?
+    !user.nil?
+  end
+
+  def show_guest_prompt?
+    user.nil?
+  end
+
+  def checkout_enabled?
+    has_items? && user_authenticated?
+  end
+
+  def discount_applied?
+    has_coupon? && cart.discount_amount.to_f > 0
+  end
+
+  def to_h
+    {
+      has_items: has_items?,
+      has_coupon: has_coupon?,
+      authenticated: user_authenticated?,
+      checkout_enabled: checkout_enabled?,
+      discount_applied: discount_applied?,
+      item_count: cart.line_items.size,
+      total: cart.total
+    }
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_finalize_override/bad/DatabaseConnection.java b/priv/combined_metrics/samples/code_smells/no_finalize_override/bad/DatabaseConnection.java
new file mode 100644
index 0000000..823d0c1
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_finalize_override/bad/DatabaseConnection.java
@@ -0,0 +1,67 @@
+package com.example.db;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class DatabaseConnection {
+
+    private static final Logger logger = Logger.getLogger(DatabaseConnection.class.getName());
+
+    private final Connection connection;
+    private boolean closed = false;
+
+    public DatabaseConnection(Connection connection) {
+        this.connection = connection;
+    }
+
+    public QueryResult execute(String sql, Object... params) throws SQLException {
+        try (var stmt = connection.prepareStatement(sql)) {
+            for (int i = 0; i < params.length; i++) {
+                stmt.setObject(i + 1, params[i]);
+            }
+            return QueryResult.from(stmt.executeQuery());
+        }
+    }
+
+    public void beginTransaction() throws SQLException {
+        connection.setAutoCommit(false);
+    }
+
+    public void commit() throws SQLException {
+        connection.commit();
+    }
+
+    public void rollback() throws SQLException {
+        connection.rollback();
+    }
+
+    public void close() throws SQLException {
+        if (!closed) {
+            closed = true;
+            connection.close();
+        }
+    }
+
+    /**
+     * Overrides Object.finalize() to close the connection when garbage collected.
+     * This is unreliable — finalize() may never run, or run too late, leaving
+     * database connections open indefinitely.
+     */
+    @Override
+    protected void finalize() throws Throwable {
+        try {
+            if (!closed) {
+                logger.log(Level.WARNING, "DatabaseConnection was not closed explicitly — closing in finalizer");
+                connection.close();
+            }
+        } finally {
+            super.finalize();
+        }
+    }
+
+    public boolean isClosed() {
+        return closed;
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/no_finalize_override/good/DatabaseConnection.java b/priv/combined_metrics/samples/code_smells/no_finalize_override/good/DatabaseConnection.java
new file mode 100644
index 0000000..ed98a87
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_finalize_override/good/DatabaseConnection.java
@@ -0,0 +1,77 @@
+package com.example.db;
+
+import java.io.Closeable;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Wraps a JDBC connection. Use try-with-resources to ensure the connection
+ * is closed promptly; do not rely on garbage collection for cleanup.
+ */
+public class DatabaseConnection implements Closeable {
+
+    private static final Logger logger = Logger.getLogger(DatabaseConnection.class.getName());
+
+    private final Connection connection;
+    private boolean closed = false;
+
+    public DatabaseConnection(Connection connection) {
+        this.connection = connection;
+    }
+
+    public QueryResult execute(String sql, Object... params) throws SQLException {
+        ensureOpen();
+        try (var stmt = connection.prepareStatement(sql)) {
+            for (int i = 0; i < params.length; i++) {
+                stmt.setObject(i + 1, params[i]);
+            }
+            return QueryResult.from(stmt.executeQuery());
+        }
+    }
+
+    public void beginTransaction() throws SQLException {
+        ensureOpen();
+        connection.setAutoCommit(false);
+    }
+
+    public void commit() throws SQLException {
+        ensureOpen();
+        connection.commit();
+    }
+
+    public void rollback() throws SQLException {
+        ensureOpen();
+        try {
+            connection.rollback();
+        } catch (SQLException e) {
+            logger.log(Level.WARNING, "Rollback failed", e);
+            throw e;
+        }
+    }
+
+    @Override
+    public void close() {
+        if (!closed) {
+            closed = true;
+            try {
+                connection.close();
+            } catch (SQLException e) {
+                // Log but do not propagate — close() must not throw checked exceptions.
+                // The connection resource is released regardless.
+                logger.log(Level.WARNING, "Error closing database connection", e);
+            }
+        }
+    }
+
+    public boolean isClosed() {
+        return closed;
+    }
+
+    private void ensureOpen() {
+        if (closed) {
+            throw new IllegalStateException("DatabaseConnection has already been closed");
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/no_fixme_comments/bad/importer.ex b/priv/combined_metrics/samples/code_smells/no_fixme_comments/bad/importer.ex
new file mode 100644
index 0000000..6e5ea09
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_fixme_comments/bad/importer.ex
@@ -0,0 +1,77 @@
+defmodule Importer do
+  @moduledoc "Handles importing data from CSV and external sources"
+
+  # FIXME: this crashes on empty files, need to handle that
+  def import_csv(path) do
+    path
+    |> File.read!()
+    |> String.split("\n")
+    |> Enum.map(&parse_row/1)
+    |> Enum.reject(&is_nil/1)
+  end
+
+  # TODO: FIXME - validate headers before parsing rows
+  def parse_row(line) do
+    case String.split(line, ",") do
+      [id, name, email] ->
+        %{id: id, name: name, email: email}
+
+      # XXX: silently drops malformed rows, should log or collect errors
+      _ ->
+        nil
+    end
+  end
+
+  def import_users(rows) do
+    # FIXME: this does N+1 inserts, wrap in a transaction
+    Enum.map(rows, fn row ->
+      insert_user(row)
+    end)
+  end
+
+  def validate_row(%{email: email} = row) do
+    # XXX: email regex is wrong, doesn't handle subdomains
+    if String.match?(email, ~r/@/) do
+      {:ok, row}
+    else
+      {:error, :invalid_email}
+    end
+  end
+
+  def deduplicate(rows) do
+    # FIXME: uses email as dedup key but doesn't normalize case first
+    rows
+    |> Enum.group_by(& &1.email)
+    |> Enum.map(fn {_email, [first | _rest]} -> first end)
+  end
+
+  def import_from_api(source_url) do
+    # TODO: FIXME - add retry logic and timeout handling
+    case fetch_remote(source_url) do
+      {:ok, data} ->
+        parse_api_response(data)
+
+      # XXX: swallows all errors, need proper error propagation
+      _ ->
+        []
+    end
+  end
+
+  def transform_row(row, field_map) do
+    # FIXME: doesn't handle nested fields or type coercion
+    Enum.reduce(field_map, %{}, fn {src, dst}, acc ->
+      Map.put(acc, dst, Map.get(row, src))
+    end)
+  end
+
+  def write_results(results, output_path) do
+    # XXX: overwrites file without backup, could lose data
+    content = Enum.map_join(results, "\n", &format_result/1)
+    File.write!(output_path, content)
+  end
+
+  defp insert_user(row), do: {:ok, row}
+  defp fetch_remote(_url), do: {:ok, []}
+  defp parse_api_response(data), do: data
+  defp format_result(result), do: inspect(result)
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_fixme_comments/config.yml b/priv/combined_metrics/samples/code_smells/no_fixme_comments/config.yml
new file mode 100644
index 0000000..be88771
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_fixme_comments/config.yml
@@ -0,0 +1 @@
+doc: "FIXME, XXX, and HACK comments indicate known problems that should be resolved before merging."
diff --git a/priv/combined_metrics/samples/code_smells/no_fixme_comments/good/importer.ex b/priv/combined_metrics/samples/code_smells/no_fixme_comments/good/importer.ex
new file mode 100644
index 0000000..2af79a9
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_fixme_comments/good/importer.ex
@@ -0,0 +1,88 @@
+defmodule Importer do
+  @moduledoc "Handles importing data from CSV and external sources"
+
+  def import_csv(path) do
+    case File.read(path) do
+      {:ok, ""} ->
+        {:error, :empty_file}
+
+      {:ok, content} ->
+        rows =
+          content
+          |> String.split("\n", trim: true)
+          |> Enum.map(&parse_row/1)
+          |> Enum.reject(&is_nil/1)
+
+        {:ok, rows}
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  def parse_row(line) do
+    case String.split(line, ",") do
+      [id, name, email] ->
+        %{id: id, name: name, email: email}
+
+      _ ->
+        nil
+    end
+  end
+
+  def import_users(rows) do
+    rows
+    |> Enum.map(&insert_user/1)
+    |> Enum.split_with(&match?({:ok, _}, &1))
+    |> then(fn {ok, errors} -> {:ok, length(ok), length(errors)} end)
+  end
+
+  def validate_row(%{email: email} = row) do
+    normalized = String.downcase(email)
+
+    if String.match?(normalized, ~r/^[^\s@]+@[^\s@]+\.[^\s@]+$/) do
+      {:ok, %{row | email: normalized}}
+    else
+      {:error, :invalid_email}
+    end
+  end
+
+  def deduplicate(rows) do
+    rows
+    |> Enum.map(fn row -> %{row | email: String.downcase(row.email)} end)
+    |> Enum.group_by(& &1.email)
+    |> Enum.map(fn {_email, [first | _rest]} -> first end)
+  end
+
+  def import_from_api(source_url) do
+    with {:ok, data} <- fetch_remote(source_url),
+         {:ok, parsed} <- parse_api_response(data) do
+      {:ok, parsed}
+    end
+  end
+
+  def transform_row(row, field_map) do
+    Enum.reduce(field_map, %{}, fn {src, dst}, acc ->
+      Map.put(acc, dst, Map.get(row, src))
+    end)
+  end
+
+  def write_results(results, output_path) do
+    backup_path = output_path <> ".bak"
+
+    with :ok <- maybe_backup(output_path, backup_path),
+         content = Enum.map_join(results, "\n", &format_result/1),
+         :ok <- File.write(output_path, content) do
+      :ok
+    end
+  end
+
+  defp maybe_backup(path, backup) do
+    if File.exists?(path), do: File.copy(path, backup), else: :ok
+  end
+
+  defp insert_user(row), do: {:ok, row}
+  defp fetch_remote(_url), do: {:ok, []}
+  defp parse_api_response(data), do: {:ok, data}
+  defp format_result(result), do: inspect(result)
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_global_scope_pollution/bad/analytics_tracker.js b/priv/combined_metrics/samples/code_smells/no_global_scope_pollution/bad/analytics_tracker.js
new file mode 100644
index 0000000..02af07e
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_global_scope_pollution/bad/analytics_tracker.js
@@ -0,0 +1,59 @@
+window.ANALYTICS_ENDPOINT = "/api/analytics";
+window.ANALYTICS_API_KEY = process.env.ANALYTICS_API_KEY;
+window.analyticsQueue = [];
+window.analyticsSessionId = null;
+window.analyticsFlushTimer = null;
+const MAX_QUEUE_SIZE = 100;
+
+function initAnalytics() {
+  const stored = sessionStorage.getItem("session");
+  window.analyticsSessionId = stored ?? crypto.randomUUID();
+  sessionStorage.setItem("session", window.analyticsSessionId);
+}
+
+function trackEvent(eventName, properties = {}) {
+  if (window.analyticsQueue.length >= MAX_QUEUE_SIZE) {
+    flushAnalytics();
+  }
+
+  window.analyticsQueue.push({
+    event: eventName,
+    properties,
+    sessionId: window.analyticsSessionId,
+    timestamp: Date.now(),
+  });
+
+  scheduleAnalyticsFlush();
+}
+
+function identifyUser(userId, traits = {}) {
+  trackEvent("$identify", { userId, ...traits });
+}
+
+function scheduleAnalyticsFlush() {
+  if (window.analyticsFlushTimer) return;
+  window.analyticsFlushTimer = setTimeout(() => {
+    window.analyticsFlushTimer = null;
+    flushAnalytics();
+  }, 2000);
+}
+
+async function flushAnalytics() {
+  if (window.analyticsQueue.length === 0) return;
+  const events = window.analyticsQueue.splice(0, window.analyticsQueue.length);
+  await fetch(window.ANALYTICS_ENDPOINT, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Api-Key": window.ANALYTICS_API_KEY,
+    },
+    body: JSON.stringify({ events }),
+  });
+}
+
+window.trackEvent = trackEvent;
+window.identifyUser = identifyUser;
+window.flushAnalytics = flushAnalytics;
+window.initAnalytics = initAnalytics;
+
+initAnalytics();
diff --git a/priv/combined_metrics/samples/code_smells/no_global_scope_pollution/good/analytics_tracker.js b/priv/combined_metrics/samples/code_smells/no_global_scope_pollution/good/analytics_tracker.js
new file mode 100644
index 0000000..d81f8ac
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_global_scope_pollution/good/analytics_tracker.js
@@ -0,0 +1,68 @@
+const SESSION_KEY = "analytics_session";
+const MAX_QUEUE_SIZE = 100;
+
+class AnalyticsTracker {
+  constructor(config) {
+    this._endpoint = config.endpoint;
+    this._apiKey = config.apiKey;
+    this._queue = [];
+    this._sessionId = this._loadOrCreateSession();
+    this._flushTimer = null;
+  }
+
+  track(eventName, properties = {}) {
+    if (this._queue.length >= MAX_QUEUE_SIZE) {
+      this._flushQueue();
+    }
+
+    this._queue.push({
+      event: eventName,
+      properties,
+      sessionId: this._sessionId,
+      timestamp: Date.now(),
+    });
+
+    this._scheduleFlush();
+  }
+
+  identify(userId, traits = {}) {
+    this.track("$identify", { userId, ...traits });
+  }
+
+  async flush() {
+    await this._flushQueue();
+  }
+
+  _scheduleFlush() {
+    if (this._flushTimer) return;
+    this._flushTimer = setTimeout(() => {
+      this._flushTimer = null;
+      this._flushQueue();
+    }, 2000);
+  }
+
+  async _flushQueue() {
+    if (this._queue.length === 0) return;
+    const events = this._queue.splice(0, this._queue.length);
+    await fetch(this._endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Api-Key": this._apiKey },
+      body: JSON.stringify({ events }),
+    });
+  }
+
+  _loadOrCreateSession() {
+    const stored = sessionStorage.getItem(SESSION_KEY);
+    if (stored) return stored;
+    const id = crypto.randomUUID();
+    sessionStorage.setItem(SESSION_KEY, id);
+    return id;
+  }
+}
+
+const tracker = new AnalyticsTracker({
+  endpoint: "/api/analytics",
+  apiKey: process.env.ANALYTICS_API_KEY,
+});
+
+export { tracker, AnalyticsTracker };
diff --git a/priv/combined_metrics/samples/code_smells/no_library_global_application_config/bad/billing.ex b/priv/combined_metrics/samples/code_smells/no_library_global_application_config/bad/billing.ex
new file mode 100644
index 0000000..7e639a1
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_library_global_application_config/bad/billing.ex
@@ -0,0 +1,58 @@
+defmodule Acme.Billing do
+  @moduledoc """
+  Billing library.
+  """
+
+  # Bad: reads configuration from the global application environment.
+  # This couples the library to a specific OTP app name and config key.
+  # The library cannot be used without configuring `:acme_billing` in config.exs,
+  # and it cannot be used with different configs simultaneously (e.g., multiple accounts).
+
+  @doc """
+  Creates a charge. Reads API key and base URL from Application env.
+  """
+  @spec create_charge(map()) :: {:ok, map()} | {:error, term()}
+  def create_charge(params) do
+    # Bad: tight coupling to global config
+    api_key = Application.get_env(:acme_billing, :api_key) ||
+      raise "Acme.Billing: :api_key not configured"
+
+    base_url = Application.get_env(:acme_billing, :base_url, "https://api.acmebilling.com")
+    timeout = Application.get_env(:acme_billing, :timeout_ms, 5_000)
+
+    url = "#{base_url}/charges"
+    headers = [{"Authorization", "Bearer #{api_key}"}]
+    options = [timeout: timeout, recv_timeout: timeout]
+
+    case HTTPoison.post(url, Jason.encode!(params), headers, options) do
+      {:ok, %{status_code: 201, body: body}} -> {:ok, Jason.decode!(body)}
+      {:ok, %{status_code: status, body: body}} -> {:error, {:http_error, status, body}}
+      {:error, reason} -> {:error, {:network_error, reason}}
+    end
+  end
+
+  @doc """
+  Lists recent charges. Also reads from Application env.
+  """
+  @spec list_charges(keyword()) :: {:ok, [map()]} | {:error, term()}
+  def list_charges(opts \\ []) do
+    # Bad: same global config dependency repeated in every function
+    api_key = Application.get_env(:acme_billing, :api_key) ||
+      raise "Acme.Billing: :api_key not configured"
+
+    base_url = Application.get_env(:acme_billing, :base_url, "https://api.acmebilling.com")
+    timeout = Application.get_env(:acme_billing, :timeout_ms, 5_000)
+    retry = Application.get_env(:acme_billing, :retry_count, 3)
+
+    limit = Keyword.get(opts, :limit, 20)
+    url = "#{base_url}/charges?limit=#{limit}"
+    headers = [{"Authorization", "Bearer #{api_key}"}]
+
+    case HTTPoison.get(url, headers, timeout: timeout, recv_timeout: timeout) do
+      {:ok, %{status_code: 200, body: body}} -> {:ok, Jason.decode!(body)}
+      {:ok, %{status_code: status}} -> {:error, {:http_error, status}}
+      {:error, reason} when retry > 0 -> list_charges(opts)
+      {:error, reason} -> {:error, {:network_error, reason}}
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_library_global_application_config/good/billing.ex b/priv/combined_metrics/samples/code_smells/no_library_global_application_config/good/billing.ex
new file mode 100644
index 0000000..f656656
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_library_global_application_config/good/billing.ex
@@ -0,0 +1,53 @@
+defmodule Acme.Billing do
+  @moduledoc """
+  Billing library. All configuration is passed as explicit function
+  arguments rather than read from `Application.get_env/2`.
+  This makes the library usable in any application without side effects.
+  """
+
+  defmodule Config do
+    @moduledoc "Configuration struct for the Acme.Billing client."
+    @enforce_keys [:api_key, :base_url]
+    defstruct [:api_key, :base_url, timeout_ms: 5_000, retry_count: 3]
+
+    @type t :: %__MODULE__{
+      api_key: String.t(),
+      base_url: String.t(),
+      timeout_ms: pos_integer(),
+      retry_count: non_neg_integer()
+    }
+  end
+
+  @doc """
+  Creates a charge using the provided configuration.
+  Config is passed explicitly — the library does not read global app env.
+  """
+  @spec create_charge(Config.t(), map()) :: {:ok, map()} | {:error, term()}
+  def create_charge(%Config{} = config, params) do
+    url = "#{config.base_url}/charges"
+    headers = [{"Authorization", "Bearer #{config.api_key}"}]
+    options = [timeout: config.timeout_ms, recv_timeout: config.timeout_ms]
+
+    case HTTPoison.post(url, Jason.encode!(params), headers, options) do
+      {:ok, %{status_code: 201, body: body}} -> {:ok, Jason.decode!(body)}
+      {:ok, %{status_code: status, body: body}} -> {:error, {:http_error, status, body}}
+      {:error, reason} -> {:error, {:network_error, reason}}
+    end
+  end
+
+  @doc """
+  Lists recent charges. Configuration is explicit.
+  """
+  @spec list_charges(Config.t(), keyword()) :: {:ok, [map()]} | {:error, term()}
+  def list_charges(%Config{} = config, opts \\ []) do
+    limit = Keyword.get(opts, :limit, 20)
+    url = "#{config.base_url}/charges?limit=#{limit}"
+    headers = [{"Authorization", "Bearer #{config.api_key}"}]
+
+    case HTTPoison.get(url, headers, timeout: config.timeout_ms) do
+      {:ok, %{status_code: 200, body: body}} -> {:ok, Jason.decode!(body)}
+      {:ok, %{status_code: status}} -> {:error, {:http_error, status}}
+      {:error, reason} -> {:error, {:network_error, reason}}
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_list_comprehension_for_side_effects/bad/task_runner.py b/priv/combined_metrics/samples/code_smells/no_list_comprehension_for_side_effects/bad/task_runner.py
new file mode 100644
index 0000000..46f7234
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_list_comprehension_for_side_effects/bad/task_runner.py
@@ -0,0 +1,61 @@
+"""Task runner that executes a queue of background jobs and logs results."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Callable, Optional
+
+
+@dataclass
+class Task:
+    id: str
+    name: str
+    action: Callable[[], None]
+    retries: int = 0
+
+
+@dataclass
+class TaskResult:
+    task_id: str
+    success: bool
+    started_at: datetime
+    finished_at: datetime
+    error: Optional[str] = None
+
+
+_results: list[TaskResult] = []
+
+
+def run_task(task: Task) -> TaskResult:
+    started = datetime.utcnow()
+    try:
+        task.action()
+        return TaskResult(task_id=task.id, success=True, started_at=started, finished_at=datetime.utcnow())
+    except Exception as exc:
+        return TaskResult(task_id=task.id, success=False, started_at=started, finished_at=datetime.utcnow(), error=str(exc))
+
+
+def run_all(tasks: list[Task]) -> list[TaskResult]:
+    """Run all tasks — comprehension used only for its side effect; returned list discarded."""
+    results = []
+    # list comprehension purely for the side effect of appending to results
+    [results.append(run_task(task)) for task in tasks]  # bad: comprehension for side effects
+    return results
+
+
+def notify_failures(results: list[TaskResult]) -> None:
+    """Log failures — comprehension builds a list of Nones that is immediately discarded."""
+    [print(f"[ALERT] Task {r.task_id} failed: {r.error}") for r in results if not r.success]
+
+
+def archive_results(results: list[TaskResult]) -> None:
+    """Persist results — comprehension is used purely to call append on _results."""
+    [_results.append(result) for result in results]  # bad: side-effect-only comprehension
+
+
+def send_summary_emails(results: list[TaskResult], recipients: list[str]) -> None:
+    """Send emails — nested comprehension used entirely for its side effects."""
+    [
+        print(f"Sending summary to {email}: {len(results)} tasks run")
+        for email in recipients
+    ]  # bad: comprehension discarded, used only for print side effect
diff --git a/priv/combined_metrics/samples/code_smells/no_list_comprehension_for_side_effects/good/task_runner.py b/priv/combined_metrics/samples/code_smells/no_list_comprehension_for_side_effects/good/task_runner.py
new file mode 100644
index 0000000..eb472eb
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_list_comprehension_for_side_effects/good/task_runner.py
@@ -0,0 +1,76 @@
+"""Task runner that executes a queue of background jobs and logs results."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Callable, Optional
+
+
+@dataclass
+class Task:
+    id: str
+    name: str
+    action: Callable[[], None]
+    retries: int = 0
+
+
+@dataclass
+class TaskResult:
+    task_id: str
+    success: bool
+    started_at: datetime
+    finished_at: datetime
+    error: Optional[str] = None
+
+
+_results: list[TaskResult] = []
+
+
+def run_task(task: Task) -> TaskResult:
+    """Execute a single task and return its result."""
+    started = datetime.utcnow()
+    try:
+        task.action()
+        return TaskResult(
+            task_id=task.id,
+            success=True,
+            started_at=started,
+            finished_at=datetime.utcnow(),
+        )
+    except Exception as exc:
+        return TaskResult(
+            task_id=task.id,
+            success=False,
+            started_at=started,
+            finished_at=datetime.utcnow(),
+            error=str(exc),
+        )
+
+
+def run_all(tasks: list[Task]) -> list[TaskResult]:
+    """Run all tasks and collect results using a plain for loop."""
+    results = []
+    for task in tasks:
+        result = run_task(task)
+        results.append(result)
+    return results
+
+
+def notify_failures(results: list[TaskResult]) -> None:
+    """Log each failed result — side-effect loop, not a list comprehension."""
+    for result in results:
+        if not result.success:
+            print(f"[ALERT] Task {result.task_id} failed: {result.error}")
+
+
+def archive_results(results: list[TaskResult]) -> None:
+    """Persist results to the global store — explicit for loop makes intent clear."""
+    for result in results:
+        _results.append(result)
+
+
+def retry_failed(tasks: list[Task], results: list[TaskResult]) -> list[TaskResult]:
+    """Re-run tasks whose first attempt failed."""
+    failed_ids = {r.task_id for r in results if not r.success}
+    retry_tasks = [t for t in tasks if t.id in failed_ids]
+    return run_all(retry_tasks)
diff --git a/priv/combined_metrics/samples/code_smells/no_long_parameter_list/bad/accounts.ex b/priv/combined_metrics/samples/code_smells/no_long_parameter_list/bad/accounts.ex
new file mode 100644
index 0000000..b8bbc26
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_long_parameter_list/bad/accounts.ex
@@ -0,0 +1,62 @@
+defmodule MyApp.Accounts do
+  @moduledoc """
+  User account management.
+  """
+
+  alias MyApp.Accounts.User
+  alias MyApp.Repo
+
+  # Bad: eight positional parameters. Callers must remember the exact order.
+  # What is the difference between `role` and `plan`? Is `org_id` before or after?
+  # Easy to accidentally swap `team_id` and `org_id`.
+  @spec register(String.t(), String.t(), String.t(), atom(), atom(), integer(), integer(), DateTime.t()) ::
+          {:ok, User.t()} | {:error, Ecto.Changeset.t()}
+  def register(name, email, password, role, plan, org_id, team_id, trial_expires_at) do
+    %User{}
+    |> User.registration_changeset(%{
+      name: name,
+      email: email,
+      password: password,
+      role: role,
+      plan: plan,
+      organization_id: org_id,
+      team_id: team_id,
+      trial_expires_at: trial_expires_at
+    })
+    |> Repo.insert()
+  end
+
+  # Bad: sending an email with six individual string parameters
+  @spec send_welcome_email(String.t(), String.t(), String.t(), String.t(), String.t(), String.t()) :: :ok
+  def send_welcome_email(to_email, user_name, org_name, plan_name, support_email, login_url) do
+    MyApp.Mailer.deliver(%{
+      to: to_email,
+      subject: "Welcome, #{user_name}!",
+      template: :welcome,
+      assigns: %{
+        name: user_name,
+        org: org_name,
+        plan: plan_name,
+        support: support_email,
+        url: login_url
+      }
+    })
+
+    :ok
+  end
+
+  # Bad: updating a user with many individual named fields — no grouping
+  @spec update_profile(User.t(), String.t(), String.t(), String.t(), String.t(), boolean()) ::
+          {:ok, User.t()} | {:error, Ecto.Changeset.t()}
+  def update_profile(%User{} = user, name, bio, website, timezone, notifications_enabled) do
+    user
+    |> User.profile_changeset(%{
+      name: name,
+      bio: bio,
+      website: website,
+      timezone: timezone,
+      notifications_enabled: notifications_enabled
+    })
+    |> Repo.update()
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_long_parameter_list/good/accounts.ex b/priv/combined_metrics/samples/code_smells/no_long_parameter_list/good/accounts.ex
new file mode 100644
index 0000000..473fb53
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_long_parameter_list/good/accounts.ex
@@ -0,0 +1,66 @@
+defmodule MyApp.Accounts do
+  @moduledoc """
+  User account management. Related parameters are grouped into
+  structs rather than passed as long argument lists.
+  """
+
+  alias MyApp.Accounts.{User, UserRegistration}
+  alias MyApp.Repo
+
+  defmodule UserRegistration do
+    @moduledoc "Encapsulates all parameters needed to register a new user."
+    @enforce_keys [:email, :password, :name]
+    defstruct [
+      :email,
+      :password,
+      :name,
+      :organization_id,
+      :role,
+      :plan,
+      :invite_token,
+      timezone: "UTC"
+    ]
+  end
+
+  @doc """
+  Registers a new user. Parameters are grouped in a `UserRegistration` struct
+  rather than passed as individual arguments.
+  """
+  @spec register(UserRegistration.t()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
+  def register(%UserRegistration{} = registration) do
+    %User{}
+    |> User.registration_changeset(%{
+      email: registration.email,
+      password: registration.password,
+      name: registration.name,
+      organization_id: registration.organization_id,
+      role: registration.role || :member,
+      plan: registration.plan || :free,
+      timezone: registration.timezone
+    })
+    |> Repo.insert()
+  end
+
+  @doc """
+  Sends a welcome email. Takes the user struct rather than individual fields.
+  """
+  @spec send_welcome_email(User.t()) :: :ok | {:error, term()}
+  def send_welcome_email(%User{} = user) do
+    MyApp.Mailer.deliver(%{
+      to: user.email,
+      subject: "Welcome, #{user.name}!",
+      template: :welcome,
+      assigns: %{user: user}
+    })
+  end
+
+  @doc """
+  Updates a user's profile. Groups the changeable fields in a map.
+  """
+  @spec update_profile(User.t(), map()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
+  def update_profile(%User{} = user, attrs) when is_map(attrs) do
+    user
+    |> User.profile_changeset(attrs)
+    |> Repo.update()
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_magic_method_abuse/bad/OrderService.php b/priv/combined_metrics/samples/code_smells/no_magic_method_abuse/bad/OrderService.php
new file mode 100644
index 0000000..1186908
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_magic_method_abuse/bad/OrderService.php
@@ -0,0 +1,57 @@
+<?php
+
+namespace App\Service;
+
+class OrderService
+{
+    private array $data = [];
+    private array $repository;
+
+    public function __construct($repository)
+    {
+        $this->repository = $repository;
+    }
+
+    // __get is used to make all properties dynamically readable — obscures what actually exists
+    public function __get(string $name): mixed
+    {
+        if (array_key_exists($name, $this->data)) {
+            return $this->data[$name];
+        }
+
+        // Silently returns null for any unknown property
+        return null;
+    }
+
+    // __set makes all properties dynamically writable — no validation, no IDE support
+    public function __set(string $name, mixed $value): void
+    {
+        $this->data[$name] = $value;
+    }
+
+    // __call forwards any method call to the repository — callers can't know what's supported
+    public function __call(string $name, array $arguments): mixed
+    {
+        if (method_exists($this->repository, $name)) {
+            return $this->repository->$name(...$arguments);
+        }
+
+        // Falls through silently for unknown methods
+        return null;
+    }
+
+    // __isset makes isset() work on magic properties — further obfuscating the interface
+    public function __isset(string $name): bool
+    {
+        return isset($this->data[$name]);
+    }
+
+    // This is the only real method, but callers are expected to discover API via trial and error
+    public function place(int $customerId, array $items): array
+    {
+        $this->lastCustomer = $customerId;  // Triggers __set — invisible
+        $this->lastItems = $items;           // Triggers __set — invisible
+
+        return $this->repository->createOrder($customerId, $items);
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/no_magic_method_abuse/good/OrderService.php b/priv/combined_metrics/samples/code_smells/no_magic_method_abuse/good/OrderService.php
new file mode 100644
index 0000000..b328e2d
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_magic_method_abuse/good/OrderService.php
@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+use App\Entity\Order;
+use App\Exception\OrderNotFoundException;
+
+class OrderService
+{
+    private array $orders = [];
+
+    public function __construct(private OrderRepository $repository)
+    {
+    }
+
+    public function findById(int $id): ?Order
+    {
+        if (isset($this->orders[$id])) {
+            return $this->orders[$id];
+        }
+
+        $order = $this->repository->findById($id);
+        if ($order !== null) {
+            $this->orders[$id] = $order;
+        }
+
+        return $order;
+    }
+
+    public function getStatus(int $orderId): string
+    {
+        $order = $this->findById($orderId);
+        if ($order === null) {
+            throw new OrderNotFoundException("Order {$orderId} not found");
+        }
+
+        return $order->getStatus();
+    }
+
+    public function updateStatus(int $orderId, string $status): void
+    {
+        $order = $this->findById($orderId);
+        if ($order === null) {
+            throw new OrderNotFoundException("Order {$orderId} not found");
+        }
+
+        $order->setStatus($status);
+        $this->repository->save($order);
+        unset($this->orders[$orderId]);
+    }
+
+    public function listByCustomer(int $customerId): array
+    {
+        return $this->repository->findByCustomer($customerId);
+    }
+
+    public function countByStatus(string $status): int
+    {
+        return $this->repository->countByStatus($status);
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/no_namespace_trespassing/bad/catalog.ex b/priv/combined_metrics/samples/code_smells/no_namespace_trespassing/bad/catalog.ex
new file mode 100644
index 0000000..ab1c4fd
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_namespace_trespassing/bad/catalog.ex
@@ -0,0 +1,58 @@
+defmodule Acme.Catalog do
+  @moduledoc """
+  Public API for the Acme product catalog library.
+  """
+
+  alias Acme.Catalog.Product
+
+  @doc "Searches the catalog."
+  @spec search(String.t()) :: [Product.t()]
+  def search(query) do
+    Acme.Catalog.SearchIndex.query(query)
+  end
+end
+
+# Bad: defines a module inside Elixir's standard `Enum` namespace.
+# This will conflict with the standard library and confuse anyone reading the code.
+defmodule Enum.CatalogUtils do
+  @moduledoc """
+  Extra Enum utilities added by the Acme.Catalog library.
+  BAD: This module pollutes the `Enum` namespace which belongs to Elixir itself.
+  """
+
+  def filter_available(products) do
+    Enum.filter(products, & &1.available)
+  end
+
+  def sort_by_price(products) do
+    Enum.sort_by(products, & &1.price_cents)
+  end
+end
+
+# Bad: extends the `String` module with catalog-specific logic.
+# Any library calling `String.normalize/1` will be confused.
+defmodule String.Utils do
+  @moduledoc """
+  String helpers added by the Acme.Catalog library.
+  BAD: Trespasses on the `String` namespace owned by Elixir.
+  """
+
+  def normalize(str) when is_binary(str) do
+    str
+    |> String.trim()
+    |> String.downcase()
+    |> String.replace(~r/[^\w\s]/, "")
+  end
+end
+
+# Bad: opens a module under `Map` — a core Elixir namespace.
+defmodule Map.ProductHelpers do
+  @moduledoc """
+  Map utilities for products.
+  BAD: Pollutes the standard `Map` namespace.
+  """
+
+  def from_product(%{id: id, name: name, price_cents: price}) do
+    %{id: id, name: name, price_cents: price}
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_namespace_trespassing/good/catalog.ex b/priv/combined_metrics/samples/code_smells/no_namespace_trespassing/good/catalog.ex
new file mode 100644
index 0000000..333e3bf
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_namespace_trespassing/good/catalog.ex
@@ -0,0 +1,61 @@
+defmodule Acme.Catalog do
+  @moduledoc """
+  Public API for the Acme product catalog library.
+  All modules defined by this library live under the `Acme` namespace.
+  """
+
+  alias Acme.Catalog.{Product, Category, SearchIndex}
+
+  @doc """
+  Searches the catalog for products matching the query.
+  """
+  @spec search(String.t(), keyword()) :: [Product.t()]
+  def search(query, opts \\ []) do
+    SearchIndex.query(query, opts)
+  end
+
+  @doc """
+  Lists all products in a category.
+  """
+  @spec list_by_category(Category.t()) :: [Product.t()]
+  def list_by_category(%Category{} = category) do
+    Product.by_category(category)
+  end
+end
+
+defmodule Acme.Catalog.Product do
+  @moduledoc """
+  Product schema and query helpers. Stays within the `Acme.Catalog` namespace.
+  """
+
+  defstruct [:id, :name, :sku, :price_cents, :category_id]
+
+  @type t :: %__MODULE__{
+    id: integer(),
+    name: String.t(),
+    sku: String.t(),
+    price_cents: integer(),
+    category_id: integer()
+  }
+
+  def by_category(%Acme.Catalog.Category{id: id}) do
+    # query implementation
+    []
+  end
+end
+
+defmodule Acme.Catalog.StringHelpers do
+  @moduledoc """
+  String utilities specific to catalog use cases.
+  Kept under `Acme.Catalog` — not polluting the `String` namespace.
+  """
+
+  @doc "Normalizes a product name for indexing."
+  @spec normalize(String.t()) :: String.t()
+  def normalize(str) when is_binary(str) do
+    str
+    |> String.trim()
+    |> String.downcase()
+    |> String.replace(~r/[^\w\s]/, "")
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_nested_method_definition/bad/subscription.rb b/priv/combined_metrics/samples/code_smells/no_nested_method_definition/bad/subscription.rb
new file mode 100644
index 0000000..767b739
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_nested_method_definition/bad/subscription.rb
@@ -0,0 +1,39 @@
+class SubscriptionRenewalService
+  def initialize(billing, notifier, logger)
+    @billing = billing
+    @notifier = notifier
+    @logger = logger
+  end
+
+  def renew(subscription)
+    # Methods defined inside another method do NOT create closures in Ruby.
+    # They are defined on the enclosing class/object, not scoped locally.
+    def renewable?(sub)
+      sub.active? || sub.in_grace_period?
+    end
+
+    def attempt_charge(sub)
+      @billing.charge(
+        sub.payment_method_id,
+        sub.plan.monthly_price_cents
+      )
+    rescue Billing::DeclinedError => e
+      { success: false, error: :payment_declined }
+    end
+
+    def extend_subscription(sub)
+      new_expiry = [sub.expires_at, Time.current].max + 30.days
+      sub.update!(expires_at: new_expiry, status: :active)
+    end
+
+    return { success: false, skipped: true } unless renewable?(subscription)
+
+    charge_result = attempt_charge(subscription)
+    return charge_result unless charge_result[:success]
+
+    extend_subscription(subscription)
+    @notifier.send_renewal_confirmation(subscription.user, subscription)
+
+    { success: true, renewed_until: subscription.expires_at }
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_nested_method_definition/good/subscription.rb b/priv/combined_metrics/samples/code_smells/no_nested_method_definition/good/subscription.rb
new file mode 100644
index 0000000..f099fe4
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_nested_method_definition/good/subscription.rb
@@ -0,0 +1,48 @@
+class SubscriptionRenewalService
+  def initialize(billing, notifier, logger)
+    @billing = billing
+    @notifier = notifier
+    @logger = logger
+  end
+
+  def renew(subscription)
+    return skip_result(:not_renewable) unless renewable?(subscription)
+
+    charge_result = attempt_charge(subscription)
+    return charge_result unless charge_result[:success]
+
+    extend_subscription(subscription)
+    notify_renewal(subscription)
+
+    { success: true, renewed_until: subscription.expires_at }
+  end
+
+  private
+
+  def renewable?(subscription)
+    subscription.active? || subscription.in_grace_period?
+  end
+
+  def attempt_charge(subscription)
+    @billing.charge(
+      subscription.payment_method_id,
+      subscription.plan.monthly_price_cents
+    )
+  rescue Billing::DeclinedError => e
+    @logger.warn("Renewal charge declined for #{subscription.id}: #{e.message}")
+    { success: false, error: :payment_declined }
+  end
+
+  def extend_subscription(subscription)
+    new_expiry = [subscription.expires_at, Time.current].max + 30.days
+    subscription.update!(expires_at: new_expiry, status: :active)
+  end
+
+  def notify_renewal(subscription)
+    @notifier.send_renewal_confirmation(subscription.user, subscription)
+  end
+
+  def skip_result(reason)
+    { success: false, skipped: true, reason: reason }
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_nested_ternary/bad/pricing.ex b/priv/combined_metrics/samples/code_smells/no_nested_ternary/bad/pricing.ex
new file mode 100644
index 0000000..4828b43
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_nested_ternary/bad/pricing.ex
@@ -0,0 +1,105 @@
+defmodule Pricing do
+  @moduledoc "Calculates prices and discounts for products"
+
+  def final_price(product, user, coupon) do
+    base =
+      if product.on_sale do
+        if product.sale_price > 0 do
+          product.sale_price
+        else
+          product.price * 0.9
+        end
+      else
+        product.price
+      end
+
+    with_membership =
+      if user.member do
+        if user.tier == :gold do
+          if base > 100 do
+            base * 0.75
+          else
+            base * 0.85
+          end
+        else
+          base * 0.9
+        end
+      else
+        base
+      end
+
+    if coupon != nil do
+      if coupon.type == :percent do
+        if coupon.value > 50 do
+          with_membership * 0.5
+        else
+          with_membership * (1 - coupon.value / 100)
+        end
+      else
+        if with_membership - coupon.value > 0 do
+          with_membership - coupon.value
+        else
+          0
+        end
+      end
+    else
+      with_membership
+    end
+  end
+
+  def shipping_cost(order, user) do
+    if order.total > 50 do
+      if user.member do
+        0
+      else
+        if order.express do
+          9.99
+        else
+          4.99
+        end
+      end
+    else
+      if user.member do
+        if order.express do
+          5.99
+        else
+          2.99
+        end
+      else
+        if order.express do
+          14.99
+        else
+          7.99
+        end
+      end
+    end
+  end
+
+  def tax_rate(country, region, product_type) do
+    if country == "US" do
+      if region == "CA" do
+        if product_type == :food do
+          0.0
+        else
+          0.0725
+        end
+      else
+        if product_type == :food do
+          0.0
+        else
+          0.05
+        end
+      end
+    else
+      if country == "DE" do
+        if product_type == :food do
+          0.07
+        else
+          0.19
+        end
+      else
+        0.0
+      end
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_nested_ternary/config.yml b/priv/combined_metrics/samples/code_smells/no_nested_ternary/config.yml
new file mode 100644
index 0000000..a87321f
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_nested_ternary/config.yml
@@ -0,0 +1 @@
+doc: "Nested conditional expressions (ternary-within-ternary) are harder to read than a plain if-else."
diff --git a/priv/combined_metrics/samples/code_smells/no_nested_ternary/good/pricing.ex b/priv/combined_metrics/samples/code_smells/no_nested_ternary/good/pricing.ex
new file mode 100644
index 0000000..fbef9ef
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_nested_ternary/good/pricing.ex
@@ -0,0 +1,54 @@
+defmodule Pricing do
+  @moduledoc "Calculates prices and discounts for products"
+
+  def final_price(product, user, coupon) do
+    product
+    |> base_price()
+    |> apply_membership(user)
+    |> apply_coupon(coupon)
+  end
+
+  defp base_price(%{on_sale: true, sale_price: sale}) when sale > 0, do: sale
+  defp base_price(%{on_sale: true, price: price}), do: price * 0.9
+  defp base_price(%{price: price}), do: price
+
+  defp apply_membership(price, %{member: true, tier: :gold}) when price > 100, do: price * 0.75
+  defp apply_membership(price, %{member: true, tier: :gold}), do: price * 0.85
+  defp apply_membership(price, %{member: true}), do: price * 0.9
+  defp apply_membership(price, _user), do: price
+
+  defp apply_coupon(price, nil), do: price
+
+  defp apply_coupon(price, %{type: :percent, value: value}) when value > 50 do
+    price * 0.5
+  end
+
+  defp apply_coupon(price, %{type: :percent, value: value}) do
+    price * (1 - value / 100)
+  end
+
+  defp apply_coupon(price, %{type: :fixed, value: value}) do
+    max(price - value, 0)
+  end
+
+  def shipping_cost(order, user) do
+    shipping_rate(order.total, user.member, order.express)
+  end
+
+  defp shipping_rate(total, _member, _express) when total > 50, do: 0
+  defp shipping_rate(_total, true, true), do: 5.99
+  defp shipping_rate(_total, true, false), do: 2.99
+  defp shipping_rate(_total, false, true), do: 14.99
+  defp shipping_rate(_total, false, false), do: 7.99
+
+  def tax_rate(country, region, product_type) do
+    tax_for(country, region, product_type)
+  end
+
+  defp tax_for("US", _region, :food), do: 0.0
+  defp tax_for("US", "CA", _type), do: 0.0725
+  defp tax_for("US", _region, _type), do: 0.05
+  defp tax_for("DE", :food, _type), do: 0.07
+  defp tax_for("DE", _region, _type), do: 0.19
+  defp tax_for(_country, _region, _type), do: 0.0
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_primitive_wrapper_constructors/bad/form_validator.js b/priv/combined_metrics/samples/code_smells/no_primitive_wrapper_constructors/bad/form_validator.js
new file mode 100644
index 0000000..40efe98
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_primitive_wrapper_constructors/bad/form_validator.js
@@ -0,0 +1,68 @@
+function isNonEmptyString(value) {
+  const s = new String(value);
+  return s.trim().length > 0;
+}
+
+function isPositiveNumber(value) {
+  const n = new Number(value);
+  return isFinite(n) && n > 0;
+}
+
+function isTruthy(value) {
+  const b = new Boolean(value);
+  return b.valueOf();
+}
+
+function coerceToNumber(value) {
+  const n = new Number(value);
+  return isNaN(n) ? null : n.valueOf();
+}
+
+function coerceToString(value) {
+  if (value === null || value === undefined) return new String("");
+  return new String(value);
+}
+
+function validateField(name, value, rules) {
+  const errors = [];
+
+  for (const rule of rules) {
+    switch (rule.type) {
+      case "required":
+        const strVal = new String(value);
+        if (strVal.trim().length === 0) {
+          errors.push(new String(`${name} is required`).valueOf());
+        }
+        break;
+      case "minLength":
+        if (new String(value).length < new Number(rule.value)) {
+          errors.push(`${name} must be at least ${rule.value} characters`);
+        }
+        break;
+      case "numeric":
+        if (isNaN(new Number(value))) {
+          errors.push(`${name} must be a number`);
+        }
+        break;
+      case "positive":
+        if (!isPositiveNumber(value)) {
+          errors.push(`${name} must be a positive number`);
+        }
+        break;
+      default:
+        break;
+    }
+  }
+
+  return errors;
+}
+
+function validateForm(fields) {
+  return Object.entries(fields).reduce((errors, [name, { value, rules }]) => {
+    const fieldErrors = validateField(name, value, rules);
+    if (fieldErrors.length > new Number(0)) errors[name] = fieldErrors;
+    return errors;
+  }, {});
+}
+
+export { validateForm, validateField, isNonEmptyString, isPositiveNumber };
diff --git a/priv/combined_metrics/samples/code_smells/no_primitive_wrapper_constructors/good/form_validator.js b/priv/combined_metrics/samples/code_smells/no_primitive_wrapper_constructors/good/form_validator.js
new file mode 100644
index 0000000..0c1e42b
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_primitive_wrapper_constructors/good/form_validator.js
@@ -0,0 +1,64 @@
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+function isPositiveNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+
+function isTruthy(value) {
+  return Boolean(value);
+}
+
+function coerceToNumber(value) {
+  const n = Number(value);
+  return Number.isNaN(n) ? null : n;
+}
+
+function coerceToString(value) {
+  if (value === null || value === undefined) return "";
+  return String(value);
+}
+
+function validateField(name, value, rules) {
+  const errors = [];
+
+  for (const rule of rules) {
+    switch (rule.type) {
+      case "required":
+        if (!isNonEmptyString(coerceToString(value))) {
+          errors.push(`${name} is required`);
+        }
+        break;
+      case "minLength":
+        if (typeof value === "string" && value.length < rule.value) {
+          errors.push(`${name} must be at least ${rule.value} characters`);
+        }
+        break;
+      case "numeric":
+        if (coerceToNumber(value) === null) {
+          errors.push(`${name} must be a number`);
+        }
+        break;
+      case "positive":
+        if (!isPositiveNumber(coerceToNumber(value))) {
+          errors.push(`${name} must be a positive number`);
+        }
+        break;
+      default:
+        break;
+    }
+  }
+
+  return errors;
+}
+
+function validateForm(fields) {
+  return Object.entries(fields).reduce((errors, [name, { value, rules }]) => {
+    const fieldErrors = validateField(name, value, rules);
+    if (fieldErrors.length > 0) errors[name] = fieldErrors;
+    return errors;
+  }, {});
+}
+
+export { validateForm, validateField, isNonEmptyString, isPositiveNumber, coerceToNumber, coerceToString };
diff --git a/priv/combined_metrics/samples/code_smells/no_private_inheritance/bad/Connection.cpp b/priv/combined_metrics/samples/code_smells/no_private_inheritance/bad/Connection.cpp
new file mode 100644
index 0000000..b6a5f52
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_private_inheritance/bad/Connection.cpp
@@ -0,0 +1,75 @@
+#include <string>
+#include <chrono>
+#include <stdexcept>
+
+class TcpSocket {
+public:
+    explicit TcpSocket(const std::string& host, int port)
+        : host_(host), port_(port), connected_(false) {}
+
+    void connect() { connected_ = true; }
+    void disconnect() noexcept { connected_ = false; }
+    bool isConnected() const noexcept { return connected_; }
+    void send(const std::string& data) { (void)data; }
+    std::string receive(std::size_t maxBytes) { (void)maxBytes; return {}; }
+
+protected:
+    std::string host_;
+    int port_;
+    bool connected_;
+};
+
+class RetryPolicy {
+public:
+    explicit RetryPolicy(int maxAttempts, std::chrono::milliseconds delay)
+        : maxAttempts_(maxAttempts), delay_(delay) {}
+
+    bool shouldRetry(int attempt) const noexcept { return attempt < maxAttempts_; }
+    std::chrono::milliseconds delay() const noexcept { return delay_; }
+
+protected:
+    int maxAttempts_;
+    std::chrono::milliseconds delay_;
+};
+
+// Private inheritance used for implementation reuse — anti-pattern.
+// Connection IS-NOT-A TcpSocket; it has confusing base-class subobjects
+// and makes it hard to switch the socket implementation later.
+class Connection
+    : private TcpSocket        // private inheritance for reuse — should be composition
+    , private RetryPolicy      // same problem
+{
+public:
+    Connection(const std::string& host, int port, int maxRetries)
+        : TcpSocket(host, port)
+        , RetryPolicy(maxRetries, std::chrono::milliseconds(500))
+    {}
+
+    void open() {
+        for (int attempt = 0; ; ++attempt) {
+            try {
+                TcpSocket::connect(); // must call base explicitly — tightly coupled
+                return;
+            } catch (const std::exception&) {
+                if (!RetryPolicy::shouldRetry(attempt))
+                    throw;
+            }
+        }
+    }
+
+    void close() noexcept { TcpSocket::disconnect(); }
+    bool isOpen() const noexcept { return TcpSocket::isConnected(); }
+
+    void send(const std::string& data) {
+        if (!isOpen()) throw std::runtime_error("Connection is closed");
+        TcpSocket::send(data); // using base class members directly
+    }
+
+    std::string receive(std::size_t maxBytes) {
+        if (!isOpen()) throw std::runtime_error("Connection is closed");
+        return TcpSocket::receive(maxBytes);
+    }
+
+    // Accesses inherited protected member directly — tight coupling
+    std::string connectedHost() const { return host_; }
+};
diff --git a/priv/combined_metrics/samples/code_smells/no_private_inheritance/good/Connection.cpp b/priv/combined_metrics/samples/code_smells/no_private_inheritance/good/Connection.cpp
new file mode 100644
index 0000000..c4b7060
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_private_inheritance/good/Connection.cpp
@@ -0,0 +1,75 @@
+#include <memory>
+#include <string>
+#include <chrono>
+#include <stdexcept>
+
+// Reuse via composition, not private inheritance
+
+class TcpSocket {
+public:
+    explicit TcpSocket(const std::string& host, int port)
+        : host_(host), port_(port), connected_(false) {}
+
+    void connect() { connected_ = true; }
+    void disconnect() noexcept { connected_ = false; }
+    bool isConnected() const noexcept { return connected_; }
+    void send(const std::string& data) { (void)data; }
+    std::string receive(std::size_t maxBytes) { (void)maxBytes; return {}; }
+
+private:
+    std::string host_;
+    int port_;
+    bool connected_;
+};
+
+class RetryPolicy {
+public:
+    explicit RetryPolicy(int maxAttempts, std::chrono::milliseconds delay)
+        : maxAttempts_(maxAttempts), delay_(delay) {}
+
+    bool shouldRetry(int attempt) const noexcept { return attempt < maxAttempts_; }
+    std::chrono::milliseconds delay() const noexcept { return delay_; }
+
+private:
+    int maxAttempts_;
+    std::chrono::milliseconds delay_;
+};
+
+// Composition: Connection HAS-A TcpSocket and HAS-A RetryPolicy
+// Not IS-A; private inheritance would expose implementation details
+class Connection {
+public:
+    Connection(const std::string& host, int port, int maxRetries)
+        : socket_(std::make_unique<TcpSocket>(host, port))
+        , retryPolicy_(maxRetries, std::chrono::milliseconds(500))
+    {}
+
+    void open() {
+        for (int attempt = 0; ; ++attempt) {
+            try {
+                socket_->connect();
+                return;
+            } catch (const std::exception&) {
+                if (!retryPolicy_.shouldRetry(attempt))
+                    throw;
+            }
+        }
+    }
+
+    void close() noexcept { socket_->disconnect(); }
+    bool isOpen() const noexcept { return socket_->isConnected(); }
+
+    void send(const std::string& data) {
+        if (!isOpen()) throw std::runtime_error("Connection is closed");
+        socket_->send(data);
+    }
+
+    std::string receive(std::size_t maxBytes) {
+        if (!isOpen()) throw std::runtime_error("Connection is closed");
+        return socket_->receive(maxBytes);
+    }
+
+private:
+    std::unique_ptr<TcpSocket> socket_;   // composed, not inherited
+    RetryPolicy retryPolicy_;              // composed, not inherited
+};
diff --git a/priv/combined_metrics/samples/code_smells/no_problematic_operator_overloads/bad/Widget.cpp b/priv/combined_metrics/samples/code_smells/no_problematic_operator_overloads/bad/Widget.cpp
new file mode 100644
index 0000000..62209d6
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_problematic_operator_overloads/bad/Widget.cpp
@@ -0,0 +1,58 @@
+#include <memory>
+#include <string>
+#include <vector>
+
+class Widget {
+public:
+    Widget(int id, std::string label, bool visible)
+        : id_(id), label_(std::move(label)), visible_(visible), valid_(true) {}
+
+    // Overloading && — breaks short-circuit evaluation; both operands always evaluated
+    bool operator&&(const Widget& rhs) const {
+        return valid_ && rhs.valid_;
+    }
+
+    // Overloading || — same problem: no short-circuit, confusing semantics
+    bool operator||(const Widget& rhs) const {
+        return visible_ || rhs.visible_;
+    }
+
+    // Overloading comma operator — evaluated left-to-right but breaks comma in function
+    // arguments and for-loop expressions in surprising ways
+    Widget& operator,(const Widget& rhs) {
+        (void)rhs;
+        return *this;
+    }
+
+    // Overloading unary & — takes the address of Widget, not its actual address
+    // Breaks generic code that uses &widget to get a pointer
+    Widget* operator&() {
+        return nullptr; // returns something other than the real address — very surprising
+    }
+
+    int id() const { return id_; }
+    const std::string& label() const { return label_; }
+    bool isVisible() const { return visible_; }
+
+private:
+    int id_;
+    std::string label_;
+    bool visible_;
+    bool valid_;
+};
+
+void processWidget(Widget* ptr);
+
+void demonstrate() {
+    Widget a(1, "Alpha", true);
+    Widget b(2, "Beta", false);
+
+    // Looks like short-circuit but isn't — b.valid_ is ALWAYS evaluated
+    if (a && b) { /* ... */ }
+
+    // Comma operator overloaded — (a, b) returns a, not b as expected
+    Widget& result = (a, b);
+
+    // &a calls overloaded operator& — does NOT return the real address of a
+    processWidget(&a); // silently passes nullptr
+}
diff --git a/priv/combined_metrics/samples/code_smells/no_problematic_operator_overloads/good/Widget.cpp b/priv/combined_metrics/samples/code_smells/no_problematic_operator_overloads/good/Widget.cpp
new file mode 100644
index 0000000..8998506
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_problematic_operator_overloads/good/Widget.cpp
@@ -0,0 +1,72 @@
+#include <memory>
+#include <string>
+#include <vector>
+
+// Overloads only operators with predictable, well-defined semantics.
+// Does NOT overload &&, ||, comma, or unary &.
+
+class WidgetId {
+public:
+    explicit WidgetId(int value) : value_(value) {}
+
+    bool operator==(const WidgetId& rhs) const noexcept { return value_ == rhs.value_; }
+    bool operator!=(const WidgetId& rhs) const noexcept { return !(*this == rhs); }
+    bool operator<(const WidgetId& rhs) const noexcept { return value_ < rhs.value_; }
+
+    int value() const noexcept { return value_; }
+
+private:
+    int value_;
+};
+
+class Widget {
+public:
+    Widget(WidgetId id, std::string label, int priority)
+        : id_(id), label_(std::move(label)), priority_(priority) {}
+
+    // Comparison by priority — clear semantic
+    bool operator<(const Widget& rhs) const noexcept { return priority_ < rhs.priority_; }
+    bool operator==(const Widget& rhs) const noexcept { return id_ == rhs.id_; }
+
+    // Arithmetic with clear meaning: combine widget priority scores
+    Widget operator+(int extraPriority) const {
+        return Widget(id_, label_, priority_ + extraPriority);
+    }
+
+    WidgetId id() const noexcept { return id_; }
+    const std::string& label() const noexcept { return label_; }
+    int priority() const noexcept { return priority_; }
+
+    // Logical conditions are free functions using && and || naturally —
+    // no overloaded && or || to break short-circuit evaluation
+    static bool isHighPriority(const Widget& w) { return w.priority_ > 100; }
+    static bool isVisible(const Widget& w) { return !w.label_.empty(); }
+
+private:
+    WidgetId id_;
+    std::string label_;
+    int priority_;
+};
+
+class WidgetCollection {
+public:
+    void add(Widget w) { items_.push_back(std::move(w)); }
+
+    // operator[] with clear semantics
+    Widget& operator[](std::size_t index) { return items_[index]; }
+    const Widget& operator[](std::size_t index) const { return items_[index]; }
+
+    std::size_t size() const noexcept { return items_.size(); }
+    bool empty() const noexcept { return items_.empty(); }
+
+    // Natural use of && and || without overloading:
+    bool hasHighPriorityVisible() const {
+        for (const auto& w : items_)
+            if (Widget::isHighPriority(w) && Widget::isVisible(w))
+                return true;
+        return false;
+    }
+
+private:
+    std::vector<Widget> items_;
+};
diff --git a/priv/combined_metrics/samples/code_smells/no_process_for_code_organization/bad/inventory.ex b/priv/combined_metrics/samples/code_smells/no_process_for_code_organization/bad/inventory.ex
new file mode 100644
index 0000000..86da060
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_process_for_code_organization/bad/inventory.ex
@@ -0,0 +1,71 @@
+defmodule MyApp.Inventory do
+  @moduledoc """
+  Inventory calculations. Unnecessarily uses a GenServer to hold a map
+  that could simply be passed as function arguments. The GenServer adds
+  overhead and serializes all access with no benefit.
+  """
+
+  use GenServer
+
+  # Bad: using a GenServer purely to hold a map that needs no
+  # concurrency protection or long-lived state.
+  def start_link(products) do
+    GenServer.start_link(__MODULE__, products, name: __MODULE__)
+  end
+
+  @impl true
+  def init(products) do
+    {:ok, Map.new(products, &{&1.id, &1})}
+  end
+
+  # Bad: simple computation wrapped in a GenServer.call — all callers
+  # are serialized through a single process for no reason.
+  @spec sufficient_stock?(integer(), pos_integer()) :: boolean()
+  def sufficient_stock?(product_id, quantity) do
+    GenServer.call(__MODULE__, {:sufficient_stock, product_id, quantity})
+  end
+
+  @spec compute_reservation([{integer(), pos_integer()}]) :: map()
+  def compute_reservation(items) do
+    GenServer.call(__MODULE__, {:compute_reservation, items})
+  end
+
+  @spec reorder_point(integer()) :: integer()
+  def reorder_point(product_id) do
+    GenServer.call(__MODULE__, {:reorder_point, product_id})
+  end
+
+  @impl true
+  def handle_call({:sufficient_stock, product_id, quantity}, _from, products) do
+    result =
+      case Map.get(products, product_id) do
+        nil -> false
+        product -> product.stock >= quantity
+      end
+    {:reply, result, products}
+  end
+
+  @impl true
+  def handle_call({:compute_reservation, items}, _from, products) do
+    result =
+      Enum.reduce(items, %{available: [], unavailable: []}, fn {id, qty}, acc ->
+        product = Map.get(products, id)
+        if product && product.stock >= qty do
+          Map.update!(acc, :available, &[{id, qty} | &1])
+        else
+          Map.update!(acc, :unavailable, &[{id, qty} | &1])
+        end
+      end)
+    {:reply, result, products}
+  end
+
+  @impl true
+  def handle_call({:reorder_point, product_id}, _from, products) do
+    result =
+      case Map.get(products, product_id) do
+        nil -> 0
+        product -> ceil(product.daily_usage * product.lead_time_days * 1.2)
+      end
+    {:reply, result, products}
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_process_for_code_organization/good/inventory.ex b/priv/combined_metrics/samples/code_smells/no_process_for_code_organization/good/inventory.ex
new file mode 100644
index 0000000..0f79e0d
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_process_for_code_organization/good/inventory.ex
@@ -0,0 +1,58 @@
+defmodule MyApp.Inventory do
+  @moduledoc """
+  Inventory calculations. Pure module with stateless functions —
+  no GenServer or Agent needed because there is no mutable state
+  or concurrency concern. The "state" is just data passed around.
+  """
+
+  alias MyApp.Inventory.{Product, StockLevel}
+
+  @doc """
+  Checks whether a product has enough stock for the requested quantity.
+  Pure function — no process needed.
+  """
+  @spec sufficient_stock?(Product.t(), pos_integer()) :: boolean()
+  def sufficient_stock?(%Product{stock: stock}, quantity), do: stock >= quantity
+
+  @doc """
+  Computes a reservation summary for a list of items.
+  Pure transformation — no process needed.
+  """
+  @spec compute_reservation([{Product.t(), pos_integer()}]) :: map()
+  def compute_reservation(items) when is_list(items) do
+    items
+    |> Enum.reduce(%{available: [], unavailable: []}, fn {product, qty}, acc ->
+      if sufficient_stock?(product, qty) do
+        Map.update!(acc, :available, &[{product.id, qty} | &1])
+      else
+        Map.update!(acc, :unavailable, &[{product.id, qty} | &1])
+      end
+    end)
+  end
+
+  @doc """
+  Calculates the reorder point for a product based on lead time and daily usage.
+  Pure computation — no process involved.
+  """
+  @spec reorder_point(float(), pos_integer()) :: integer()
+  def reorder_point(daily_usage, lead_time_days) when daily_usage >= 0 do
+    ceil(daily_usage * lead_time_days * 1.2)
+  end
+
+  @doc """
+  Groups stock levels by warehouse.
+  Pure data transformation.
+  """
+  @spec group_by_warehouse([StockLevel.t()]) :: map()
+  def group_by_warehouse(levels) when is_list(levels) do
+    Enum.group_by(levels, & &1.warehouse_id)
+  end
+
+  @doc """
+  Merges two stock level maps, summing quantities for shared keys.
+  """
+  @spec merge_stock(map(), map()) :: map()
+  def merge_stock(stock_a, stock_b) do
+    Map.merge(stock_a, stock_b, fn _warehouse, qty_a, qty_b -> qty_a + qty_b end)
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/no_prototype_modification/bad/data_store.js b/priv/combined_metrics/samples/code_smells/no_prototype_modification/bad/data_store.js
new file mode 100644
index 0000000..0773eec
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_prototype_modification/bad/data_store.js
@@ -0,0 +1,63 @@
+Array.prototype.groupBy = function (keyFn) {
+  return this.reduce((groups, item) => {
+    const key = keyFn(item);
+    if (!groups[key]) groups[key] = [];
+    groups[key].push(item);
+    return groups;
+  }, {});
+};
+
+Array.prototype.unique = function (keyFn = (x) => x) {
+  const seen = new Set();
+  return this.filter((item) => {
+    const key = keyFn(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+};
+
+Array.prototype.sortedBy = function (keyFn, direction = "asc") {
+  const multiplier = direction === "asc" ? 1 : -1;
+  return [...this].sort((a, b) => {
+    const ak = keyFn(a);
+    const bk = keyFn(b);
+    return ak < bk ? -multiplier : ak > bk ? multiplier : 0;
+  });
+};
+
+Object.prototype.deepClone = function () {
+  return JSON.parse(JSON.stringify(this));
+};
+
+String.prototype.toTitleCase = function () {
+  return this.replace(/\b\w/g, (c) => c.toUpperCase());
+};
+
+class DataStore {
+  constructor(records = []) {
+    this._records = [...records];
+  }
+
+  add(record) {
+    this._records.push(record);
+  }
+
+  findBy(predicate) {
+    return this._records.filter(predicate);
+  }
+
+  groupBy(keyFn) {
+    return this._records.groupBy(keyFn);
+  }
+
+  sortedBy(keyFn, direction) {
+    return this._records.sortedBy(keyFn, direction);
+  }
+
+  get size() {
+    return this._records.length;
+  }
+}
+
+export { DataStore };
diff --git a/priv/combined_metrics/samples/code_smells/no_prototype_modification/good/data_store.js b/priv/combined_metrics/samples/code_smells/no_prototype_modification/good/data_store.js
new file mode 100644
index 0000000..60cab9d
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_prototype_modification/good/data_store.js
@@ -0,0 +1,67 @@
+function groupBy(array, keyFn) {
+  return array.reduce((groups, item) => {
+    const key = keyFn(item);
+    if (!Object.prototype.hasOwnProperty.call(groups, key)) {
+      groups[key] = [];
+    }
+    groups[key].push(item);
+    return groups;
+  }, {});
+}
+
+function unique(array, keyFn = (x) => x) {
+  const seen = new Set();
+  return array.filter((item) => {
+    const key = keyFn(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function sortedBy(array, keyFn, direction = "asc") {
+  const multiplier = direction === "asc" ? 1 : -1;
+  return [...array].sort((a, b) => {
+    const ak = keyFn(a);
+    const bk = keyFn(b);
+    return ak < bk ? -multiplier : ak > bk ? multiplier : 0;
+  });
+}
+
+class DataStore {
+  constructor(records = []) {
+    this._records = [...records];
+    this._indexes = new Map();
+  }
+
+  add(record) {
+    this._records.push(record);
+    this._invalidateIndexes();
+  }
+
+  findBy(predicate) {
+    return this._records.filter(predicate);
+  }
+
+  groupBy(keyFn) {
+    return groupBy(this._records, keyFn);
+  }
+
+  sortedBy(keyFn, direction) {
+    return sortedBy(this._records, keyFn, direction);
+  }
+
+  unique(keyFn) {
+    return unique(this._records, keyFn);
+  }
+
+  _invalidateIndexes() {
+    this._indexes.clear();
+  }
+
+  get size() {
+    return this._records.length;
+  }
+}
+
+export { DataStore, groupBy, unique, sortedBy };
diff --git a/priv/combined_metrics/samples/code_smells/no_raw_sql_string_concatenation/bad/UserRepository.php b/priv/combined_metrics/samples/code_smells/no_raw_sql_string_concatenation/bad/UserRepository.php
new file mode 100644
index 0000000..5fb56b0
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_raw_sql_string_concatenation/bad/UserRepository.php
@@ -0,0 +1,58 @@
+<?php
+
+namespace App\Repository;
+
+use PDO;
+
+class UserRepository
+{
+    public function __construct(private PDO $connection)
+    {
+    }
+
+    public function search($query, $role, $limit): array
+    {
+        // SQL injection vulnerability: user input concatenated directly into query
+        $sql = "SELECT * FROM users
+                WHERE (name LIKE '%" . $query . "%' OR email LIKE '%" . $query . "%')
+                AND role = '" . $role . "'
+                AND deleted_at IS NULL
+                ORDER BY created_at DESC
+                LIMIT " . $limit;
+
+        $stmt = $this->connection->query($sql);
+
+        return $stmt->fetchAll(PDO::FETCH_ASSOC);
+    }
+
+    public function findByIds($ids): array
+    {
+        if (empty($ids)) {
+            return [];
+        }
+
+        // Unsafe: builds IN clause by joining raw input
+        $idList = implode(',', $ids);
+        $sql = "SELECT * FROM users WHERE id IN ($idList) AND deleted_at IS NULL";
+
+        return $this->connection->query($sql)->fetchAll(PDO::FETCH_ASSOC);
+    }
+
+    public function updateLastLogin($userId, $ip): void
+    {
+        // Direct interpolation of $ip — attacker-controlled value in SQL
+        $sql = "UPDATE users SET last_login_at = NOW(), last_login_ip = '" . $ip . "' WHERE id = " . $userId;
+        $this->connection->exec($sql);
+    }
+
+    public function findByUsername($username): ?array
+    {
+        // Classic SQL injection pattern
+        $result = $this->connection->query(
+            "SELECT * FROM users WHERE username = '" . $username . "'"
+        );
+
+        $row = $result->fetch(PDO::FETCH_ASSOC);
+        return $row ?: null;
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/no_raw_sql_string_concatenation/good/UserRepository.php b/priv/combined_metrics/samples/code_smells/no_raw_sql_string_concatenation/good/UserRepository.php
new file mode 100644
index 0000000..1d815a4
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_raw_sql_string_concatenation/good/UserRepository.php
@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Repository;
+
+use App\Entity\User;
+use PDO;
+
+class UserRepository
+{
+    public function __construct(private PDO $connection)
+    {
+    }
+
+    public function search(string $query, string $role, int $limit): array
+    {
+        // Parameterized query — no user input interpolated into SQL
+        $stmt = $this->connection->prepare(
+            'SELECT * FROM users
+             WHERE (name LIKE :query OR email LIKE :query)
+               AND role = :role
+               AND deleted_at IS NULL
+             ORDER BY created_at DESC
+             LIMIT :limit'
+        );
+
+        $stmt->bindValue(':query', "%{$query}%", PDO::PARAM_STR);
+        $stmt->bindValue(':role', $role, PDO::PARAM_STR);
+        $stmt->bindValue(':limit', $limit, PDO::PARAM_INT);
+        $stmt->execute();
+
+        return array_map([$this, 'hydrate'], $stmt->fetchAll(PDO::FETCH_ASSOC));
+    }
+
+    public function findByIds(array $ids): array
+    {
+        if (empty($ids)) {
+            return [];
+        }
+
+        // Safe handling of IN clause with bound parameters
+        $placeholders = implode(',', array_fill(0, count($ids), '?'));
+        $stmt = $this->connection->prepare(
+            "SELECT * FROM users WHERE id IN ({$placeholders}) AND deleted_at IS NULL"
+        );
+        $stmt->execute(array_values($ids));
+
+        return array_map([$this, 'hydrate'], $stmt->fetchAll(PDO::FETCH_ASSOC));
+    }
+
+    public function updateLastLogin(int $userId, string $ip): void
+    {
+        $stmt = $this->connection->prepare(
+            'UPDATE users SET last_login_at = NOW(), last_login_ip = :ip WHERE id = :id'
+        );
+        $stmt->execute(['ip' => $ip, 'id' => $userId]);
+    }
+
+    private function hydrate(array $row): User
+    {
+        return new User(
+            id: (int) $row['id'],
+            email: $row['email'],
+            name: $row['name'],
+            role: $row['role']
+        );
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/no_runblocking_in_coroutines/bad/FileImportService.kt b/priv/combined_metrics/samples/code_smells/no_runblocking_in_coroutines/bad/FileImportService.kt
new file mode 100644
index 0000000..a598525
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_runblocking_in_coroutines/bad/FileImportService.kt
@@ -0,0 +1,54 @@
+package com.example.imports
+
+import kotlinx.coroutines.*
+import java.io.File
+
+data class ImportResult(val rowsImported: Int, val errors: List<String>)
+
+class FileImportService(
+    private val parser: CsvParser,
+    private val repository: ProductRepository
+) {
+
+    /**
+     * importFile is a suspend function — it is called from within a coroutine.
+     * Using runBlocking here blocks the thread that the coroutine was running on,
+     * which can cause deadlocks on single-threaded dispatchers and defeats the
+     * purpose of structured concurrency.
+     */
+    suspend fun importFile(filePath: String): ImportResult {
+        val lines = File(filePath).readLines()
+        val errors = mutableListOf<String>()
+        var count = 0
+
+        val batches = lines.drop(1).chunked(500)
+
+        // runBlocking inside a suspend function — blocks the coroutine's thread
+        count = runBlocking {
+            val jobs = batches.mapIndexed { index, batch ->
+                async(Dispatchers.IO) {
+                    processBatch(batch, index, errors)
+                }
+            }
+            jobs.sumOf { it.await() }
+        }
+
+        return ImportResult(count, errors)
+    }
+
+    suspend fun validateAndImport(filePath: String): ImportResult {
+        // runBlocking used to call another suspend function from within a suspend function
+        val exists = runBlocking { checkFileExists(filePath) }
+        if (!exists) return ImportResult(0, listOf("File not found: $filePath"))
+        return importFile(filePath)
+    }
+
+    private suspend fun checkFileExists(path: String): Boolean {
+        return withContext(Dispatchers.IO) { File(path).exists() }
+    }
+
+    private suspend fun processBatch(lines: List<String>, batchIndex: Int, errors: MutableList<String>): Int {
+        val products = parser.parseLines(lines, batchIndex)
+        return repository.upsertAll(products)
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/no_runblocking_in_coroutines/good/FileImportService.kt b/priv/combined_metrics/samples/code_smells/no_runblocking_in_coroutines/good/FileImportService.kt
new file mode 100644
index 0000000..4c09849
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_runblocking_in_coroutines/good/FileImportService.kt
@@ -0,0 +1,51 @@
+package com.example.imports
+
+import kotlinx.coroutines.*
+import java.io.File
+
+data class ImportResult(val rowsImported: Int, val errors: List<String>)
+
+class FileImportService(
+    private val parser: CsvParser,
+    private val repository: ProductRepository
+) {
+
+    /**
+     * Top-level entry point — runBlocking here is acceptable because this is
+     * the boundary between the non-coroutine world (e.g. a CLI main function)
+     * and the coroutine world. It is NOT inside an existing coroutine.
+     */
+    fun importFromCli(filePath: String): ImportResult = runBlocking {
+        importFile(filePath)
+    }
+
+    /**
+     * The actual work is a proper suspend function.
+     * Any coroutine-aware caller (HTTP handler, scheduled job) calls this directly
+     * without incurring the overhead or blocking of runBlocking.
+     */
+    suspend fun importFile(filePath: String): ImportResult = coroutineScope {
+        val lines = File(filePath).readLines()
+        val errors = mutableListOf<String>()
+        var count = 0
+
+        val batches = lines.drop(1).chunked(500)
+        val jobs = batches.mapIndexed { index, batch ->
+            async(Dispatchers.IO) {
+                processBatch(batch, index, errors)
+            }
+        }
+
+        count = jobs.sumOf { it.await() }
+        ImportResult(count, errors)
+    }
+
+    private suspend fun processBatch(
+        lines: List<String>,
+        batchIndex: Int,
+        errors: MutableList<String>
+    ): Int {
+        val products = parser.parseLines(lines, batchIndex)
+        return repository.upsertAll(products)
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/no_side_effects_in_declaration_file/bad/UserRepository.php b/priv/combined_metrics/samples/code_smells/no_side_effects_in_declaration_file/bad/UserRepository.php
new file mode 100644
index 0000000..b8d851d
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_side_effects_in_declaration_file/bad/UserRepository.php
@@ -0,0 +1,55 @@
+<?php
+
+namespace App\Repository;
+
+use PDO;
+
+// Side effect: echoing output at include time (PSR-1 violation)
+echo "Loading UserRepository...\n";
+
+// Side effect: modifying global state at include time
+ini_set('display_errors', '1');
+error_reporting(E_ALL);
+
+// Side effect: connecting to a database at include time
+$pdo = new PDO('mysql:host=localhost;dbname=app', 'root', '');
+$GLOBALS['db'] = $pdo;
+
+// Side effect: defining a global function at include time
+function get_user($id) {
+    return $GLOBALS['db']->query("SELECT * FROM users WHERE id = $id")->fetch();
+}
+
+class UserRepository
+{
+    private PDO $connection;
+
+    public function __construct(PDO $connection)
+    {
+        $this->connection = $connection;
+
+        // Side effect: running a query in the constructor (at class use time)
+        $this->connection->exec("SET NAMES utf8mb4");
+    }
+
+    public function findById(int $id): ?array
+    {
+        $stmt = $this->connection->prepare('SELECT * FROM users WHERE id = :id');
+        $stmt->execute(['id' => $id]);
+        return $stmt->fetch(PDO::FETCH_ASSOC) ?: null;
+    }
+
+    public function findByEmail(string $email): ?array
+    {
+        $stmt = $this->connection->prepare('SELECT * FROM users WHERE email = :email');
+        $stmt->execute(['email' => strtolower($email)]);
+        return $stmt->fetch(PDO::FETCH_ASSOC) ?: null;
+    }
+}
+
+// Side effect: running code at include time — creates a user unconditionally
+$repo = new UserRepository($GLOBALS['db']);
+$adminUser = $repo->findByEmail('admin@example.com');
+if (!$adminUser) {
+    echo "Warning: no admin user found\n";
+}
diff --git a/priv/combined_metrics/samples/code_smells/no_side_effects_in_declaration_file/good/UserRepository.php b/priv/combined_metrics/samples/code_smells/no_side_effects_in_declaration_file/good/UserRepository.php
new file mode 100644
index 0000000..228a432
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_side_effects_in_declaration_file/good/UserRepository.php
@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Repository;
+
+use App\Entity\User;
+use App\Exception\UserNotFoundException;
+use PDO;
+
+/**
+ * Declares a class only. No side effects when this file is included.
+ */
+class UserRepository
+{
+    public function __construct(private PDO $connection)
+    {
+    }
+
+    public function findById(int $id): ?User
+    {
+        $stmt = $this->connection->prepare(
+            'SELECT * FROM users WHERE id = :id'
+        );
+        $stmt->execute(['id' => $id]);
+        $row = $stmt->fetch(PDO::FETCH_ASSOC);
+
+        return $row ? $this->hydrate($row) : null;
+    }
+
+    public function findByEmail(string $email): ?User
+    {
+        $stmt = $this->connection->prepare(
+            'SELECT * FROM users WHERE email = :email'
+        );
+        $stmt->execute(['email' => mb_strtolower($email)]);
+        $row = $stmt->fetch(PDO::FETCH_ASSOC);
+
+        return $row ? $this->hydrate($row) : null;
+    }
+
+    public function save(User $user): void
+    {
+        if ($user->getId() === null) {
+            $this->insert($user);
+        } else {
+            $this->update($user);
+        }
+    }
+
+    private function hydrate(array $row): User
+    {
+        return new User(
+            id: (int) $row['id'],
+            email: $row['email'],
+            name: $row['name'],
+            role: $row['role']
+        );
+    }
+
+    private function insert(User $user): void
+    {
+        $stmt = $this->connection->prepare(
+            'INSERT INTO users (email, name, role, created_at) VALUES (:email, :name, :role, NOW())'
+        );
+        $stmt->execute([
+            'email' => $user->getEmail(),
+            'name'  => $user->getName(),
+            'role'  => $user->getRole(),
+        ]);
+    }
+
+    private function update(User $user): void
+    {
+        $stmt = $this->connection->prepare(
+            'UPDATE users SET email = :email, name = :name WHERE id = :id'
+        );
+        $stmt->execute([
+            'email' => $user->getEmail(),
+            'name'  => $user->getName(),
+            'id'    => $user->getId(),
+        ]);
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/no_unnecessary_conditions/bad/order_service.ts b/priv/combined_metrics/samples/code_smells/no_unnecessary_conditions/bad/order_service.ts
new file mode 100644
index 0000000..3c51ec9
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_unnecessary_conditions/bad/order_service.ts
@@ -0,0 +1,68 @@
+interface Order {
+  id: string;
+  status: "pending" | "confirmed" | "shipped" | "delivered" | "cancelled";
+  total: number;
+  currency: string;
+  items: Array<{ productId: string; quantity: number; price: number }>;
+}
+
+function isOrderCancellable(order: Order): boolean {
+  // Always true for a string — typeof check is unnecessary here
+  if (typeof order.id === "string") {
+    return order.status === "pending" || order.status === "confirmed";
+  }
+  return false;
+}
+
+function canRequestRefund(order: Order): boolean {
+  return order.status === "delivered";
+}
+
+async function cancelOrder(order: Order): Promise<Order> {
+  // order.id is always truthy (typed as string), this check is unnecessary
+  if (order.id) {
+    if (!isOrderCancellable(order)) {
+      throw new Error(`Order ${order.id} cannot be cancelled in status '${order.status}'`);
+    }
+  }
+
+  const response = await fetch(`/api/orders/${order.id}/cancel`, { method: "POST" });
+  if (!response.ok) throw new Error(`Cancel failed: ${response.status}`);
+  return response.json() as Promise<Order>;
+}
+
+function calculateOrderTotal(items: Order["items"]): number {
+  // items is typed as Array — the null check is unnecessary
+  if (items !== null && items !== undefined) {
+    return items.reduce((sum, item) => sum + item.price * item.quantity, 0);
+  }
+  return 0;
+}
+
+function getHighValueItems(order: Order, threshold: number): Order["items"] {
+  return order.items.filter((item) => {
+    // item.price is typed as number, it's always a number
+    if (typeof item.price === "number") {
+      return item.price > threshold;
+    }
+    return false;
+  });
+}
+
+function formatOrderSummary(order: Order): string {
+  const itemCount = order.items.length;
+  // itemCount is always >= 0; the `< 0` branch is unreachable
+  if (itemCount < 0) {
+    return `Order #${order.id}: no items`;
+  }
+
+  const total = new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: order.currency,
+  }).format(order.total);
+
+  return `Order #${order.id}: ${itemCount} item${itemCount === 1 ? "" : "s"}, ${total} (${order.status})`;
+}
+
+export { cancelOrder, isOrderCancellable, canRequestRefund, calculateOrderTotal, getHighValueItems, formatOrderSummary };
+export type { Order };
diff --git a/priv/combined_metrics/samples/code_smells/no_unnecessary_conditions/good/order_service.ts b/priv/combined_metrics/samples/code_smells/no_unnecessary_conditions/good/order_service.ts
new file mode 100644
index 0000000..e454095
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_unnecessary_conditions/good/order_service.ts
@@ -0,0 +1,46 @@
+interface Order {
+  id: string;
+  status: "pending" | "confirmed" | "shipped" | "delivered" | "cancelled";
+  total: number;
+  currency: string;
+  items: Array<{ productId: string; quantity: number; price: number }>;
+}
+
+function isOrderCancellable(order: Order): boolean {
+  return order.status === "pending" || order.status === "confirmed";
+}
+
+function canRequestRefund(order: Order): boolean {
+  return order.status === "delivered";
+}
+
+async function cancelOrder(order: Order): Promise<Order> {
+  if (!isOrderCancellable(order)) {
+    throw new Error(`Order ${order.id} cannot be cancelled in status '${order.status}'`);
+  }
+
+  const response = await fetch(`/api/orders/${order.id}/cancel`, { method: "POST" });
+  if (!response.ok) throw new Error(`Cancel failed: ${response.status}`);
+  return response.json() as Promise<Order>;
+}
+
+function calculateOrderTotal(items: Order["items"]): number {
+  return items.reduce((sum, item) => sum + item.price * item.quantity, 0);
+}
+
+function getHighValueItems(order: Order, threshold: number): Order["items"] {
+  return order.items.filter((item) => item.price > threshold);
+}
+
+function formatOrderSummary(order: Order): string {
+  const itemCount = order.items.length;
+  const total = new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: order.currency,
+  }).format(order.total);
+
+  return `Order #${order.id}: ${itemCount} item${itemCount === 1 ? "" : "s"}, ${total} (${order.status})`;
+}
+
+export { cancelOrder, isOrderCancellable, canRequestRefund, calculateOrderTotal, getHighValueItems, formatOrderSummary };
+export type { Order };
diff --git a/priv/combined_metrics/samples/code_smells/no_using_namespace_directives/bad/Matrix.cpp b/priv/combined_metrics/samples/code_smells/no_using_namespace_directives/bad/Matrix.cpp
new file mode 100644
index 0000000..ba1ca5d
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_using_namespace_directives/bad/Matrix.cpp
@@ -0,0 +1,75 @@
+#include <algorithm>
+#include <cmath>
+#include <stdexcept>
+#include <vector>
+
+// Pollutes the global namespace — conflicts with user-defined names and other libraries
+using namespace std;
+
+class Matrix {
+public:
+    Matrix(size_t rows, size_t cols)  // "size_t" unqualified due to using namespace std
+        : rows_(rows), cols_(cols), data_(rows * cols, 0.0) {}
+
+    double& at(size_t row, size_t col) {
+        boundsCheck(row, col);
+        return data_[row * cols_ + col];
+    }
+
+    double at(size_t row, size_t col) const {
+        boundsCheck(row, col);
+        return data_[row * cols_ + col];
+    }
+
+    size_t rows() const { return rows_; }
+    size_t cols() const { return cols_; }
+
+    Matrix operator+(const Matrix& rhs) const {
+        checkCompatible(rhs);
+        Matrix result(rows_, cols_);
+        // "transform" and "plus" silently resolved via using namespace std
+        transform(data_.begin(), data_.end(),
+                  rhs.data_.begin(), result.data_.begin(),
+                  plus<double>());
+        return result;
+    }
+
+    Matrix operator*(const Matrix& rhs) const {
+        if (cols_ != rhs.rows_)
+            throw invalid_argument("Incompatible dimensions");
+
+        Matrix result(rows_, rhs.cols_);
+        for (size_t i = 0; i < rows_; ++i)
+            for (size_t k = 0; k < cols_; ++k)
+                for (size_t j = 0; j < rhs.cols_; ++j)
+                    result.at(i, j) += at(i, k) * rhs.at(k, j);
+        return result;
+    }
+
+    double frobeniusNorm() const {
+        double sum = 0.0;
+        for (double val : data_)
+            sum += val * val;
+        return sqrt(sum); // unqualified — ambiguous if a custom sqrt exists in scope
+    }
+
+    void fill(double value) {
+        // "fill" collides with std::fill; confusing without qualification
+        fill(data_.begin(), data_.end(), value);
+    }
+
+private:
+    size_t rows_;
+    size_t cols_;
+    vector<double> data_;
+
+    void boundsCheck(size_t row, size_t col) const {
+        if (row >= rows_ || col >= cols_)
+            throw out_of_range("Matrix index out of range");
+    }
+
+    void checkCompatible(const Matrix& other) const {
+        if (rows_ != other.rows_ || cols_ != other.cols_)
+            throw invalid_argument("Matrix dimensions do not match");
+    }
+};
diff --git a/priv/combined_metrics/samples/code_smells/no_using_namespace_directives/good/Matrix.cpp b/priv/combined_metrics/samples/code_smells/no_using_namespace_directives/good/Matrix.cpp
new file mode 100644
index 0000000..8468d0c
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_using_namespace_directives/good/Matrix.cpp
@@ -0,0 +1,72 @@
+#include <algorithm>
+#include <cmath>
+#include <stdexcept>
+#include <vector>
+
+// No "using namespace std;" — names are qualified explicitly
+
+class Matrix {
+public:
+    Matrix(std::size_t rows, std::size_t cols)
+        : rows_(rows), cols_(cols), data_(rows * cols, 0.0) {}
+
+    double& at(std::size_t row, std::size_t col) {
+        boundsCheck(row, col);
+        return data_[row * cols_ + col];
+    }
+
+    double at(std::size_t row, std::size_t col) const {
+        boundsCheck(row, col);
+        return data_[row * cols_ + col];
+    }
+
+    std::size_t rows() const noexcept { return rows_; }
+    std::size_t cols() const noexcept { return cols_; }
+
+    Matrix operator+(const Matrix& rhs) const {
+        checkCompatible(rhs);
+        Matrix result(rows_, cols_);
+        std::transform(data_.begin(), data_.end(),
+                       rhs.data_.begin(), result.data_.begin(),
+                       std::plus<double>());
+        return result;
+    }
+
+    Matrix operator*(const Matrix& rhs) const {
+        if (cols_ != rhs.rows_)
+            throw std::invalid_argument("Incompatible matrix dimensions for multiplication");
+
+        Matrix result(rows_, rhs.cols_);
+        for (std::size_t i = 0; i < rows_; ++i)
+            for (std::size_t k = 0; k < cols_; ++k)
+                for (std::size_t j = 0; j < rhs.cols_; ++j)
+                    result.at(i, j) += at(i, k) * rhs.at(k, j);
+        return result;
+    }
+
+    double frobeniusNorm() const {
+        double sum = 0.0;
+        for (double val : data_)
+            sum += val * val;
+        return std::sqrt(sum);
+    }
+
+    void fill(double value) {
+        std::fill(data_.begin(), data_.end(), value);
+    }
+
+private:
+    std::size_t rows_;
+    std::size_t cols_;
+    std::vector<double> data_;
+
+    void boundsCheck(std::size_t row, std::size_t col) const {
+        if (row >= rows_ || col >= cols_)
+            throw std::out_of_range("Matrix index out of range");
+    }
+
+    void checkCompatible(const Matrix& other) const {
+        if (rows_ != other.rows_ || cols_ != other.cols_)
+            throw std::invalid_argument("Matrix dimensions do not match");
+    }
+};
diff --git a/priv/combined_metrics/samples/code_smells/no_virtual_calls_in_constructors/bad/Widget.cpp b/priv/combined_metrics/samples/code_smells/no_virtual_calls_in_constructors/bad/Widget.cpp
new file mode 100644
index 0000000..a2e698b
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_virtual_calls_in_constructors/bad/Widget.cpp
@@ -0,0 +1,72 @@
+#include <string>
+#include <vector>
+#include <memory>
+
+class Renderer {
+public:
+    virtual ~Renderer() = default;
+    virtual void draw(const std::string& label) = 0;
+};
+
+class Widget {
+public:
+    explicit Widget(std::string label)
+        : label_(std::move(label))
+    {
+        // Calls virtual methods in the constructor — at this point the vtable
+        // points to Widget's implementations, not the derived class overrides.
+        // This is almost certainly a bug when derived classes override these.
+        setupLayout();    // virtual call in ctor — dispatches to Widget::setupLayout
+        loadResources();  // virtual call in ctor — dispatches to Widget::loadResources
+    }
+
+    virtual ~Widget() = default;
+
+    virtual void render(Renderer& renderer) const {
+        renderer.draw(label_);
+    }
+
+protected:
+    virtual void setupLayout() {
+        // Base implementation — called even when derived class overrides it
+        minWidth_ = static_cast<int>(label_.size());
+    }
+
+    virtual void loadResources() {
+        // Base implementation — derived class version is never called from ctor
+    }
+
+    std::string label_;
+    int minWidth_ = 0;
+};
+
+class Button : public Widget {
+public:
+    explicit Button(std::string label, std::string action)
+        : Widget(std::move(label))  // Widget ctor calls setupLayout/loadResources...
+        , action_(std::move(action))
+    {
+        // ...but Button::setupLayout and Button::loadResources were NOT called above.
+        // The Button is not properly initialized after construction.
+    }
+
+    void render(Renderer& renderer) const override {
+        renderer.draw("[" + label_ + "]");
+    }
+
+protected:
+    void setupLayout() override {
+        // This override is NEVER called from Widget's constructor
+        minWidth_ = static_cast<int>(label_.size()) + 4; // button-specific padding
+        paddingSet_ = true;
+    }
+
+    void loadResources() override {
+        resourcesLoaded_ = true;
+    }
+
+private:
+    std::string action_;
+    bool paddingSet_ = false;     // always false after construction
+    bool resourcesLoaded_ = false; // always false after construction
+};
diff --git a/priv/combined_metrics/samples/code_smells/no_virtual_calls_in_constructors/good/Widget.cpp b/priv/combined_metrics/samples/code_smells/no_virtual_calls_in_constructors/good/Widget.cpp
new file mode 100644
index 0000000..bac17fc
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_virtual_calls_in_constructors/good/Widget.cpp
@@ -0,0 +1,77 @@
+#include <string>
+#include <vector>
+#include <memory>
+
+// Deferred initialization pattern: virtual methods are not called from constructors.
+// Initialization that depends on virtual behavior uses a factory or a separate init step.
+
+class Renderer {
+public:
+    virtual ~Renderer() = default;
+    virtual void draw(const std::string& label) = 0;
+};
+
+class Widget {
+public:
+    explicit Widget(std::string label)
+        : label_(std::move(label)), initialized_(false)
+    {
+        // Constructor only sets plain data — no virtual calls
+    }
+
+    virtual ~Widget() = default;
+
+    // Separate initialization method that can safely call virtual members
+    void initialize() {
+        if (initialized_) return;
+        setupLayout();   // virtual — called after construction, when vtable is correct
+        loadResources(); // virtual — same
+        initialized_ = true;
+    }
+
+    virtual void render(Renderer& renderer) const {
+        renderer.draw(label_);
+    }
+
+    const std::string& label() const noexcept { return label_; }
+    bool isInitialized() const noexcept { return initialized_; }
+
+protected:
+    virtual void setupLayout() {}
+    virtual void loadResources() {}
+
+    std::string label_;
+    bool initialized_;
+};
+
+class Button : public Widget {
+public:
+    explicit Button(std::string label, std::string action)
+        : Widget(std::move(label)), action_(std::move(action)) {}
+
+    void render(Renderer& renderer) const override {
+        renderer.draw("[" + label_ + "]");
+    }
+
+protected:
+    void setupLayout() override {
+        // Button-specific layout — runs after construction, vtable is fully set
+        minWidth_ = static_cast<int>(label_.size()) + 4;
+    }
+
+    void loadResources() override {
+        // Load button-specific resources
+    }
+
+private:
+    std::string action_;
+    int minWidth_ = 0;
+};
+
+// Factory ensures initialize() is called on the fully-constructed object
+template<typename T, typename... Args>
+std::unique_ptr<T> makeWidget(Args&&... args) {
+    auto widget = std::make_unique<T>(std::forward<Args>(args)...);
+    widget->initialize(); // safe: called after full construction
+    return widget;
+}
diff --git a/priv/combined_metrics/samples/code_smells/no_with_statement/bad/report_builder.js b/priv/combined_metrics/samples/code_smells/no_with_statement/bad/report_builder.js
new file mode 100644
index 0000000..0f4caee
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_with_statement/bad/report_builder.js
@@ -0,0 +1,54 @@
+function formatCurrency(amount, currency = "USD") {
+  return new Intl.NumberFormat("en-US", { style: "currency", currency }).format(amount);
+}
+
+function formatDate(date) {
+  return new Intl.DateTimeFormat("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+  }).format(new Date(date));
+}
+
+function buildOrderRow(order) {
+  with (order) {
+    const total = formatCurrency(order.total, currency);
+    const date = formatDate(createdAt);
+    const statusLabel = status.charAt(0).toUpperCase() + status.slice(1);
+
+    return {
+      id,
+      customer: `${customer.firstName} ${customer.lastName}`,
+      email: customer.email,
+      date,
+      total,
+      status: statusLabel,
+      itemCount: items.length,
+    };
+  }
+}
+
+function buildSummaryStats(orders) {
+  const totalRevenue = orders.reduce((sum, o) => sum + o.total, 0);
+
+  with (Math) {
+    const averageOrderValue = totalRevenue / orders.length;
+    const completedCount = orders.filter((o) => o.status === "completed").length;
+
+    return {
+      totalOrders: orders.length,
+      totalRevenue: formatCurrency(totalRevenue),
+      averageOrderValue: formatCurrency(round(averageOrderValue * 100) / 100),
+      completionRate: `${round((completedCount / orders.length) * 100)}%`,
+    };
+  }
+}
+
+function buildReport(orders) {
+  const rows = orders.map(buildOrderRow);
+  const summary = buildSummaryStats(orders);
+
+  return { rows, summary, generatedAt: new Date().toISOString() };
+}
+
+export { buildReport, buildOrderRow, buildSummaryStats };
diff --git a/priv/combined_metrics/samples/code_smells/no_with_statement/good/report_builder.js b/priv/combined_metrics/samples/code_smells/no_with_statement/good/report_builder.js
new file mode 100644
index 0000000..4e80900
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/no_with_statement/good/report_builder.js
@@ -0,0 +1,49 @@
+function formatCurrency(amount, currency = "USD") {
+  return new Intl.NumberFormat("en-US", { style: "currency", currency }).format(amount);
+}
+
+function formatDate(date) {
+  return new Intl.DateTimeFormat("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+  }).format(new Date(date));
+}
+
+function buildOrderRow(order) {
+  const total = formatCurrency(order.total, order.currency);
+  const date = formatDate(order.createdAt);
+  const statusLabel = order.status.charAt(0).toUpperCase() + order.status.slice(1);
+
+  return {
+    id: order.id,
+    customer: `${order.customer.firstName} ${order.customer.lastName}`,
+    email: order.customer.email,
+    date,
+    total,
+    status: statusLabel,
+    itemCount: order.items.length,
+  };
+}
+
+function buildSummaryStats(orders) {
+  const totalRevenue = orders.reduce((sum, o) => sum + o.total, 0);
+  const averageOrderValue = totalRevenue / orders.length;
+  const completedCount = orders.filter((o) => o.status === "completed").length;
+
+  return {
+    totalOrders: orders.length,
+    totalRevenue: formatCurrency(totalRevenue),
+    averageOrderValue: formatCurrency(averageOrderValue),
+    completionRate: `${Math.round((completedCount / orders.length) * 100)}%`,
+  };
+}
+
+function buildReport(orders) {
+  const rows = orders.map(buildOrderRow);
+  const summary = buildSummaryStats(orders);
+
+  return { rows, summary, generatedAt: new Date().toISOString() };
+}
+
+export { buildReport, buildOrderRow, buildSummaryStats, formatCurrency, formatDate };
diff --git a/priv/combined_metrics/samples/code_smells/shares_memory_by_communicating/bad/counter.go b/priv/combined_metrics/samples/code_smells/shares_memory_by_communicating/bad/counter.go
new file mode 100644
index 0000000..ced67d4
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/shares_memory_by_communicating/bad/counter.go
@@ -0,0 +1,39 @@
+package counter
+
+import "sync"
+
+// PageCounter tracks page view counts using a mutex-guarded map.
+// Multiple goroutines directly mutate shared state instead of communicating.
+type PageCounter struct {
+	mu     sync.Mutex
+	counts map[string]int
+}
+
+func NewPageCounter() *PageCounter {
+	return &PageCounter{
+		counts: make(map[string]int),
+	}
+}
+
+// Increment records a hit for the given page.
+// Multiple goroutines share the map directly, protected only by a mutex.
+func (c *PageCounter) Increment(page string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.counts[page]++
+}
+
+// Count returns the current hit count for the given page.
+func (c *PageCounter) Count(page string) int {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.counts[page]
+}
+
+// Reset clears all counters.
+func (c *PageCounter) Reset() {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	// Direct mutation of shared map — goroutines share memory instead of communicating.
+	c.counts = make(map[string]int)
+}
diff --git a/priv/combined_metrics/samples/code_smells/shares_memory_by_communicating/good/counter.go b/priv/combined_metrics/samples/code_smells/shares_memory_by_communicating/good/counter.go
new file mode 100644
index 0000000..a4bcf19
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/shares_memory_by_communicating/good/counter.go
@@ -0,0 +1,55 @@
+package counter
+
+// PageCounter tracks page view counts by routing all mutations through a channel.
+// No mutex is needed; the single goroutine that owns the map is the only writer.
+type PageCounter struct {
+	inc   chan string
+	query chan queryReq
+	stop  chan struct{}
+}
+
+type queryReq struct {
+	page   string
+	result chan int
+}
+
+func NewPageCounter() *PageCounter {
+	c := &PageCounter{
+		inc:   make(chan string, 64),
+		query: make(chan queryReq),
+		stop:  make(chan struct{}),
+	}
+	go c.run()
+	return c
+}
+
+func (c *PageCounter) run() {
+	counts := make(map[string]int)
+	for {
+		select {
+		case page := <-c.inc:
+			counts[page]++
+		case req := <-c.query:
+			req.result <- counts[req.page]
+		case <-c.stop:
+			return
+		}
+	}
+}
+
+// Increment records a hit for the given page. Safe to call from multiple goroutines.
+func (c *PageCounter) Increment(page string) {
+	c.inc <- page
+}
+
+// Count returns the current hit count for the given page.
+func (c *PageCounter) Count(page string) int {
+	result := make(chan int, 1)
+	c.query <- queryReq{page: page, result: result}
+	return <-result
+}
+
+// Stop shuts down the background goroutine.
+func (c *PageCounter) Stop() {
+	close(c.stop)
+}
diff --git a/priv/combined_metrics/samples/code_smells/single_argument_constructors_are_explicit/bad/Parser.cpp b/priv/combined_metrics/samples/code_smells/single_argument_constructors_are_explicit/bad/Parser.cpp
new file mode 100644
index 0000000..ab246bc
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/single_argument_constructors_are_explicit/bad/Parser.cpp
@@ -0,0 +1,97 @@
+#include <string>
+#include <string_view>
+#include <vector>
+#include <stdexcept>
+
+class TokenStream {
+public:
+    // Missing explicit: any string is silently convertible to TokenStream
+    TokenStream(std::string source)
+        : source_(std::move(source)), position_(0) {}
+
+    bool hasNext() const { return position_ < source_.size(); }
+    char peek() const { return source_[position_]; }
+    char consume() { return source_[position_++]; }
+
+private:
+    std::string source_;
+    std::size_t position_;
+};
+
+class ParseError : public std::runtime_error {
+public:
+    // Missing explicit: a string literal accidentally converts to ParseError in the wrong context
+    ParseError(const std::string& message) : std::runtime_error(message) {}
+};
+
+class Token {
+public:
+    enum class Kind { Identifier, Number, Operator, EndOfStream };
+
+    Token(Kind kind, std::string value)
+        : kind_(kind), value_(std::move(value)) {}
+
+    Kind kind() const { return kind_; }
+    const std::string& value() const { return value_; }
+
+private:
+    Kind kind_;
+    std::string value_;
+};
+
+// Accepting a TokenStream by value triggers an implicit conversion from string
+void processStream(TokenStream stream);
+
+class Parser {
+public:
+    // Missing explicit: Parser p = "some expression"; compiles silently
+    Parser(std::string input)
+        : stream_(std::move(input)) {}
+
+    std::vector<Token> tokenize() {
+        std::vector<Token> tokens;
+        while (stream_.hasNext()) {
+            skipWhitespace();
+            if (!stream_.hasNext()) break;
+
+            char c = stream_.peek();
+            if (std::isalpha(c))
+                tokens.push_back(readIdentifier());
+            else if (std::isdigit(c))
+                tokens.push_back(readNumber());
+            else
+                tokens.push_back(readOperator());
+        }
+        tokens.emplace_back(Token::Kind::EndOfStream, "");
+        return tokens;
+    }
+
+private:
+    TokenStream stream_;
+
+    void skipWhitespace() {
+        while (stream_.hasNext() && std::isspace(stream_.peek()))
+            stream_.consume();
+    }
+
+    Token readIdentifier() {
+        std::string value;
+        while (stream_.hasNext() && std::isalnum(stream_.peek()))
+            value += stream_.consume();
+        return Token(Token::Kind::Identifier, std::move(value));
+    }
+
+    Token readNumber() {
+        std::string value;
+        while (stream_.hasNext() && std::isdigit(stream_.peek()))
+            value += stream_.consume();
+        return Token(Token::Kind::Number, std::move(value));
+    }
+
+    Token readOperator() {
+        return Token(Token::Kind::Operator, std::string(1, stream_.consume()));
+    }
+};
+
+// This compiles because Parser(std::string) is not explicit:
+// Parser p = std::string("1 + 2");   // implicit conversion
diff --git a/priv/combined_metrics/samples/code_smells/single_argument_constructors_are_explicit/good/Parser.cpp b/priv/combined_metrics/samples/code_smells/single_argument_constructors_are_explicit/good/Parser.cpp
new file mode 100644
index 0000000..6f2a96a
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/single_argument_constructors_are_explicit/good/Parser.cpp
@@ -0,0 +1,93 @@
+#include <string>
+#include <string_view>
+#include <vector>
+#include <stdexcept>
+
+class TokenStream {
+public:
+    explicit TokenStream(std::string source)  // explicit: prevents implicit string -> TokenStream
+        : source_(std::move(source)), position_(0) {}
+
+    bool hasNext() const noexcept { return position_ < source_.size(); }
+    char peek() const { return source_[position_]; }
+    char consume() { return source_[position_++]; }
+
+private:
+    std::string source_;
+    std::size_t position_;
+};
+
+class ParseError : public std::runtime_error {
+public:
+    explicit ParseError(const std::string& message)  // explicit: single-arg exception ctor
+        : std::runtime_error(message) {}
+
+    explicit ParseError(std::string_view message)
+        : std::runtime_error(std::string(message)) {}
+};
+
+class Token {
+public:
+    enum class Kind { Identifier, Number, Operator, EndOfStream };
+
+    Token(Kind kind, std::string value)  // two-arg ctor: explicit not required but consistent
+        : kind_(kind), value_(std::move(value)) {}
+
+    Kind kind() const noexcept { return kind_; }
+    const std::string& value() const noexcept { return value_; }
+
+private:
+    Kind kind_;
+    std::string value_;
+};
+
+class Parser {
+public:
+    // explicit: prevents accidental conversion from string to Parser
+    explicit Parser(std::string input)
+        : stream_(std::move(input)) {}
+
+    std::vector<Token> tokenize() {
+        std::vector<Token> tokens;
+        while (stream_.hasNext()) {
+            skipWhitespace();
+            if (!stream_.hasNext()) break;
+
+            char c = stream_.peek();
+            if (std::isalpha(c))
+                tokens.push_back(readIdentifier());
+            else if (std::isdigit(c))
+                tokens.push_back(readNumber());
+            else
+                tokens.push_back(readOperator());
+        }
+        tokens.emplace_back(Token::Kind::EndOfStream, "");
+        return tokens;
+    }
+
+private:
+    TokenStream stream_;
+
+    void skipWhitespace() {
+        while (stream_.hasNext() && std::isspace(stream_.peek()))
+            stream_.consume();
+    }
+
+    Token readIdentifier() {
+        std::string value;
+        while (stream_.hasNext() && std::isalnum(stream_.peek()))
+            value += stream_.consume();
+        return Token(Token::Kind::Identifier, std::move(value));
+    }
+
+    Token readNumber() {
+        std::string value;
+        while (stream_.hasNext() && std::isdigit(stream_.peek()))
+            value += stream_.consume();
+        return Token(Token::Kind::Number, std::move(value));
+    }
+
+    Token readOperator() {
+        return Token(Token::Kind::Operator, std::string(1, stream_.consume()));
+    }
+};
diff --git a/priv/combined_metrics/samples/code_smells/supervised_processes_in_supervision_tree/bad/analytics.ex b/priv/combined_metrics/samples/code_smells/supervised_processes_in_supervision_tree/bad/analytics.ex
new file mode 100644
index 0000000..fad35d2
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/supervised_processes_in_supervision_tree/bad/analytics.ex
@@ -0,0 +1,65 @@
+defmodule MyApp.Analytics.EventBuffer do
+  @moduledoc """
+  Buffers analytics events.
+  """
+
+  @flush_interval_ms 5_000
+
+  # Bad: starts the background loop with a bare spawn/1 call.
+  # If this process crashes it will not be restarted, and no crash report
+  # is linked to any supervisor — it silently disappears.
+  @spec start() :: pid()
+  def start do
+    state = %{buffer: [], count: 0}
+    spawn(fn -> loop(state) end)
+  end
+
+  @spec push(pid(), map()) :: :ok
+  def push(pid, event) when is_map(event) do
+    send(pid, {:push, event})
+    :ok
+  end
+
+  defp loop(state) do
+    receive do
+      {:push, event} ->
+        new_state = %{state | buffer: [event | state.buffer], count: state.count + 1}
+
+        if new_state.count >= 500 do
+          flush(new_state.buffer)
+          loop(%{buffer: [], count: 0})
+        else
+          loop(new_state)
+        end
+
+      :flush ->
+        flush(state.buffer)
+        schedule_flush(self())
+        loop(%{buffer: [], count: 0})
+    end
+  end
+
+  defp flush(events), do: MyApp.Analytics.Store.insert_all(Enum.reverse(events))
+
+  defp schedule_flush(pid) do
+    Process.send_after(pid, :flush, @flush_interval_ms)
+  end
+end
+
+defmodule MyApp.Application do
+  use Application
+
+  @impl true
+  def start(_type, _args) do
+    children = [MyApp.Repo]
+
+    result = Supervisor.start_link(children, strategy: :one_for_one)
+
+    # Bad: EventBuffer is started with spawn/1 outside the supervision tree.
+    # It will not be restarted on crash and the PID is hard to track.
+    pid = MyApp.Analytics.EventBuffer.start()
+    Process.register(pid, :event_buffer)
+
+    result
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/supervised_processes_in_supervision_tree/good/analytics.ex b/priv/combined_metrics/samples/code_smells/supervised_processes_in_supervision_tree/good/analytics.ex
new file mode 100644
index 0000000..caa83d3
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/supervised_processes_in_supervision_tree/good/analytics.ex
@@ -0,0 +1,74 @@
+defmodule MyApp.Analytics.EventBuffer do
+  @moduledoc """
+  Buffers analytics events before flushing to the database.
+  Started under the application supervisor — never spawned bare.
+  """
+
+  use GenServer, restart: :permanent
+
+  @flush_interval_ms 5_000
+  @max_buffer_size 500
+
+  def start_link(opts) do
+    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
+  end
+
+  @doc "Adds an event to the buffer."
+  @spec push(map()) :: :ok
+  def push(event) when is_map(event) do
+    GenServer.cast(__MODULE__, {:push, event})
+  end
+
+  @impl true
+  def init(_opts) do
+    schedule_flush()
+    {:ok, %{buffer: [], count: 0}}
+  end
+
+  @impl true
+  def handle_cast({:push, event}, %{buffer: buf, count: count} = state) do
+    new_state = %{state | buffer: [event | buf], count: count + 1}
+
+    if new_state.count >= @max_buffer_size do
+      flush(new_state.buffer)
+      {:noreply, %{new_state | buffer: [], count: 0}}
+    else
+      {:noreply, new_state}
+    end
+  end
+
+  @impl true
+  def handle_info(:flush, %{buffer: []} = state) do
+    schedule_flush()
+    {:noreply, state}
+  end
+
+  def handle_info(:flush, %{buffer: buf} = state) do
+    flush(buf)
+    schedule_flush()
+    {:noreply, %{state | buffer: [], count: 0}}
+  end
+
+  defp flush(events) do
+    MyApp.Analytics.Store.insert_all(Enum.reverse(events))
+  end
+
+  defp schedule_flush do
+    Process.send_after(self(), :flush, @flush_interval_ms)
+  end
+end
+
+defmodule MyApp.Application do
+  use Application
+
+  @impl true
+  def start(_type, _args) do
+    children = [
+      MyApp.Repo,
+      # Good: EventBuffer is started as a supervised child, not with spawn/1
+      MyApp.Analytics.EventBuffer
+    ]
+
+    Supervisor.start_link(children, strategy: :one_for_one)
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/switch_has_default_case/bad/notification_router.js b/priv/combined_metrics/samples/code_smells/switch_has_default_case/bad/notification_router.js
new file mode 100644
index 0000000..f43c6b1
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/switch_has_default_case/bad/notification_router.js
@@ -0,0 +1,58 @@
+function getNotificationChannel(userPreferences, notificationType) {
+  switch (notificationType) {
+    case "order_confirmed":
+      return userPreferences.emailEnabled ? "email" : "push";
+    case "order_shipped":
+      return "push";
+    case "order_delivered":
+      return userPreferences.emailEnabled ? "email" : "push";
+    case "payment_failed":
+      return "email";
+    case "account_locked":
+      return "email";
+    case "promotional":
+      return userPreferences.marketingEnabled ? "email" : null;
+  }
+}
+
+function formatNotificationMessage(notification) {
+  const { type, data } = notification;
+
+  switch (type) {
+    case "order_confirmed":
+      return {
+        subject: `Order #${data.orderId} confirmed`,
+        body: `Your order has been confirmed and is being prepared.`,
+      };
+    case "order_shipped":
+      return {
+        subject: `Order #${data.orderId} is on its way`,
+        body: `Your order has shipped. Tracking number: ${data.trackingNumber}`,
+      };
+    case "order_delivered":
+      return {
+        subject: `Order #${data.orderId} delivered`,
+        body: `Your order has been delivered. Enjoy!`,
+      };
+    case "payment_failed":
+      return {
+        subject: "Payment failed",
+        body: `Your payment of ${data.amount} could not be processed.`,
+      };
+  }
+}
+
+function getNotificationPriority(type) {
+  switch (type) {
+    case "account_locked":
+      return "critical";
+    case "payment_failed":
+      return "high";
+    case "order_shipped":
+      return "medium";
+    case "promotional":
+      return "low";
+  }
+}
+
+export { getNotificationChannel, formatNotificationMessage, getNotificationPriority };
diff --git a/priv/combined_metrics/samples/code_smells/switch_has_default_case/good/notification_router.js b/priv/combined_metrics/samples/code_smells/switch_has_default_case/good/notification_router.js
new file mode 100644
index 0000000..562cacd
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/switch_has_default_case/good/notification_router.js
@@ -0,0 +1,52 @@
+import logger from "./logger.js";
+
+function getNotificationChannel(userPreferences, notificationType) {
+  switch (notificationType) {
+    case "order_confirmed":
+      return userPreferences.emailEnabled ? "email" : "push";
+    case "order_shipped":
+      return "push";
+    case "order_delivered":
+      return userPreferences.emailEnabled ? "email" : "push";
+    case "payment_failed":
+      return "email";
+    case "account_locked":
+      return "email";
+    case "promotional":
+      return userPreferences.marketingEnabled ? "email" : null;
+    default:
+      logger.warn(`Unknown notification type: '${notificationType}'`);
+      return null;
+  }
+}
+
+function formatNotificationMessage(notification) {
+  const { type, data } = notification;
+
+  switch (type) {
+    case "order_confirmed":
+      return {
+        subject: `Order #${data.orderId} confirmed`,
+        body: `Your order has been confirmed and is being prepared.`,
+      };
+    case "order_shipped":
+      return {
+        subject: `Order #${data.orderId} is on its way`,
+        body: `Your order has shipped. Tracking number: ${data.trackingNumber}`,
+      };
+    case "order_delivered":
+      return {
+        subject: `Order #${data.orderId} delivered`,
+        body: `Your order has been delivered. Enjoy!`,
+      };
+    case "payment_failed":
+      return {
+        subject: "Payment failed",
+        body: `Your payment of ${data.amount} could not be processed.`,
+      };
+    default:
+      throw new Error(`No message template for notification type: '${type}'`);
+  }
+}
+
+export { getNotificationChannel, formatNotificationMessage };
diff --git a/priv/combined_metrics/samples/code_smells/uses_appropriate_dispatcher/bad/AnalyticsProcessor.kt b/priv/combined_metrics/samples/code_smells/uses_appropriate_dispatcher/bad/AnalyticsProcessor.kt
new file mode 100644
index 0000000..05ef94c
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_appropriate_dispatcher/bad/AnalyticsProcessor.kt
@@ -0,0 +1,54 @@
+package com.example.analytics
+
+import kotlinx.coroutines.*
+import java.time.LocalDate
+
+data class DailyStats(val date: LocalDate, val totalRevenue: Double, val orderCount: Int)
+
+class AnalyticsProcessor(
+    private val repository: AnalyticsRepository,
+    private val fileExporter: CsvExporter
+) {
+
+    /**
+     * CPU-intensive computation incorrectly uses Dispatchers.IO.
+     * IO's thread pool is designed for blocking calls — using it for heavy
+     * CPU work starves I/O threads and misses parallelism optimisations.
+     */
+    suspend fun computeDailyStats(events: List<RawEvent>): List<DailyStats> =
+        withContext(Dispatchers.IO) {   // Wrong dispatcher for CPU work
+            events
+                .groupBy { it.occurredAt.toLocalDate() }
+                .map { (date, dayEvents) ->
+                    val revenue = dayEvents.sumOf { it.amount }
+                    val orders = dayEvents.count { it.type == "ORDER_PLACED" }
+                    DailyStats(date, revenue, orders)
+                }
+                .sortedBy { it.date }
+        }
+
+    /**
+     * Database access incorrectly uses Dispatchers.Default.
+     * Default is for CPU-bound work; blocking DB calls here will exhaust
+     * the limited Default thread pool and degrade all CPU-bound tasks.
+     */
+    suspend fun loadEvents(from: LocalDate, to: LocalDate): List<RawEvent> =
+        withContext(Dispatchers.Default) {  // Wrong dispatcher for I/O
+            repository.findBetween(from, to)
+        }
+
+    /**
+     * File write runs on Dispatchers.Default — blocking I/O on a CPU dispatcher
+     * ties up a thread that should be doing computation.
+     */
+    suspend fun exportToCsv(stats: List<DailyStats>, outputPath: String) =
+        withContext(Dispatchers.Default) {  // Wrong dispatcher for file I/O
+            fileExporter.write(outputPath, stats)
+        }
+
+    suspend fun generateReport(from: LocalDate, to: LocalDate, outputPath: String) {
+        val events = loadEvents(from, to)
+        val stats = computeDailyStats(events)
+        exportToCsv(stats, outputPath)
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_appropriate_dispatcher/good/AnalyticsProcessor.kt b/priv/combined_metrics/samples/code_smells/uses_appropriate_dispatcher/good/AnalyticsProcessor.kt
new file mode 100644
index 0000000..57fa3b4
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_appropriate_dispatcher/good/AnalyticsProcessor.kt
@@ -0,0 +1,54 @@
+package com.example.analytics
+
+import kotlinx.coroutines.*
+import java.time.LocalDate
+
+data class DailyStats(val date: LocalDate, val totalRevenue: Double, val orderCount: Int)
+
+class AnalyticsProcessor(
+    private val repository: AnalyticsRepository,
+    private val fileExporter: CsvExporter
+) {
+
+    /**
+     * CPU-intensive aggregation uses Dispatchers.Default — optimised for
+     * parallel computation on a thread pool sized to available CPU cores.
+     */
+    suspend fun computeDailyStats(events: List<RawEvent>): List<DailyStats> =
+        withContext(Dispatchers.Default) {
+            events
+                .groupBy { it.occurredAt.toLocalDate() }
+                .map { (date, dayEvents) ->
+                    val revenue = dayEvents.sumOf { it.amount }
+                    val orders = dayEvents.count { it.type == "ORDER_PLACED" }
+                    DailyStats(date, revenue, orders)
+                }
+                .sortedBy { it.date }
+        }
+
+    /**
+     * Database reads and writes use Dispatchers.IO — the thread pool is sized
+     * for blocking I/O without starving CPU-bound work.
+     */
+    suspend fun loadEvents(from: LocalDate, to: LocalDate): List<RawEvent> =
+        withContext(Dispatchers.IO) {
+            repository.findBetween(from, to)
+        }
+
+    /**
+     * File write is I/O-bound — Dispatchers.IO is appropriate.
+     */
+    suspend fun exportToCsv(stats: List<DailyStats>, outputPath: String) =
+        withContext(Dispatchers.IO) {
+            fileExporter.write(outputPath, stats)
+        }
+
+    /**
+     * Orchestrator — each step runs on the right dispatcher via the helpers above.
+     */
+    suspend fun generateReport(from: LocalDate, to: LocalDate, outputPath: String) {
+        val events = loadEvents(from, to)        // I/O dispatcher
+        val stats = computeDailyStats(events)   // Default dispatcher
+        exportToCsv(stats, outputPath)           // I/O dispatcher
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_arc_only_with_send_sync_types/bad/pool.rs b/priv/combined_metrics/samples/code_smells/uses_arc_only_with_send_sync_types/bad/pool.rs
new file mode 100644
index 0000000..c44f1cc
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_arc_only_with_send_sync_types/bad/pool.rs
@@ -0,0 +1,52 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::sync::Arc;
+
+/// A connection that uses RefCell for interior mutability.
+/// RefCell is NOT Sync — it cannot be safely accessed from multiple threads.
+pub struct Connection {
+    pub id: u64,
+    pub url: String,
+    // RefCell is !Sync — wrapping this in Arc<Connection> is unsound
+    pub state: RefCell<String>,
+}
+
+// BAD: Arc<Connection> requires Connection: Send + Sync.
+// Because Connection contains RefCell, it is !Sync.
+// This will fail to compile when sent across threads, but the intent is wrong.
+pub struct Pool {
+    // Arc<Connection> here is misleading — it looks thread-safe but isn't
+    connections: Vec<Arc<Connection>>,
+}
+
+impl Pool {
+    pub fn new() -> Self {
+        Self { connections: Vec::new() }
+    }
+
+    pub fn add(&mut self, url: impl Into<String>) -> Arc<Connection> {
+        let conn = Arc::new(Connection {
+            id: self.connections.len() as u64,
+            url: url.into(),
+            state: RefCell::new("idle".to_string()),
+        });
+        self.connections.push(Arc::clone(&conn));
+        conn
+    }
+}
+
+// BAD: Rc is not Send, so Arc<Rc<T>> cannot be used across threads.
+// Using Arc here is misleading — the Rc inside prevents thread sharing.
+pub struct BadSharedHandle {
+    inner: Arc<Rc<String>>,
+}
+
+impl BadSharedHandle {
+    pub fn new(s: impl Into<String>) -> Self {
+        Self { inner: Arc::new(Rc::new(s.into())) }
+    }
+
+    pub fn value(&self) -> Rc<String> {
+        Rc::clone(&self.inner)
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_arc_only_with_send_sync_types/good/pool.rs b/priv/combined_metrics/samples/code_smells/uses_arc_only_with_send_sync_types/good/pool.rs
new file mode 100644
index 0000000..63865a9
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_arc_only_with_send_sync_types/good/pool.rs
@@ -0,0 +1,55 @@
+use std::sync::{Arc, Mutex};
+
+/// A connection that is safe to share across threads.
+/// Implements Send + Sync, making it valid to wrap in Arc.
+#[derive(Debug)]
+pub struct Connection {
+    pub id: u64,
+    pub url: String,
+    pub active: bool,
+}
+
+// Connection is Send + Sync because all its fields are Send + Sync
+// Arc<Connection> is therefore also Send + Sync — correct usage
+pub struct Pool {
+    connections: Vec<Arc<Mutex<Connection>>>,
+    max_size: usize,
+}
+
+impl Pool {
+    pub fn new(max_size: usize) -> Self {
+        Self { connections: Vec::new(), max_size }
+    }
+
+    pub fn add(&mut self, url: impl Into<String>) -> Arc<Mutex<Connection>> {
+        let conn = Arc::new(Mutex::new(Connection {
+            id: self.connections.len() as u64,
+            url: url.into(),
+            active: true,
+        }));
+        self.connections.push(Arc::clone(&conn));
+        conn
+    }
+
+    // Returns an Arc to share the connection safely between threads
+    pub fn get_connection(&self, id: u64) -> Option<Arc<Mutex<Connection>>> {
+        self.connections
+            .iter()
+            .find(|c| c.lock().map(|c| c.id == id).unwrap_or(false))
+            .map(Arc::clone)
+    }
+
+    pub fn active_count(&self) -> usize {
+        self.connections
+            .iter()
+            .filter(|c| c.lock().map(|c| c.active).unwrap_or(false))
+            .count()
+    }
+}
+
+// Shared, thread-safe state — Arc wraps a Mutex<Vec<...>>, all Send + Sync
+pub type SharedLog = Arc<Mutex<Vec<String>>>;
+
+pub fn create_shared_log() -> SharedLog {
+    Arc::new(Mutex::new(Vec::new()))
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_attr_accessor_not_manual_getter_setter/bad/payment.rb b/priv/combined_metrics/samples/code_smells/uses_attr_accessor_not_manual_getter_setter/bad/payment.rb
new file mode 100644
index 0000000..e515c9c
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_attr_accessor_not_manual_getter_setter/bad/payment.rb
@@ -0,0 +1,58 @@
+class PaymentMethod
+  def initialize(attrs = {})
+    @id = attrs[:id]
+    @card_type = attrs[:card_type]
+    @last_four = attrs[:last_four]
+    @expires_at = attrs[:expires_at]
+    @billing_address = attrs[:billing_address]
+    @nickname = attrs[:nickname]
+    @is_default = attrs[:is_default] || false
+  end
+
+  # Manual getters — should use attr_reader
+  def id
+    @id
+  end
+
+  def card_type
+    @card_type
+  end
+
+  def last_four
+    @last_four
+  end
+
+  def expires_at
+    @expires_at
+  end
+
+  def billing_address
+    @billing_address
+  end
+
+  # Manual getter + setter pair — should use attr_accessor
+  def nickname
+    @nickname
+  end
+
+  def nickname=(value)
+    @nickname = value
+  end
+
+  def is_default
+    @is_default
+  end
+
+  def is_default=(value)
+    @is_default = value
+  end
+
+  def expired?
+    @expires_at < Date.today
+  end
+
+  def display_name
+    base = "#{@card_type.upcase} ending in #{@last_four}"
+    @nickname ? "#{@nickname} (#{base})" : base
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/uses_attr_accessor_not_manual_getter_setter/good/payment.rb b/priv/combined_metrics/samples/code_smells/uses_attr_accessor_not_manual_getter_setter/good/payment.rb
new file mode 100644
index 0000000..b00ead9
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_attr_accessor_not_manual_getter_setter/good/payment.rb
@@ -0,0 +1,39 @@
+class PaymentMethod
+  attr_reader :id, :card_type, :last_four, :expires_at, :billing_address
+  attr_accessor :nickname, :is_default
+
+  def initialize(attrs = {})
+    @id = attrs[:id]
+    @card_type = attrs[:card_type]
+    @last_four = attrs[:last_four]
+    @expires_at = attrs[:expires_at]
+    @billing_address = attrs[:billing_address]
+    @nickname = attrs[:nickname]
+    @is_default = attrs[:is_default] || false
+  end
+
+  def expired?
+    expires_at < Date.today
+  end
+
+  def expiring_soon?
+    !expired? && expires_at < 30.days.from_now
+  end
+
+  def display_name
+    base = "#{card_type.upcase} ending in #{last_four}"
+    nickname ? "#{nickname} (#{base})" : base
+  end
+
+  def to_h
+    {
+      id: id,
+      card_type: card_type,
+      last_four: last_four,
+      expires_at: expires_at,
+      nickname: nickname,
+      is_default: is_default,
+      expired: expired?
+    }
+  end
+end
diff --git a/priv/combined_metrics/samples/code_smells/uses_context_manager_for_resources/bad/database_manager.py b/priv/combined_metrics/samples/code_smells/uses_context_manager_for_resources/bad/database_manager.py
new file mode 100644
index 0000000..e3bf408
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_context_manager_for_resources/bad/database_manager.py
@@ -0,0 +1,62 @@
+"""Database manager providing connection pooling and query helpers."""
+from __future__ import annotations
+
+import sqlite3
+from typing import Any, Optional
+
+
+DB_PATH = ":memory:"
+
+
+def get_connection(path: str = DB_PATH) -> sqlite3.Connection:
+    """Return a raw connection — caller is responsible for closing it."""
+    return sqlite3.connect(path)
+
+
+def execute_query(
+    sql: str,
+    params: tuple = (),
+    path: str = DB_PATH,
+) -> list[dict[str, Any]]:
+    """Run a SELECT query — connection left open if an exception is raised."""
+    conn = get_connection(path)               # no context manager
+    conn.row_factory = sqlite3.Row
+    cursor = conn.cursor()
+    cursor.execute(sql, params)               # if this raises, conn is never closed
+    rows = [dict(row) for row in cursor.fetchall()]
+    conn.close()                              # only reached on success
+    return rows
+
+
+def execute_write(
+    sql: str,
+    params: tuple = (),
+    path: str = DB_PATH,
+) -> int:
+    """Execute a write — connection leaked on error; no rollback on failure."""
+    conn = get_connection(path)
+    cursor = conn.cursor()
+    cursor.execute(sql, params)               # exception here leaks conn
+    conn.commit()
+    conn.close()
+    return cursor.rowcount
+
+
+def export_to_csv(
+    sql: str,
+    output_path: str,
+    path: str = DB_PATH,
+) -> int:
+    """Export results — both file and connection are manually managed."""
+    import csv
+    rows = execute_query(sql, path=path)
+    if not rows:
+        return 0
+
+    csv_file = open(output_path, "w", newline="", encoding="utf-8")  # no 'with'
+    writer = csv.DictWriter(csv_file, fieldnames=rows[0].keys())
+    writer.writeheader()
+    writer.writerows(rows)
+    csv_file.close()    # only reached if writerows() doesn't raise
+
+    return len(rows)
diff --git a/priv/combined_metrics/samples/code_smells/uses_context_manager_for_resources/good/database_manager.py b/priv/combined_metrics/samples/code_smells/uses_context_manager_for_resources/good/database_manager.py
new file mode 100644
index 0000000..6f0405e
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_context_manager_for_resources/good/database_manager.py
@@ -0,0 +1,67 @@
+"""Database manager providing connection pooling and query helpers."""
+from __future__ import annotations
+
+import sqlite3
+from contextlib import contextmanager
+from typing import Any, Generator, Optional
+
+
+DB_PATH = ":memory:"
+
+
+@contextmanager
+def get_connection(path: str = DB_PATH) -> Generator[sqlite3.Connection, None, None]:
+    """Yield a database connection, committing on success and rolling back on error."""
+    conn = sqlite3.connect(path)
+    try:
+        yield conn
+        conn.commit()
+    except Exception:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+
+def execute_query(
+    sql: str,
+    params: tuple = (),
+    path: str = DB_PATH,
+) -> list[dict[str, Any]]:
+    """Run a SELECT query and return rows as dicts — connection closed automatically."""
+    with get_connection(path) as conn:
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+        cursor.execute(sql, params)
+        return [dict(row) for row in cursor.fetchall()]
+
+
+def execute_write(
+    sql: str,
+    params: tuple = (),
+    path: str = DB_PATH,
+) -> int:
+    """Execute an INSERT/UPDATE/DELETE and return the number of affected rows."""
+    with get_connection(path) as conn:
+        cursor = conn.cursor()
+        cursor.execute(sql, params)
+        return cursor.rowcount
+
+
+def export_to_csv(
+    sql: str,
+    output_path: str,
+    path: str = DB_PATH,
+) -> int:
+    """Export query results to a CSV file using context managers for both resources."""
+    import csv
+    rows = execute_query(sql, path=path)
+    if not rows:
+        return 0
+
+    with open(output_path, "w", newline="", encoding="utf-8") as csv_file:
+        writer = csv.DictWriter(csv_file, fieldnames=rows[0].keys())
+        writer.writeheader()
+        writer.writerows(rows)
+
+    return len(rows)
diff --git a/priv/combined_metrics/samples/code_smells/uses_copied_on_copy_types/bad/metrics.rs b/priv/combined_metrics/samples/code_smells/uses_copied_on_copy_types/bad/metrics.rs
new file mode 100644
index 0000000..72a44f8
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_copied_on_copy_types/bad/metrics.rs
@@ -0,0 +1,48 @@
+pub struct MetricSeries {
+    pub timestamps: Vec<u64>,
+    pub values: Vec<f64>,
+}
+
+impl MetricSeries {
+    pub fn new(timestamps: Vec<u64>, values: Vec<f64>) -> Self {
+        Self { timestamps, values }
+    }
+
+    // Bad: .cloned() on u64 — u64 is Copy, .copied() is the right choice
+    pub fn recent_timestamps(&self, n: usize) -> Vec<u64> {
+        self.timestamps
+            .iter()
+            .rev()
+            .take(n)
+            .cloned()
+            .collect()
+    }
+
+    // Bad: .cloned() on f64 — misleadingly suggests Clone behavior
+    pub fn max_value(&self) -> Option<f64> {
+        self.values.iter().cloned().reduce(f64::max)
+    }
+
+    pub fn values_above(&self, threshold: f64) -> Vec<f64> {
+        self.values
+            .iter()
+            .cloned()
+            .filter(|&v| v > threshold)
+            .collect()
+    }
+
+    pub fn timestamp_range(&self) -> Option<(u64, u64)> {
+        // Bad: .cloned() on a Copy type throughout
+        let min = self.timestamps.iter().cloned().min()?;
+        let max = self.timestamps.iter().cloned().max()?;
+        Some((min, max))
+    }
+
+    // Bad: .cloned() on i32 — i32 implements Copy, not just Clone
+    pub fn count_ids_above(ids: &[i32], threshold: i32) -> Vec<i32> {
+        ids.iter()
+            .cloned()
+            .filter(|&id| id > threshold)
+            .collect()
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_copied_on_copy_types/good/metrics.rs b/priv/combined_metrics/samples/code_smells/uses_copied_on_copy_types/good/metrics.rs
new file mode 100644
index 0000000..f77af03
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_copied_on_copy_types/good/metrics.rs
@@ -0,0 +1,47 @@
+pub struct MetricSeries {
+    pub timestamps: Vec<u64>,
+    pub values: Vec<f64>,
+}
+
+impl MetricSeries {
+    pub fn new(timestamps: Vec<u64>, values: Vec<f64>) -> Self {
+        Self { timestamps, values }
+    }
+
+    // u64 is Copy — use .copied() to avoid the misleading suggestion of Clone
+    pub fn recent_timestamps(&self, n: usize) -> Vec<u64> {
+        self.timestamps
+            .iter()
+            .rev()
+            .take(n)
+            .copied()
+            .collect()
+    }
+
+    // f64 is Copy — .copied() is correct and clear
+    pub fn max_value(&self) -> Option<f64> {
+        self.values.iter().copied().reduce(f64::max)
+    }
+
+    pub fn values_above(&self, threshold: f64) -> Vec<f64> {
+        self.values
+            .iter()
+            .copied()
+            .filter(|&v| v > threshold)
+            .collect()
+    }
+
+    pub fn timestamp_range(&self) -> Option<(u64, u64)> {
+        let min = self.timestamps.iter().copied().min()?;
+        let max = self.timestamps.iter().copied().max()?;
+        Some((min, max))
+    }
+
+    // i32 is Copy — .copied() communicates intent clearly
+    pub fn count_ids_above(ids: &[i32], threshold: i32) -> Vec<i32> {
+        ids.iter()
+            .copied()
+            .filter(|&id| id > threshold)
+            .collect()
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_mb_string_functions_for_unicode/bad/ProductCatalog.php b/priv/combined_metrics/samples/code_smells/uses_mb_string_functions_for_unicode/bad/ProductCatalog.php
new file mode 100644
index 0000000..80ae1f6
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_mb_string_functions_for_unicode/bad/ProductCatalog.php
@@ -0,0 +1,62 @@
+<?php
+
+namespace App\Catalog;
+
+class ProductCatalog
+{
+    private const MAX_SLUG_LENGTH = 100;
+    private const MAX_EXCERPT_LENGTH = 160;
+
+    public function slugify(string $name): string
+    {
+        // strtolower breaks on multibyte characters (e.g., "Ü" becomes "ü" incorrectly or corrupts)
+        $lower = strtolower($name);
+
+        $slug = preg_replace('/[^a-z0-9]+/', '-', $lower);
+        $slug = trim($slug, '-');
+
+        // substr splits in the middle of multibyte sequences — corrupts non-ASCII characters
+        return substr($slug, 0, self::MAX_SLUG_LENGTH);
+    }
+
+    public function truncateDescription(string $description): string
+    {
+        // strlen counts bytes, not characters — wrong for UTF-8
+        if (strlen($description) <= self::MAX_EXCERPT_LENGTH) {
+            return $description;
+        }
+
+        // substr may cut a multibyte character in half, producing invalid UTF-8
+        $truncated = substr($description, 0, self::MAX_EXCERPT_LENGTH - 3);
+
+        return rtrim($truncated) . '...';
+    }
+
+    public function normalizeTitle(string $title): string
+    {
+        // ucwords only handles ASCII — leaves accented first letters lowercase
+        return ucwords(strtolower($title));
+    }
+
+    public function searchByName(array $products, string $query): array
+    {
+        $lowerQuery = strtolower($query);
+
+        return array_filter($products, function (array $product) use ($lowerQuery): bool {
+            // strpos is byte-based — misses matches for multibyte characters
+            return strpos(strtolower($product['name']), $lowerQuery) !== false;
+        });
+    }
+
+    public function countCharacters(string $text): int
+    {
+        // strlen returns byte count, not character count for multibyte strings
+        return strlen($text);
+    }
+
+    public function getFirstCharacter(string $text): string
+    {
+        // $text[0] returns first byte, not first character — corrupts multibyte chars
+        return $text[0];
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_mb_string_functions_for_unicode/good/ProductCatalog.php b/priv/combined_metrics/samples/code_smells/uses_mb_string_functions_for_unicode/good/ProductCatalog.php
new file mode 100644
index 0000000..400f15d
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_mb_string_functions_for_unicode/good/ProductCatalog.php
@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Catalog;
+
+class ProductCatalog
+{
+    private const MAX_SLUG_LENGTH = 100;
+    private const MAX_EXCERPT_LENGTH = 160;
+
+    public function slugify(string $name): string
+    {
+        // mb_strtolower handles multibyte characters correctly
+        $lower = mb_strtolower($name, 'UTF-8');
+
+        // Transliterate accented characters
+        $ascii = transliterator_transliterate('Any-Latin; Latin-ASCII', $lower);
+
+        // Replace non-alphanumeric characters with hyphens
+        $slug = preg_replace('/[^a-z0-9]+/', '-', $ascii);
+        $slug = trim($slug, '-');
+
+        return mb_substr($slug, 0, self::MAX_SLUG_LENGTH, 'UTF-8');
+    }
+
+    public function truncateDescription(string $description): string
+    {
+        if (mb_strlen($description, 'UTF-8') <= self::MAX_EXCERPT_LENGTH) {
+            return $description;
+        }
+
+        // mb_substr preserves multibyte characters — does not split code points
+        $truncated = mb_substr($description, 0, self::MAX_EXCERPT_LENGTH - 3, 'UTF-8');
+
+        return rtrim($truncated) . '...';
+    }
+
+    public function normalizeTitle(string $title): string
+    {
+        // mb_convert_case for proper Unicode title casing
+        return mb_convert_case(mb_strtolower($title, 'UTF-8'), MB_CASE_TITLE, 'UTF-8');
+    }
+
+    public function searchByName(array $products, string $query): array
+    {
+        $lowerQuery = mb_strtolower($query, 'UTF-8');
+
+        return array_filter($products, function (array $product) use ($lowerQuery): bool {
+            // mb_strpos for multibyte-safe substring search
+            return mb_strpos(mb_strtolower($product['name'], 'UTF-8'), $lowerQuery, 0, 'UTF-8') !== false;
+        });
+    }
+
+    public function countCharacters(string $text): int
+    {
+        // mb_strlen counts characters, not bytes
+        return mb_strlen($text, 'UTF-8');
+    }
+
+    public function padProductCode(string $code, int $length): string
+    {
+        // mb_str_pad handles multibyte padding correctly (PHP 8.3+)
+        return str_pad($code, $length, '0', STR_PAD_LEFT);
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_optionals_not_sentinel_values/bad/UserProfile.swift b/priv/combined_metrics/samples/code_smells/uses_optionals_not_sentinel_values/bad/UserProfile.swift
new file mode 100644
index 0000000..27512b6
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_optionals_not_sentinel_values/bad/UserProfile.swift
@@ -0,0 +1,60 @@
+import Foundation
+
+struct Address {
+    let street: String
+    let city: String
+    let postalCode: String
+    let country: String
+}
+
+struct UserProfile {
+    let id: String
+    var displayName: String
+    var email: String
+    // Sentinel: -1 means "not provided" instead of using Int?
+    var age: Int = -1
+    // Sentinel: "" means "not provided" instead of using String?
+    var phoneNumber: String = ""
+    // Sentinel: "" means no bio
+    var bio: String = ""
+    // Sentinel: 0.0/0.0 means no location instead of using optional struct
+    var latitude: Double = 0.0
+    var longitude: Double = 0.0
+    // Sentinel: -1 means "not enrolled" instead of Int?
+    var loyaltyPoints: Int = -1
+    // Sentinel: .distantPast means "never logged in" instead of Date?
+    var lastLoginDate: Date = .distantPast
+
+    var isPhoneVerified: Bool = false
+    var isPremiumMember: Bool = false
+
+    func formattedAge() -> String {
+        // Magic number check instead of nil check
+        if age == -1 {
+            return "Age not provided"
+        }
+        return "\(age) years old"
+    }
+
+    func contactSummary() -> String {
+        var parts: [String] = [email]
+        // Empty string check instead of nil check
+        if !phoneNumber.isEmpty {
+            parts.append(phoneNumber)
+        }
+        return parts.joined(separator: " | ")
+    }
+
+    func loyaltySummary() -> String {
+        // Magic number check throughout codebase
+        if loyaltyPoints == -1 {
+            return "Not enrolled in loyalty program"
+        }
+        return "\(loyaltyPoints) points"
+    }
+
+    func hasLocation() -> Bool {
+        // Magic value comparison: 0/0 is technically a real coordinate
+        return latitude != 0.0 || longitude != 0.0
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_optionals_not_sentinel_values/good/UserProfile.swift b/priv/combined_metrics/samples/code_smells/uses_optionals_not_sentinel_values/good/UserProfile.swift
new file mode 100644
index 0000000..9215e6a
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_optionals_not_sentinel_values/good/UserProfile.swift
@@ -0,0 +1,57 @@
+import Foundation
+
+struct Address {
+    let street: String
+    let city: String
+    let postalCode: String
+    let country: String
+}
+
+struct UserProfile {
+    let id: String
+    var displayName: String
+    var email: String
+    var age: Int?
+    var phoneNumber: String?
+    var bio: String?
+    var address: Address?
+    var loyaltyPoints: Int?
+    var lastLoginDate: Date?
+
+    var isPhoneVerified: Bool
+    var isPremiumMember: Bool
+
+    func formattedAge() -> String {
+        guard let age = age else {
+            return "Age not provided"
+        }
+        return "\(age) years old"
+    }
+
+    func contactSummary() -> String {
+        var parts: [String] = [email]
+        if let phone = phoneNumber {
+            parts.append(phone)
+        }
+        return parts.joined(separator: " | ")
+    }
+
+    func loyaltySummary() -> String {
+        guard let points = loyaltyPoints else {
+            return "Not enrolled in loyalty program"
+        }
+        return "\(points) points"
+    }
+}
+
+class UserProfileRepository {
+    private var profiles: [String: UserProfile] = [:]
+
+    func profile(for userID: String) -> UserProfile? {
+        return profiles[userID]
+    }
+
+    func update(_ profile: UserProfile) {
+        profiles[profile.id] = profile
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_recover_in_long_running_goroutines/bad/server.go b/priv/combined_metrics/samples/code_smells/uses_recover_in_long_running_goroutines/bad/server.go
new file mode 100644
index 0000000..0b451f7
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_recover_in_long_running_goroutines/bad/server.go
@@ -0,0 +1,46 @@
+package server
+
+import (
+	"context"
+	"log"
+)
+
+type Task struct {
+	ID      string
+	Payload string
+}
+
+type Executor interface {
+	Execute(ctx context.Context, task Task) error
+}
+
+// TaskServer runs tasks continuously but does not recover from panics.
+// A single panic in Execute will crash the entire process.
+type TaskServer struct {
+	executor Executor
+	tasks    <-chan Task
+	logger   *log.Logger
+}
+
+func New(executor Executor, tasks <-chan Task, logger *log.Logger) *TaskServer {
+	return &TaskServer{executor: executor, tasks: tasks, logger: logger}
+}
+
+// Run starts the task processing loop with no panic recovery.
+func (s *TaskServer) Run(ctx context.Context) {
+	for {
+		select {
+		case <-ctx.Done():
+			s.logger.Println("task server shutting down")
+			return
+		case task, ok := <-s.tasks:
+			if !ok {
+				return
+			}
+			// No recover — a panic inside Execute terminates the process.
+			if err := s.executor.Execute(ctx, task); err != nil {
+				s.logger.Printf("task %s failed: %v", task.ID, err)
+			}
+		}
+	}
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_recover_in_long_running_goroutines/good/server.go b/priv/combined_metrics/samples/code_smells/uses_recover_in_long_running_goroutines/good/server.go
new file mode 100644
index 0000000..acd60f4
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_recover_in_long_running_goroutines/good/server.go
@@ -0,0 +1,58 @@
+package server
+
+import (
+	"context"
+	"log"
+	"time"
+)
+
+type Task struct {
+	ID      string
+	Payload string
+}
+
+type Executor interface {
+	Execute(ctx context.Context, task Task) error
+}
+
+// TaskServer runs tasks continuously and recovers from panics so the process stays alive.
+type TaskServer struct {
+	executor Executor
+	tasks    <-chan Task
+	logger   *log.Logger
+}
+
+func New(executor Executor, tasks <-chan Task, logger *log.Logger) *TaskServer {
+	return &TaskServer{executor: executor, tasks: tasks, logger: logger}
+}
+
+// Run starts the task processing loop. It recovers from panics within each iteration.
+func (s *TaskServer) Run(ctx context.Context) {
+	for {
+		select {
+		case <-ctx.Done():
+			s.logger.Println("task server shutting down")
+			return
+		case task, ok := <-s.tasks:
+			if !ok {
+				return
+			}
+			s.processWithRecover(ctx, task)
+		}
+	}
+}
+
+// processWithRecover wraps task execution in a deferred recover so a panic in
+// Execute cannot crash the entire server process.
+func (s *TaskServer) processWithRecover(ctx context.Context, task Task) {
+	defer func() {
+		if r := recover(); r != nil {
+			s.logger.Printf("panic processing task %s: %v — continuing", task.ID, r)
+			time.Sleep(100 * time.Millisecond) // brief back-off after panic
+		}
+	}()
+
+	if err := s.executor.Execute(ctx, task); err != nil {
+		s.logger.Printf("task %s failed: %v", task.ID, err)
+	}
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_short_circuit_operators/bad/AccessPolicy.cs b/priv/combined_metrics/samples/code_smells/uses_short_circuit_operators/bad/AccessPolicy.cs
new file mode 100644
index 0000000..3b77421
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_short_circuit_operators/bad/AccessPolicy.cs
@@ -0,0 +1,56 @@
+using System;
+
+namespace Security
+{
+    public class AccessPolicy
+    {
+        public bool CanReadDocument(User user, Document document)
+        {
+            // Non-short-circuit & evaluates both sides even if user is null → NullReferenceException
+            return user != null & document != null
+                & (user.IsAdmin | document.OwnerId == user.Id | user.HasRole("reader"));
+        }
+
+        public bool CanEditDocument(User user, Document document)
+        {
+            if (user == null | document == null) // | does not short-circuit
+                return false;
+
+            // | evaluates both sides; IsLocked check runs even when OwnerId doesn't match
+            return user.IsAdmin | (document.OwnerId == user.Id & !document.IsLocked);
+        }
+
+        public bool ShouldSendAlert(SystemMetrics metrics)
+        {
+            // Non-short-circuit & can throw if metrics is null
+            return metrics != null
+                & (metrics.CpuUsage > 90.0 | metrics.MemoryUsage > 85.0)
+                & metrics.AlertsEnabled;
+        }
+
+        public string ResolveDisplayName(User user)
+        {
+            // Non-short-circuit & evaluates IsNullOrWhiteSpace even when user is null
+            return user != null & !string.IsNullOrWhiteSpace(user.DisplayName)
+                ? user.DisplayName
+                : "Anonymous";
+        }
+
+        public bool IsValidRequest(ApiRequest request)
+        {
+            // All conditions evaluated regardless; throws if request is null
+            return request != null
+                & !string.IsNullOrWhiteSpace(request.ApiKey)
+                & request.Timestamp > DateTimeOffset.UtcNow.AddMinutes(-5)
+                & request.Payload?.Length <= 1_048_576;
+        }
+
+        public bool ShouldRetry(HttpResponse response, int attempt)
+        {
+            // Non-short-circuit | evaluates status codes even when response is null
+            return response != null
+                & attempt < 3
+                & (response.StatusCode == 429 | response.StatusCode >= 500);
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_short_circuit_operators/good/AccessPolicy.cs b/priv/combined_metrics/samples/code_smells/uses_short_circuit_operators/good/AccessPolicy.cs
new file mode 100644
index 0000000..1c5b6ea
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_short_circuit_operators/good/AccessPolicy.cs
@@ -0,0 +1,54 @@
+using System;
+
+namespace Security
+{
+    public class AccessPolicy
+    {
+        public bool CanReadDocument(User user, Document document)
+        {
+            // Short-circuit: if user is null, the rest is never evaluated
+            return user != null && document != null
+                && (user.IsAdmin || document.OwnerId == user.Id || user.HasRole("reader"));
+        }
+
+        public bool CanEditDocument(User user, Document document)
+        {
+            if (user == null || document == null)
+                return false;
+
+            // Short-circuit: IsAdmin check avoids evaluating the more expensive checks
+            return user.IsAdmin || (document.OwnerId == user.Id && !document.IsLocked);
+        }
+
+        public bool ShouldSendAlert(SystemMetrics metrics)
+        {
+            // Short-circuit: if metrics is null, subsequent property access is skipped
+            return metrics != null
+                && (metrics.CpuUsage > 90.0 || metrics.MemoryUsage > 85.0)
+                && metrics.AlertsEnabled;
+        }
+
+        public string ResolveDisplayName(User user)
+        {
+            // Short-circuit null coalescing with && guards
+            return user != null && !string.IsNullOrWhiteSpace(user.DisplayName)
+                ? user.DisplayName
+                : "Anonymous";
+        }
+
+        public bool IsValidRequest(ApiRequest request)
+        {
+            return request != null
+                && !string.IsNullOrWhiteSpace(request.ApiKey)
+                && request.Timestamp > DateTimeOffset.UtcNow.AddMinutes(-5)
+                && request.Payload?.Length <= 1_048_576;
+        }
+
+        public bool ShouldRetry(HttpResponse response, int attempt)
+        {
+            return response != null
+                && attempt < 3
+                && (response.StatusCode == 429 || response.StatusCode >= 500);
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_smart_pointers_for_ownership/bad/Buffer.cpp b/priv/combined_metrics/samples/code_smells/uses_smart_pointers_for_ownership/bad/Buffer.cpp
new file mode 100644
index 0000000..d1ee596
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_smart_pointers_for_ownership/bad/Buffer.cpp
@@ -0,0 +1,77 @@
+#include <cstdint>
+#include <cstring>
+#include <stdexcept>
+#include <vector>
+#include <string>
+
+class Buffer {
+public:
+    explicit Buffer(std::size_t capacity)
+        : capacity_(capacity)
+        , size_(0)
+    {
+        // Raw owning pointer — must be manually deleted; leaks on exception
+        data_ = new uint8_t[capacity];
+    }
+
+    ~Buffer() {
+        delete[] data_; // relies on correct destructor call; no RAII safety
+    }
+
+    // Copy constructor not implemented — double-free if copied
+    Buffer(const Buffer&) = delete;
+    Buffer& operator=(const Buffer&) = delete;
+
+    void write(const uint8_t* src, std::size_t length) {
+        if (size_ + length > capacity_)
+            throw std::overflow_error("Buffer capacity exceeded");
+        std::memcpy(data_ + size_, src, length);
+        size_ += length;
+    }
+
+    std::size_t read(uint8_t* dst, std::size_t maxLength) const {
+        std::size_t toRead = std::min(maxLength, size_);
+        std::memcpy(dst, data_, toRead);
+        return toRead;
+    }
+
+    void clear() { size_ = 0; }
+    std::size_t size() const { return size_; }
+
+private:
+    uint8_t* data_; // raw owning pointer — manual memory management
+    std::size_t capacity_;
+    std::size_t size_;
+};
+
+class BufferPool {
+public:
+    explicit BufferPool(std::size_t bufferSize, std::size_t poolSize)
+        : bufferSize_(bufferSize)
+    {
+        for (std::size_t i = 0; i < poolSize; ++i)
+            available_.push_back(new Buffer(bufferSize)); // raw owning pointers in vector
+    }
+
+    ~BufferPool() {
+        for (auto* buf : available_)
+            delete buf; // manual cleanup; leaks if exception thrown before this
+    }
+
+    Buffer* acquire() {
+        if (available_.empty())
+            return new Buffer(bufferSize_); // caller must delete — ownership unclear
+        Buffer* buf = available_.back();
+        available_.pop_back();
+        return buf;
+    }
+
+    void release(Buffer* buf) {
+        buf->clear();
+        available_.push_back(buf);
+    }
+
+private:
+    std::size_t bufferSize_;
+    std::vector<Buffer*> available_; // vector of raw owning pointers
+};
diff --git a/priv/combined_metrics/samples/code_smells/uses_smart_pointers_for_ownership/good/Buffer.cpp b/priv/combined_metrics/samples/code_smells/uses_smart_pointers_for_ownership/good/Buffer.cpp
new file mode 100644
index 0000000..7dd829d
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_smart_pointers_for_ownership/good/Buffer.cpp
@@ -0,0 +1,63 @@
+#include <cstdint>
+#include <memory>
+#include <stdexcept>
+#include <vector>
+#include <string>
+
+class Buffer {
+public:
+    explicit Buffer(std::size_t capacity)
+        : data_(std::make_unique<uint8_t[]>(capacity))
+        , capacity_(capacity)
+        , size_(0)
+    {}
+
+    void write(const uint8_t* src, std::size_t length) {
+        if (size_ + length > capacity_)
+            throw std::overflow_error("Buffer capacity exceeded");
+        std::copy(src, src + length, data_.get() + size_);
+        size_ += length;
+    }
+
+    std::size_t read(uint8_t* dst, std::size_t maxLength) const {
+        std::size_t toRead = std::min(maxLength, size_);
+        std::copy(data_.get(), data_.get() + toRead, dst);
+        return toRead;
+    }
+
+    void clear() noexcept { size_ = 0; }
+    std::size_t size() const noexcept { return size_; }
+    std::size_t capacity() const noexcept { return capacity_; }
+
+private:
+    std::unique_ptr<uint8_t[]> data_; // ownership is explicit and automatic
+    std::size_t capacity_;
+    std::size_t size_;
+};
+
+class BufferPool {
+public:
+    explicit BufferPool(std::size_t bufferSize, std::size_t poolSize)
+        : bufferSize_(bufferSize)
+    {
+        for (std::size_t i = 0; i < poolSize; ++i)
+            available_.push_back(std::make_unique<Buffer>(bufferSize));
+    }
+
+    std::unique_ptr<Buffer> acquire() {
+        if (available_.empty())
+            return std::make_unique<Buffer>(bufferSize_);
+        auto buf = std::move(available_.back());
+        available_.pop_back();
+        return buf;
+    }
+
+    void release(std::unique_ptr<Buffer> buf) {
+        buf->clear();
+        available_.push_back(std::move(buf));
+    }
+
+private:
+    std::size_t bufferSize_;
+    std::vector<std::unique_ptr<Buffer>> available_;
+};
diff --git a/priv/combined_metrics/samples/code_smells/uses_standard_library_constants/bad/geometry.rs b/priv/combined_metrics/samples/code_smells/uses_standard_library_constants/bad/geometry.rs
new file mode 100644
index 0000000..22f144e
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_standard_library_constants/bad/geometry.rs
@@ -0,0 +1,51 @@
+#[derive(Debug, Clone, Copy)]
+pub struct Circle {
+    pub radius: f64,
+}
+
+impl Circle {
+    pub fn new(radius: f64) -> Self {
+        Self { radius }
+    }
+
+    pub fn area(&self) -> f64 {
+        // BAD: hardcoded approximation — less precise than std::f64::consts::PI
+        3.14159 * self.radius * self.radius
+    }
+
+    pub fn circumference(&self) -> f64 {
+        // BAD: 2 * pi approximated — differs from PI at the 6th decimal place
+        2.0 * 3.14159 * self.radius
+    }
+
+    pub fn inscribed_square_side(&self) -> f64 {
+        // BAD: sqrt(2) hardcoded — use std::f64::consts::SQRT_2
+        2.0 * self.radius / 1.41421
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Sector {
+    pub radius: f64,
+    pub angle: f64,
+}
+
+impl Sector {
+    pub fn area(&self) -> f64 {
+        0.5 * self.radius * self.radius * self.angle
+    }
+
+    pub fn from_degrees(radius: f64, degrees: f64) -> Self {
+        // BAD: magic constant instead of TAU or PI from std
+        Self { radius, angle: degrees * 6.28318 / 360.0 }
+    }
+}
+
+pub fn degrees_to_radians(degrees: f64) -> f64 {
+    // BAD: literal approximation of PI
+    degrees * 3.14159265 / 180.0
+}
+
+pub fn radians_to_degrees(radians: f64) -> f64 {
+    radians * 180.0 / 3.14159265
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_standard_library_constants/good/geometry.rs b/priv/combined_metrics/samples/code_smells/uses_standard_library_constants/good/geometry.rs
new file mode 100644
index 0000000..ca9790f
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_standard_library_constants/good/geometry.rs
@@ -0,0 +1,55 @@
+use std::f64::consts::{PI, SQRT_2, TAU};
+
+#[derive(Debug, Clone, Copy)]
+pub struct Circle {
+    pub radius: f64,
+}
+
+impl Circle {
+    pub fn new(radius: f64) -> Self {
+        Self { radius }
+    }
+
+    pub fn area(&self) -> f64 {
+        PI * self.radius * self.radius
+    }
+
+    pub fn circumference(&self) -> f64 {
+        TAU * self.radius
+    }
+
+    pub fn inscribed_square_diagonal(&self) -> f64 {
+        // Diameter * sqrt(2) / sqrt(2) == diameter, but demonstrates SQRT_2 usage
+        2.0 * self.radius / SQRT_2 * SQRT_2
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Sector {
+    pub radius: f64,
+    /// angle in radians
+    pub angle: f64,
+}
+
+impl Sector {
+    pub fn arc_length(&self) -> f64 {
+        self.radius * self.angle
+    }
+
+    pub fn area(&self) -> f64 {
+        0.5 * self.radius * self.radius * self.angle
+    }
+
+    pub fn from_degrees(radius: f64, degrees: f64) -> Self {
+        // TAU / 360.0 is exact; using PI * 2.0 / 360.0 would also work
+        Self { radius, angle: degrees * TAU / 360.0 }
+    }
+}
+
+pub fn degrees_to_radians(degrees: f64) -> f64 {
+    degrees * PI / 180.0
+}
+
+pub fn radians_to_degrees(radians: f64) -> f64 {
+    radians * 180.0 / PI
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_string_builder_for_loop_concatenation/bad/HtmlRenderer.cs b/priv/combined_metrics/samples/code_smells/uses_string_builder_for_loop_concatenation/bad/HtmlRenderer.cs
new file mode 100644
index 0000000..7164ee6
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_string_builder_for_loop_concatenation/bad/HtmlRenderer.cs
@@ -0,0 +1,61 @@
+using System.Collections.Generic;
+
+namespace Rendering
+{
+    public class HtmlRenderer
+    {
+        public string RenderTable(IEnumerable<TableRow> rows)
+        {
+            // String concatenation in loops creates a new string object on every iteration
+            string html = "<table>\n  <tbody>\n";
+
+            foreach (var row in rows)
+            {
+                html += "    <tr>";
+                foreach (var cell in row.Cells)
+                {
+                    html += "<td>" + Escape(cell) + "</td>"; // O(n²) allocations
+                }
+                html += "</tr>\n";
+            }
+
+            html += "  </tbody>\n</table>\n";
+            return html;
+        }
+
+        public string RenderList(IEnumerable<string> items, string cssClass)
+        {
+            string html = "<ul";
+            if (!string.IsNullOrEmpty(cssClass))
+                html += " class=\"" + Escape(cssClass) + "\""; // another allocation
+            html += ">\n";
+
+            foreach (var item in items)
+            {
+                html += "  <li>" + Escape(item) + "</li>\n"; // new string every loop
+            }
+
+            html += "</ul>\n";
+            return html;
+        }
+
+        public string RenderReport(ReportData report)
+        {
+            string html = "<!DOCTYPE html>\n<html>\n<body>\n";
+            html += "<h1>" + Escape(report.Title) + "</h1>\n";
+
+            foreach (var section in report.Sections)
+            {
+                // Each += allocates a new string on the heap
+                html += "<h2>" + Escape(section.Heading) + "</h2>\n";
+                html += "<p>" + Escape(section.Body) + "</p>\n";
+            }
+
+            html += "</body>\n</html>\n";
+            return html;
+        }
+
+        private static string Escape(string text) =>
+            text?.Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;") ?? string.Empty;
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_string_builder_for_loop_concatenation/good/HtmlRenderer.cs b/priv/combined_metrics/samples/code_smells/uses_string_builder_for_loop_concatenation/good/HtmlRenderer.cs
new file mode 100644
index 0000000..b9d892a
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_string_builder_for_loop_concatenation/good/HtmlRenderer.cs
@@ -0,0 +1,72 @@
+using System.Collections.Generic;
+using System.Text;
+
+namespace Rendering
+{
+    public class HtmlRenderer
+    {
+        public string RenderTable(IEnumerable<TableRow> rows)
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine("<table>");
+            sb.AppendLine("  <tbody>");
+
+            foreach (var row in rows)
+            {
+                sb.Append("    <tr>");
+                foreach (var cell in row.Cells)
+                {
+                    sb.Append("<td>")
+                      .Append(Escape(cell))
+                      .Append("</td>");
+                }
+                sb.AppendLine("</tr>");
+            }
+
+            sb.AppendLine("  </tbody>");
+            sb.AppendLine("</table>");
+            return sb.ToString();
+        }
+
+        public string RenderList(IEnumerable<string> items, string cssClass)
+        {
+            var sb = new StringBuilder();
+            sb.Append("<ul");
+            if (!string.IsNullOrEmpty(cssClass))
+                sb.Append(" class=\"").Append(Escape(cssClass)).Append('"');
+            sb.AppendLine(">");
+
+            foreach (var item in items)
+            {
+                sb.Append("  <li>").Append(Escape(item)).AppendLine("</li>");
+            }
+
+            sb.AppendLine("</ul>");
+            return sb.ToString();
+        }
+
+        public string RenderReport(ReportData report)
+        {
+            var sb = new StringBuilder(capacity: 4096);
+            sb.AppendLine("<!DOCTYPE html>")
+              .AppendLine("<html>")
+              .AppendLine("<body>");
+
+            sb.Append("<h1>").Append(Escape(report.Title)).AppendLine("</h1>");
+
+            foreach (var section in report.Sections)
+            {
+                sb.Append("<h2>").Append(Escape(section.Heading)).AppendLine("</h2>");
+                sb.Append("<p>").Append(Escape(section.Body)).AppendLine("</p>");
+            }
+
+            sb.AppendLine("</body>")
+              .AppendLine("</html>");
+
+            return sb.ToString();
+        }
+
+        private static string Escape(string text) =>
+            text?.Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;") ?? string.Empty;
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_structured_concurrency/bad/DataSyncService.kt b/priv/combined_metrics/samples/code_smells/uses_structured_concurrency/bad/DataSyncService.kt
new file mode 100644
index 0000000..49db07d
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_structured_concurrency/bad/DataSyncService.kt
@@ -0,0 +1,47 @@
+package com.example.sync
+
+import kotlinx.coroutines.*
+
+class DataSyncService(
+    private val userRepository: UserRepository,
+    private val orderRepository: OrderRepository,
+    private val inventoryClient: InventoryClient
+) {
+
+    /**
+     * Launches coroutines using GlobalScope — they are not tied to any lifecycle.
+     * If the service is destroyed or the app shuts down, these coroutines keep running
+     * and cannot be cancelled as a group.
+     */
+    fun startPeriodicSync(): Job = GlobalScope.launch(Dispatchers.IO) {
+        while (isActive) {
+            syncAll()
+            delay(60_000)
+        }
+    }
+
+    /**
+     * Each task is launched into GlobalScope independently.
+     * There is no parent scope to cancel them together, and exceptions
+     * in one do not cancel the others.
+     */
+    suspend fun syncAll(): SyncReport {
+        val userJob = GlobalScope.async(Dispatchers.IO) { syncUsers() }
+        val orderJob = GlobalScope.async(Dispatchers.IO) { syncOrders() }
+        val inventoryJob = GlobalScope.async(Dispatchers.IO) { syncInventory() }
+
+        return SyncReport(
+            usersUpdated = userJob.await(),
+            ordersUpdated = orderJob.await(),
+            itemsUpdated = inventoryJob.await()
+        )
+    }
+
+    private suspend fun syncUsers(): Int = userRepository.fetchAndUpdate()
+    private suspend fun syncOrders(): Int = orderRepository.fetchAndUpdate()
+    private suspend fun syncInventory(): Int = inventoryClient.syncAll()
+
+    fun stop() {
+        // No-op — nothing to cancel because GlobalScope outlives everything
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_structured_concurrency/good/DataSyncService.kt b/priv/combined_metrics/samples/code_smells/uses_structured_concurrency/good/DataSyncService.kt
new file mode 100644
index 0000000..92cbb33
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_structured_concurrency/good/DataSyncService.kt
@@ -0,0 +1,49 @@
+package com.example.sync
+
+import kotlinx.coroutines.*
+
+class DataSyncService(
+    private val userRepository: UserRepository,
+    private val orderRepository: OrderRepository,
+    private val inventoryClient: InventoryClient
+) {
+
+    // Uses a defined CoroutineScope tied to the service lifecycle
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+
+    /**
+     * Launches a background sync job within the service scope.
+     * When the service is stopped, all child coroutines are cancelled via scope.cancel().
+     */
+    fun startPeriodicSync(): Job = scope.launch {
+        while (isActive) {
+            syncAll()
+            delay(60_000)
+        }
+    }
+
+    /**
+     * Runs all sync tasks concurrently within a single coroutine scope.
+     * All tasks are children of the caller's scope — cancellation propagates correctly.
+     */
+    suspend fun syncAll(): SyncReport = coroutineScope {
+        val userSync = async { syncUsers() }
+        val orderSync = async { syncOrders() }
+        val inventorySync = async { syncInventory() }
+
+        SyncReport(
+            usersUpdated = userSync.await(),
+            ordersUpdated = orderSync.await(),
+            itemsUpdated = inventorySync.await()
+        )
+    }
+
+    private suspend fun syncUsers(): Int = userRepository.fetchAndUpdate()
+    private suspend fun syncOrders(): Int = orderRepository.fetchAndUpdate()
+    private suspend fun syncInventory(): Int = inventoryClient.syncAll()
+
+    fun stop() {
+        // Cancels all coroutines launched in this scope
+        scope.cancel()
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_using_statement_for_disposables/bad/ReportExporter.cs b/priv/combined_metrics/samples/code_smells/uses_using_statement_for_disposables/bad/ReportExporter.cs
new file mode 100644
index 0000000..70fc219
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_using_statement_for_disposables/bad/ReportExporter.cs
@@ -0,0 +1,81 @@
+using System;
+using System.Data.SqlClient;
+using System.IO;
+using System.Text;
+
+namespace Reporting
+{
+    public class ReportExporter
+    {
+        private readonly string _connectionString;
+
+        public ReportExporter(string connectionString)
+        {
+            _connectionString = connectionString;
+        }
+
+        public void ExportToFile(string reportName, string outputPath)
+        {
+            // Manual resource management — Dispose never called if an exception occurs
+            var connection = new SqlConnection(_connectionString);
+            connection.Open();
+
+            var command = new SqlCommand(
+                "SELECT * FROM Reports WHERE Name = @name", connection);
+            command.Parameters.AddWithValue("@name", reportName);
+
+            var reader = command.ExecuteReader();
+            var writer = new StreamWriter(outputPath, append: false, Encoding.UTF8);
+
+            writer.WriteLine($"Report: {reportName}");
+            writer.WriteLine(new string('-', 40));
+
+            while (reader.Read())
+            {
+                writer.WriteLine(
+                    $"{reader["Date"]:yyyy-MM-dd} | {reader["Value"]:N2}");
+            }
+
+            // These Dispose calls are never reached if an exception is thrown above
+            reader.Dispose();
+            command.Dispose();
+            writer.Dispose();
+            connection.Dispose();
+        }
+
+        public byte[] ExportToBytes(int reportId)
+        {
+            var memoryStream = new MemoryStream();
+            var writer = new StreamWriter(memoryStream, Encoding.UTF8);
+
+            var connection = new SqlConnection(_connectionString);
+            connection.Open();
+
+            var command = new SqlCommand(
+                "SELECT * FROM ReportRows WHERE ReportId = @id ORDER BY RowIndex", connection);
+            command.Parameters.AddWithValue("@id", reportId);
+
+            var reader = command.ExecuteReader();
+            while (reader.Read())
+                writer.WriteLine(reader["Content"].ToString());
+
+            writer.Flush();
+            var result = memoryStream.ToArray();
+
+            // Missing dispose calls on reader, command, connection
+            writer.Dispose();
+            memoryStream.Dispose();
+
+            return result;
+        }
+
+        public void CopyReport(string sourcePath, string destinationPath)
+        {
+            var source = new FileStream(sourcePath, FileMode.Open, FileAccess.Read);
+            var destination = new FileStream(destinationPath, FileMode.Create, FileAccess.Write);
+            source.CopyTo(destination);
+            source.Dispose();
+            destination.Dispose(); // not reached if CopyTo throws
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/code_smells/uses_using_statement_for_disposables/good/ReportExporter.cs b/priv/combined_metrics/samples/code_smells/uses_using_statement_for_disposables/good/ReportExporter.cs
new file mode 100644
index 0000000..5ac04ac
--- /dev/null
+++ b/priv/combined_metrics/samples/code_smells/uses_using_statement_for_disposables/good/ReportExporter.cs
@@ -0,0 +1,66 @@
+using System;
+using System.Data.SqlClient;
+using System.IO;
+using System.Text;
+
+namespace Reporting
+{
+    public class ReportExporter
+    {
+        private readonly string _connectionString;
+
+        public ReportExporter(string connectionString)
+        {
+            _connectionString = connectionString;
+        }
+
+        public void ExportToFile(string reportName, string outputPath)
+        {
+            using var connection = new SqlConnection(_connectionString);
+            connection.Open();
+
+            using var command = new SqlCommand(
+                "SELECT * FROM Reports WHERE Name = @name", connection);
+            command.Parameters.AddWithValue("@name", reportName);
+
+            using var reader = command.ExecuteReader();
+            using var writer = new StreamWriter(outputPath, append: false, Encoding.UTF8);
+
+            writer.WriteLine($"Report: {reportName}");
+            writer.WriteLine(new string('-', 40));
+
+            while (reader.Read())
+            {
+                writer.WriteLine(
+                    $"{reader["Date"]:yyyy-MM-dd} | {reader["Value"]:N2}");
+            }
+        }
+
+        public byte[] ExportToBytes(int reportId)
+        {
+            using var memoryStream = new MemoryStream();
+            using var writer = new StreamWriter(memoryStream, Encoding.UTF8, leaveOpen: true);
+
+            using var connection = new SqlConnection(_connectionString);
+            connection.Open();
+
+            using var command = new SqlCommand(
+                "SELECT * FROM ReportRows WHERE ReportId = @id ORDER BY RowIndex", connection);
+            command.Parameters.AddWithValue("@id", reportId);
+
+            using var reader = command.ExecuteReader();
+            while (reader.Read())
+                writer.WriteLine(reader["Content"].ToString());
+
+            writer.Flush();
+            return memoryStream.ToArray();
+        }
+
+        public void CopyReport(string sourcePath, string destinationPath)
+        {
+            using var source = new FileStream(sourcePath, FileMode.Open, FileAccess.Read);
+            using var destination = new FileStream(destinationPath, FileMode.Create, FileAccess.Write);
+            source.CopyTo(destination);
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/consistency/all_methods_declare_visibility/bad/PaymentGateway.php b/priv/combined_metrics/samples/consistency/all_methods_declare_visibility/bad/PaymentGateway.php
new file mode 100644
index 0000000..e72c4f2
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/all_methods_declare_visibility/bad/PaymentGateway.php
@@ -0,0 +1,70 @@
+<?php
+
+namespace App\Payment;
+
+class PaymentGateway
+{
+    private $apiKey;
+    private $baseUrl;
+    private $requestCount = 0;
+
+    public function __construct($apiKey, $baseUrl)
+    {
+        $this->apiKey = $apiKey;
+        $this->baseUrl = $baseUrl;
+    }
+
+    // Missing visibility — defaults to public implicitly in PHP, but PSR-12 requires explicit declaration
+    function charge($amountCents, $token)
+    {
+        $this->requestCount++;
+        return $this->post('/v1/charges', ['amount' => $amountCents, 'source' => $token]);
+    }
+
+    // Missing visibility
+    function refund($transactionId, $amountCents)
+    {
+        $this->requestCount++;
+        return $this->post('/v1/refunds', ['transaction_id' => $transactionId, 'amount' => $amountCents]);
+    }
+
+    public function getRequestCount()
+    {
+        return $this->requestCount;
+    }
+
+    // Missing visibility on static method
+    static function getTotalRequests()
+    {
+        return 0;
+    }
+
+    // Missing visibility
+    function buildHeaders()
+    {
+        return [
+            'Authorization' => "Bearer {$this->apiKey}",
+            'Content-Type'  => 'application/json',
+        ];
+    }
+
+    // Missing visibility on private method
+    function post($path, $payload)
+    {
+        return [];
+    }
+
+    // Missing visibility
+    function buildUrl($path)
+    {
+        return rtrim($this->baseUrl, '/') . $path;
+    }
+
+    // Missing visibility on abstract-style helper
+    function validateAmount($amountCents)
+    {
+        if ($amountCents <= 0) {
+            throw new \InvalidArgumentException("Amount must be positive");
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/consistency/all_methods_declare_visibility/good/PaymentGateway.php b/priv/combined_metrics/samples/consistency/all_methods_declare_visibility/good/PaymentGateway.php
new file mode 100644
index 0000000..a90368d
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/all_methods_declare_visibility/good/PaymentGateway.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Payment;
+
+// All methods explicitly declare visibility — PSR-12
+class PaymentGateway
+{
+    private string $apiKey;
+    private string $baseUrl;
+    private int $requestCount = 0;
+    private static int $totalRequests = 0;
+
+    public function __construct(string $apiKey, string $baseUrl)
+    {
+        $this->apiKey = $apiKey;
+        $this->baseUrl = $baseUrl;
+    }
+
+    public function charge(int $amountCents, string $token): array
+    {
+        $this->requestCount++;
+        self::$totalRequests++;
+
+        return $this->post('/v1/charges', ['amount' => $amountCents, 'source' => $token]);
+    }
+
+    public function refund(string $transactionId, int $amountCents): array
+    {
+        $this->requestCount++;
+        self::$totalRequests++;
+
+        return $this->post('/v1/refunds', ['transaction_id' => $transactionId, 'amount' => $amountCents]);
+    }
+
+    public function getRequestCount(): int
+    {
+        return $this->requestCount;
+    }
+
+    public static function getTotalRequests(): int
+    {
+        return self::$totalRequests;
+    }
+
+    protected function buildHeaders(): array
+    {
+        return [
+            'Authorization' => "Bearer {$this->apiKey}",
+            'Content-Type'  => 'application/json',
+        ];
+    }
+
+    private function post(string $path, array $payload): array
+    {
+        $url = $this->buildUrl($path);
+        // HTTP client logic
+        return [];
+    }
+
+    private function buildUrl(string $path): string
+    {
+        return rtrim($this->baseUrl, '/') . $path;
+    }
+
+    private function validateAmount(int $amountCents): void
+    {
+        if ($amountCents <= 0) {
+            throw new \InvalidArgumentException("Amount must be positive: {$amountCents}");
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/consistency/all_properties_declare_visibility/bad/OrderService.php b/priv/combined_metrics/samples/consistency/all_properties_declare_visibility/bad/OrderService.php
new file mode 100644
index 0000000..fc0fe00
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/all_properties_declare_visibility/bad/OrderService.php
@@ -0,0 +1,70 @@
+<?php
+
+namespace App\Service;
+
+class OrderService
+{
+    // Missing visibility on several properties — PSR-12 violation
+    $orderRepository;          // no visibility modifier
+    $paymentService;           // no visibility modifier
+    $notificationService;      // no visibility modifier
+
+    // Some have visibility, some don't — inconsistent
+    protected string $defaultCurrency = 'USD';
+    $auditEnabled = false;     // missing visibility
+
+    static $instanceCount = 0; // missing visibility on static property
+    const MAX_ITEMS_PER_ORDER = 50; // constants also lack visibility
+
+    public function __construct($orderRepository, $paymentService, $notificationService)
+    {
+        $this->orderRepository = $orderRepository;
+        $this->paymentService = $paymentService;
+        $this->notificationService = $notificationService;
+        self::$instanceCount++;
+    }
+
+    public function place($customerId, $items)
+    {
+        if (count($items) > self::MAX_ITEMS_PER_ORDER) {
+            throw new \InvalidArgumentException('Too many items');
+        }
+
+        $order = new \stdClass();
+        $order->customerId = $customerId;
+        $order->currency = $this->defaultCurrency;
+        $order->items = $items;
+
+        $this->orderRepository->save($order);
+
+        if ($this->auditEnabled) {
+            $this->logPlacement($order);
+        }
+
+        return $order;
+    }
+
+    public function cancel($orderId)
+    {
+        $order = $this->orderRepository->findById($orderId);
+
+        if ($order === null) {
+            return false;
+        }
+
+        $order->status = 'cancelled';
+        $this->orderRepository->save($order);
+
+        return true;
+    }
+
+    static function getInstanceCount()  // missing visibility on static method
+    {
+        return self::$instanceCount;
+    }
+
+    function logPlacement($order): void  // missing visibility on instance method
+    {
+        // audit logging
+    }
+}
diff --git a/priv/combined_metrics/samples/consistency/all_properties_declare_visibility/good/OrderService.php b/priv/combined_metrics/samples/consistency/all_properties_declare_visibility/good/OrderService.php
new file mode 100644
index 0000000..233468f
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/all_properties_declare_visibility/good/OrderService.php
@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+use App\Entity\Order;
+use App\Exception\OrderNotFoundException;
+
+class OrderService
+{
+    // All properties explicitly declare visibility
+    private OrderRepository $orderRepository;
+    private PaymentService $paymentService;
+    private NotificationService $notificationService;
+    protected string $defaultCurrency = 'USD';
+    public bool $auditEnabled = false;
+
+    private static int $instanceCount = 0;
+    private const int MAX_ITEMS_PER_ORDER = 50;
+
+    public function __construct(
+        OrderRepository $orderRepository,
+        PaymentService $paymentService,
+        NotificationService $notificationService
+    ) {
+        $this->orderRepository = $orderRepository;
+        $this->paymentService = $paymentService;
+        $this->notificationService = $notificationService;
+        self::$instanceCount++;
+    }
+
+    public function place(int $customerId, array $items): Order
+    {
+        if (count($items) > self::MAX_ITEMS_PER_ORDER) {
+            throw new \InvalidArgumentException(
+                'Order exceeds maximum of ' . self::MAX_ITEMS_PER_ORDER . ' items'
+            );
+        }
+
+        $order = new Order(customerId: $customerId, currency: $this->defaultCurrency);
+        foreach ($items as $item) {
+            $order->addItem($item['product_id'], $item['quantity'], $item['unit_price']);
+        }
+
+        $this->orderRepository->save($order);
+
+        if ($this->auditEnabled) {
+            $this->logPlacement($order);
+        }
+
+        return $order;
+    }
+
+    public function cancel(int $orderId): bool
+    {
+        $order = $this->orderRepository->findById($orderId);
+
+        if ($order === null) {
+            throw new OrderNotFoundException("Order {$orderId} not found");
+        }
+
+        $order->setStatus('cancelled');
+        $this->orderRepository->save($order);
+        $this->notificationService->notifyCancellation($order);
+
+        return true;
+    }
+
+    public static function getInstanceCount(): int
+    {
+        return self::$instanceCount;
+    }
+
+    private function logPlacement(Order $order): void
+    {
+        // audit logging
+    }
+}
diff --git a/priv/combined_metrics/samples/consistency/consistent_casing_within_file/bad/analytics.ex b/priv/combined_metrics/samples/consistency/consistent_casing_within_file/bad/analytics.ex
new file mode 100644
index 0000000..372546b
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/consistent_casing_within_file/bad/analytics.ex
@@ -0,0 +1,78 @@
+defmodule Analytics do
+  @moduledoc "Tracks and reports on user events and analytics data"
+
+  def track_event(userId, eventName, properties) do
+    timeStamp = DateTime.utc_now()
+    eventData = build_event(userId, eventName, properties, timeStamp)
+    store_event(eventData)
+  end
+
+  def build_event(user_id, event_name, props, timestamp) do
+    %{
+      userId: user_id,
+      eventName: event_name,
+      properties: props,
+      createdAt: timestamp
+    }
+  end
+
+  def get_user_events(userId, opts \\ []) do
+    page_size = Keyword.get(opts, :pageSize, 20)
+    startDate = Keyword.get(opts, :start_date)
+    endDate = Keyword.get(opts, :end_date)
+
+    fetch_events(userId, startDate, endDate, page_size)
+  end
+
+  def aggregate_events(eventList) do
+    eventList
+    |> Enum.group_by(fn event -> event.eventName end)
+    |> Enum.map(fn {event_name, events} ->
+      event_count = length(events)
+      {event_name, event_count}
+    end)
+    |> Map.new()
+  end
+
+  def compute_retention(userList, start_date, endDate) do
+    activeUsers =
+      userList
+      |> Enum.filter(fn u ->
+        last_seen = u.lastSeenAt
+        DateTime.compare(last_seen, start_date) == :gt and
+          DateTime.compare(last_seen, endDate) == :lt
+      end)
+
+    totalUsers = length(userList)
+    activeCount = length(activeUsers)
+
+    if totalUsers > 0 do
+      retentionRate = activeCount / totalUsers
+      {:ok, retentionRate}
+    else
+      {:error, :no_users}
+    end
+  end
+
+  def format_report(reportData) do
+    event_count = reportData.totalEvents
+    uniqueUsers = reportData.unique_users
+    topEvent = reportData.topEventName
+
+    %{
+      summary: "#{event_count} events from #{uniqueUsers} users",
+      top_event: topEvent,
+      generatedAt: DateTime.utc_now()
+    }
+  end
+
+  def filter_by_property(eventList, propertyKey, propertyVal) do
+    Enum.filter(eventList, fn event ->
+      val = Map.get(event.properties, propertyKey)
+      val == propertyVal
+    end)
+  end
+
+  defp store_event(eventData), do: {:ok, eventData}
+  defp fetch_events(_userId, _start, _end, _pageSize), do: []
+end
diff --git a/priv/combined_metrics/samples/consistency/consistent_casing_within_file/config.yml b/priv/combined_metrics/samples/consistency/consistent_casing_within_file/config.yml
new file mode 100644
index 0000000..6955881
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/consistent_casing_within_file/config.yml
@@ -0,0 +1 @@
+doc: "A file should use one naming convention throughout — no mixing of camelCase and snake_case for the same kind of identifier."
diff --git a/priv/combined_metrics/samples/consistency/consistent_casing_within_file/good/analytics.ex b/priv/combined_metrics/samples/consistency/consistent_casing_within_file/good/analytics.ex
new file mode 100644
index 0000000..4e6adb5
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/consistent_casing_within_file/good/analytics.ex
@@ -0,0 +1,78 @@
+defmodule Analytics do
+  @moduledoc "Tracks and reports on user events and analytics data"
+
+  def track_event(user_id, event_name, properties) do
+    timestamp = DateTime.utc_now()
+    event_data = build_event(user_id, event_name, properties, timestamp)
+    store_event(event_data)
+  end
+
+  def build_event(user_id, event_name, properties, timestamp) do
+    %{
+      user_id: user_id,
+      event_name: event_name,
+      properties: properties,
+      created_at: timestamp
+    }
+  end
+
+  def get_user_events(user_id, opts \\ []) do
+    page_size = Keyword.get(opts, :page_size, 20)
+    start_date = Keyword.get(opts, :start_date)
+    end_date = Keyword.get(opts, :end_date)
+
+    fetch_events(user_id, start_date, end_date, page_size)
+  end
+
+  def aggregate_events(event_list) do
+    event_list
+    |> Enum.group_by(fn event -> event.event_name end)
+    |> Enum.map(fn {event_name, events} ->
+      event_count = length(events)
+      {event_name, event_count}
+    end)
+    |> Map.new()
+  end
+
+  def compute_retention(user_list, start_date, end_date) do
+    active_users =
+      user_list
+      |> Enum.filter(fn user ->
+        last_seen = user.last_seen_at
+        DateTime.compare(last_seen, start_date) == :gt and
+          DateTime.compare(last_seen, end_date) == :lt
+      end)
+
+    total_users = length(user_list)
+    active_count = length(active_users)
+
+    if total_users > 0 do
+      retention_rate = active_count / total_users
+      {:ok, retention_rate}
+    else
+      {:error, :no_users}
+    end
+  end
+
+  def format_report(report_data) do
+    event_count = report_data.total_events
+    unique_users = report_data.unique_users
+    top_event = report_data.top_event_name
+
+    %{
+      summary: "#{event_count} events from #{unique_users} users",
+      top_event: top_event,
+      generated_at: DateTime.utc_now()
+    }
+  end
+
+  def filter_by_property(event_list, property_key, property_value) do
+    Enum.filter(event_list, fn event ->
+      value = Map.get(event.properties, property_key)
+      value == property_value
+    end)
+  end
+
+  defp store_event(event_data), do: {:ok, event_data}
+  defp fetch_events(_user_id, _start_date, _end_date, _page_size), do: []
+end
diff --git a/priv/combined_metrics/samples/consistency/consistent_error_return_shape/bad/accounts.ex b/priv/combined_metrics/samples/consistency/consistent_error_return_shape/bad/accounts.ex
new file mode 100644
index 0000000..3acfccd
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/consistent_error_return_shape/bad/accounts.ex
@@ -0,0 +1,102 @@
+defmodule Accounts do
+  @moduledoc "Manages user accounts and authentication"
+
+  def get_user(id) do
+    case fetch_user_from_db(id) do
+      nil -> nil
+      user -> user
+    end
+  end
+
+  def create_user(attrs) do
+    cond do
+      Map.get(attrs, :email) == nil ->
+        "email is required"
+
+      not valid_email?(attrs.email) ->
+        {:error, "invalid email format"}
+
+      user_exists?(attrs.email) ->
+        false
+
+      true ->
+        do_insert_user(attrs)
+    end
+  end
+
+  def update_user(id, attrs) do
+    case fetch_user_from_db(id) do
+      nil ->
+        {:error, :not_found}
+
+      user ->
+        case validate_attrs(attrs) do
+          false -> "validation failed"
+          true -> do_update_user(user, attrs)
+        end
+    end
+  end
+
+  def delete_user(id) do
+    case fetch_user_from_db(id) do
+      nil -> false
+      user -> do_delete_user(user)
+    end
+  end
+
+  def authenticate(email, password) do
+    case fetch_user_by_email(email) do
+      nil ->
+        {:error, :not_found}
+
+      user ->
+        if check_password(user, password) do
+          {:ok, user}
+        else
+          "invalid password"
+        end
+    end
+  end
+
+  def change_password(user, old_password, new_password) do
+    cond do
+      not check_password(user, old_password) ->
+        {:error, :wrong_password}
+
+      String.length(new_password) < 8 ->
+        nil
+
+      true ->
+        do_update_password(user, new_password)
+    end
+  end
+
+  def list_users(filters \\ %{}) do
+    case fetch_all_users(filters) do
+      [] -> false
+      users -> users
+    end
+  end
+
+  def verify_email(user, token) do
+    case validate_token(token) do
+      :invalid -> "token is invalid"
+      :expired -> {:error, :token_expired}
+      :ok -> do_verify_email(user)
+    end
+  end
+
+  defp fetch_user_from_db(_id), do: nil
+  defp fetch_user_by_email(_email), do: nil
+  defp fetch_all_users(_filters), do: []
+  defp do_insert_user(attrs), do: {:ok, attrs}
+  defp do_update_user(user, _attrs), do: {:ok, user}
+  defp do_delete_user(_user), do: {:ok, :deleted}
+  defp do_update_password(user, _pw), do: {:ok, user}
+  defp do_verify_email(user), do: {:ok, user}
+  defp valid_email?(_email), do: true
+  defp user_exists?(_email), do: false
+  defp validate_attrs(_attrs), do: true
+  defp check_password(_user, _pw), do: true
+  defp validate_token(_token), do: :ok
+end
diff --git a/priv/combined_metrics/samples/consistency/consistent_error_return_shape/config.yml b/priv/combined_metrics/samples/consistency/consistent_error_return_shape/config.yml
new file mode 100644
index 0000000..5b61d8f
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/consistent_error_return_shape/config.yml
@@ -0,0 +1 @@
+doc: "All functions in a module should return errors in the same shape — mixed `nil`, `false`, and `{:error, _}` returns are confusing."
diff --git a/priv/combined_metrics/samples/consistency/consistent_error_return_shape/good/accounts.ex b/priv/combined_metrics/samples/consistency/consistent_error_return_shape/good/accounts.ex
new file mode 100644
index 0000000..045cb19
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/consistent_error_return_shape/good/accounts.ex
@@ -0,0 +1,94 @@
+defmodule Accounts do
+  @moduledoc "Manages user accounts and authentication"
+
+  def get_user(id) do
+    case fetch_user_from_db(id) do
+      nil -> {:error, :not_found}
+      user -> {:ok, user}
+    end
+  end
+
+  def create_user(attrs) do
+    cond do
+      Map.get(attrs, :email) == nil ->
+        {:error, :email_required}
+
+      not valid_email?(attrs.email) ->
+        {:error, :invalid_email}
+
+      user_exists?(attrs.email) ->
+        {:error, :email_taken}
+
+      true ->
+        do_insert_user(attrs)
+    end
+  end
+
+  def update_user(id, attrs) do
+    with {:ok, user} <- get_user(id),
+         :ok <- validate_attrs(attrs) do
+      do_update_user(user, attrs)
+    end
+  end
+
+  def delete_user(id) do
+    case fetch_user_from_db(id) do
+      nil -> {:error, :not_found}
+      user -> do_delete_user(user)
+    end
+  end
+
+  def authenticate(email, password) do
+    case fetch_user_by_email(email) do
+      nil ->
+        {:error, :not_found}
+
+      user ->
+        if check_password(user, password) do
+          {:ok, user}
+        else
+          {:error, :invalid_password}
+        end
+    end
+  end
+
+  def change_password(user, old_password, new_password) do
+    cond do
+      not check_password(user, old_password) ->
+        {:error, :wrong_password}
+
+      String.length(new_password) < 8 ->
+        {:error, :password_too_short}
+
+      true ->
+        do_update_password(user, new_password)
+    end
+  end
+
+  def list_users(filters \\ %{}) do
+    users = fetch_all_users(filters)
+    {:ok, users}
+  end
+
+  def verify_email(user, token) do
+    case validate_token(token) do
+      :invalid -> {:error, :invalid_token}
+      :expired -> {:error, :token_expired}
+      :ok -> do_verify_email(user)
+    end
+  end
+
+  defp fetch_user_from_db(_id), do: nil
+  defp fetch_user_by_email(_email), do: nil
+  defp fetch_all_users(_filters), do: []
+  defp do_insert_user(attrs), do: {:ok, attrs}
+  defp do_update_user(user, _attrs), do: {:ok, user}
+  defp do_delete_user(_user), do: {:ok, :deleted}
+  defp do_update_password(user, _pw), do: {:ok, user}
+  defp do_verify_email(user), do: {:ok, user}
+  defp valid_email?(_email), do: true
+  defp user_exists?(_email), do: false
+  defp validate_attrs(_attrs), do: :ok
+  defp check_password(_user, _pw), do: true
+  defp validate_token(_token), do: :ok
+end
diff --git a/priv/combined_metrics/samples/consistency/consistent_function_style/bad/formatter.ex b/priv/combined_metrics/samples/consistency/consistent_function_style/bad/formatter.ex
new file mode 100644
index 0000000..44ee61e
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/consistent_function_style/bad/formatter.ex
@@ -0,0 +1,66 @@
+defmodule Formatter do
+  @moduledoc "Formats and serializes various data types for display and output"
+
+  def format_name(first, last), do: "#{first} #{last}"
+
+  def format_full_address(address) do
+    "#{address.street}, #{address.city}, #{address.state} #{address.zip}"
+  end
+
+  def format_price(cents), do: "$#{:erlang.float_to_binary(cents / 100, decimals: 2)}"
+
+  def format_date(date) do
+    "#{date.year}-#{pad(date.month)}-#{pad(date.day)}"
+  end
+
+  def format_phone(digits), do: "(#{String.slice(digits, 0, 3)}) #{String.slice(digits, 3, 3)}-#{String.slice(digits, 6, 4)}"
+
+  def format_percentage(value) do
+    rounded = Float.round(value * 100, 1)
+    "#{rounded}%"
+  end
+
+  def format_bytes(bytes), do: if(bytes < 1024, do: "#{bytes} B", else: "#{Float.round(bytes / 1024, 1)} KB")
+
+  def format_duration(seconds) do
+    minutes = div(seconds, 60)
+    remaining = rem(seconds, 60)
+    "#{minutes}m #{remaining}s"
+  end
+
+  def serialize_user(user), do: %{id: user.id, name: format_name(user.first_name, user.last_name), email: user.email}
+
+  def serialize_order(order) do
+    %{
+      id: order.id,
+      total: format_price(order.total_cents),
+      placed_at: format_date(order.inserted_at),
+      items: Enum.map(order.items, &serialize_order_item/1)
+    }
+  end
+
+  def serialize_order_item(item), do: %{name: item.name, quantity: item.quantity, unit_price: format_price(item.unit_price_cents)}
+
+  def truncate(text, max_length) do
+    if String.length(text) > max_length do
+      String.slice(text, 0, max_length - 3) <> "..."
+    else
+      text
+    end
+  end
+
+  def slugify(text), do: text |> String.downcase() |> String.replace(~r/[^a-z0-9]+/, "-") |> String.trim("-")
+
+  def format_list(items) do
+    case length(items) do
+      0 -> "none"
+      1 -> hd(items)
+      2 -> "#{Enum.at(items, 0)} and #{Enum.at(items, 1)}"
+      _ ->
+        all_but_last = Enum.join(Enum.drop(items, -1), ", ")
+        "#{all_but_last}, and #{List.last(items)}"
+    end
+  end
+
+  defp pad(n), do: String.pad_leading(Integer.to_string(n), 2, "0")
+end
diff --git a/priv/combined_metrics/samples/consistency/consistent_function_style/config.yml b/priv/combined_metrics/samples/consistency/consistent_function_style/config.yml
new file mode 100644
index 0000000..28e73a2
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/consistent_function_style/config.yml
@@ -0,0 +1 @@
+doc: "A module should not mix one-liner and multi-clause function definitions for the same concern."
diff --git a/priv/combined_metrics/samples/consistency/consistent_function_style/good/formatter.ex b/priv/combined_metrics/samples/consistency/consistent_function_style/good/formatter.ex
new file mode 100644
index 0000000..1f43bed
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/consistent_function_style/good/formatter.ex
@@ -0,0 +1,96 @@
+defmodule Formatter do
+  @moduledoc "Formats and serializes various data types for display and output"
+
+  def format_name(first, last) do
+    "#{first} #{last}"
+  end
+
+  def format_full_address(address) do
+    "#{address.street}, #{address.city}, #{address.state} #{address.zip}"
+  end
+
+  def format_price(cents) do
+    "$#{:erlang.float_to_binary(cents / 100, decimals: 2)}"
+  end
+
+  def format_date(date) do
+    "#{date.year}-#{pad(date.month)}-#{pad(date.day)}"
+  end
+
+  def format_phone(digits) do
+    area = String.slice(digits, 0, 3)
+    prefix = String.slice(digits, 3, 3)
+    line = String.slice(digits, 6, 4)
+    "(#{area}) #{prefix}-#{line}"
+  end
+
+  def format_percentage(value) do
+    rounded = Float.round(value * 100, 1)
+    "#{rounded}%"
+  end
+
+  def format_bytes(bytes) when bytes < 1024 do
+    "#{bytes} B"
+  end
+
+  def format_bytes(bytes) do
+    "#{Float.round(bytes / 1024, 1)} KB"
+  end
+
+  def format_duration(seconds) do
+    minutes = div(seconds, 60)
+    remaining = rem(seconds, 60)
+    "#{minutes}m #{remaining}s"
+  end
+
+  def serialize_user(user) do
+    %{
+      id: user.id,
+      name: format_name(user.first_name, user.last_name),
+      email: user.email
+    }
+  end
+
+  def serialize_order(order) do
+    %{
+      id: order.id,
+      total: format_price(order.total_cents),
+      placed_at: format_date(order.inserted_at),
+      items: Enum.map(order.items, &serialize_order_item/1)
+    }
+  end
+
+  def serialize_order_item(item) do
+    %{
+      name: item.name,
+      quantity: item.quantity,
+      unit_price: format_price(item.unit_price_cents)
+    }
+  end
+
+  def truncate(text, max_length) do
+    if String.length(text) > max_length do
+      String.slice(text, 0, max_length - 3) <> "..."
+    else
+      text
+    end
+  end
+
+  def slugify(text) do
+    text
+    |> String.downcase()
+    |> String.replace(~r/[^a-z0-9]+/, "-")
+    |> String.trim("-")
+  end
+
+  def format_list([]), do: "none"
+  def format_list([item]), do: item
+  def format_list([a, b]), do: "#{a} and #{b}"
+
+  def format_list(items) do
+    all_but_last = items |> Enum.drop(-1) |> Enum.join(", ")
+    "#{all_but_last}, and #{List.last(items)}"
+  end
+
+  defp pad(n), do: String.pad_leading(Integer.to_string(n), 2, "0")
+end
diff --git a/priv/combined_metrics/samples/consistency/doc_vs_comment_separation/bad/subscriptions.ex b/priv/combined_metrics/samples/consistency/doc_vs_comment_separation/bad/subscriptions.ex
new file mode 100644
index 0000000..619771b
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/doc_vs_comment_separation/bad/subscriptions.ex
@@ -0,0 +1,58 @@
+defmodule MyApp.Subscriptions do
+  # Bad: no @moduledoc at all — public module with no documentation
+  # The module purpose, lifecycle, and conventions are undocumented.
+
+  alias MyApp.Subscriptions.{Subscription, Plan}
+  alias MyApp.Repo
+
+  # Bad: using a plain comment instead of @doc for a public function.
+  # Consumers cannot use `h MyApp.Subscriptions.create/2` in IEx.
+  # Creates a new subscription
+  @spec create(integer(), Plan.t()) :: {:ok, Subscription.t()} | {:error, Ecto.Changeset.t()}
+  def create(customer_id, %Plan{} = plan) do
+    initial_status = if plan.trial_days > 0, do: :trialing, else: :active
+
+    trial_ends_at =
+      if plan.trial_days > 0 do
+        DateTime.add(DateTime.utc_now(), plan.trial_days * 86_400, :second)
+      end
+
+    %Subscription{}
+    |> Subscription.changeset(%{
+      customer_id: customer_id,
+      plan_id: plan.id,
+      status: initial_status,
+      trial_ends_at: trial_ends_at
+    })
+    |> Repo.insert()
+  end
+
+  @doc """
+  Cancels the subscription.
+
+  Implementation note: we first check if the changeset is valid by calling
+  Subscription.changeset/2, then call Repo.update/1. The Subscription schema
+  has a :cancelled_at field that gets set here. We also emit a telemetry event
+  by calling :telemetry.execute/3 with the [:my_app, :subscriptions, :transitioned]
+  event name. The metadata map has :from and :to keys. The Repo is aliased at the
+  top of this module. We use DateTime.utc_now() for the timestamp.
+  """
+  # Bad: @doc describes the implementation in exhaustive detail — not the contract.
+  # The doc should explain what the function does for callers, not how it works internally.
+  @spec cancel(Subscription.t()) :: {:ok, Subscription.t()} | {:error, Ecto.Changeset.t()}
+  def cancel(%Subscription{status: :cancelled} = sub), do: {:ok, sub}
+
+  def cancel(%Subscription{} = sub) do
+    sub
+    |> Subscription.changeset(%{status: :cancelled, cancelled_at: DateTime.utc_now()})
+    |> Repo.update()
+  end
+
+  # Bad: no @doc on a public function — leaves callers guessing
+  @spec reactivate(Subscription.t()) :: {:ok, Subscription.t()} | {:error, atom()}
+  def reactivate(%Subscription{} = sub) do
+    sub
+    |> Subscription.changeset(%{status: :active, cancelled_at: nil})
+    |> Repo.update()
+  end
+end
diff --git a/priv/combined_metrics/samples/consistency/doc_vs_comment_separation/good/subscriptions.ex b/priv/combined_metrics/samples/consistency/doc_vs_comment_separation/good/subscriptions.ex
new file mode 100644
index 0000000..fab6629
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/doc_vs_comment_separation/good/subscriptions.ex
@@ -0,0 +1,67 @@
+defmodule MyApp.Subscriptions do
+  @moduledoc """
+  Public API for managing customer subscriptions.
+
+  Subscriptions move through the following lifecycle:
+  `:trialing` -> `:active` -> `:past_due` -> `:cancelled`
+
+  All state transitions emit a telemetry event under
+  `[:my_app, :subscriptions, :transitioned]`.
+  """
+
+  alias MyApp.Subscriptions.{Subscription, Plan}
+  alias MyApp.Repo
+
+  @doc """
+  Creates a new subscription for the given customer on the specified plan.
+
+  Returns `{:ok, subscription}` on success, or `{:error, changeset}` when
+  validation fails (e.g. the customer already has an active subscription).
+  """
+  @spec create(integer(), Plan.t()) :: {:ok, Subscription.t()} | {:error, Ecto.Changeset.t()}
+  def create(customer_id, %Plan{} = plan) do
+    # Determine initial status: new customers start in a trial period
+    initial_status = if plan.trial_days > 0, do: :trialing, else: :active
+
+    # Compute trial end date; nil when the plan has no trial
+    trial_ends_at =
+      if plan.trial_days > 0 do
+        DateTime.add(DateTime.utc_now(), plan.trial_days * 86_400, :second)
+      end
+
+    %Subscription{}
+    |> Subscription.changeset(%{
+      customer_id: customer_id,
+      plan_id: plan.id,
+      status: initial_status,
+      trial_ends_at: trial_ends_at
+    })
+    |> Repo.insert()
+  end
+
+  @doc """
+  Cancels a subscription immediately.
+
+  If the subscription is already cancelled this is a no-op and
+  `{:ok, subscription}` is still returned.
+  """
+  @spec cancel(Subscription.t()) :: {:ok, Subscription.t()} | {:error, Ecto.Changeset.t()}
+  def cancel(%Subscription{status: :cancelled} = sub), do: {:ok, sub}
+
+  def cancel(%Subscription{} = sub) do
+    sub
+    |> Subscription.changeset(%{status: :cancelled, cancelled_at: DateTime.utc_now()})
+    |> Repo.update()
+    |> tap(fn
+      {:ok, updated} ->
+        # Emit telemetry so billing can react to the cancellation
+        :telemetry.execute([:my_app, :subscriptions, :transitioned], %{}, %{
+          from: sub.status,
+          to: updated.status
+        })
+
+      _ ->
+        :ok
+    end)
+  end
+end
diff --git a/priv/combined_metrics/samples/consistency/overloads_are_contiguous/bad/PaymentProcessor.java b/priv/combined_metrics/samples/consistency/overloads_are_contiguous/bad/PaymentProcessor.java
new file mode 100644
index 0000000..40e5226
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/overloads_are_contiguous/bad/PaymentProcessor.java
@@ -0,0 +1,62 @@
+package com.example.payments;
+
+import java.math.BigDecimal;
+import java.util.Currency;
+import java.util.Locale;
+
+public class PaymentProcessor {
+
+    private final PaymentGateway gateway;
+    private final AuditLog auditLog;
+
+    public PaymentProcessor(PaymentGateway gateway, AuditLog auditLog) {
+        this.gateway = gateway;
+        this.auditLog = auditLog;
+    }
+
+    // First process() overload
+    public PaymentResult process(PaymentRequest request) {
+        return process(request, Currency.getInstance(Locale.US));
+    }
+
+    // refund() overload interspersed between process() overloads
+    public RefundResult refund(String transactionId) {
+        return refund(transactionId, null);
+    }
+
+    // Second process() overload — separated from the first by refund()
+    public PaymentResult process(PaymentRequest request, Currency currency) {
+        return process(request, currency, false);
+    }
+
+    public boolean isHealthy() {
+        return gateway.ping();
+    }
+
+    // Third process() overload — far from the other two
+    public PaymentResult process(PaymentRequest request, Currency currency, boolean capture) {
+        ChargeRequest charge = ChargeRequest.builder()
+            .amount(request.getAmount())
+            .currency(currency)
+            .capture(capture)
+            .token(request.getPaymentToken())
+            .build();
+        PaymentResult result = gateway.charge(charge);
+        auditLog.record(request, result);
+        return result;
+    }
+
+    public PaymentSummary summarize(String merchantId) {
+        return gateway.fetchSummary(merchantId);
+    }
+
+    // Second refund() overload — separated from the first by three other methods
+    public RefundResult refund(String transactionId, BigDecimal amount) {
+        RefundRequest refund = amount != null
+            ? RefundRequest.partial(transactionId, amount)
+            : RefundRequest.full(transactionId);
+        RefundResult result = gateway.refund(refund);
+        auditLog.record(refund, result);
+        return result;
+    }
+}
diff --git a/priv/combined_metrics/samples/consistency/overloads_are_contiguous/good/PaymentProcessor.java b/priv/combined_metrics/samples/consistency/overloads_are_contiguous/good/PaymentProcessor.java
new file mode 100644
index 0000000..4c30cc7
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/overloads_are_contiguous/good/PaymentProcessor.java
@@ -0,0 +1,59 @@
+package com.example.payments;
+
+import java.math.BigDecimal;
+import java.util.Currency;
+import java.util.Locale;
+
+public class PaymentProcessor {
+
+    private final PaymentGateway gateway;
+    private final AuditLog auditLog;
+
+    public PaymentProcessor(PaymentGateway gateway, AuditLog auditLog) {
+        this.gateway = gateway;
+        this.auditLog = auditLog;
+    }
+
+    // All process() overloads are grouped together
+    public PaymentResult process(PaymentRequest request) {
+        return process(request, Currency.getInstance(Locale.US));
+    }
+
+    public PaymentResult process(PaymentRequest request, Currency currency) {
+        return process(request, currency, false);
+    }
+
+    public PaymentResult process(PaymentRequest request, Currency currency, boolean capture) {
+        ChargeRequest charge = ChargeRequest.builder()
+            .amount(request.getAmount())
+            .currency(currency)
+            .capture(capture)
+            .token(request.getPaymentToken())
+            .build();
+        PaymentResult result = gateway.charge(charge);
+        auditLog.record(request, result);
+        return result;
+    }
+
+    // All refund() overloads are grouped together
+    public RefundResult refund(String transactionId) {
+        return refund(transactionId, null);
+    }
+
+    public RefundResult refund(String transactionId, BigDecimal amount) {
+        RefundRequest refund = amount != null
+            ? RefundRequest.partial(transactionId, amount)
+            : RefundRequest.full(transactionId);
+        RefundResult result = gateway.refund(refund);
+        auditLog.record(refund, result);
+        return result;
+    }
+
+    public boolean isHealthy() {
+        return gateway.ping();
+    }
+
+    public PaymentSummary summarize(String merchantId) {
+        return gateway.fetchSummary(merchantId);
+    }
+}
diff --git a/priv/combined_metrics/samples/consistency/override_annotation_present/bad/UserRepository.java b/priv/combined_metrics/samples/consistency/override_annotation_present/bad/UserRepository.java
new file mode 100644
index 0000000..71ef3cd
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/override_annotation_present/bad/UserRepository.java
@@ -0,0 +1,88 @@
+package com.example.users;
+
+import java.util.List;
+import java.util.Objects;
+
+public class UserRepository extends AbstractRepository<User> implements Auditable {
+
+    private final DataSource dataSource;
+
+    public UserRepository(DataSource dataSource) {
+        this.dataSource = dataSource;
+    }
+
+    // Missing @Override — not obvious this is implementing the abstract method
+    public User findById(long id) {
+        return dataSource.query(
+            "SELECT * FROM users WHERE id = ?",
+            ps -> ps.setLong(1, id),
+            UserRepository::mapRow
+        );
+    }
+
+    // Missing @Override
+    public List<User> findAll() {
+        return dataSource.queryList(
+            "SELECT * FROM users ORDER BY created_at DESC",
+            UserRepository::mapRow
+        );
+    }
+
+    // Missing @Override
+    public void save(User user) {
+        if (user.getId() == null) {
+            insert(user);
+        } else {
+            update(user);
+        }
+    }
+
+    // Missing @Override
+    public void delete(long id) {
+        dataSource.execute("DELETE FROM users WHERE id = ?", ps -> ps.setLong(1, id));
+    }
+
+    // Missing @Override — implementing interface method without annotation
+    public String auditLabel() {
+        return "users";
+    }
+
+    // Missing @Override on Object methods
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof UserRepository)) return false;
+        UserRepository that = (UserRepository) o;
+        return Objects.equals(dataSource, that.dataSource);
+    }
+
+    // Missing @Override
+    public int hashCode() {
+        return Objects.hash(dataSource);
+    }
+
+    // Missing @Override
+    public String toString() {
+        return "UserRepository{dataSource=" + dataSource + "}";
+    }
+
+    private void insert(User user) {
+        dataSource.execute(
+            "INSERT INTO users (email, name, created_at) VALUES (?, ?, NOW())",
+            ps -> {
+                ps.setString(1, user.getEmail());
+                ps.setString(2, user.getName());
+            }
+        );
+    }
+
+    private void update(User user) {
+        dataSource.execute(
+            "UPDATE users SET email = ?, name = ? WHERE id = ?",
+            ps -> {
+                ps.setString(1, user.getEmail());
+                ps.setString(2, user.getName());
+                ps.setLong(3, user.getId());
+            }
+        );
+    }
+}
diff --git a/priv/combined_metrics/samples/consistency/override_annotation_present/good/UserRepository.java b/priv/combined_metrics/samples/consistency/override_annotation_present/good/UserRepository.java
new file mode 100644
index 0000000..0e1124e
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/override_annotation_present/good/UserRepository.java
@@ -0,0 +1,92 @@
+package com.example.users;
+
+import java.util.List;
+import java.util.Objects;
+
+public class UserRepository extends AbstractRepository<User> implements Auditable {
+
+    private final DataSource dataSource;
+
+    public UserRepository(DataSource dataSource) {
+        this.dataSource = dataSource;
+    }
+
+    @Override
+    public User findById(long id) {
+        return dataSource.query(
+            "SELECT * FROM users WHERE id = ?",
+            ps -> ps.setLong(1, id),
+            UserRepository::mapRow
+        );
+    }
+
+    @Override
+    public List<User> findAll() {
+        return dataSource.queryList(
+            "SELECT * FROM users ORDER BY created_at DESC",
+            UserRepository::mapRow
+        );
+    }
+
+    @Override
+    public void save(User user) {
+        if (user.getId() == null) {
+            insert(user);
+        } else {
+            update(user);
+        }
+    }
+
+    @Override
+    public void delete(long id) {
+        dataSource.execute("DELETE FROM users WHERE id = ?", ps -> ps.setLong(1, id));
+    }
+
+    @Override
+    public String auditLabel() {
+        return "users";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof UserRepository)) return false;
+        UserRepository that = (UserRepository) o;
+        return Objects.equals(dataSource, that.dataSource);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(dataSource);
+    }
+
+    @Override
+    public String toString() {
+        return "UserRepository{dataSource=" + dataSource + "}";
+    }
+
+    private void insert(User user) {
+        dataSource.execute(
+            "INSERT INTO users (email, name, created_at) VALUES (?, ?, NOW())",
+            ps -> {
+                ps.setString(1, user.getEmail());
+                ps.setString(2, user.getName());
+            }
+        );
+    }
+
+    private void update(User user) {
+        dataSource.execute(
+            "UPDATE users SET email = ?, name = ? WHERE id = ?",
+            ps -> {
+                ps.setString(1, user.getEmail());
+                ps.setString(2, user.getName());
+                ps.setLong(3, user.getId());
+            }
+        );
+    }
+
+    private static User mapRow(ResultSet rs) throws SQLException {
+        return new User(rs.getLong("id"), rs.getString("email"), rs.getString("name"));
+    }
+}
diff --git a/priv/combined_metrics/samples/consistency/process_interactions_centralized/bad/sessions.ex b/priv/combined_metrics/samples/consistency/process_interactions_centralized/bad/sessions.ex
new file mode 100644
index 0000000..9c67252
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/process_interactions_centralized/bad/sessions.ex
@@ -0,0 +1,60 @@
+defmodule MyApp.SessionStore do
+  @moduledoc "Holds session state."
+
+  use GenServer
+
+  def start_link(opts), do: GenServer.start_link(__MODULE__, opts, name: __MODULE__)
+
+  @impl true
+  def init(_opts), do: {:ok, %{sessions: %{}}}
+
+  @impl true
+  def handle_call({:put, token, session}, _from, state) do
+    {:reply, :ok, put_in(state, [:sessions, token], session)}
+  end
+
+  def handle_call({:get, token}, _from, state) do
+    {:reply, Map.get(state.sessions, token), state}
+  end
+
+  def handle_call(:count, _from, state) do
+    {:reply, map_size(state.sessions), state}
+  end
+
+  @impl true
+  def handle_cast({:delete, token}, state) do
+    {:noreply, update_in(state, [:sessions], &Map.delete(&1, token))}
+  end
+end
+
+# Bad: MyApp.AuthController calls GenServer directly instead of going through a facade
+defmodule MyApp.AuthController do
+  def login(conn, %{"token" => token}) do
+    # Bad: direct GenServer call scattered in a controller
+    session = GenServer.call(MyApp.SessionStore, {:get, token})
+    # ...
+  end
+end
+
+# Bad: MyApp.Plugs.LoadSession also calls GenServer directly — duplication
+defmodule MyApp.Plugs.LoadSession do
+  def call(conn, _opts) do
+    token = get_session_token(conn)
+    # Bad: same GenServer call repeated here — no single facade
+    session = GenServer.call(MyApp.SessionStore, {:get, token})
+    assign(conn, :current_session, session)
+  end
+
+  defp get_session_token(conn), do: Plug.Conn.get_req_header(conn, "x-session-token") |> List.first()
+  defp assign(conn, key, value), do: Map.put(conn, key, value)
+end
+
+# Bad: yet another module talking directly to the GenServer
+defmodule MyApp.SessionCleanup do
+  def delete_expired(tokens) do
+    Enum.each(tokens, fn token ->
+      # Bad: direct cast, not going through any facade
+      GenServer.cast(MyApp.SessionStore, {:delete, token})
+    end)
+  end
+end
diff --git a/priv/combined_metrics/samples/consistency/process_interactions_centralized/good/sessions.ex b/priv/combined_metrics/samples/consistency/process_interactions_centralized/good/sessions.ex
new file mode 100644
index 0000000..9690d41
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/process_interactions_centralized/good/sessions.ex
@@ -0,0 +1,76 @@
+defmodule MyApp.SessionStore do
+  @moduledoc """
+  Facade for all interactions with the session cache GenServer.
+  All GenServer calls are centralised here — no other module calls
+  `GenServer.call/cast` on the session process directly.
+  """
+
+  use GenServer
+
+  alias MyApp.Sessions.Session
+
+  # --- Public API (the facade) ---
+
+  def start_link(opts), do: GenServer.start_link(__MODULE__, opts, name: __MODULE__)
+
+  @doc "Stores a session, returning the token."
+  @spec put(Session.t()) :: String.t()
+  def put(%Session{} = session) do
+    token = generate_token()
+    GenServer.call(__MODULE__, {:put, token, session})
+    token
+  end
+
+  @doc "Retrieves a session by token."
+  @spec get(String.t()) :: Session.t() | nil
+  def get(token) when is_binary(token) do
+    GenServer.call(__MODULE__, {:get, token})
+  end
+
+  @doc "Deletes a session by token."
+  @spec delete(String.t()) :: :ok
+  def delete(token) when is_binary(token) do
+    GenServer.cast(__MODULE__, {:delete, token})
+  end
+
+  @doc "Extends a session's TTL by the given number of seconds."
+  @spec touch(String.t(), pos_integer()) :: :ok
+  def touch(token, ttl_seconds) when is_binary(token) and is_integer(ttl_seconds) do
+    GenServer.cast(__MODULE__, {:touch, token, ttl_seconds})
+  end
+
+  @doc "Returns the number of active sessions."
+  @spec count() :: non_neg_integer()
+  def count do
+    GenServer.call(__MODULE__, :count)
+  end
+
+  # --- GenServer callbacks ---
+
+  @impl true
+  def init(_opts), do: {:ok, %{sessions: %{}, expiry: %{}}}
+
+  @impl true
+  def handle_call({:put, token, session}, _from, state) do
+    {:reply, :ok, put_in(state, [:sessions, token], session)}
+  end
+
+  def handle_call({:get, token}, _from, state) do
+    {:reply, Map.get(state.sessions, token), state}
+  end
+
+  def handle_call(:count, _from, state) do
+    {:reply, map_size(state.sessions), state}
+  end
+
+  @impl true
+  def handle_cast({:delete, token}, state) do
+    {:noreply, update_in(state, [:sessions], &Map.delete(&1, token))}
+  end
+
+  def handle_cast({:touch, _token, _ttl}, state) do
+    {:noreply, state}
+  end
+
+  defp generate_token, do: Base.url_encode64(:crypto.strong_rand_bytes(32), padding: false)
+end
diff --git a/priv/combined_metrics/samples/consistency/protocol_conformance_in_separate_extension/bad/PaymentProcessor.swift b/priv/combined_metrics/samples/consistency/protocol_conformance_in_separate_extension/bad/PaymentProcessor.swift
new file mode 100644
index 0000000..7161470
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/protocol_conformance_in_separate_extension/bad/PaymentProcessor.swift
@@ -0,0 +1,53 @@
+import Foundation
+
+enum PaymentMethod {
+    case creditCard(last4: String)
+    case bankTransfer(accountNumber: String)
+    case digitalWallet(provider: String)
+}
+
+enum PaymentStatus {
+    case pending, authorized, captured, refunded, failed
+}
+
+// All protocol conformances declared inline with the primary type,
+// making it harder to locate core logic vs. protocol implementations
+struct PaymentTransaction: Equatable, Hashable, CustomStringConvertible, Codable {
+    let id: String
+    let amount: Decimal
+    let currency: String
+    let method: PaymentMethod
+    var status: PaymentStatus
+    let createdAt: Date
+    var completedAt: Date?
+    var failureReason: String?
+
+    // Equatable mixed in with stored properties
+    static func == (lhs: PaymentTransaction, rhs: PaymentTransaction) -> Bool {
+        return lhs.id == rhs.id
+    }
+
+    // Hashable mixed in with stored properties
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(id)
+    }
+
+    // CustomStringConvertible mixed in with stored properties
+    var description: String {
+        return "PaymentTransaction(id: \(id), amount: \(amount) \(currency), status: \(status))"
+    }
+
+    // Codable CodingKeys mixed in with stored properties
+    enum CodingKeys: String, CodingKey {
+        case id, amount, currency, status, createdAt, completedAt, failureReason
+    }
+
+    // Business logic buried alongside protocol boilerplate
+    func isRefundable() -> Bool {
+        return status == .captured && completedAt != nil
+    }
+
+    func summary() -> String {
+        return "\(currency) \(amount) via \(method)"
+    }
+}
diff --git a/priv/combined_metrics/samples/consistency/protocol_conformance_in_separate_extension/good/PaymentProcessor.swift b/priv/combined_metrics/samples/consistency/protocol_conformance_in_separate_extension/good/PaymentProcessor.swift
new file mode 100644
index 0000000..f7cfcad
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/protocol_conformance_in_separate_extension/good/PaymentProcessor.swift
@@ -0,0 +1,51 @@
+import Foundation
+
+enum PaymentMethod {
+    case creditCard(last4: String)
+    case bankTransfer(accountNumber: String)
+    case digitalWallet(provider: String)
+}
+
+enum PaymentStatus {
+    case pending, authorized, captured, refunded, failed
+}
+
+// Primary type definition — only core stored properties and init
+struct PaymentTransaction {
+    let id: String
+    let amount: Decimal
+    let currency: String
+    let method: PaymentMethod
+    var status: PaymentStatus
+    let createdAt: Date
+    var completedAt: Date?
+    var failureReason: String?
+}
+
+// MARK: - Equatable conformance in its own extension
+extension PaymentTransaction: Equatable {
+    static func == (lhs: PaymentTransaction, rhs: PaymentTransaction) -> Bool {
+        return lhs.id == rhs.id
+    }
+}
+
+// MARK: - Hashable conformance in its own extension
+extension PaymentTransaction: Hashable {
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(id)
+    }
+}
+
+// MARK: - CustomStringConvertible in its own extension
+extension PaymentTransaction: CustomStringConvertible {
+    var description: String {
+        return "PaymentTransaction(id: \(id), amount: \(amount) \(currency), status: \(status))"
+    }
+}
+
+// MARK: - Codable in its own extension
+extension PaymentTransaction: Codable {
+    enum CodingKeys: String, CodingKey {
+        case id, amount, currency, status, createdAt, completedAt, failureReason
+    }
+}
diff --git a/priv/combined_metrics/samples/consistency/same_concept_same_name/bad/auth.ex b/priv/combined_metrics/samples/consistency/same_concept_same_name/bad/auth.ex
new file mode 100644
index 0000000..3dbbbc3
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/same_concept_same_name/bad/auth.ex
@@ -0,0 +1,102 @@
+defmodule Auth do
+  @moduledoc "Handles authentication and session management"
+
+  def login(account, password) do
+    case fetch_user(account.email) do
+      nil ->
+        {:error, :not_found}
+
+      u ->
+        if verify_password(u, password) do
+          token = generate_token(u.id)
+          {:ok, token}
+        else
+          {:error, :invalid_credentials}
+        end
+    end
+  end
+
+  def logout(usr) do
+    case fetch_active_session(usr.id) do
+      nil -> {:error, :no_session}
+      session -> invalidate_session(session)
+    end
+  end
+
+  def register(params) do
+    with :ok <- validate_registration(params),
+         {:ok, new_account} <- create_user(params),
+         {:ok, _} <- send_verification_email(new_account) do
+      {:ok, new_account}
+    end
+  end
+
+  def verify_token(token_string) do
+    case decode_token(token_string) do
+      {:ok, claims} ->
+        account = fetch_user_by_id(claims["sub"])
+        {:ok, account}
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  def change_password(u, old_pw, new_pw) do
+    if verify_password(u, old_pw) do
+      hashed = hash_password(new_pw)
+      update_user_password(u.id, hashed)
+    else
+      {:error, :wrong_password}
+    end
+  end
+
+  def request_password_reset(email_address) do
+    case fetch_user(email_address) do
+      nil ->
+        {:error, :not_found}
+
+      account ->
+        reset_token = generate_reset_token(account.id)
+        send_reset_email(account.email, reset_token)
+    end
+  end
+
+  def reset_password(reset_token, new_pw) do
+    with {:ok, usr_id} <- validate_reset_token(reset_token),
+         account <- fetch_user_by_id(usr_id),
+         hashed = hash_password(new_pw),
+         {:ok, updated} <- update_user_password(account.id, hashed) do
+      {:ok, updated}
+    end
+  end
+
+  def list_sessions(account) do
+    fetch_sessions_for_user(account.id)
+  end
+
+  def revoke_session(u, session_id) do
+    case fetch_session(session_id) do
+      %{user_id: ^u.id} = session -> invalidate_session(session)
+      _ -> {:error, :unauthorized}
+    end
+  end
+
+  defp fetch_user(_email), do: nil
+  defp fetch_user_by_id(_id), do: nil
+  defp fetch_active_session(_user_id), do: nil
+  defp fetch_session(_id), do: nil
+  defp fetch_sessions_for_user(_user_id), do: []
+  defp verify_password(_user, _pw), do: true
+  defp generate_token(_user_id), do: "tok_abc"
+  defp generate_reset_token(_user_id), do: "rst_abc"
+  defp invalidate_session(_session), do: {:ok, :logged_out}
+  defp create_user(attrs), do: {:ok, attrs}
+  defp send_verification_email(_user), do: {:ok, :sent}
+  defp send_reset_email(_email, _token), do: {:ok, :sent}
+  defp decode_token(_token), do: {:ok, %{"sub" => "1"}}
+  defp validate_reset_token(_token), do: {:ok, "1"}
+  defp validate_registration(_params), do: :ok
+  defp hash_password(pw), do: pw
+  defp update_user_password(_id, _hash), do: {:ok, %{}}
+end
diff --git a/priv/combined_metrics/samples/consistency/same_concept_same_name/config.yml b/priv/combined_metrics/samples/consistency/same_concept_same_name/config.yml
new file mode 100644
index 0000000..3543d7a
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/same_concept_same_name/config.yml
@@ -0,0 +1 @@
+doc: "The same domain concept should use the same name throughout a file — mixing `user`, `usr`, and `u` for the same thing harms readability."
diff --git a/priv/combined_metrics/samples/consistency/same_concept_same_name/good/auth.ex b/priv/combined_metrics/samples/consistency/same_concept_same_name/good/auth.ex
new file mode 100644
index 0000000..ea578d8
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/same_concept_same_name/good/auth.ex
@@ -0,0 +1,102 @@
+defmodule Auth do
+  @moduledoc "Handles authentication and session management"
+
+  def login(user, password) do
+    case fetch_user(user.email) do
+      nil ->
+        {:error, :not_found}
+
+      user ->
+        if verify_password(user, password) do
+          token = generate_token(user.id)
+          {:ok, token}
+        else
+          {:error, :invalid_credentials}
+        end
+    end
+  end
+
+  def logout(user) do
+    case fetch_active_session(user.id) do
+      nil -> {:error, :no_session}
+      session -> invalidate_session(session)
+    end
+  end
+
+  def register(params) do
+    with :ok <- validate_registration(params),
+         {:ok, user} <- create_user(params),
+         {:ok, _} <- send_verification_email(user) do
+      {:ok, user}
+    end
+  end
+
+  def verify_token(token_string) do
+    case decode_token(token_string) do
+      {:ok, claims} ->
+        user = fetch_user_by_id(claims["sub"])
+        {:ok, user}
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  def change_password(user, old_password, new_password) do
+    if verify_password(user, old_password) do
+      hashed = hash_password(new_password)
+      update_user_password(user.id, hashed)
+    else
+      {:error, :wrong_password}
+    end
+  end
+
+  def request_password_reset(email) do
+    case fetch_user(email) do
+      nil ->
+        {:error, :not_found}
+
+      user ->
+        reset_token = generate_reset_token(user.id)
+        send_reset_email(user.email, reset_token)
+    end
+  end
+
+  def reset_password(reset_token, new_password) do
+    with {:ok, user_id} <- validate_reset_token(reset_token),
+         user <- fetch_user_by_id(user_id),
+         hashed = hash_password(new_password),
+         {:ok, updated_user} <- update_user_password(user.id, hashed) do
+      {:ok, updated_user}
+    end
+  end
+
+  def list_sessions(user) do
+    fetch_sessions_for_user(user.id)
+  end
+
+  def revoke_session(user, session_id) do
+    case fetch_session(session_id) do
+      %{user_id: ^user.id} = session -> invalidate_session(session)
+      _ -> {:error, :unauthorized}
+    end
+  end
+
+  defp fetch_user(_email), do: nil
+  defp fetch_user_by_id(_id), do: nil
+  defp fetch_active_session(_user_id), do: nil
+  defp fetch_session(_id), do: nil
+  defp fetch_sessions_for_user(_user_id), do: []
+  defp verify_password(_user, _password), do: true
+  defp generate_token(_user_id), do: "tok_abc"
+  defp generate_reset_token(_user_id), do: "rst_abc"
+  defp invalidate_session(_session), do: {:ok, :logged_out}
+  defp create_user(attrs), do: {:ok, attrs}
+  defp send_verification_email(_user), do: {:ok, :sent}
+  defp send_reset_email(_email, _token), do: {:ok, :sent}
+  defp decode_token(_token), do: {:ok, %{"sub" => "1"}}
+  defp validate_reset_token(_token), do: {:ok, "1"}
+  defp validate_registration(_params), do: :ok
+  defp hash_password(password), do: password
+  defp update_user_password(_id, _hash), do: {:ok, %{}}
+end
diff --git a/priv/combined_metrics/samples/consistency/static_member_via_class_name/bad/ProductCatalog.java b/priv/combined_metrics/samples/consistency/static_member_via_class_name/bad/ProductCatalog.java
new file mode 100644
index 0000000..3e63a8b
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/static_member_via_class_name/bad/ProductCatalog.java
@@ -0,0 +1,63 @@
+package com.example.catalog;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+public class ProductCatalog {
+
+    public static final int MAX_SEARCH_RESULTS = 100;
+    public static final BigDecimal DEFAULT_TAX_RATE = new BigDecimal("0.20");
+
+    private static int instanceCount = 0;
+
+    private final String region;
+    private final ProductRepository repository;
+
+    public ProductCatalog(String region, ProductRepository repository) {
+        this.region = region;
+        this.repository = repository;
+        // Accessing static field via `this` — misleading, looks like instance state
+        this.instanceCount++;
+    }
+
+    public List<Product> search(String query) {
+        // Accessing static constant via instance reference — hides the static nature
+        return repository.search(query, this.MAX_SEARCH_RESULTS);
+    }
+
+    public BigDecimal priceWithTax(Product product) {
+        // Accessing static constant via instance reference
+        return product.getBasePrice().multiply(
+            BigDecimal.ONE.add(this.DEFAULT_TAX_RATE)
+        );
+    }
+
+    public static ProductCatalog forRegion(String region, ProductRepository repo) {
+        return new ProductCatalog(region, repo);
+    }
+
+    public static int getInstanceCount() {
+        // Fine in static context, but inconsistent with rest of file
+        return instanceCount;
+    }
+
+    public void resetInstanceTracking() {
+        // Accessing static field via `this` in instance method
+        this.instanceCount = 0;
+    }
+
+    public List<Product> findOnSale() {
+        ProductCatalog catalog = this;
+        // Accessing static member via local instance variable — very confusing
+        return repository.findAll().stream()
+            .filter(Product::isOnSale)
+            .limit(catalog.MAX_SEARCH_RESULTS)
+            .toList();
+    }
+
+    public void logStats() {
+        ProductCatalog temp = new ProductCatalog(region, repository);
+        // Accessing static field through a different instance
+        System.out.println("Count: " + temp.instanceCount);
+    }
+}
diff --git a/priv/combined_metrics/samples/consistency/static_member_via_class_name/good/ProductCatalog.java b/priv/combined_metrics/samples/consistency/static_member_via_class_name/good/ProductCatalog.java
new file mode 100644
index 0000000..363e97a
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/static_member_via_class_name/good/ProductCatalog.java
@@ -0,0 +1,62 @@
+package com.example.catalog;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+public class ProductCatalog {
+
+    public static final int MAX_SEARCH_RESULTS = 100;
+    public static final BigDecimal DEFAULT_TAX_RATE = new BigDecimal("0.20");
+
+    private static int instanceCount = 0;
+
+    private final String region;
+    private final ProductRepository repository;
+
+    public ProductCatalog(String region, ProductRepository repository) {
+        this.region = region;
+        this.repository = repository;
+        ProductCatalog.instanceCount++;
+    }
+
+    public List<Product> search(String query) {
+        // Accessing static constant via class name
+        return repository.search(query, ProductCatalog.MAX_SEARCH_RESULTS);
+    }
+
+    public BigDecimal priceWithTax(Product product) {
+        // Accessing static constant via class name
+        return product.getBasePrice().multiply(
+            BigDecimal.ONE.add(ProductCatalog.DEFAULT_TAX_RATE)
+        );
+    }
+
+    public static ProductCatalog forRegion(String region, ProductRepository repo) {
+        return new ProductCatalog(region, repo);
+    }
+
+    public static int getInstanceCount() {
+        // Accessing static field via class name inside static method
+        return ProductCatalog.instanceCount;
+    }
+
+    public void resetInstanceTracking() {
+        // Static field accessed via class name even from instance method
+        ProductCatalog.instanceCount = 0;
+    }
+
+    public Product findBySkuOrThrow(String sku) {
+        Product product = repository.findBySku(sku);
+        if (product == null) {
+            throw new ProductNotFoundException(sku);
+        }
+        return product;
+    }
+
+    public List<Product> findOnSale() {
+        return repository.findAll().stream()
+            .filter(Product::isOnSale)
+            .limit(ProductCatalog.MAX_SEARCH_RESULTS)
+            .toList();
+    }
+}
diff --git a/priv/combined_metrics/samples/consistency/switch_fallthrough_has_comment/bad/OrderService.php b/priv/combined_metrics/samples/consistency/switch_fallthrough_has_comment/bad/OrderService.php
new file mode 100644
index 0000000..90f311c
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/switch_fallthrough_has_comment/bad/OrderService.php
@@ -0,0 +1,71 @@
+<?php
+
+namespace App\Service;
+
+class OrderService
+{
+    public function getStatusLabel($status): string
+    {
+        switch ($status) {
+            case 'pending':
+                return 'Awaiting Confirmation';
+            case 'confirmed':
+                return 'Confirmed';
+            case 'processing':
+                return 'Being Prepared';
+            case 'shipped':
+                return 'On the Way';
+            case 'delivered':
+                // Falls through to 'completed' with no comment — PSR-12 violation
+            case 'completed':
+                return 'Delivered';
+            case 'cancelled':
+                return 'Cancelled';
+            default:
+                return 'Unknown';
+        }
+    }
+
+    public function getStatusPriority($status): int
+    {
+        switch ($status) {
+            case 'pending':
+                $priority = 10;
+                break;
+            case 'confirmed':
+                // Intentional fall-through but missing the required `// no break` comment
+            case 'processing':
+                $priority = 20;
+                break;
+            case 'shipped':
+                $priority = 30;
+                break;
+            case 'delivered':
+                // Missing fall-through comment
+            case 'completed':
+                $priority = 0;
+                break;
+            default:
+                $priority = -1;
+                break;
+        }
+
+        return $priority;
+    }
+
+    public function applyDiscount($status, &$total): void
+    {
+        switch ($status) {
+            case 'vip':
+                $total *= 0.8;
+                // Falls through without comment — ambiguous: bug or intent?
+            case 'member':
+                $total *= 0.95;
+                break;
+            case 'guest':
+                break;
+            default:
+                break;
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/consistency/switch_fallthrough_has_comment/good/OrderService.php b/priv/combined_metrics/samples/consistency/switch_fallthrough_has_comment/good/OrderService.php
new file mode 100644
index 0000000..06d952e
--- /dev/null
+++ b/priv/combined_metrics/samples/consistency/switch_fallthrough_has_comment/good/OrderService.php
@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+class OrderService
+{
+    public function getStatusLabel(string $status): string
+    {
+        switch ($status) {
+            case 'pending':
+                return 'Awaiting Confirmation';
+            case 'confirmed':
+                return 'Confirmed';
+            case 'processing':
+                return 'Being Prepared';
+            case 'shipped':
+                return 'On the Way';
+            case 'delivered':
+                // no break
+            case 'completed':
+                // Both 'delivered' and 'completed' map to the same label.
+                // Intentional fall-through marked with `// no break`.
+                return 'Delivered';
+            case 'cancelled':
+                return 'Cancelled';
+            default:
+                return 'Unknown';
+        }
+    }
+
+    public function getStatusPriority(string $status): int
+    {
+        switch ($status) {
+            case 'pending':
+                $priority = 10;
+                break;
+            case 'confirmed':
+                // no break
+            case 'processing':
+                // Both 'confirmed' and 'processing' have the same urgency level.
+                // Intentional fall-through.
+                $priority = 20;
+                break;
+            case 'shipped':
+                $priority = 30;
+                break;
+            case 'delivered':
+                // no break
+            case 'completed':
+                // Intentional fall-through — both statuses are terminal.
+                $priority = 0;
+                break;
+            default:
+                $priority = -1;
+                break;
+        }
+
+        return $priority;
+    }
+
+    public function canTransitionTo(string $current, string $next): bool
+    {
+        switch ($current) {
+            case 'pending':
+                return in_array($next, ['confirmed', 'cancelled'], true);
+            case 'confirmed':
+                return in_array($next, ['processing', 'cancelled'], true);
+            case 'processing':
+                return $next === 'shipped';
+            case 'shipped':
+                return in_array($next, ['delivered', 'completed'], true);
+            default:
+                return false;
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/dependencies/import_count_under_10/bad/dashboard.ex b/priv/combined_metrics/samples/dependencies/import_count_under_10/bad/dashboard.ex
new file mode 100644
index 0000000..bdc4822
--- /dev/null
+++ b/priv/combined_metrics/samples/dependencies/import_count_under_10/bad/dashboard.ex
@@ -0,0 +1,80 @@
+defmodule MyApp.Dashboard do
+  alias MyApp.Accounts.User
+  alias MyApp.Accounts.UserToken
+  alias MyApp.Accounts.UserProfile
+  alias MyApp.Orders.Order
+  alias MyApp.Orders.OrderItem
+  alias MyApp.Orders.OrderStatus
+  alias MyApp.Billing.Invoice
+  alias MyApp.Billing.Payment
+  alias MyApp.Billing.PaymentMethod
+  alias MyApp.Shipping.Shipment
+  alias MyApp.Shipping.TrackingEvent
+  alias MyApp.Notifications.Notification
+  alias MyApp.Notifications.EmailTemplate
+  alias MyApp.Analytics.Event, as: AnalyticsEvent
+  alias MyApp.Analytics.Report
+  alias MyApp.Repo
+
+  @moduledoc """
+  Dashboard aggregation module that compiles user-facing metrics
+  and summaries from all subdomains.
+  """
+
+  @spec summary(User.t()) :: map()
+  def summary(%User{} = user) do
+    %{
+      orders: recent_orders(user),
+      invoices: open_invoices(user),
+      shipments: active_shipments(user),
+      notifications: unread_notifications(user)
+    }
+  end
+
+  @spec recent_orders(User.t()) :: [Order.t()]
+  def recent_orders(%User{id: user_id}) do
+    Repo.all(
+      from o in Order,
+        where: o.user_id == ^user_id,
+        order_by: [desc: o.inserted_at],
+        limit: 5,
+        preload: [:items]
+    )
+  end
+
+  @spec open_invoices(User.t()) :: [Invoice.t()]
+  def open_invoices(%User{id: user_id}) do
+    Repo.all(
+      from i in Invoice,
+        where: i.user_id == ^user_id and i.status == :open
+    )
+  end
+
+  @spec active_shipments(User.t()) :: [Shipment.t()]
+  def active_shipments(%User{id: user_id}) do
+    Repo.all(
+      from s in Shipment,
+        where: s.user_id == ^user_id and s.status == :in_transit,
+        preload: [:tracking_events]
+    )
+  end
+
+  @spec unread_notifications(User.t()) :: [Notification.t()]
+  def unread_notifications(%User{id: user_id}) do
+    Repo.all(
+      from n in Notification,
+        where: n.user_id == ^user_id and n.read == false,
+        order_by: [desc: n.inserted_at]
+    )
+  end
+
+  @spec analytics_report(User.t(), Date.t(), Date.t()) :: Report.t()
+  def analytics_report(%User{id: user_id}, from, to) do
+    events = Repo.all(
+      from e in AnalyticsEvent,
+        where: e.user_id == ^user_id and e.date >= ^from and e.date <= ^to
+    )
+
+    %Report{user_id: user_id, events: events}
+  end
+end
diff --git a/priv/combined_metrics/samples/dependencies/import_count_under_10/config.yml b/priv/combined_metrics/samples/dependencies/import_count_under_10/config.yml
new file mode 100644
index 0000000..3fad5bf
--- /dev/null
+++ b/priv/combined_metrics/samples/dependencies/import_count_under_10/config.yml
@@ -0,0 +1 @@
+doc: "Files should import fewer than 10 modules; high import counts signal excessive coupling."
diff --git a/priv/combined_metrics/samples/dependencies/import_count_under_10/good/dashboard.ex b/priv/combined_metrics/samples/dependencies/import_count_under_10/good/dashboard.ex
new file mode 100644
index 0000000..8313437
--- /dev/null
+++ b/priv/combined_metrics/samples/dependencies/import_count_under_10/good/dashboard.ex
@@ -0,0 +1,80 @@
+defmodule MyApp.Dashboard do
+  @moduledoc """
+  Dashboard aggregation module that compiles user-facing metrics
+  and summaries from all subdomains.
+  """
+
+  alias MyApp.Accounts
+  alias MyApp.Orders
+  alias MyApp.Billing
+  alias MyApp.Shipping
+  alias MyApp.Notifications
+
+  @spec summary(Accounts.User.t()) :: map()
+  def summary(user) do
+    %{
+      orders: Orders.recent_for_user(user, limit: 5),
+      invoices: Billing.open_invoices_for_user(user),
+      shipments: Shipping.active_shipments_for_user(user),
+      notifications: Notifications.unread_for_user(user)
+    }
+  end
+
+  @spec order_count(Accounts.User.t()) :: non_neg_integer()
+  def order_count(user) do
+    user
+    |> Orders.for_user()
+    |> length()
+  end
+
+  @spec billing_status(Accounts.User.t()) :: :current | :overdue | :no_invoices
+  def billing_status(user) do
+    user
+    |> Billing.open_invoices_for_user()
+    |> determine_billing_status()
+  end
+
+  @spec shipment_summary(Accounts.User.t()) :: map()
+  def shipment_summary(user) do
+    shipments = Shipping.active_shipments_for_user(user)
+
+    %{
+      in_transit: Enum.count(shipments, &(&1.status == :in_transit)),
+      delivered: Enum.count(shipments, &(&1.status == :delivered)),
+      total: length(shipments)
+    }
+  end
+
+  @spec notification_badge(Accounts.User.t()) :: non_neg_integer()
+  def notification_badge(user) do
+    user
+    |> Notifications.unread_for_user()
+    |> length()
+  end
+
+  @spec activity_feed(Accounts.User.t(), keyword()) :: [map()]
+  def activity_feed(user, opts \\ []) do
+    limit = Keyword.get(opts, :limit, 20)
+
+    [
+      Orders.recent_for_user(user, limit: limit),
+      Shipping.recent_events_for_user(user, limit: limit),
+      Notifications.unread_for_user(user)
+    ]
+    |> List.flatten()
+    |> Enum.sort_by(& &1.inserted_at, {:desc, DateTime})
+    |> Enum.take(limit)
+  end
+
+  # Private
+
+  defp determine_billing_status([]), do: :no_invoices
+
+  defp determine_billing_status(invoices) do
+    if Enum.any?(invoices, &past_due?/1), do: :overdue, else: :current
+  end
+
+  defp past_due?(%{due_date: due_date}) do
+    Date.compare(due_date, Date.utc_today()) == :lt
+  end
+end
diff --git a/priv/combined_metrics/samples/dependencies/low_coupling/bad/order_controller.ex b/priv/combined_metrics/samples/dependencies/low_coupling/bad/order_controller.ex
new file mode 100644
index 0000000..e52e77e
--- /dev/null
+++ b/priv/combined_metrics/samples/dependencies/low_coupling/bad/order_controller.ex
@@ -0,0 +1,91 @@
+defmodule MyAppWeb.OrderController do
+  use MyAppWeb, :controller
+
+  alias MyApp.Repo
+  alias MyApp.Orders.Order
+  alias MyApp.Orders.OrderItem
+  alias MyApp.Accounts.User
+  alias MyApp.Billing.Invoice
+  alias MyApp.Notifications.Mailer
+  alias MyApp.Shipping.ShipmentService
+
+  @moduledoc """
+  Controller for order lifecycle management.
+  """
+
+  def index(conn, _params) do
+    user_id = conn.assigns.current_user.id
+
+    orders =
+      Repo.all(
+        from o in Order,
+          where: o.user_id == ^user_id,
+          preload: [:items, :invoice]
+      )
+
+    render(conn, :index, orders: orders)
+  end
+
+  def show(conn, %{"id" => id}) do
+    order = Repo.get!(Order, id) |> Repo.preload([:items, :invoice, :user])
+    render(conn, :show, order: order)
+  end
+
+  def create(conn, %{"order" => params}) do
+    user = Repo.get!(User, conn.assigns.current_user.id)
+
+    changeset = Order.changeset(%Order{}, Map.put(params, "user_id", user.id))
+
+    case Repo.insert(changeset) do
+      {:ok, order} ->
+        items = Map.get(params, "items", [])
+
+        Enum.each(items, fn item_params ->
+          %OrderItem{}
+          |> OrderItem.changeset(Map.put(item_params, "order_id", order.id))
+          |> Repo.insert!()
+        end)
+
+        invoice = Repo.insert!(%Invoice{order_id: order.id, user_id: user.id, status: :open})
+
+        total = Enum.reduce(items, 0, fn i, acc -> acc + i["price"] * i["quantity"] end)
+        Repo.update!(Invoice.changeset(invoice, %{total: total}))
+
+        ShipmentService.create_shipment_for_order(order)
+
+        Mailer.send_order_confirmation(user.email, order)
+
+        conn
+        |> put_status(:created)
+        |> render(:show, order: order)
+
+      {:error, changeset} ->
+        conn
+        |> put_status(:unprocessable_entity)
+        |> render(:error, changeset: changeset)
+    end
+  end
+
+  def cancel(conn, %{"id" => id}) do
+    order = Repo.get!(Order, id)
+
+    case Repo.update(Order.changeset(order, %{status: :cancelled})) do
+      {:ok, order} ->
+        invoice = Repo.get_by!(Invoice, order_id: order.id)
+        Repo.update!(Invoice.changeset(invoice, %{status: :voided}))
+
+        shipment = ShipmentService.find_shipment(order.id)
+        if shipment, do: ShipmentService.cancel_shipment(shipment)
+
+        user = Repo.get!(User, order.user_id)
+        Mailer.send_cancellation_notice(user.email, order)
+
+        render(conn, :show, order: order)
+
+      {:error, changeset} ->
+        conn
+        |> put_status(:unprocessable_entity)
+        |> render(:error, changeset: changeset)
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/dependencies/low_coupling/config.yml b/priv/combined_metrics/samples/dependencies/low_coupling/config.yml
new file mode 100644
index 0000000..a84bf39
--- /dev/null
+++ b/priv/combined_metrics/samples/dependencies/low_coupling/config.yml
@@ -0,0 +1 @@
+doc: "Modules should depend on few external symbols — a low unique-operand count relative to total is a proxy for tight coupling."
diff --git a/priv/combined_metrics/samples/dependencies/low_coupling/good/order_controller.ex b/priv/combined_metrics/samples/dependencies/low_coupling/good/order_controller.ex
new file mode 100644
index 0000000..0bbb5c1
--- /dev/null
+++ b/priv/combined_metrics/samples/dependencies/low_coupling/good/order_controller.ex
@@ -0,0 +1,57 @@
+defmodule MyAppWeb.OrderController do
+  use MyAppWeb, :controller
+
+  alias MyApp.Orders
+
+  @moduledoc """
+  Controller for order lifecycle management.
+  Delegates all business logic to the Orders context.
+  """
+
+  action_fallback MyAppWeb.FallbackController
+
+  def index(conn, _params) do
+    orders = Orders.list_orders_for_user(conn.assigns.current_user)
+    render(conn, :index, orders: orders)
+  end
+
+  def show(conn, %{"id" => id}) do
+    with {:ok, order} <- Orders.get_order(id, conn.assigns.current_user) do
+      render(conn, :show, order: order)
+    end
+  end
+
+  def create(conn, %{"order" => params}) do
+    with {:ok, order} <- Orders.place_order(conn.assigns.current_user, params) do
+      conn
+      |> put_status(:created)
+      |> render(:show, order: order)
+    end
+  end
+
+  def cancel(conn, %{"id" => id}) do
+    with {:ok, order} <- Orders.get_order(id, conn.assigns.current_user),
+         {:ok, cancelled} <- Orders.cancel_order(order) do
+      render(conn, :show, order: cancelled)
+    end
+  end
+
+  def update(conn, %{"id" => id, "order" => params}) do
+    with {:ok, order} <- Orders.get_order(id, conn.assigns.current_user),
+         {:ok, updated} <- Orders.update_order(order, params) do
+      render(conn, :show, order: updated)
+    end
+  end
+
+  def history(conn, params) do
+    page = Map.get(params, "page", 1)
+    per_page = Map.get(params, "per_page", 20)
+
+    orders = Orders.order_history_for_user(conn.assigns.current_user,
+      page: page,
+      per_page: per_page
+    )
+
+    render(conn, :index, orders: orders)
+  end
+end
diff --git a/priv/combined_metrics/samples/dependencies/no_default_exports/bad/payment_gateway.ts b/priv/combined_metrics/samples/dependencies/no_default_exports/bad/payment_gateway.ts
new file mode 100644
index 0000000..d50dc6c
--- /dev/null
+++ b/priv/combined_metrics/samples/dependencies/no_default_exports/bad/payment_gateway.ts
@@ -0,0 +1,68 @@
+interface ChargeRequest {
+  amount: number;
+  currency: string;
+  paymentMethodId: string;
+  customerId: string;
+}
+
+interface ChargeResult {
+  id: string;
+  status: "succeeded" | "pending" | "failed";
+  amount: number;
+  currency: string;
+  createdAt: string;
+}
+
+interface RefundRequest {
+  chargeId: string;
+  amount?: number;
+  reason?: string;
+}
+
+interface RefundResult {
+  id: string;
+  chargeId: string;
+  amount: number;
+  status: "pending" | "succeeded";
+}
+
+async function createCharge(request: ChargeRequest): Promise<ChargeResult> {
+  const response = await fetch("/api/charges", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request),
+  });
+  if (!response.ok) throw new Error(`Charge failed: ${response.status}`);
+  return response.json() as Promise<ChargeResult>;
+}
+
+async function fetchCharge(chargeId: string): Promise<ChargeResult> {
+  const response = await fetch(`/api/charges/${chargeId}`);
+  if (!response.ok) throw new Error(`Charge not found: ${chargeId}`);
+  return response.json() as Promise<ChargeResult>;
+}
+
+async function refundCharge(request: RefundRequest): Promise<RefundResult> {
+  const response = await fetch("/api/refunds", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request),
+  });
+  if (!response.ok) throw new Error(`Refund failed: ${response.status}`);
+  return response.json() as Promise<RefundResult>;
+}
+
+function formatChargeAmount(charge: ChargeResult): string {
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: charge.currency,
+  }).format(charge.amount / 100);
+}
+
+// Default export makes it hard to rename consistently across the codebase
+export default {
+  createCharge,
+  fetchCharge,
+  refundCharge,
+  formatChargeAmount,
+};
diff --git a/priv/combined_metrics/samples/dependencies/no_default_exports/good/payment_gateway.ts b/priv/combined_metrics/samples/dependencies/no_default_exports/good/payment_gateway.ts
new file mode 100644
index 0000000..5cc1ba3
--- /dev/null
+++ b/priv/combined_metrics/samples/dependencies/no_default_exports/good/payment_gateway.ts
@@ -0,0 +1,63 @@
+interface ChargeRequest {
+  amount: number;
+  currency: string;
+  paymentMethodId: string;
+  customerId: string;
+}
+
+interface ChargeResult {
+  id: string;
+  status: "succeeded" | "pending" | "failed";
+  amount: number;
+  currency: string;
+  createdAt: string;
+}
+
+interface RefundRequest {
+  chargeId: string;
+  amount?: number;
+  reason?: string;
+}
+
+interface RefundResult {
+  id: string;
+  chargeId: string;
+  amount: number;
+  status: "pending" | "succeeded";
+}
+
+async function createCharge(request: ChargeRequest): Promise<ChargeResult> {
+  const response = await fetch("/api/charges", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request),
+  });
+  if (!response.ok) throw new Error(`Charge failed: ${response.status}`);
+  return response.json() as Promise<ChargeResult>;
+}
+
+async function fetchCharge(chargeId: string): Promise<ChargeResult> {
+  const response = await fetch(`/api/charges/${chargeId}`);
+  if (!response.ok) throw new Error(`Charge not found: ${chargeId}`);
+  return response.json() as Promise<ChargeResult>;
+}
+
+async function refundCharge(request: RefundRequest): Promise<RefundResult> {
+  const response = await fetch("/api/refunds", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request),
+  });
+  if (!response.ok) throw new Error(`Refund failed: ${response.status}`);
+  return response.json() as Promise<RefundResult>;
+}
+
+function formatChargeAmount(charge: ChargeResult): string {
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: charge.currency,
+  }).format(charge.amount / 100);
+}
+
+export { createCharge, fetchCharge, refundCharge, formatChargeAmount };
+export type { ChargeRequest, ChargeResult, RefundRequest, RefundResult };
diff --git a/priv/combined_metrics/samples/dependencies/no_mutable_exports/bad/product_repository.ts b/priv/combined_metrics/samples/dependencies/no_mutable_exports/bad/product_repository.ts
new file mode 100644
index 0000000..d1daac2
--- /dev/null
+++ b/priv/combined_metrics/samples/dependencies/no_mutable_exports/bad/product_repository.ts
@@ -0,0 +1,46 @@
+interface Product {
+  id: string;
+  name: string;
+  price: number;
+  category: string;
+}
+
+// Exported mutable state — consumers can accidentally mutate these
+export let productCache: Map<string, Product> = new Map();
+export let cacheLastFetchedAt: number | null = null;
+export let isLoading = false;
+
+const CACHE_TTL_MS = 5 * 60 * 1000;
+
+function isCacheStale(): boolean {
+  return cacheLastFetchedAt === null || Date.now() - cacheLastFetchedAt > CACHE_TTL_MS;
+}
+
+export async function loadProducts(): Promise<void> {
+  isLoading = true;
+  try {
+    const response = await fetch("/api/products");
+    if (!response.ok) throw new Error(`Failed to load products: ${response.status}`);
+    const products: Product[] = await response.json();
+
+    productCache = new Map(products.map((p) => [p.id, p]));
+    cacheLastFetchedAt = Date.now();
+  } finally {
+    isLoading = false;
+  }
+}
+
+export async function getProducts(): Promise<Product[]> {
+  if (isCacheStale()) await loadProducts();
+  return Array.from(productCache.values());
+}
+
+export async function getProduct(id: string): Promise<Product | null> {
+  if (isCacheStale()) await loadProducts();
+  return productCache.get(id) ?? null;
+}
+
+export function invalidateCache(): void {
+  productCache = new Map();
+  cacheLastFetchedAt = null;
+}
diff --git a/priv/combined_metrics/samples/dependencies/no_mutable_exports/good/product_repository.ts b/priv/combined_metrics/samples/dependencies/no_mutable_exports/good/product_repository.ts
new file mode 100644
index 0000000..66a99a3
--- /dev/null
+++ b/priv/combined_metrics/samples/dependencies/no_mutable_exports/good/product_repository.ts
@@ -0,0 +1,57 @@
+interface Product {
+  id: string;
+  name: string;
+  price: number;
+  category: string;
+}
+
+interface CacheState {
+  products: Map<string, Product>;
+  lastFetchedAt: number | null;
+}
+
+const state: CacheState = {
+  products: new Map(),
+  lastFetchedAt: null,
+};
+
+const CACHE_TTL_MS = 5 * 60 * 1000;
+
+function isCacheStale(): boolean {
+  return state.lastFetchedAt === null || Date.now() - state.lastFetchedAt > CACHE_TTL_MS;
+}
+
+async function loadProducts(): Promise<void> {
+  const response = await fetch("/api/products");
+  if (!response.ok) throw new Error(`Failed to load products: ${response.status}`);
+  const products: Product[] = await response.json();
+
+  state.products.clear();
+  for (const product of products) {
+    state.products.set(product.id, product);
+  }
+  state.lastFetchedAt = Date.now();
+}
+
+async function getProducts(): Promise<Product[]> {
+  if (isCacheStale()) await loadProducts();
+  return Array.from(state.products.values());
+}
+
+async function getProduct(id: string): Promise<Product | null> {
+  if (isCacheStale()) await loadProducts();
+  return state.products.get(id) ?? null;
+}
+
+function invalidateCache(): void {
+  state.products.clear();
+  state.lastFetchedAt = null;
+}
+
+function getCacheAge(): number | null {
+  if (state.lastFetchedAt === null) return null;
+  return Date.now() - state.lastFetchedAt;
+}
+
+export { getProducts, getProduct, invalidateCache, getCacheAge, loadProducts };
+export type { Product };
diff --git a/priv/combined_metrics/samples/dependencies/no_wildcard_imports/bad/query_helpers.ex b/priv/combined_metrics/samples/dependencies/no_wildcard_imports/bad/query_helpers.ex
new file mode 100644
index 0000000..32f1c3d
--- /dev/null
+++ b/priv/combined_metrics/samples/dependencies/no_wildcard_imports/bad/query_helpers.ex
@@ -0,0 +1,74 @@
+defmodule MyApp.QueryHelpers do
+  @moduledoc """
+  Helpers for building common Ecto query patterns.
+  """
+
+  import Ecto.Query
+  import Ecto.Changeset
+  import MyApp.QueryFilters
+  import MyApp.PaginationHelpers
+
+  @spec paginate(Ecto.Queryable.t(), map()) :: Ecto.Query.t()
+  def paginate(query, params) do
+    page = Map.get(params, "page", 1)
+    per_page = Map.get(params, "per_page", 20)
+
+    query
+    |> offset(^((page - 1) * per_page))
+    |> limit(^per_page)
+  end
+
+  @spec filter_by_status(Ecto.Queryable.t(), atom()) :: Ecto.Query.t()
+  def filter_by_status(query, status) do
+    where(query, [q], q.status == ^status)
+  end
+
+  @spec filter_by_user(Ecto.Queryable.t(), integer()) :: Ecto.Query.t()
+  def filter_by_user(query, user_id) do
+    where(query, [q], q.user_id == ^user_id)
+  end
+
+  @spec order_by_inserted(Ecto.Queryable.t(), :asc | :desc) :: Ecto.Query.t()
+  def order_by_inserted(query, direction \\ :desc) do
+    order_by(query, [q], [{^direction, q.inserted_at}])
+  end
+
+  @spec search_name(Ecto.Queryable.t(), String.t()) :: Ecto.Query.t()
+  def search_name(query, term) do
+    like_term = "%#{term}%"
+    where(query, [q], ilike(q.name, ^like_term))
+  end
+
+  @spec with_preloads(Ecto.Queryable.t(), list()) :: Ecto.Query.t()
+  def with_preloads(query, associations) do
+    preload(query, ^associations)
+  end
+
+  @spec apply_filters(Ecto.Queryable.t(), map()) :: Ecto.Query.t()
+  def apply_filters(query, filters) do
+    Enum.reduce(filters, query, fn
+      {"status", status}, q -> filter_by_status(q, String.to_atom(status))
+      {"user_id", id}, q -> filter_by_user(q, id)
+      {"search", term}, q -> search_name(q, term)
+      _unknown, q -> q
+    end)
+  end
+
+  @spec validate_and_apply(Ecto.Changeset.t(), map()) :: Ecto.Changeset.t()
+  def validate_and_apply(changeset, attrs) do
+    changeset
+    |> cast(attrs, [:status, :name])
+    |> validate_required([:status])
+    |> validate_inclusion(:status, [:active, :inactive, :pending])
+  end
+
+  @spec count_query(Ecto.Queryable.t()) :: Ecto.Query.t()
+  def count_query(query) do
+    from q in query, select: count(q.id)
+  end
+
+  @spec date_range(Ecto.Queryable.t(), Date.t(), Date.t()) :: Ecto.Query.t()
+  def date_range(query, from_date, to_date) do
+    where(query, [q], q.inserted_at >= ^from_date and q.inserted_at <= ^to_date)
+  end
+end
diff --git a/priv/combined_metrics/samples/dependencies/no_wildcard_imports/config.yml b/priv/combined_metrics/samples/dependencies/no_wildcard_imports/config.yml
new file mode 100644
index 0000000..4b85bcb
--- /dev/null
+++ b/priv/combined_metrics/samples/dependencies/no_wildcard_imports/config.yml
@@ -0,0 +1 @@
+doc: "Wildcard imports (`import *`, `using Module`) pollute the local namespace and hide dependencies."
diff --git a/priv/combined_metrics/samples/dependencies/no_wildcard_imports/good/query_helpers.ex b/priv/combined_metrics/samples/dependencies/no_wildcard_imports/good/query_helpers.ex
new file mode 100644
index 0000000..ccde3df
--- /dev/null
+++ b/priv/combined_metrics/samples/dependencies/no_wildcard_imports/good/query_helpers.ex
@@ -0,0 +1,73 @@
+defmodule MyApp.QueryHelpers do
+  @moduledoc """
+  Helpers for building common Ecto query patterns.
+  """
+
+  import Ecto.Query, only: [from: 2, where: 3, order_by: 3, limit: 2, offset: 2, preload: 2]
+  import Ecto.Changeset, only: [cast: 3, validate_required: 2, validate_inclusion: 3]
+
+  alias MyApp.QueryFilters
+  alias MyApp.PaginationHelpers
+
+  @spec paginate(Ecto.Queryable.t(), map()) :: Ecto.Query.t()
+  def paginate(query, params) do
+    {page, per_page} = PaginationHelpers.extract_pagination(params)
+
+    query
+    |> offset(^((page - 1) * per_page))
+    |> limit(^per_page)
+  end
+
+  @spec filter_by_status(Ecto.Queryable.t(), atom()) :: Ecto.Query.t()
+  def filter_by_status(query, status) do
+    where(query, [q], q.status == ^status)
+  end
+
+  @spec filter_by_user(Ecto.Queryable.t(), integer()) :: Ecto.Query.t()
+  def filter_by_user(query, user_id) do
+    where(query, [q], q.user_id == ^user_id)
+  end
+
+  @spec order_by_inserted(Ecto.Queryable.t(), :asc | :desc) :: Ecto.Query.t()
+  def order_by_inserted(query, direction \\ :desc) do
+    order_by(query, [q], [{^direction, q.inserted_at}])
+  end
+
+  @spec search_name(Ecto.Queryable.t(), String.t()) :: Ecto.Query.t()
+  def search_name(query, term) do
+    QueryFilters.ilike_search(query, :name, term)
+  end
+
+  @spec with_preloads(Ecto.Queryable.t(), list()) :: Ecto.Query.t()
+  def with_preloads(query, associations) do
+    preload(query, ^associations)
+  end
+
+  @spec apply_filters(Ecto.Queryable.t(), map()) :: Ecto.Query.t()
+  def apply_filters(query, filters) do
+    Enum.reduce(filters, query, fn
+      {"status", status}, q -> filter_by_status(q, String.to_atom(status))
+      {"user_id", id}, q -> filter_by_user(q, id)
+      {"search", term}, q -> search_name(q, term)
+      _unknown, q -> q
+    end)
+  end
+
+  @spec validate_and_apply(Ecto.Changeset.t(), map()) :: Ecto.Changeset.t()
+  def validate_and_apply(changeset, attrs) do
+    changeset
+    |> cast(attrs, [:status, :name])
+    |> validate_required([:status])
+    |> validate_inclusion(:status, [:active, :inactive, :pending])
+  end
+
+  @spec count_query(Ecto.Queryable.t()) :: Ecto.Query.t()
+  def count_query(query) do
+    from q in query, select: count(q.id)
+  end
+
+  @spec date_range(Ecto.Queryable.t(), Date.t(), Date.t()) :: Ecto.Query.t()
+  def date_range(query, from_date, to_date) do
+    where(query, [q], q.inserted_at >= ^from_date and q.inserted_at <= ^to_date)
+  end
+end
diff --git a/priv/combined_metrics/samples/dependencies/uses_import_type_for_type_only_imports/bad/user_service.ts b/priv/combined_metrics/samples/dependencies/uses_import_type_for_type_only_imports/bad/user_service.ts
new file mode 100644
index 0000000..a1fbecd
--- /dev/null
+++ b/priv/combined_metrics/samples/dependencies/uses_import_type_for_type_only_imports/bad/user_service.ts
@@ -0,0 +1,47 @@
+// Regular imports used for type-only symbols — should use `import type`
+import { User, CreateUserPayload, UpdateUserPayload } from "./user_types.js";
+import { PaginatedResponse, ApiError } from "./api_types.js";
+import { buildApiUrl, handleResponse } from "./api_client.js";
+import { formatDate } from "./date_utils.js";
+
+async function fetchUser(userId: string): Promise<User> {
+  const url = buildApiUrl(`/users/${userId}`);
+  const response = await fetch(url);
+  return handleResponse<User>(response);
+}
+
+async function createUser(payload: CreateUserPayload): Promise<User> {
+  const url = buildApiUrl("/users");
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload),
+  });
+  return handleResponse<User>(response);
+}
+
+async function updateUser(userId: string, changes: UpdateUserPayload): Promise<User> {
+  const url = buildApiUrl(`/users/${userId}`);
+  const response = await fetch(url, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(changes),
+  });
+  return handleResponse<User>(response);
+}
+
+async function listUsers(page = 1, pageSize = 20): Promise<PaginatedResponse<User>> {
+  const url = buildApiUrl(`/users?page=${page}&pageSize=${pageSize}`);
+  const response = await fetch(url);
+  return handleResponse<PaginatedResponse<User>>(response);
+}
+
+function handleApiError(error: ApiError): void {
+  console.error(`API error [${error.code}]: ${error.message}`);
+}
+
+function formatUserCreatedDate(user: User): string {
+  return formatDate(user.createdAt);
+}
+
+export { fetchUser, createUser, updateUser, listUsers, handleApiError, formatUserCreatedDate };
diff --git a/priv/combined_metrics/samples/dependencies/uses_import_type_for_type_only_imports/good/user_service.ts b/priv/combined_metrics/samples/dependencies/uses_import_type_for_type_only_imports/good/user_service.ts
new file mode 100644
index 0000000..78fef3b
--- /dev/null
+++ b/priv/combined_metrics/samples/dependencies/uses_import_type_for_type_only_imports/good/user_service.ts
@@ -0,0 +1,47 @@
+import type { User, CreateUserPayload, UpdateUserPayload } from "./user_types.js";
+import type { PaginatedResponse, ApiError } from "./api_types.js";
+import { buildApiUrl, handleResponse } from "./api_client.js";
+import { formatDate } from "./date_utils.js";
+
+async function fetchUser(userId: string): Promise<User> {
+  const url = buildApiUrl(`/users/${userId}`);
+  const response = await fetch(url);
+  return handleResponse<User>(response);
+}
+
+async function createUser(payload: CreateUserPayload): Promise<User> {
+  const url = buildApiUrl("/users");
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload),
+  });
+  return handleResponse<User>(response);
+}
+
+async function updateUser(userId: string, changes: UpdateUserPayload): Promise<User> {
+  const url = buildApiUrl(`/users/${userId}`);
+  const response = await fetch(url, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(changes),
+  });
+  return handleResponse<User>(response);
+}
+
+async function listUsers(page = 1, pageSize = 20): Promise<PaginatedResponse<User>> {
+  const url = buildApiUrl(`/users?page=${page}&pageSize=${pageSize}`);
+  const response = await fetch(url);
+  return handleResponse<PaginatedResponse<User>>(response);
+}
+
+function formatUserCreatedDate(user: User): string {
+  return formatDate(user.createdAt);
+}
+
+function getUserDisplayLabel(user: User): string {
+  return `${user.displayName} <${user.email}>`;
+}
+
+export { fetchUser, createUser, updateUser, listUsers, formatUserCreatedDate, getUserDisplayLabel };
+export type { User, CreateUserPayload, UpdateUserPayload };
diff --git a/priv/combined_metrics/samples/documentation/docstring_is_nonempty/bad/cache.ex b/priv/combined_metrics/samples/documentation/docstring_is_nonempty/bad/cache.ex
new file mode 100644
index 0000000..1127e5f
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/docstring_is_nonempty/bad/cache.ex
@@ -0,0 +1,78 @@
+defmodule MyApp.Cache do
+  @moduledoc ""
+
+  @doc ""
+  @spec start_link(keyword()) :: GenServer.on_start()
+  def start_link(opts \\ []) do
+    name = Keyword.get(opts, :name, __MODULE__)
+    ttl = Keyword.get(opts, :ttl, :timer.minutes(5))
+    :ets.new(name, [:set, :public, :named_table, read_concurrency: true])
+    Agent.start_link(fn -> %{name: name, ttl: ttl} end, name: :"#{name}_agent")
+  end
+
+  @doc ""
+  @spec get(atom(), term()) :: term() | nil
+  def get(cache, key) do
+    case :ets.lookup(cache, key) do
+      [{^key, value, expires_at}] ->
+        if System.monotonic_time(:millisecond) < expires_at, do: value, else: nil
+
+      [] ->
+        nil
+    end
+  end
+
+  @doc ""
+  @spec put(atom(), term(), term(), keyword()) :: true
+  def put(cache, key, value, opts \\ []) do
+    ttl = Keyword.get(opts, :ttl, default_ttl(cache))
+    expires_at = System.monotonic_time(:millisecond) + ttl
+    :ets.insert(cache, {key, value, expires_at})
+  end
+
+  @doc ""
+  @spec delete(atom(), term()) :: true
+  def delete(cache, key) do
+    :ets.delete(cache, key)
+  end
+
+  @doc ""
+  @spec flush(atom()) :: true
+  def flush(cache) do
+    :ets.delete_all_objects(cache)
+  end
+
+  @doc ""
+  @spec fetch(atom(), term(), (-> term())) :: term()
+  def fetch(cache, key, fun) do
+    case get(cache, key) do
+      nil ->
+        value = fun.()
+        put(cache, key, value)
+        value
+
+      value ->
+        value
+    end
+  end
+
+  @doc ""
+  @spec size(atom()) :: non_neg_integer()
+  def size(cache) do
+    :ets.info(cache, :size)
+  end
+
+  @doc ""
+  @spec stats(atom()) :: map()
+  def stats(cache) do
+    %{
+      size: size(cache),
+      memory: :ets.info(cache, :memory)
+    }
+  end
+
+  defp default_ttl(cache) do
+    agent = :"#{cache}_agent"
+    Agent.get(agent, & &1.ttl)
+  end
+end
diff --git a/priv/combined_metrics/samples/documentation/docstring_is_nonempty/config.yml b/priv/combined_metrics/samples/documentation/docstring_is_nonempty/config.yml
new file mode 100644
index 0000000..02f3c8b
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/docstring_is_nonempty/config.yml
@@ -0,0 +1 @@
+doc: "Docstrings must contain meaningful content, not just a placeholder or empty string."
diff --git a/priv/combined_metrics/samples/documentation/docstring_is_nonempty/good/cache.ex b/priv/combined_metrics/samples/documentation/docstring_is_nonempty/good/cache.ex
new file mode 100644
index 0000000..89bb205
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/docstring_is_nonempty/good/cache.ex
@@ -0,0 +1,96 @@
+defmodule MyApp.Cache do
+  @moduledoc """
+  ETS-backed in-memory cache with per-entry TTL support.
+
+  Each cache instance is an ETS table created at startup via `start_link/1`.
+  Values are stored with an expiry timestamp and are considered stale after
+  their TTL has elapsed. Stale entries are not automatically evicted but are
+  ignored on read.
+
+  Use `fetch/3` for the common read-through pattern to avoid redundant
+  computations or database calls.
+  """
+
+  @doc """
+  Creates a new cache ETS table and starts its companion Agent.
+
+  Accepts the following options:
+  - `:name` — the atom name for the ETS table (defaults to `#{__MODULE__}`)
+  - `:ttl` — default time-to-live in milliseconds (defaults to 5 minutes)
+  """
+  @spec start_link(keyword()) :: GenServer.on_start()
+  def start_link(opts \\ []) do
+    name = Keyword.get(opts, :name, __MODULE__)
+    ttl = Keyword.get(opts, :ttl, :timer.minutes(5))
+    :ets.new(name, [:set, :public, :named_table, read_concurrency: true])
+    Agent.start_link(fn -> %{name: name, ttl: ttl} end, name: :"#{name}_agent")
+  end
+
+  @doc """
+  Returns the cached value for `key`, or `nil` if missing or expired.
+  """
+  @spec get(atom(), term()) :: term() | nil
+  def get(cache, key) do
+    case :ets.lookup(cache, key) do
+      [{^key, value, expires_at}] ->
+        if System.monotonic_time(:millisecond) < expires_at, do: value, else: nil
+
+      [] ->
+        nil
+    end
+  end
+
+  @doc """
+  Stores `value` under `key` in the cache with an optional `:ttl` override.
+
+  If `:ttl` is not provided, the cache's default TTL is used.
+  """
+  @spec put(atom(), term(), term(), keyword()) :: true
+  def put(cache, key, value, opts \\ []) do
+    ttl = Keyword.get(opts, :ttl, default_ttl(cache))
+    expires_at = System.monotonic_time(:millisecond) + ttl
+    :ets.insert(cache, {key, value, expires_at})
+  end
+
+  @doc """
+  Removes the entry for `key` from the cache.
+  """
+  @spec delete(atom(), term()) :: true
+  def delete(cache, key), do: :ets.delete(cache, key)
+
+  @doc """
+  Removes all entries from the cache without deleting the table itself.
+  """
+  @spec flush(atom()) :: true
+  def flush(cache), do: :ets.delete_all_objects(cache)
+
+  @doc """
+  Returns the cached value for `key`, computing and storing it via `fun` on a miss.
+
+  This is the preferred read-through pattern to avoid duplicate work:
+
+      MyApp.Cache.fetch(:my_cache, {:user, id}, fn -> Accounts.get_user!(id) end)
+  """
+  @spec fetch(atom(), term(), (-> term())) :: term()
+  def fetch(cache, key, fun) do
+    case get(cache, key) do
+      nil ->
+        value = fun.()
+        put(cache, key, value)
+        value
+
+      value ->
+        value
+    end
+  end
+
+  @doc """
+  Returns the number of entries currently stored in the cache table.
+  """
+  @spec size(atom()) :: non_neg_integer()
+  def size(cache), do: :ets.info(cache, :size)
+
+  defp default_ttl(cache) do
+    Agent.get(:"#{cache}_agent", & &1.ttl)
+  end
+end
diff --git a/priv/combined_metrics/samples/documentation/doctests_validate_examples/bad/billing.ex b/priv/combined_metrics/samples/documentation/doctests_validate_examples/bad/billing.ex
new file mode 100644
index 0000000..a90ebe2
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/doctests_validate_examples/bad/billing.ex
@@ -0,0 +1,59 @@
+defmodule MyApp.Billing.Formatter do
+  @moduledoc """
+  Formatting utilities for billing amounts and invoice references.
+  """
+
+  @doc """
+  Formats an integer amount in cents to a display string for the given currency.
+
+  For example, passing 2999 and :usd would return a string like "$29.99".
+  Passing 0 for any currency returns "0.00" with the appropriate symbol.
+  For unknown currencies the amount is formatted without a symbol prefix.
+
+  Note that the function expects a non-negative integer for cents.
+  Negative values are not supported and may produce unexpected output.
+  The currency atom should be one of :usd, :eur, or :gbp for proper
+  symbol formatting. Other atoms fall back to an uppercase string suffix.
+  """
+  # Bad: prose-only documentation with no `iex>` examples.
+  # The description is vague ("a string like...") and untestable.
+  # A doctest would pin the exact return values and catch regressions.
+  @spec format_amount(integer(), atom()) :: String.t()
+  def format_amount(cents, currency) when is_integer(cents) and cents >= 0 do
+    value = :erlang.float_to_binary(cents / 100, decimals: 2)
+
+    case currency do
+      :usd -> "$#{value}"
+      :eur -> "€#{value}"
+      :gbp -> "£#{value}"
+      other -> "#{value} #{other |> Atom.to_string() |> String.upcase()}"
+    end
+  end
+
+  @doc """
+  Generates an invoice reference string.
+
+  The format is "INV-" followed by the customer ID padded to 5 digits,
+  a dash, and the sequence number padded to 4 digits.
+  Customer IDs and sequence numbers must be positive integers.
+  """
+  # Bad: describes the format in prose but provides no runnable example.
+  # No doctest means the claimed format cannot be verified automatically.
+  @spec invoice_ref(pos_integer(), pos_integer()) :: String.t()
+  def invoice_ref(customer_id, sequence)
+      when is_integer(customer_id) and is_integer(sequence) do
+    "INV-#{String.pad_leading(to_string(customer_id), 5, "0")}-#{String.pad_leading(to_string(sequence), 4, "0")}"
+  end
+
+  @doc """
+  Checks whether an amount is valid for charging.
+  Returns true for amounts between 1 and 1,000,000 (inclusive), false otherwise.
+  Zero is not a valid charge amount. Amounts above one million are rejected.
+  """
+  # Bad: no iex> examples. The boundary conditions (0, 1, 1_000_000, 1_000_001)
+  # are described in words but never tested via doctest.
+  @spec valid_amount?(integer()) :: boolean()
+  def valid_amount?(amount) when is_integer(amount) do
+    amount in 1..1_000_000
+  end
+end
diff --git a/priv/combined_metrics/samples/documentation/doctests_validate_examples/good/billing.ex b/priv/combined_metrics/samples/documentation/doctests_validate_examples/good/billing.ex
new file mode 100644
index 0000000..d451fb6
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/doctests_validate_examples/good/billing.ex
@@ -0,0 +1,73 @@
+defmodule MyApp.Billing.Formatter do
+  @moduledoc """
+  Formatting utilities for billing amounts and invoice references.
+
+  All examples in this module's `@doc` blocks are run as ExUnit doctests.
+  See `test/my_app/billing/formatter_test.exs`.
+  """
+
+  @doc """
+  Formats an integer amount in cents to a display string for the given currency.
+
+      iex> MyApp.Billing.Formatter.format_amount(2999, :usd)
+      "$29.99"
+
+      iex> MyApp.Billing.Formatter.format_amount(1050, :eur)
+      "€10.50"
+
+      iex> MyApp.Billing.Formatter.format_amount(0, :gbp)
+      "£0.00"
+
+      iex> MyApp.Billing.Formatter.format_amount(100, :unknown)
+      "1.00 UNKNOWN"
+  """
+  @spec format_amount(integer(), atom()) :: String.t()
+  def format_amount(cents, currency) when is_integer(cents) and cents >= 0 do
+    value = :erlang.float_to_binary(cents / 100, decimals: 2)
+
+    case currency do
+      :usd -> "$#{value}"
+      :eur -> "€#{value}"
+      :gbp -> "£#{value}"
+      other -> "#{value} #{other |> Atom.to_string() |> String.upcase()}"
+    end
+  end
+
+  @doc """
+  Generates an invoice reference from a customer ID and sequence number.
+
+      iex> MyApp.Billing.Formatter.invoice_ref(42, 7)
+      "INV-00042-0007"
+
+      iex> MyApp.Billing.Formatter.invoice_ref(1, 1)
+      "INV-00001-0001"
+
+      iex> MyApp.Billing.Formatter.invoice_ref(99999, 9999)
+      "INV-99999-9999"
+  """
+  @spec invoice_ref(pos_integer(), pos_integer()) :: String.t()
+  def invoice_ref(customer_id, sequence)
+      when is_integer(customer_id) and is_integer(sequence) do
+    "INV-#{String.pad_leading(to_string(customer_id), 5, "0")}-#{String.pad_leading(to_string(sequence), 4, "0")}"
+  end
+
+  @doc """
+  Returns true if the amount is within the acceptable charge range.
+
+      iex> MyApp.Billing.Formatter.valid_amount?(50)
+      true
+
+      iex> MyApp.Billing.Formatter.valid_amount?(0)
+      false
+
+      iex> MyApp.Billing.Formatter.valid_amount?(10_000_00)
+      true
+
+      iex> MyApp.Billing.Formatter.valid_amount?(10_000_01)
+      false
+  """
+  @spec valid_amount?(integer()) :: boolean()
+  def valid_amount?(amount) when is_integer(amount) do
+    amount in 1..1_000_000
+  end
+end
diff --git a/priv/combined_metrics/samples/documentation/every_declaration_has_doc_comment/bad/ShippingService.swift b/priv/combined_metrics/samples/documentation/every_declaration_has_doc_comment/bad/ShippingService.swift
new file mode 100644
index 0000000..1bca816
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/every_declaration_has_doc_comment/bad/ShippingService.swift
@@ -0,0 +1,57 @@
+import Foundation
+
+// No doc comment on the enum
+enum ShipmentStatus {
+    // No doc comment on cases
+    case pending
+    case inTransit(currentLocation: String)
+    case delivered(at: Date)
+    case attemptedDelivery(attemptedAt: Date)
+    case returned(reason: String)
+}
+
+// No doc comment on the struct
+struct Shipment {
+    // No doc comment on properties
+    let trackingNumber: String
+    let destinationAddress: String
+    let estimatedDeliveryDate: Date
+    var status: ShipmentStatus
+    let carrier: String
+}
+
+// No doc comment on the class
+class ShippingService {
+    private var shipments: [String: Shipment] = [:]
+
+    // No doc comment — what does this return, and what are the failure conditions?
+    @discardableResult
+    func register(_ shipment: Shipment) -> Bool {
+        guard shipments[shipment.trackingNumber] == nil else { return false }
+        shipments[shipment.trackingNumber] = shipment
+        return true
+    }
+
+    // No doc comment — unclear whether nil means "not found" or "error"
+    func shipment(for trackingNumber: String) -> Shipment? {
+        return shipments[trackingNumber]
+    }
+
+    // No doc comment — parameters and return value undocumented
+    @discardableResult
+    func updateStatus(for trackingNumber: String, to status: ShipmentStatus) -> Bool {
+        guard shipments[trackingNumber] != nil else { return false }
+        shipments[trackingNumber]?.status = status
+        return true
+    }
+
+    // No doc comment — what counts as "overdue"? What is referenceDate for?
+    func overdueShipments(referenceDate: Date = Date()) -> [Shipment] {
+        return shipments.values
+            .filter { shipment in
+                if case .delivered = shipment.status { return false }
+                return shipment.estimatedDeliveryDate < referenceDate
+            }
+            .sorted { $0.estimatedDeliveryDate < $1.estimatedDeliveryDate }
+    }
+}
diff --git a/priv/combined_metrics/samples/documentation/every_declaration_has_doc_comment/good/ShippingService.swift b/priv/combined_metrics/samples/documentation/every_declaration_has_doc_comment/good/ShippingService.swift
new file mode 100644
index 0000000..3b7a244
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/every_declaration_has_doc_comment/good/ShippingService.swift
@@ -0,0 +1,85 @@
+import Foundation
+
+/// Represents the current status of a shipment in the delivery pipeline.
+enum ShipmentStatus {
+    /// The order has been placed but not yet picked up by a carrier.
+    case pending
+    /// The package is in transit between facilities.
+    case inTransit(currentLocation: String)
+    /// The package has been delivered to the destination address.
+    case delivered(at: Date)
+    /// Delivery was attempted but the recipient was unavailable.
+    case attemptedDelivery(attemptedAt: Date)
+    /// The shipment was returned to the sender.
+    case returned(reason: String)
+}
+
+/// Encapsulates all tracking information for a single shipment.
+struct Shipment {
+    /// The unique tracking number assigned by the carrier.
+    let trackingNumber: String
+    /// The destination address.
+    let destinationAddress: String
+    /// The estimated delivery date provided at the time of dispatch.
+    let estimatedDeliveryDate: Date
+    /// The current status of the shipment.
+    var status: ShipmentStatus
+    /// The carrier responsible for delivery (e.g., "FedEx", "UPS").
+    let carrier: String
+}
+
+/// Manages shipment creation, tracking updates, and delivery confirmation.
+///
+/// Use this service as the single point of contact for all shipping operations.
+/// It maintains an in-memory registry of active shipments.
+class ShippingService {
+    private var shipments: [String: Shipment] = [:]
+
+    /// Registers a new shipment and begins tracking it.
+    ///
+    /// - Parameter shipment: The shipment to register. The `trackingNumber` must be unique.
+    /// - Returns: `true` if registration succeeded; `false` if the tracking number already exists.
+    @discardableResult
+    func register(_ shipment: Shipment) -> Bool {
+        guard shipments[shipment.trackingNumber] == nil else { return false }
+        shipments[shipment.trackingNumber] = shipment
+        return true
+    }
+
+    /// Returns the shipment with the given tracking number, if it exists.
+    ///
+    /// - Parameter trackingNumber: The carrier-assigned tracking number.
+    /// - Returns: The matching `Shipment`, or `nil` if not found.
+    func shipment(for trackingNumber: String) -> Shipment? {
+        return shipments[trackingNumber]
+    }
+
+    /// Updates the status of an existing shipment.
+    ///
+    /// - Parameters:
+    ///   - trackingNumber: The tracking number of the shipment to update.
+    ///   - status: The new status to apply.
+    /// - Returns: `true` if the update was applied; `false` if the tracking number was not found.
+    @discardableResult
+    func updateStatus(for trackingNumber: String, to status: ShipmentStatus) -> Bool {
+        guard shipments[trackingNumber] != nil else { return false }
+        shipments[trackingNumber]?.status = status
+        return true
+    }
+
+    /// Returns all shipments that are currently overdue based on their estimated delivery date.
+    ///
+    /// A shipment is considered overdue if it has not been delivered and its estimated
+    /// delivery date is in the past.
+    ///
+    /// - Parameter referenceDate: The date to compare against. Defaults to the current date.
+    /// - Returns: An array of overdue shipments, sorted by estimated delivery date ascending.
+    func overdueShipments(referenceDate: Date = Date()) -> [Shipment] {
+        return shipments.values
+            .filter { shipment in
+                if case .delivered = shipment.status { return false }
+                return shipment.estimatedDeliveryDate < referenceDate
+            }
+            .sorted { $0.estimatedDeliveryDate < $1.estimatedDeliveryDate }
+    }
+}
diff --git a/priv/combined_metrics/samples/documentation/exported_symbol_has_doc_comment/bad/cache.go b/priv/combined_metrics/samples/documentation/exported_symbol_has_doc_comment/bad/cache.go
new file mode 100644
index 0000000..b53ea42
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/exported_symbol_has_doc_comment/bad/cache.go
@@ -0,0 +1,67 @@
+package cache
+
+import (
+	"sync"
+	"time"
+)
+
+// no doc comment on exported var
+var ErrExpired = errExpired{}
+
+type errExpired struct{}
+
+func (errExpired) Error() string { return "cache entry expired" }
+
+// no doc comment on exported type
+type Entry struct {
+	Value     interface{}
+	ExpiresAt time.Time
+}
+
+// no doc comment on exported method
+func (e Entry) IsExpired() bool {
+	return time.Now().After(e.ExpiresAt)
+}
+
+// no doc comment on exported type
+type Cache struct {
+	mu      sync.RWMutex
+	entries map[string]Entry
+}
+
+// no doc comment on exported constructor
+func New() *Cache {
+	return &Cache{entries: make(map[string]Entry)}
+}
+
+// no doc comment on exported method
+func (c *Cache) Set(key string, value interface{}, ttl time.Duration) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if ttl <= 0 {
+		delete(c.entries, key)
+		return
+	}
+	c.entries[key] = Entry{Value: value, ExpiresAt: time.Now().Add(ttl)}
+}
+
+// no doc comment on exported method
+func (c *Cache) Get(key string) (interface{}, error) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	entry, ok := c.entries[key]
+	if !ok {
+		return nil, nil
+	}
+	if entry.IsExpired() {
+		return nil, ErrExpired
+	}
+	return entry.Value, nil
+}
+
+// no doc comment on exported method
+func (c *Cache) Delete(key string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	delete(c.entries, key)
+}
diff --git a/priv/combined_metrics/samples/documentation/exported_symbol_has_doc_comment/good/cache.go b/priv/combined_metrics/samples/documentation/exported_symbol_has_doc_comment/good/cache.go
new file mode 100644
index 0000000..973bb5c
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/exported_symbol_has_doc_comment/good/cache.go
@@ -0,0 +1,72 @@
+// Package cache provides an in-memory key-value cache with TTL-based expiry.
+package cache
+
+import (
+	"sync"
+	"time"
+)
+
+// ErrExpired is returned when a requested key exists but its TTL has elapsed.
+var ErrExpired = errExpired{}
+
+type errExpired struct{}
+
+func (errExpired) Error() string { return "cache entry expired" }
+
+// Entry holds a cached value together with its expiry time.
+type Entry struct {
+	Value     interface{}
+	ExpiresAt time.Time
+}
+
+// IsExpired reports whether the entry's TTL has elapsed.
+func (e Entry) IsExpired() bool {
+	return time.Now().After(e.ExpiresAt)
+}
+
+// Cache is a thread-safe in-memory store with per-entry TTLs.
+// The zero value is not usable; construct one with New.
+type Cache struct {
+	mu      sync.RWMutex
+	entries map[string]Entry
+}
+
+// New constructs an empty Cache ready for use.
+func New() *Cache {
+	return &Cache{entries: make(map[string]Entry)}
+}
+
+// Set stores value under key with the given TTL.
+// Calling Set with a non-positive TTL removes any existing entry for key.
+func (c *Cache) Set(key string, value interface{}, ttl time.Duration) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if ttl <= 0 {
+		delete(c.entries, key)
+		return
+	}
+	c.entries[key] = Entry{Value: value, ExpiresAt: time.Now().Add(ttl)}
+}
+
+// Get returns the value stored under key.
+// It returns ErrExpired if the entry exists but has elapsed, and a nil error
+// with a nil value if the key is absent.
+func (c *Cache) Get(key string) (interface{}, error) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	entry, ok := c.entries[key]
+	if !ok {
+		return nil, nil
+	}
+	if entry.IsExpired() {
+		return nil, ErrExpired
+	}
+	return entry.Value, nil
+}
+
+// Delete removes the entry for key. It is a no-op if key is not present.
+func (c *Cache) Delete(key string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	delete(c.entries, key)
+}
diff --git a/priv/combined_metrics/samples/documentation/file_has_license_header/bad/core.ex b/priv/combined_metrics/samples/documentation/file_has_license_header/bad/core.ex
new file mode 100644
index 0000000..b07eabd
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/file_has_license_header/bad/core.ex
@@ -0,0 +1,74 @@
+defmodule MyApp.Core do
+  @moduledoc """
+  Core utility functions shared across all contexts.
+
+  Provides helpers for formatting, type coercion, and safe value
+  extraction that do not belong to any specific domain context.
+  """
+
+  @spec format_currency(Decimal.t(), String.t()) :: String.t()
+  def format_currency(%Decimal{} = amount, currency \\ "USD") do
+    formatted =
+      amount
+      |> Decimal.round(2)
+      |> Decimal.to_string(:normal)
+
+    "#{currency} #{formatted}"
+  end
+
+  @spec truncate(String.t(), non_neg_integer()) :: String.t()
+  def truncate(string, max_length) when byte_size(string) <= max_length, do: string
+
+  def truncate(string, max_length) do
+    String.slice(string, 0, max_length - 3) <> "..."
+  end
+
+  @spec slugify(String.t()) :: String.t()
+  def slugify(string) do
+    string
+    |> String.downcase()
+    |> String.replace(~r/[^a-z0-9\s-]/, "")
+    |> String.replace(~r/\s+/, "-")
+    |> String.trim("-")
+  end
+
+  @spec safe_to_integer(term()) :: {:ok, integer()} | :error
+  def safe_to_integer(value) when is_integer(value), do: {:ok, value}
+
+  def safe_to_integer(value) when is_binary(value) do
+    case Integer.parse(value) do
+      {int, ""} -> {:ok, int}
+      _ -> :error
+    end
+  end
+
+  def safe_to_integer(_), do: :error
+
+  @spec deep_merge(map(), map()) :: map()
+  def deep_merge(left, right) do
+    Map.merge(left, right, fn _key, left_val, right_val ->
+      if is_map(left_val) and is_map(right_val) do
+        deep_merge(left_val, right_val)
+      else
+        right_val
+      end
+    end)
+  end
+
+  @spec present?(term()) :: boolean()
+  def present?(nil), do: false
+  def present?(""), do: false
+  def present?([]), do: false
+  def present?(%{} = map) when map_size(map) == 0, do: false
+  def present?(_), do: true
+
+  @spec blank?(term()) :: boolean()
+  def blank?(value), do: not present?(value)
+
+  @spec wrap_ok(term()) :: {:ok, term()}
+  def wrap_ok(value), do: {:ok, value}
+
+  @spec unwrap_ok!({:ok, term()}) :: term()
+  def unwrap_ok!({:ok, value}), do: value
+  def unwrap_ok!({:error, reason}), do: raise("Expected {:ok, _}, got {:error, #{inspect(reason)}}")
+end
diff --git a/priv/combined_metrics/samples/documentation/file_has_license_header/config.yml b/priv/combined_metrics/samples/documentation/file_has_license_header/config.yml
new file mode 100644
index 0000000..5611933
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/file_has_license_header/config.yml
@@ -0,0 +1 @@
+doc: "Source files should begin with a license or copyright header."
diff --git a/priv/combined_metrics/samples/documentation/file_has_license_header/good/core.ex b/priv/combined_metrics/samples/documentation/file_has_license_header/good/core.ex
new file mode 100644
index 0000000..93e899d
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/file_has_license_header/good/core.ex
@@ -0,0 +1,76 @@
+# Copyright (c) 2024 Acme Corp. MIT License.
+
+defmodule MyApp.Core do
+  @moduledoc """
+  Core utility functions shared across all contexts.
+
+  Provides helpers for formatting, type coercion, and safe value
+  extraction that do not belong to any specific domain context.
+  """
+
+  @spec format_currency(Decimal.t(), String.t()) :: String.t()
+  def format_currency(%Decimal{} = amount, currency \\ "USD") do
+    formatted =
+      amount
+      |> Decimal.round(2)
+      |> Decimal.to_string(:normal)
+
+    "#{currency} #{formatted}"
+  end
+
+  @spec truncate(String.t(), non_neg_integer()) :: String.t()
+  def truncate(string, max_length) when byte_size(string) <= max_length, do: string
+
+  def truncate(string, max_length) do
+    String.slice(string, 0, max_length - 3) <> "..."
+  end
+
+  @spec slugify(String.t()) :: String.t()
+  def slugify(string) do
+    string
+    |> String.downcase()
+    |> String.replace(~r/[^a-z0-9\s-]/, "")
+    |> String.replace(~r/\s+/, "-")
+    |> String.trim("-")
+  end
+
+  @spec safe_to_integer(term()) :: {:ok, integer()} | :error
+  def safe_to_integer(value) when is_integer(value), do: {:ok, value}
+
+  def safe_to_integer(value) when is_binary(value) do
+    case Integer.parse(value) do
+      {int, ""} -> {:ok, int}
+      _ -> :error
+    end
+  end
+
+  def safe_to_integer(_), do: :error
+
+  @spec deep_merge(map(), map()) :: map()
+  def deep_merge(left, right) do
+    Map.merge(left, right, fn _key, left_val, right_val ->
+      if is_map(left_val) and is_map(right_val) do
+        deep_merge(left_val, right_val)
+      else
+        right_val
+      end
+    end)
+  end
+
+  @spec present?(term()) :: boolean()
+  def present?(nil), do: false
+  def present?(""), do: false
+  def present?([]), do: false
+  def present?(%{} = map) when map_size(map) == 0, do: false
+  def present?(_), do: true
+
+  @spec blank?(term()) :: boolean()
+  def blank?(value), do: not present?(value)
+
+  @spec wrap_ok(term()) :: {:ok, term()}
+  def wrap_ok(value), do: {:ok, value}
+
+  @spec unwrap_ok!({:ok, term()}) :: term()
+  def unwrap_ok!({:ok, value}), do: value
+  def unwrap_ok!({:error, reason}), do: raise("Expected {:ok, _}, got {:error, #{inspect(reason)}}")
+end
diff --git a/priv/combined_metrics/samples/documentation/file_has_module_docstring/bad/shipping.ex b/priv/combined_metrics/samples/documentation/file_has_module_docstring/bad/shipping.ex
new file mode 100644
index 0000000..044c4f8
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/file_has_module_docstring/bad/shipping.ex
@@ -0,0 +1,73 @@
+defmodule MyApp.Shipping do
+  alias MyApp.Repo
+  alias MyApp.Shipping.Shipment
+  alias MyApp.Shipping.TrackingEvent
+  alias MyApp.Orders.Order
+
+  @spec create_shipment(Order.t(), map()) :: {:ok, Shipment.t()} | {:error, Ecto.Changeset.t()}
+  def create_shipment(%Order{} = order, attrs) do
+    %Shipment{}
+    |> Shipment.changeset(Map.put(attrs, :order_id, order.id))
+    |> Repo.insert()
+  end
+
+  @spec get_shipment!(integer()) :: Shipment.t()
+  def get_shipment!(id) do
+    Repo.get!(Shipment, id)
+    |> Repo.preload(:tracking_events)
+  end
+
+  @spec update_shipment(Shipment.t(), map()) :: {:ok, Shipment.t()} | {:error, Ecto.Changeset.t()}
+  def update_shipment(%Shipment{} = shipment, attrs) do
+    shipment
+    |> Shipment.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @spec cancel_shipment(Shipment.t()) :: {:ok, Shipment.t()} | {:error, Ecto.Changeset.t()}
+  def cancel_shipment(%Shipment{} = shipment) do
+    update_shipment(shipment, %{status: :cancelled})
+  end
+
+  @spec add_tracking_event(Shipment.t(), map()) ::
+          {:ok, TrackingEvent.t()} | {:error, Ecto.Changeset.t()}
+  def add_tracking_event(%Shipment{} = shipment, attrs) do
+    %TrackingEvent{}
+    |> TrackingEvent.changeset(Map.put(attrs, :shipment_id, shipment.id))
+    |> Repo.insert()
+  end
+
+  @spec estimated_delivery(Shipment.t()) :: Date.t() | nil
+  def estimated_delivery(%Shipment{shipped_at: nil}), do: nil
+
+  def estimated_delivery(%Shipment{shipped_at: shipped_at, service: service}) do
+    days = transit_days(service)
+    Date.add(DateTime.to_date(shipped_at), days)
+  end
+
+  @spec active_shipments_for_user(map()) :: [Shipment.t()]
+  def active_shipments_for_user(%{id: user_id}) do
+    Repo.all(
+      from s in Shipment,
+        join: o in Order,
+        on: o.id == s.order_id,
+        where: o.user_id == ^user_id and s.status == :in_transit
+    )
+  end
+
+  @spec calculate_shipping_cost(map(), String.t()) :: Decimal.t()
+  def calculate_shipping_cost(%{weight_grams: weight}, destination_zone) do
+    base = base_rate(destination_zone)
+    weight_cost = Decimal.mult(Decimal.new(weight), Decimal.new("0.001"))
+    Decimal.add(base, weight_cost)
+  end
+
+  defp transit_days(:standard), do: 5
+  defp transit_days(:express), do: 2
+  defp transit_days(:overnight), do: 1
+  defp transit_days(_), do: 7
+
+  defp base_rate("domestic"), do: Decimal.new("4.99")
+  defp base_rate("international"), do: Decimal.new("19.99")
+  defp base_rate(_), do: Decimal.new("9.99")
+end
diff --git a/priv/combined_metrics/samples/documentation/file_has_module_docstring/config.yml b/priv/combined_metrics/samples/documentation/file_has_module_docstring/config.yml
new file mode 100644
index 0000000..d3f61c3
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/file_has_module_docstring/config.yml
@@ -0,0 +1 @@
+doc: "Files should have a module-level docstring explaining purpose and usage."
diff --git a/priv/combined_metrics/samples/documentation/file_has_module_docstring/good/shipping.ex b/priv/combined_metrics/samples/documentation/file_has_module_docstring/good/shipping.ex
new file mode 100644
index 0000000..5d7e2de
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/file_has_module_docstring/good/shipping.ex
@@ -0,0 +1,88 @@
+defmodule MyApp.Shipping do
+  @moduledoc """
+  Context module for shipment lifecycle management.
+
+  Handles creating and tracking shipments tied to orders, recording
+  tracking events, and estimating delivery dates based on the selected
+  shipping service and destination zone.
+
+  All public functions in this module are the sole entry point for
+  shipment-related operations. Internal schema modules such as
+  `MyApp.Shipping.Shipment` and `MyApp.Shipping.TrackingEvent` should
+  not be accessed directly from outside this context.
+  """
+
+  alias MyApp.Repo
+  alias MyApp.Shipping.Shipment
+  alias MyApp.Shipping.TrackingEvent
+  alias MyApp.Orders.Order
+
+  @spec create_shipment(Order.t(), map()) :: {:ok, Shipment.t()} | {:error, Ecto.Changeset.t()}
+  def create_shipment(%Order{} = order, attrs) do
+    %Shipment{}
+    |> Shipment.changeset(Map.put(attrs, :order_id, order.id))
+    |> Repo.insert()
+  end
+
+  @spec get_shipment!(integer()) :: Shipment.t()
+  def get_shipment!(id) do
+    Repo.get!(Shipment, id)
+    |> Repo.preload(:tracking_events)
+  end
+
+  @spec update_shipment(Shipment.t(), map()) :: {:ok, Shipment.t()} | {:error, Ecto.Changeset.t()}
+  def update_shipment(%Shipment{} = shipment, attrs) do
+    shipment
+    |> Shipment.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @spec cancel_shipment(Shipment.t()) :: {:ok, Shipment.t()} | {:error, Ecto.Changeset.t()}
+  def cancel_shipment(%Shipment{} = shipment) do
+    update_shipment(shipment, %{status: :cancelled})
+  end
+
+  @spec add_tracking_event(Shipment.t(), map()) ::
+          {:ok, TrackingEvent.t()} | {:error, Ecto.Changeset.t()}
+  def add_tracking_event(%Shipment{} = shipment, attrs) do
+    %TrackingEvent{}
+    |> TrackingEvent.changeset(Map.put(attrs, :shipment_id, shipment.id))
+    |> Repo.insert()
+  end
+
+  @spec estimated_delivery(Shipment.t()) :: Date.t() | nil
+  def estimated_delivery(%Shipment{shipped_at: nil}), do: nil
+
+  def estimated_delivery(%Shipment{shipped_at: shipped_at, service: service}) do
+    days = transit_days(service)
+    Date.add(DateTime.to_date(shipped_at), days)
+  end
+
+  @spec active_shipments_for_user(map()) :: [Shipment.t()]
+  def active_shipments_for_user(%{id: user_id}) do
+    import Ecto.Query, only: [from: 2, where: 3, join: 5]
+
+    Repo.all(
+      from s in Shipment,
+        join: o in Order,
+        on: o.id == s.order_id,
+        where: o.user_id == ^user_id and s.status == :in_transit
+    )
+  end
+
+  @spec calculate_shipping_cost(map(), String.t()) :: Decimal.t()
+  def calculate_shipping_cost(%{weight_grams: weight}, destination_zone) do
+    base = base_rate(destination_zone)
+    weight_cost = Decimal.mult(Decimal.new(weight), Decimal.new("0.001"))
+    Decimal.add(base, weight_cost)
+  end
+
+  defp transit_days(:standard), do: 5
+  defp transit_days(:express), do: 2
+  defp transit_days(:overnight), do: 1
+  defp transit_days(_), do: 7
+
+  defp base_rate("domestic"), do: Decimal.new("4.99")
+  defp base_rate("international"), do: Decimal.new("19.99")
+  defp base_rate(_), do: Decimal.new("9.99")
+end
diff --git a/priv/combined_metrics/samples/documentation/file_has_no_commented_out_code/bad/legacy_importer.ex b/priv/combined_metrics/samples/documentation/file_has_no_commented_out_code/bad/legacy_importer.ex
new file mode 100644
index 0000000..78f7f78
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/file_has_no_commented_out_code/bad/legacy_importer.ex
@@ -0,0 +1,91 @@
+defmodule MyApp.LegacyImporter do
+  @moduledoc """
+  Handles importing records from the legacy CSV export format.
+  """
+
+  alias MyApp.Repo
+  alias MyApp.Accounts.User
+  alias MyApp.Orders.Order
+
+  # def import_all(path) do
+  #   path
+  #   |> File.stream!()
+  #   |> CSV.decode!(headers: true)
+  #   |> Enum.map(&import_row/1)
+  # end
+
+  @spec import_file(String.t()) :: {:ok, non_neg_integer()} | {:error, String.t()}
+  def import_file(path) do
+    rows =
+      path
+      |> File.stream!()
+      |> Stream.map(&String.trim/1)
+      |> Stream.reject(&(&1 == ""))
+      |> Stream.drop(1)
+      |> Enum.map(&String.split(&1, ","))
+
+    results = Enum.map(rows, &import_row/1)
+    errors = Enum.filter(results, &match?({:error, _}, &1))
+
+    if errors == [] do
+      {:ok, length(results)}
+    else
+      {:error, "#{length(errors)} rows failed"}
+    end
+  end
+
+  # Old row import — replaced by pattern matched version below
+  # def import_row(row) do
+  #   user = Repo.get_by(User, email: Enum.at(row, 2))
+  #   if user do
+  #     %Order{user_id: user.id, total: String.to_float(Enum.at(row, 5))}
+  #     |> Repo.insert()
+  #   else
+  #     {:error, "user not found"}
+  #   end
+  # end
+
+  defp import_row([id, _name, email, date, _source, total | _rest]) do
+    with %User{} = user <- Repo.get_by(User, email: email),
+         {:ok, ordered_at} <- Date.from_iso8601(date),
+         {amount, _} <- Float.parse(total) do
+      %Order{}
+      |> Order.changeset(%{
+        legacy_id: id,
+        user_id: user.id,
+        total: amount,
+        ordered_at: ordered_at
+      })
+      |> Repo.insert()
+    else
+      nil -> {:error, "unknown user: #{email}"}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  defp import_row(_invalid), do: {:error, "malformed row"}
+
+  # TODO: add dry_run mode
+  # def dry_run(path) do
+  #   import_file(path)
+  #   |> case do
+  #     {:ok, count} -> IO.puts("Would import #{count} rows")
+  #     {:error, msg} -> IO.puts("Error: #{msg}")
+  #   end
+  # end
+
+  @spec summary_stats(String.t()) :: map()
+  def summary_stats(path) do
+    rows =
+      path
+      |> File.stream!()
+      |> Stream.drop(1)
+      |> Enum.to_list()
+
+    %{
+      total_rows: length(rows),
+      # valid_rows: Enum.count(rows, &valid_row?/1),
+      file: path
+    }
+  end
+end
diff --git a/priv/combined_metrics/samples/documentation/file_has_no_commented_out_code/config.yml b/priv/combined_metrics/samples/documentation/file_has_no_commented_out_code/config.yml
new file mode 100644
index 0000000..345b09b
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/file_has_no_commented_out_code/config.yml
@@ -0,0 +1 @@
+doc: "Files should not contain commented-out code blocks left from development."
diff --git a/priv/combined_metrics/samples/documentation/file_has_no_commented_out_code/good/legacy_importer.ex b/priv/combined_metrics/samples/documentation/file_has_no_commented_out_code/good/legacy_importer.ex
new file mode 100644
index 0000000..aa6d3da
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/file_has_no_commented_out_code/good/legacy_importer.ex
@@ -0,0 +1,83 @@
+defmodule MyApp.LegacyImporter do
+  @moduledoc """
+  Handles importing records from the legacy CSV export format.
+
+  Rows are expected to be comma-separated with the following columns:
+  `id, name, email, date, source, total`.
+
+  Use `import_file/1` to run the full import and receive a success count,
+  or `summary_stats/1` to inspect the file without persisting any records.
+  """
+
+  alias MyApp.Repo
+  alias MyApp.Accounts.User
+  alias MyApp.Orders.Order
+
+  @spec import_file(String.t()) :: {:ok, non_neg_integer()} | {:error, String.t()}
+  def import_file(path) do
+    rows =
+      path
+      |> File.stream!()
+      |> Stream.map(&String.trim/1)
+      |> Stream.reject(&(&1 == ""))
+      |> Stream.drop(1)
+      |> Enum.map(&String.split(&1, ","))
+
+    results = Enum.map(rows, &import_row/1)
+    failed = Enum.count(results, &match?({:error, _}, &1))
+
+    if failed == 0 do
+      {:ok, length(results)}
+    else
+      {:error, "#{failed} rows failed to import"}
+    end
+  end
+
+  @spec dry_run(String.t()) :: {:ok, non_neg_integer()} | {:error, String.t()}
+  def dry_run(path) do
+    Repo.transaction(fn ->
+      case import_file(path) do
+        {:ok, count} ->
+          Repo.rollback({:dry_run, count})
+
+        {:error, reason} ->
+          Repo.rollback({:error, reason})
+      end
+    end)
+    |> case do
+      {:error, {:dry_run, count}} -> {:ok, count}
+      {:error, {:error, reason}} -> {:error, reason}
+    end
+  end
+
+  @spec summary_stats(String.t()) :: map()
+  def summary_stats(path) do
+    rows =
+      path
+      |> File.stream!()
+      |> Stream.drop(1)
+      |> Enum.to_list()
+
+    %{total_rows: length(rows), file: path}
+  end
+
+  defp import_row([id, _name, email, date, _source, total | _rest]) do
+    with %User{} = user <- Repo.get_by(User, email: email),
+         {:ok, ordered_at} <- Date.from_iso8601(date),
+         {amount, _} <- Float.parse(total) do
+      %Order{}
+      |> Order.changeset(%{
+        legacy_id: id,
+        user_id: user.id,
+        total: amount,
+        ordered_at: ordered_at
+      })
+      |> Repo.insert()
+    else
+      nil -> {:error, "unknown user: #{email}"}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  defp import_row(_invalid), do: {:error, "malformed row"}
+end
diff --git a/priv/combined_metrics/samples/documentation/function_has_docstring/bad/tax.ex b/priv/combined_metrics/samples/documentation/function_has_docstring/bad/tax.ex
new file mode 100644
index 0000000..48812b4
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/function_has_docstring/bad/tax.ex
@@ -0,0 +1,73 @@
+defmodule MyApp.Tax do
+  @moduledoc """
+  Tax calculation context for order totals and line items.
+  """
+
+  alias MyApp.Tax.Rate
+  alias MyApp.Tax.Exemption
+  alias MyApp.Repo
+
+  @spec calculate(Decimal.t(), String.t()) :: Decimal.t()
+  def calculate(subtotal, region) do
+    rate = fetch_rate(region)
+    Decimal.mult(subtotal, rate)
+  end
+
+  @spec calculate_line_items([map()], String.t()) :: [map()]
+  def calculate_line_items(items, region) do
+    rate = fetch_rate(region)
+    Enum.map(items, fn item ->
+      tax = Decimal.mult(item.price, rate)
+      Map.put(item, :tax, tax)
+    end)
+  end
+
+  @spec effective_rate(String.t()) :: Decimal.t()
+  def effective_rate(region) do
+    fetch_rate(region)
+  end
+
+  @spec exempt?(String.t(), String.t()) :: boolean()
+  def exempt?(product_category, region) do
+    Repo.get_by(Exemption, category: product_category, region: region) != nil
+  end
+
+  @spec apply_exemptions([map()], String.t()) :: [map()]
+  def apply_exemptions(items, region) do
+    Enum.map(items, fn item ->
+      if exempt?(item.category, region) do
+        Map.put(item, :tax, Decimal.new(0))
+      else
+        item
+      end
+    end)
+  end
+
+  @spec summarize(Decimal.t(), String.t()) :: map()
+  def summarize(subtotal, region) do
+    tax = calculate(subtotal, region)
+    total = Decimal.add(subtotal, tax)
+
+    %{
+      subtotal: subtotal,
+      tax: tax,
+      total: total,
+      rate: effective_rate(region),
+      region: region
+    }
+  end
+
+  @spec annual_liability([map()]) :: Decimal.t()
+  def annual_liability(transactions) do
+    transactions
+    |> Enum.map(& &1.tax)
+    |> Enum.reduce(Decimal.new(0), &Decimal.add/2)
+  end
+
+  defp fetch_rate(region) do
+    case Repo.get_by(Rate, region: region) do
+      %Rate{rate: rate} -> rate
+      nil -> Decimal.new("0.10")
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/documentation/function_has_docstring/config.yml b/priv/combined_metrics/samples/documentation/function_has_docstring/config.yml
new file mode 100644
index 0000000..bac2ee2
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/function_has_docstring/config.yml
@@ -0,0 +1 @@
+doc: "Public functions should have a docstring describing behaviour, params, and return value."
diff --git a/priv/combined_metrics/samples/documentation/function_has_docstring/good/tax.ex b/priv/combined_metrics/samples/documentation/function_has_docstring/good/tax.ex
new file mode 100644
index 0000000..9767383
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/function_has_docstring/good/tax.ex
@@ -0,0 +1,105 @@
+defmodule MyApp.Tax do
+  @moduledoc """
+  Tax calculation context for order totals and line items.
+  """
+
+  alias MyApp.Tax.Rate
+  alias MyApp.Tax.Exemption
+  alias MyApp.Repo
+
+  @doc """
+  Calculates the tax amount for a given subtotal and region.
+
+  Returns the tax amount as a `Decimal`, not the total. Use `summarize/2`
+  to get a full breakdown including subtotal, tax, and total.
+
+  ## Examples
+
+      iex> MyApp.Tax.calculate(Decimal.new("100.00"), "us-ca")
+      Decimal.new("8.25")
+  """
+  @spec calculate(Decimal.t(), String.t()) :: Decimal.t()
+  def calculate(subtotal, region) do
+    rate = fetch_rate(region)
+    Decimal.mult(subtotal, rate)
+  end
+
+  @doc """
+  Applies per-line-item tax to a list of order items for a given region.
+
+  Each item map must have a `:price` and `:category` key. Returns the
+  same list with a `:tax` key added to each item. Items with an exemption
+  in the given region receive a tax of zero.
+  """
+  @spec calculate_line_items([map()], String.t()) :: [map()]
+  def calculate_line_items(items, region) do
+    items
+    |> apply_exemptions(region)
+    |> Enum.map(&apply_tax_rate(&1, fetch_rate(region)))
+  end
+
+  @doc """
+  Returns the applicable tax rate for the given region as a `Decimal`.
+
+  Falls back to a default rate of 10% when no specific rate is configured.
+  """
+  @spec effective_rate(String.t()) :: Decimal.t()
+  def effective_rate(region) do
+    fetch_rate(region)
+  end
+
+  @doc """
+  Returns `true` if the given product category is tax-exempt in a region.
+  """
+  @spec exempt?(String.t(), String.t()) :: boolean()
+  def exempt?(product_category, region) do
+    Repo.get_by(Exemption, category: product_category, region: region) != nil
+  end
+
+  @doc """
+  Returns a tax summary map for a subtotal and region.
+
+  The map contains `:subtotal`, `:tax`, `:total`, `:rate`, and `:region`.
+  """
+  @spec summarize(Decimal.t(), String.t()) :: map()
+  def summarize(subtotal, region) do
+    tax = calculate(subtotal, region)
+    total = Decimal.add(subtotal, tax)
+
+    %{
+      subtotal: subtotal,
+      tax: tax,
+      total: total,
+      rate: effective_rate(region),
+      region: region
+    }
+  end
+
+  @doc """
+  Sums the total tax liability across a list of transactions.
+
+  Each transaction map must have a `:tax` key with a `Decimal` value.
+  """
+  @spec annual_liability([map()]) :: Decimal.t()
+  def annual_liability(transactions) do
+    transactions
+    |> Enum.map(& &1.tax)
+    |> Enum.reduce(Decimal.new(0), &Decimal.add/2)
+  end
+
+  defp apply_exemptions(items, region) do
+    Enum.map(items, fn item ->
+      if exempt?(item.category, region), do: Map.put(item, :tax, Decimal.new(0)), else: item
+    end)
+  end
+
+  defp apply_tax_rate(%{tax: _already_set} = item, _rate), do: item
+  defp apply_tax_rate(item, rate), do: Map.put(item, :tax, Decimal.mult(item.price, rate))
+
+  defp fetch_rate(region) do
+    case Repo.get_by(Rate, region: region) do
+      %Rate{rate: rate} -> rate
+      nil -> Decimal.new("0.10")
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/documentation/function_todo_comment_in_body/bad/sync.ex b/priv/combined_metrics/samples/documentation/function_todo_comment_in_body/bad/sync.ex
new file mode 100644
index 0000000..4cfb397
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/function_todo_comment_in_body/bad/sync.ex
@@ -0,0 +1,95 @@
+defmodule MyApp.Sync do
+  @moduledoc """
+  Data synchronization service for reconciling records with an external system.
+  """
+
+  alias MyApp.Repo
+  alias MyApp.Sync.Record
+  alias MyApp.ExternalAPI
+
+  @spec sync_all() :: {:ok, map()} | {:error, String.t()}
+  def sync_all() do
+    # TODO: add pagination support so we don't fetch all records at once
+    records = Repo.all(Record)
+    results = Enum.map(records, &sync_record/1)
+
+    %{
+      total: length(results),
+      success: Enum.count(results, &match?({:ok, _}, &1)),
+      failed: Enum.count(results, &match?({:error, _}, &1))
+    }
+    |> then(&{:ok, &1})
+  end
+
+  @spec sync_record(Record.t()) :: {:ok, Record.t()} | {:error, String.t()}
+  def sync_record(%Record{} = record) do
+    # TODO: handle rate limiting from ExternalAPI
+    case ExternalAPI.push(record.external_id, record_payload(record)) do
+      {:ok, response} ->
+        # TODO: parse and store the response metadata
+        update_synced_at(record, response)
+
+      {:error, reason} ->
+        {:error, "ExternalAPI error: #{reason}"}
+    end
+  end
+
+  @spec pull_updates(DateTime.t()) :: {:ok, non_neg_integer()} | {:error, String.t()}
+  def pull_updates(since) do
+    # TODO: implement delta sync — currently fetches everything
+    case ExternalAPI.list_updated(since) do
+      {:ok, items} ->
+        count =
+          items
+          |> Enum.map(&upsert_from_external/1)
+          |> Enum.count(&match?({:ok, _}, &1))
+
+        {:ok, count}
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  @spec conflict_resolution(Record.t(), map()) :: {:ok, Record.t()}
+  def conflict_resolution(%Record{} = local, remote) do
+    # TODO: implement proper conflict resolution strategy (last-write-wins vs merge)
+    if DateTime.compare(local.updated_at, remote["updated_at"]) == :gt do
+      {:ok, local}
+    else
+      upsert_from_external(remote)
+    end
+  end
+
+  @spec status() :: map()
+  def status() do
+    # TODO: add last_error_at tracking
+    total = Repo.aggregate(Record, :count)
+    synced = Repo.aggregate(from(r in Record, where: not is_nil(r.synced_at)), :count)
+
+    %{
+      total: total,
+      synced: synced,
+      pending: total - synced
+    }
+  end
+
+  defp record_payload(%Record{} = record) do
+    %{id: record.external_id, data: record.payload, version: record.version}
+  end
+
+  defp update_synced_at(record, _response) do
+    record
+    |> Record.changeset(%{synced_at: DateTime.utc_now()})
+    |> Repo.update()
+  end
+
+  defp upsert_from_external(%{"id" => ext_id} = data) do
+    attrs = %{external_id: ext_id, payload: data, synced_at: DateTime.utc_now()}
+
+    case Repo.get_by(Record, external_id: ext_id) do
+      nil -> Repo.insert(Record.changeset(%Record{}, attrs))
+      record -> Repo.update(Record.changeset(record, attrs))
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/documentation/function_todo_comment_in_body/config.yml b/priv/combined_metrics/samples/documentation/function_todo_comment_in_body/config.yml
new file mode 100644
index 0000000..d1cd973
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/function_todo_comment_in_body/config.yml
@@ -0,0 +1 @@
+doc: "Functions should not contain TODO/FIXME comments indicating unfinished work."
diff --git a/priv/combined_metrics/samples/documentation/function_todo_comment_in_body/good/sync.ex b/priv/combined_metrics/samples/documentation/function_todo_comment_in_body/good/sync.ex
new file mode 100644
index 0000000..08778c0
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/function_todo_comment_in_body/good/sync.ex
@@ -0,0 +1,104 @@
+defmodule MyApp.Sync do
+  @moduledoc """
+  Data synchronization service for reconciling records with an external system.
+
+  Supports full sync via `sync_all/0`, incremental pull via `pull_updates/1`,
+  and per-record sync via `sync_record/1`. Conflict resolution uses a
+  last-write-wins strategy based on `updated_at` timestamps.
+  """
+
+  alias MyApp.Repo
+  alias MyApp.Sync.Record
+  alias MyApp.ExternalAPI
+
+  @page_size 100
+
+  @spec sync_all() :: {:ok, map()} | {:error, String.t()}
+  def sync_all() do
+    results =
+      stream_all_records()
+      |> Enum.map(&sync_record/1)
+
+    summary = %{
+      total: length(results),
+      success: Enum.count(results, &match?({:ok, _}, &1)),
+      failed: Enum.count(results, &match?({:error, _}, &1))
+    }
+
+    {:ok, summary}
+  end
+
+  @spec sync_record(Record.t()) :: {:ok, Record.t()} | {:error, String.t()}
+  def sync_record(%Record{} = record) do
+    case ExternalAPI.push(record.external_id, record_payload(record)) do
+      {:ok, response} -> update_synced_at(record, response)
+      {:error, reason} -> {:error, "ExternalAPI error: #{reason}"}
+    end
+  end
+
+  @spec pull_updates(DateTime.t()) :: {:ok, non_neg_integer()} | {:error, String.t()}
+  def pull_updates(since) do
+    case ExternalAPI.list_updated(since) do
+      {:ok, items} ->
+        count =
+          items
+          |> Enum.map(&upsert_from_external/1)
+          |> Enum.count(&match?({:ok, _}, &1))
+
+        {:ok, count}
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  @spec conflict_resolution(Record.t(), map()) :: {:ok, Record.t()}
+  def conflict_resolution(%Record{} = local, remote) do
+    if DateTime.compare(local.updated_at, remote["updated_at"]) == :gt do
+      {:ok, local}
+    else
+      upsert_from_external(remote)
+    end
+  end
+
+  @spec status() :: map()
+  def status() do
+    import Ecto.Query, only: [from: 2]
+
+    total = Repo.aggregate(Record, :count)
+    synced = Repo.aggregate(from(r in Record, where: not is_nil(r.synced_at)), :count)
+
+    %{
+      total: total,
+      synced: synced,
+      pending: total - synced
+    }
+  end
+
+  defp stream_all_records() do
+    import Ecto.Query, only: [from: 2]
+
+    Repo.all(from r in Record, order_by: r.id)
+    |> Stream.chunk_every(@page_size)
+    |> Stream.flat_map(& &1)
+  end
+
+  defp record_payload(%Record{} = record) do
+    %{id: record.external_id, data: record.payload, version: record.version}
+  end
+
+  defp update_synced_at(record, _response) do
+    record
+    |> Record.changeset(%{synced_at: DateTime.utc_now()})
+    |> Repo.update()
+  end
+
+  defp upsert_from_external(%{"id" => ext_id} = data) do
+    attrs = %{external_id: ext_id, payload: data, synced_at: DateTime.utc_now()}
+
+    case Repo.get_by(Record, external_id: ext_id) do
+      nil -> Repo.insert(Record.changeset(%Record{}, attrs))
+      record -> Repo.update(Record.changeset(record, attrs))
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/documentation/public_api_has_moduledoc_and_doc/bad/payments.ex b/priv/combined_metrics/samples/documentation/public_api_has_moduledoc_and_doc/bad/payments.ex
new file mode 100644
index 0000000..2f886e0
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/public_api_has_moduledoc_and_doc/bad/payments.ex
@@ -0,0 +1,81 @@
+defmodule MyApp.Payments do
+  # Bad: no @moduledoc — the module's purpose, conventions, and usage
+  # are completely undiscoverable without reading the full source.
+
+  alias MyApp.Payments.{Charge, Refund}
+  alias MyApp.Repo
+
+  # Bad: no @doc on a public function. Callers cannot use `h MyApp.Payments.charge/3`
+  # in IEx, and documentation tools will not generate an entry for this function.
+  @spec charge(integer(), pos_integer(), :usd | :eur | :gbp) ::
+          {:ok, Charge.t()} | {:error, atom()}
+  def charge(customer_id, amount, currency)
+      when is_integer(amount) and amount > 0 do
+    with {:ok, pm} <- fetch_default_payment_method(customer_id),
+         {:ok, result} <- MyApp.PaymentGateway.charge(pm.token, amount, currency) do
+      insert_charge(customer_id, amount, currency, result.transaction_id)
+    end
+  end
+
+  # Bad: no @doc on this public function either
+  @spec refund(integer(), pos_integer()) :: {:ok, Refund.t()} | {:error, atom()}
+  def refund(charge_id, amount) when is_integer(amount) and amount > 0 do
+    with {:ok, charge} <- fetch_charge(charge_id),
+         :ok <- validate_refund_amount(charge, amount),
+         {:ok, result} <- MyApp.PaymentGateway.refund(charge.transaction_id, amount) do
+      insert_refund(charge, amount, result.refund_id)
+    end
+  end
+
+  # Bad: `list_charges/2` is public but completely undocumented.
+  # What does `opts` accept? What order are results in?
+  def list_charges(customer_id, opts \\ []) do
+    limit = Keyword.get(opts, :limit, 20)
+    offset = Keyword.get(opts, :offset, 0)
+
+    Repo.all(
+      from c in Charge,
+        where: c.customer_id == ^customer_id,
+        order_by: [desc: c.inserted_at],
+        limit: ^limit,
+        offset: ^offset
+    )
+  end
+
+  defp fetch_default_payment_method(customer_id) do
+    case Repo.get_by(MyApp.Payments.PaymentMethod, customer_id: customer_id, default: true) do
+      nil -> {:error, :no_payment_method}
+      pm -> {:ok, pm}
+    end
+  end
+
+  defp fetch_charge(charge_id) do
+    case Repo.get(Charge, charge_id) do
+      nil -> {:error, :charge_not_found}
+      charge -> {:ok, charge}
+    end
+  end
+
+  defp validate_refund_amount(%Charge{amount: orig}, amount) when amount > orig do
+    {:error, :exceeds_original}
+  end
+
+  defp validate_refund_amount(_, _), do: :ok
+
+  defp insert_charge(customer_id, amount, currency, transaction_id) do
+    %Charge{}
+    |> Charge.changeset(%{
+      customer_id: customer_id,
+      amount: amount,
+      currency: currency,
+      transaction_id: transaction_id
+    })
+    |> Repo.insert()
+  end
+
+  defp insert_refund(charge, amount, refund_id) do
+    %Refund{}
+    |> Refund.changeset(%{charge_id: charge.id, amount: amount, refund_id: refund_id})
+    |> Repo.insert()
+  end
+end
diff --git a/priv/combined_metrics/samples/documentation/public_api_has_moduledoc_and_doc/good/payments.ex b/priv/combined_metrics/samples/documentation/public_api_has_moduledoc_and_doc/good/payments.ex
new file mode 100644
index 0000000..2d87c50
--- /dev/null
+++ b/priv/combined_metrics/samples/documentation/public_api_has_moduledoc_and_doc/good/payments.ex
@@ -0,0 +1,109 @@
+defmodule MyApp.Payments do
+  @moduledoc """
+  Public API for processing payments and managing charges.
+
+  All monetary amounts are in the smallest currency unit (e.g. cents for USD).
+  Currency codes follow ISO 4217 (e.g. `:usd`, `:eur`).
+
+  ## Usage
+
+      {:ok, charge} = MyApp.Payments.charge(customer_id, 2999, :usd)
+      {:ok, _} = MyApp.Payments.refund(charge.id, 2999)
+  """
+
+  alias MyApp.Payments.{Charge, Refund}
+  alias MyApp.Repo
+
+  @doc """
+  Creates a charge against a customer's default payment method.
+
+  `amount` must be a positive integer in the smallest currency unit.
+  `currency` must be one of `:usd`, `:eur`, or `:gbp`.
+
+  Returns `{:ok, charge}` on success, or `{:error, reason}` when the
+  customer has no payment method, the card is declined, or validation fails.
+  """
+  @spec charge(integer(), pos_integer(), :usd | :eur | :gbp) ::
+          {:ok, Charge.t()} | {:error, atom()}
+  def charge(customer_id, amount, currency)
+      when is_integer(amount) and amount > 0 do
+    with {:ok, pm} <- fetch_default_payment_method(customer_id),
+         {:ok, result} <- MyApp.PaymentGateway.charge(pm.token, amount, currency) do
+      insert_charge(customer_id, amount, currency, result.transaction_id)
+    end
+  end
+
+  @doc """
+  Refunds a charge fully or partially.
+
+  `amount` must not exceed the original charge amount. Pass the full charge
+  amount to issue a full refund.
+
+  Returns `{:ok, refund}` or `{:error, :exceeds_original}` when the requested
+  amount is greater than the charge amount.
+  """
+  @spec refund(integer(), pos_integer()) :: {:ok, Refund.t()} | {:error, atom()}
+  def refund(charge_id, amount) when is_integer(amount) and amount > 0 do
+    with {:ok, charge} <- fetch_charge(charge_id),
+         :ok <- validate_refund_amount(charge, amount),
+         {:ok, result} <- MyApp.PaymentGateway.refund(charge.transaction_id, amount) do
+      insert_refund(charge, amount, result.refund_id)
+    end
+  end
+
+  @doc """
+  Lists all charges for a customer, ordered by most recent first.
+
+  `opts` supports `:limit` (default 20) and `:offset` (default 0).
+  """
+  @spec list_charges(integer(), keyword()) :: [Charge.t()]
+  def list_charges(customer_id, opts \\ []) do
+    limit = Keyword.get(opts, :limit, 20)
+    offset = Keyword.get(opts, :offset, 0)
+
+    Repo.all(
+      from c in Charge,
+        where: c.customer_id == ^customer_id,
+        order_by: [desc: c.inserted_at],
+        limit: ^limit,
+        offset: ^offset
+    )
+  end
+
+  defp fetch_default_payment_method(customer_id) do
+    case Repo.get_by(MyApp.Payments.PaymentMethod, customer_id: customer_id, default: true) do
+      nil -> {:error, :no_payment_method}
+      pm -> {:ok, pm}
+    end
+  end
+
+  defp fetch_charge(charge_id) do
+    case Repo.get(Charge, charge_id) do
+      nil -> {:error, :charge_not_found}
+      charge -> {:ok, charge}
+    end
+  end
+
+  defp validate_refund_amount(%Charge{amount: orig}, amount) when amount > orig do
+    {:error, :exceeds_original}
+  end
+
+  defp validate_refund_amount(_, _), do: :ok
+
+  defp insert_charge(customer_id, amount, currency, transaction_id) do
+    %Charge{}
+    |> Charge.changeset(%{
+      customer_id: customer_id,
+      amount: amount,
+      currency: currency,
+      transaction_id: transaction_id
+    })
+    |> Repo.insert()
+  end
+
+  defp insert_refund(charge, amount, refund_id) do
+    %Refund{}
+    |> Refund.changeset(%{charge_id: charge.id, amount: amount, refund_id: refund_id})
+    |> Repo.insert()
+  end
+end
diff --git a/priv/combined_metrics/samples/error_handling/catches_specific_exception/bad/file_importer.py b/priv/combined_metrics/samples/error_handling/catches_specific_exception/bad/file_importer.py
new file mode 100644
index 0000000..0ab63e0
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/catches_specific_exception/bad/file_importer.py
@@ -0,0 +1,66 @@
+"""File importer that reads, parses, and ingests CSV data files."""
+from __future__ import annotations
+
+import csv
+import io
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class ImportResult:
+    filename: str
+    rows_imported: int
+    rows_skipped: int
+    error: Optional[str] = None
+
+
+def read_file(path: str) -> str:
+    """Read a file — catches all exceptions, masking programming errors."""
+    try:
+        with open(path, encoding="utf-8") as fh:
+            return fh.read()
+    except Exception:          # too broad: hides PermissionError, MemoryError, etc.
+        return ""
+
+
+def parse_csv(content: str) -> list:
+    """Parse CSV text — broad catch swallows malformed-data signals."""
+    try:
+        reader = csv.DictReader(io.StringIO(content))
+        return list(reader)
+    except Exception as e:     # catches everything including KeyboardInterrupt chain
+        print(f"parse error: {e}")
+        return []
+
+
+def convert_row(row: dict) -> dict:
+    """Convert raw string values — broad except prevents surfacing schema issues."""
+    try:
+        return {
+            "id": int(row["id"]),
+            "name": row["name"].strip(),
+            "amount": float(row["amount"]),
+        }
+    except Exception:          # hides KeyError (missing column) vs ValueError (bad data)
+        return {}
+
+
+def import_file(path: str) -> ImportResult:
+    """Import a CSV file — catches everything so failures are silently swallowed."""
+    filename = os.path.basename(path)
+    try:
+        content = read_file(path)
+        rows = parse_csv(content)
+        imported = 0
+        skipped = 0
+        for row in rows:
+            result = convert_row(row)
+            if result:
+                imported += 1
+            else:
+                skipped += 1
+        return ImportResult(filename=filename, rows_imported=imported, rows_skipped=skipped)
+    except Exception as e:     # outermost catch hides all failures
+        return ImportResult(filename=filename, rows_imported=0, rows_skipped=0, error=str(e))
diff --git a/priv/combined_metrics/samples/error_handling/catches_specific_exception/good/file_importer.py b/priv/combined_metrics/samples/error_handling/catches_specific_exception/good/file_importer.py
new file mode 100644
index 0000000..790db17
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/catches_specific_exception/good/file_importer.py
@@ -0,0 +1,69 @@
+"""File importer that reads, parses, and ingests CSV data files."""
+from __future__ import annotations
+
+import csv
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class ImportResult:
+    filename: str
+    rows_imported: int
+    rows_skipped: int
+    error: Optional[str] = None
+
+
+def read_file(path: str) -> str:
+    """Read a file and return its contents, raising descriptive errors."""
+    try:
+        with open(path, encoding="utf-8") as fh:
+            return fh.read()
+    except FileNotFoundError:
+        raise FileNotFoundError(f"Import file not found: {path}")
+    except PermissionError:
+        raise PermissionError(f"No read permission for file: {path}")
+    except UnicodeDecodeError as exc:
+        raise ValueError(f"File {path} is not valid UTF-8") from exc
+
+
+def parse_csv(content: str) -> list[dict[str, str]]:
+    """Parse CSV text into a list of row dicts."""
+    import io
+    try:
+        reader = csv.DictReader(io.StringIO(content))
+        return list(reader)
+    except csv.Error as exc:
+        raise ValueError(f"Malformed CSV content: {exc}") from exc
+
+
+def convert_row(row: dict[str, str]) -> dict:
+    """Convert raw string values to typed fields."""
+    try:
+        return {
+            "id": int(row["id"]),
+            "name": row["name"].strip(),
+            "amount": float(row["amount"]),
+        }
+    except KeyError as exc:
+        raise ValueError(f"Missing required column: {exc}") from exc
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"Type conversion failed for row {row}: {exc}") from exc
+
+
+def import_file(path: str) -> ImportResult:
+    """Import a CSV file, skipping rows that fail conversion."""
+    filename = os.path.basename(path)
+    content = read_file(path)
+    rows = parse_csv(content)
+
+    imported, skipped = 0, 0
+    for row in rows:
+        try:
+            convert_row(row)
+            imported += 1
+        except ValueError:
+            skipped += 1
+
+    return ImportResult(filename=filename, rows_imported=imported, rows_skipped=skipped)
diff --git a/priv/combined_metrics/samples/error_handling/catches_typed_exception/bad/PaymentGateway.php b/priv/combined_metrics/samples/error_handling/catches_typed_exception/bad/PaymentGateway.php
new file mode 100644
index 0000000..db4449b
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/catches_typed_exception/bad/PaymentGateway.php
@@ -0,0 +1,62 @@
+<?php
+
+namespace App\Payment;
+
+class PaymentGateway
+{
+    public function __construct(
+        private $httpClient,
+        private $logger
+    ) {
+    }
+
+    public function charge($amountCents, $token, $customerId)
+    {
+        try {
+            $response = $this->httpClient->post('/v1/charges', [
+                'amount'      => $amountCents,
+                'source'      => $token,
+                'customer_id' => $customerId,
+            ]);
+
+            return [
+                'transaction_id' => $response['id'],
+                'status'         => $response['status'],
+            ];
+        } catch (\Exception $e) {
+            // Bare \Exception catches everything — loses all error specificity
+            $this->logger->error("Charge failed: {$e->getMessage()}");
+            return null;
+        }
+    }
+
+    public function refund($transactionId, $amountCents)
+    {
+        try {
+            $response = $this->httpClient->post('/v1/refunds', [
+                'transaction_id' => $transactionId,
+                'amount'         => $amountCents,
+            ]);
+
+            return ['refund_id' => $response['refund_id']];
+        } catch (\Throwable $e) {
+            // \Throwable is even broader — catches Errors and Exceptions alike
+            $this->logger->error("Refund failed: {$e->getMessage()}");
+            return false;
+        }
+    }
+
+    public function validateCard($cardNumber, $expiry, $cvv)
+    {
+        try {
+            return $this->httpClient->post('/v1/validate', [
+                'number' => $cardNumber,
+                'expiry' => $expiry,
+                'cvv'    => $cvv,
+            ]);
+        } catch (\Exception $e) {
+            // Swallows all exceptions — caller gets null regardless of cause
+            return null;
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/catches_typed_exception/good/PaymentGateway.php b/priv/combined_metrics/samples/error_handling/catches_typed_exception/good/PaymentGateway.php
new file mode 100644
index 0000000..5d49240
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/catches_typed_exception/good/PaymentGateway.php
@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Payment;
+
+use App\Exception\CardDeclinedException;
+use App\Exception\GatewayTimeoutException;
+use App\Exception\InvalidCardException;
+use Psr\Log\LoggerInterface;
+
+class PaymentGateway
+{
+    public function __construct(
+        private HttpClient $httpClient,
+        private LoggerInterface $logger
+    ) {
+    }
+
+    public function charge(int $amountCents, string $token, int $customerId): ChargeResult
+    {
+        try {
+            $response = $this->httpClient->post('/v1/charges', [
+                'amount'      => $amountCents,
+                'source'      => $token,
+                'customer_id' => $customerId,
+            ]);
+
+            return new ChargeResult(
+                transactionId: $response['id'],
+                status: $response['status']
+            );
+        } catch (CardDeclinedException $e) {
+            $this->logger->info("Card declined for customer {$customerId}: {$e->getDeclineCode()}");
+            throw $e;
+        } catch (GatewayTimeoutException $e) {
+            $this->logger->error("Gateway timeout for customer {$customerId}: {$e->getMessage()}");
+            throw new \RuntimeException("Payment service temporarily unavailable", 0, $e);
+        } catch (InvalidCardException $e) {
+            $this->logger->warning("Invalid card for customer {$customerId}: {$e->getMessage()}");
+            throw $e;
+        }
+    }
+
+    public function refund(string $transactionId, int $amountCents): RefundResult
+    {
+        try {
+            $response = $this->httpClient->post('/v1/refunds', [
+                'transaction_id' => $transactionId,
+                'amount'         => $amountCents,
+            ]);
+
+            return new RefundResult(refundId: $response['refund_id']);
+        } catch (TransactionNotFoundException $e) {
+            $this->logger->error("Refund failed — transaction not found: {$transactionId}");
+            throw $e;
+        } catch (RefundNotAllowedException $e) {
+            $this->logger->warning("Refund not allowed for {$transactionId}: {$e->getMessage()}");
+            throw $e;
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/custom_error_type_implements_unwrap/bad/processor.go b/priv/combined_metrics/samples/error_handling/custom_error_type_implements_unwrap/bad/processor.go
new file mode 100644
index 0000000..6e00094
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/custom_error_type_implements_unwrap/bad/processor.go
@@ -0,0 +1,61 @@
+package processor
+
+import (
+	"errors"
+	"fmt"
+)
+
+// ProcessingError wraps an underlying error but does NOT implement Unwrap.
+// This prevents errors.Is and errors.As from traversing the chain.
+type ProcessingError struct {
+	Stage string
+	JobID string
+	Err   error
+}
+
+func (e *ProcessingError) Error() string {
+	return fmt.Sprintf("processing job %s at stage %q: %v", e.JobID, e.Stage, e.Err)
+}
+
+// Missing: func (e *ProcessingError) Unwrap() error { return e.Err }
+
+var ErrInvalidPayload = errors.New("invalid payload")
+
+type Job struct {
+	ID      string
+	Payload []byte
+}
+
+type PaymentProcessor struct{}
+
+func (p *PaymentProcessor) Process(job Job) error {
+	if len(job.Payload) == 0 {
+		return &ProcessingError{
+			Stage: "validate",
+			JobID: job.ID,
+			Err:   ErrInvalidPayload,
+		}
+	}
+
+	if err := p.execute(job); err != nil {
+		return &ProcessingError{
+			Stage: "execute",
+			JobID: job.ID,
+			Err:   err,
+		}
+	}
+	return nil
+}
+
+func (p *PaymentProcessor) execute(job Job) error {
+	return nil
+}
+
+// HandleJob — errors.Is returns false here because Unwrap is missing.
+func HandleJob(p *PaymentProcessor, job Job) {
+	err := p.Process(job)
+	// This will never be true; the error chain cannot be traversed.
+	if errors.Is(err, ErrInvalidPayload) {
+		fmt.Println("bad payload, skip job")
+	}
+}
diff --git a/priv/combined_metrics/samples/error_handling/custom_error_type_implements_unwrap/good/processor.go b/priv/combined_metrics/samples/error_handling/custom_error_type_implements_unwrap/good/processor.go
new file mode 100644
index 0000000..591ad1c
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/custom_error_type_implements_unwrap/good/processor.go
@@ -0,0 +1,63 @@
+package processor
+
+import (
+	"errors"
+	"fmt"
+)
+
+// ProcessingError wraps an underlying error and adds the stage at which it occurred.
+// It implements Unwrap so errors.Is and errors.As can traverse the chain.
+type ProcessingError struct {
+	Stage string
+	JobID string
+	Err   error
+}
+
+func (e *ProcessingError) Error() string {
+	return fmt.Sprintf("processing job %s at stage %q: %v", e.JobID, e.Stage, e.Err)
+}
+
+// Unwrap allows errors.Is and errors.As to inspect the wrapped error.
+func (e *ProcessingError) Unwrap() error { return e.Err }
+
+var ErrInvalidPayload = errors.New("invalid payload")
+
+type Job struct {
+	ID      string
+	Payload []byte
+}
+
+type PaymentProcessor struct{}
+
+func (p *PaymentProcessor) Process(job Job) error {
+	if len(job.Payload) == 0 {
+		return &ProcessingError{
+			Stage: "validate",
+			JobID: job.ID,
+			Err:   ErrInvalidPayload,
+		}
+	}
+
+	if err := p.execute(job); err != nil {
+		return &ProcessingError{
+			Stage: "execute",
+			JobID: job.ID,
+			Err:   err,
+		}
+	}
+	return nil
+}
+
+func (p *PaymentProcessor) execute(job Job) error {
+	// simulate execution
+	return nil
+}
+
+// HandleJob demonstrates that errors.Is works through ProcessingError.Unwrap.
+func HandleJob(p *PaymentProcessor, job Job) {
+	err := p.Process(job)
+	if errors.Is(err, ErrInvalidPayload) {
+		// reachable because ProcessingError implements Unwrap
+		fmt.Println("bad payload, skip job")
+	}
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_assert_result_without_value/bad/validator_test.rs b/priv/combined_metrics/samples/error_handling/does_not_assert_result_without_value/bad/validator_test.rs
new file mode 100644
index 0000000..dd0e094
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_assert_result_without_value/bad/validator_test.rs
@@ -0,0 +1,50 @@
+// Bad: assert!(result.is_ok()) discards the error — failures show no useful info
+
+fn validate_email(email: &str) -> Result<(), String> {
+    if email.contains('@') && email.contains('.') {
+        Ok(())
+    } else {
+        Err(format!("'{email}' is not a valid email address"))
+    }
+}
+
+fn parse_port(s: &str) -> Result<u16, String> {
+    s.parse::<u16>().map_err(|e| format!("invalid port '{s}': {e}"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn valid_email_passes() {
+        // Failure output: "assertion failed" — no indication of what went wrong
+        assert!(validate_email("user@example.com").is_ok());
+    }
+
+    #[test]
+    fn invalid_email_returns_error() {
+        // Only checks that it's an Err — cannot see the actual message
+        assert!(validate_email("not-an-email").is_err());
+    }
+
+    #[test]
+    fn valid_port_parses() {
+        let result = parse_port("8080");
+        // We know it's Ok but cannot verify the actual parsed value
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn non_numeric_port_returns_error() {
+        // Cannot inspect what error was returned
+        assert!(parse_port("abc").is_err());
+    }
+
+    #[test]
+    fn edge_case_port() {
+        // If this fails, we see nothing about what parse_port returned
+        assert!(parse_port("65535").is_ok());
+        assert!(parse_port("65536").is_err());
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_assert_result_without_value/good/validator_test.rs b/priv/combined_metrics/samples/error_handling/does_not_assert_result_without_value/good/validator_test.rs
new file mode 100644
index 0000000..8619e93
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_assert_result_without_value/good/validator_test.rs
@@ -0,0 +1,50 @@
+// Good: tests unwrap the Result so the actual error is shown on failure
+
+fn validate_email(email: &str) -> Result<(), String> {
+    if email.contains('@') && email.contains('.') {
+        Ok(())
+    } else {
+        Err(format!("'{email}' is not a valid email address"))
+    }
+}
+
+fn parse_port(s: &str) -> Result<u16, String> {
+    s.parse::<u16>().map_err(|e| format!("invalid port '{s}': {e}"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn valid_email_passes() {
+        // Using unwrap() shows the error message when the assertion fails
+        validate_email("user@example.com").unwrap();
+    }
+
+    #[test]
+    fn invalid_email_returns_error() {
+        let err = validate_email("not-an-email").unwrap_err();
+        assert!(err.contains("not-an-email"), "expected email in error, got: {err}");
+    }
+
+    #[test]
+    fn valid_port_parses() {
+        let port = parse_port("8080").unwrap();
+        assert_eq!(port, 8080);
+    }
+
+    #[test]
+    fn port_zero_is_rejected() {
+        // parse_port("0") succeeds (0 is a valid u16), but a higher-level
+        // validator would reject it — show the value to understand failures
+        let port = parse_port("0").unwrap();
+        assert_eq!(port, 0);
+    }
+
+    #[test]
+    fn non_numeric_port_returns_error() {
+        let err = parse_port("abc").unwrap_err();
+        assert!(err.contains("abc"), "expected input in error, got: {err}");
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_catch_and_suppress_errors/bad/FileImporter.swift b/priv/combined_metrics/samples/error_handling/does_not_catch_and_suppress_errors/bad/FileImporter.swift
new file mode 100644
index 0000000..2a90f19
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_catch_and_suppress_errors/bad/FileImporter.swift
@@ -0,0 +1,58 @@
+import Foundation
+
+struct ImportResult {
+    let recordsImported: Int
+    let sourceURL: URL
+}
+
+class FileImporter {
+
+    func importCSV(from url: URL) -> ImportResult? {
+        guard FileManager.default.fileExists(atPath: url.path) else {
+            return nil
+        }
+
+        let contents: String
+        do {
+            contents = try String(contentsOf: url, encoding: .utf8)
+        } catch {
+            // Silently swallowed — caller has no idea what went wrong
+            return nil
+        }
+
+        let lines = contents.components(separatedBy: .newlines).filter { !$0.isEmpty }
+        guard lines.count > 1 else {
+            return nil
+        }
+
+        var successCount = 0
+
+        for (index, line) in lines.dropFirst().enumerated() {
+            do {
+                try processLine(line, index: index)
+                successCount += 1
+            } catch {
+                // Silently skipping bad rows — data loss with no notification
+                continue
+            }
+        }
+
+        // Returns a "success" even when half the rows were silently dropped
+        return ImportResult(recordsImported: successCount, sourceURL: url)
+    }
+
+    func saveRecord(_ data: Data, to url: URL) {
+        do {
+            try data.write(to: url)
+        } catch {
+            // Error completely swallowed — caller thinks save succeeded
+        }
+    }
+
+    private func processLine(_ line: String, index: Int) throws {
+        let columns = line.components(separatedBy: ",")
+        guard columns.count >= 3 else {
+            throw NSError(domain: "ImportError", code: 1)
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_catch_and_suppress_errors/good/FileImporter.swift b/priv/combined_metrics/samples/error_handling/does_not_catch_and_suppress_errors/good/FileImporter.swift
new file mode 100644
index 0000000..031ad87
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_catch_and_suppress_errors/good/FileImporter.swift
@@ -0,0 +1,66 @@
+import Foundation
+
+enum ImportError: Error {
+    case fileNotFound(URL)
+    case invalidFormat(String)
+    case permissionDenied
+    case partialFailure(succeeded: Int, failed: [Error])
+}
+
+struct ImportResult {
+    let recordsImported: Int
+    let sourceURL: URL
+}
+
+class FileImporter {
+    private let logger: Logger
+
+    init(logger: Logger = Logger(subsystem: "com.app", category: "importer")) {
+        self.logger = logger
+    }
+
+    func importCSV(from url: URL) throws -> ImportResult {
+        guard FileManager.default.fileExists(atPath: url.path) else {
+            throw ImportError.fileNotFound(url)
+        }
+
+        let contents: String
+        do {
+            contents = try String(contentsOf: url, encoding: .utf8)
+        } catch {
+            logger.error("Failed to read file at \(url.path): \(error)")
+            throw ImportError.permissionDenied
+        }
+
+        let lines = contents.components(separatedBy: .newlines).filter { !$0.isEmpty }
+        guard lines.count > 1 else {
+            throw ImportError.invalidFormat("File contains no data rows")
+        }
+
+        var errors: [Error] = []
+        var successCount = 0
+
+        for (index, line) in lines.dropFirst().enumerated() {
+            do {
+                try processLine(line, index: index)
+                successCount += 1
+            } catch {
+                logger.warning("Row \(index) failed: \(error)")
+                errors.append(error)
+            }
+        }
+
+        if !errors.isEmpty {
+            throw ImportError.partialFailure(succeeded: successCount, failed: errors)
+        }
+
+        return ImportResult(recordsImported: successCount, sourceURL: url)
+    }
+
+    private func processLine(_ line: String, index: Int) throws {
+        let columns = line.components(separatedBy: ",")
+        guard columns.count >= 3 else {
+            throw ImportError.invalidFormat("Row \(index) has \(columns.count) columns, expected 3+")
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_catch_general_exception/bad/OrderProcessor.cs b/priv/combined_metrics/samples/error_handling/does_not_catch_general_exception/bad/OrderProcessor.cs
new file mode 100644
index 0000000..12e1c1c
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_catch_general_exception/bad/OrderProcessor.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Data.SqlClient;
+using System.IO;
+
+namespace OrderService
+{
+    public class OrderProcessor
+    {
+        private readonly IOrderRepository _repository;
+        private readonly ILogger _logger;
+
+        public OrderProcessor(IOrderRepository repository, ILogger logger)
+        {
+            _repository = repository;
+            _logger = logger;
+        }
+
+        public void ProcessOrder(int orderId)
+        {
+            try
+            {
+                var order = _repository.GetById(orderId);
+                ValidateOrder(order);
+                _repository.MarkAsProcessed(order);
+            }
+            catch (Exception ex)
+            {
+                // Catches everything — hides programming errors, thread aborts, etc.
+                _logger.Error("Something went wrong: " + ex.Message);
+            }
+        }
+
+        public bool TrySaveInvoice(Order order, string path)
+        {
+            try
+            {
+                var content = GenerateInvoiceContent(order);
+                File.WriteAllText(path, content);
+                return true;
+            }
+            catch (Exception)
+            {
+                // Swallows all exceptions silently, including OutOfMemoryException
+                return false;
+            }
+        }
+
+        public void FinalizeOrders()
+        {
+            try
+            {
+                var pending = _repository.GetPendingOrders();
+                foreach (var order in pending)
+                {
+                    _repository.Finalize(order);
+                }
+            }
+            catch (Exception ex)
+            {
+                // Re-throwing System.Exception as a new Exception loses the specific type
+                throw new Exception("Finalization failed", ex);
+            }
+        }
+
+        private void ValidateOrder(Order order)
+        {
+            if (order.Items.Count == 0)
+                throw new InvalidOrderException("Order must contain at least one item");
+        }
+
+        private string GenerateInvoiceContent(Order order) => $"Invoice for order {order.Id}";
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_catch_general_exception/good/OrderProcessor.cs b/priv/combined_metrics/samples/error_handling/does_not_catch_general_exception/good/OrderProcessor.cs
new file mode 100644
index 0000000..e9614dc
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_catch_general_exception/good/OrderProcessor.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Data.SqlClient;
+using System.IO;
+
+namespace OrderService
+{
+    public class OrderProcessor
+    {
+        private readonly IOrderRepository _repository;
+        private readonly ILogger _logger;
+
+        public OrderProcessor(IOrderRepository repository, ILogger logger)
+        {
+            _repository = repository;
+            _logger = logger;
+        }
+
+        public void ProcessOrder(int orderId)
+        {
+            try
+            {
+                var order = _repository.GetById(orderId);
+                ValidateOrder(order);
+                _repository.MarkAsProcessed(order);
+            }
+            catch (SqlException ex)
+            {
+                _logger.Error("Database error while processing order {orderId}", ex);
+                throw new OrderProcessingException("Failed to access order data", ex);
+            }
+            catch (InvalidOrderException ex)
+            {
+                _logger.Warning("Order {orderId} failed validation: {message}", ex.Message);
+                throw;
+            }
+        }
+
+        public bool TrySaveInvoice(Order order, string path)
+        {
+            try
+            {
+                var content = GenerateInvoiceContent(order);
+                File.WriteAllText(path, content);
+                return true;
+            }
+            catch (UnauthorizedAccessException ex)
+            {
+                _logger.Warning("Cannot write invoice to {path}: access denied", ex);
+                return false;
+            }
+            catch (IOException ex)
+            {
+                _logger.Warning("IO error writing invoice to {path}", ex);
+                return false;
+            }
+        }
+
+        private void ValidateOrder(Order order)
+        {
+            if (order.Items.Count == 0)
+                throw new InvalidOrderException("Order must contain at least one item");
+            if (order.CustomerId <= 0)
+                throw new InvalidOrderException("Order must be associated with a valid customer");
+        }
+
+        private string GenerateInvoiceContent(Order order) => $"Invoice for order {order.Id}";
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_discard_errors/bad/handler.go b/priv/combined_metrics/samples/error_handling/does_not_discard_errors/bad/handler.go
new file mode 100644
index 0000000..9ecb167
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_discard_errors/bad/handler.go
@@ -0,0 +1,50 @@
+package handler
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+)
+
+type OrderRequest struct {
+	UserID    string  `json:"user_id"`
+	ProductID string  `json:"product_id"`
+	Quantity  int     `json:"quantity"`
+	Price     float64 `json:"price"`
+}
+
+type OrderResponse struct {
+	OrderID string `json:"order_id"`
+	Status  string `json:"status"`
+}
+
+type OrderService interface {
+	PlaceOrder(req OrderRequest) (string, error)
+	NotifyUser(userID, orderID string) error
+}
+
+type OrderHandler struct {
+	service OrderService
+	logger  *log.Logger
+}
+
+func NewOrderHandler(service OrderService, logger *log.Logger) *OrderHandler {
+	return &OrderHandler{service: service, logger: logger}
+}
+
+func (h *OrderHandler) PlaceOrder(w http.ResponseWriter, r *http.Request) {
+	var req OrderRequest
+	// error from Decode is discarded
+	_ = json.NewDecoder(r.Body).Decode(&req)
+
+	// error from PlaceOrder is discarded
+	orderID, _ := h.service.PlaceOrder(req)
+
+	// error from NotifyUser is discarded
+	_ = h.service.NotifyUser(req.UserID, orderID)
+
+	resp := OrderResponse{OrderID: orderID, Status: "confirmed"}
+	w.Header().Set("Content-Type", "application/json")
+	// error from Encode is discarded
+	_ = json.NewEncoder(w).Encode(resp)
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_discard_errors/good/handler.go b/priv/combined_metrics/samples/error_handling/does_not_discard_errors/good/handler.go
new file mode 100644
index 0000000..3b4be17
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_discard_errors/good/handler.go
@@ -0,0 +1,60 @@
+package handler
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+)
+
+type OrderRequest struct {
+	UserID    string  `json:"user_id"`
+	ProductID string  `json:"product_id"`
+	Quantity  int     `json:"quantity"`
+	Price     float64 `json:"price"`
+}
+
+type OrderResponse struct {
+	OrderID string `json:"order_id"`
+	Status  string `json:"status"`
+}
+
+type OrderService interface {
+	PlaceOrder(req OrderRequest) (string, error)
+	NotifyUser(userID, orderID string) error
+}
+
+type OrderHandler struct {
+	service OrderService
+	logger  *log.Logger
+}
+
+func NewOrderHandler(service OrderService, logger *log.Logger) *OrderHandler {
+	return &OrderHandler{service: service, logger: logger}
+}
+
+func (h *OrderHandler) PlaceOrder(w http.ResponseWriter, r *http.Request) {
+	var req OrderRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		h.logger.Printf("failed to decode request: %v", err)
+		http.Error(w, "invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	orderID, err := h.service.PlaceOrder(req)
+	if err != nil {
+		h.logger.Printf("failed to place order for user %s: %v", req.UserID, err)
+		http.Error(w, "failed to place order", http.StatusInternalServerError)
+		return
+	}
+
+	if err := h.service.NotifyUser(req.UserID, orderID); err != nil {
+		h.logger.Printf("failed to notify user %s for order %s: %v", req.UserID, orderID, err)
+		// notification failure is non-fatal; continue
+	}
+
+	resp := OrderResponse{OrderID: orderID, Status: "confirmed"}
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(resp); err != nil {
+		h.logger.Printf("failed to encode response: %v", err)
+	}
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_expose_implementation_errors/bad/gateway.go b/priv/combined_metrics/samples/error_handling/does_not_expose_implementation_errors/bad/gateway.go
new file mode 100644
index 0000000..5394b67
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_expose_implementation_errors/bad/gateway.go
@@ -0,0 +1,50 @@
+package gateway
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+// ShipmentStatus is returned by the shipping gateway.
+type ShipmentStatus struct {
+	TrackingID string
+	State      string
+}
+
+// ShippingGateway calls an external carrier API.
+type ShippingGateway struct {
+	base   string
+	client *http.Client
+}
+
+func New(base string) *ShippingGateway {
+	return &ShippingGateway{base: base, client: &http.Client{}}
+}
+
+// TrackShipment retrieves the current status of a shipment.
+// Using %w exposes internal http, net/url, and json error types to callers,
+// leaking implementation details across the abstraction boundary.
+func (g *ShippingGateway) TrackShipment(ctx context.Context, trackingID string) (*ShipmentStatus, error) {
+	url := fmt.Sprintf("%s/shipments/%s", g.base, trackingID)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		// %w leaks *url.Error and http internals to callers.
+		return nil, fmt.Errorf("track shipment %q: build request: %w", trackingID, err)
+	}
+
+	resp, err := g.client.Do(req)
+	if err != nil {
+		// %w propagates net/http transport types; callers now depend on them.
+		return nil, fmt.Errorf("track shipment %q: call carrier api: %w", trackingID, err)
+	}
+	defer resp.Body.Close()
+
+	var status ShipmentStatus
+	if err := json.NewDecoder(resp.Body).Decode(&status); err != nil {
+		// %w exposes *json.SyntaxError / *json.UnmarshalTypeError to callers.
+		return nil, fmt.Errorf("track shipment %q: decode response: %w", trackingID, err)
+	}
+	return &status, nil
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_expose_implementation_errors/good/gateway.go b/priv/combined_metrics/samples/error_handling/does_not_expose_implementation_errors/good/gateway.go
new file mode 100644
index 0000000..fa7fc27
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_expose_implementation_errors/good/gateway.go
@@ -0,0 +1,50 @@
+package gateway
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+// ShipmentStatus is returned by the shipping gateway.
+type ShipmentStatus struct {
+	TrackingID string
+	State      string
+}
+
+// ShippingGateway calls an external carrier API.
+type ShippingGateway struct {
+	base   string
+	client *http.Client
+}
+
+func New(base string) *ShippingGateway {
+	return &ShippingGateway{base: base, client: &http.Client{}}
+}
+
+// TrackShipment retrieves the current status of a shipment.
+// Internal HTTP and JSON errors are wrapped with %v to avoid leaking
+// implementation details to callers above this abstraction layer.
+func (g *ShippingGateway) TrackShipment(ctx context.Context, trackingID string) (*ShipmentStatus, error) {
+	url := fmt.Sprintf("%s/shipments/%s", g.base, trackingID)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		// %v instead of %w: callers should not depend on http.Request internals.
+		return nil, fmt.Errorf("track shipment %q: build request: %v", trackingID, err)
+	}
+
+	resp, err := g.client.Do(req)
+	if err != nil {
+		// %v prevents leaking net/url or transport error types.
+		return nil, fmt.Errorf("track shipment %q: call carrier api: %v", trackingID, err)
+	}
+	defer resp.Body.Close()
+
+	var status ShipmentStatus
+	if err := json.NewDecoder(resp.Body).Decode(&status); err != nil {
+		// %v hides JSON parsing internals from callers.
+		return nil, fmt.Errorf("track shipment %q: decode response: %v", trackingID, err)
+	}
+	return &status, nil
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_force_unwrap_optionals/bad/NetworkClient.swift b/priv/combined_metrics/samples/error_handling/does_not_force_unwrap_optionals/bad/NetworkClient.swift
new file mode 100644
index 0000000..49710b7
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_force_unwrap_optionals/bad/NetworkClient.swift
@@ -0,0 +1,57 @@
+import Foundation
+
+struct APIResponse<T: Decodable>: Decodable {
+    let data: T
+    let statusCode: Int
+}
+
+enum NetworkError: Error {
+    case invalidURL
+    case noData
+    case decodingFailed(Error)
+}
+
+class NetworkClient {
+    private let session: URLSession
+    private let baseURL: URL
+
+    init(baseURL: URL, session: URLSession = .shared) {
+        self.session = session
+        self.baseURL = baseURL
+    }
+
+    func fetch<T: Decodable>(
+        path: String,
+        completion: @escaping (Result<T, NetworkError>) -> Void
+    ) {
+        // Force unwrap: crashes if path is not a valid URL
+        let url = URL(string: path, relativeTo: baseURL)!
+
+        session.dataTask(with: url) { data, response, error in
+            // Force unwrap: crashes if data is nil
+            let responseData = data!
+
+            do {
+                let decoded = try JSONDecoder().decode(T.self, from: responseData)
+                completion(.success(decoded))
+            } catch {
+                completion(.failure(.decodingFailed(error)))
+            }
+        }.resume()
+    }
+
+    func buildURL(for path: String) -> URL {
+        // Force unwrap: crashes on invalid input
+        return URL(string: path, relativeTo: baseURL)!
+    }
+
+    func headerValue(for key: String, in response: HTTPURLResponse) -> String {
+        // Force unwrap: crashes if header is absent
+        return response.value(forHTTPHeaderField: key)!
+    }
+
+    func firstComponent(of url: URL) -> String {
+        // Force unwrap: crashes if pathComponents is empty
+        return url.pathComponents.first!
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_force_unwrap_optionals/good/NetworkClient.swift b/priv/combined_metrics/samples/error_handling/does_not_force_unwrap_optionals/good/NetworkClient.swift
new file mode 100644
index 0000000..242e54e
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_force_unwrap_optionals/good/NetworkClient.swift
@@ -0,0 +1,66 @@
+import Foundation
+
+struct APIResponse<T: Decodable>: Decodable {
+    let data: T
+    let statusCode: Int
+}
+
+enum NetworkError: Error {
+    case invalidURL
+    case noData
+    case decodingFailed(Error)
+    case unexpectedStatusCode(Int)
+}
+
+class NetworkClient {
+    private let session: URLSession
+    private let baseURL: URL
+
+    init(baseURL: URL, session: URLSession = .shared) {
+        self.session = session
+        self.baseURL = baseURL
+    }
+
+    func fetch<T: Decodable>(
+        path: String,
+        completion: @escaping (Result<T, NetworkError>) -> Void
+    ) {
+        guard let url = URL(string: path, relativeTo: baseURL) else {
+            completion(.failure(.invalidURL))
+            return
+        }
+
+        session.dataTask(with: url) { data, response, error in
+            if let error = error {
+                completion(.failure(.decodingFailed(error)))
+                return
+            }
+
+            guard let data = data else {
+                completion(.failure(.noData))
+                return
+            }
+
+            if let httpResponse = response as? HTTPURLResponse,
+               !(200..<300).contains(httpResponse.statusCode) {
+                completion(.failure(.unexpectedStatusCode(httpResponse.statusCode)))
+                return
+            }
+
+            do {
+                let decoded = try JSONDecoder().decode(T.self, from: data)
+                completion(.success(decoded))
+            } catch {
+                completion(.failure(.decodingFailed(error)))
+            }
+        }.resume()
+    }
+
+    func buildURL(for path: String) -> URL? {
+        return URL(string: path, relativeTo: baseURL)
+    }
+
+    func headerValue(for key: String, in response: HTTPURLResponse) -> String? {
+        return response.value(forHTTPHeaderField: key)
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_return_error_codes/bad/UserRepository.cs b/priv/combined_metrics/samples/error_handling/does_not_return_error_codes/bad/UserRepository.cs
new file mode 100644
index 0000000..64fcb35
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_return_error_codes/bad/UserRepository.cs
@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.Data.SqlClient;
+
+namespace UserService
+{
+    public class UserRepository
+    {
+        private readonly string _connectionString;
+
+        public UserRepository(string connectionString)
+        {
+            _connectionString = connectionString;
+        }
+
+        // Returns -1 on failure instead of throwing
+        public int GetById(int userId, out User user)
+        {
+            user = null;
+            try
+            {
+                using var connection = new SqlConnection(_connectionString);
+                connection.Open();
+                var command = new SqlCommand("SELECT * FROM Users WHERE Id = @id", connection);
+                command.Parameters.AddWithValue("@id", userId);
+
+                using var reader = command.ExecuteReader();
+                if (!reader.Read())
+                    return -1; // not found
+
+                user = MapUser(reader);
+                return 0; // success
+            }
+            catch (SqlException)
+            {
+                return -2; // database error
+            }
+        }
+
+        // Returns false on failure — caller can't distinguish why it failed
+        public bool Create(User user)
+        {
+            if (user == null) return false;
+            if (string.IsNullOrWhiteSpace(user.Email)) return false;
+
+            try
+            {
+                using var connection = new SqlConnection(_connectionString);
+                connection.Open();
+
+                var checkCmd = new SqlCommand(
+                    "SELECT COUNT(1) FROM Users WHERE Email = @email", connection);
+                checkCmd.Parameters.AddWithValue("@email", user.Email);
+                if ((int)checkCmd.ExecuteScalar() > 0)
+                    return false; // duplicate email, but caller doesn't know that
+
+                var command = new SqlCommand(
+                    "INSERT INTO Users (Email, Name) VALUES (@email, @name)", connection);
+                command.Parameters.AddWithValue("@email", user.Email);
+                command.Parameters.AddWithValue("@name", user.Name);
+                command.ExecuteNonQuery();
+                return true;
+            }
+            catch (SqlException)
+            {
+                return false;
+            }
+        }
+
+        // Returns null to signal "no users" or "error" — ambiguous
+        public List<User> GetByRole(string role)
+        {
+            if (string.IsNullOrWhiteSpace(role)) return null;
+
+            try
+            {
+                using var connection = new SqlConnection(_connectionString);
+                connection.Open();
+                var command = new SqlCommand("SELECT * FROM Users WHERE Role = @role", connection);
+                command.Parameters.AddWithValue("@role", role);
+
+                var users = new List<User>();
+                using var reader = command.ExecuteReader();
+                while (reader.Read())
+                    users.Add(MapUser(reader));
+
+                return users;
+            }
+            catch (SqlException)
+            {
+                return null; // error or empty — caller cannot tell the difference
+            }
+        }
+
+        private User MapUser(SqlDataReader reader) =>
+            new User(reader.GetInt32(0), reader.GetString(1), reader.GetString(2));
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_return_error_codes/good/UserRepository.cs b/priv/combined_metrics/samples/error_handling/does_not_return_error_codes/good/UserRepository.cs
new file mode 100644
index 0000000..f113b5d
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_return_error_codes/good/UserRepository.cs
@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Data.SqlClient;
+
+namespace UserService
+{
+    public class UserRepository
+    {
+        private readonly string _connectionString;
+
+        public UserRepository(string connectionString)
+        {
+            _connectionString = connectionString;
+        }
+
+        public User GetById(int userId)
+        {
+            using var connection = new SqlConnection(_connectionString);
+            connection.Open();
+            var command = new SqlCommand("SELECT * FROM Users WHERE Id = @id", connection);
+            command.Parameters.AddWithValue("@id", userId);
+
+            using var reader = command.ExecuteReader();
+            if (!reader.Read())
+                throw new UserNotFoundException($"User with ID {userId} does not exist.");
+
+            return MapUser(reader);
+        }
+
+        public void Create(User user)
+        {
+            if (user == null) throw new ArgumentNullException(nameof(user));
+            if (string.IsNullOrWhiteSpace(user.Email))
+                throw new ArgumentException("Email is required.", nameof(user));
+
+            using var connection = new SqlConnection(_connectionString);
+            connection.Open();
+
+            if (EmailExists(connection, user.Email))
+                throw new DuplicateEmailException($"Email '{user.Email}' is already registered.");
+
+            var command = new SqlCommand(
+                "INSERT INTO Users (Email, Name) VALUES (@email, @name)", connection);
+            command.Parameters.AddWithValue("@email", user.Email);
+            command.Parameters.AddWithValue("@name", user.Name);
+            command.ExecuteNonQuery();
+        }
+
+        public IReadOnlyList<User> GetByRole(string role)
+        {
+            if (string.IsNullOrWhiteSpace(role))
+                throw new ArgumentException("Role must not be empty.", nameof(role));
+
+            using var connection = new SqlConnection(_connectionString);
+            connection.Open();
+            var command = new SqlCommand("SELECT * FROM Users WHERE Role = @role", connection);
+            command.Parameters.AddWithValue("@role", role);
+
+            var users = new List<User>();
+            using var reader = command.ExecuteReader();
+            while (reader.Read())
+                users.Add(MapUser(reader));
+
+            return users.AsReadOnly();
+        }
+
+        private bool EmailExists(SqlConnection connection, string email)
+        {
+            var command = new SqlCommand(
+                "SELECT COUNT(1) FROM Users WHERE Email = @email", connection);
+            command.Parameters.AddWithValue("@email", email);
+            return (int)command.ExecuteScalar() > 0;
+        }
+
+        private User MapUser(SqlDataReader reader) =>
+            new User(reader.GetInt32(0), reader.GetString(1), reader.GetString(2));
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_swallow_errors/bad/file_processor.ex b/priv/combined_metrics/samples/error_handling/does_not_swallow_errors/bad/file_processor.ex
new file mode 100644
index 0000000..e1c017f
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_swallow_errors/bad/file_processor.ex
@@ -0,0 +1,85 @@
+defmodule FileProcessor do
+  @moduledoc """
+  Processes uploaded files and extracts their contents.
+  """
+
+  def process_file(path) do
+    try do
+      contents = File.read!(path)
+      parsed = parse_contents(contents)
+      {:ok, parsed}
+    rescue
+      _ -> nil
+    end
+  end
+
+  def read_csv(path) do
+    try do
+      path
+      |> File.stream!()
+      |> Enum.map(&String.trim/1)
+      |> Enum.map(&parse_csv_row/1)
+    rescue
+      e -> false
+    end
+  end
+
+  def extract_metadata(path) do
+    try do
+      stat = File.stat!(path)
+      %{size: stat.size, modified: stat.mtime}
+    catch
+      _, _ -> nil
+    end
+  end
+
+  def batch_process(paths) do
+    Enum.map(paths, fn path ->
+      try do
+        process_file(path)
+      rescue
+        _ -> nil
+      end
+    end)
+  end
+
+  def validate_and_process(path) do
+    try do
+      if File.exists?(path) do
+        process_file(path)
+      else
+        {:error, :not_found}
+      end
+    rescue
+      _ -> false
+    end
+  end
+
+  def compress_file(path, dest) do
+    try do
+      contents = File.read!(path)
+      compressed = :zlib.compress(contents)
+      File.write!(dest, compressed)
+      :ok
+    rescue
+      _ -> nil
+    end
+  end
+
+  def delete_processed(path) do
+    try do
+      File.rm!(path)
+      :ok
+    catch
+      _, _ -> false
+    end
+  end
+
+  defp parse_contents(contents) do
+    String.split(contents, "\n")
+  end
+
+  defp parse_csv_row(row) do
+    String.split(row, ",")
+  end
+end
diff --git a/priv/combined_metrics/samples/error_handling/does_not_swallow_errors/config.yml b/priv/combined_metrics/samples/error_handling/does_not_swallow_errors/config.yml
new file mode 100644
index 0000000..9db16ed
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_swallow_errors/config.yml
@@ -0,0 +1 @@
+doc: "Errors must be handled or re-raised — empty rescue/catch blocks silently hide failures."
diff --git a/priv/combined_metrics/samples/error_handling/does_not_swallow_errors/good/file_processor.ex b/priv/combined_metrics/samples/error_handling/does_not_swallow_errors/good/file_processor.ex
new file mode 100644
index 0000000..6647609
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_swallow_errors/good/file_processor.ex
@@ -0,0 +1,98 @@
+defmodule FileProcessor do
+  @moduledoc """
+  Processes uploaded files and extracts their contents.
+  """
+
+  require Logger
+
+  def process_file(path) do
+    try do
+      contents = File.read!(path)
+      parsed = parse_contents(contents)
+      {:ok, parsed}
+    rescue
+      e in File.Error ->
+        Logger.error("Failed to read file at #{path}: #{Exception.message(e)}")
+        {:error, {:read_failed, path}}
+    end
+  end
+
+  def read_csv(path) do
+    try do
+      rows =
+        path
+        |> File.stream!()
+        |> Enum.map(&String.trim/1)
+        |> Enum.map(&parse_csv_row/1)
+
+      {:ok, rows}
+    rescue
+      e in File.Error ->
+        Logger.error("CSV read failed for #{path}: #{Exception.message(e)}")
+        {:error, {:csv_read_failed, path}}
+    end
+  end
+
+  def extract_metadata(path) do
+    try do
+      stat = File.stat!(path)
+      {:ok, %{size: stat.size, modified: stat.mtime}}
+    rescue
+      e in File.Error ->
+        Logger.warning("Could not stat file #{path}: #{Exception.message(e)}")
+        {:error, {:stat_failed, path}}
+    end
+  end
+
+  def batch_process(paths) do
+    Enum.map(paths, fn path ->
+      case process_file(path) do
+        {:ok, result} -> {:ok, result}
+        {:error, reason} ->
+          Logger.warning("Skipping #{path} due to error: #{inspect(reason)}")
+          {:error, reason}
+      end
+    end)
+  end
+
+  def validate_and_process(path) do
+    if File.exists?(path) do
+      process_file(path)
+    else
+      Logger.warning("Attempted to process non-existent file: #{path}")
+      {:error, {:file_not_found, path}}
+    end
+  end
+
+  def compress_file(path, dest) do
+    try do
+      contents = File.read!(path)
+      compressed = :zlib.compress(contents)
+      File.write!(dest, compressed)
+      :ok
+    rescue
+      e in File.Error ->
+        Logger.error("Compression failed for #{path} -> #{dest}: #{Exception.message(e)}")
+        reraise e, __STACKTRACE__
+    end
+  end
+
+  def delete_processed(path) do
+    case File.rm(path) do
+      :ok ->
+        Logger.info("Deleted processed file: #{path}")
+        :ok
+      {:error, reason} ->
+        Logger.error("Failed to delete #{path}: #{inspect(reason)}")
+        {:error, {:delete_failed, reason}}
+    end
+  end
+
+  defp parse_contents(contents) do
+    String.split(contents, "\n")
+  end
+
+  defp parse_csv_row(row) do
+    String.split(row, ",")
+  end
+end
diff --git a/priv/combined_metrics/samples/error_handling/does_not_swallow_errors_silently/bad/event_bus.js b/priv/combined_metrics/samples/error_handling/does_not_swallow_errors_silently/bad/event_bus.js
new file mode 100644
index 0000000..677dcc5
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_swallow_errors_silently/bad/event_bus.js
@@ -0,0 +1,61 @@
+class EventBus {
+  constructor() {
+    this._handlers = new Map();
+  }
+
+  subscribe(eventName, handler) {
+    if (!this._handlers.has(eventName)) {
+      this._handlers.set(eventName, []);
+    }
+    this._handlers.get(eventName).push(handler);
+  }
+
+  unsubscribe(eventName, handler) {
+    try {
+      const handlers = this._handlers.get(eventName);
+      const index = handlers.indexOf(handler);
+      handlers.splice(index, 1);
+    } catch (e) {
+    }
+  }
+
+  async publish(eventName, payload) {
+    const handlers = this._handlers.get(eventName) ?? [];
+
+    for (const handler of handlers) {
+      try {
+        await handler(payload);
+      } catch (e) {
+      }
+    }
+  }
+
+  async publishAll(events) {
+    for (const { name, payload } of events) {
+      try {
+        await this.publish(name, payload);
+      } catch {
+      }
+    }
+  }
+}
+
+async function initializeAnalytics(bus) {
+  try {
+    await bus.publish("analytics:init", { timestamp: Date.now() });
+  } catch (e) {
+  }
+}
+
+async function loadUserPreferences(userId, bus) {
+  try {
+    const prefs = await fetch(`/api/users/${userId}/preferences`).then((r) =>
+      r.json()
+    );
+    await bus.publish("preferences:loaded", prefs);
+  } catch (err) {
+  }
+}
+
+const bus = new EventBus();
+export { bus, EventBus, initializeAnalytics, loadUserPreferences };
diff --git a/priv/combined_metrics/samples/error_handling/does_not_swallow_errors_silently/good/event_bus.js b/priv/combined_metrics/samples/error_handling/does_not_swallow_errors_silently/good/event_bus.js
new file mode 100644
index 0000000..2c13f6a
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_swallow_errors_silently/good/event_bus.js
@@ -0,0 +1,66 @@
+import logger from "./logger.js";
+
+class EventBus {
+  constructor() {
+    this._handlers = new Map();
+    this._deadLetterQueue = [];
+  }
+
+  subscribe(eventName, handler) {
+    if (!this._handlers.has(eventName)) {
+      this._handlers.set(eventName, []);
+    }
+    this._handlers.get(eventName).push(handler);
+  }
+
+  unsubscribe(eventName, handler) {
+    const handlers = this._handlers.get(eventName);
+    if (!handlers) return;
+    const index = handlers.indexOf(handler);
+    if (index !== -1) {
+      handlers.splice(index, 1);
+    }
+  }
+
+  async publish(eventName, payload) {
+    const handlers = this._handlers.get(eventName) ?? [];
+
+    for (const handler of handlers) {
+      try {
+        await handler(payload);
+      } catch (err) {
+        logger.error(
+          `EventBus: handler for '${eventName}' threw an error`,
+          err
+        );
+        this._deadLetterQueue.push({ eventName, payload, error: err, ts: Date.now() });
+      }
+    }
+  }
+
+  async publishOrFail(eventName, payload) {
+    const handlers = this._handlers.get(eventName) ?? [];
+
+    for (const handler of handlers) {
+      await handler(payload);
+    }
+  }
+
+  drainDeadLetterQueue() {
+    const items = [...this._deadLetterQueue];
+    this._deadLetterQueue.length = 0;
+    return items;
+  }
+}
+
+async function initializeAnalytics(bus) {
+  try {
+    await bus.publish("analytics:init", { timestamp: Date.now() });
+  } catch (err) {
+    // Analytics is non-critical; log and continue application startup
+    logger.warn("Analytics initialization failed, proceeding without it", err);
+  }
+}
+
+const bus = new EventBus();
+export { bus, EventBus, initializeAnalytics };
diff --git a/priv/combined_metrics/samples/error_handling/does_not_swallow_exceptions/bad/OrderService.java b/priv/combined_metrics/samples/error_handling/does_not_swallow_exceptions/bad/OrderService.java
new file mode 100644
index 0000000..388899c
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_swallow_exceptions/bad/OrderService.java
@@ -0,0 +1,69 @@
+package com.example.orders;
+
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.logging.Logger;
+
+public class OrderService {
+
+    private static final Logger logger = Logger.getLogger(OrderService.class.getName());
+
+    private final OrderRepository repository;
+    private final PaymentGateway paymentGateway;
+
+    public OrderService(OrderRepository repository, PaymentGateway paymentGateway) {
+        this.repository = repository;
+        this.paymentGateway = paymentGateway;
+    }
+
+    public Order placeOrder(Cart cart, PaymentDetails payment) {
+        Order order = Order.from(cart);
+
+        try {
+            paymentGateway.charge(payment, order.totalAmount());
+        } catch (PaymentDeclinedException e) {
+            // silently swallowed — caller will never know the charge failed
+        } catch (IOException e) {
+            // silently swallowed — network errors are completely hidden
+        }
+
+        try {
+            repository.save(order);
+        } catch (SQLException e) {
+            // silently swallowed — order may not have been saved at all
+        }
+
+        return order;
+    }
+
+    public void cancelOrder(String orderId) {
+        Order order = null;
+        try {
+            order = repository.findById(orderId);
+        } catch (SQLException e) {
+            // silently swallowed — order is null but execution continues
+        }
+
+        if (order == null) {
+            return;
+        }
+
+        order.cancel();
+
+        try {
+            repository.update(order);
+        } catch (SQLException e) {
+            // silently swallowed — cancellation may not have been persisted
+        }
+    }
+
+    public double getOrderTotal(String orderId) {
+        try {
+            Order order = repository.findById(orderId);
+            return order.totalAmount();
+        } catch (Exception e) {
+            // catch-all swallowed; returns 0 as if the order doesn't exist
+            return 0.0;
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_swallow_exceptions/good/OrderService.java b/priv/combined_metrics/samples/error_handling/does_not_swallow_exceptions/good/OrderService.java
new file mode 100644
index 0000000..2a9655c
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_swallow_exceptions/good/OrderService.java
@@ -0,0 +1,73 @@
+package com.example.orders;
+
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class OrderService {
+
+    private static final Logger logger = Logger.getLogger(OrderService.class.getName());
+
+    private final OrderRepository repository;
+    private final PaymentGateway paymentGateway;
+
+    public OrderService(OrderRepository repository, PaymentGateway paymentGateway) {
+        this.repository = repository;
+        this.paymentGateway = paymentGateway;
+    }
+
+    public Order placeOrder(Cart cart, PaymentDetails payment) {
+        Order order = Order.from(cart);
+
+        try {
+            paymentGateway.charge(payment, order.totalAmount());
+        } catch (PaymentDeclinedException e) {
+            // Payment was declined by the gateway; surface this to the caller
+            // so they can prompt the user to retry with different details.
+            throw new OrderPlacementException("Payment declined: " + e.getReason(), e);
+        } catch (IOException e) {
+            // Network error communicating with the payment gateway.
+            // Log at ERROR level and rethrow so the caller can handle retries.
+            logger.log(Level.SEVERE, "Network failure while charging payment for order", e);
+            throw new OrderPlacementException("Payment gateway unreachable", e);
+        }
+
+        try {
+            repository.save(order);
+        } catch (SQLException e) {
+            // Database write failed after successful payment — log with order
+            // context so support can reconcile the charge manually.
+            logger.log(Level.SEVERE, "Failed to persist order after successful payment: orderId=" + order.getId(), e);
+            throw new OrderPlacementException("Order could not be saved", e);
+        }
+
+        return order;
+    }
+
+    public void cancelOrder(String orderId) {
+        Order order;
+        try {
+            order = repository.findById(orderId);
+        } catch (SQLException e) {
+            // Could not load order from the database; rethrow with context.
+            logger.log(Level.WARNING, "Database error looking up order: " + orderId, e);
+            throw new OrderServiceException("Unable to retrieve order " + orderId, e);
+        }
+
+        if (order == null) {
+            throw new OrderNotFoundException(orderId);
+        }
+
+        order.cancel();
+
+        try {
+            repository.update(order);
+        } catch (SQLException e) {
+            // Persisting the cancellation status failed; rethrow so the caller
+            // knows the cancellation did not complete successfully.
+            logger.log(Level.SEVERE, "Failed to persist cancellation for orderId=" + orderId, e);
+            throw new OrderServiceException("Cancellation could not be saved", e);
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_throw_from_finally_block/bad/FileProcessor.cs b/priv/combined_metrics/samples/error_handling/does_not_throw_from_finally_block/bad/FileProcessor.cs
new file mode 100644
index 0000000..473b49a
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_throw_from_finally_block/bad/FileProcessor.cs
@@ -0,0 +1,81 @@
+using System;
+using System.IO;
+
+namespace FileProcessing
+{
+    public class FileProcessor
+    {
+        private readonly ILogger _logger;
+
+        public FileProcessor(ILogger logger)
+        {
+            _logger = logger;
+        }
+
+        public string ReadAndProcess(string filePath)
+        {
+            StreamReader reader = null;
+            try
+            {
+                reader = new StreamReader(filePath);
+                var content = reader.ReadToEnd();
+                return Transform(content);
+            }
+            catch (FileNotFoundException ex)
+            {
+                _logger.Error("Input file not found", ex);
+                throw;
+            }
+            finally
+            {
+                reader?.Close();
+                // Throws from finally — suppresses the FileNotFoundException above
+                if (!File.Exists(filePath + ".processed"))
+                    throw new InvalidOperationException("Processed marker missing.");
+            }
+        }
+
+        public void ProcessBatch(string[] filePaths)
+        {
+            FileStream lockFile = null;
+            try
+            {
+                lockFile = AcquireLock();
+                foreach (var path in filePaths)
+                {
+                    ProcessSingleFile(path);
+                }
+            }
+            finally
+            {
+                lockFile?.Close();
+
+                // Validating state inside finally and throwing — bad practice.
+                // Any exception thrown during batch processing is now lost.
+                var pendingCount = CountPending(filePaths);
+                if (pendingCount > 0)
+                    throw new InvalidOperationException(
+                        $"{pendingCount} files were not processed.");
+            }
+        }
+
+        private string Transform(string content) => content.Trim().ToUpperInvariant();
+
+        private void ProcessSingleFile(string path)
+        {
+            var content = File.ReadAllText(path);
+            File.WriteAllText(path + ".out", Transform(content));
+        }
+
+        private int CountPending(string[] filePaths)
+        {
+            int count = 0;
+            foreach (var p in filePaths)
+                if (!File.Exists(p + ".out")) count++;
+            return count;
+        }
+
+        private FileStream AcquireLock() =>
+            new FileStream("/tmp/processor.lock", FileMode.Create, FileAccess.Write);
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_throw_from_finally_block/good/FileProcessor.cs b/priv/combined_metrics/samples/error_handling/does_not_throw_from_finally_block/good/FileProcessor.cs
new file mode 100644
index 0000000..dc5510b
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_throw_from_finally_block/good/FileProcessor.cs
@@ -0,0 +1,84 @@
+using System;
+using System.IO;
+
+namespace FileProcessing
+{
+    public class FileProcessor
+    {
+        private readonly ILogger _logger;
+
+        public FileProcessor(ILogger logger)
+        {
+            _logger = logger;
+        }
+
+        public string ReadAndProcess(string filePath)
+        {
+            StreamReader reader = null;
+            try
+            {
+                reader = new StreamReader(filePath);
+                var content = reader.ReadToEnd();
+                return Transform(content);
+            }
+            catch (FileNotFoundException ex)
+            {
+                _logger.Error("Input file not found: {path}", ex);
+                throw;
+            }
+            finally
+            {
+                // Finally only performs cleanup — never throws
+                try
+                {
+                    reader?.Close();
+                }
+                catch (IOException ex)
+                {
+                    // Log but do not rethrow; we must not suppress the original exception
+                    _logger.Warning("Failed to close reader cleanly", ex);
+                }
+            }
+        }
+
+        public void ProcessBatch(string[] filePaths)
+        {
+            FileStream lockFile = null;
+            try
+            {
+                lockFile = AcquireLock();
+                foreach (var path in filePaths)
+                {
+                    ProcessSingleFile(path);
+                }
+            }
+            finally
+            {
+                // Cleanup only — releasing the lock must not throw out of finally
+                if (lockFile != null)
+                {
+                    try
+                    {
+                        lockFile.Close();
+                        File.Delete(lockFile.Name);
+                    }
+                    catch (IOException ex)
+                    {
+                        _logger.Warning("Lock file cleanup failed", ex);
+                    }
+                }
+            }
+        }
+
+        private string Transform(string content) => content.Trim().ToUpperInvariant();
+
+        private void ProcessSingleFile(string path)
+        {
+            var content = File.ReadAllText(path);
+            File.WriteAllText(path + ".out", Transform(content));
+        }
+
+        private FileStream AcquireLock() =>
+            new FileStream("/tmp/processor.lock", FileMode.Create, FileAccess.Write);
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_use_exceptions_for_control_flow/bad/ProductCatalog.cs b/priv/combined_metrics/samples/error_handling/does_not_use_exceptions_for_control_flow/bad/ProductCatalog.cs
new file mode 100644
index 0000000..90547ea
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_use_exceptions_for_control_flow/bad/ProductCatalog.cs
@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+
+namespace Catalog
+{
+    public class ProductCatalog
+    {
+        private readonly Dictionary<string, Product> _products = new();
+
+        // Using exception to detect "not found" as normal control flow
+        public Product GetProduct(string sku)
+        {
+            try
+            {
+                return _products[sku]; // throws KeyNotFoundException for missing keys
+            }
+            catch (KeyNotFoundException)
+            {
+                return null;
+            }
+        }
+
+        // Using FormatException to drive parsing logic
+        public int ParseQuantity(string input)
+        {
+            try
+            {
+                return int.Parse(input);
+            }
+            catch (FormatException)
+            {
+                return 0;
+            }
+            catch (OverflowException)
+            {
+                return 0;
+            }
+        }
+
+        // Using exception to check discount applicability
+        public decimal ApplyDiscount(string couponCode, decimal originalPrice)
+        {
+            try
+            {
+                decimal rate = _discountMap[couponCode]; // throws if not found
+                return originalPrice * (1 - rate);
+            }
+            catch (KeyNotFoundException)
+            {
+                return originalPrice; // no discount — but this is expected, not exceptional
+            }
+        }
+
+        public decimal CalculateTotalPrice(string sku, string quantityInput, string couponCode)
+        {
+            var product = GetProduct(sku);
+            if (product == null) return 0m;
+
+            int quantity = ParseQuantity(quantityInput);
+            if (quantity <= 0) return 0m;
+
+            decimal lineTotal = product.UnitPrice * quantity;
+            return ApplyDiscount(couponCode, lineTotal);
+        }
+
+        public IReadOnlyList<Product> SearchByCategory(string category)
+        {
+            var results = new List<Product>();
+            try
+            {
+                foreach (var product in _products.Values)
+                {
+                    // Throwing to break from nested search — very bad pattern
+                    if (results.Count >= 50)
+                        throw new InvalidOperationException("limit reached");
+
+                    if (product.Category.Equals(category, StringComparison.OrdinalIgnoreCase))
+                        results.Add(product);
+                }
+            }
+            catch (InvalidOperationException)
+            {
+                // silently stop — exception used as a loop break
+            }
+            return results.AsReadOnly();
+        }
+
+        private readonly Dictionary<string, decimal> _discountMap = new()
+        {
+            ["SAVE10"] = 0.10m,
+            ["SAVE20"] = 0.20m,
+        };
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_use_exceptions_for_control_flow/good/ProductCatalog.cs b/priv/combined_metrics/samples/error_handling/does_not_use_exceptions_for_control_flow/good/ProductCatalog.cs
new file mode 100644
index 0000000..4c79b6b
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_use_exceptions_for_control_flow/good/ProductCatalog.cs
@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+
+namespace Catalog
+{
+    public class ProductCatalog
+    {
+        private readonly Dictionary<string, Product> _products = new();
+
+        public bool TryGetProduct(string sku, out Product product)
+        {
+            return _products.TryGetValue(sku, out product);
+        }
+
+        public bool TryParseQuantity(string input, out int quantity)
+        {
+            return int.TryParse(input, out quantity) && quantity > 0;
+        }
+
+        public bool TryApplyDiscount(string couponCode, decimal originalPrice, out decimal discountedPrice)
+        {
+            discountedPrice = originalPrice;
+
+            if (string.IsNullOrWhiteSpace(couponCode))
+                return false;
+
+            if (!_discountMap.TryGetValue(couponCode, out decimal rate))
+                return false;
+
+            discountedPrice = originalPrice * (1 - rate);
+            return true;
+        }
+
+        public decimal CalculateTotalPrice(string sku, string quantityInput, string couponCode)
+        {
+            if (!TryGetProduct(sku, out var product))
+                return 0m;
+
+            if (!TryParseQuantity(quantityInput, out int quantity))
+                return 0m;
+
+            decimal lineTotal = product.UnitPrice * quantity;
+
+            if (TryApplyDiscount(couponCode, lineTotal, out decimal discounted))
+                return discounted;
+
+            return lineTotal;
+        }
+
+        public IReadOnlyList<Product> SearchByCategory(string category)
+        {
+            var results = new List<Product>();
+            foreach (var product in _products.Values)
+            {
+                if (product.Category.Equals(category, StringComparison.OrdinalIgnoreCase))
+                    results.Add(product);
+            }
+            return results.AsReadOnly();
+        }
+
+        private readonly Dictionary<string, decimal> _discountMap = new()
+        {
+            ["SAVE10"] = 0.10m,
+            ["SAVE20"] = 0.20m,
+        };
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_use_force_try/bad/DataLoader.swift b/priv/combined_metrics/samples/error_handling/does_not_use_force_try/bad/DataLoader.swift
new file mode 100644
index 0000000..9e973ac
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_use_force_try/bad/DataLoader.swift
@@ -0,0 +1,49 @@
+import Foundation
+
+enum DataLoaderError: Error {
+    case fileNotFound(String)
+    case decodingFailed(Error)
+}
+
+struct UserPreferences: Codable {
+    var theme: String
+    var notificationsEnabled: Bool
+    var language: String
+}
+
+class DataLoader {
+    private let fileManager: FileManager
+    private let documentsURL: URL
+
+    init(fileManager: FileManager = .default) {
+        self.fileManager = fileManager
+        self.documentsURL = fileManager.urls(for: .documentDirectory, in: .userDomainMask)[0]
+    }
+
+    func loadPreferences(from filename: String) -> UserPreferences {
+        let fileURL = documentsURL.appendingPathComponent(filename)
+
+        // try! crashes the app if the file is missing or malformed
+        let data = try! Data(contentsOf: fileURL)
+        return try! JSONDecoder().decode(UserPreferences.self, from: data)
+    }
+
+    func savePreferences(_ preferences: UserPreferences, to filename: String) {
+        let fileURL = documentsURL.appendingPathComponent(filename)
+
+        // try! crashes if encoding or writing fails
+        let data = try! JSONEncoder().encode(preferences)
+        try! data.write(to: fileURL, options: .atomic)
+    }
+
+    func loadJSON<T: Decodable>(from url: URL, as type: T.Type) -> T {
+        // try! on remote or file URL will crash for any network/IO error
+        let data = try! Data(contentsOf: url)
+        return try! JSONDecoder().decode(type, from: data)
+    }
+
+    func parseRegex(pattern: String) -> NSRegularExpression {
+        // try! will crash for invalid regex patterns
+        return try! NSRegularExpression(pattern: pattern, options: [])
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_use_force_try/good/DataLoader.swift b/priv/combined_metrics/samples/error_handling/does_not_use_force_try/good/DataLoader.swift
new file mode 100644
index 0000000..d7da4fc
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_use_force_try/good/DataLoader.swift
@@ -0,0 +1,60 @@
+import Foundation
+
+enum DataLoaderError: Error {
+    case fileNotFound(String)
+    case decodingFailed(Error)
+    case encodingFailed(Error)
+}
+
+struct UserPreferences: Codable {
+    var theme: String
+    var notificationsEnabled: Bool
+    var language: String
+}
+
+class DataLoader {
+    private let fileManager: FileManager
+    private let documentsURL: URL
+
+    init(fileManager: FileManager = .default) {
+        self.fileManager = fileManager
+        self.documentsURL = fileManager.urls(for: .documentDirectory, in: .userDomainMask)[0]
+    }
+
+    func loadPreferences(from filename: String) -> Result<UserPreferences, DataLoaderError> {
+        let fileURL = documentsURL.appendingPathComponent(filename)
+
+        guard fileManager.fileExists(atPath: fileURL.path) else {
+            return .failure(.fileNotFound(filename))
+        }
+
+        do {
+            let data = try Data(contentsOf: fileURL)
+            let preferences = try JSONDecoder().decode(UserPreferences.self, from: data)
+            return .success(preferences)
+        } catch let error as DecodingError {
+            return .failure(.decodingFailed(error))
+        } catch {
+            return .failure(.decodingFailed(error))
+        }
+    }
+
+    func savePreferences(_ preferences: UserPreferences, to filename: String) throws {
+        let fileURL = documentsURL.appendingPathComponent(filename)
+        do {
+            let data = try JSONEncoder().encode(preferences)
+            try data.write(to: fileURL, options: .atomic)
+        } catch {
+            throw DataLoaderError.encodingFailed(error)
+        }
+    }
+
+    func loadJSON<T: Decodable>(from url: URL, as type: T.Type) throws -> T {
+        do {
+            let data = try Data(contentsOf: url)
+            return try JSONDecoder().decode(type, from: data)
+        } catch {
+            throw DataLoaderError.decodingFailed(error)
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_use_inband_error_values/bad/store.go b/priv/combined_metrics/samples/error_handling/does_not_use_inband_error_values/bad/store.go
new file mode 100644
index 0000000..807d8ef
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_use_inband_error_values/bad/store.go
@@ -0,0 +1,53 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+)
+
+type User struct {
+	ID    int64
+	Name  string
+	Email string
+}
+
+type UserStore struct {
+	db *sql.DB
+}
+
+func NewUserStore(db *sql.DB) *UserStore {
+	return &UserStore{db: db}
+}
+
+// FindByEmail returns the user's name or empty string if not found.
+// Callers must check for empty string to detect failure.
+func (s *UserStore) FindByEmail(ctx context.Context, email string) string {
+	row := s.db.QueryRowContext(ctx,
+		`SELECT name FROM users WHERE email = $1`, email)
+
+	var name string
+	if err := row.Scan(&name); err != nil {
+		// returns sentinel "" to signal failure — callers can't distinguish
+		// "not found" from a real DB error
+		return ""
+	}
+	return name
+}
+
+// FindByID returns the user ID or -1 if not found.
+// Callers must check for -1 to detect failure.
+func (s *UserStore) FindByID(ctx context.Context, id int64) int64 {
+	row := s.db.QueryRowContext(ctx,
+		`SELECT id FROM users WHERE id = $1`, id)
+
+	var found int64
+	if err := row.Scan(&found); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			// returns sentinel -1 to signal "not found"
+			return -1
+		}
+		return -1
+	}
+	return found
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_use_inband_error_values/good/store.go b/priv/combined_metrics/samples/error_handling/does_not_use_inband_error_values/good/store.go
new file mode 100644
index 0000000..eaa1e8a
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_use_inband_error_values/good/store.go
@@ -0,0 +1,56 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+)
+
+var ErrNotFound = errors.New("record not found")
+
+type User struct {
+	ID    int64
+	Name  string
+	Email string
+}
+
+type UserStore struct {
+	db *sql.DB
+}
+
+func NewUserStore(db *sql.DB) *UserStore {
+	return &UserStore{db: db}
+}
+
+// FindByEmail returns the user with the given email address.
+// Returns ErrNotFound if no such user exists.
+func (s *UserStore) FindByEmail(ctx context.Context, email string) (*User, error) {
+	row := s.db.QueryRowContext(ctx,
+		`SELECT id, name, email FROM users WHERE email = $1`, email)
+
+	var u User
+	if err := row.Scan(&u.ID, &u.Name, &u.Email); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, ErrNotFound
+		}
+		return nil, fmt.Errorf("find user by email %q: %w", email, err)
+	}
+	return &u, nil
+}
+
+// FindByID returns the user with the given ID.
+// Returns ErrNotFound if no such user exists.
+func (s *UserStore) FindByID(ctx context.Context, id int64) (*User, error) {
+	row := s.db.QueryRowContext(ctx,
+		`SELECT id, name, email FROM users WHERE id = $1`, id)
+
+	var u User
+	if err := row.Scan(&u.ID, &u.Name, &u.Email); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, ErrNotFound
+		}
+		return nil, fmt.Errorf("find user by id %d: %w", id, err)
+	}
+	return &u, nil
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_use_unwrap_in_production/bad/client.rs b/priv/combined_metrics/samples/error_handling/does_not_use_unwrap_in_production/bad/client.rs
new file mode 100644
index 0000000..f8747ae
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_use_unwrap_in_production/bad/client.rs
@@ -0,0 +1,48 @@
+use std::collections::HashMap;
+use std::time::Duration;
+
+pub struct HttpClient {
+    base_url: String,
+    timeout: Duration,
+    headers: HashMap<String, String>,
+}
+
+impl HttpClient {
+    pub fn new(base_url: &str, timeout_secs: u64) -> Self {
+        // unwrap() in constructor: if base_url is empty this is confusing to debug
+        let parsed = base_url.strip_prefix("https://").unwrap();
+        let _ = parsed; // not used, just demonstrating the unwrap
+
+        Self {
+            base_url: base_url.to_string(),
+            timeout: Duration::from_secs(timeout_secs),
+            headers: HashMap::new(),
+        }
+    }
+
+    pub fn set_auth_token(&mut self, token: Option<&str>) {
+        // unwrap() here panics if caller passes None — no graceful handling
+        let tok = token.unwrap();
+        self.headers.insert("Authorization".to_string(), format!("Bearer {tok}"));
+    }
+
+    pub fn get(&self, path: &str) -> String {
+        let url = format!("{}{}", self.base_url, path);
+        let response = self.execute(&url);
+        // unwrap() on production path — any error panics the whole process
+        response.unwrap()
+    }
+
+    fn execute(&self, url: &str) -> Result<String, String> {
+        if url.contains("unreachable") {
+            return Err(format!("cannot connect to {url}"));
+        }
+        Ok(format!("OK from {url}"))
+    }
+}
+
+pub fn fetch_user_profile(client: &HttpClient, user_id: u64) -> String {
+    let path = format!("/users/{user_id}");
+    // Returns a String — caller has no way to handle errors
+    client.get(&path)
+}
diff --git a/priv/combined_metrics/samples/error_handling/does_not_use_unwrap_in_production/good/client.rs b/priv/combined_metrics/samples/error_handling/does_not_use_unwrap_in_production/good/client.rs
new file mode 100644
index 0000000..6605d25
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/does_not_use_unwrap_in_production/good/client.rs
@@ -0,0 +1,64 @@
+use std::time::Duration;
+
+#[derive(Debug)]
+pub enum ClientError {
+    InvalidUrl(String),
+    ConnectionFailed(String),
+    Timeout,
+    BadResponse { status: u16, body: String },
+}
+
+impl std::fmt::Display for ClientError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ClientError::InvalidUrl(u) => write!(f, "invalid URL: {u}"),
+            ClientError::ConnectionFailed(msg) => write!(f, "connection failed: {msg}"),
+            ClientError::Timeout => write!(f, "request timed out"),
+            ClientError::BadResponse { status, body } => {
+                write!(f, "unexpected status {status}: {body}")
+            }
+        }
+    }
+}
+
+pub struct HttpClient {
+    base_url: String,
+    timeout: Duration,
+}
+
+impl HttpClient {
+    pub fn new(base_url: impl Into<String>, timeout_secs: u64) -> Result<Self, ClientError> {
+        let base_url = base_url.into();
+        if !base_url.starts_with("http://") && !base_url.starts_with("https://") {
+            return Err(ClientError::InvalidUrl(base_url));
+        }
+        Ok(Self {
+            base_url,
+            timeout: Duration::from_secs(timeout_secs),
+        })
+    }
+
+    pub fn get(&self, path: &str) -> Result<String, ClientError> {
+        let url = format!("{}{}", self.base_url, path);
+        // Simulated HTTP call — real impl would use reqwest or hyper
+        self.execute_request(&url)
+    }
+
+    fn execute_request(&self, url: &str) -> Result<String, ClientError> {
+        if url.contains("unreachable") {
+            return Err(ClientError::ConnectionFailed(format!(
+                "host not reachable for {url}"
+            )));
+        }
+        if self.timeout < Duration::from_millis(1) {
+            return Err(ClientError::Timeout);
+        }
+        Ok(format!("200 OK from {url}"))
+    }
+}
+
+pub fn fetch_user_profile(client: &HttpClient, user_id: u64) -> Result<String, ClientError> {
+    let path = format!("/users/{user_id}/profile");
+    let body = client.get(&path)?;
+    Ok(body)
+}
diff --git a/priv/combined_metrics/samples/error_handling/error_message_is_descriptive/bad/billing.ex b/priv/combined_metrics/samples/error_handling/error_message_is_descriptive/bad/billing.ex
new file mode 100644
index 0000000..351c5de
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/error_message_is_descriptive/bad/billing.ex
@@ -0,0 +1,83 @@
+defmodule Billing do
+  @moduledoc """
+  Handles billing and invoice generation.
+  """
+
+  def create_invoice(user_id, items) do
+    case fetch_user(user_id) do
+      nil -> {:error, :error}
+      user -> build_invoice(user, items)
+    end
+  end
+
+  def charge_customer(customer_id, amount) do
+    if amount <= 0 do
+      raise "error"
+    end
+
+    case find_payment_method(customer_id) do
+      nil -> {:error, ""}
+      method -> process_charge(method, amount)
+    end
+  end
+
+  def apply_discount(invoice, code) do
+    case lookup_discount_code(code) do
+      nil -> {:error, :not_found}
+      discount ->
+        if discount.expired do
+          {:error, :expired}
+        else
+          {:ok, apply(invoice, discount)}
+        end
+    end
+  end
+
+  def issue_refund(invoice_id, amount) do
+    case get_invoice(invoice_id) do
+      nil ->
+        {:error, :error}
+      invoice ->
+        if amount > invoice.total do
+          raise "bad amount"
+        else
+          process_refund(invoice, amount)
+        end
+    end
+  end
+
+  def update_billing_address(customer_id, address) do
+    if address == nil or address == "" do
+      {:error, ""}
+    else
+      case find_customer(customer_id) do
+        nil -> {:error, :error}
+        customer -> save_address(customer, address)
+      end
+    end
+  end
+
+  def send_invoice(invoice_id, email) do
+    case get_invoice(invoice_id) do
+      nil -> {:error, :missing}
+      invoice ->
+        case validate_email(email) do
+          false -> {:error, :bad}
+          true -> dispatch_email(invoice, email)
+        end
+    end
+  end
+
+  defp fetch_user(_id), do: nil
+  defp find_payment_method(_id), do: nil
+  defp process_charge(_method, _amount), do: {:ok, %{}}
+  defp lookup_discount_code(_code), do: nil
+  defp apply(_invoice, _discount), do: %{}
+  defp get_invoice(_id), do: nil
+  defp process_refund(_invoice, _amount), do: {:ok, %{}}
+  defp find_customer(_id), do: nil
+  defp save_address(_customer, _address), do: {:ok, %{}}
+  defp validate_email(_email), do: true
+  defp dispatch_email(_invoice, _email), do: :ok
+  defp build_invoice(_user, _items), do: {:ok, %{}}
+end
diff --git a/priv/combined_metrics/samples/error_handling/error_message_is_descriptive/config.yml b/priv/combined_metrics/samples/error_handling/error_message_is_descriptive/config.yml
new file mode 100644
index 0000000..6a3115e
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/error_message_is_descriptive/config.yml
@@ -0,0 +1 @@
+doc: "Error values should carry a meaningful message, not just a bare atom or empty string."
diff --git a/priv/combined_metrics/samples/error_handling/error_message_is_descriptive/good/billing.ex b/priv/combined_metrics/samples/error_handling/error_message_is_descriptive/good/billing.ex
new file mode 100644
index 0000000..270a35b
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/error_message_is_descriptive/good/billing.ex
@@ -0,0 +1,93 @@
+defmodule Billing do
+  @moduledoc """
+  Handles billing and invoice generation.
+  """
+
+  def create_invoice(user_id, items) do
+    case fetch_user(user_id) do
+      nil ->
+        {:error, "User #{user_id} not found, cannot create invoice"}
+      user ->
+        build_invoice(user, items)
+    end
+  end
+
+  def charge_customer(customer_id, amount) do
+    if amount <= 0 do
+      raise ArgumentError, "Charge amount must be positive, got: #{amount}"
+    end
+
+    case find_payment_method(customer_id) do
+      nil ->
+        {:error, "No payment method on file for customer #{customer_id}"}
+      method ->
+        process_charge(method, amount)
+    end
+  end
+
+  def apply_discount(invoice, code) do
+    case lookup_discount_code(code) do
+      nil ->
+        {:error, "Discount code #{inspect(code)} does not exist"}
+      %{expired: true, expires_at: expires_at} ->
+        {:error, "Discount code #{inspect(code)} expired on #{expires_at}"}
+      discount ->
+        {:ok, apply_to_invoice(invoice, discount)}
+    end
+  end
+
+  def issue_refund(invoice_id, amount) do
+    case get_invoice(invoice_id) do
+      nil ->
+        {:error, "Invoice #{invoice_id} not found, cannot issue refund"}
+      invoice ->
+        if amount > invoice.total do
+          raise ArgumentError,
+            "Refund amount #{amount} exceeds invoice total #{invoice.total} for invoice #{invoice_id}"
+        else
+          process_refund(invoice, amount)
+        end
+    end
+  end
+
+  def update_billing_address(customer_id, address) do
+    cond do
+      is_nil(address) ->
+        {:error, "Billing address for customer #{customer_id} cannot be nil"}
+      address == "" ->
+        {:error, "Billing address for customer #{customer_id} cannot be empty"}
+      true ->
+        case find_customer(customer_id) do
+          nil -> {:error, "Customer #{customer_id} not found"}
+          customer -> save_address(customer, address)
+        end
+    end
+  end
+
+  def send_invoice(invoice_id, email) do
+    case get_invoice(invoice_id) do
+      nil ->
+        {:error, "Invoice #{invoice_id} not found, cannot send"}
+      invoice ->
+        case validate_email(email) do
+          false ->
+            {:error, "Cannot send invoice #{invoice_id}: #{inspect(email)} is not a valid email"}
+          true ->
+            dispatch_email(invoice, email)
+        end
+    end
+  end
+
+  defp fetch_user(_id), do: nil
+  defp find_payment_method(_id), do: nil
+  defp process_charge(_method, _amount), do: {:ok, %{}}
+  defp lookup_discount_code(_code), do: nil
+  defp apply_to_invoice(_invoice, _discount), do: %{}
+  defp get_invoice(_id), do: nil
+  defp process_refund(_invoice, _amount), do: {:ok, %{}}
+  defp find_customer(_id), do: nil
+  defp save_address(_customer, _address), do: {:ok, %{}}
+  defp validate_email(_email), do: true
+  defp dispatch_email(_invoice, _email), do: :ok
+  defp build_invoice(_user, _items), do: {:ok, %{}}
+end
diff --git a/priv/combined_metrics/samples/error_handling/error_string_not_capitalized/bad/service.go b/priv/combined_metrics/samples/error_handling/error_string_not_capitalized/bad/service.go
new file mode 100644
index 0000000..57413c6
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/error_string_not_capitalized/bad/service.go
@@ -0,0 +1,54 @@
+package service
+
+import (
+	"errors"
+	"fmt"
+)
+
+type Product struct {
+	ID    string
+	Stock int
+	Price float64
+}
+
+type Inventory interface {
+	Get(id string) (*Product, error)
+	Decrement(id string, qty int) error
+}
+
+type CartService struct {
+	inventory Inventory
+}
+
+func NewCartService(inv Inventory) *CartService {
+	return &CartService{inventory: inv}
+}
+
+var (
+	// Error strings are capitalized and end with punctuation — bad practice.
+	ErrProductNotFound   = errors.New("Product not found.")
+	ErrInsufficientStock = errors.New("Insufficient stock.")
+)
+
+func (s *CartService) AddToCart(productID string, qty int) error {
+	if qty <= 0 {
+		// Capitalized and ends with period — will look odd when embedded in larger messages.
+		return fmt.Errorf("Quantity must be positive, got %d.", qty)
+	}
+
+	product, err := s.inventory.Get(productID)
+	if err != nil {
+		// Capitalized start and trailing period break embedding.
+		return fmt.Errorf("Failed to get product %q: %w.", productID, err)
+	}
+
+	if product.Stock < qty {
+		return fmt.Errorf("Not enough stock for product %q. Has %d, requested %d.",
+			productID, product.Stock, qty)
+	}
+
+	if err := s.inventory.Decrement(productID, qty); err != nil {
+		return fmt.Errorf("Could not decrement stock for %q: %w.", productID, err)
+	}
+	return nil
+}
diff --git a/priv/combined_metrics/samples/error_handling/error_string_not_capitalized/good/service.go b/priv/combined_metrics/samples/error_handling/error_string_not_capitalized/good/service.go
new file mode 100644
index 0000000..5c2c49f
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/error_string_not_capitalized/good/service.go
@@ -0,0 +1,51 @@
+package service
+
+import (
+	"errors"
+	"fmt"
+)
+
+type Product struct {
+	ID    string
+	Stock int
+	Price float64
+}
+
+type Inventory interface {
+	Get(id string) (*Product, error)
+	Decrement(id string, qty int) error
+}
+
+type CartService struct {
+	inventory Inventory
+}
+
+func NewCartService(inv Inventory) *CartService {
+	return &CartService{inventory: inv}
+}
+
+var (
+	ErrProductNotFound  = errors.New("product not found")
+	ErrInsufficientStock = errors.New("insufficient stock")
+)
+
+func (s *CartService) AddToCart(productID string, qty int) error {
+	if qty <= 0 {
+		return fmt.Errorf("quantity must be positive, got %d", qty)
+	}
+
+	product, err := s.inventory.Get(productID)
+	if err != nil {
+		return fmt.Errorf("add to cart: get product %q: %w", productID, err)
+	}
+
+	if product.Stock < qty {
+		return fmt.Errorf("add to cart: product %q has %d in stock, requested %d: %w",
+			productID, product.Stock, qty, ErrInsufficientStock)
+	}
+
+	if err := s.inventory.Decrement(productID, qty); err != nil {
+		return fmt.Errorf("add to cart: decrement stock for %q: %w", productID, err)
+	}
+	return nil
+}
diff --git a/priv/combined_metrics/samples/error_handling/error_type_includes_context/bad/client.go b/priv/combined_metrics/samples/error_handling/error_type_includes_context/bad/client.go
new file mode 100644
index 0000000..a4c354d
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/error_type_includes_context/bad/client.go
@@ -0,0 +1,47 @@
+package client
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+)
+
+// APIError carries no useful context about what failed or where.
+type APIError struct {
+	Message string
+}
+
+func (e *APIError) Error() string {
+	return e.Message
+}
+
+type PaymentClient struct {
+	base   string
+	client *http.Client
+}
+
+func NewPaymentClient(base string) *PaymentClient {
+	return &PaymentClient{base: base, client: &http.Client{}}
+}
+
+func (c *PaymentClient) Charge(orderID string, amountCents int) error {
+	url := fmt.Sprintf("%s/orders/%s/charge", c.base, orderID)
+	req, err := http.NewRequest(http.MethodPost, url, nil)
+	if err != nil {
+		// wraps nothing; caller cannot recover the original error or know the URL
+		return &APIError{Message: "request failed"}
+	}
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		// loses the original transport error entirely
+		return errors.New("request failed")
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		// no operation, resource, or status code included
+		return &APIError{Message: "unexpected response"}
+	}
+	return nil
+}
diff --git a/priv/combined_metrics/samples/error_handling/error_type_includes_context/good/client.go b/priv/combined_metrics/samples/error_handling/error_type_includes_context/good/client.go
new file mode 100644
index 0000000..4309e53
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/error_type_includes_context/good/client.go
@@ -0,0 +1,56 @@
+package client
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// APIError captures the HTTP operation, the target resource, the HTTP status
+// code, and the underlying transport error when one occurs.
+type APIError struct {
+	Method   string
+	Resource string
+	Status   int
+	Err      error
+}
+
+func (e *APIError) Error() string {
+	if e.Err != nil {
+		return fmt.Sprintf("%s %s: status %d: %v", e.Method, e.Resource, e.Status, e.Err)
+	}
+	return fmt.Sprintf("%s %s: status %d", e.Method, e.Resource, e.Status)
+}
+
+func (e *APIError) Unwrap() error { return e.Err }
+
+type PaymentClient struct {
+	base   string
+	client *http.Client
+}
+
+func NewPaymentClient(base string) *PaymentClient {
+	return &PaymentClient{base: base, client: &http.Client{}}
+}
+
+func (c *PaymentClient) Charge(orderID string, amountCents int) error {
+	url := fmt.Sprintf("%s/orders/%s/charge", c.base, orderID)
+	req, err := http.NewRequest(http.MethodPost, url, nil)
+	if err != nil {
+		return &APIError{Method: "POST", Resource: url, Err: err}
+	}
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return &APIError{Method: "POST", Resource: url, Err: err}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return &APIError{
+			Method:   "POST",
+			Resource: url,
+			Status:   resp.StatusCode,
+		}
+	}
+	return nil
+}
diff --git a/priv/combined_metrics/samples/error_handling/no_bare_except/bad/api_client.py b/priv/combined_metrics/samples/error_handling/no_bare_except/bad/api_client.py
new file mode 100644
index 0000000..5f4386c
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_bare_except/bad/api_client.py
@@ -0,0 +1,60 @@
+"""HTTP API client with retry logic and structured error handling."""
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass
+from typing import Any, Optional
+from urllib.request import urlopen
+
+
+@dataclass
+class ApiResponse:
+    status_code: int
+    body: dict[str, Any]
+    latency_ms: float
+
+
+def get(url: str, timeout: float = 5.0) -> Optional[ApiResponse]:
+    """Perform a GET request — bare except swallows KeyboardInterrupt and SystemExit."""
+    start = time.monotonic()
+    try:
+        with urlopen(url, timeout=timeout) as resp:
+            raw = resp.read().decode("utf-8")
+            elapsed = (time.monotonic() - start) * 1000
+            return ApiResponse(
+                status_code=resp.status,
+                body=json.loads(raw),
+                latency_ms=round(elapsed, 2),
+            )
+    except:                    # bare except — catches EVERYTHING including Ctrl+C
+        return None
+
+
+def get_with_retry(
+    url: str,
+    retries: int = 3,
+    backoff: float = 1.0,
+    timeout: float = 5.0,
+) -> Optional[ApiResponse]:
+    """Retry a GET — bare except in retry loop makes Ctrl+C impossible to act on."""
+    for attempt in range(1, retries + 1):
+        try:
+            response = get(url, timeout=timeout)
+            if response is not None:
+                return response
+        except:                # bare except — user cannot interrupt a long retry loop
+            pass
+        time.sleep(backoff * attempt)
+    return None
+
+
+def batch_fetch(urls: list[str]) -> list[Optional[ApiResponse]]:
+    """Fetch multiple URLs — each bare except silently discards all error context."""
+    results = []
+    for url in urls:
+        try:
+            results.append(get(url))
+        except:                # can't distinguish network vs programming error
+            results.append(None)
+    return results
diff --git a/priv/combined_metrics/samples/error_handling/no_bare_except/good/api_client.py b/priv/combined_metrics/samples/error_handling/no_bare_except/good/api_client.py
new file mode 100644
index 0000000..87e96ad
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_bare_except/good/api_client.py
@@ -0,0 +1,71 @@
+"""HTTP API client with retry logic and structured error handling."""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Any, Optional
+from urllib.error import HTTPError, URLError
+from urllib.request import urlopen
+import json
+
+
+@dataclass
+class ApiResponse:
+    status_code: int
+    body: dict[str, Any]
+    latency_ms: float
+
+
+class ApiClientError(Exception):
+    """Base error for all API client failures."""
+
+
+class NetworkError(ApiClientError):
+    """Raised when the network is unreachable."""
+
+
+class HttpError(ApiClientError):
+    """Raised when the server returns a 4xx or 5xx response."""
+
+    def __init__(self, status_code: int, message: str) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+
+def get(url: str, timeout: float = 5.0) -> ApiResponse:
+    """Perform a GET request and return a structured response."""
+    start = time.monotonic()
+    try:
+        with urlopen(url, timeout=timeout) as resp:
+            raw = resp.read().decode("utf-8")
+            elapsed = (time.monotonic() - start) * 1000
+            return ApiResponse(
+                status_code=resp.status,
+                body=json.loads(raw),
+                latency_ms=round(elapsed, 2),
+            )
+    except HTTPError as exc:
+        raise HttpError(exc.code, f"Server returned {exc.code} for {url}") from exc
+    except URLError as exc:
+        raise NetworkError(f"Could not reach {url}: {exc.reason}") from exc
+    except json.JSONDecodeError as exc:
+        raise ApiClientError(f"Invalid JSON from {url}") from exc
+
+
+def get_with_retry(
+    url: str,
+    retries: int = 3,
+    backoff: float = 1.0,
+    timeout: float = 5.0,
+) -> Optional[ApiResponse]:
+    """Retry a GET request on network errors only; re-raise HTTP errors immediately."""
+    for attempt in range(1, retries + 1):
+        try:
+            return get(url, timeout=timeout)
+        except NetworkError:
+            if attempt == retries:
+                raise
+            time.sleep(backoff * attempt)
+        except HttpError:
+            raise  # do not retry server-side errors
+    return None
diff --git a/priv/combined_metrics/samples/error_handling/no_blind_rescue/bad/cart.rb b/priv/combined_metrics/samples/error_handling/no_blind_rescue/bad/cart.rb
new file mode 100644
index 0000000..4304d84
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_blind_rescue/bad/cart.rb
@@ -0,0 +1,45 @@
+class CartCheckoutService
+  def initialize(inventory, payment_processor, logger)
+    @inventory = inventory
+    @payment_processor = payment_processor
+    @logger = logger
+  end
+
+  def checkout(cart, payment_details)
+    reserve_items(cart)
+    process_payment(cart, payment_details)
+  end
+
+  private
+
+  def reserve_items(cart)
+    cart.line_items.each do |item|
+      begin
+        @inventory.reserve(item.sku, item.quantity)
+      rescue => e
+        # Bare rescue catches all StandardError — masks the specific cause
+        raise "Reservation failed: #{e.message}"
+      end
+    end
+  end
+
+  def process_payment(cart, payment_details)
+    begin
+      result = @payment_processor.charge(cart.total_cents, payment_details)
+      { success: true, order_id: result.order_id }
+    rescue
+      # Bare rescue with no class — swallows everything silently
+      { success: false, error: :unknown }
+    end
+  end
+
+  def release_reserved_items(cart)
+    cart.line_items.each do |item|
+      begin
+        @inventory.release(item.sku, item.quantity)
+      rescue
+        # Silent swallow — no logging, no re-raise
+      end
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/error_handling/no_blind_rescue/good/cart.rb b/priv/combined_metrics/samples/error_handling/no_blind_rescue/good/cart.rb
new file mode 100644
index 0000000..bcccc52
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_blind_rescue/good/cart.rb
@@ -0,0 +1,53 @@
+class CartCheckoutService
+  def initialize(inventory, payment_processor, logger)
+    @inventory = inventory
+    @payment_processor = payment_processor
+    @logger = logger
+  end
+
+  def checkout(cart, payment_details)
+    reserve_items(cart)
+    process_payment(cart, payment_details)
+  end
+
+  private
+
+  def reserve_items(cart)
+    cart.line_items.each do |item|
+      begin
+        @inventory.reserve(item.sku, item.quantity)
+      rescue Inventory::OutOfStockError => e
+        raise CheckoutError.new(:out_of_stock, "#{item.name} is no longer available: #{e.message}")
+      rescue Inventory::ConnectionError => e
+        @logger.error("Inventory service unreachable: #{e.message}")
+        raise CheckoutError.new(:service_unavailable, "Unable to confirm stock at this time")
+      end
+    end
+  end
+
+  def process_payment(cart, payment_details)
+    begin
+      result = @payment_processor.charge(cart.total_cents, payment_details)
+      { success: true, order_id: result.order_id, receipt_url: result.receipt_url }
+    rescue PaymentProcessor::DeclinedError => e
+      @logger.info("Payment declined for cart #{cart.id}: #{e.decline_code}")
+      { success: false, error: :payment_declined, decline_code: e.decline_code }
+    rescue PaymentProcessor::TimeoutError => e
+      @logger.error("Payment timeout for cart #{cart.id}: #{e.message}")
+      release_reserved_items(cart)
+      { success: false, error: :payment_timeout }
+    rescue PaymentProcessor::Error => e
+      @logger.error("Payment error for cart #{cart.id}: #{e.message}")
+      release_reserved_items(cart)
+      raise
+    end
+  end
+
+  def release_reserved_items(cart)
+    cart.line_items.each do |item|
+      @inventory.release(item.sku, item.quantity)
+    rescue Inventory::Error => e
+      @logger.warn("Failed to release reservation for #{item.sku}: #{e.message}")
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/error_handling/no_empty_rescue_block/bad/payment.rb b/priv/combined_metrics/samples/error_handling/no_empty_rescue_block/bad/payment.rb
new file mode 100644
index 0000000..9f168e8
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_empty_rescue_block/bad/payment.rb
@@ -0,0 +1,42 @@
+class PaymentProcessor
+  def initialize(gateway, logger)
+    @gateway = gateway
+    @logger = logger
+  end
+
+  def charge(order, card_token)
+    amount_cents = (order.total * 100).to_i
+
+    begin
+      response = @gateway.charge(amount_cents, card_token, order_id: order.id)
+      record_transaction(order, response.transaction_id)
+      { success: true, transaction_id: response.transaction_id }
+    rescue PaymentGateway::CardDeclinedError
+      # TODO: handle this
+    rescue PaymentGateway::NetworkError
+    rescue PaymentGateway::InvalidAmountError
+    end
+  end
+
+  def refund(transaction_id, amount_cents)
+    begin
+      response = @gateway.refund(transaction_id, amount_cents)
+      { success: true, refund_id: response.refund_id }
+    rescue PaymentGateway::TransactionNotFoundError
+    rescue PaymentGateway::RefundError
+    end
+  end
+
+  private
+
+  def record_transaction(order, transaction_id)
+    begin
+      order.update!(
+        payment_status: :paid,
+        transaction_id: transaction_id,
+        paid_at: Time.current
+      )
+    rescue
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/error_handling/no_empty_rescue_block/good/payment.rb b/priv/combined_metrics/samples/error_handling/no_empty_rescue_block/good/payment.rb
new file mode 100644
index 0000000..6845c92
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_empty_rescue_block/good/payment.rb
@@ -0,0 +1,49 @@
+class PaymentProcessor
+  def initialize(gateway, logger)
+    @gateway = gateway
+    @logger = logger
+  end
+
+  def charge(order, card_token)
+    amount_cents = (order.total * 100).to_i
+
+    begin
+      response = @gateway.charge(amount_cents, card_token, order_id: order.id)
+      record_transaction(order, response.transaction_id)
+      { success: true, transaction_id: response.transaction_id }
+    rescue PaymentGateway::CardDeclinedError => e
+      @logger.warn("Card declined for order #{order.id}: #{e.message}")
+      { success: false, error: :card_declined, message: e.message }
+    rescue PaymentGateway::NetworkError => e
+      @logger.error("Gateway network error for order #{order.id}: #{e.message}")
+      { success: false, error: :network_error, message: "Payment service unavailable" }
+    rescue PaymentGateway::InvalidAmountError => e
+      @logger.error("Invalid amount #{amount_cents} for order #{order.id}: #{e.message}")
+      raise ArgumentError, "Order total is invalid: #{order.total}"
+    end
+  end
+
+  def refund(transaction_id, amount_cents)
+    begin
+      response = @gateway.refund(transaction_id, amount_cents)
+      @logger.info("Refund issued: #{response.refund_id} for transaction #{transaction_id}")
+      { success: true, refund_id: response.refund_id }
+    rescue PaymentGateway::TransactionNotFoundError => e
+      @logger.error("Refund failed — transaction not found: #{transaction_id} — #{e.message}")
+      { success: false, error: :transaction_not_found }
+    rescue PaymentGateway::RefundError => e
+      @logger.error("Refund failed for transaction #{transaction_id}: #{e.message}")
+      { success: false, error: :refund_failed, message: e.message }
+    end
+  end
+
+  private
+
+  def record_transaction(order, transaction_id)
+    order.update!(
+      payment_status: :paid,
+      transaction_id: transaction_id,
+      paid_at: Time.current
+    )
+  end
+end
diff --git a/priv/combined_metrics/samples/error_handling/no_error_suppression_operator/bad/ProductCatalog.php b/priv/combined_metrics/samples/error_handling/no_error_suppression_operator/bad/ProductCatalog.php
new file mode 100644
index 0000000..da091c1
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_error_suppression_operator/bad/ProductCatalog.php
@@ -0,0 +1,62 @@
+<?php
+
+namespace App\Catalog;
+
+class ProductCatalog
+{
+    public function __construct(
+        private string $storageBasePath
+    ) {
+    }
+
+    public function importFromCsv(string $filePath): array
+    {
+        // @ suppresses any warnings/errors from fopen — failures are invisible
+        $handle = @fopen($filePath, 'r');
+
+        if ($handle === false) {
+            return [];
+        }
+
+        $products = [];
+        // @ suppresses errors if file becomes unreadable mid-read
+        $headers = @fgetcsv($handle);
+
+        while (($row = @fgetcsv($handle)) !== false) {
+            $products[] = array_combine($headers, $row);
+        }
+
+        @fclose($handle);
+
+        return $products;
+    }
+
+    public function saveProductImage(string $sku, string $sourcePath): string
+    {
+        $destination = "{$this->storageBasePath}/{$sku}.jpg";
+
+        // @ suppresses mkdir warnings — no way to know if it actually succeeded
+        @mkdir(dirname($destination), 0755, true);
+
+        // @ suppresses copy errors — destination may not exist but no error is thrown
+        @copy($sourcePath, $destination);
+
+        return $destination;
+    }
+
+    public function deleteImage(string $sku): bool
+    {
+        $path = "{$this->storageBasePath}/{$sku}.jpg";
+
+        // @ suppresses warnings if file doesn't exist — silent success/failure
+        return @unlink($path);
+    }
+
+    public function readConfig(string $iniPath): array
+    {
+        // @ hides parse errors in the ini file
+        $config = @parse_ini_file($iniPath, true);
+
+        return $config ?: [];
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/no_error_suppression_operator/good/ProductCatalog.php b/priv/combined_metrics/samples/error_handling/no_error_suppression_operator/good/ProductCatalog.php
new file mode 100644
index 0000000..95e941d
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_error_suppression_operator/good/ProductCatalog.php
@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Catalog;
+
+use App\Exception\CatalogImportException;
+use App\Exception\ImageProcessingException;
+
+class ProductCatalog
+{
+    public function __construct(
+        private string $storageBasePath,
+        private \Psr\Log\LoggerInterface $logger
+    ) {
+    }
+
+    public function importFromCsv(string $filePath): array
+    {
+        if (!file_exists($filePath)) {
+            throw new CatalogImportException("Import file not found: {$filePath}");
+        }
+
+        if (!is_readable($filePath)) {
+            throw new CatalogImportException("Import file is not readable: {$filePath}");
+        }
+
+        $handle = fopen($filePath, 'r');
+        if ($handle === false) {
+            throw new CatalogImportException("Failed to open import file: {$filePath}");
+        }
+
+        try {
+            return $this->parseRows($handle);
+        } finally {
+            fclose($handle);
+        }
+    }
+
+    public function saveProductImage(string $sku, string $sourcePath): string
+    {
+        $destination = "{$this->storageBasePath}/{$sku}.jpg";
+
+        if (!file_exists($sourcePath)) {
+            throw new ImageProcessingException("Source image not found: {$sourcePath}");
+        }
+
+        $targetDir = dirname($destination);
+        if (!is_dir($targetDir) && !mkdir($targetDir, 0755, true)) {
+            throw new ImageProcessingException("Failed to create directory: {$targetDir}");
+        }
+
+        if (!copy($sourcePath, $destination)) {
+            throw new ImageProcessingException(
+                "Failed to copy image from {$sourcePath} to {$destination}"
+            );
+        }
+
+        return $destination;
+    }
+
+    private function parseRows($handle): array
+    {
+        $products = [];
+        $headers = fgetcsv($handle);
+
+        if ($headers === false) {
+            throw new CatalogImportException("CSV file is empty or unreadable");
+        }
+
+        while (($row = fgetcsv($handle)) !== false) {
+            $products[] = array_combine($headers, $row);
+        }
+
+        return $products;
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/no_eval_or_dynamic_code_execution/bad/template_engine.js b/priv/combined_metrics/samples/error_handling/no_eval_or_dynamic_code_execution/bad/template_engine.js
new file mode 100644
index 0000000..e6ff440
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_eval_or_dynamic_code_execution/bad/template_engine.js
@@ -0,0 +1,48 @@
+function renderTemplate(template, context) {
+  const keys = Object.keys(context);
+  const values = Object.values(context);
+
+  // Using Function constructor to evaluate template expressions
+  const fn = new Function(...keys, `return \`${template}\``);
+  return fn(...values);
+}
+
+function applyFilter(value, filterExpression) {
+  // Evaluate arbitrary filter code supplied by the user
+  return eval(`(function(v) { return ${filterExpression}; })(${JSON.stringify(value)})`);
+}
+
+function buildSortComparator(sortConfig) {
+  // Build a comparator from a user-supplied config string
+  const comparatorCode = `(a, b) => { return ${sortConfig}; }`;
+  return eval(comparatorCode);
+}
+
+function compileValidator(rules) {
+  // Compile validation rules into executable code
+  const body = rules.map((rule) => `if (!(${rule.expression})) return false;`).join("\n");
+  return new Function("value", `${body}\nreturn true;`);
+}
+
+function executePluginHook(pluginCode, eventName, payload) {
+  // Execute plugin hook code loaded from external source
+  const runner = new Function("event", "payload", pluginCode);
+  return runner(eventName, payload);
+}
+
+function renderDynamicField(fieldConfig, record) {
+  // Evaluate field display expression
+  const displayValue = eval(
+    `(function(record) { return ${fieldConfig.expression}; })(record)`
+  );
+  return displayValue;
+}
+
+export {
+  renderTemplate,
+  applyFilter,
+  buildSortComparator,
+  compileValidator,
+  executePluginHook,
+  renderDynamicField,
+};
diff --git a/priv/combined_metrics/samples/error_handling/no_eval_or_dynamic_code_execution/good/template_engine.js b/priv/combined_metrics/samples/error_handling/no_eval_or_dynamic_code_execution/good/template_engine.js
new file mode 100644
index 0000000..88ea2db
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_eval_or_dynamic_code_execution/good/template_engine.js
@@ -0,0 +1,58 @@
+const ALLOWED_FILTERS = {
+  uppercase: (value) => String(value).toUpperCase(),
+  lowercase: (value) => String(value).toLowerCase(),
+  trim: (value) => String(value).trim(),
+  truncate: (value, length = 80) => String(value).slice(0, Number(length)),
+};
+
+function renderTemplate(template, context) {
+  return template.replace(/\{\{\s*([\w.]+)(?:\s*\|\s*([\w]+)(?::([^}]*))?)?\s*\}\}/g, (_, path, filter, arg) => {
+    const value = resolvePath(context, path);
+
+    if (value === undefined || value === null) {
+      return "";
+    }
+
+    if (filter) {
+      const fn = ALLOWED_FILTERS[filter];
+      if (!fn) {
+        throw new Error(`Unknown filter: '${filter}'. Allowed filters: ${Object.keys(ALLOWED_FILTERS).join(", ")}`);
+      }
+      return fn(value, arg);
+    }
+
+    return String(value);
+  });
+}
+
+function resolvePath(obj, path) {
+  return path.split(".").reduce((current, key) => {
+    if (current == null) return undefined;
+    return current[key];
+  }, obj);
+}
+
+function buildSortComparator(field, direction) {
+  const multiplier = direction === "desc" ? -1 : 1;
+
+  return (a, b) => {
+    const av = resolvePath(a, field);
+    const bv = resolvePath(b, field);
+
+    if (av == null && bv == null) return 0;
+    if (av == null) return 1 * multiplier;
+    if (bv == null) return -1 * multiplier;
+
+    return av < bv ? -1 * multiplier : av > bv ? 1 * multiplier : 0;
+  };
+}
+
+function applyTransforms(value, transforms) {
+  return transforms.reduce((acc, { name, args }) => {
+    const fn = ALLOWED_FILTERS[name];
+    if (!fn) throw new Error(`Unknown transform: '${name}'`);
+    return fn(acc, ...args);
+  }, value);
+}
+
+export { renderTemplate, buildSortComparator, applyTransforms };
diff --git a/priv/combined_metrics/samples/error_handling/no_exceptions_for_control_flow/bad/billing.ex b/priv/combined_metrics/samples/error_handling/no_exceptions_for_control_flow/bad/billing.ex
new file mode 100644
index 0000000..f3e75ea
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_exceptions_for_control_flow/bad/billing.ex
@@ -0,0 +1,68 @@
+defmodule MyApp.Billing do
+  @moduledoc """
+  Billing operations.
+  """
+
+  alias MyApp.Billing.{Invoice, PaymentMethod}
+  alias MyApp.Repo
+
+  # Bad: using try/rescue for expected, recoverable failures (subscription not found)
+  @spec create_invoice(integer()) :: {:ok, Invoice.t()} | {:error, atom()}
+  def create_invoice(subscription_id) do
+    try do
+      subscription = Repo.get!(MyApp.Subscriptions.Subscription, subscription_id)
+
+      unless subscription.billing_enabled do
+        raise "billing disabled"
+      end
+
+      line_items = MyApp.Billing.LineItemCalculator.compute(subscription)
+
+      invoice =
+        %Invoice{}
+        |> Invoice.changeset(%{
+          subscription_id: subscription.id,
+          customer_id: subscription.customer_id,
+          line_items: line_items,
+          status: :draft
+        })
+        |> Repo.insert!()
+
+      {:ok, invoice}
+    rescue
+      Ecto.NoResultsError -> {:error, :subscription_not_found}
+      RuntimeError -> {:error, :billing_disabled}
+      Ecto.InvalidChangesetError -> {:error, :invalid_data}
+    end
+  end
+
+  # Bad: using try/rescue as a null-check replacement
+  @spec charge_invoice(Invoice.t()) :: {:ok, Invoice.t()} | {:error, atom()}
+  def charge_invoice(%Invoice{} = invoice) do
+    try do
+      if invoice.status == :paid, do: raise("already paid")
+      if invoice.status == :void, do: raise("invoice void")
+
+      payment_method = Repo.get_by!(PaymentMethod, customer_id: invoice.customer_id, default: true)
+
+      unless payment_method.active do
+        raise "payment method inactive"
+      end
+
+      case MyApp.PaymentGateway.charge(payment_method.token, invoice.total) do
+        {:ok, _transaction} ->
+          invoice
+          |> Invoice.changeset(%{status: :paid, paid_at: DateTime.utc_now()})
+          |> Repo.update()
+
+        {:error, reason} ->
+          raise "payment failed: #{inspect(reason)}"
+      end
+    rescue
+      RuntimeError, message: "already paid" -> {:error, :already_paid}
+      RuntimeError, message: "invoice void" -> {:error, :invoice_void}
+      Ecto.NoResultsError -> {:error, :no_payment_method}
+      RuntimeError -> {:error, :payment_failed}
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/error_handling/no_exceptions_for_control_flow/good/billing.ex b/priv/combined_metrics/samples/error_handling/no_exceptions_for_control_flow/good/billing.ex
new file mode 100644
index 0000000..04fd18b
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_exceptions_for_control_flow/good/billing.ex
@@ -0,0 +1,84 @@
+defmodule MyApp.Billing do
+  @moduledoc """
+  Billing operations. Uses `{:ok, value}` / `{:error, reason}` tuples
+  for all expected failure paths — no exceptions for control flow.
+  """
+
+  alias MyApp.Billing.{Invoice, PaymentMethod}
+  alias MyApp.Repo
+
+  @doc """
+  Creates an invoice for the given subscription ID.
+  Returns `{:ok, invoice}` or `{:error, reason}`.
+  """
+  @spec create_invoice(integer()) :: {:ok, Invoice.t()} | {:error, atom()}
+  def create_invoice(subscription_id) do
+    with {:ok, subscription} <- fetch_subscription(subscription_id),
+         :ok <- validate_billing_enabled(subscription),
+         {:ok, line_items} <- compute_line_items(subscription),
+         {:ok, invoice} <- insert_invoice(subscription, line_items) do
+      {:ok, invoice}
+    end
+  end
+
+  @doc """
+  Charges the default payment method for an invoice.
+  Returns `{:ok, invoice}` or `{:error, reason}`.
+  """
+  @spec charge_invoice(Invoice.t()) :: {:ok, Invoice.t()} | {:error, atom()}
+  def charge_invoice(%Invoice{status: :paid}), do: {:error, :already_paid}
+  def charge_invoice(%Invoice{status: :void}), do: {:error, :invoice_void}
+
+  def charge_invoice(%Invoice{} = invoice) do
+    case fetch_payment_method(invoice.customer_id) do
+      {:ok, %PaymentMethod{active: true} = pm} -> process_payment(invoice, pm)
+      {:ok, %PaymentMethod{active: false}} -> {:error, :payment_method_inactive}
+      {:error, :not_found} -> {:error, :no_payment_method}
+    end
+  end
+
+  defp fetch_subscription(id) do
+    case Repo.get(MyApp.Subscriptions.Subscription, id) do
+      nil -> {:error, :subscription_not_found}
+      sub -> {:ok, sub}
+    end
+  end
+
+  defp validate_billing_enabled(%{billing_enabled: true}), do: :ok
+  defp validate_billing_enabled(_), do: {:error, :billing_disabled}
+
+  defp compute_line_items(subscription) do
+    items = MyApp.Billing.LineItemCalculator.compute(subscription)
+    {:ok, items}
+  end
+
+  defp insert_invoice(subscription, line_items) do
+    %Invoice{}
+    |> Invoice.changeset(%{
+      subscription_id: subscription.id,
+      customer_id: subscription.customer_id,
+      line_items: line_items,
+      status: :draft
+    })
+    |> Repo.insert()
+  end
+
+  defp fetch_payment_method(customer_id) do
+    case Repo.get_by(PaymentMethod, customer_id: customer_id, default: true) do
+      nil -> {:error, :not_found}
+      pm -> {:ok, pm}
+    end
+  end
+
+  defp process_payment(invoice, payment_method) do
+    case MyApp.PaymentGateway.charge(payment_method.token, invoice.total) do
+      {:ok, _transaction} ->
+        invoice
+        |> Invoice.changeset(%{status: :paid, paid_at: DateTime.utc_now()})
+        |> Repo.update()
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/error_handling/no_floating_promises/bad/order_service.js b/priv/combined_metrics/samples/error_handling/no_floating_promises/bad/order_service.js
new file mode 100644
index 0000000..21c1b60
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_floating_promises/bad/order_service.js
@@ -0,0 +1,55 @@
+import logger from "./logger.js";
+
+async function processOrder(orderId) {
+  const order = await fetchOrder(orderId);
+
+  validateInventory(order.items);
+
+  const payment = await chargePayment(order.total, order.paymentMethod);
+
+  updateOrderStatus(orderId, "confirmed");
+  sendConfirmationEmail(order.customerEmail, order);
+  recordAnalyticsEvent("order_confirmed", { orderId, total: order.total });
+
+  return { orderId, paymentId: payment.id, status: "confirmed" };
+}
+
+async function cancelOrder(orderId, reason) {
+  const order = await fetchOrder(orderId);
+
+  if (order.status === "shipped") {
+    throw new Error("Cannot cancel an order that has already shipped");
+  }
+
+  await updateOrderStatus(orderId, "cancelled");
+
+  refundPayment(order.paymentId, order.total);
+  sendCancellationEmail(order.customerEmail, { orderId, reason });
+
+  return { orderId, status: "cancelled" };
+}
+
+function scheduleOrderReminder(orderId, delayMs) {
+  new Promise((resolve) => setTimeout(resolve, delayMs))
+    .then(() => sendReminderEmail(orderId));
+}
+
+async function bulkFulfillOrders(orderIds) {
+  let fulfilled = 0;
+
+  for (const id of orderIds) {
+    processOrder(id).then(() => {
+      fulfilled++;
+    });
+  }
+
+  return { fulfilled };
+}
+
+function onOrderCreated(order) {
+  sendConfirmationEmail(order.customerEmail, order);
+  recordAnalyticsEvent("order_created", { orderId: order.id });
+  updateInventoryReservation(order.items);
+}
+
+export { processOrder, cancelOrder, scheduleOrderReminder, bulkFulfillOrders, onOrderCreated };
diff --git a/priv/combined_metrics/samples/error_handling/no_floating_promises/bad/user_service.ts b/priv/combined_metrics/samples/error_handling/no_floating_promises/bad/user_service.ts
new file mode 100644
index 0000000..c803dcf
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_floating_promises/bad/user_service.ts
@@ -0,0 +1,68 @@
+interface User {
+  id: string;
+  email: string;
+  displayName: string;
+}
+
+interface AuditEntry {
+  action: string;
+  userId: string;
+  timestamp: number;
+}
+
+async function fetchUser(userId: string): Promise<User> {
+  const response = await fetch(`/api/users/${userId}`);
+  if (!response.ok) throw new Error(`User not found: ${userId}`);
+  return response.json() as Promise<User>;
+}
+
+async function writeAuditLog(entry: AuditEntry): Promise<void> {
+  await fetch("/api/audit", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(entry),
+  });
+}
+
+async function deleteUser(userId: string): Promise<void> {
+  const user = await fetchUser(userId);
+
+  const response = await fetch(`/api/users/${userId}`, { method: "DELETE" });
+  if (!response.ok) throw new Error(`Failed to delete user: ${response.status}`);
+
+  // Floating promise — not awaited
+  writeAuditLog({
+    action: "user_deleted",
+    userId: user.id,
+    timestamp: Date.now(),
+  });
+}
+
+async function updateEmail(userId: string, newEmail: string): Promise<User> {
+  const response = await fetch(`/api/users/${userId}`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ email: newEmail }),
+  });
+
+  if (!response.ok) throw new Error(`Failed to update email: ${response.status}`);
+
+  const updated: User = await response.json();
+
+  // Floating promise — not awaited
+  writeAuditLog({ action: "email_updated", userId, timestamp: Date.now() });
+
+  return updated;
+}
+
+function onUserCreated(user: User): void {
+  // Floating promises in void function
+  writeAuditLog({ action: "user_created", userId: user.id, timestamp: Date.now() });
+  fetch("/api/notifications/welcome", {
+    method: "POST",
+    body: JSON.stringify({ userId: user.id }),
+  });
+}
+
+export { fetchUser, deleteUser, updateEmail, onUserCreated };
+export type { User };
diff --git a/priv/combined_metrics/samples/error_handling/no_floating_promises/good/order_service.js b/priv/combined_metrics/samples/error_handling/no_floating_promises/good/order_service.js
new file mode 100644
index 0000000..9a4237f
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_floating_promises/good/order_service.js
@@ -0,0 +1,59 @@
+import logger from "./logger.js";
+
+async function processOrder(orderId) {
+  const order = await fetchOrder(orderId);
+
+  await validateInventory(order.items);
+
+  const payment = await chargePayment(order.total, order.paymentMethod);
+
+  await Promise.all([
+    updateOrderStatus(orderId, "confirmed"),
+    sendConfirmationEmail(order.customerEmail, order),
+    recordAnalyticsEvent("order_confirmed", { orderId, total: order.total }),
+  ]);
+
+  return { orderId, paymentId: payment.id, status: "confirmed" };
+}
+
+async function cancelOrder(orderId, reason) {
+  const order = await fetchOrder(orderId);
+
+  if (order.status === "shipped") {
+    throw new Error("Cannot cancel an order that has already shipped");
+  }
+
+  await updateOrderStatus(orderId, "cancelled");
+
+  const refundPromise = refundPayment(order.paymentId, order.total);
+  const emailPromise = sendCancellationEmail(order.customerEmail, { orderId, reason });
+
+  const [refund] = await Promise.all([refundPromise, emailPromise]);
+
+  return { orderId, refundId: refund.id, status: "cancelled" };
+}
+
+function scheduleOrderReminder(orderId, delayMs) {
+  const reminderPromise = new Promise((resolve) => setTimeout(resolve, delayMs))
+    .then(() => sendReminderEmail(orderId))
+    .catch((err) => logger.error("Reminder email failed", { orderId, err }));
+
+  return reminderPromise;
+}
+
+async function bulkFulfillOrders(orderIds) {
+  const results = await Promise.allSettled(
+    orderIds.map((id) => processOrder(id))
+  );
+
+  const fulfilled = results.filter((r) => r.status === "fulfilled").length;
+  const failed = results.filter((r) => r.status === "rejected");
+
+  for (const result of failed) {
+    logger.error("Order fulfillment failed", result.reason);
+  }
+
+  return { fulfilled, failedCount: failed.length };
+}
+
+export { processOrder, cancelOrder, scheduleOrderReminder, bulkFulfillOrders };
diff --git a/priv/combined_metrics/samples/error_handling/no_floating_promises/good/user_service.ts b/priv/combined_metrics/samples/error_handling/no_floating_promises/good/user_service.ts
new file mode 100644
index 0000000..a0a83e4
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_floating_promises/good/user_service.ts
@@ -0,0 +1,86 @@
+import logger from "./logger.js";
+
+interface User {
+  id: string;
+  email: string;
+  displayName: string;
+}
+
+interface AuditEntry {
+  action: string;
+  userId: string;
+  timestamp: number;
+}
+
+async function fetchUser(userId: string): Promise<User> {
+  const response = await fetch(`/api/users/${userId}`);
+  if (!response.ok) throw new Error(`User not found: ${userId}`);
+  return response.json() as Promise<User>;
+}
+
+async function writeAuditLog(entry: AuditEntry): Promise<void> {
+  await fetch("/api/audit", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(entry),
+  });
+}
+
+async function deleteUser(userId: string): Promise<void> {
+  const user = await fetchUser(userId);
+
+  const response = await fetch(`/api/users/${userId}`, { method: "DELETE" });
+  if (!response.ok) throw new Error(`Failed to delete user: ${response.status}`);
+
+  await writeAuditLog({
+    action: "user_deleted",
+    userId: user.id,
+    timestamp: Date.now(),
+  });
+}
+
+async function updateEmail(userId: string, newEmail: string): Promise<User> {
+  const response = await fetch(`/api/users/${userId}`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ email: newEmail }),
+  });
+
+  if (!response.ok) throw new Error(`Failed to update email: ${response.status}`);
+
+  const updated: User = await response.json();
+
+  await writeAuditLog({
+    action: "email_updated",
+    userId,
+    timestamp: Date.now(),
+  });
+
+  return updated;
+}
+
+async function bulkInviteUsers(emails: string[]): Promise<{ sent: number; failed: number }> {
+  const results = await Promise.allSettled(
+    emails.map((email) =>
+      fetch("/api/invitations", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email }),
+      })
+    )
+  );
+
+  const sent = results.filter((r) => r.status === "fulfilled").length;
+  const failed = results.filter((r) => r.status === "rejected").length;
+
+  for (const r of results) {
+    if (r.status === "rejected") {
+      logger.error("Invitation failed", r.reason);
+    }
+  }
+
+  return { sent, failed };
+}
+
+export { fetchUser, deleteUser, updateEmail, bulkInviteUsers };
+export type { User };
diff --git a/priv/combined_metrics/samples/error_handling/no_misused_promises/bad/product_repository.ts b/priv/combined_metrics/samples/error_handling/no_misused_promises/bad/product_repository.ts
new file mode 100644
index 0000000..2f286a5
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_misused_promises/bad/product_repository.ts
@@ -0,0 +1,64 @@
+interface Product {
+  id: string;
+  name: string;
+  inStock: boolean;
+}
+
+async function fetchProduct(id: string): Promise<Product> {
+  const response = await fetch(`/api/products/${id}`);
+  if (!response.ok) throw new Error(`Product not found: ${id}`);
+  return response.json() as Promise<Product>;
+}
+
+async function isProductAvailable(id: string): Promise<boolean> {
+  const product = await fetchProduct(id);
+  return product.inStock;
+}
+
+async function handleAddToCart(productId: string): Promise<void> {
+  // Misuse: Promise<boolean> used directly in `if` without await
+  if (isProductAvailable(productId)) {
+    console.log(`Adding product ${productId} to cart`);
+  } else {
+    console.log(`Product ${productId} is out of stock`);
+  }
+}
+
+function loadAndFilterProducts(ids: string[]): Product[] {
+  const products: Product[] = [];
+
+  ids.forEach(async (id) => {
+    // Misuse: async callback in forEach — errors and results are ignored
+    const product = await fetchProduct(id);
+    if (product.inStock) {
+      products.push(product);
+    }
+  });
+
+  return products;
+}
+
+function setupProductEventListeners(productId: string): void {
+  const button = document.querySelector(`[data-product="${productId}"]`);
+  if (!button) return;
+
+  // Misuse: async function passed where void callback is expected with no error handling
+  button.addEventListener("click", async () => {
+    await handleAddToCart(productId);
+  });
+}
+
+async function validateBeforeCheckout(cartItems: string[]): Promise<string[]> {
+  const unavailable: string[] = [];
+
+  cartItems.forEach(async (id) => {
+    // Misuse: async in forEach, result never collected
+    const available = await isProductAvailable(id);
+    if (!available) unavailable.push(id);
+  });
+
+  return unavailable;
+}
+
+export { fetchProduct, isProductAvailable, handleAddToCart, loadAndFilterProducts, validateBeforeCheckout };
+export type { Product };
diff --git a/priv/combined_metrics/samples/error_handling/no_misused_promises/good/product_repository.ts b/priv/combined_metrics/samples/error_handling/no_misused_promises/good/product_repository.ts
new file mode 100644
index 0000000..fba04b3
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_misused_promises/good/product_repository.ts
@@ -0,0 +1,55 @@
+interface Product {
+  id: string;
+  name: string;
+  inStock: boolean;
+}
+
+async function fetchProduct(id: string): Promise<Product> {
+  const response = await fetch(`/api/products/${id}`);
+  if (!response.ok) throw new Error(`Product not found: ${id}`);
+  return response.json() as Promise<Product>;
+}
+
+async function isProductAvailable(id: string): Promise<boolean> {
+  const product = await fetchProduct(id);
+  return product.inStock;
+}
+
+async function handleAddToCart(productId: string): Promise<void> {
+  const available = await isProductAvailable(productId);
+
+  if (available) {
+    console.log(`Adding product ${productId} to cart`);
+  } else {
+    console.log(`Product ${productId} is out of stock`);
+  }
+}
+
+async function loadAndFilterProducts(ids: string[]): Promise<Product[]> {
+  const products = await Promise.all(ids.map((id) => fetchProduct(id)));
+  return products.filter((p) => p.inStock);
+}
+
+function setupProductEventListeners(productId: string): void {
+  const button = document.querySelector(`[data-product="${productId}"]`);
+  if (!button) return;
+
+  button.addEventListener("click", () => {
+    handleAddToCart(productId).catch((err) => {
+      console.error("Failed to add to cart", err);
+    });
+  });
+}
+
+async function validateBeforeCheckout(cartItems: string[]): Promise<string[]> {
+  const checks = await Promise.all(
+    cartItems.map(async (id) => {
+      const available = await isProductAvailable(id);
+      return available ? null : id;
+    })
+  );
+  return checks.filter((id): id is string => id !== null);
+}
+
+export { fetchProduct, isProductAvailable, handleAddToCart, loadAndFilterProducts, validateBeforeCheckout, setupProductEventListeners };
+export type { Product };
diff --git a/priv/combined_metrics/samples/error_handling/no_rescue_as_flow_control/bad/invoice.rb b/priv/combined_metrics/samples/error_handling/no_rescue_as_flow_control/bad/invoice.rb
new file mode 100644
index 0000000..3cfab14
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_rescue_as_flow_control/bad/invoice.rb
@@ -0,0 +1,65 @@
+class InvoiceService
+  def initialize(repository, mailer)
+    @repository = repository
+    @mailer = mailer
+  end
+
+  def find_or_create_for_order(order)
+    begin
+      @repository.find_by!(order_id: order.id)
+    rescue ActiveRecord::RecordNotFound
+      create_invoice(order)
+    end
+  end
+
+  def apply_discount(invoice, coupon_code)
+    begin
+      coupon = @repository.find_coupon!(coupon_code)
+    rescue ActiveRecord::RecordNotFound
+      return { success: false, error: :coupon_not_found }
+    end
+
+    begin
+      raise "expired" if coupon.expired?
+      raise "used" if coupon.already_used_by?(invoice.customer_id)
+    rescue => e
+      return { success: false, error: e.message.to_sym }
+    end
+
+    discount = coupon.calculate_discount(invoice.subtotal)
+    invoice.update!(discount_amount: discount, coupon_code: coupon_code)
+
+    { success: true, discount_amount: discount }
+  end
+
+  def mark_paid(invoice_id, paid_at: Time.current)
+    begin
+      invoice = @repository.find!(invoice_id)
+    rescue ActiveRecord::RecordNotFound
+      return { success: false, error: :not_found }
+    end
+
+    begin
+      raise "already paid" if invoice.paid?
+    rescue
+      return { success: false, error: :already_paid }
+    end
+
+    invoice.update!(status: :paid, paid_at: paid_at)
+    @mailer.send_receipt(invoice)
+
+    { success: true, invoice: invoice }
+  end
+
+  private
+
+  def create_invoice(order)
+    @repository.create!(
+      order_id: order.id,
+      customer_id: order.customer_id,
+      subtotal: order.subtotal,
+      total: order.total,
+      status: :pending
+    )
+  end
+end
diff --git a/priv/combined_metrics/samples/error_handling/no_rescue_as_flow_control/good/invoice.rb b/priv/combined_metrics/samples/error_handling/no_rescue_as_flow_control/good/invoice.rb
new file mode 100644
index 0000000..9b97439
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_rescue_as_flow_control/good/invoice.rb
@@ -0,0 +1,59 @@
+class InvoiceService
+  def initialize(repository, mailer)
+    @repository = repository
+    @mailer = mailer
+  end
+
+  def find_or_create_for_order(order)
+    existing = @repository.find_by(order_id: order.id)
+    return existing if existing
+
+    create_invoice(order)
+  end
+
+  def apply_discount(invoice, coupon_code)
+    coupon = @repository.find_coupon(coupon_code)
+
+    unless coupon
+      return { success: false, error: :coupon_not_found }
+    end
+
+    if coupon.expired?
+      return { success: false, error: :coupon_expired }
+    end
+
+    if coupon.already_used_by?(invoice.customer_id)
+      return { success: false, error: :coupon_already_used }
+    end
+
+    discount = coupon.calculate_discount(invoice.subtotal)
+    invoice.update!(discount_amount: discount, coupon_code: coupon_code)
+
+    { success: true, discount_amount: discount }
+  end
+
+  def mark_paid(invoice_id, paid_at: Time.current)
+    invoice = @repository.find(invoice_id)
+
+    return { success: false, error: :not_found } unless invoice
+    return { success: false, error: :already_paid } if invoice.paid?
+
+    invoice.update!(status: :paid, paid_at: paid_at)
+    @mailer.send_receipt(invoice)
+
+    { success: true, invoice: invoice }
+  end
+
+  private
+
+  def create_invoice(order)
+    @repository.create!(
+      order_id: order.id,
+      customer_id: order.customer_id,
+      subtotal: order.subtotal,
+      tax: order.tax,
+      total: order.total,
+      status: :pending
+    )
+  end
+end
diff --git a/priv/combined_metrics/samples/error_handling/no_return_from_ensure/bad/subscription.rb b/priv/combined_metrics/samples/error_handling/no_return_from_ensure/bad/subscription.rb
new file mode 100644
index 0000000..ea096c4
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_return_from_ensure/bad/subscription.rb
@@ -0,0 +1,49 @@
+class SubscriptionActivator
+  def initialize(billing_client, notifier, logger)
+    @billing_client = billing_client
+    @notifier = notifier
+    @logger = logger
+  end
+
+  def activate(subscription)
+    begin
+      @billing_client.authorize(subscription.payment_method_id, subscription.plan.monthly_price)
+      subscription.update!(status: :active, activated_at: Time.current)
+      @notifier.send_welcome_email(subscription.user)
+      return { success: true, subscription: subscription }
+    rescue BillingClient::AuthorizationError => e
+      @logger.warn("Authorization failed: #{e.message}")
+      return { success: false, error: :payment_authorization_failed }
+    ensure
+      # This return silently swallows any exception raised above
+      cleanup_pending_state(subscription)
+      return { success: false, error: :aborted }
+    end
+  end
+
+  def cancel(subscription, reason:)
+    begin
+      subscription.update!(status: :cancelled, cancelled_at: Time.current, cancel_reason: reason)
+      @billing_client.cancel_recurring(subscription.billing_id)
+      @notifier.send_cancellation_confirmation(subscription.user)
+      return true
+    rescue StandardError => e
+      @logger.error("Cancel failed: #{e.message}")
+      raise
+    ensure
+      release_subscription_seats(subscription)
+      # Returning from ensure masks the re-raised exception
+      return false
+    end
+  end
+
+  private
+
+  def cleanup_pending_state(subscription)
+    subscription.update_column(:pending_activation, false) if subscription.pending_activation?
+  end
+
+  def release_subscription_seats(subscription)
+    subscription.team_seats.update_all(active: false)
+  end
+end
diff --git a/priv/combined_metrics/samples/error_handling/no_return_from_ensure/good/subscription.rb b/priv/combined_metrics/samples/error_handling/no_return_from_ensure/good/subscription.rb
new file mode 100644
index 0000000..b5b7ee2
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/no_return_from_ensure/good/subscription.rb
@@ -0,0 +1,52 @@
+class SubscriptionActivator
+  def initialize(billing_client, notifier, logger)
+    @billing_client = billing_client
+    @notifier = notifier
+    @logger = logger
+  end
+
+  def activate(subscription)
+    result = nil
+
+    begin
+      @billing_client.authorize(subscription.payment_method_id, subscription.plan.monthly_price)
+      subscription.update!(status: :active, activated_at: Time.current)
+      @notifier.send_welcome_email(subscription.user)
+      result = { success: true, subscription: subscription }
+    rescue BillingClient::AuthorizationError => e
+      @logger.warn("Authorization failed for subscription #{subscription.id}: #{e.message}")
+      result = { success: false, error: :payment_authorization_failed }
+    rescue StandardError => e
+      @logger.error("Unexpected error activating subscription #{subscription.id}: #{e.message}")
+      raise
+    ensure
+      @logger.info("Activation attempt completed for subscription #{subscription.id}")
+      cleanup_pending_state(subscription)
+    end
+
+    result
+  end
+
+  def cancel(subscription, reason:)
+    begin
+      subscription.update!(status: :cancelled, cancelled_at: Time.current, cancel_reason: reason)
+      @billing_client.cancel_recurring(subscription.billing_id)
+      @notifier.send_cancellation_confirmation(subscription.user)
+    rescue BillingClient::NotFoundError => e
+      @logger.warn("Billing record not found during cancel #{subscription.id}: #{e.message}")
+    ensure
+      release_subscription_seats(subscription)
+      @logger.info("Cancellation cleanup done for #{subscription.id}")
+    end
+  end
+
+  private
+
+  def cleanup_pending_state(subscription)
+    subscription.update_column(:pending_activation, false) if subscription.pending_activation?
+  end
+
+  def release_subscription_seats(subscription)
+    subscription.team_seats.update_all(active: false)
+  end
+end
diff --git a/priv/combined_metrics/samples/error_handling/rescue_most_specific_first/bad/account.rb b/priv/combined_metrics/samples/error_handling/rescue_most_specific_first/bad/account.rb
new file mode 100644
index 0000000..c7eaa2e
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/rescue_most_specific_first/bad/account.rb
@@ -0,0 +1,55 @@
+class AccountImporter
+  def initialize(csv_parser, repository, logger)
+    @csv_parser = csv_parser
+    @repository = repository
+    @logger = logger
+  end
+
+  def import(file_path)
+    results = { imported: 0, skipped: 0, errors: [] }
+
+    @csv_parser.each_row(file_path) do |row|
+      import_row(row, results)
+    end
+
+    results
+  end
+
+  private
+
+  def import_row(row, results)
+    account = build_account(row)
+
+    begin
+      @repository.save!(account)
+      results[:imported] += 1
+    rescue StandardError => e
+      # Too broad — this catches everything below and the specific rescues are unreachable
+      @logger.error("Unexpected error for #{row[:email]}: #{e.message}")
+      results[:errors] << { email: row[:email], reason: :unexpected }
+    rescue ActiveRecord::ActiveRecordError => e
+      # Dead code — StandardError already matched this
+      @logger.error("ActiveRecord error for #{row[:email]}: #{e.message}")
+      results[:errors] << { email: row[:email], reason: :active_record_error }
+    rescue ActiveRecord::StatementInvalid => e
+      # Dead code — caught by StandardError above
+      @logger.error("DB statement error for #{row[:email]}: #{e.message}")
+      results[:errors] << { email: row[:email], reason: :database_error }
+    rescue ActiveRecord::RecordNotUnique
+      # Dead code — caught by StandardError above
+      results[:skipped] += 1
+    rescue ActiveRecord::RecordInvalid
+      # Dead code — caught by StandardError above
+      results[:skipped] += 1
+    end
+  end
+
+  def build_account(row)
+    Account.new(
+      email: row[:email],
+      name: row[:name],
+      plan: row[:plan] || :free,
+      source: :csv_import
+    )
+  end
+end
diff --git a/priv/combined_metrics/samples/error_handling/rescue_most_specific_first/good/account.rb b/priv/combined_metrics/samples/error_handling/rescue_most_specific_first/good/account.rb
new file mode 100644
index 0000000..85147a7
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/rescue_most_specific_first/good/account.rb
@@ -0,0 +1,57 @@
+class AccountImporter
+  def initialize(csv_parser, repository, logger)
+    @csv_parser = csv_parser
+    @repository = repository
+    @logger = logger
+  end
+
+  def import(file_path)
+    results = { imported: 0, skipped: 0, errors: [] }
+
+    @csv_parser.each_row(file_path) do |row|
+      import_row(row, results)
+    end
+
+    results
+  end
+
+  private
+
+  def import_row(row, results)
+    account = build_account(row)
+
+    begin
+      @repository.save!(account)
+      results[:imported] += 1
+    rescue ActiveRecord::RecordInvalid => e
+      # Most specific: validation failures are expected and recoverable
+      @logger.warn("Validation failed for row #{row[:email]}: #{e.record.errors.full_messages.join(', ')}")
+      results[:skipped] += 1
+    rescue ActiveRecord::RecordNotUnique => e
+      # More specific than StatementInvalid but less than RecordInvalid
+      @logger.warn("Duplicate account skipped: #{row[:email]}")
+      results[:skipped] += 1
+    rescue ActiveRecord::StatementInvalid => e
+      # Less specific DB error
+      @logger.error("DB statement error for #{row[:email]}: #{e.message}")
+      results[:errors] << { email: row[:email], reason: :database_error }
+    rescue ActiveRecord::ActiveRecordError => e
+      # Broad ActiveRecord error — catches anything above not already matched
+      @logger.error("ActiveRecord error for #{row[:email]}: #{e.message}")
+      results[:errors] << { email: row[:email], reason: :active_record_error }
+    rescue StandardError => e
+      # Catch-all for unexpected errors
+      @logger.error("Unexpected error for #{row[:email]}: #{e.message}")
+      results[:errors] << { email: row[:email], reason: :unexpected }
+    end
+  end
+
+  def build_account(row)
+    Account.new(
+      email: row[:email],
+      name: row[:name],
+      plan: row[:plan] || :free,
+      source: :csv_import
+    )
+  end
+end
diff --git a/priv/combined_metrics/samples/error_handling/returns_typed_error/bad/repository.ex b/priv/combined_metrics/samples/error_handling/returns_typed_error/bad/repository.ex
new file mode 100644
index 0000000..cebeb97
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/returns_typed_error/bad/repository.ex
@@ -0,0 +1,92 @@
+defmodule Repository do
+  @moduledoc """
+  Data repository layer for persisting and fetching domain records.
+  """
+
+  def find_by_id(id) do
+    case lookup(id) do
+      nil -> nil
+      record -> record
+    end
+  end
+
+  def find_by_email(email) do
+    case search_email(email) do
+      [] -> false
+      [record | _] -> record
+    end
+  end
+
+  def save(record) do
+    if valid?(record) do
+      do_insert(record)
+    else
+      false
+    end
+  end
+
+  def update(id, attrs) do
+    case lookup(id) do
+      nil -> nil
+      record ->
+        if valid_attrs?(attrs) do
+          do_update(record, attrs)
+        else
+          :invalid
+        end
+    end
+  end
+
+  def delete(id) do
+    case lookup(id) do
+      nil -> false
+      record ->
+        case do_delete(record) do
+          :ok -> true
+          _ -> false
+        end
+    end
+  end
+
+  def list_all(filters) do
+    try do
+      do_list(filters)
+    rescue
+      _ -> []
+    end
+  end
+
+  def count(filters) do
+    case do_count(filters) do
+      nil -> 0
+      n -> n
+    end
+  end
+
+  def exists?(id) do
+    case lookup(id) do
+      nil -> false
+      _ -> true
+    end
+  end
+
+  def find_or_create(attrs) do
+    case search_attrs(attrs) do
+      nil ->
+        if valid_attrs?(attrs), do: do_insert(attrs), else: nil
+      record ->
+        record
+    end
+  end
+
+  defp lookup(_id), do: nil
+  defp search_email(_email), do: []
+  defp valid?(_record), do: true
+  defp do_insert(record), do: record
+  defp valid_attrs?(_attrs), do: true
+  defp do_update(record, _attrs), do: record
+  defp do_delete(_record), do: :ok
+  defp do_list(_filters), do: []
+  defp do_count(_filters), do: 0
+  defp search_attrs(_attrs), do: nil
+end
diff --git a/priv/combined_metrics/samples/error_handling/returns_typed_error/config.yml b/priv/combined_metrics/samples/error_handling/returns_typed_error/config.yml
new file mode 100644
index 0000000..85e423f
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/returns_typed_error/config.yml
@@ -0,0 +1 @@
+doc: "Functions should signal failure via a typed return (e.g. `{:error, reason}`) rather than returning `nil` or `false`."
diff --git a/priv/combined_metrics/samples/error_handling/returns_typed_error/good/repository.ex b/priv/combined_metrics/samples/error_handling/returns_typed_error/good/repository.ex
new file mode 100644
index 0000000..755ed07
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/returns_typed_error/good/repository.ex
@@ -0,0 +1,96 @@
+defmodule Repository do
+  @moduledoc """
+  Data repository layer for persisting and fetching domain records.
+  """
+
+  @spec find_by_id(term()) :: {:ok, map()} | {:error, :not_found}
+  def find_by_id(id) do
+    case lookup(id) do
+      nil -> {:error, :not_found}
+      record -> {:ok, record}
+    end
+  end
+
+  @spec find_by_email(String.t()) :: {:ok, map()} | {:error, :not_found}
+  def find_by_email(email) do
+    case search_email(email) do
+      [] -> {:error, :not_found}
+      [record | _] -> {:ok, record}
+    end
+  end
+
+  @spec save(map()) :: {:ok, map()} | {:error, :validation_failed}
+  def save(record) do
+    if valid?(record) do
+      {:ok, do_insert(record)}
+    else
+      {:error, :validation_failed}
+    end
+  end
+
+  @spec update(term(), map()) :: {:ok, map()} | {:error, :not_found | :validation_failed}
+  def update(id, attrs) do
+    with {:ok, record} <- find_by_id(id),
+         true <- valid_attrs?(attrs) do
+      {:ok, do_update(record, attrs)}
+    else
+      {:error, :not_found} -> {:error, :not_found}
+      false -> {:error, :validation_failed}
+    end
+  end
+
+  @spec delete(term()) :: {:ok, map()} | {:error, :not_found | :delete_failed}
+  def delete(id) do
+    case find_by_id(id) do
+      {:error, :not_found} ->
+        {:error, :not_found}
+      {:ok, record} ->
+        case do_delete(record) do
+          :ok -> {:ok, record}
+          {:error, reason} -> {:error, {:delete_failed, reason}}
+        end
+    end
+  end
+
+  @spec list_all(map()) :: {:ok, list()} | {:error, :query_failed}
+  def list_all(filters) do
+    try do
+      {:ok, do_list(filters)}
+    rescue
+      e -> {:error, {:query_failed, Exception.message(e)}}
+    end
+  end
+
+  @spec count(map()) :: {:ok, non_neg_integer()} | {:error, :query_failed}
+  def count(filters) do
+    case do_count(filters) do
+      nil -> {:error, :query_failed}
+      n -> {:ok, n}
+    end
+  end
+
+  @spec find_or_create(map()) :: {:ok, map()} | {:error, :validation_failed}
+  def find_or_create(attrs) do
+    case search_attrs(attrs) do
+      nil ->
+        if valid_attrs?(attrs) do
+          {:ok, do_insert(attrs)}
+        else
+          {:error, :validation_failed}
+        end
+      record ->
+        {:ok, record}
+    end
+  end
+
+  defp lookup(_id), do: nil
+  defp search_email(_email), do: []
+  defp valid?(_record), do: true
+  defp do_insert(record), do: record
+  defp valid_attrs?(_attrs), do: true
+  defp do_update(record, _attrs), do: record
+  defp do_delete(_record), do: :ok
+  defp do_list(_filters), do: []
+  defp do_count(_filters), do: 0
+  defp search_attrs(_attrs), do: nil
+end
diff --git a/priv/combined_metrics/samples/error_handling/throws_error_objects_not_primitives/bad/api_client.js b/priv/combined_metrics/samples/error_handling/throws_error_objects_not_primitives/bad/api_client.js
new file mode 100644
index 0000000..5dc49bc
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/throws_error_objects_not_primitives/bad/api_client.js
@@ -0,0 +1,64 @@
+async function fetchUser(userId) {
+  if (!userId || typeof userId !== "string") {
+    throw "userId must be a non-empty string";
+  }
+
+  let response;
+  try {
+    response = await fetch(`/api/users/${userId}`);
+  } catch (err) {
+    throw "Failed to reach the API server";
+  }
+
+  if (response.status === 404) {
+    throw 404;
+  }
+
+  if (response.status === 403) {
+    throw { code: 403, message: "You do not have permission to view this user" };
+  }
+
+  if (!response.ok) {
+    throw `Unexpected response status: ${response.status}`;
+  }
+
+  return response.json();
+}
+
+async function updateUserEmail(userId, newEmail) {
+  if (!newEmail.includes("@")) {
+    throw `'${newEmail}' is not a valid email address`;
+  }
+
+  const response = await fetch(`/api/users/${userId}`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ email: newEmail }),
+  });
+
+  if (!response.ok) {
+    const body = await response.json().catch(() => ({}));
+    throw {
+      code: response.status,
+      message: body.message ?? `Failed to update user: ${response.status}`,
+    };
+  }
+
+  return response.json();
+}
+
+async function deleteUser(userId) {
+  if (!userId) {
+    throw null;
+  }
+
+  const response = await fetch(`/api/users/${userId}`, { method: "DELETE" });
+
+  if (!response.ok) {
+    throw response.status;
+  }
+
+  return true;
+}
+
+export { fetchUser, updateUserEmail, deleteUser };
diff --git a/priv/combined_metrics/samples/error_handling/throws_error_objects_not_primitives/good/api_client.js b/priv/combined_metrics/samples/error_handling/throws_error_objects_not_primitives/good/api_client.js
new file mode 100644
index 0000000..41331e9
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/throws_error_objects_not_primitives/good/api_client.js
@@ -0,0 +1,69 @@
+class ApiError extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "ApiError";
+    this.statusCode = statusCode;
+  }
+}
+
+class NetworkError extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "NetworkError";
+    this.cause = cause;
+  }
+}
+
+async function fetchUser(userId) {
+  if (!userId || typeof userId !== "string") {
+    throw new TypeError("userId must be a non-empty string");
+  }
+
+  let response;
+  try {
+    response = await fetch(`/api/users/${userId}`);
+  } catch (err) {
+    throw new NetworkError("Failed to reach the API server", err);
+  }
+
+  if (response.status === 404) {
+    throw new ApiError(`User with id '${userId}' not found`, 404);
+  }
+
+  if (response.status === 403) {
+    throw new ApiError("You do not have permission to view this user", 403);
+  }
+
+  if (!response.ok) {
+    throw new ApiError(
+      `Unexpected response status: ${response.status}`,
+      response.status
+    );
+  }
+
+  return response.json();
+}
+
+async function updateUserEmail(userId, newEmail) {
+  if (!newEmail.includes("@")) {
+    throw new RangeError(`'${newEmail}' is not a valid email address`);
+  }
+
+  const response = await fetch(`/api/users/${userId}`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ email: newEmail }),
+  });
+
+  if (!response.ok) {
+    const body = await response.json().catch(() => ({}));
+    throw new ApiError(
+      body.message ?? `Failed to update user: ${response.status}`,
+      response.status
+    );
+  }
+
+  return response.json();
+}
+
+export { fetchUser, updateUserEmail, ApiError, NetworkError };
diff --git a/priv/combined_metrics/samples/error_handling/try_block_is_minimal/bad/payment_processor.py b/priv/combined_metrics/samples/error_handling/try_block_is_minimal/bad/payment_processor.py
new file mode 100644
index 0000000..84740c2
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/try_block_is_minimal/bad/payment_processor.py
@@ -0,0 +1,73 @@
+"""Payment processor that charges customers and records transactions."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from decimal import Decimal
+from typing import Optional
+import uuid
+
+
+class PaymentGatewayError(Exception):
+    """Raised when the external gateway rejects a charge."""
+
+
+@dataclass
+class PaymentIntent:
+    amount: Decimal
+    currency: str
+    customer_id: str
+    description: str
+
+
+@dataclass
+class ChargeResult:
+    charge_id: str
+    amount: Decimal
+    currency: str
+    customer_id: str
+
+
+def _call_gateway(intent: PaymentIntent) -> str:
+    if intent.amount <= 0:
+        raise PaymentGatewayError("Amount must be positive")
+    return f"ch_{uuid.uuid4().hex[:16]}"
+
+
+def _record_transaction(charge_id: str, intent: PaymentIntent) -> None:
+    print(f"[DB] recorded charge {charge_id} for customer {intent.customer_id}")
+
+
+def charge(intent: PaymentIntent) -> Optional[ChargeResult]:
+    """Charge a customer — oversized try block hides bugs in safe code."""
+    try:
+        # gateway call AND all subsequent safe operations crammed into one try block
+        charge_id = _call_gateway(intent)
+
+        # if _record_transaction raises (e.g. DB error), it's caught as PaymentGatewayError
+        _record_transaction(charge_id, intent)
+
+        # building the result struct is also in try — bugs here are misattributed
+        result = ChargeResult(
+            charge_id=charge_id,
+            amount=intent.amount,
+            currency=intent.currency,
+            customer_id=intent.customer_id,
+        )
+        return result
+    except PaymentGatewayError as exc:
+        print(f"charge failed: {exc}")
+        return None
+
+
+def refund(charge_id: str, amount: Optional[Decimal] = None) -> bool:
+    """Issue a refund — the try block swallows errors from multiple unrelated steps."""
+    try:
+        # all three steps are wrapped together; an error in any one blames the gateway
+        is_valid = charge_id.startswith("ch_")
+        if not is_valid:
+            raise PaymentGatewayError(f"Refund rejected for charge {charge_id}")
+        print(f"[DB] recorded refund for {charge_id} amount={amount}")
+        return True
+    except PaymentGatewayError as exc:
+        print(f"refund failed: {exc}")
+        return False
diff --git a/priv/combined_metrics/samples/error_handling/try_block_is_minimal/good/payment_processor.py b/priv/combined_metrics/samples/error_handling/try_block_is_minimal/good/payment_processor.py
new file mode 100644
index 0000000..e6e7c52
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/try_block_is_minimal/good/payment_processor.py
@@ -0,0 +1,78 @@
+"""Payment processor that charges customers and records transactions."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from decimal import Decimal
+from typing import Optional
+import uuid
+
+
+class PaymentGatewayError(Exception):
+    """Raised when the external gateway rejects a charge."""
+
+
+@dataclass
+class PaymentIntent:
+    amount: Decimal
+    currency: str
+    customer_id: str
+    description: str
+
+
+@dataclass
+class ChargeResult:
+    charge_id: str
+    amount: Decimal
+    currency: str
+    customer_id: str
+
+
+def _call_gateway(intent: PaymentIntent) -> str:
+    """Simulate an external gateway call; returns a charge ID."""
+    if intent.amount <= 0:
+        raise PaymentGatewayError("Amount must be positive")
+    return f"ch_{uuid.uuid4().hex[:16]}"
+
+
+def _record_transaction(charge_id: str, intent: PaymentIntent) -> None:
+    """Persist the transaction record (simulated)."""
+    print(f"[DB] recorded charge {charge_id} for customer {intent.customer_id}")
+
+
+def charge(intent: PaymentIntent) -> ChargeResult:
+    """Charge a customer, keeping the try block as small as possible.
+
+    Only the gateway call is inside try; recording and building the result
+    happen outside so any errors there surface with a clean traceback.
+    """
+    try:
+        charge_id = _call_gateway(intent)   # only the risky call is in try
+    except PaymentGatewayError as exc:
+        raise PaymentGatewayError(
+            f"Gateway rejected charge for customer {intent.customer_id}: {exc}"
+        ) from exc
+
+    # safe operations live outside the try block
+    _record_transaction(charge_id, intent)
+
+    return ChargeResult(
+        charge_id=charge_id,
+        amount=intent.amount,
+        currency=intent.currency,
+        customer_id=intent.customer_id,
+    )
+
+
+def refund(charge_id: str, amount: Optional[Decimal] = None) -> bool:
+    """Issue a refund — try wraps only the gateway call."""
+    try:
+        # only the I/O-bound, failure-prone call belongs inside try
+        success = charge_id.startswith("ch_")  # simulated gateway call
+    except AttributeError as exc:
+        raise ValueError(f"Invalid charge_id: {charge_id!r}") from exc
+
+    if not success:
+        raise PaymentGatewayError(f"Refund rejected for charge {charge_id}")
+
+    print(f"[DB] recorded refund for {charge_id} amount={amount}")
+    return True
diff --git a/priv/combined_metrics/samples/error_handling/uses_checked_arithmetic/bad/invoice.rs b/priv/combined_metrics/samples/error_handling/uses_checked_arithmetic/bad/invoice.rs
new file mode 100644
index 0000000..fdbb4c4
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_checked_arithmetic/bad/invoice.rs
@@ -0,0 +1,41 @@
+pub struct LineItem {
+    pub description: String,
+    pub unit_price_cents: u64,
+    pub quantity: u32,
+}
+
+impl LineItem {
+    pub fn subtotal(&self) -> u64 {
+        // Silently wraps on overflow in release builds — wrong amount charged
+        self.unit_price_cents * self.quantity as u64
+    }
+}
+
+pub struct Invoice {
+    pub items: Vec<LineItem>,
+    /// Discount in basis points (100 = 1%)
+    pub discount_bps: u32,
+}
+
+impl Invoice {
+    pub fn total_cents(&self) -> u64 {
+        let subtotal: u64 = self.items.iter().map(|i| i.subtotal()).sum();
+
+        // If discount_bps > 10_000 this underflows to a huge positive number
+        let after_discount = subtotal * (10_000 - self.discount_bps as u64) / 10_000;
+
+        // Final accumulation also has no overflow check
+        after_discount
+    }
+
+    pub fn tax_amount(&self, rate_bps: u32) -> u64 {
+        let total = self.total_cents();
+        // Multiplication can overflow for large totals
+        total * rate_bps as u64 / 10_000
+    }
+
+    pub fn grand_total(&self, tax_rate_bps: u32) -> u64 {
+        // Adding two potentially wrapped values — wrong result silently returned
+        self.total_cents() + self.tax_amount(tax_rate_bps)
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/uses_checked_arithmetic/good/invoice.rs b/priv/combined_metrics/samples/error_handling/uses_checked_arithmetic/good/invoice.rs
new file mode 100644
index 0000000..4d160c1
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_checked_arithmetic/good/invoice.rs
@@ -0,0 +1,69 @@
+use std::fmt;
+
+#[derive(Debug)]
+pub enum InvoiceError {
+    LineItemOverflow { item: String },
+    TotalOverflow,
+    DiscountOutOfRange(u32),
+}
+
+impl fmt::Display for InvoiceError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            InvoiceError::LineItemOverflow { item } => {
+                write!(f, "line item subtotal overflowed for: {item}")
+            }
+            InvoiceError::TotalOverflow => write!(f, "invoice total overflowed u64"),
+            InvoiceError::DiscountOutOfRange(d) => {
+                write!(f, "discount {d} basis points exceeds 100%")
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct LineItem {
+    pub description: String,
+    pub unit_price_cents: u64,
+    pub quantity: u32,
+}
+
+impl LineItem {
+    pub fn subtotal(&self) -> Result<u64, InvoiceError> {
+        let qty = self.quantity as u64;
+        self.unit_price_cents
+            .checked_mul(qty)
+            .ok_or_else(|| InvoiceError::LineItemOverflow {
+                item: self.description.clone(),
+            })
+    }
+}
+
+pub struct Invoice {
+    pub items: Vec<LineItem>,
+    /// Discount in basis points (100 = 1%)
+    pub discount_bps: u32,
+}
+
+impl Invoice {
+    pub fn total_cents(&self) -> Result<u64, InvoiceError> {
+        if self.discount_bps > 10_000 {
+            return Err(InvoiceError::DiscountOutOfRange(self.discount_bps));
+        }
+
+        let subtotal = self
+            .items
+            .iter()
+            .try_fold(0u64, |acc, item| {
+                item.subtotal()?
+                    .checked_add(acc)
+                    .ok_or(InvoiceError::TotalOverflow)
+            })?;
+
+        let discount_factor = 10_000 - self.discount_bps as u64;
+        subtotal
+            .checked_mul(discount_factor)
+            .and_then(|n| n.checked_div(10_000))
+            .ok_or(InvoiceError::TotalOverflow)
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/uses_custom_error_type_with_context/bad/store.rs b/priv/combined_metrics/samples/error_handling/uses_custom_error_type_with_context/bad/store.rs
new file mode 100644
index 0000000..e1d6bb3
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_custom_error_type_with_context/bad/store.rs
@@ -0,0 +1,51 @@
+use std::collections::HashMap;
+
+pub struct BoundedStore {
+    data: HashMap<String, Vec<u8>>,
+    max_entries: usize,
+    max_bytes: u64,
+    used_bytes: u64,
+}
+
+impl BoundedStore {
+    pub fn new(max_entries: usize, max_bytes: u64) -> Self {
+        Self {
+            data: HashMap::new(),
+            max_entries,
+            max_bytes,
+            used_bytes: 0,
+        }
+    }
+
+    // Returning raw &str errors: no structure, callers can't match on variants
+    pub fn insert(&mut self, key: String, value: Vec<u8>) -> Result<(), &'static str> {
+        if self.data.len() >= self.max_entries && !self.data.contains_key(&key) {
+            // Cannot include actual limit in static string
+            return Err("capacity exceeded");
+        }
+        let new_bytes = self.used_bytes + value.len() as u64;
+        if new_bytes > self.max_bytes {
+            // Cannot communicate how full the store is
+            return Err("storage full");
+        }
+        self.used_bytes = new_bytes;
+        self.data.insert(key, value);
+        Ok(())
+    }
+
+    // Returning String errors: slightly better, but callers can't pattern match
+    pub fn get(&self, key: &str) -> Result<&[u8], String> {
+        self.data
+            .get(key)
+            .map(Vec::as_slice)
+            // key is in the message, but only as a substring — fragile to parse
+            .ok_or_else(|| format!("not found: {key}"))
+    }
+
+    pub fn remove(&mut self, key: &str) -> Result<Vec<u8>, String> {
+        self.data
+            .remove(key)
+            .ok_or_else(|| "key does not exist".to_string())
+        // No key context — caller cannot tell which key was missing
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/uses_custom_error_type_with_context/good/store.rs b/priv/combined_metrics/samples/error_handling/uses_custom_error_type_with_context/good/store.rs
new file mode 100644
index 0000000..86b8f5e
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_custom_error_type_with_context/good/store.rs
@@ -0,0 +1,70 @@
+use std::collections::HashMap;
+use std::fmt;
+
+#[derive(Debug)]
+pub enum StoreError {
+    NotFound { key: String },
+    CapacityExceeded { limit: usize },
+    SerializationFailed { key: String, reason: String },
+    StorageFull { used_bytes: u64, max_bytes: u64 },
+}
+
+impl fmt::Display for StoreError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            StoreError::NotFound { key } => write!(f, "key not found: '{key}'"),
+            StoreError::CapacityExceeded { limit } => {
+                write!(f, "store capacity of {limit} entries exceeded")
+            }
+            StoreError::SerializationFailed { key, reason } => {
+                write!(f, "failed to serialize value for key '{key}': {reason}")
+            }
+            StoreError::StorageFull { used_bytes, max_bytes } => {
+                write!(f, "storage full: {used_bytes}/{max_bytes} bytes used")
+            }
+        }
+    }
+}
+
+impl std::error::Error for StoreError {}
+
+pub struct BoundedStore {
+    data: HashMap<String, Vec<u8>>,
+    max_entries: usize,
+    max_bytes: u64,
+    used_bytes: u64,
+}
+
+impl BoundedStore {
+    pub fn new(max_entries: usize, max_bytes: u64) -> Self {
+        Self {
+            data: HashMap::new(),
+            max_entries,
+            max_bytes,
+            used_bytes: 0,
+        }
+    }
+
+    pub fn insert(&mut self, key: String, value: Vec<u8>) -> Result<(), StoreError> {
+        if self.data.len() >= self.max_entries && !self.data.contains_key(&key) {
+            return Err(StoreError::CapacityExceeded { limit: self.max_entries });
+        }
+        let new_bytes = self.used_bytes + value.len() as u64;
+        if new_bytes > self.max_bytes {
+            return Err(StoreError::StorageFull {
+                used_bytes: self.used_bytes,
+                max_bytes: self.max_bytes,
+            });
+        }
+        self.used_bytes = new_bytes;
+        self.data.insert(key, value);
+        Ok(())
+    }
+
+    pub fn get(&self, key: &str) -> Result<&[u8], StoreError> {
+        self.data
+            .get(key)
+            .map(Vec::as_slice)
+            .ok_or_else(|| StoreError::NotFound { key: key.to_string() })
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/uses_errors_as_for_type_assertion/bad/router.go b/priv/combined_metrics/samples/error_handling/uses_errors_as_for_type_assertion/bad/router.go
new file mode 100644
index 0000000..c153d1b
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_errors_as_for_type_assertion/bad/router.go
@@ -0,0 +1,44 @@
+package router
+
+import (
+	"net/http"
+)
+
+// ValidationError represents a field-level validation failure.
+type ValidationError struct {
+	Field   string
+	Message string
+}
+
+func (e *ValidationError) Error() string {
+	return e.Field + ": " + e.Message
+}
+
+type ProductHandler struct {
+	service ProductService
+}
+
+type ProductService interface {
+	Create(name string, price float64) error
+}
+
+// CreateProduct handles product creation and maps ValidationError to 400.
+// It uses a direct type assertion, which fails silently when the error is wrapped.
+func (h *ProductHandler) CreateProduct(w http.ResponseWriter, r *http.Request) {
+	name := r.FormValue("name")
+	price := 0.0
+
+	err := h.service.Create(name, price)
+	if err == nil {
+		w.WriteHeader(http.StatusCreated)
+		return
+	}
+
+	// Direct type assertion fails when the error is wrapped with fmt.Errorf("%w", ve).
+	if ve, ok := err.(*ValidationError); ok {
+		http.Error(w, "validation error: "+ve.Field+": "+ve.Message, http.StatusBadRequest)
+		return
+	}
+
+	http.Error(w, "internal server error", http.StatusInternalServerError)
+}
diff --git a/priv/combined_metrics/samples/error_handling/uses_errors_as_for_type_assertion/good/router.go b/priv/combined_metrics/samples/error_handling/uses_errors_as_for_type_assertion/good/router.go
new file mode 100644
index 0000000..e92ca34
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_errors_as_for_type_assertion/good/router.go
@@ -0,0 +1,46 @@
+package router
+
+import (
+	"errors"
+	"net/http"
+)
+
+// ValidationError represents a field-level validation failure.
+type ValidationError struct {
+	Field   string
+	Message string
+}
+
+func (e *ValidationError) Error() string {
+	return e.Field + ": " + e.Message
+}
+
+type ProductHandler struct {
+	service ProductService
+}
+
+type ProductService interface {
+	Create(name string, price float64) error
+}
+
+// CreateProduct handles product creation and maps ValidationError to 400.
+// It uses errors.As to correctly unwrap errors in a chain.
+func (h *ProductHandler) CreateProduct(w http.ResponseWriter, r *http.Request) {
+	name := r.FormValue("name")
+	price := 0.0
+
+	err := h.service.Create(name, price)
+	if err == nil {
+		w.WriteHeader(http.StatusCreated)
+		return
+	}
+
+	// errors.As traverses the error chain to find *ValidationError even when wrapped.
+	var ve *ValidationError
+	if errors.As(err, &ve) {
+		http.Error(w, "validation error: "+ve.Field+": "+ve.Message, http.StatusBadRequest)
+		return
+	}
+
+	http.Error(w, "internal server error", http.StatusInternalServerError)
+}
diff --git a/priv/combined_metrics/samples/error_handling/uses_errors_is_for_sentinel_comparison/bad/middleware.go b/priv/combined_metrics/samples/error_handling/uses_errors_is_for_sentinel_comparison/bad/middleware.go
new file mode 100644
index 0000000..bec84b2
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_errors_is_for_sentinel_comparison/bad/middleware.go
@@ -0,0 +1,42 @@
+package middleware
+
+import (
+	"errors"
+	"net/http"
+)
+
+var (
+	ErrUnauthorized = errors.New("unauthorized")
+	ErrForbidden    = errors.New("forbidden")
+)
+
+type AuthService interface {
+	Validate(token string) error
+}
+
+// RequireAuth returns a middleware that validates the Bearer token.
+// It uses == for error comparison, which breaks when errors are wrapped.
+func RequireAuth(auth AuthService) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			token := r.Header.Get("Authorization")
+			err := auth.Validate(token)
+			if err == nil {
+				next.ServeHTTP(w, r)
+				return
+			}
+
+			// Direct == comparison fails when err is wrapped with fmt.Errorf("%w").
+			if err == ErrUnauthorized {
+				http.Error(w, "authentication required", http.StatusUnauthorized)
+				return
+			}
+			if err == ErrForbidden {
+				http.Error(w, "access denied", http.StatusForbidden)
+				return
+			}
+
+			http.Error(w, "internal server error", http.StatusInternalServerError)
+		})
+	}
+}
diff --git a/priv/combined_metrics/samples/error_handling/uses_errors_is_for_sentinel_comparison/good/middleware.go b/priv/combined_metrics/samples/error_handling/uses_errors_is_for_sentinel_comparison/good/middleware.go
new file mode 100644
index 0000000..01e3a4e
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_errors_is_for_sentinel_comparison/good/middleware.go
@@ -0,0 +1,42 @@
+package middleware
+
+import (
+	"errors"
+	"net/http"
+)
+
+var (
+	ErrUnauthorized = errors.New("unauthorized")
+	ErrForbidden    = errors.New("forbidden")
+)
+
+type AuthService interface {
+	Validate(token string) error
+}
+
+// RequireAuth returns a middleware that validates the Bearer token.
+// It uses errors.Is to correctly match sentinel errors through any wrapping.
+func RequireAuth(auth AuthService) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			token := r.Header.Get("Authorization")
+			err := auth.Validate(token)
+			if err == nil {
+				next.ServeHTTP(w, r)
+				return
+			}
+
+			// errors.Is traverses the error chain, so wrapped sentinels are matched correctly.
+			if errors.Is(err, ErrUnauthorized) {
+				http.Error(w, "authentication required", http.StatusUnauthorized)
+				return
+			}
+			if errors.Is(err, ErrForbidden) {
+				http.Error(w, "access denied", http.StatusForbidden)
+				return
+			}
+
+			http.Error(w, "internal server error", http.StatusInternalServerError)
+		})
+	}
+}
diff --git a/priv/combined_metrics/samples/error_handling/uses_exceptions_not_error_codes/bad/OrderService.php b/priv/combined_metrics/samples/error_handling/uses_exceptions_not_error_codes/bad/OrderService.php
new file mode 100644
index 0000000..cc7773c
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_exceptions_not_error_codes/bad/OrderService.php
@@ -0,0 +1,66 @@
+<?php
+
+namespace App\Service;
+
+class OrderService
+{
+    public function __construct(
+        private $orders,
+        private $inventory,
+        private $payments
+    ) {
+    }
+
+    // Returns error codes / false instead of throwing exceptions
+    public function place($customerId, $items)
+    {
+        foreach ($items as $item) {
+            $available = $this->inventory->getAvailableQuantity($item['product_id']);
+            if ($available < $item['quantity']) {
+                return -1; // Caller must know magic codes
+            }
+        }
+
+        $order = new \stdClass();
+        $order->customerId = $customerId;
+        $order->status = 'pending';
+        $order->items = $items;
+        $saved = $this->orders->save($order);
+
+        if (!$saved) {
+            return false; // Is false a different error than -1?
+        }
+
+        return $order;
+    }
+
+    public function confirm($orderId, $paymentToken)
+    {
+        $order = $this->orders->findById($orderId);
+        if ($order === null) {
+            return null; // Caller must null-check
+        }
+
+        if ($order->status !== 'pending') {
+            return -2; // Magic number for wrong state
+        }
+
+        $charged = $this->payments->charge($order->total, $paymentToken);
+        if (!$charged) {
+            return -3; // Magic number for payment failed
+        }
+
+        $order->status = 'confirmed';
+        $this->orders->save($order);
+
+        return $order;
+    }
+
+    public function getOrFail($orderId)
+    {
+        $order = $this->orders->findById($orderId);
+
+        // Returns false — caller must remember to check === false
+        return $order ?? false;
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/uses_exceptions_not_error_codes/good/OrderService.php b/priv/combined_metrics/samples/error_handling/uses_exceptions_not_error_codes/good/OrderService.php
new file mode 100644
index 0000000..2c3d70b
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_exceptions_not_error_codes/good/OrderService.php
@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+use App\Entity\Order;
+use App\Exception\OrderNotFoundException;
+use App\Exception\InvalidOrderStateException;
+use App\Exception\PaymentFailedException;
+use App\Exception\InsufficientStockException;
+
+class OrderService
+{
+    public function __construct(
+        private OrderRepository $orders,
+        private InventoryService $inventory,
+        private PaymentService $payments
+    ) {
+    }
+
+    public function place(int $customerId, array $items): Order
+    {
+        foreach ($items as $item) {
+            $available = $this->inventory->getAvailableQuantity($item['product_id']);
+            if ($available < $item['quantity']) {
+                throw new InsufficientStockException(
+                    "Product {$item['product_id']} has only {$available} units available"
+                );
+            }
+        }
+
+        $order = new Order(customerId: $customerId, status: 'pending');
+        foreach ($items as $item) {
+            $order->addItem($item['product_id'], $item['quantity'], $item['unit_price']);
+        }
+        $this->orders->save($order);
+
+        return $order;
+    }
+
+    public function confirm(int $orderId, string $paymentToken): Order
+    {
+        $order = $this->orders->findById($orderId);
+        if ($order === null) {
+            throw new OrderNotFoundException("Order {$orderId} not found");
+        }
+
+        if ($order->getStatus() !== 'pending') {
+            throw new InvalidOrderStateException(
+                "Cannot confirm order in state '{$order->getStatus()}'"
+            );
+        }
+
+        $this->payments->charge($order->getTotal(), $paymentToken);
+
+        $order->setStatus('confirmed');
+        $this->orders->save($order);
+
+        return $order;
+    }
+
+    public function getOrFail(int $orderId): Order
+    {
+        $order = $this->orders->findById($orderId);
+        if ($order === null) {
+            throw new OrderNotFoundException("Order {$orderId} not found");
+        }
+
+        return $order;
+    }
+}
diff --git a/priv/combined_metrics/samples/error_handling/uses_question_mark_for_propagation/bad/loader.rs b/priv/combined_metrics/samples/error_handling/uses_question_mark_for_propagation/bad/loader.rs
new file mode 100644
index 0000000..ea5190d
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_question_mark_for_propagation/bad/loader.rs
@@ -0,0 +1,58 @@
+use std::fs;
+use std::io;
+use std::path::Path;
+
+pub struct FileRecord {
+    pub path: String,
+    pub lines: Vec<String>,
+    pub byte_count: usize,
+}
+
+pub fn load_record(path: &Path) -> Result<FileRecord, String> {
+    // Manual match instead of ? operator — noisy and error-prone
+    let raw = match fs::read(path) {
+        Ok(bytes) => bytes,
+        Err(e) => return Err(format!("IO error: {e}")),
+    };
+
+    let content = match String::from_utf8(raw.clone()) {
+        Ok(s) => s,
+        Err(e) => return Err(format!("encoding error: {e}")),
+    };
+
+    if content.trim().is_empty() {
+        return Err(format!("file is empty: {}", path.display()));
+    }
+
+    let lines: Vec<String> = content.lines().map(str::to_string).collect();
+
+    Ok(FileRecord {
+        path: path.display().to_string(),
+        lines,
+        byte_count: raw.len(),
+    })
+}
+
+pub fn load_all(dir: &Path) -> Result<Vec<FileRecord>, String> {
+    let read_dir = match fs::read_dir(dir) {
+        Ok(rd) => rd,
+        Err(e) => return Err(format!("cannot read dir: {e}")),
+    };
+
+    let mut records = Vec::new();
+    for entry_result in read_dir {
+        let entry = match entry_result {
+            Ok(e) => e,
+            Err(e) => return Err(format!("dir entry error: {e}")),
+        };
+        let path = entry.path();
+        if path.extension().and_then(|e| e.to_str()) == Some("txt") {
+            let record = match load_record(&path) {
+                Ok(r) => r,
+                Err(e) => return Err(e),
+            };
+            records.push(record);
+        }
+    }
+    Ok(records)
+}
diff --git a/priv/combined_metrics/samples/error_handling/uses_question_mark_for_propagation/good/loader.rs b/priv/combined_metrics/samples/error_handling/uses_question_mark_for_propagation/good/loader.rs
new file mode 100644
index 0000000..d209aae
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_question_mark_for_propagation/good/loader.rs
@@ -0,0 +1,63 @@
+use std::fs;
+use std::io;
+use std::path::Path;
+
+#[derive(Debug)]
+pub enum LoadError {
+    Io(io::Error),
+    InvalidEncoding(String),
+    EmptyFile(String),
+}
+
+impl From<io::Error> for LoadError {
+    fn from(e: io::Error) -> Self {
+        LoadError::Io(e)
+    }
+}
+
+impl std::fmt::Display for LoadError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LoadError::Io(e) => write!(f, "IO error: {e}"),
+            LoadError::InvalidEncoding(msg) => write!(f, "encoding error: {msg}"),
+            LoadError::EmptyFile(path) => write!(f, "file is empty: {path}"),
+        }
+    }
+}
+
+pub struct FileRecord {
+    pub path: String,
+    pub lines: Vec<String>,
+    pub byte_count: usize,
+}
+
+pub fn load_record(path: &Path) -> Result<FileRecord, LoadError> {
+    let raw = fs::read(path)?;
+    let content = String::from_utf8(raw.clone()).map_err(|e| {
+        LoadError::InvalidEncoding(format!("{}: {e}", path.display()))
+    })?;
+
+    if content.trim().is_empty() {
+        return Err(LoadError::EmptyFile(path.display().to_string()));
+    }
+
+    let lines: Vec<String> = content.lines().map(str::to_string).collect();
+
+    Ok(FileRecord {
+        path: path.display().to_string(),
+        lines,
+        byte_count: raw.len(),
+    })
+}
+
+pub fn load_all(dir: &Path) -> Result<Vec<FileRecord>, LoadError> {
+    let mut records = Vec::new();
+    for entry in fs::read_dir(dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        if path.extension().and_then(|e| e.to_str()) == Some("txt") {
+            records.push(load_record(&path)?);
+        }
+    }
+    Ok(records)
+}
diff --git a/priv/combined_metrics/samples/error_handling/uses_raise_from/bad/config_loader.py b/priv/combined_metrics/samples/error_handling/uses_raise_from/bad/config_loader.py
new file mode 100644
index 0000000..7a97e95
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_raise_from/bad/config_loader.py
@@ -0,0 +1,68 @@
+"""Configuration loader that reads YAML/JSON config files and validates them."""
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+
+class ConfigError(Exception):
+    """Raised when configuration cannot be loaded or is invalid."""
+
+
+class MissingKeyError(ConfigError):
+    """Raised when a required configuration key is absent."""
+
+
+def _read_file(path: str) -> str:
+    try:
+        with open(path, encoding="utf-8") as fh:
+            return fh.read()
+    except FileNotFoundError:
+        # original FileNotFoundError context is lost — no 'from exc'
+        raise ConfigError(f"Configuration file not found: {path}")
+    except PermissionError:
+        raise ConfigError(f"Cannot read configuration file: {path}")
+
+
+def _parse_json(raw: str, path: str) -> dict[str, Any]:
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        # the precise parse error (line, column) vanishes from the traceback
+        raise ConfigError(f"Invalid JSON in configuration file {path}")
+
+
+def _require_key(config: dict[str, Any], key: str) -> Any:
+    try:
+        return config[key]
+    except KeyError:
+        # KeyError is silently replaced — no chain, harder to debug
+        raise MissingKeyError(f"Required configuration key {key!r} is missing")
+
+
+def load(path: str) -> dict[str, Any]:
+    """Load and validate a JSON configuration file."""
+    raw = _read_file(path)
+    config = _parse_json(raw, path)
+
+    database_url = _require_key(config, "database_url")
+    secret_key = _require_key(config, "secret_key")
+    debug = config.get("debug", False)
+
+    return {
+        "database_url": database_url,
+        "secret_key": secret_key,
+        "debug": debug,
+        "raw": config,
+    }
+
+
+def load_from_env_or_file(env_var: str, fallback_path: str) -> dict[str, Any]:
+    """Load config from an env var path or fall back to a default file."""
+    path = os.environ.get(env_var, fallback_path)
+    try:
+        return load(path)
+    except ConfigError:
+        # wraps again without from — traceback chain is broken at every level
+        raise ConfigError(f"Failed to load config (env {env_var}={path!r})")
diff --git a/priv/combined_metrics/samples/error_handling/uses_raise_from/good/config_loader.py b/priv/combined_metrics/samples/error_handling/uses_raise_from/good/config_loader.py
new file mode 100644
index 0000000..99ae990
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_raise_from/good/config_loader.py
@@ -0,0 +1,72 @@
+"""Configuration loader that reads YAML/JSON config files and validates them."""
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+
+class ConfigError(Exception):
+    """Raised when configuration cannot be loaded or is invalid."""
+
+
+class MissingKeyError(ConfigError):
+    """Raised when a required configuration key is absent."""
+
+
+def _read_file(path: str) -> str:
+    try:
+        with open(path, encoding="utf-8") as fh:
+            return fh.read()
+    except FileNotFoundError as exc:
+        raise ConfigError(f"Configuration file not found: {path}") from exc
+    except PermissionError as exc:
+        raise ConfigError(f"Cannot read configuration file: {path}") from exc
+
+
+def _parse_json(raw: str, path: str) -> dict[str, Any]:
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as exc:
+        # raise from preserves the JSON parse error in the exception chain
+        raise ConfigError(
+            f"Invalid JSON in configuration file {path}: {exc.msg} "
+            f"(line {exc.lineno}, col {exc.colno})"
+        ) from exc
+
+
+def _require_key(config: dict[str, Any], key: str) -> Any:
+    try:
+        return config[key]
+    except KeyError as exc:
+        raise MissingKeyError(
+            f"Required configuration key {key!r} is missing"
+        ) from exc
+
+
+def load(path: str) -> dict[str, Any]:
+    """Load and validate a JSON configuration file."""
+    raw = _read_file(path)
+    config = _parse_json(raw, path)
+
+    database_url = _require_key(config, "database_url")
+    secret_key = _require_key(config, "secret_key")
+    debug = config.get("debug", False)
+
+    return {
+        "database_url": database_url,
+        "secret_key": secret_key,
+        "debug": debug,
+        "raw": config,
+    }
+
+
+def load_from_env_or_file(env_var: str, fallback_path: str) -> dict[str, Any]:
+    """Load config from an env var path or fall back to a default file."""
+    path = os.environ.get(env_var, fallback_path)
+    try:
+        return load(path)
+    except ConfigError as exc:
+        raise ConfigError(
+            f"Failed to load config (env {env_var}={path!r})"
+        ) from exc
diff --git a/priv/combined_metrics/samples/error_handling/uses_result_for_recoverable_errors/bad/parser.rs b/priv/combined_metrics/samples/error_handling/uses_result_for_recoverable_errors/bad/parser.rs
new file mode 100644
index 0000000..d1668dc
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_result_for_recoverable_errors/bad/parser.rs
@@ -0,0 +1,50 @@
+pub struct Config {
+    pub host: String,
+    pub port: u16,
+    pub max_connections: usize,
+}
+
+pub fn parse_config(raw: &str) -> Config {
+    let mut host = String::new();
+    let mut port: u16 = 0;
+    let mut max_connections: usize = 10;
+
+    for line in raw.lines() {
+        let line = line.trim();
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+
+        // Panics if line has no '=' separator — caller cannot recover
+        let parts: Vec<&str> = line.splitn(2, '=').collect();
+        if parts.len() != 2 {
+            panic!("malformed config line: {line}");
+        }
+
+        let key = parts[0].trim();
+        let value = parts[1].trim();
+
+        match key {
+            "host" => host = value.to_string(),
+            "port" => {
+                // Panics on invalid port — even a typo in the config file crashes
+                port = value.parse().unwrap();
+            }
+            "max_connections" => {
+                max_connections = value.parse().unwrap();
+            }
+            _ => {}
+        }
+    }
+
+    if host.is_empty() {
+        // Missing config key is recoverable but we panic anyway
+        panic!("config missing required field: host");
+    }
+
+    if port == 0 {
+        panic!("config missing required field: port");
+    }
+
+    Config { host, port, max_connections }
+}
diff --git a/priv/combined_metrics/samples/error_handling/uses_result_for_recoverable_errors/good/parser.rs b/priv/combined_metrics/samples/error_handling/uses_result_for_recoverable_errors/good/parser.rs
new file mode 100644
index 0000000..4f99ea2
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_result_for_recoverable_errors/good/parser.rs
@@ -0,0 +1,74 @@
+use std::num::ParseIntError;
+use std::fmt;
+
+#[derive(Debug)]
+pub enum ConfigError {
+    MissingField(String),
+    InvalidValue { field: String, reason: String },
+    ParseError(ParseIntError),
+}
+
+impl fmt::Display for ConfigError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ConfigError::MissingField(field) => write!(f, "missing required field: {field}"),
+            ConfigError::InvalidValue { field, reason } => {
+                write!(f, "invalid value for '{field}': {reason}")
+            }
+            ConfigError::ParseError(e) => write!(f, "parse error: {e}"),
+        }
+    }
+}
+
+impl From<ParseIntError> for ConfigError {
+    fn from(e: ParseIntError) -> Self {
+        ConfigError::ParseError(e)
+    }
+}
+
+pub struct Config {
+    pub host: String,
+    pub port: u16,
+    pub max_connections: usize,
+}
+
+pub fn parse_config(raw: &str) -> Result<Config, ConfigError> {
+    let mut host = None;
+    let mut port = None;
+    let mut max_connections = None;
+
+    for line in raw.lines() {
+        let line = line.trim();
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+        let (key, value) = line.split_once('=').ok_or_else(|| {
+            ConfigError::InvalidValue {
+                field: line.to_string(),
+                reason: "expected key=value format".to_string(),
+            }
+        })?;
+
+        match key.trim() {
+            "host" => host = Some(value.trim().to_string()),
+            "port" => {
+                let p: u16 = value.trim().parse().map_err(|_| ConfigError::InvalidValue {
+                    field: "port".to_string(),
+                    reason: "must be a number between 1 and 65535".to_string(),
+                })?;
+                port = Some(p);
+            }
+            "max_connections" => {
+                let n: usize = value.trim().parse()?;
+                max_connections = Some(n);
+            }
+            _ => {}
+        }
+    }
+
+    Ok(Config {
+        host: host.ok_or_else(|| ConfigError::MissingField("host".to_string()))?,
+        port: port.ok_or_else(|| ConfigError::MissingField("port".to_string()))?,
+        max_connections: max_connections.unwrap_or(10),
+    })
+}
diff --git a/priv/combined_metrics/samples/error_handling/uses_throws_for_recoverable_errors/bad/AuthService.swift b/priv/combined_metrics/samples/error_handling/uses_throws_for_recoverable_errors/bad/AuthService.swift
new file mode 100644
index 0000000..2ce1e80
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_throws_for_recoverable_errors/bad/AuthService.swift
@@ -0,0 +1,65 @@
+import Foundation
+
+struct AuthToken {
+    let value: String
+    let expiresAt: Date
+    let userID: String
+}
+
+struct Credentials {
+    let username: String
+    let password: String
+}
+
+class AuthService {
+    private var failedAttempts: [String: Int] = [:]
+    private let maxAttempts = 5
+
+    // Returns nil for all failure modes — caller cannot distinguish between
+    // invalid credentials, account locked, network error, etc.
+    func login(with credentials: Credentials) -> AuthToken? {
+        guard !credentials.username.isEmpty, !credentials.password.isEmpty else {
+            return nil
+        }
+
+        let attempts = failedAttempts[credentials.username, default: 0]
+        if attempts >= maxAttempts {
+            return nil
+        }
+
+        guard isReachable() else {
+            return nil
+        }
+
+        guard validateCredentials(credentials) else {
+            failedAttempts[credentials.username, default: 0] += 1
+            return nil
+        }
+
+        failedAttempts.removeValue(forKey: credentials.username)
+        return AuthToken(
+            value: generateToken(),
+            expiresAt: Date().addingTimeInterval(3600),
+            userID: credentials.username
+        )
+    }
+
+    // Returns nil with no way to tell if expired or invalid
+    func validateToken(_ token: AuthToken) -> Bool? {
+        guard token.expiresAt > Date() else {
+            return nil
+        }
+        return true
+    }
+
+    // Returns false for both "no permission" and "token invalid"
+    func requirePermission(_ permission: String, for token: AuthToken) -> Bool {
+        guard token.expiresAt > Date() else { return false }
+        return hasPermission(permission, userID: token.userID)
+    }
+
+    private func validateCredentials(_ credentials: Credentials) -> Bool { true }
+    private func generateToken() -> String { UUID().uuidString }
+    private func isReachable() -> Bool { true }
+    private func hasPermission(_ permission: String, userID: String) -> Bool { true }
+}
diff --git a/priv/combined_metrics/samples/error_handling/uses_throws_for_recoverable_errors/good/AuthService.swift b/priv/combined_metrics/samples/error_handling/uses_throws_for_recoverable_errors/good/AuthService.swift
new file mode 100644
index 0000000..b0862b7
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/uses_throws_for_recoverable_errors/good/AuthService.swift
@@ -0,0 +1,70 @@
+import Foundation
+
+enum AuthError: Error {
+    case invalidCredentials
+    case accountLocked(until: Date)
+    case networkUnavailable
+    case tokenExpired
+    case insufficientPermissions(required: String)
+}
+
+struct AuthToken {
+    let value: String
+    let expiresAt: Date
+    let userID: String
+}
+
+struct Credentials {
+    let username: String
+    let password: String
+}
+
+class AuthService {
+    private var failedAttempts: [String: Int] = [:]
+    private let maxAttempts = 5
+
+    func login(with credentials: Credentials) throws -> AuthToken {
+        guard !credentials.username.isEmpty, !credentials.password.isEmpty else {
+            throw AuthError.invalidCredentials
+        }
+
+        let attempts = failedAttempts[credentials.username, default: 0]
+        if attempts >= maxAttempts {
+            let lockoutEnd = Date().addingTimeInterval(15 * 60)
+            throw AuthError.accountLocked(until: lockoutEnd)
+        }
+
+        guard isReachable() else {
+            throw AuthError.networkUnavailable
+        }
+
+        guard validateCredentials(credentials) else {
+            failedAttempts[credentials.username, default: 0] += 1
+            throw AuthError.invalidCredentials
+        }
+
+        failedAttempts.removeValue(forKey: credentials.username)
+        return AuthToken(
+            value: generateToken(),
+            expiresAt: Date().addingTimeInterval(3600),
+            userID: credentials.username
+        )
+    }
+
+    func validateToken(_ token: AuthToken) throws {
+        guard token.expiresAt > Date() else {
+            throw AuthError.tokenExpired
+        }
+    }
+
+    func requirePermission(_ permission: String, for token: AuthToken) throws {
+        guard hasPermission(permission, userID: token.userID) else {
+            throw AuthError.insufficientPermissions(required: permission)
+        }
+    }
+
+    private func validateCredentials(_ credentials: Credentials) -> Bool { true }
+    private func generateToken() -> String { UUID().uuidString }
+    private func isReachable() -> Bool { true }
+    private func hasPermission(_ permission: String, userID: String) -> Bool { true }
+}
diff --git a/priv/combined_metrics/samples/error_handling/wraps_errors_with_context/bad/repository.go b/priv/combined_metrics/samples/error_handling/wraps_errors_with_context/bad/repository.go
new file mode 100644
index 0000000..18a4ad3
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/wraps_errors_with_context/bad/repository.go
@@ -0,0 +1,50 @@
+package repository
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+)
+
+var ErrNotFound = errors.New("not found")
+
+type Invoice struct {
+	ID         int64
+	CustomerID int64
+	Amount     float64
+}
+
+type InvoiceRepository struct {
+	db *sql.DB
+}
+
+func New(db *sql.DB) *InvoiceRepository {
+	return &InvoiceRepository{db: db}
+}
+
+func (r *InvoiceRepository) FindByID(ctx context.Context, id int64) (*Invoice, error) {
+	row := r.db.QueryRowContext(ctx,
+		`SELECT id, customer_id, amount FROM invoices WHERE id = $1`, id)
+
+	var inv Invoice
+	if err := row.Scan(&inv.ID, &inv.CustomerID, &inv.Amount); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, ErrNotFound
+		}
+		// Returns a new error that discards the original — callers lose all context.
+		return nil, fmt.Errorf("database error")
+	}
+	return &inv, nil
+}
+
+func (r *InvoiceRepository) Save(ctx context.Context, inv *Invoice) error {
+	_, err := r.db.ExecContext(ctx,
+		`INSERT INTO invoices (customer_id, amount) VALUES ($1, $2)`,
+		inv.CustomerID, inv.Amount)
+	if err != nil {
+		// No wrapping, no context — callers see only a bare message.
+		return errors.New("save failed")
+	}
+	return nil
+}
diff --git a/priv/combined_metrics/samples/error_handling/wraps_errors_with_context/good/repository.go b/priv/combined_metrics/samples/error_handling/wraps_errors_with_context/good/repository.go
new file mode 100644
index 0000000..f31e17a
--- /dev/null
+++ b/priv/combined_metrics/samples/error_handling/wraps_errors_with_context/good/repository.go
@@ -0,0 +1,49 @@
+package repository
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+)
+
+var ErrNotFound = errors.New("not found")
+
+type Invoice struct {
+	ID         int64
+	CustomerID int64
+	Amount     float64
+}
+
+type InvoiceRepository struct {
+	db *sql.DB
+}
+
+func New(db *sql.DB) *InvoiceRepository {
+	return &InvoiceRepository{db: db}
+}
+
+func (r *InvoiceRepository) FindByID(ctx context.Context, id int64) (*Invoice, error) {
+	row := r.db.QueryRowContext(ctx,
+		`SELECT id, customer_id, amount FROM invoices WHERE id = $1`, id)
+
+	var inv Invoice
+	if err := row.Scan(&inv.ID, &inv.CustomerID, &inv.Amount); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, fmt.Errorf("find invoice %d: %w", id, ErrNotFound)
+		}
+		// Wraps the database error so callers can inspect it with errors.Is/As.
+		return nil, fmt.Errorf("find invoice %d: %w", id, err)
+	}
+	return &inv, nil
+}
+
+func (r *InvoiceRepository) Save(ctx context.Context, inv *Invoice) error {
+	_, err := r.db.ExecContext(ctx,
+		`INSERT INTO invoices (customer_id, amount) VALUES ($1, $2)`,
+		inv.CustomerID, inv.Amount)
+	if err != nil {
+		return fmt.Errorf("save invoice for customer %d: %w", inv.CustomerID, err)
+	}
+	return nil
+}
diff --git a/priv/combined_metrics/samples/file_structure/has_consistent_indentation/bad/worker.ex b/priv/combined_metrics/samples/file_structure/has_consistent_indentation/bad/worker.ex
new file mode 100644
index 0000000..f11b5cf
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/has_consistent_indentation/bad/worker.ex
@@ -0,0 +1,73 @@
+defmodule Worker do
+  @moduledoc """
+  Background worker for processing queued jobs.
+  """
+
+  def start(queue) do
+    jobs = fetch_jobs(queue)
+    Enum.each(jobs, fn job ->
+        process(job)
+    end)
+  end
+
+  def process(job) do
+      case job.type do
+        :email ->
+          send_email(job)
+        :report ->
+            generate_report(job)
+        _ ->
+          {:error, :unknown_type}
+      end
+  end
+
+  def retry(job, attempts) do
+    if attempts > 0 do
+        case process(job) do
+          :ok -> :ok
+          {:error, _} ->
+              retry(job, attempts - 1)
+        end
+    else
+      {:error, :max_retries_exceeded}
+    end
+  end
+
+  def schedule(job, delay_ms) do
+      Process.send_after(self(), {:run, job}, delay_ms)
+      :ok
+  end
+
+  def cancel(job_id) do
+    case find_job(job_id) do
+        nil ->
+          {:error, :not_found}
+        job ->
+            do_cancel(job)
+    end
+  end
+
+  def status(job_id) do
+      case find_job(job_id) do
+        nil -> {:error, :not_found}
+        job ->
+            {:ok, job.status}
+      end
+  end
+
+  def drain(queue) do
+    jobs = fetch_jobs(queue)
+      Enum.reduce(jobs, {[], []}, fn job, {ok, err} ->
+        case process(job) do
+          :ok -> {[job | ok], err}
+              {:error, _} -> {ok, [job | err]}
+        end
+      end)
+  end
+
+  defp fetch_jobs(_queue), do: []
+  defp send_email(_job), do: :ok
+  defp generate_report(_job), do: :ok
+  defp find_job(_id), do: nil
+  defp do_cancel(_job), do: :ok
+end
diff --git a/priv/combined_metrics/samples/file_structure/has_consistent_indentation/config.yml b/priv/combined_metrics/samples/file_structure/has_consistent_indentation/config.yml
new file mode 100644
index 0000000..f3fd8c4
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/has_consistent_indentation/config.yml
@@ -0,0 +1 @@
+doc: "Files should use a single, consistent indentation style with no mixed tabs and spaces."
diff --git a/priv/combined_metrics/samples/file_structure/has_consistent_indentation/good/worker.ex b/priv/combined_metrics/samples/file_structure/has_consistent_indentation/good/worker.ex
new file mode 100644
index 0000000..7edae97
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/has_consistent_indentation/good/worker.ex
@@ -0,0 +1,67 @@
+defmodule Worker do
+  @moduledoc """
+  Background worker for processing queued jobs.
+  """
+
+  def start(queue) do
+    jobs = fetch_jobs(queue)
+    Enum.each(jobs, fn job ->
+      process(job)
+    end)
+  end
+
+  def process(job) do
+    case job.type do
+      :email -> send_email(job)
+      :report -> generate_report(job)
+      _ -> {:error, :unknown_type}
+    end
+  end
+
+  def retry(job, attempts) do
+    if attempts > 0 do
+      case process(job) do
+        :ok -> :ok
+        {:error, _} -> retry(job, attempts - 1)
+      end
+    else
+      {:error, :max_retries_exceeded}
+    end
+  end
+
+  def schedule(job, delay_ms) do
+    Process.send_after(self(), {:run, job}, delay_ms)
+    :ok
+  end
+
+  def cancel(job_id) do
+    case find_job(job_id) do
+      nil -> {:error, :not_found}
+      job -> do_cancel(job)
+    end
+  end
+
+  def status(job_id) do
+    case find_job(job_id) do
+      nil -> {:error, :not_found}
+      job -> {:ok, job.status}
+    end
+  end
+
+  def drain(queue) do
+    jobs = fetch_jobs(queue)
+
+    Enum.reduce(jobs, {[], []}, fn job, {ok, err} ->
+      case process(job) do
+        :ok -> {[job | ok], err}
+        {:error, _} -> {ok, [job | err]}
+      end
+    end)
+  end
+
+  defp fetch_jobs(_queue), do: []
+  defp send_email(_job), do: :ok
+  defp generate_report(_job), do: :ok
+  defp find_job(_id), do: nil
+  defp do_cancel(_job), do: :ok
+end
diff --git a/priv/combined_metrics/samples/file_structure/headers_have_include_guards/bad/Parser.cpp b/priv/combined_metrics/samples/file_structure/headers_have_include_guards/bad/Parser.cpp
new file mode 100644
index 0000000..bee9773
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/headers_have_include_guards/bad/Parser.cpp
@@ -0,0 +1,121 @@
+// This file demonstrates a translation unit that includes headers WITHOUT
+// include guards. If these headers are included more than once — directly
+// or transitively — the compiler sees duplicate declarations and definitions,
+// causing errors or subtle ODR (One Definition Rule) violations.
+
+// token.h (inline for demonstration — NO include guard)
+// -----------------------------------------------
+// // No #pragma once and no #ifndef guard
+//
+// enum class TokenKind { Identifier, Number, Operator, EndOfStream };
+//
+// struct Token {
+//     TokenKind kind;
+//     std::string value;
+//     int line;
+// };
+// -----------------------------------------------
+
+// parse_error.h (inline for demonstration — NO include guard)
+// -----------------------------------------------
+// // No #pragma once and no #ifndef guard
+//
+// #include <stdexcept>
+// #include <string>
+//
+// // If parse_error.h is included by both Parser.cpp and another header that
+// // Parser.cpp also includes, ParseError is defined twice → compile error.
+// class ParseError : public std::runtime_error {
+// public:
+//     explicit ParseError(const std::string& msg, int line)
+//         : std::runtime_error(msg), line_(line) {}
+//     int line() const noexcept { return line_; }
+// private:
+//     int line_;
+// };
+// -----------------------------------------------
+
+#include <string>
+#include <vector>
+#include <stdexcept>
+
+// Simulated second include of the same unguarded header content:
+// In a real project this happens via transitive includes.
+// Without guards, the declarations below would appear twice — compile error.
+
+enum class TokenKind { Identifier, Number, Operator, EndOfStream };
+
+struct Token {         // first definition
+    TokenKind kind;
+    std::string value;
+    int line;
+};
+
+// struct Token {      ← if the header were included again, this would be a redefinition
+//     TokenKind kind;
+//     std::string value;
+//     int line;
+// };
+
+class ParseError : public std::runtime_error {
+public:
+    explicit ParseError(const std::string& msg, int line)
+        : std::runtime_error(msg), line_(line) {}
+    int line() const noexcept { return line_; }
+private:
+    int line_;
+};
+
+class Parser {
+public:
+    explicit Parser(std::string source)
+        : source_(std::move(source)), pos_(0), currentLine_(1) {}
+
+    std::vector<Token> tokenize() {
+        std::vector<Token> tokens;
+        while (pos_ < source_.size()) {
+            skipWhitespace();
+            if (pos_ >= source_.size()) break;
+
+            char c = source_[pos_];
+            if (std::isalpha(static_cast<unsigned char>(c)))
+                tokens.push_back(readIdentifier());
+            else if (std::isdigit(static_cast<unsigned char>(c)))
+                tokens.push_back(readNumber());
+            else
+                tokens.push_back(readOperator());
+        }
+        tokens.push_back({TokenKind::EndOfStream, "", currentLine_});
+        return tokens;
+    }
+
+private:
+    std::string source_;
+    std::size_t pos_;
+    int currentLine_;
+
+    void skipWhitespace() {
+        while (pos_ < source_.size() && std::isspace(static_cast<unsigned char>(source_[pos_]))) {
+            if (source_[pos_] == '\n') ++currentLine_;
+            ++pos_;
+        }
+    }
+
+    Token readIdentifier() {
+        std::string value;
+        while (pos_ < source_.size() && std::isalnum(static_cast<unsigned char>(source_[pos_])))
+            value += source_[pos_++];
+        return {TokenKind::Identifier, std::move(value), currentLine_};
+    }
+
+    Token readNumber() {
+        std::string value;
+        while (pos_ < source_.size() && std::isdigit(static_cast<unsigned char>(source_[pos_])))
+            value += source_[pos_++];
+        return {TokenKind::Number, std::move(value), currentLine_};
+    }
+
+    Token readOperator() {
+        return {TokenKind::Operator, std::string(1, source_[pos_++]), currentLine_};
+    }
+};
diff --git a/priv/combined_metrics/samples/file_structure/headers_have_include_guards/good/Parser.cpp b/priv/combined_metrics/samples/file_structure/headers_have_include_guards/good/Parser.cpp
new file mode 100644
index 0000000..09df204
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/headers_have_include_guards/good/Parser.cpp
@@ -0,0 +1,116 @@
+// This file demonstrates a translation unit that includes multiple headers,
+// each of which is protected by an include guard (or #pragma once).
+// The guards ensure that even if the same header is transitively included
+// multiple times, its contents are only processed once by the compiler.
+
+// token.h (inline for demonstration)
+// -----------------------------------------------
+// #pragma once                  ← include guard: #pragma once form
+//
+// enum class TokenKind { Identifier, Number, Operator, EndOfStream };
+//
+// struct Token {
+//     TokenKind kind;
+//     std::string value;
+//     int line;
+// };
+// -----------------------------------------------
+
+// parse_error.h (inline for demonstration)
+// -----------------------------------------------
+// #ifndef MYAPP_PARSE_ERROR_H   ← include guard: #define guard form
+// #define MYAPP_PARSE_ERROR_H
+//
+// #include <stdexcept>
+// #include <string>
+//
+// class ParseError : public std::runtime_error {
+// public:
+//     explicit ParseError(const std::string& msg, int line)
+//         : std::runtime_error(msg), line_(line) {}
+//     int line() const noexcept { return line_; }
+// private:
+//     int line_;
+// };
+//
+// #endif // MYAPP_PARSE_ERROR_H
+// -----------------------------------------------
+
+#include <string>
+#include <string_view>
+#include <vector>
+#include <stdexcept>
+
+// Both headers above are guarded; including them multiple times (e.g., via
+// transitive includes) is safe and idiomatic.
+
+enum class TokenKind { Identifier, Number, Operator, EndOfStream };
+
+struct Token {
+    TokenKind kind;
+    std::string value;
+    int line;
+};
+
+class ParseError : public std::runtime_error {
+public:
+    explicit ParseError(const std::string& msg, int line)
+        : std::runtime_error(msg), line_(line) {}
+    int line() const noexcept { return line_; }
+private:
+    int line_;
+};
+
+class Parser {
+public:
+    explicit Parser(std::string source)
+        : source_(std::move(source)), pos_(0), currentLine_(1) {}
+
+    std::vector<Token> tokenize() {
+        std::vector<Token> tokens;
+        while (pos_ < source_.size()) {
+            skipWhitespace();
+            if (pos_ >= source_.size()) break;
+
+            char c = source_[pos_];
+            if (std::isalpha(static_cast<unsigned char>(c)))
+                tokens.push_back(readIdentifier());
+            else if (std::isdigit(static_cast<unsigned char>(c)))
+                tokens.push_back(readNumber());
+            else
+                tokens.push_back(readOperator());
+        }
+        tokens.push_back({TokenKind::EndOfStream, "", currentLine_});
+        return tokens;
+    }
+
+private:
+    std::string source_;
+    std::size_t pos_;
+    int currentLine_;
+
+    void skipWhitespace() {
+        while (pos_ < source_.size() && std::isspace(static_cast<unsigned char>(source_[pos_]))) {
+            if (source_[pos_] == '\n') ++currentLine_;
+            ++pos_;
+        }
+    }
+
+    Token readIdentifier() {
+        std::string value;
+        while (pos_ < source_.size() && std::isalnum(static_cast<unsigned char>(source_[pos_])))
+            value += source_[pos_++];
+        return {TokenKind::Identifier, std::move(value), currentLine_};
+    }
+
+    Token readNumber() {
+        std::string value;
+        while (pos_ < source_.size() && std::isdigit(static_cast<unsigned char>(source_[pos_])))
+            value += source_[pos_++];
+        return {TokenKind::Number, std::move(value), currentLine_};
+    }
+
+    Token readOperator() {
+        return {TokenKind::Operator, std::string(1, source_[pos_++]), currentLine_};
+    }
+};
diff --git a/priv/combined_metrics/samples/file_structure/line_count_under_300/bad/mega_service.ex b/priv/combined_metrics/samples/file_structure/line_count_under_300/bad/mega_service.ex
new file mode 100644
index 0000000..f14f2de
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/line_count_under_300/bad/mega_service.ex
@@ -0,0 +1,130 @@
+defmodule MegaService do
+  @moduledoc "Handles accounts, payments, shipping, and email all in one module."
+  def create_account(email, password) do
+    if String.length(password) < 8, do: {:error, :weak_password}, else: {:ok, %{email: email, password_hash: hash(password), id: generate_id()}}
+  end
+  def update_account(id, attrs) do
+    case find_account(id) do
+      nil -> {:error, :not_found}
+      account -> {:ok, Map.merge(account, attrs)}
+    end
+  end
+  def delete_account(id) do
+    case find_account(id) do
+      nil -> {:error, :not_found}
+      _account -> :ok
+    end
+  end
+  def authenticate(email, password) do
+    case find_by_email(email) do
+      nil -> {:error, :not_found}
+      account -> if verify_password(password, account.password_hash), do: {:ok, account}, else: {:error, :invalid_password}
+    end
+  end
+  def change_password(id, old_password, new_password) do
+    with {:ok, account} <- {:ok, find_account(id)}, true <- verify_password(old_password, account.password_hash), true <- String.length(new_password) >= 8 do
+      {:ok, Map.put(account, :password_hash, hash(new_password))}
+    else
+      _ -> {:error, :password_change_failed}
+    end
+  end
+  def charge_card(account_id, amount_cents, card_token) do
+    if amount_cents <= 0, do: {:error, :invalid_amount}, else: call_payment_gateway(card_token, amount_cents, account_id)
+  end
+  def refund_charge(charge_id, amount_cents) do
+    case find_charge(charge_id) do
+      nil -> {:error, :not_found}
+      charge -> if amount_cents > charge.amount, do: {:error, :exceeds_original}, else: process_refund(charge, amount_cents)
+    end
+  end
+  def create_subscription(account_id, plan) do
+    valid_plans = [:basic, :pro, :enterprise]
+    if plan in valid_plans do
+      {:ok, %{account_id: account_id, plan: plan, started_at: DateTime.utc_now(), billing_cycle: :monthly}}
+    else
+      {:error, :invalid_plan}
+    end
+  end
+  def cancel_subscription(account_id) do
+    case find_subscription(account_id) do
+      nil -> {:error, :no_subscription}
+      sub -> {:ok, Map.put(sub, :cancelled_at, DateTime.utc_now())}
+    end
+  end
+  def apply_coupon(account_id, code) do
+    case lookup_coupon(code) do
+      nil -> {:error, :invalid_coupon}
+      coupon -> if coupon.expired, do: {:error, :expired_coupon}, else: attach_coupon(account_id, coupon)
+    end
+  end
+  def create_shipment(order_id, address) do
+    case find_order(order_id) do
+      nil -> {:error, :order_not_found}
+      order -> {:ok, %{order_id: order.id, address: address, tracking: generate_tracking(), status: :pending}}
+    end
+  end
+  def update_shipment_status(shipment_id, status) do
+    valid_statuses = [:pending, :in_transit, :delivered, :returned]
+    if status in valid_statuses do
+      case find_shipment(shipment_id) do
+        nil -> {:error, :not_found}
+        shipment -> {:ok, Map.put(shipment, :status, status)}
+      end
+    else
+      {:error, :invalid_status}
+    end
+  end
+  def estimate_delivery(shipment_id) do
+    case find_shipment(shipment_id) do
+      nil -> {:error, :not_found}
+      %{status: :delivered} -> {:error, :already_delivered}
+      shipment -> {:ok, calculate_eta(shipment)}
+    end
+  end
+  def cancel_shipment(shipment_id) do
+    case find_shipment(shipment_id) do
+      nil -> {:error, :not_found}
+      %{status: :delivered} -> {:error, :cannot_cancel_delivered}
+      shipment -> {:ok, Map.put(shipment, :status, :cancelled)}
+    end
+  end
+  def send_welcome_email(account_id) do
+    case find_account(account_id) do
+      nil -> {:error, :not_found}
+      account -> dispatch_email(account.email, "Welcome!", welcome_body(account))
+    end
+  end
+  def send_receipt_email(account_id, charge_id) do
+    with account when not is_nil(account) <- find_account(account_id), charge when not is_nil(charge) <- find_charge(charge_id) do
+      dispatch_email(account.email, "Your receipt", receipt_body(charge))
+    else
+      nil -> {:error, :not_found}
+    end
+  end
+  def send_shipment_notification(account_id, shipment_id) do
+    with account when not is_nil(account) <- find_account(account_id), shipment when not is_nil(shipment) <- find_shipment(shipment_id) do
+      dispatch_email(account.email, "Your order shipped!", shipment_body(shipment))
+    else
+      nil -> {:error, :not_found}
+    end
+  end
+  defp hash(password), do: :crypto.hash(:sha256, password)
+  defp generate_id, do: :rand.uniform(1_000_000)
+  defp generate_tracking, do: "TRACK-#{:rand.uniform(999_999)}"
+  defp find_account(_id), do: nil
+  defp find_by_email(_email), do: nil
+  defp verify_password(_pw, _hash), do: true
+  defp call_payment_gateway(_token, _amount, _id), do: {:ok, %{id: generate_id()}}
+  defp find_charge(_id), do: nil
+  defp process_refund(charge, _amount), do: {:ok, charge}
+  defp find_subscription(_id), do: nil
+  defp lookup_coupon(_code), do: nil
+  defp attach_coupon(_id, coupon), do: {:ok, coupon}
+  defp find_order(_id), do: nil
+  defp find_shipment(_id), do: nil
+  defp calculate_eta(_shipment), do: DateTime.add(DateTime.utc_now(), 3 * 24 * 3600)
+  defp dispatch_email(_to, _subject, _body), do: :ok
+  defp welcome_body(account), do: "Welcome #{account.email}"
+  defp receipt_body(charge), do: "Amount: #{charge}"
+  defp shipment_body(shipment), do: "Tracking: #{shipment}"
+end
diff --git a/priv/combined_metrics/samples/file_structure/line_count_under_300/config.yml b/priv/combined_metrics/samples/file_structure/line_count_under_300/config.yml
new file mode 100644
index 0000000..2c19563
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/line_count_under_300/config.yml
@@ -0,0 +1 @@
+doc: "Files should be under 300 lines; longer files typically violate single responsibility."
diff --git a/priv/combined_metrics/samples/file_structure/line_count_under_300/good/order_service.ex b/priv/combined_metrics/samples/file_structure/line_count_under_300/good/order_service.ex
new file mode 100644
index 0000000..761517a
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/line_count_under_300/good/order_service.ex
@@ -0,0 +1,68 @@
+defmodule OrderService do
+  @moduledoc """
+  Manages order lifecycle: creation, updates, and cancellation.
+  """
+
+  alias OrderService.{Order, Repo}
+
+  @spec create_order(map()) :: {:ok, Order.t()} | {:error, String.t()}
+  def create_order(attrs) do
+    with {:ok, validated} <- validate_order_attrs(attrs),
+         {:ok, order} <- Repo.insert(Order, validated) do
+      {:ok, order}
+    end
+  end
+
+  @spec get_order(String.t()) :: {:ok, Order.t()} | {:error, :not_found}
+  def get_order(order_id) do
+    case Repo.find(Order, order_id) do
+      nil -> {:error, :not_found}
+      order -> {:ok, order}
+    end
+  end
+
+  @spec list_orders_for_user(String.t()) :: {:ok, list(Order.t())}
+  def list_orders_for_user(user_id) do
+    orders = Repo.all(Order, user_id: user_id)
+    {:ok, orders}
+  end
+
+  @spec update_order(String.t(), map()) :: {:ok, Order.t()} | {:error, :not_found | String.t()}
+  def update_order(order_id, attrs) do
+    with {:ok, order} <- get_order(order_id),
+         {:ok, validated} <- validate_order_attrs(attrs),
+         {:ok, updated} <- Repo.update(order, validated) do
+      {:ok, updated}
+    end
+  end
+
+  @spec cancel_order(String.t()) :: {:ok, Order.t()} | {:error, :not_found | :already_cancelled}
+  def cancel_order(order_id) do
+    case get_order(order_id) do
+      {:error, :not_found} ->
+        {:error, :not_found}
+      {:ok, %Order{status: :cancelled}} ->
+        {:error, :already_cancelled}
+      {:ok, order} ->
+        Repo.update(order, %{status: :cancelled})
+    end
+  end
+
+  @spec complete_order(String.t()) :: {:ok, Order.t()} | {:error, :not_found | :not_fulfillable}
+  def complete_order(order_id) do
+    with {:ok, order} <- get_order(order_id),
+         :ok <- ensure_fulfillable(order),
+         {:ok, completed} <- Repo.update(order, %{status: :completed}) do
+      {:ok, completed}
+    end
+  end
+
+  defp validate_order_attrs(%{items: items}) when is_list(items) and length(items) > 0 do
+    {:ok, items}
+  end
+
+  defp validate_order_attrs(_), do: {:error, "Order must contain at least one item"}
+
+  defp ensure_fulfillable(%Order{status: :pending}), do: :ok
+  defp ensure_fulfillable(_), do: {:error, :not_fulfillable}
+end
diff --git a/priv/combined_metrics/samples/file_structure/line_length_under_120/bad/query_builder.ex b/priv/combined_metrics/samples/file_structure/line_length_under_120/bad/query_builder.ex
new file mode 100644
index 0000000..5e55bb9
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/line_length_under_120/bad/query_builder.ex
@@ -0,0 +1,46 @@
+defmodule QueryBuilder do
+  @moduledoc """
+  Builds Ecto queries for filtering and sorting records.
+  """
+
+  import Ecto.Query
+
+  def build_user_query(filters) do
+    from(u in "users", where: u.active == true and u.role in ^Map.get(filters, :roles, ["admin", "member", "viewer", "guest"]) and u.inserted_at >= ^Map.get(filters, :since, ~D[2020-01-01]))
+  end
+
+  def build_order_query(user_id, status, date_from, date_to, include_archived) do
+    from(o in "orders", where: o.user_id == ^user_id and o.status == ^status and o.inserted_at >= ^date_from and o.inserted_at <= ^date_to and (^include_archived or o.archived == false), order_by: [desc: o.inserted_at])
+  end
+
+  def build_product_query(filters) do
+    from(p in "products", where: p.price >= ^Map.get(filters, :min_price, 0) and p.price <= ^Map.get(filters, :max_price, 999_999) and p.category in ^Map.get(filters, :categories, []) and p.in_stock == ^Map.get(filters, :in_stock, true), select: %{id: p.id, name: p.name, price: p.price, category: p.category, description: p.description})
+  end
+
+  def paginate(query, page, per_page) do
+    offset = (page - 1) * per_page
+    from(q in query, limit: ^per_page, offset: ^offset)
+  end
+
+  def apply_sort(query, "name_asc"), do: from(q in query, order_by: [asc: q.name])
+  def apply_sort(query, "name_desc"), do: from(q in query, order_by: [desc: q.name])
+  def apply_sort(query, "created_asc"), do: from(q in query, order_by: [asc: q.inserted_at])
+  def apply_sort(query, "created_desc"), do: from(q in query, order_by: [desc: q.inserted_at])
+  def apply_sort(query, _), do: query
+
+  def with_preloads(query, preloads) when is_list(preloads) do
+    Enum.reduce(preloads, query, fn preload, acc -> from(q in acc, preload: ^[preload]) end)
+  end
+
+  def build_report_query(tenant_id, report_type, date_range_start, date_range_end, group_by_field, aggregate_function, having_threshold) do
+    from(r in "report_entries", where: r.tenant_id == ^tenant_id and r.type == ^report_type and r.date >= ^date_range_start and r.date <= ^date_range_end, group_by: ^[group_by_field], having: fragment("? > ?", ^aggregate_function, ^having_threshold))
+  end
+
+  def build_search_query(search_term, fields, opts) do
+    pattern = "%#{String.replace(search_term, "%", "\\%")}%"
+    conditions = Enum.map(fields, fn field -> dynamic([q], ilike(field(q, ^field), ^pattern)) end)
+    combined_condition = Enum.reduce(conditions, fn cond, acc -> dynamic(^acc or ^cond) end)
+    base = from(q in Map.get(opts, :schema, "records"), where: ^combined_condition, limit: ^Map.get(opts, :limit, 50), offset: ^Map.get(opts, :offset, 0))
+    base
+  end
+end
diff --git a/priv/combined_metrics/samples/file_structure/line_length_under_120/config.yml b/priv/combined_metrics/samples/file_structure/line_length_under_120/config.yml
new file mode 100644
index 0000000..42f9df1
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/line_length_under_120/config.yml
@@ -0,0 +1 @@
+doc: "Lines should be under 120 characters to avoid horizontal scrolling."
diff --git a/priv/combined_metrics/samples/file_structure/line_length_under_120/good/query_builder.ex b/priv/combined_metrics/samples/file_structure/line_length_under_120/good/query_builder.ex
new file mode 100644
index 0000000..994e696
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/line_length_under_120/good/query_builder.ex
@@ -0,0 +1,89 @@
+defmodule QueryBuilder do
+  @moduledoc """
+  Builds Ecto queries for filtering and sorting records.
+  """
+
+  import Ecto.Query
+
+  def build_user_query(filters) do
+    roles = Map.get(filters, :roles, ["admin", "member", "viewer"])
+    since = Map.get(filters, :since, ~D[2020-01-01])
+
+    from u in "users",
+      where: u.active == true,
+      where: u.role in ^roles,
+      where: u.inserted_at >= ^since
+  end
+
+  def build_order_query(user_id, status, date_from, date_to, include_archived) do
+    from o in "orders",
+      where: o.user_id == ^user_id,
+      where: o.status == ^status,
+      where: o.inserted_at >= ^date_from,
+      where: o.inserted_at <= ^date_to,
+      where: ^include_archived or o.archived == false,
+      order_by: [desc: o.inserted_at]
+  end
+
+  def build_product_query(filters) do
+    min_price = Map.get(filters, :min_price, 0)
+    max_price = Map.get(filters, :max_price, 999_999)
+    categories = Map.get(filters, :categories, [])
+    in_stock = Map.get(filters, :in_stock, true)
+
+    from p in "products",
+      where: p.price >= ^min_price,
+      where: p.price <= ^max_price,
+      where: p.category in ^categories,
+      where: p.in_stock == ^in_stock,
+      select: %{id: p.id, name: p.name, price: p.price, category: p.category}
+  end
+
+  def paginate(query, page, per_page) do
+    offset = (page - 1) * per_page
+
+    from q in query,
+      limit: ^per_page,
+      offset: ^offset
+  end
+
+  def apply_sort(query, "name_asc"), do: from(q in query, order_by: [asc: q.name])
+  def apply_sort(query, "name_desc"), do: from(q in query, order_by: [desc: q.name])
+  def apply_sort(query, "created_asc"), do: from(q in query, order_by: [asc: q.inserted_at])
+  def apply_sort(query, "created_desc"), do: from(q in query, order_by: [desc: q.inserted_at])
+  def apply_sort(query, _), do: query
+
+  def with_preloads(query, preloads) when is_list(preloads) do
+    Enum.reduce(preloads, query, fn preload, acc ->
+      from q in acc, preload: ^[preload]
+    end)
+  end
+
+  def build_report_query(tenant_id, report_type, date_start, date_end) do
+    from r in "report_entries",
+      where: r.tenant_id == ^tenant_id,
+      where: r.type == ^report_type,
+      where: r.date >= ^date_start,
+      where: r.date <= ^date_end
+  end
+
+  def build_search_query(search_term, fields, opts) do
+    pattern = "%#{String.replace(search_term, "%", "\\%")}%"
+    schema = Map.get(opts, :schema, "records")
+    limit = Map.get(opts, :limit, 50)
+    offset = Map.get(opts, :offset, 0)
+
+    conditions = Enum.map(fields, fn field ->
+      dynamic([q], ilike(field(q, ^field), ^pattern))
+    end)
+
+    combined = Enum.reduce(conditions, fn cond, acc ->
+      dynamic(^acc or ^cond)
+    end)
+
+    from q in schema,
+      where: ^combined,
+      limit: ^limit,
+      offset: ^offset
+  end
+end
diff --git a/priv/combined_metrics/samples/file_structure/no_magic_numbers/bad/rate_limiter.ex b/priv/combined_metrics/samples/file_structure/no_magic_numbers/bad/rate_limiter.ex
new file mode 100644
index 0000000..2a1b738
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/no_magic_numbers/bad/rate_limiter.ex
@@ -0,0 +1,91 @@
+defmodule RateLimiter do
+  @moduledoc """
+  Rate limiting logic for API endpoints.
+  """
+
+  def check_rate(user_id, action) do
+    key = "#{user_id}:#{action}"
+    count = get_count(key)
+
+    cond do
+      action == :api_call and count >= 100 ->
+        {:error, :rate_limited}
+      action == :login and count >= 5 ->
+        {:error, :rate_limited}
+      action == :export and count >= 10 ->
+        {:error, :rate_limited}
+      true ->
+        increment_count(key)
+        :ok
+    end
+  end
+
+  def session_valid?(created_at) do
+    age_seconds = DateTime.diff(DateTime.utc_now(), created_at)
+    age_seconds < 3600
+  end
+
+  def token_expired?(issued_at) do
+    age_seconds = DateTime.diff(DateTime.utc_now(), issued_at)
+    age_seconds > 86400
+  end
+
+  def compute_backoff(attempt) do
+    min(1000 * :math.pow(2, attempt), 30_000)
+  end
+
+  def charge_credits(user_id, action) do
+    cost =
+      case action do
+        :api_call -> 1
+        :export -> 10
+        :bulk_import -> 50
+        :report -> 25
+      end
+
+    balance = get_balance(user_id)
+
+    if balance >= cost do
+      deduct_credits(user_id, cost)
+      :ok
+    else
+      {:error, :insufficient_credits}
+    end
+  end
+
+  def apply_rate_penalty(user_id, violation_count) do
+    penalty_seconds =
+      cond do
+        violation_count >= 10 -> 86400
+        violation_count >= 5 -> 3600
+        violation_count >= 3 -> 300
+        true -> 60
+      end
+
+    lock_until = DateTime.add(DateTime.utc_now(), penalty_seconds)
+    set_lock(user_id, lock_until)
+  end
+
+  def calculate_overage_fee(requests_made, limit) do
+    overage = max(0, requests_made - limit)
+    overage * 0.15
+  end
+
+  def burst_allowed?(user_id) do
+    recent = count_recent_requests(user_id, 60)
+    recent < 200
+  end
+
+  def cleanup_old_entries do
+    cutoff = DateTime.add(DateTime.utc_now(), -604800)
+    delete_entries_before(cutoff)
+  end
+
+  defp get_count(_key), do: 0
+  defp increment_count(_key), do: :ok
+  defp get_balance(_user_id), do: 100
+  defp deduct_credits(_user_id, _amount), do: :ok
+  defp set_lock(_user_id, _until), do: :ok
+  defp count_recent_requests(_user_id, _seconds), do: 0
+  defp delete_entries_before(_cutoff), do: :ok
+end
diff --git a/priv/combined_metrics/samples/file_structure/no_magic_numbers/config.yml b/priv/combined_metrics/samples/file_structure/no_magic_numbers/config.yml
new file mode 100644
index 0000000..dddb8b2
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/no_magic_numbers/config.yml
@@ -0,0 +1 @@
+doc: "Numeric literals should be extracted to named constants rather than used inline."
diff --git a/priv/combined_metrics/samples/file_structure/no_magic_numbers/good/rate_limiter.ex b/priv/combined_metrics/samples/file_structure/no_magic_numbers/good/rate_limiter.ex
new file mode 100644
index 0000000..ecde981
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/no_magic_numbers/good/rate_limiter.ex
@@ -0,0 +1,114 @@
+defmodule RateLimiter do
+  @moduledoc """
+  Rate limiting logic for API endpoints.
+  """
+
+  @api_call_limit 100
+  @login_limit 5
+  @export_limit 10
+
+  @session_ttl_seconds 3_600
+  @token_ttl_seconds 86_400
+  @week_in_seconds 604_800
+
+  @max_backoff_ms 30_000
+  @base_backoff_ms 1_000
+
+  @credit_cost_api_call 1
+  @credit_cost_export 10
+  @credit_cost_bulk_import 50
+  @credit_cost_report 25
+
+  @penalty_minor_seconds 60
+  @penalty_low_seconds 300
+  @penalty_medium_seconds 3_600
+  @penalty_high_seconds 86_400
+
+  @overage_fee_per_request 0.15
+  @burst_window_seconds 60
+  @burst_limit 200
+
+  def check_rate(user_id, action) do
+    key = "#{user_id}:#{action}"
+    count = get_count(key)
+
+    cond do
+      action == :api_call and count >= @api_call_limit ->
+        {:error, :rate_limited}
+      action == :login and count >= @login_limit ->
+        {:error, :rate_limited}
+      action == :export and count >= @export_limit ->
+        {:error, :rate_limited}
+      true ->
+        increment_count(key)
+        :ok
+    end
+  end
+
+  def session_valid?(created_at) do
+    age_seconds = DateTime.diff(DateTime.utc_now(), created_at)
+    age_seconds < @session_ttl_seconds
+  end
+
+  def token_expired?(issued_at) do
+    age_seconds = DateTime.diff(DateTime.utc_now(), issued_at)
+    age_seconds > @token_ttl_seconds
+  end
+
+  def compute_backoff(attempt) do
+    min(@base_backoff_ms * :math.pow(2, attempt), @max_backoff_ms)
+  end
+
+  def charge_credits(user_id, action) do
+    cost = credit_cost(action)
+    balance = get_balance(user_id)
+
+    if balance >= cost do
+      deduct_credits(user_id, cost)
+      :ok
+    else
+      {:error, :insufficient_credits}
+    end
+  end
+
+  def apply_rate_penalty(user_id, violation_count) do
+    penalty_seconds =
+      cond do
+        violation_count >= 10 -> @penalty_high_seconds
+        violation_count >= 5 -> @penalty_medium_seconds
+        violation_count >= 3 -> @penalty_low_seconds
+        true -> @penalty_minor_seconds
+      end
+
+    lock_until = DateTime.add(DateTime.utc_now(), penalty_seconds)
+    set_lock(user_id, lock_until)
+  end
+
+  def calculate_overage_fee(requests_made, limit) do
+    overage = max(0, requests_made - limit)
+    overage * @overage_fee_per_request
+  end
+
+  def burst_allowed?(user_id) do
+    recent = count_recent_requests(user_id, @burst_window_seconds)
+    recent < @burst_limit
+  end
+
+  def cleanup_old_entries do
+    cutoff = DateTime.add(DateTime.utc_now(), -@week_in_seconds)
+    delete_entries_before(cutoff)
+  end
+
+  defp credit_cost(:api_call), do: @credit_cost_api_call
+  defp credit_cost(:export), do: @credit_cost_export
+  defp credit_cost(:bulk_import), do: @credit_cost_bulk_import
+  defp credit_cost(:report), do: @credit_cost_report
+
+  defp get_count(_key), do: 0
+  defp increment_count(_key), do: :ok
+  defp get_balance(_user_id), do: 100
+  defp deduct_credits(_user_id, _amount), do: :ok
+  defp set_lock(_user_id, _until), do: :ok
+  defp count_recent_requests(_user_id, _seconds), do: 0
+  defp delete_entries_before(_cutoff), do: :ok
+end
diff --git a/priv/combined_metrics/samples/file_structure/one_top_level_class_per_file/bad/InvoiceService.java b/priv/combined_metrics/samples/file_structure/one_top_level_class_per_file/bad/InvoiceService.java
new file mode 100644
index 0000000..49c3ca7
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/one_top_level_class_per_file/bad/InvoiceService.java
@@ -0,0 +1,55 @@
+package com.example.billing;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.List;
+
+// Multiple top-level class declarations in a single file
+
+public class InvoiceService {
+
+    private final InvoiceRepository repository;
+    private final TaxCalculator taxCalculator;
+
+    public InvoiceService(InvoiceRepository repository, TaxCalculator taxCalculator) {
+        this.repository = repository;
+        this.taxCalculator = taxCalculator;
+    }
+
+    public Invoice createInvoice(Order order) {
+        List<InvoiceLineItem> lineItems = order.getItems().stream()
+            .map(item -> new InvoiceLineItem(item.getDescription(), item.getUnitPrice(), item.getQuantity()))
+            .toList();
+        return new Invoice(order.getId(), lineItems, LocalDate.now().plusDays(30));
+    }
+}
+
+// Second top-level class in the same file — violates the one-class-per-file rule
+class InvoiceLineItem {
+    private final String description;
+    private final BigDecimal unitPrice;
+    private final int quantity;
+
+    public InvoiceLineItem(String description, BigDecimal unitPrice, int quantity) {
+        this.description = description;
+        this.unitPrice = unitPrice;
+        this.quantity = quantity;
+    }
+
+    public BigDecimal total() {
+        return unitPrice.multiply(BigDecimal.valueOf(quantity));
+    }
+
+    public String getDescription() { return description; }
+    public BigDecimal getUnitPrice() { return unitPrice; }
+    public int getQuantity() { return quantity; }
+}
+
+// Third top-level class in the same file
+class InvoiceValidator {
+    public boolean isValid(Invoice invoice) {
+        return invoice != null
+            && invoice.getId() != null
+            && !invoice.getLineItems().isEmpty();
+    }
+}
diff --git a/priv/combined_metrics/samples/file_structure/one_top_level_class_per_file/good/InvoiceService.java b/priv/combined_metrics/samples/file_structure/one_top_level_class_per_file/good/InvoiceService.java
new file mode 100644
index 0000000..5117698
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/one_top_level_class_per_file/good/InvoiceService.java
@@ -0,0 +1,63 @@
+package com.example.billing;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.List;
+
+/**
+ * Service responsible for creating and managing invoices.
+ * Supporting types (InvoiceLineItem, InvoiceStatus) live in their own files.
+ */
+public class InvoiceService {
+
+    private final InvoiceRepository repository;
+    private final TaxCalculator taxCalculator;
+    private final NotificationService notifications;
+
+    public InvoiceService(
+        InvoiceRepository repository,
+        TaxCalculator taxCalculator,
+        NotificationService notifications
+    ) {
+        this.repository = repository;
+        this.taxCalculator = taxCalculator;
+        this.notifications = notifications;
+    }
+
+    public Invoice createInvoice(Order order) {
+        List<InvoiceLineItem> lineItems = order.getItems().stream()
+            .map(item -> new InvoiceLineItem(item.getDescription(), item.getUnitPrice(), item.getQuantity()))
+            .toList();
+
+        BigDecimal subtotal = lineItems.stream()
+            .map(InvoiceLineItem::total)
+            .reduce(BigDecimal.ZERO, BigDecimal::add);
+
+        BigDecimal tax = taxCalculator.calculate(subtotal, order.getRegion());
+
+        Invoice invoice = new Invoice(
+            order.getId(),
+            lineItems,
+            subtotal,
+            tax,
+            LocalDate.now().plusDays(30)
+        );
+
+        repository.save(invoice);
+        notifications.sendInvoiceCreated(order.getCustomerEmail(), invoice);
+        return invoice;
+    }
+
+    public void markPaid(String invoiceId) {
+        Invoice invoice = repository.findByIdOrThrow(invoiceId);
+        invoice.markPaid();
+        repository.update(invoice);
+        notifications.sendPaymentConfirmation(invoice);
+    }
+
+    public List<Invoice> findOverdue() {
+        return repository.findByDueDateBefore(LocalDate.now()).stream()
+            .filter(inv -> inv.getStatus() == InvoiceStatus.PENDING)
+            .toList();
+    }
+}
diff --git a/priv/combined_metrics/samples/file_structure/single_responsibility/bad/user_handler.ex b/priv/combined_metrics/samples/file_structure/single_responsibility/bad/user_handler.ex
new file mode 100644
index 0000000..8178879
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/single_responsibility/bad/user_handler.ex
@@ -0,0 +1,110 @@
+defmodule UserHandler do
+  @moduledoc """
+  Handles everything user-related: registration, email, payments, and audit.
+  """
+
+  require Logger
+
+  def register_user(attrs) do
+    with {:ok, _} <- validate_registration(attrs),
+         {:ok, user} <- insert_user(attrs),
+         :ok <- send_welcome_email(user),
+         :ok <- create_free_trial_subscription(user),
+         :ok <- log_audit_event(:user_registered, user) do
+      {:ok, user}
+    end
+  end
+
+  def update_user(id, attrs) do
+    case find_user(id) do
+      nil -> {:error, :not_found}
+      user ->
+        updated = Map.merge(user, attrs)
+        save_user(updated)
+        send_profile_updated_email(updated)
+        log_audit_event(:user_updated, updated)
+        {:ok, updated}
+    end
+  end
+
+  def delete_user(id) do
+    case find_user(id) do
+      nil -> {:error, :not_found}
+      user ->
+        cancel_subscription(user)
+        send_goodbye_email(user)
+        remove_user(user)
+        log_audit_event(:user_deleted, user)
+        :ok
+    end
+  end
+
+  def send_welcome_email(user) do
+    body = "Hi #{user.name}, welcome to our platform!"
+    dispatch_email(user.email, "Welcome!", body)
+  end
+
+  def send_profile_updated_email(user) do
+    body = "Hi #{user.name}, your profile has been updated."
+    dispatch_email(user.email, "Profile Updated", body)
+  end
+
+  def send_goodbye_email(user) do
+    body = "Goodbye #{user.name}, your account has been deleted."
+    dispatch_email(user.email, "Account Deleted", body)
+  end
+
+  def create_free_trial_subscription(user) do
+    sub = %{user_id: user.id, plan: :free_trial, expires_at: trial_expiry()}
+    save_subscription(sub)
+    charge_initial_setup_fee(user, 0)
+    :ok
+  end
+
+  def cancel_subscription(user) do
+    case find_subscription(user.id) do
+      nil -> :ok
+      sub ->
+        update_subscription(sub, %{status: :cancelled})
+        process_prorated_refund(user, sub)
+        :ok
+    end
+  end
+
+  def charge_initial_setup_fee(user, amount) do
+    if amount > 0 do
+      call_payment_gateway(user.payment_method, amount)
+    else
+      :ok
+    end
+  end
+
+  def process_prorated_refund(_user, _sub) do
+    :ok
+  end
+
+  def log_audit_event(event, user) do
+    Logger.info("AUDIT: #{event} for user #{user.id} at #{DateTime.utc_now()}")
+    write_audit_log(%{event: event, user_id: user.id, timestamp: DateTime.utc_now()})
+  end
+
+  defp validate_registration(attrs) do
+    if Map.has_key?(attrs, :email) and Map.has_key?(attrs, :password) do
+      {:ok, attrs}
+    else
+      {:error, :missing_fields}
+    end
+  end
+
+  defp find_user(_id), do: nil
+  defp insert_user(attrs), do: {:ok, Map.put(attrs, :id, :rand.uniform(1000))}
+  defp save_user(_user), do: :ok
+  defp remove_user(_user), do: :ok
+  defp dispatch_email(_to, _subject, _body), do: :ok
+  defp save_subscription(_sub), do: :ok
+  defp find_subscription(_user_id), do: nil
+  defp update_subscription(_sub, _attrs), do: :ok
+  defp call_payment_gateway(_method, _amount), do: :ok
+  defp write_audit_log(_entry), do: :ok
+  defp trial_expiry, do: DateTime.add(DateTime.utc_now(), 30 * 86_400)
+end
diff --git a/priv/combined_metrics/samples/file_structure/single_responsibility/config.yml b/priv/combined_metrics/samples/file_structure/single_responsibility/config.yml
new file mode 100644
index 0000000..2497edc
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/single_responsibility/config.yml
@@ -0,0 +1 @@
+doc: "Each file should have one primary concern — low complexity spread across few, focused functions."
diff --git a/priv/combined_metrics/samples/file_structure/single_responsibility/good/user_registration.ex b/priv/combined_metrics/samples/file_structure/single_responsibility/good/user_registration.ex
new file mode 100644
index 0000000..a530341
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/single_responsibility/good/user_registration.ex
@@ -0,0 +1,53 @@
+defmodule UserRegistration do
+  @moduledoc """
+  Handles new user registration: validation and account creation only.
+
+  Side effects (email, billing, audit) are delegated to their respective
+  context modules and triggered via events after successful registration.
+  """
+
+  alias UserRegistration.{Repo, User}
+
+  @spec register(map()) :: {:ok, User.t()} | {:error, :missing_fields | :email_taken | String.t()}
+  def register(attrs) do
+    with {:ok, validated} <- validate(attrs),
+         :ok <- ensure_email_available(validated.email),
+         {:ok, user} <- Repo.insert(User, validated) do
+      {:ok, user}
+    end
+  end
+
+  @spec validate(map()) :: {:ok, map()} | {:error, :missing_fields}
+  def validate(attrs) do
+    required = [:email, :password, :name]
+    missing = Enum.reject(required, &Map.has_key?(attrs, &1))
+
+    if missing == [] do
+      {:ok, attrs}
+    else
+      {:error, :missing_fields}
+    end
+  end
+
+  @spec ensure_email_available(String.t()) :: :ok | {:error, :email_taken}
+  def ensure_email_available(email) do
+    case Repo.find_by(User, email: email) do
+      nil -> :ok
+      _existing -> {:error, :email_taken}
+    end
+  end
+
+  @spec valid_password?(String.t()) :: boolean()
+  def valid_password?(password) do
+    String.length(password) >= 8 and
+      String.match?(password, ~r/[A-Z]/) and
+      String.match?(password, ~r/[0-9]/)
+  end
+
+  @spec normalize_email(String.t()) :: String.t()
+  def normalize_email(email) do
+    email
+    |> String.trim()
+    |> String.downcase()
+  end
+end
diff --git a/priv/combined_metrics/samples/file_structure/uses_standard_indentation_width/bad/mailer.ex b/priv/combined_metrics/samples/file_structure/uses_standard_indentation_width/bad/mailer.ex
new file mode 100644
index 0000000..6a23fc5
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/uses_standard_indentation_width/bad/mailer.ex
@@ -0,0 +1,86 @@
+defmodule Mailer do
+    @moduledoc """
+    Sends transactional emails.
+    """
+
+    @from_address "noreply@example.com"
+
+    def send_welcome(user) do
+        body = build_welcome_body(user)
+        dispatch(%{
+            to: user.email,
+            from: @from_address,
+            subject: "Welcome to the platform",
+            body: body
+        })
+    end
+
+    def send_password_reset(user, token) do
+        link = reset_link(token)
+        body = build_reset_body(user, link)
+        dispatch(%{
+            to: user.email,
+            from: @from_address,
+            subject: "Reset your password",
+            body: body
+        })
+    end
+
+    def send_invoice(user, invoice) do
+        case format_invoice(invoice) do
+            {:ok, formatted} ->
+                dispatch(%{
+                    to: user.email,
+                    from: @from_address,
+                    subject: "Your invoice ##{invoice.id}",
+                    body: formatted
+                })
+            {:error, reason} ->
+                {:error, reason}
+        end
+    end
+
+    def send_notification(user, message) do
+        if String.length(message) > 0 do
+            dispatch(%{
+                to: user.email,
+                from: @from_address,
+                subject: "Notification",
+                body: message
+            })
+        else
+            {:error, :empty_message}
+        end
+    end
+
+    def send_bulk(users, subject, body) do
+        Enum.map(users, fn user ->
+            dispatch(%{
+                to: user.email,
+                from: @from_address,
+                subject: subject,
+                body: body
+            })
+        end)
+    end
+
+    defp build_welcome_body(user) do
+        "Hi #{user.name}, welcome aboard!"
+    end
+
+    defp build_reset_body(user, link) do
+        "Hi #{user.name}, reset your password here: #{link}"
+    end
+
+    defp reset_link(token) do
+        "https://example.com/reset?token=#{token}"
+    end
+
+    defp format_invoice(invoice) do
+        {:ok, "Invoice ##{invoice.id}: $#{invoice.total}"}
+    end
+
+    defp dispatch(email) do
+        {:ok, email}
+    end
+end
diff --git a/priv/combined_metrics/samples/file_structure/uses_standard_indentation_width/config.yml b/priv/combined_metrics/samples/file_structure/uses_standard_indentation_width/config.yml
new file mode 100644
index 0000000..6a6b96b
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/uses_standard_indentation_width/config.yml
@@ -0,0 +1 @@
+doc: "Indentation should use consistent multiples of 2 or 4 spaces throughout the file."
diff --git a/priv/combined_metrics/samples/file_structure/uses_standard_indentation_width/good/mailer.ex b/priv/combined_metrics/samples/file_structure/uses_standard_indentation_width/good/mailer.ex
new file mode 100644
index 0000000..2538478
--- /dev/null
+++ b/priv/combined_metrics/samples/file_structure/uses_standard_indentation_width/good/mailer.ex
@@ -0,0 +1,88 @@
+defmodule Mailer do
+  @moduledoc """
+  Sends transactional emails.
+  """
+
+  @from_address "noreply@example.com"
+
+  def send_welcome(user) do
+    body = build_welcome_body(user)
+
+    dispatch(%{
+      to: user.email,
+      from: @from_address,
+      subject: "Welcome to the platform",
+      body: body
+    })
+  end
+
+  def send_password_reset(user, token) do
+    link = reset_link(token)
+    body = build_reset_body(user, link)
+
+    dispatch(%{
+      to: user.email,
+      from: @from_address,
+      subject: "Reset your password",
+      body: body
+    })
+  end
+
+  def send_invoice(user, invoice) do
+    case format_invoice(invoice) do
+      {:ok, formatted} ->
+        dispatch(%{
+          to: user.email,
+          from: @from_address,
+          subject: "Your invoice ##{invoice.id}",
+          body: formatted
+        })
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  def send_notification(user, message) do
+    if String.length(message) > 0 do
+      dispatch(%{
+        to: user.email,
+        from: @from_address,
+        subject: "Notification",
+        body: message
+      })
+    else
+      {:error, :empty_message}
+    end
+  end
+
+  def send_bulk(users, subject, body) do
+    Enum.map(users, fn user ->
+      dispatch(%{
+        to: user.email,
+        from: @from_address,
+        subject: subject,
+        body: body
+      })
+    end)
+  end
+
+  defp build_welcome_body(user) do
+    "Hi #{user.name}, welcome aboard!"
+  end
+
+  defp build_reset_body(user, link) do
+    "Hi #{user.name}, reset your password here: #{link}"
+  end
+
+  defp reset_link(token) do
+    "https://example.com/reset?token=#{token}"
+  end
+
+  defp format_invoice(invoice) do
+    {:ok, "Invoice ##{invoice.id}: $#{invoice.total}"}
+  end
+
+  defp dispatch(email) do
+    {:ok, email}
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/arrow_functions_as_callbacks/bad/user_service.ts b/priv/combined_metrics/samples/function_design/arrow_functions_as_callbacks/bad/user_service.ts
new file mode 100644
index 0000000..b835058
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/arrow_functions_as_callbacks/bad/user_service.ts
@@ -0,0 +1,68 @@
+interface User {
+  id: string;
+  email: string;
+  displayName: string;
+  role: "admin" | "member";
+  score: number;
+}
+
+class UserService {
+  private readonly baseUrl: string;
+  private readonly defaultPageSize: number;
+
+  constructor(baseUrl: string, defaultPageSize = 20) {
+    this.baseUrl = baseUrl;
+    this.defaultPageSize = defaultPageSize;
+  }
+
+  async fetchUsers(): Promise<User[]> {
+    const response = await fetch(`${this.baseUrl}/users`);
+    return response.json() as Promise<User[]>;
+  }
+
+  async getAdmins(): Promise<User[]> {
+    const users = await this.fetchUsers();
+    // Using function keyword instead of arrow — `this` is unbound inside
+    return users.filter(function (user) {
+      return user.role === "admin";
+    });
+  }
+
+  async getSortedByScore(): Promise<User[]> {
+    const users = await this.fetchUsers();
+    return [...users].sort(function (a, b) {
+      return b.score - a.score;
+    });
+  }
+
+  async getPage(page: number): Promise<User[]> {
+    const users = await this.fetchUsers();
+    const offset = (page - 1) * this.defaultPageSize;
+    return users.slice(offset, offset + this.defaultPageSize);
+  }
+
+  async getDisplayNames(): Promise<string[]> {
+    const users = await this.fetchUsers();
+    return users.map(function (user) {
+      return user.displayName;
+    });
+  }
+
+  async searchByEmail(query: string): Promise<User[]> {
+    const users = await this.fetchUsers();
+    return users.filter(function (user) {
+      return user.email.toLowerCase().includes(query.toLowerCase());
+    });
+  }
+
+  async transformToMap(): Promise<Map<string, User>> {
+    const users = await this.fetchUsers();
+    return users.reduce(function (map, user) {
+      map.set(user.id, user);
+      return map;
+    }, new Map<string, User>());
+  }
+}
+
+export { UserService };
+export type { User };
diff --git a/priv/combined_metrics/samples/function_design/arrow_functions_as_callbacks/good/user_service.ts b/priv/combined_metrics/samples/function_design/arrow_functions_as_callbacks/good/user_service.ts
new file mode 100644
index 0000000..cc00697
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/arrow_functions_as_callbacks/good/user_service.ts
@@ -0,0 +1,61 @@
+interface User {
+  id: string;
+  email: string;
+  displayName: string;
+  role: "admin" | "member";
+  score: number;
+}
+
+class UserService {
+  private readonly baseUrl: string;
+  private readonly defaultPageSize: number;
+
+  constructor(baseUrl: string, defaultPageSize = 20) {
+    this.baseUrl = baseUrl;
+    this.defaultPageSize = defaultPageSize;
+  }
+
+  async fetchUsers(): Promise<User[]> {
+    const response = await fetch(`${this.baseUrl}/users`);
+    return response.json() as Promise<User[]>;
+  }
+
+  async getAdmins(): Promise<User[]> {
+    const users = await this.fetchUsers();
+    return users.filter((user) => user.role === "admin");
+  }
+
+  async getSortedByScore(): Promise<User[]> {
+    const users = await this.fetchUsers();
+    return [...users].sort((a, b) => b.score - a.score);
+  }
+
+  async getPage(page: number): Promise<User[]> {
+    const users = await this.fetchUsers();
+    const offset = (page - 1) * this.defaultPageSize;
+    return users.slice(offset, offset + this.defaultPageSize);
+  }
+
+  async getDisplayNames(): Promise<string[]> {
+    const users = await this.fetchUsers();
+    return users.map((user) => user.displayName);
+  }
+
+  async searchByEmail(query: string): Promise<User[]> {
+    const users = await this.fetchUsers();
+    return users.filter((user) =>
+      user.email.toLowerCase().includes(query.toLowerCase())
+    );
+  }
+
+  async transformToMap(): Promise<Map<string, User>> {
+    const users = await this.fetchUsers();
+    return users.reduce((map, user) => {
+      map.set(user.id, user);
+      return map;
+    }, new Map<string, User>());
+  }
+}
+
+export { UserService };
+export type { User };
diff --git a/priv/combined_metrics/samples/function_design/async_functions_contain_await/bad/payment_gateway.ts b/priv/combined_metrics/samples/function_design/async_functions_contain_await/bad/payment_gateway.ts
new file mode 100644
index 0000000..657baaf
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/async_functions_contain_await/bad/payment_gateway.ts
@@ -0,0 +1,69 @@
+interface ChargeRequest {
+  amount: number;
+  currency: string;
+  paymentMethodId: string;
+  description: string;
+}
+
+interface ChargeResult {
+  chargeId: string;
+  status: "succeeded" | "pending" | "failed";
+  amount: number;
+  currency: string;
+}
+
+// async but no await — just wraps a synchronous value
+async function buildChargeRequest(
+  paymentMethodId: string,
+  amount: number,
+  currency: string
+): Promise<ChargeRequest> {
+  return {
+    amount,
+    currency,
+    paymentMethodId,
+    description: `Charge of ${amount} ${currency}`,
+  };
+}
+
+// async but no await — validation is synchronous
+async function validateChargeRequest(request: ChargeRequest): Promise<boolean> {
+  if (request.amount <= 0) return false;
+  if (!request.paymentMethodId) return false;
+  if (!request.currency) return false;
+  return true;
+}
+
+// async but no await — just rethrows synchronously
+async function assertPositiveAmount(amount: number): Promise<void> {
+  if (amount <= 0) {
+    throw new Error(`Amount must be positive, got ${amount}`);
+  }
+}
+
+async function createCharge(request: ChargeRequest): Promise<ChargeResult> {
+  const response = await fetch("/api/charges", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Charge failed with status ${response.status}`);
+  }
+
+  return response.json() as Promise<ChargeResult>;
+}
+
+// async but only returns a promise chain without await
+async function fetchAndLogCharge(chargeId: string): Promise<ChargeResult> {
+  return fetch(`/api/charges/${chargeId}`)
+    .then((r) => r.json() as Promise<ChargeResult>)
+    .then((charge) => {
+      console.log("Fetched charge", charge.chargeId);
+      return charge;
+    });
+}
+
+export { buildChargeRequest, validateChargeRequest, assertPositiveAmount, createCharge, fetchAndLogCharge };
+export type { ChargeRequest, ChargeResult };
diff --git a/priv/combined_metrics/samples/function_design/async_functions_contain_await/good/payment_gateway.ts b/priv/combined_metrics/samples/function_design/async_functions_contain_await/good/payment_gateway.ts
new file mode 100644
index 0000000..b07cdbd
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/async_functions_contain_await/good/payment_gateway.ts
@@ -0,0 +1,75 @@
+interface ChargeRequest {
+  amount: number;
+  currency: string;
+  paymentMethodId: string;
+  description: string;
+}
+
+interface ChargeResult {
+  chargeId: string;
+  status: "succeeded" | "pending" | "failed";
+  amount: number;
+  currency: string;
+}
+
+async function createCharge(request: ChargeRequest): Promise<ChargeResult> {
+  const response = await fetch("/api/charges", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Charge failed with status ${response.status}`);
+  }
+
+  return response.json() as Promise<ChargeResult>;
+}
+
+async function fetchCharge(chargeId: string): Promise<ChargeResult> {
+  const response = await fetch(`/api/charges/${chargeId}`);
+
+  if (!response.ok) {
+    throw new Error(`Charge not found: ${chargeId}`);
+  }
+
+  return response.json() as Promise<ChargeResult>;
+}
+
+async function waitForChargeSettlement(
+  chargeId: string,
+  maxAttempts = 10
+): Promise<ChargeResult> {
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const charge = await fetchCharge(chargeId);
+
+    if (charge.status === "succeeded" || charge.status === "failed") {
+      return charge;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 2000 * (attempt + 1)));
+  }
+
+  throw new Error(`Charge ${chargeId} did not settle after ${maxAttempts} attempts`);
+}
+
+async function processPaymentWithRetry(
+  request: ChargeRequest,
+  maxRetries = 3
+): Promise<ChargeResult> {
+  let lastError: Error | null = null;
+
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      const charge = await createCharge(request);
+      return await waitForChargeSettlement(charge.chargeId);
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+    }
+  }
+
+  throw lastError ?? new Error("Payment failed after retries");
+}
+
+export { createCharge, fetchCharge, waitForChargeSettlement, processPaymentWithRetry };
+export type { ChargeRequest, ChargeResult };
diff --git a/priv/combined_metrics/samples/function_design/async_method_has_await/bad/EmailDispatcher.cs b/priv/combined_metrics/samples/function_design/async_method_has_await/bad/EmailDispatcher.cs
new file mode 100644
index 0000000..d82401d
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/async_method_has_await/bad/EmailDispatcher.cs
@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace Email
+{
+    public class EmailDispatcher
+    {
+        private readonly HttpClient _httpClient;
+        private readonly string _apiEndpoint;
+
+        public EmailDispatcher(HttpClient httpClient, string apiEndpoint)
+        {
+            _httpClient = httpClient;
+            _apiEndpoint = apiEndpoint;
+        }
+
+        // async keyword with no await — compiles with a warning; runs synchronously
+        public async Task<SendResult> SendAsync(EmailMessage message)
+        {
+            var payload = JsonSerializer.Serialize(message);
+            var content = new StringContent(payload, System.Text.Encoding.UTF8, "application/json");
+
+            // Missing await — blocks synchronously, defeats the purpose of async
+            var response = _httpClient.PostAsync(_apiEndpoint, content).Result;
+            var body = response.Content.ReadAsStringAsync().Result;
+
+            return response.IsSuccessStatusCode
+                ? SendResult.Success()
+                : SendResult.Failure(body);
+        }
+
+        // async but delegates all work to non-awaited helpers — no suspension point
+        public async Task<bool> PingAsync()
+        {
+            return CheckPing(); // synchronous; async here adds overhead with no benefit
+        }
+
+        // async method that just wraps a completed task — should not be async
+        public async Task<string> GetApiEndpointAsync()
+        {
+            return _apiEndpoint; // no await, just returns a value
+        }
+
+        // async that does no I/O at all — the async machinery is pure overhead
+        public async Task LogMetricsAsync(int sent, int failed)
+        {
+            var summary = $"Sent: {sent}, Failed: {failed}";
+            System.Console.WriteLine(summary);
+        }
+
+        private bool CheckPing()
+        {
+            var response = _httpClient.GetAsync(_apiEndpoint + "/ping").Result;
+            return response.IsSuccessStatusCode;
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/function_design/async_method_has_await/good/EmailDispatcher.cs b/priv/combined_metrics/samples/function_design/async_method_has_await/good/EmailDispatcher.cs
new file mode 100644
index 0000000..6480e69
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/async_method_has_await/good/EmailDispatcher.cs
@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace Email
+{
+    public class EmailDispatcher
+    {
+        private readonly HttpClient _httpClient;
+        private readonly string _apiEndpoint;
+
+        public EmailDispatcher(HttpClient httpClient, string apiEndpoint)
+        {
+            _httpClient = httpClient;
+            _apiEndpoint = apiEndpoint;
+        }
+
+        public async Task<SendResult> SendAsync(EmailMessage message)
+        {
+            var payload = JsonSerializer.Serialize(message);
+            var content = new StringContent(payload, System.Text.Encoding.UTF8, "application/json");
+
+            // Contains genuine await — truly async I/O operation
+            var response = await _httpClient.PostAsync(_apiEndpoint, content);
+            var body = await response.Content.ReadAsStringAsync();
+
+            return response.IsSuccessStatusCode
+                ? SendResult.Success()
+                : SendResult.Failure(body);
+        }
+
+        public async Task<IReadOnlyList<SendResult>> SendBatchAsync(IEnumerable<EmailMessage> messages)
+        {
+            var tasks = new List<Task<SendResult>>();
+            foreach (var message in messages)
+                tasks.Add(SendAsync(message));
+
+            // Awaits all concurrent I/O operations
+            var results = await Task.WhenAll(tasks);
+            return results;
+        }
+
+        public async Task<bool> PingAsync()
+        {
+            // Contains await — not just wrapping sync work
+            var response = await _httpClient.GetAsync(_apiEndpoint + "/ping");
+            return response.IsSuccessStatusCode;
+        }
+
+        public async Task<EmailQuota> GetRemainingQuotaAsync()
+        {
+            var response = await _httpClient.GetAsync(_apiEndpoint + "/quota");
+            response.EnsureSuccessStatusCode();
+            var json = await response.Content.ReadAsStringAsync();
+            return JsonSerializer.Deserialize<EmailQuota>(json)!;
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/function_design/boolean_function_has_question_mark/bad/guards.ex b/priv/combined_metrics/samples/function_design/boolean_function_has_question_mark/bad/guards.ex
new file mode 100644
index 0000000..eb9fb04
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/boolean_function_has_question_mark/bad/guards.ex
@@ -0,0 +1,41 @@
+defmodule Guards do
+  def valid(value) when is_binary(value) do
+    String.length(value) > 0
+  end
+
+  def active(user) do
+    user.status == :active && !user.banned
+  end
+
+  def empty(list) when is_list(list) do
+    length(list) == 0
+  end
+
+  def expired(token) do
+    DateTime.compare(token.expires_at, DateTime.utc_now()) == :lt
+  end
+
+  def admin(user) do
+    user.role == :admin
+  end
+
+  def verified(user) do
+    user.email_verified && user.phone_verified
+  end
+
+  def authorized(user, resource) do
+    user.role == :admin || resource.owner_id == user.id
+  end
+
+  def pending(order) do
+    order.status == :pending
+  end
+
+  def within_limit(count, limit) do
+    count < limit
+  end
+
+  def matching(a, b) do
+    a == b
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/boolean_function_has_question_mark/config.yml b/priv/combined_metrics/samples/function_design/boolean_function_has_question_mark/config.yml
new file mode 100644
index 0000000..87e5ea3
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/boolean_function_has_question_mark/config.yml
@@ -0,0 +1 @@
+doc: "Functions returning a boolean should end with `?` (Elixir/Ruby) or start with `is_`/`has_` (JS/Python)."
diff --git a/priv/combined_metrics/samples/function_design/boolean_function_has_question_mark/good/guards.ex b/priv/combined_metrics/samples/function_design/boolean_function_has_question_mark/good/guards.ex
new file mode 100644
index 0000000..bb5c168
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/boolean_function_has_question_mark/good/guards.ex
@@ -0,0 +1,41 @@
+defmodule Guards do
+  def valid?(value) when is_binary(value) do
+    String.length(value) > 0
+  end
+
+  def active?(user) do
+    user.status == :active && !user.banned
+  end
+
+  def empty?(list) when is_list(list) do
+    length(list) == 0
+  end
+
+  def expired?(token) do
+    DateTime.compare(token.expires_at, DateTime.utc_now()) == :lt
+  end
+
+  def admin?(user) do
+    user.role == :admin
+  end
+
+  def verified?(user) do
+    user.email_verified && user.phone_verified
+  end
+
+  def authorized?(user, resource) do
+    user.role == :admin || resource.owner_id == user.id
+  end
+
+  def pending?(order) do
+    order.status == :pending
+  end
+
+  def within_limit?(count, limit) do
+    count < limit
+  end
+
+  def matching?(a, b) do
+    a == b
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/call_site_forms_grammatical_phrase/bad/EventHandler.swift b/priv/combined_metrics/samples/function_design/call_site_forms_grammatical_phrase/bad/EventHandler.swift
new file mode 100644
index 0000000..e6eca29
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/call_site_forms_grammatical_phrase/bad/EventHandler.swift
@@ -0,0 +1,56 @@
+import Foundation
+
+enum EventPriority: Int, Comparable {
+    case low = 0, normal = 1, high = 2, critical = 3
+
+    static func < (lhs: EventPriority, rhs: EventPriority) -> Bool {
+        return lhs.rawValue < rhs.rawValue
+    }
+}
+
+struct AppEvent {
+    let name: String
+    let payload: [String: Any]
+    let priority: EventPriority
+    let occurredAt: Date
+}
+
+typealias EventCallback = (AppEvent) -> Void
+
+class EventBus {
+    private var handlers: [String: [EventCallback]] = [:]
+    private var filters: [String: (AppEvent) -> Bool] = [:]
+
+    // Reads awkwardly: eventBus.handlerRegistration(callback, eventName: "purchase")
+    func handlerRegistration(_ callback: @escaping EventCallback, eventName: String) {
+        handlers[eventName, default: []].append(callback)
+    }
+
+    // Reads awkwardly: eventBus.handlerRemoval(eventName: "purchase")
+    func handlerRemoval(eventName: String) {
+        handlers.removeValue(forKey: eventName)
+    }
+
+    // Reads awkwardly: eventBus.eventPublishing(event)
+    func eventPublishing(_ event: AppEvent) {
+        guard let eventHandlers = handlers[event.name] else { return }
+        let passes = filters[event.name].map { $0(event) } ?? true
+        guard passes else { return }
+        eventHandlers.forEach { $0(event) }
+    }
+
+    // Reads awkwardly: eventBus.filterAddition(predicate, eventName: "purchase")
+    func filterAddition(_ predicate: @escaping (AppEvent) -> Bool, eventName: String) {
+        filters[eventName] = predicate
+    }
+
+    // Reads awkwardly: eventBus.subscriptionCheck(eventName: "purchase")
+    func subscriptionCheck(eventName: String) -> Bool {
+        return handlers[eventName]?.isEmpty == false
+    }
+
+    // Reads awkwardly: eventBus.priorityFiltering(priority: .critical, log: events)
+    func priorityFiltering(priority: EventPriority, log: [AppEvent]) -> [AppEvent] {
+        return log.filter { $0.priority >= priority }
+    }
+}
diff --git a/priv/combined_metrics/samples/function_design/call_site_forms_grammatical_phrase/good/EventHandler.swift b/priv/combined_metrics/samples/function_design/call_site_forms_grammatical_phrase/good/EventHandler.swift
new file mode 100644
index 0000000..9a7a356
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/call_site_forms_grammatical_phrase/good/EventHandler.swift
@@ -0,0 +1,56 @@
+import Foundation
+
+enum EventPriority: Int, Comparable {
+    case low = 0, normal = 1, high = 2, critical = 3
+
+    static func < (lhs: EventPriority, rhs: EventPriority) -> Bool {
+        return lhs.rawValue < rhs.rawValue
+    }
+}
+
+struct AppEvent {
+    let name: String
+    let payload: [String: Any]
+    let priority: EventPriority
+    let occurredAt: Date
+}
+
+typealias EventHandler = (AppEvent) -> Void
+
+class EventBus {
+    private var handlers: [String: [EventHandler]] = [:]
+    private var filters: [String: (AppEvent) -> Bool] = [:]
+
+    // Reads naturally: eventBus.register(handler, for: "purchase")
+    func register(_ handler: @escaping EventHandler, for eventName: String) {
+        handlers[eventName, default: []].append(handler)
+    }
+
+    // Reads naturally: eventBus.remove(handlers, for: "purchase")
+    func removeHandlers(for eventName: String) {
+        handlers.removeValue(forKey: eventName)
+    }
+
+    // Reads naturally: eventBus.publish(event)
+    func publish(_ event: AppEvent) {
+        guard let eventHandlers = handlers[event.name] else { return }
+        let passesFiler = filters[event.name].map { $0(event) } ?? true
+        guard passesFiler else { return }
+        eventHandlers.forEach { $0(event) }
+    }
+
+    // Reads naturally: eventBus.addFilter(predicate, for: "purchase")
+    func addFilter(_ predicate: @escaping (AppEvent) -> Bool, for eventName: String) {
+        filters[eventName] = predicate
+    }
+
+    // Reads naturally: eventBus.isSubscribed(to: "purchase")
+    func isSubscribed(to eventName: String) -> Bool {
+        return handlers[eventName]?.isEmpty == false
+    }
+
+    // Reads naturally: eventBus.events(with priority: .critical)
+    func events(with priority: EventPriority, from log: [AppEvent]) -> [AppEvent] {
+        return log.filter { $0.priority >= priority }
+    }
+}
diff --git a/priv/combined_metrics/samples/function_design/context_is_first_parameter/bad/mailer.go b/priv/combined_metrics/samples/function_design/context_is_first_parameter/bad/mailer.go
new file mode 100644
index 0000000..5b99bd2
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/context_is_first_parameter/bad/mailer.go
@@ -0,0 +1,60 @@
+package mailer
+
+import (
+	"context"
+	"fmt"
+	"net/smtp"
+)
+
+// Message is an outbound email.
+type Message struct {
+	To      string
+	Subject string
+	Body    string
+}
+
+// SMTPMailer sends email over SMTP.
+type SMTPMailer struct {
+	host string
+	port int
+	from string
+	auth smtp.Auth
+}
+
+// New constructs an SMTPMailer.
+func New(host string, port int, from string, auth smtp.Auth) *SMTPMailer {
+	return &SMTPMailer{host: host, port: port, from: from, auth: auth}
+}
+
+// Send delivers a message. ctx is passed last and named "context" — both
+// violate Go conventions: context must be first and named ctx.
+func (m *SMTPMailer) Send(msg Message, context context.Context) error {
+	if context.Err() != nil {
+		return fmt.Errorf("send email: context already done: %w", context.Err())
+	}
+
+	addr := fmt.Sprintf("%s:%d", m.host, m.port)
+	body := fmt.Sprintf("From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n%s",
+		m.from, msg.To, msg.Subject, msg.Body)
+
+	if err := smtp.SendMail(addr, m.auth, m.from, []string{msg.To}, []byte(body)); err != nil {
+		return fmt.Errorf("send email to %q: %w", msg.To, err)
+	}
+	return nil
+}
+
+// SendBulk delivers multiple messages. ctx is in the middle — inconsistent
+// with the convention that context is always the first parameter.
+func (m *SMTPMailer) SendBulk(msgs []Message, ctx context.Context, stopOnError bool) error {
+	for _, msg := range msgs {
+		if ctx.Err() != nil {
+			return fmt.Errorf("send bulk: %w", ctx.Err())
+		}
+		if err := m.Send(msg, ctx); err != nil {
+			if stopOnError {
+				return err
+			}
+		}
+	}
+	return nil
+}
diff --git a/priv/combined_metrics/samples/function_design/context_is_first_parameter/good/mailer.go b/priv/combined_metrics/samples/function_design/context_is_first_parameter/good/mailer.go
new file mode 100644
index 0000000..585c524
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/context_is_first_parameter/good/mailer.go
@@ -0,0 +1,57 @@
+package mailer
+
+import (
+	"context"
+	"fmt"
+	"net/smtp"
+)
+
+// Message is an outbound email.
+type Message struct {
+	To      string
+	Subject string
+	Body    string
+}
+
+// SMTPMailer sends email over SMTP.
+type SMTPMailer struct {
+	host string
+	port int
+	from string
+	auth smtp.Auth
+}
+
+// New constructs an SMTPMailer.
+func New(host string, port int, from string, auth smtp.Auth) *SMTPMailer {
+	return &SMTPMailer{host: host, port: port, from: from, auth: auth}
+}
+
+// Send delivers a message. ctx is the first parameter, named ctx — idiomatic Go.
+func (m *SMTPMailer) Send(ctx context.Context, msg Message) error {
+	if ctx.Err() != nil {
+		return fmt.Errorf("send email: context already done: %w", ctx.Err())
+	}
+
+	addr := fmt.Sprintf("%s:%d", m.host, m.port)
+	body := fmt.Sprintf("From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n%s",
+		m.from, msg.To, msg.Subject, msg.Body)
+
+	if err := smtp.SendMail(addr, m.auth, m.from, []string{msg.To}, []byte(body)); err != nil {
+		return fmt.Errorf("send email to %q: %w", msg.To, err)
+	}
+	return nil
+}
+
+// SendBulk delivers multiple messages, stopping if the context is cancelled.
+// ctx is the first parameter on every method that does I/O.
+func (m *SMTPMailer) SendBulk(ctx context.Context, msgs []Message) error {
+	for _, msg := range msgs {
+		if ctx.Err() != nil {
+			return fmt.Errorf("send bulk: %w", ctx.Err())
+		}
+		if err := m.Send(ctx, msg); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/priv/combined_metrics/samples/function_design/cyclomatic_complexity_under_10/bad/order_processor.ex b/priv/combined_metrics/samples/function_design/cyclomatic_complexity_under_10/bad/order_processor.ex
new file mode 100644
index 0000000..b73b804
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/cyclomatic_complexity_under_10/bad/order_processor.ex
@@ -0,0 +1,52 @@
+defmodule OrderProcessor do
+  def process(order) do
+    cond do
+      order.status == :new && order.payment_method == :card && order.total > 0 ->
+        if order.user.verified do
+          if order.items != [] do
+            case charge_card(order) do
+              {:ok, charge} ->
+                if order.total > 1000 do
+                  notify_fraud_team(order)
+                end
+                {:ok, %{order | status: :paid, charge_id: charge.id}}
+              {:error, :declined} ->
+                {:error, :payment_declined}
+              {:error, _} ->
+                {:error, :payment_failed}
+            end
+          else
+            {:error, :empty_order}
+          end
+        else
+          {:error, :unverified_user}
+        end
+
+      order.status == :new && order.payment_method == :invoice ->
+        if order.user.credit_approved do
+          {:ok, %{order | status: :invoiced}}
+        else
+          {:error, :credit_not_approved}
+        end
+
+      order.status == :paid ->
+        if order.shipment_address != nil do
+          {:ok, %{order | status: :shipped}}
+        else
+          {:error, :no_address}
+        end
+
+      order.status == :shipped ->
+        {:ok, %{order | status: :delivered}}
+
+      order.status == :cancelled ->
+        {:error, :already_cancelled}
+
+      true ->
+        {:error, :invalid_transition}
+    end
+  end
+
+  defp charge_card(order), do: {:ok, %{id: "ch_#{order.id}"}}
+  defp notify_fraud_team(order), do: IO.puts("Fraud check: #{order.id}")
+end
diff --git a/priv/combined_metrics/samples/function_design/cyclomatic_complexity_under_10/config.yml b/priv/combined_metrics/samples/function_design/cyclomatic_complexity_under_10/config.yml
new file mode 100644
index 0000000..bdf1f44
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/cyclomatic_complexity_under_10/config.yml
@@ -0,0 +1 @@
+doc: "Functions should have a cyclomatic complexity under 10."
diff --git a/priv/combined_metrics/samples/function_design/cyclomatic_complexity_under_10/good/order_processor.ex b/priv/combined_metrics/samples/function_design/cyclomatic_complexity_under_10/good/order_processor.ex
new file mode 100644
index 0000000..2ceae99
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/cyclomatic_complexity_under_10/good/order_processor.ex
@@ -0,0 +1,50 @@
+defmodule OrderProcessor do
+  def process(%{status: :new, payment_method: :card} = order) do
+    with :ok <- verify_user(order),
+         :ok <- require_items(order),
+         {:ok, charge} <- charge_card(order) do
+      maybe_alert_fraud(order)
+      {:ok, %{order | status: :paid, charge_id: charge.id}}
+    end
+  end
+
+  def process(%{status: :new, payment_method: :invoice} = order) do
+    if order.user.credit_approved do
+      {:ok, %{order | status: :invoiced}}
+    else
+      {:error, :credit_not_approved}
+    end
+  end
+
+  def process(%{status: :paid} = order) do
+    case order.shipment_address do
+      nil -> {:error, :no_address}
+      _ -> {:ok, %{order | status: :shipped}}
+    end
+  end
+
+  def process(%{status: :shipped} = order) do
+    {:ok, %{order | status: :delivered}}
+  end
+
+  def process(%{status: :cancelled}) do
+    {:error, :already_cancelled}
+  end
+
+  def process(_order), do: {:error, :invalid_transition}
+
+  defp verify_user(%{user: %{verified: true}}), do: :ok
+  defp verify_user(_), do: {:error, :unverified_user}
+
+  defp require_items(%{items: []}), do: {:error, :empty_order}
+  defp require_items(_), do: :ok
+
+  defp maybe_alert_fraud(%{total: total} = order) when total > 1000 do
+    notify_fraud_team(order)
+  end
+
+  defp maybe_alert_fraud(_order), do: :ok
+
+  defp charge_card(order), do: {:ok, %{id: "ch_#{order.id}"}}
+  defp notify_fraud_team(order), do: IO.puts("Fraud check: #{order.id}")
+end
diff --git a/priv/combined_metrics/samples/function_design/default_parameters_placed_at_end/bad/EmailComposer.swift b/priv/combined_metrics/samples/function_design/default_parameters_placed_at_end/bad/EmailComposer.swift
new file mode 100644
index 0000000..04475b5
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/default_parameters_placed_at_end/bad/EmailComposer.swift
@@ -0,0 +1,64 @@
+import Foundation
+
+struct EmailMessage {
+    let to: [String]
+    let subject: String
+    let body: String
+    let cc: [String]
+    let bcc: [String]
+    let isHTML: Bool
+    let attachments: [URL]
+}
+
+class EmailComposer {
+
+    // Default parameters intermixed with required ones, making call sites confusing
+    func compose(
+        cc: [String] = [],           // default before required params
+        to recipients: [String],      // required
+        isHTML: Bool = false,         // default before more required params
+        subject: String,              // required
+        attachments: [URL] = [],      // default
+        body: String,                 // required — buried after defaults
+        bcc: [String] = []
+    ) -> EmailMessage {
+        return EmailMessage(
+            to: recipients,
+            subject: subject,
+            body: body,
+            cc: cc,
+            bcc: bcc,
+            isHTML: isHTML,
+            attachments: attachments
+        )
+    }
+
+    // Default parameter (includeGettingStartedGuide) appears before required "name"
+    func sendWelcome(
+        to recipient: String,
+        includeGettingStartedGuide: Bool = true,  // default before required
+        name: String,                              // required after default
+        replyTo: String? = nil
+    ) -> EmailMessage {
+        let body = includeGettingStartedGuide
+            ? "Welcome, \(name)! Check out our getting started guide."
+            : "Welcome, \(name)!"
+
+        var bcc: [String] = []
+        if let replyAddress = replyTo {
+            bcc.append(replyAddress)
+        }
+
+        return EmailMessage(to: [recipient], subject: "Welcome!", body: body, cc: [], bcc: bcc, isHTML: false, attachments: [])
+    }
+
+    // Default "retryCount" before required "date"
+    func scheduleDelivery(
+        for message: EmailMessage,
+        retryCount: Int = 3,        // default before required
+        at date: Date,              // required after default
+        retryDelay: TimeInterval = 60
+    ) {
+        _ = (message, date, retryCount, retryDelay)
+    }
+}
diff --git a/priv/combined_metrics/samples/function_design/default_parameters_placed_at_end/good/EmailComposer.swift b/priv/combined_metrics/samples/function_design/default_parameters_placed_at_end/good/EmailComposer.swift
new file mode 100644
index 0000000..167e085
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/default_parameters_placed_at_end/good/EmailComposer.swift
@@ -0,0 +1,64 @@
+import Foundation
+
+struct EmailMessage {
+    let to: [String]
+    let subject: String
+    let body: String
+    let cc: [String]
+    let bcc: [String]
+    let isHTML: Bool
+    let attachments: [URL]
+}
+
+class EmailComposer {
+
+    // Required parameters first, defaults at the end
+    func compose(
+        to recipients: [String],
+        subject: String,
+        body: String,
+        cc: [String] = [],
+        bcc: [String] = [],
+        isHTML: Bool = false,
+        attachments: [URL] = []
+    ) -> EmailMessage {
+        return EmailMessage(
+            to: recipients,
+            subject: subject,
+            body: body,
+            cc: cc,
+            bcc: bcc,
+            isHTML: isHTML,
+            attachments: attachments
+        )
+    }
+
+    // Required parameter first, optional config at end
+    func sendWelcome(
+        to recipient: String,
+        name: String,
+        includeGettingStartedGuide: Bool = true,
+        replyTo: String? = nil
+    ) -> EmailMessage {
+        let body = includeGettingStartedGuide
+            ? "Welcome, \(name)! Check out our getting started guide."
+            : "Welcome, \(name)!"
+
+        var bcc: [String] = []
+        if let replyAddress = replyTo {
+            bcc.append(replyAddress)
+        }
+
+        return EmailMessage(to: [recipient], subject: "Welcome!", body: body, cc: [], bcc: bcc, isHTML: false, attachments: [])
+    }
+
+    func scheduleDelivery(
+        for message: EmailMessage,
+        at date: Date,
+        retryCount: Int = 3,
+        retryDelay: TimeInterval = 60
+    ) {
+        // Schedule logic here
+        _ = (message, date, retryCount, retryDelay)
+    }
+}
diff --git a/priv/combined_metrics/samples/function_design/function_does_not_change_return_type_via_options/bad/reports.ex b/priv/combined_metrics/samples/function_design/function_does_not_change_return_type_via_options/bad/reports.ex
new file mode 100644
index 0000000..803e326
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/function_does_not_change_return_type_via_options/bad/reports.ex
@@ -0,0 +1,64 @@
+defmodule MyApp.Reports do
+  @moduledoc """
+  Report generation.
+  """
+
+  alias MyApp.Analytics
+
+  # Bad: `format` option changes the return type from struct -> binary -> map.
+  # Callers cannot know the return type without inspecting the options.
+  @spec build_revenue_report(Date.t(), Date.t(), keyword()) ::
+          map() | binary() | MyApp.Reports.RevenueReport.t()
+  def build_revenue_report(%Date{} = from, %Date{} = to, opts \\ []) do
+    rows = Analytics.revenue_by_day(from, to)
+    total = Enum.sum(Enum.map(rows, & &1.amount))
+
+    report = %{from: from, to: to, rows: rows, total: total}
+
+    case Keyword.get(opts, :format) do
+      :csv ->
+        # Returns a binary when :csv
+        header = "date,amount\n"
+        body = Enum.map_join(rows, "\n", &"#{&1.date},#{&1.amount}")
+        header <> body
+
+      :json ->
+        # Returns a map when :json
+        %{
+          from: Date.to_iso8601(from),
+          to: Date.to_iso8601(to),
+          total: total,
+          rows: Enum.map(rows, &%{date: Date.to_iso8601(&1.date), amount: &1.amount})
+        }
+
+      nil ->
+        # Returns raw map with no format
+        report
+    end
+  end
+
+  # Bad: `raw` option changes return from list of maps to list of tuples
+  @spec fetch_revenue_rows(Date.t(), Date.t(), keyword()) :: [map()] | [{Date.t(), integer()}]
+  def fetch_revenue_rows(from, to, opts \\ []) do
+    rows = Analytics.revenue_by_day(from, to)
+
+    if Keyword.get(opts, :raw) do
+      Enum.map(rows, &{&1.date, &1.amount})
+    else
+      rows
+    end
+  end
+
+  # Bad: `verbose` option changes return from integer to map
+  @spec total_revenue(Date.t(), Date.t(), keyword()) :: integer() | map()
+  def total_revenue(from, to, opts \\ []) do
+    rows = Analytics.revenue_by_day(from, to)
+    total = Enum.sum(Enum.map(rows, & &1.amount))
+
+    if Keyword.get(opts, :verbose) do
+      %{total: total, from: from, to: to, row_count: length(rows)}
+    else
+      total
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/function_does_not_change_return_type_via_options/good/reports.ex b/priv/combined_metrics/samples/function_design/function_does_not_change_return_type_via_options/good/reports.ex
new file mode 100644
index 0000000..01aafb2
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/function_does_not_change_return_type_via_options/good/reports.ex
@@ -0,0 +1,69 @@
+defmodule MyApp.Reports do
+  @moduledoc """
+  Report generation. Separate functions are used for distinct output
+  formats rather than changing the return type via options.
+  """
+
+  alias MyApp.Reports.{RevenueReport, SummaryReport}
+  alias MyApp.Analytics
+
+  @doc """
+  Builds a revenue report struct for the given date range.
+  Always returns a `RevenueReport` struct.
+  """
+  @spec build_revenue_report(Date.t(), Date.t()) :: RevenueReport.t()
+  def build_revenue_report(%Date{} = from, %Date{} = to) do
+    rows = Analytics.revenue_by_day(from, to)
+    total = Enum.sum(Enum.map(rows, & &1.amount))
+
+    %RevenueReport{
+      from: from,
+      to: to,
+      rows: rows,
+      total: total,
+      generated_at: DateTime.utc_now()
+    }
+  end
+
+  @doc """
+  Renders a revenue report as a CSV binary.
+  Always returns a binary.
+  """
+  @spec render_revenue_csv(RevenueReport.t()) :: binary()
+  def render_revenue_csv(%RevenueReport{rows: rows}) do
+    header = "date,amount\n"
+    body = Enum.map_join(rows, "\n", &"#{&1.date},#{&1.amount}")
+    header <> body
+  end
+
+  @doc """
+  Renders a revenue report as a JSON-encodable map.
+  Always returns a map.
+  """
+  @spec render_revenue_json(RevenueReport.t()) :: map()
+  def render_revenue_json(%RevenueReport{} = report) do
+    %{
+      from: Date.to_iso8601(report.from),
+      to: Date.to_iso8601(report.to),
+      total: report.total,
+      rows: Enum.map(report.rows, &%{date: Date.to_iso8601(&1.date), amount: &1.amount})
+    }
+  end
+
+  @doc """
+  Builds a summary report for a single month.
+  Always returns a `SummaryReport` struct.
+  """
+  @spec build_summary(integer(), integer()) :: SummaryReport.t()
+  def build_summary(year, month) do
+    data = Analytics.monthly_summary(year, month)
+
+    %SummaryReport{
+      year: year,
+      month: month,
+      total_orders: data.order_count,
+      total_revenue: data.revenue,
+      avg_order_value: data.revenue / max(data.order_count, 1)
+    }
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/has_verb_in_name/bad/api.ex b/priv/combined_metrics/samples/function_design/has_verb_in_name/bad/api.ex
new file mode 100644
index 0000000..8ac1843
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/has_verb_in_name/bad/api.ex
@@ -0,0 +1,54 @@
+defmodule Api do
+  def user_data(user_id) do
+    case http_get("/users/#{user_id}") do
+      {:ok, body} -> {:ok, Jason.decode!(body)}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  def order_status(order_id) do
+    case http_get("/orders/#{order_id}/status") do
+      {:ok, body} -> {:ok, Jason.decode!(body)}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  def payment_result(payment_id) do
+    case http_get("/payments/#{payment_id}") do
+      {:ok, body} -> {:ok, Jason.decode!(body)}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  def product_inventory(sku) do
+    case http_get("/inventory/#{sku}") do
+      {:ok, body} -> {:ok, Jason.decode!(body)}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  def shipment_tracking(tracking_number) do
+    case http_get("/shipments/#{tracking_number}") do
+      {:ok, body} -> {:ok, Jason.decode!(body)}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  def customer_profile(customer_id) do
+    case http_get("/customers/#{customer_id}/profile") do
+      {:ok, body} -> {:ok, Jason.decode!(body)}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  def webhook_registration(url, events) do
+    payload = Jason.encode!(%{url: url, events: events})
+    case http_post("/webhooks", payload) do
+      {:ok, body} -> {:ok, Jason.decode!(body)}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  defp http_get(path), do: {:ok, ~s({"path":"#{path}"})}
+  defp http_post(path, _body), do: {:ok, ~s({"path":"#{path}","created":true})}
+end
diff --git a/priv/combined_metrics/samples/function_design/has_verb_in_name/config.yml b/priv/combined_metrics/samples/function_design/has_verb_in_name/config.yml
new file mode 100644
index 0000000..cd84977
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/has_verb_in_name/config.yml
@@ -0,0 +1 @@
+doc: "Function names should contain a verb describing the action performed."
diff --git a/priv/combined_metrics/samples/function_design/has_verb_in_name/good/api.ex b/priv/combined_metrics/samples/function_design/has_verb_in_name/good/api.ex
new file mode 100644
index 0000000..c60f64d
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/has_verb_in_name/good/api.ex
@@ -0,0 +1,54 @@
+defmodule Api do
+  def fetch_user_data(user_id) do
+    case http_get("/users/#{user_id}") do
+      {:ok, body} -> {:ok, Jason.decode!(body)}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  def get_order_status(order_id) do
+    case http_get("/orders/#{order_id}/status") do
+      {:ok, body} -> {:ok, Jason.decode!(body)}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  def retrieve_payment_result(payment_id) do
+    case http_get("/payments/#{payment_id}") do
+      {:ok, body} -> {:ok, Jason.decode!(body)}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  def check_product_inventory(sku) do
+    case http_get("/inventory/#{sku}") do
+      {:ok, body} -> {:ok, Jason.decode!(body)}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  def track_shipment(tracking_number) do
+    case http_get("/shipments/#{tracking_number}") do
+      {:ok, body} -> {:ok, Jason.decode!(body)}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  def load_customer_profile(customer_id) do
+    case http_get("/customers/#{customer_id}/profile") do
+      {:ok, body} -> {:ok, Jason.decode!(body)}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  def register_webhook(url, events) do
+    payload = Jason.encode!(%{url: url, events: events})
+    case http_post("/webhooks", payload) do
+      {:ok, body} -> {:ok, Jason.decode!(body)}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  defp http_get(path), do: {:ok, ~s({"path":"#{path}"})}
+  defp http_post(path, _body), do: {:ok, ~s({"path":"#{path}","created":true})}
+end
diff --git a/priv/combined_metrics/samples/function_design/input_parameters_before_output_parameters/bad/Matrix.cpp b/priv/combined_metrics/samples/function_design/input_parameters_before_output_parameters/bad/Matrix.cpp
new file mode 100644
index 0000000..2d26944
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/input_parameters_before_output_parameters/bad/Matrix.cpp
@@ -0,0 +1,64 @@
+#include <cstddef>
+#include <stdexcept>
+#include <vector>
+#include <string>
+
+// Output parameters appear before inputs — confusing parameter order
+
+// Output result comes first — counterintuitive
+void multiplyScalar(std::vector<double>& result,     // output first — confusing
+                    const std::vector<double>& input, // input second
+                    double scalar)
+{
+    result.resize(input.size());
+    for (std::size_t i = 0; i < input.size(); ++i)
+        result[i] = input[i] * scalar;
+}
+
+// Output before input dimensions — reader must study the body to understand the order
+void transpose(double* output,           // output first
+               const double* input,      // input second
+               std::size_t rows, std::size_t cols)
+{
+    for (std::size_t r = 0; r < rows; ++r)
+        for (std::size_t c = 0; c < cols; ++c)
+            output[c * rows + r] = input[r * cols + c];
+}
+
+// Output interleaved with inputs — no clear convention
+void addVectors(double* result,          // output first
+                const double* a,         // input
+                std::size_t size,        // input dimension
+                const double* b)         // second input — split from first by size
+{
+    for (std::size_t i = 0; i < size; ++i)
+        result[i] = a[i] + b[i];
+}
+
+// Output buried in the middle of the parameter list
+void multiplyMatrices(const double* lhs,
+                      std::size_t lhsRows,
+                      double* result,         // output in the middle
+                      const double* rhs,
+                      std::size_t sharedDim,
+                      std::size_t rhsCols)
+{
+    for (std::size_t i = 0; i < lhsRows; ++i)
+        for (std::size_t k = 0; k < sharedDim; ++k)
+            for (std::size_t j = 0; j < rhsCols; ++j)
+                result[i * rhsCols + j] += lhs[i * sharedDim + k] * rhs[k * rhsCols + j];
+}
+
+// Output first, then all inputs
+void formatRow(std::string& output,           // output first
+               int rowIndex,
+               const std::vector<double>& values,
+               char separator)
+{
+    output.clear();
+    output += std::to_string(rowIndex) + separator;
+    for (std::size_t i = 0; i < values.size(); ++i) {
+        if (i > 0) output += separator;
+        output += std::to_string(values[i]);
+    }
+}
diff --git a/priv/combined_metrics/samples/function_design/input_parameters_before_output_parameters/good/Matrix.cpp b/priv/combined_metrics/samples/function_design/input_parameters_before_output_parameters/good/Matrix.cpp
new file mode 100644
index 0000000..51e9333
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/input_parameters_before_output_parameters/good/Matrix.cpp
@@ -0,0 +1,53 @@
+#include <cstddef>
+#include <stdexcept>
+#include <vector>
+
+// Inputs come first, outputs last — consistent with standard library conventions (e.g., std::copy)
+
+// Pure inputs first, result returned by value
+std::vector<double> multiplyScalar(const std::vector<double>& input, double scalar) {
+    std::vector<double> result(input.size());
+    for (std::size_t i = 0; i < input.size(); ++i)
+        result[i] = input[i] * scalar;
+    return result;
+}
+
+// Input rows/cols before the output matrix
+void transpose(const double* input, std::size_t rows, std::size_t cols,
+               double* output) // output parameter last
+{
+    for (std::size_t r = 0; r < rows; ++r)
+        for (std::size_t c = 0; c < cols; ++c)
+            output[c * rows + r] = input[r * cols + c];
+}
+
+// Read-only inputs (a, b, size) before write output (result)
+void addVectors(const double* a, const double* b, std::size_t size,
+                double* result) // output last
+{
+    for (std::size_t i = 0; i < size; ++i)
+        result[i] = a[i] + b[i];
+}
+
+// Inputs: lhs, rhs matrices and their dimensions; output: result matrix last
+void multiplyMatrices(const double* lhs, const double* rhs,
+                      std::size_t lhsRows, std::size_t sharedDim, std::size_t rhsCols,
+                      double* result) // output last
+{
+    for (std::size_t i = 0; i < lhsRows; ++i)
+        for (std::size_t k = 0; k < sharedDim; ++k)
+            for (std::size_t j = 0; j < rhsCols; ++j)
+                result[i * rhsCols + j] += lhs[i * sharedDim + k] * rhs[k * rhsCols + j];
+}
+
+// Input configuration first, output buffer last
+void formatRow(int rowIndex, const std::vector<double>& values, char separator,
+               std::string& output) // output last
+{
+    output.clear();
+    output += std::to_string(rowIndex) + separator;
+    for (std::size_t i = 0; i < values.size(); ++i) {
+        if (i > 0) output += separator;
+        output += std::to_string(values[i]);
+    }
+}
diff --git a/priv/combined_metrics/samples/function_design/interface_has_one_or_two_methods/bad/storage.go b/priv/combined_metrics/samples/function_design/interface_has_one_or_two_methods/bad/storage.go
new file mode 100644
index 0000000..4a93408
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/interface_has_one_or_two_methods/bad/storage.go
@@ -0,0 +1,43 @@
+package storage
+
+import "context"
+
+// Document is a stored item.
+type Document struct {
+	ID      string
+	Content []byte
+}
+
+// Store is a fat interface with many methods. Implementors must provide all of
+// them even when a caller only needs Read. This makes mocking in tests verbose
+// and tightly couples callers to the full Store surface.
+type Store interface {
+	Read(ctx context.Context, id string) (*Document, error)
+	Write(ctx context.Context, doc Document) error
+	Delete(ctx context.Context, id string) error
+	List(ctx context.Context) ([]Document, error)
+	Count(ctx context.Context) (int, error)
+	Exists(ctx context.Context, id string) (bool, error)
+	Ping(ctx context.Context) error
+}
+
+// DocumentService depends on the entire Store interface even though it only
+// uses Read and Write.
+type DocumentService struct {
+	store Store
+}
+
+// New constructs a DocumentService.
+func New(store Store) *DocumentService {
+	return &DocumentService{store: store}
+}
+
+// Get fetches a document by ID.
+func (s *DocumentService) Get(ctx context.Context, id string) (*Document, error) {
+	return s.store.Read(ctx, id)
+}
+
+// Save persists a document.
+func (s *DocumentService) Save(ctx context.Context, doc Document) error {
+	return s.store.Write(ctx, doc)
+}
diff --git a/priv/combined_metrics/samples/function_design/interface_has_one_or_two_methods/good/storage.go b/priv/combined_metrics/samples/function_design/interface_has_one_or_two_methods/good/storage.go
new file mode 100644
index 0000000..be1d6ba
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/interface_has_one_or_two_methods/good/storage.go
@@ -0,0 +1,53 @@
+package storage
+
+import "context"
+
+// Document is a stored item.
+type Document struct {
+	ID      string
+	Content []byte
+}
+
+// Reader is a single-method interface for fetching a document.
+// Small interfaces are easy to implement, test, and compose.
+type Reader interface {
+	Read(ctx context.Context, id string) (*Document, error)
+}
+
+// Writer is a single-method interface for persisting a document.
+type Writer interface {
+	Write(ctx context.Context, doc Document) error
+}
+
+// Deleter is a single-method interface for removing a document.
+type Deleter interface {
+	Delete(ctx context.Context, id string) error
+}
+
+// ReadWriter composes Reader and Writer for callers that need both.
+// Composed from small interfaces rather than a large monolith.
+type ReadWriter interface {
+	Reader
+	Writer
+}
+
+// DocumentService uses only the capabilities it requires.
+type DocumentService struct {
+	rw     ReadWriter
+	deleter Deleter
+}
+
+// New constructs a DocumentService.
+func New(rw ReadWriter, deleter Deleter) *DocumentService {
+	return &DocumentService{rw: rw, deleter: deleter}
+}
+
+// Get fetches a document by ID.
+func (s *DocumentService) Get(ctx context.Context, id string) (*Document, error) {
+	return s.rw.Read(ctx, id)
+}
+
+// Save persists a document.
+func (s *DocumentService) Save(ctx context.Context, doc Document) error {
+	return s.rw.Write(ctx, doc)
+}
diff --git a/priv/combined_metrics/samples/function_design/is_less_than_20_lines/bad/report_generator.ex b/priv/combined_metrics/samples/function_design/is_less_than_20_lines/bad/report_generator.ex
new file mode 100644
index 0000000..90ba048
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/is_less_than_20_lines/bad/report_generator.ex
@@ -0,0 +1,53 @@
+defmodule ReportGenerator do
+  def generate_report(orders, user, opts) do
+    start_date = Keyword.get(opts, :start_date)
+    end_date = Keyword.get(opts, :end_date)
+    format = Keyword.get(opts, :format, :pdf)
+
+    filtered = Enum.filter(orders, fn order ->
+      order.user_id == user.id &&
+        (is_nil(start_date) || Date.compare(order.date, start_date) != :lt) &&
+        (is_nil(end_date) || Date.compare(order.date, end_date) != :gt)
+    end)
+
+    total = Enum.reduce(filtered, 0, fn order, acc ->
+      line_total = Enum.reduce(order.items, 0, fn item, item_acc ->
+        item_acc + item.price * item.quantity
+      end)
+      acc + line_total
+    end)
+
+    discount = if user.vip do
+      total * 0.1
+    else
+      0
+    end
+
+    net_total = total - discount
+    tax = net_total * 0.2
+    grand_total = net_total + tax
+
+    summary_lines = Enum.map(filtered, fn order ->
+      items_text = Enum.map_join(order.items, ", ", fn item ->
+        "#{item.name} x#{item.quantity} @ #{item.price}"
+      end)
+      "Order #{order.id} (#{order.date}): #{items_text}"
+    end)
+
+    header = "Report for #{user.name} | #{start_date} - #{end_date}"
+    body = Enum.join(summary_lines, "\n")
+    footer = "Subtotal: #{total} | Discount: #{discount} | Tax: #{tax} | Total: #{grand_total}"
+
+    content = "#{header}\n\n#{body}\n\n#{footer}"
+
+    case format do
+      :pdf -> {:ok, render_pdf(content)}
+      :csv -> {:ok, render_csv(filtered, grand_total)}
+      :html -> {:ok, "<html><body><pre>#{content}</pre></body></html>"}
+      _ -> {:error, :unsupported_format}
+    end
+  end
+
+  defp render_pdf(content), do: %{type: :pdf, data: content}
+  defp render_csv(orders, total), do: %{type: :csv, orders: orders, total: total}
+end
diff --git a/priv/combined_metrics/samples/function_design/is_less_than_20_lines/config.yml b/priv/combined_metrics/samples/function_design/is_less_than_20_lines/config.yml
new file mode 100644
index 0000000..10d2d75
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/is_less_than_20_lines/config.yml
@@ -0,0 +1 @@
+doc: "Functions should be 20 lines or fewer."
diff --git a/priv/combined_metrics/samples/function_design/is_less_than_20_lines/good/report_generator.ex b/priv/combined_metrics/samples/function_design/is_less_than_20_lines/good/report_generator.ex
new file mode 100644
index 0000000..c777d77
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/is_less_than_20_lines/good/report_generator.ex
@@ -0,0 +1,55 @@
+defmodule ReportGenerator do
+  def generate_report(orders, user, opts) do
+    filtered = filter_orders(orders, user, opts)
+    totals = calculate_totals(filtered, user)
+    content = build_content(filtered, user, totals, opts)
+    render(content, filtered, totals, Keyword.get(opts, :format, :pdf))
+  end
+
+  defp filter_orders(orders, user, opts) do
+    start_date = Keyword.get(opts, :start_date)
+    end_date = Keyword.get(opts, :end_date)
+
+    Enum.filter(orders, fn order ->
+      order.user_id == user.id &&
+        within_date_range?(order.date, start_date, end_date)
+    end)
+  end
+
+  defp within_date_range?(date, start_date, end_date) do
+    (is_nil(start_date) || Date.compare(date, start_date) != :lt) &&
+      (is_nil(end_date) || Date.compare(date, end_date) != :gt)
+  end
+
+  defp calculate_totals(orders, user) do
+    subtotal = Enum.sum(Enum.map(orders, &order_subtotal/1))
+    discount = if user.vip, do: subtotal * 0.1, else: 0
+    net = subtotal - discount
+    %{subtotal: subtotal, discount: discount, net: net, tax: net * 0.2, grand: net + net * 0.2}
+  end
+
+  defp order_subtotal(order) do
+    Enum.sum(Enum.map(order.items, fn item -> item.price * item.quantity end))
+  end
+
+  defp build_content(orders, user, totals, opts) do
+    start_date = Keyword.get(opts, :start_date)
+    end_date = Keyword.get(opts, :end_date)
+    header = "Report for #{user.name} | #{start_date} - #{end_date}"
+    body = Enum.map_join(orders, "\n", &format_order_line/1)
+    footer = "Subtotal: #{totals.subtotal} | Discount: #{totals.discount} | Tax: #{totals.tax} | Total: #{totals.grand}"
+    "#{header}\n\n#{body}\n\n#{footer}"
+  end
+
+  defp format_order_line(order) do
+    items_text = Enum.map_join(order.items, ", ", fn item ->
+      "#{item.name} x#{item.quantity} @ #{item.price}"
+    end)
+    "Order #{order.id} (#{order.date}): #{items_text}"
+  end
+
+  defp render(content, _orders, _totals, :pdf), do: {:ok, %{type: :pdf, data: content}}
+  defp render(_content, orders, totals, :csv), do: {:ok, %{type: :csv, orders: orders, total: totals.grand}}
+  defp render(content, _orders, _totals, :html), do: {:ok, "<html><body><pre>#{content}</pre></body></html>"}
+  defp render(_content, _orders, _totals, _), do: {:error, :unsupported_format}
+end
diff --git a/priv/combined_metrics/samples/function_design/move_constructors_are_noexcept/bad/Buffer.cpp b/priv/combined_metrics/samples/function_design/move_constructors_are_noexcept/bad/Buffer.cpp
new file mode 100644
index 0000000..7ced490
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/move_constructors_are_noexcept/bad/Buffer.cpp
@@ -0,0 +1,82 @@
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <stdexcept>
+#include <vector>
+
+class Buffer {
+public:
+    explicit Buffer(std::size_t capacity)
+        : data_(std::make_unique<uint8_t[]>(capacity))
+        , capacity_(capacity)
+        , size_(0)
+    {}
+
+    // Move constructor without noexcept:
+    // std::vector and other containers will use the copy constructor instead of move
+    // during reallocation, causing unnecessary heap allocations and memcpy calls
+    Buffer(Buffer&& other) // missing noexcept
+        : data_(std::move(other.data_))
+        , capacity_(other.capacity_)
+        , size_(other.size_)
+    {
+        other.capacity_ = 0;
+        other.size_ = 0;
+    }
+
+    // Move assignment also missing noexcept
+    Buffer& operator=(Buffer&& other) // missing noexcept
+    {
+        if (this != &other) {
+            data_ = std::move(other.data_);
+            capacity_ = other.capacity_;
+            size_ = other.size_;
+            other.capacity_ = 0;
+            other.size_ = 0;
+        }
+        return *this;
+    }
+
+    Buffer(const Buffer& other)
+        : data_(std::make_unique<uint8_t[]>(other.capacity_))
+        , capacity_(other.capacity_)
+        , size_(other.size_)
+    {
+        std::memcpy(data_.get(), other.data_.get(), other.size_);
+    }
+
+    Buffer& operator=(const Buffer& other) {
+        if (this != &other) {
+            auto newData = std::make_unique<uint8_t[]>(other.capacity_);
+            std::memcpy(newData.get(), other.data_.get(), other.size_);
+            data_ = std::move(newData);
+            capacity_ = other.capacity_;
+            size_ = other.size_;
+        }
+        return *this;
+    }
+
+    void append(const uint8_t* src, std::size_t length) {
+        if (size_ + length > capacity_)
+            throw std::overflow_error("Buffer capacity exceeded");
+        std::memcpy(data_.get() + size_, src, length);
+        size_ += length;
+    }
+
+    std::size_t size() const noexcept { return size_; }
+    std::size_t capacity() const noexcept { return capacity_; }
+
+private:
+    std::unique_ptr<uint8_t[]> data_;
+    std::size_t capacity_;
+    std::size_t size_;
+};
+
+// Because move ctor is not noexcept, std::vector will copy (not move) Buffer
+// objects during reallocation — expensive for large buffers
+void demonstrateVectorRealloc() {
+    std::vector<Buffer> buffers;
+    buffers.reserve(4);
+    for (int i = 0; i < 8; ++i)
+        buffers.emplace_back(1024); // triggers copy, not move, on reallocation
+}
diff --git a/priv/combined_metrics/samples/function_design/move_constructors_are_noexcept/good/Buffer.cpp b/priv/combined_metrics/samples/function_design/move_constructors_are_noexcept/good/Buffer.cpp
new file mode 100644
index 0000000..3fce1c2
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/move_constructors_are_noexcept/good/Buffer.cpp
@@ -0,0 +1,79 @@
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <stdexcept>
+#include <vector>
+
+class Buffer {
+public:
+    explicit Buffer(std::size_t capacity)
+        : data_(std::make_unique<uint8_t[]>(capacity))
+        , capacity_(capacity)
+        , size_(0)
+    {}
+
+    // Move constructor is noexcept: only reassigns pointers and integers — cannot throw
+    Buffer(Buffer&& other) noexcept
+        : data_(std::move(other.data_))
+        , capacity_(other.capacity_)
+        , size_(other.size_)
+    {
+        other.capacity_ = 0;
+        other.size_ = 0;
+    }
+
+    // Move assignment is noexcept for the same reason
+    Buffer& operator=(Buffer&& other) noexcept {
+        if (this != &other) {
+            data_ = std::move(other.data_);
+            capacity_ = other.capacity_;
+            size_ = other.size_;
+            other.capacity_ = 0;
+            other.size_ = 0;
+        }
+        return *this;
+    }
+
+    Buffer(const Buffer& other)
+        : data_(std::make_unique<uint8_t[]>(other.capacity_))
+        , capacity_(other.capacity_)
+        , size_(other.size_)
+    {
+        std::memcpy(data_.get(), other.data_.get(), other.size_);
+    }
+
+    Buffer& operator=(const Buffer& other) {
+        if (this != &other) {
+            auto newData = std::make_unique<uint8_t[]>(other.capacity_);
+            std::memcpy(newData.get(), other.data_.get(), other.size_);
+            data_ = std::move(newData);
+            capacity_ = other.capacity_;
+            size_ = other.size_;
+        }
+        return *this;
+    }
+
+    void append(const uint8_t* src, std::size_t length) {
+        if (size_ + length > capacity_)
+            throw std::overflow_error("Buffer capacity exceeded");
+        std::memcpy(data_.get() + size_, src, length);
+        size_ += length;
+    }
+
+    std::size_t size() const noexcept { return size_; }
+    std::size_t capacity() const noexcept { return capacity_; }
+
+private:
+    std::unique_ptr<uint8_t[]> data_;
+    std::size_t capacity_;
+    std::size_t size_;
+};
+
+// noexcept move allows std::vector<Buffer> to use move during reallocation
+// rather than copying — important for performance
+void demonstrateVectorRealloc() {
+    std::vector<Buffer> buffers;
+    buffers.reserve(4);
+    for (int i = 0; i < 8; ++i)
+        buffers.emplace_back(1024); // triggers reallocation; uses move ctor (noexcept)
+}
diff --git a/priv/combined_metrics/samples/function_design/named_return_values_used_for_documentation/bad/parser.go b/priv/combined_metrics/samples/function_design/named_return_values_used_for_documentation/bad/parser.go
new file mode 100644
index 0000000..c57a550
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/named_return_values_used_for_documentation/bad/parser.go
@@ -0,0 +1,56 @@
+package parser
+
+import (
+	"bufio"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// ParseCSVRow splits a CSV line into its fields.
+// Without named returns the two []string values are indistinguishable from
+// the signature alone — callers must read the body to know which is which.
+func ParseCSVRow(line string) ([]string, []string) {
+	var headers, values []string
+	parts := strings.Split(line, ",")
+	for i, p := range parts {
+		p = strings.TrimSpace(p)
+		if i == 0 {
+			headers = append(headers, p)
+		} else {
+			values = append(values, p)
+		}
+	}
+	return headers, values
+}
+
+// ParseBounds extracts the start and end line numbers from a range string "N-M".
+// Three return values of which two are int — callers cannot tell from the
+// signature which int is start and which is end without reading the body.
+func ParseBounds(rangeStr string) (int, int, error) {
+	parts := strings.SplitN(rangeStr, "-", 2)
+	if len(parts) != 2 {
+		return 0, 0, fmt.Errorf("invalid range %q: expected format N-M", rangeStr)
+	}
+	start, err := strconv.Atoi(strings.TrimSpace(parts[0]))
+	if err != nil {
+		return 0, 0, fmt.Errorf("invalid start in range %q: %w", rangeStr, err)
+	}
+	end, err := strconv.Atoi(strings.TrimSpace(parts[1]))
+	if err != nil {
+		return 0, 0, fmt.Errorf("invalid end in range %q: %w", rangeStr, err)
+	}
+	return start, end, nil
+}
+
+// CountWords scans a multi-line string and returns two counts.
+// The two ints are ambiguous — is it (words, lines) or (lines, words)?
+func CountWords(text string) (int, int) {
+	var words, lines int
+	scanner := bufio.NewScanner(strings.NewReader(text))
+	for scanner.Scan() {
+		lines++
+		words += len(strings.Fields(scanner.Text()))
+	}
+	return words, lines
+}
diff --git a/priv/combined_metrics/samples/function_design/named_return_values_used_for_documentation/good/parser.go b/priv/combined_metrics/samples/function_design/named_return_values_used_for_documentation/good/parser.go
new file mode 100644
index 0000000..0abe9cf
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/named_return_values_used_for_documentation/good/parser.go
@@ -0,0 +1,58 @@
+package parser
+
+import (
+	"bufio"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// ParseCSVRow splits a CSV line into its fields.
+// Named returns make the two string slices unambiguous at the call site.
+func ParseCSVRow(line string) (headers []string, values []string) {
+	parts := strings.Split(line, ",")
+	for i, p := range parts {
+		p = strings.TrimSpace(p)
+		if i == 0 {
+			headers = append(headers, p)
+		} else {
+			values = append(values, p)
+		}
+	}
+	return
+}
+
+// ParseBounds extracts the start and end line numbers from a range string "N-M".
+// Named returns clarify which int is start and which is end.
+func ParseBounds(rangeStr string) (start, end int, err error) {
+	parts := strings.SplitN(rangeStr, "-", 2)
+	if len(parts) != 2 {
+		err = fmt.Errorf("invalid range %q: expected format N-M", rangeStr)
+		return
+	}
+	start, err = strconv.Atoi(strings.TrimSpace(parts[0]))
+	if err != nil {
+		err = fmt.Errorf("invalid start in range %q: %w", rangeStr, err)
+		return
+	}
+	end, err = strconv.Atoi(strings.TrimSpace(parts[1]))
+	if err != nil {
+		err = fmt.Errorf("invalid end in range %q: %w", rangeStr, err)
+		return
+	}
+	if end < start {
+		err = fmt.Errorf("end %d is before start %d in range %q", end, start, rangeStr)
+	}
+	return
+}
+
+// CountWords scans a multi-line string and returns word and line counts.
+// Named returns document what each int represents.
+func CountWords(text string) (words, lines int) {
+	scanner := bufio.NewScanner(strings.NewReader(text))
+	for scanner.Scan() {
+		lines++
+		words += len(strings.Fields(scanner.Text()))
+	}
+	return
+}
diff --git a/priv/combined_metrics/samples/function_design/nesting_depth_under_4/bad/validator.ex b/priv/combined_metrics/samples/function_design/nesting_depth_under_4/bad/validator.ex
new file mode 100644
index 0000000..b53ed02
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/nesting_depth_under_4/bad/validator.ex
@@ -0,0 +1,59 @@
+defmodule Validator do
+  def validate_request(request) do
+    if request != nil do
+      if Map.has_key?(request, :user) do
+        if request.user != nil do
+          if Map.has_key?(request.user, :role) do
+            if request.user.role in [:admin, :editor, :viewer] do
+              if Map.has_key?(request, :payload) do
+                {:ok, request}
+              else
+                {:error, "missing payload"}
+              end
+            else
+              {:error, "invalid role"}
+            end
+          else
+            {:error, "missing role"}
+          end
+        else
+          {:error, "user is nil"}
+        end
+      else
+        {:error, "missing user"}
+      end
+    else
+      {:error, "request is nil"}
+    end
+  end
+
+  def validate_order(order) do
+    case order do
+      nil -> {:error, "order is nil"}
+      _ ->
+        case order.status do
+          :pending ->
+            case order.items do
+              [] -> {:error, "no items"}
+              items ->
+                case Enum.all?(items, &valid_item?/1) do
+                  true ->
+                    case order.payment do
+                      nil -> {:error, "no payment"}
+                      payment ->
+                        case payment.method do
+                          :card -> {:ok, order}
+                          :cash -> {:ok, order}
+                          _ -> {:error, "invalid payment method"}
+                        end
+                    end
+                  false -> {:error, "invalid item"}
+                end
+            end
+          _ -> {:error, "order not pending"}
+        end
+    end
+  end
+
+  defp valid_item?(item), do: item.quantity > 0 && item.price > 0
+end
diff --git a/priv/combined_metrics/samples/function_design/nesting_depth_under_4/config.yml b/priv/combined_metrics/samples/function_design/nesting_depth_under_4/config.yml
new file mode 100644
index 0000000..df376c9
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/nesting_depth_under_4/config.yml
@@ -0,0 +1 @@
+doc: "Code should not nest deeper than 4 levels."
diff --git a/priv/combined_metrics/samples/function_design/nesting_depth_under_4/good/validator.ex b/priv/combined_metrics/samples/function_design/nesting_depth_under_4/good/validator.ex
new file mode 100644
index 0000000..5ced262
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/nesting_depth_under_4/good/validator.ex
@@ -0,0 +1,49 @@
+defmodule Validator do
+  def validate_request(nil), do: {:error, "request is nil"}
+
+  def validate_request(request) do
+    with {:ok, user} <- fetch_user(request),
+         :ok <- validate_role(user),
+         :ok <- require_payload(request) do
+      {:ok, request}
+    end
+  end
+
+  def validate_order(nil), do: {:error, "order is nil"}
+
+  def validate_order(order) do
+    with :ok <- require_pending(order),
+         :ok <- require_items(order.items),
+         :ok <- validate_items(order.items),
+         :ok <- validate_payment(order.payment) do
+      {:ok, order}
+    end
+  end
+
+  defp fetch_user(%{user: nil}), do: {:error, "user is nil"}
+  defp fetch_user(%{user: user}), do: {:ok, user}
+  defp fetch_user(_), do: {:error, "missing user"}
+
+  defp validate_role(%{role: role}) when role in [:admin, :editor, :viewer], do: :ok
+  defp validate_role(%{role: _}), do: {:error, "invalid role"}
+  defp validate_role(_), do: {:error, "missing role"}
+
+  defp require_payload(%{payload: _}), do: :ok
+  defp require_payload(_), do: {:error, "missing payload"}
+
+  defp require_pending(%{status: :pending}), do: :ok
+  defp require_pending(_), do: {:error, "order not pending"}
+
+  defp require_items([]), do: {:error, "no items"}
+  defp require_items(_), do: :ok
+
+  defp validate_items(items) do
+    if Enum.all?(items, &valid_item?/1), do: :ok, else: {:error, "invalid item"}
+  end
+
+  defp validate_payment(nil), do: {:error, "no payment"}
+  defp validate_payment(%{method: method}) when method in [:card, :cash], do: :ok
+  defp validate_payment(_), do: {:error, "invalid payment method"}
+
+  defp valid_item?(item), do: item.quantity > 0 && item.price > 0
+end
diff --git a/priv/combined_metrics/samples/function_design/no_arguments_object/bad/query_builder.js b/priv/combined_metrics/samples/function_design/no_arguments_object/bad/query_builder.js
new file mode 100644
index 0000000..38ff091
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_arguments_object/bad/query_builder.js
@@ -0,0 +1,57 @@
+function buildSelectClause() {
+  const table = arguments[0];
+  if (arguments.length <= 1) {
+    return `SELECT * FROM ${table}`;
+  }
+  const columns = [];
+  for (let i = 1; i < arguments.length; i++) {
+    columns.push(`"${arguments[i]}"`);
+  }
+  return `SELECT ${columns.join(", ")} FROM "${table}"`;
+}
+
+function buildWhereClause() {
+  if (arguments.length === 0) return "";
+  const conditions = [];
+  for (let i = 0; i < arguments.length; i++) {
+    conditions.push(arguments[i]);
+  }
+  return "WHERE " + conditions.join(" AND ");
+}
+
+function mergeQueryOptions() {
+  const result = {};
+  for (let i = 0; i < arguments.length; i++) {
+    Object.assign(result, arguments[i]);
+  }
+  return result;
+}
+
+function buildOrderClause() {
+  if (arguments.length === 0) return "";
+  const parts = [];
+  for (let i = 0; i < arguments.length; i++) {
+    const field = arguments[i];
+    parts.push(`"${field.column}" ${field.direction || "ASC"}`);
+  }
+  return "ORDER BY " + parts.join(", ");
+}
+
+function buildQuery(table, options) {
+  const columns = options.columns || [];
+  const conditions = options.conditions || [];
+  const orderBy = options.orderBy || [];
+
+  const selectPart = buildSelectClause.apply(null, [table].concat(columns));
+  const wherePart = buildWhereClause.apply(null, conditions);
+  const orderPart = buildOrderClause.apply(null, orderBy);
+
+  const parts = [selectPart, wherePart, orderPart].filter(Boolean);
+
+  if (options.limit != null) parts.push(`LIMIT ${Number(options.limit)}`);
+  if (options.offset != null) parts.push(`OFFSET ${Number(options.offset)}`);
+
+  return parts.join(" ");
+}
+
+export { buildQuery, buildSelectClause, buildWhereClause, buildOrderClause, mergeQueryOptions };
diff --git a/priv/combined_metrics/samples/function_design/no_arguments_object/good/query_builder.js b/priv/combined_metrics/samples/function_design/no_arguments_object/good/query_builder.js
new file mode 100644
index 0000000..19c8fc2
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_arguments_object/good/query_builder.js
@@ -0,0 +1,49 @@
+function buildSelectClause(table, ...columns) {
+  if (columns.length === 0) {
+    return `SELECT * FROM ${table}`;
+  }
+  const escaped = columns.map((c) => `"${c}"`).join(", ");
+  return `SELECT ${escaped} FROM "${table}"`;
+}
+
+function buildWhereClause(...conditions) {
+  if (conditions.length === 0) return "";
+  return "WHERE " + conditions.join(" AND ");
+}
+
+function mergeQueryOptions(...optionSets) {
+  return Object.assign({}, ...optionSets);
+}
+
+function buildOrderClause(...fields) {
+  if (fields.length === 0) return "";
+  const parts = fields.map(({ column, direction = "ASC" }) => `"${column}" ${direction}`);
+  return "ORDER BY " + parts.join(", ");
+}
+
+function buildQuery(table, options = {}, ...extraConditions) {
+  const { columns = [], conditions = [], orderBy = [], limit, offset } = options;
+
+  const allConditions = [...conditions, ...extraConditions];
+
+  const parts = [
+    buildSelectClause(table, ...columns),
+    buildWhereClause(...allConditions),
+    buildOrderClause(...orderBy),
+  ].filter(Boolean);
+
+  if (limit != null) parts.push(`LIMIT ${Number(limit)}`);
+  if (offset != null) parts.push(`OFFSET ${Number(offset)}`);
+
+  return parts.join(" ");
+}
+
+function paginatedQuery(table, page, pageSize, ...baseConditions) {
+  return buildQuery(table, {
+    conditions: baseConditions,
+    limit: pageSize,
+    offset: (page - 1) * pageSize,
+  });
+}
+
+export { buildQuery, buildSelectClause, buildWhereClause, buildOrderClause, paginatedQuery, mergeQueryOptions };
diff --git a/priv/combined_metrics/samples/function_design/no_async_void_outside_event_handlers/bad/BackgroundSync.cs b/priv/combined_metrics/samples/function_design/no_async_void_outside_event_handlers/bad/BackgroundSync.cs
new file mode 100644
index 0000000..935bbe0
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_async_void_outside_event_handlers/bad/BackgroundSync.cs
@@ -0,0 +1,61 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Sync
+{
+    public class BackgroundSync
+    {
+        private readonly ISyncRepository _repository;
+        private readonly ILogger _logger;
+
+        public BackgroundSync(ISyncRepository repository, ILogger logger)
+        {
+            _repository = repository;
+            _logger = logger;
+        }
+
+        // async void: callers cannot await this; exceptions crash the process unhandled
+        public async void Synchronize()
+        {
+            var pending = await _repository.GetPendingItemsAsync();
+            foreach (var item in pending)
+            {
+                await _repository.PushItemAsync(item);
+                await _repository.MarkSyncedAsync(item.Id);
+            }
+        }
+
+        // async void: caller cannot observe exceptions or know when it finishes
+        public async void SynchronizeWithLogging()
+        {
+            try
+            {
+                var pending = await _repository.GetPendingItemsAsync();
+                foreach (var item in pending)
+                {
+                    await _repository.PushItemAsync(item);
+                    await _repository.MarkSyncedAsync(item.Id);
+                }
+            }
+            catch (Exception ex)
+            {
+                // Exception is swallowed here; no way for callers to know about it
+                _logger.Error("Sync failed", ex);
+            }
+        }
+
+        // async void: cannot be unit tested properly; cannot be awaited in service startup
+        public async void RetryFailed()
+        {
+            var failed = await _repository.GetFailedItemsAsync();
+            foreach (var item in failed)
+                await _repository.PushItemAsync(item);
+        }
+
+        public void TriggerSync()
+        {
+            // Fire-and-forget via async void — exceptions are silently lost
+            Synchronize();
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/function_design/no_async_void_outside_event_handlers/good/BackgroundSync.cs b/priv/combined_metrics/samples/function_design/no_async_void_outside_event_handlers/good/BackgroundSync.cs
new file mode 100644
index 0000000..5d14172
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_async_void_outside_event_handlers/good/BackgroundSync.cs
@@ -0,0 +1,74 @@
+using System;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+
+namespace Sync
+{
+    public class BackgroundSync
+    {
+        private readonly ISyncRepository _repository;
+        private readonly ILogger _logger;
+
+        public BackgroundSync(ISyncRepository repository, ILogger logger)
+        {
+            _repository = repository;
+            _logger = logger;
+        }
+
+        // Returns Task so callers can await, observe exceptions, and compose
+        public async Task SynchronizeAsync()
+        {
+            var pending = await _repository.GetPendingItemsAsync();
+            foreach (var item in pending)
+            {
+                await _repository.PushItemAsync(item);
+                await _repository.MarkSyncedAsync(item.Id);
+            }
+        }
+
+        public async Task<SyncResult> SynchronizeWithResultAsync()
+        {
+            int synced = 0;
+            int failed = 0;
+
+            var pending = await _repository.GetPendingItemsAsync();
+            foreach (var item in pending)
+            {
+                try
+                {
+                    await _repository.PushItemAsync(item);
+                    await _repository.MarkSyncedAsync(item.Id);
+                    synced++;
+                }
+                catch (SyncException ex)
+                {
+                    _logger.Warning("Failed to sync item {id}", ex);
+                    failed++;
+                }
+            }
+
+            return new SyncResult(synced, failed);
+        }
+
+        // async void is acceptable ONLY for event handlers — exceptions cannot be caught otherwise
+        private async void OnSyncButtonClicked(object sender, EventArgs e)
+        {
+            try
+            {
+                await SynchronizeAsync();
+            }
+            catch (Exception ex)
+            {
+                _logger.Error("Sync failed from UI button", ex);
+                MessageBox.Show("Sync failed. Please try again.");
+            }
+        }
+
+        public async Task RetryFailedAsync()
+        {
+            var failed = await _repository.GetFailedItemsAsync();
+            foreach (var item in failed)
+                await _repository.PushItemAsync(item);
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/function_design/no_boolean_parameter/bad/notifications.ex b/priv/combined_metrics/samples/function_design/no_boolean_parameter/bad/notifications.ex
new file mode 100644
index 0000000..e6f0bcd
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_boolean_parameter/bad/notifications.ex
@@ -0,0 +1,49 @@
+defmodule Notifications do
+  def send_email(user, is_welcome) do
+    if is_welcome do
+      deliver(user.email, "Welcome!", "Hello #{user.name}, welcome aboard!")
+    else
+      deliver(user.email, "See you soon", "Goodbye #{user.name}, we hope to see you again.")
+    end
+  end
+
+  def notify_order(user, order, is_shipped) do
+    if is_shipped do
+      deliver(user.email, "Your order shipped!", "Order #{order.id} is on its way.")
+    else
+      deliver(user.email, "Order confirmed", "We received your order #{order.id}.")
+    end
+  end
+
+  def send_payment_notification(user, amount, succeeded) do
+    if succeeded do
+      deliver(user.email, "Payment received", "We received your payment of #{amount}.")
+    else
+      deliver(user.email, "Payment failed", "Your payment of #{amount} could not be processed.")
+    end
+  end
+
+  def schedule_reminder(user, event, is_urgent) do
+    subject = if is_urgent, do: "[URGENT] Reminder", else: "Reminder"
+    body = "Don't forget: #{event.title} at #{event.time}"
+    deliver_with_priority(user.email, subject, body, is_urgent)
+  end
+
+  def send_admin_alert(admin, message, include_details) do
+    body =
+      if include_details do
+        "#{message}\n\nDetails: #{inspect(message)}"
+      else
+        message
+      end
+    deliver(admin.email, "Admin Alert", body)
+  end
+
+  defp deliver(to, subject, body) do
+    {:ok, %{to: to, subject: subject, body: body}}
+  end
+
+  defp deliver_with_priority(to, subject, body, urgent) do
+    {:ok, %{to: to, subject: subject, body: body, priority: if(urgent, do: :high, else: :normal)}}
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/no_boolean_parameter/config.yml b/priv/combined_metrics/samples/function_design/no_boolean_parameter/config.yml
new file mode 100644
index 0000000..fd6e0d6
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_boolean_parameter/config.yml
@@ -0,0 +1 @@
+doc: "Functions should not take boolean parameters — a flag usually means the function does two things."
diff --git a/priv/combined_metrics/samples/function_design/no_boolean_parameter/good/notifications.ex b/priv/combined_metrics/samples/function_design/no_boolean_parameter/good/notifications.ex
new file mode 100644
index 0000000..31d02cd
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_boolean_parameter/good/notifications.ex
@@ -0,0 +1,52 @@
+defmodule Notifications do
+  def send_welcome_email(user) do
+    deliver(user.email, "Welcome!", "Hello #{user.name}, welcome aboard!")
+  end
+
+  def send_farewell_email(user) do
+    deliver(user.email, "See you soon", "Goodbye #{user.name}, we hope to see you again.")
+  end
+
+  def notify_order_shipped(user, order) do
+    deliver(user.email, "Your order shipped!", "Order #{order.id} is on its way.")
+  end
+
+  def notify_order_confirmed(user, order) do
+    deliver(user.email, "Order confirmed", "We received your order #{order.id}.")
+  end
+
+  def notify_payment_received(user, amount) do
+    deliver(user.email, "Payment received", "We received your payment of #{amount}.")
+  end
+
+  def notify_payment_failed(user, amount) do
+    deliver(user.email, "Payment failed", "Your payment of #{amount} could not be processed.")
+  end
+
+  def send_urgent_reminder(user, event) do
+    body = "Don't forget: #{event.title} at #{event.time}"
+    deliver_with_priority(user.email, "[URGENT] Reminder", body, :high)
+  end
+
+  def send_reminder(user, event) do
+    body = "Don't forget: #{event.title} at #{event.time}"
+    deliver_with_priority(user.email, "Reminder", body, :normal)
+  end
+
+  def send_detailed_admin_alert(admin, message) do
+    body = "#{message}\n\nDetails: #{inspect(message)}"
+    deliver(admin.email, "Admin Alert", body)
+  end
+
+  def send_admin_alert(admin, message) do
+    deliver(admin.email, "Admin Alert", message)
+  end
+
+  defp deliver(to, subject, body) do
+    {:ok, %{to: to, subject: subject, body: body}}
+  end
+
+  defp deliver_with_priority(to, subject, body, priority) do
+    {:ok, %{to: to, subject: subject, body: body, priority: priority}}
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/no_default_arguments_on_virtual_functions/bad/Widget.cpp b/priv/combined_metrics/samples/function_design/no_default_arguments_on_virtual_functions/bad/Widget.cpp
new file mode 100644
index 0000000..55ab0ad
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_default_arguments_on_virtual_functions/bad/Widget.cpp
@@ -0,0 +1,63 @@
+#include <string>
+#include <memory>
+
+// Virtual functions with default argument values — the default is resolved statically
+// at the call site based on the static type, NOT the dynamic type.
+// This means the base class defaults are used even when a derived class override is called.
+
+class Widget {
+public:
+    virtual ~Widget() = default;
+
+    // Default argument on virtual function — resolved at compile time using static type
+    virtual void render(const RenderOptions& options = RenderOptions::defaults()) = 0;
+
+    // Default on virtual — if Button overrides this with a different default, the
+    // base default is used when called via a Widget pointer or reference
+    virtual void resize(int width, int height = 100) = 0;
+
+    virtual void highlight(const Color& color = Color::yellow()) = 0;
+
+    virtual std::string describe() const = 0;
+};
+
+class Button : public Widget {
+public:
+    explicit Button(std::string label) : label_(std::move(label)) {}
+
+    // Override with a DIFFERENT default — this default is NEVER used when called
+    // through a Widget pointer/reference; the base class default applies instead
+    void render(const RenderOptions& options = RenderOptions::minimal()) override {
+        (void)options;
+    }
+
+    void resize(int width, int height = 50) override { // different default — silently ignored via base ptr
+        width_ = width;
+        height_ = height;
+    }
+
+    void highlight(const Color& color = Color::blue()) override { // different default — same problem
+        highlightColor_ = color;
+    }
+
+    std::string describe() const override {
+        return "Button(" + label_ + ")";
+    }
+
+private:
+    std::string label_;
+    int width_ = 0;
+    int height_ = 0;
+    Color highlightColor_;
+};
+
+void demonstrate() {
+    std::unique_ptr<Widget> w = std::make_unique<Button>("OK");
+
+    // Calls Button::render, but uses Widget's default for options (RenderOptions::defaults()),
+    // NOT Button's default (RenderOptions::minimal()) — confusing and bug-prone
+    w->render();
+
+    // Same issue: uses height=100 (Widget's default), not height=50 (Button's default)
+    w->resize(200);
+}
diff --git a/priv/combined_metrics/samples/function_design/no_default_arguments_on_virtual_functions/good/Widget.cpp b/priv/combined_metrics/samples/function_design/no_default_arguments_on_virtual_functions/good/Widget.cpp
new file mode 100644
index 0000000..f763598
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_default_arguments_on_virtual_functions/good/Widget.cpp
@@ -0,0 +1,56 @@
+#include <string>
+#include <memory>
+
+// Virtual functions have no default arguments.
+// Overloads are used instead to provide convenience defaults.
+
+class Widget {
+public:
+    virtual ~Widget() = default;
+
+    // Non-default overload delegates to the virtual one — no default on virtual
+    void render() { render(RenderOptions::defaults()); }
+
+    // Virtual function takes all arguments explicitly — no defaults
+    virtual void render(const RenderOptions& options) = 0;
+
+    // Non-virtual overload provides the "quick" convenience form
+    void resize(int width) { resize(width, width); } // square resize shortcut
+    virtual void resize(int width, int height) = 0;
+
+    // Non-virtual overload with default color
+    void highlight() { highlight(Color::yellow()); }
+    virtual void highlight(const Color& color) = 0;
+
+    virtual std::string describe() const = 0;
+};
+
+class Button : public Widget {
+public:
+    explicit Button(std::string label) : label_(std::move(label)) {}
+
+    // Override takes all parameters — consistent with the virtual signature
+    void render(const RenderOptions& options) override {
+        (void)options;
+        // Renders button using provided options
+    }
+
+    void resize(int width, int height) override {
+        width_ = width;
+        height_ = height;
+    }
+
+    void highlight(const Color& color) override {
+        highlightColor_ = color;
+    }
+
+    std::string describe() const override {
+        return "Button(" + label_ + ")";
+    }
+
+private:
+    std::string label_;
+    int width_ = 0;
+    int height_ = 0;
+    Color highlightColor_;
+};
diff --git a/priv/combined_metrics/samples/function_design/no_magic_numbers/bad/discounter.ex b/priv/combined_metrics/samples/function_design/no_magic_numbers/bad/discounter.ex
new file mode 100644
index 0000000..327dd76
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_magic_numbers/bad/discounter.ex
@@ -0,0 +1,58 @@
+defmodule Discounter do
+  def apply_discount(price, :vip) do
+    price * (1 - 0.20)
+  end
+
+  def apply_discount(price, :member) do
+    price * (1 - 0.10)
+  end
+
+  def apply_discount(price, :new_user) do
+    price * (1 - 0.15)
+  end
+
+  def apply_discount(price, _), do: price
+
+  def calculate_bulk_discount(price, quantity) do
+    cond do
+      quantity >= 100 -> price * 0.70
+      quantity >= 50 -> price * 0.80
+      quantity >= 10 -> price * 0.90
+      true -> price
+    end
+  end
+
+  def apply_coupon(price, coupon_code) do
+    case coupon_code do
+      "SAVE5" -> max(price - 500, 0)
+      "SAVE10" -> max(price - 1000, 0)
+      "HALF" -> price * 0.50
+      _ -> price
+    end
+  end
+
+  def seasonal_discount(price, month) do
+    if month in [11, 12] do
+      price * 0.85
+    else
+      price
+    end
+  end
+
+  def calculate_tax(price, region) do
+    case region do
+      :us_ca -> price * 1.0725
+      :us_ny -> price * 1.08875
+      :uk -> price * 1.20
+      _ -> price
+    end
+  end
+
+  def minimum_order_discount(price, total) do
+    if total >= 10_000 do
+      price * 0.95
+    else
+      price
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/no_magic_numbers/config.yml b/priv/combined_metrics/samples/function_design/no_magic_numbers/config.yml
new file mode 100644
index 0000000..3568e7d
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_magic_numbers/config.yml
@@ -0,0 +1 @@
+doc: "Numeric literals should be named constants, not inline magic numbers."
diff --git a/priv/combined_metrics/samples/function_design/no_magic_numbers/good/discounter.ex b/priv/combined_metrics/samples/function_design/no_magic_numbers/good/discounter.ex
new file mode 100644
index 0000000..03d3298
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_magic_numbers/good/discounter.ex
@@ -0,0 +1,54 @@
+defmodule Discounter do
+  @vip_discount 0.20
+  @member_discount 0.10
+  @new_user_discount 0.15
+
+  @bulk_tier_large_threshold 100
+  @bulk_tier_medium_threshold 50
+  @bulk_tier_small_threshold 10
+  @bulk_tier_large_rate 0.70
+  @bulk_tier_medium_rate 0.80
+  @bulk_tier_small_rate 0.90
+
+  @coupon_save5_amount 500
+  @coupon_save10_amount 1000
+  @coupon_half_rate 0.50
+
+  @seasonal_months [11, 12]
+  @seasonal_rate 0.85
+
+  @minimum_order_threshold 10_000
+  @minimum_order_rate 0.95
+
+  def apply_discount(price, :vip), do: price * (1 - @vip_discount)
+  def apply_discount(price, :member), do: price * (1 - @member_discount)
+  def apply_discount(price, :new_user), do: price * (1 - @new_user_discount)
+  def apply_discount(price, _), do: price
+
+  def calculate_bulk_discount(price, quantity) do
+    cond do
+      quantity >= @bulk_tier_large_threshold -> price * @bulk_tier_large_rate
+      quantity >= @bulk_tier_medium_threshold -> price * @bulk_tier_medium_rate
+      quantity >= @bulk_tier_small_threshold -> price * @bulk_tier_small_rate
+      true -> price
+    end
+  end
+
+  def apply_coupon(price, "SAVE5"), do: max(price - @coupon_save5_amount, 0)
+  def apply_coupon(price, "SAVE10"), do: max(price - @coupon_save10_amount, 0)
+  def apply_coupon(price, "HALF"), do: price * @coupon_half_rate
+  def apply_coupon(price, _), do: price
+
+  def seasonal_discount(price, month) do
+    if month in @seasonal_months, do: price * @seasonal_rate, else: price
+  end
+
+  def calculate_tax(price, :us_ca), do: price * 1.0725
+  def calculate_tax(price, :us_ny), do: price * 1.08875
+  def calculate_tax(price, :uk), do: price * 1.20
+  def calculate_tax(price, _), do: price
+
+  def minimum_order_discount(price, total) do
+    if total >= @minimum_order_threshold, do: price * @minimum_order_rate, else: price
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/no_mutable_default_argument/bad/report_builder.py b/priv/combined_metrics/samples/function_design/no_mutable_default_argument/bad/report_builder.py
new file mode 100644
index 0000000..f68a0fd
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_mutable_default_argument/bad/report_builder.py
@@ -0,0 +1,60 @@
+"""Report builder that aggregates sections into a final report document."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class ReportSection:
+    title: str
+    body: str
+    tags: list = []  # mutable default in dataclass — same list shared across instances
+
+
+def build_report(
+    title: str,
+    sections: list = [],       # BUG: same list object reused across all calls
+    metadata: dict = {},       # BUG: same dict object reused across all calls
+) -> dict:
+    """Assemble a report dict from title, sections, and optional metadata.
+
+    Using mutable defaults means the very first caller's sections and metadata
+    are silently carried over into every subsequent call that omits those args.
+    """
+    return {
+        "title": title,
+        "generated_at": datetime.utcnow().isoformat(),
+        "metadata": metadata,
+        "sections": [
+            {"title": s.title, "body": s.body, "tags": s.tags}
+            for s in sections
+        ],
+        "section_count": len(sections),
+    }
+
+
+def append_section(
+    report: dict,
+    section: ReportSection,
+    extra_tags: list = [],     # BUG: extra_tags accumulates across calls
+) -> dict:
+    """Return a new report dict with the given section appended."""
+    extra_tags.append("auto-tagged")  # mutates the shared default list
+
+    combined_tags = section.tags + extra_tags
+    new_section = {"title": section.title, "body": section.body, "tags": combined_tags}
+
+    return {
+        **report,
+        "sections": report["sections"] + [new_section],
+        "section_count": report["section_count"] + 1,
+    }
+
+
+def summarise_tags(sections: list, seen: dict = {}) -> dict:
+    """Count occurrences of each tag — broken because seen persists between calls."""
+    for section in sections:
+        for tag in section.tags:
+            seen[tag] = seen.get(tag, 0) + 1
+    return seen
diff --git a/priv/combined_metrics/samples/function_design/no_mutable_default_argument/good/report_builder.py b/priv/combined_metrics/samples/function_design/no_mutable_default_argument/good/report_builder.py
new file mode 100644
index 0000000..472e56f
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_mutable_default_argument/good/report_builder.py
@@ -0,0 +1,72 @@
+"""Report builder that aggregates sections into a final report document."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class ReportSection:
+    title: str
+    body: str
+    tags: list[str] = field(default_factory=list)
+
+
+def build_report(
+    title: str,
+    sections: Optional[list[ReportSection]] = None,
+    metadata: Optional[dict[str, str]] = None,
+) -> dict:
+    """Assemble a report dict from title, sections, and optional metadata.
+
+    Uses None as default and initialises mutable containers inside the
+    function body so each call gets its own fresh objects.
+    """
+    if sections is None:
+        sections = []
+    if metadata is None:
+        metadata = {}
+
+    return {
+        "title": title,
+        "generated_at": datetime.utcnow().isoformat(),
+        "metadata": metadata,
+        "sections": [
+            {"title": s.title, "body": s.body, "tags": s.tags}
+            for s in sections
+        ],
+        "section_count": len(sections),
+    }
+
+
+def append_section(
+    report: dict,
+    section: ReportSection,
+    extra_tags: Optional[list[str]] = None,
+) -> dict:
+    """Return a new report dict with the given section appended.
+
+    extra_tags defaults to None; a fresh list is created when not supplied
+    so successive calls don't share the same list object.
+    """
+    if extra_tags is None:
+        extra_tags = []
+
+    combined_tags = section.tags + extra_tags
+    new_section = {"title": section.title, "body": section.body, "tags": combined_tags}
+
+    return {
+        **report,
+        "sections": report["sections"] + [new_section],
+        "section_count": report["section_count"] + 1,
+    }
+
+
+def summarise_tags(sections: list[ReportSection]) -> dict[str, int]:
+    """Count occurrences of each tag across all report sections."""
+    counts: dict[str, int] = {}
+    for section in sections:
+        for tag in section.tags:
+            counts[tag] = counts.get(tag, 0) + 1
+    return counts
diff --git a/priv/combined_metrics/samples/function_design/no_star_args_abuse/bad/notification_sender.py b/priv/combined_metrics/samples/function_design/no_star_args_abuse/bad/notification_sender.py
new file mode 100644
index 0000000..2bf25d0
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_star_args_abuse/bad/notification_sender.py
@@ -0,0 +1,48 @@
+"""Notification sender that dispatches alerts via multiple channels."""
+from __future__ import annotations
+
+
+def send_email(*args, **kwargs) -> bool:
+    """Send an e-mail — but what arguments does it actually need?
+
+    The caller must read the implementation to discover the required fields;
+    IDEs cannot autocomplete; type checkers cannot validate call sites.
+    """
+    recipient_id = args[0] if args else kwargs.get("recipient_id")
+    subject = args[1] if len(args) > 1 else kwargs.get("subject", "")
+    body = args[2] if len(args) > 2 else kwargs.get("body", "")
+    priority = kwargs.get("priority", 1)
+    template_id = kwargs.get("template_id")
+
+    print(
+        f"[EMAIL] to={recipient_id} priority={priority} "
+        f"subject={subject!r} template={template_id}"
+    )
+    return True
+
+
+def send_sms(*args, **kwargs) -> bool:
+    """Send an SMS — positional-or-keyword ambiguity makes calls error-prone."""
+    recipient_id = args[0] if args else kwargs.get("recipient_id")
+    body = args[1] if len(args) > 1 else kwargs.get("body", "")
+    priority = kwargs.get("priority", 1)
+    print(f"[SMS] to={recipient_id} priority={priority} body={body!r}")
+    return True
+
+
+def send_push(*args, **kwargs) -> bool:
+    recipient_id = args[0] if args else kwargs.get("recipient_id")
+    subject = args[1] if len(args) > 1 else kwargs.get("subject", "")
+    body = args[2] if len(args) > 2 else kwargs.get("body", "")
+    priority = kwargs.get("priority", 1)
+    print(f"[PUSH] to={recipient_id} priority={priority} title={subject!r}")
+    return True
+
+
+def dispatch(channel: str, *args, **kwargs) -> bool:
+    """Route a notification — the wildcard signature propagates the ambiguity."""
+    if channel == "email":
+        return send_email(*args, **kwargs)
+    if channel == "sms":
+        return send_sms(*args, **kwargs)
+    return send_push(*args, **kwargs)
diff --git a/priv/combined_metrics/samples/function_design/no_star_args_abuse/good/notification_sender.py b/priv/combined_metrics/samples/function_design/no_star_args_abuse/good/notification_sender.py
new file mode 100644
index 0000000..e203923
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_star_args_abuse/good/notification_sender.py
@@ -0,0 +1,78 @@
+"""Notification sender that dispatches alerts via multiple channels."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+
+class Channel(str, Enum):
+    EMAIL = "email"
+    SMS = "sms"
+    PUSH = "push"
+
+
+@dataclass
+class Notification:
+    recipient_id: str
+    subject: str
+    body: str
+    channel: Channel
+    priority: int = 1
+    template_id: Optional[str] = None
+
+
+def send_email(
+    recipient_id: str,
+    subject: str,
+    body: str,
+    priority: int = 1,
+    template_id: Optional[str] = None,
+) -> bool:
+    """Send an e-mail notification with explicit, documented parameters."""
+    print(
+        f"[EMAIL] to={recipient_id} priority={priority} "
+        f"subject={subject!r} template={template_id}"
+    )
+    return True
+
+
+def send_sms(recipient_id: str, body: str, priority: int = 1) -> bool:
+    """Send an SMS notification — only the fields SMS supports."""
+    print(f"[SMS] to={recipient_id} priority={priority} body={body!r}")
+    return True
+
+
+def send_push(
+    recipient_id: str,
+    subject: str,
+    body: str,
+    priority: int = 1,
+) -> bool:
+    """Send a push notification."""
+    print(f"[PUSH] to={recipient_id} priority={priority} title={subject!r}")
+    return True
+
+
+def dispatch(notification: Notification) -> bool:
+    """Route a Notification to the appropriate sender."""
+    if notification.channel == Channel.EMAIL:
+        return send_email(
+            notification.recipient_id,
+            notification.subject,
+            notification.body,
+            priority=notification.priority,
+            template_id=notification.template_id,
+        )
+    if notification.channel == Channel.SMS:
+        return send_sms(
+            notification.recipient_id,
+            notification.body,
+            priority=notification.priority,
+        )
+    return send_push(
+        notification.recipient_id,
+        notification.subject,
+        notification.body,
+        priority=notification.priority,
+    )
diff --git a/priv/combined_metrics/samples/function_design/no_static_class_for_namespacing/bad/date_utils.ts b/priv/combined_metrics/samples/function_design/no_static_class_for_namespacing/bad/date_utils.ts
new file mode 100644
index 0000000..900d7be
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_static_class_for_namespacing/bad/date_utils.ts
@@ -0,0 +1,62 @@
+class DateUtils {
+  static formatDate(date: Date | string | number, locale = "en-US"): string {
+    return new Intl.DateTimeFormat(locale, {
+      year: "numeric",
+      month: "short",
+      day: "numeric",
+    }).format(new Date(date));
+  }
+
+  static formatDateTime(date: Date | string | number, locale = "en-US"): string {
+    return new Intl.DateTimeFormat(locale, {
+      year: "numeric",
+      month: "short",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+    }).format(new Date(date));
+  }
+
+  static isToday(date: Date | string | number): boolean {
+    const d = new Date(date);
+    const now = new Date();
+    return (
+      d.getFullYear() === now.getFullYear() &&
+      d.getMonth() === now.getMonth() &&
+      d.getDate() === now.getDate()
+    );
+  }
+
+  static addDays(date: Date, days: number): Date {
+    const result = new Date(date);
+    result.setDate(result.getDate() + days);
+    return result;
+  }
+
+  static differenceInDays(a: Date, b: Date): number {
+    const msPerDay = 1000 * 60 * 60 * 24;
+    return Math.round((a.getTime() - b.getTime()) / msPerDay);
+  }
+
+  static startOfDay(date: Date): Date {
+    const result = new Date(date);
+    result.setHours(0, 0, 0, 0);
+    return result;
+  }
+
+  static endOfDay(date: Date): Date {
+    const result = new Date(date);
+    result.setHours(23, 59, 59, 999);
+    return result;
+  }
+
+  static parseIsoDate(isoString: string): Date {
+    const date = new Date(isoString);
+    if (Number.isNaN(date.getTime())) {
+      throw new RangeError(`Invalid ISO date string: '${isoString}'`);
+    }
+    return date;
+  }
+}
+
+export { DateUtils };
diff --git a/priv/combined_metrics/samples/function_design/no_static_class_for_namespacing/good/date_utils.ts b/priv/combined_metrics/samples/function_design/no_static_class_for_namespacing/good/date_utils.ts
new file mode 100644
index 0000000..4f0f040
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_static_class_for_namespacing/good/date_utils.ts
@@ -0,0 +1,58 @@
+export function formatDate(date: Date | string | number, locale = "en-US"): string {
+  return new Intl.DateTimeFormat(locale, {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+  }).format(new Date(date));
+}
+
+export function formatDateTime(date: Date | string | number, locale = "en-US"): string {
+  return new Intl.DateTimeFormat(locale, {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+  }).format(new Date(date));
+}
+
+export function isToday(date: Date | string | number): boolean {
+  const d = new Date(date);
+  const now = new Date();
+  return (
+    d.getFullYear() === now.getFullYear() &&
+    d.getMonth() === now.getMonth() &&
+    d.getDate() === now.getDate()
+  );
+}
+
+export function addDays(date: Date, days: number): Date {
+  const result = new Date(date);
+  result.setDate(result.getDate() + days);
+  return result;
+}
+
+export function differenceInDays(a: Date, b: Date): number {
+  const msPerDay = 1000 * 60 * 60 * 24;
+  return Math.round((a.getTime() - b.getTime()) / msPerDay);
+}
+
+export function startOfDay(date: Date): Date {
+  const result = new Date(date);
+  result.setHours(0, 0, 0, 0);
+  return result;
+}
+
+export function endOfDay(date: Date): Date {
+  const result = new Date(date);
+  result.setHours(23, 59, 59, 999);
+  return result;
+}
+
+export function parseIsoDate(isoString: string): Date {
+  const date = new Date(isoString);
+  if (Number.isNaN(date.getTime())) {
+    throw new RangeError(`Invalid ISO date string: '${isoString}'`);
+  }
+  return date;
+}
diff --git a/priv/combined_metrics/samples/function_design/no_static_only_container_classes/bad/string_utils.js b/priv/combined_metrics/samples/function_design/no_static_only_container_classes/bad/string_utils.js
new file mode 100644
index 0000000..cbff685
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_static_only_container_classes/bad/string_utils.js
@@ -0,0 +1,52 @@
+class StringUtils {
+  static slugify(text) {
+    return text
+      .toLowerCase()
+      .trim()
+      .replace(/[^\w\s-]/g, "")
+      .replace(/[\s_-]+/g, "-")
+      .replace(/^-+|-+$/g, "");
+  }
+
+  static truncate(text, maxLength, ellipsis = "...") {
+    if (text.length <= maxLength) return text;
+    return text.slice(0, maxLength - ellipsis.length) + ellipsis;
+  }
+
+  static capitalize(text) {
+    if (!text) return text;
+    return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
+  }
+
+  static titleCase(text) {
+    return text.replace(/\b\w/g, (c) => c.toUpperCase());
+  }
+
+  static stripHtml(html) {
+    return html.replace(/<[^>]+>/g, "");
+  }
+
+  static countWords(text) {
+    return text.trim().split(/\s+/).filter(Boolean).length;
+  }
+
+  static interpolate(template, variables) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+      return key in variables ? String(variables[key]) : `{{${key}}}`;
+    });
+  }
+
+  static padStart(text, targetLength, padChar = " ") {
+    return String(text).padStart(targetLength, padChar);
+  }
+
+  static camelToKebab(text) {
+    return text.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+  }
+
+  static kebabToCamel(text) {
+    return text.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+  }
+}
+
+export { StringUtils };
diff --git a/priv/combined_metrics/samples/function_design/no_static_only_container_classes/good/string_utils.js b/priv/combined_metrics/samples/function_design/no_static_only_container_classes/good/string_utils.js
new file mode 100644
index 0000000..e664cd4
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_static_only_container_classes/good/string_utils.js
@@ -0,0 +1,48 @@
+export function slugify(text) {
+  return text
+    .toLowerCase()
+    .trim()
+    .replace(/[^\w\s-]/g, "")
+    .replace(/[\s_-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+export function truncate(text, maxLength, ellipsis = "...") {
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength - ellipsis.length) + ellipsis;
+}
+
+export function capitalize(text) {
+  if (!text) return text;
+  return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
+}
+
+export function titleCase(text) {
+  return text.replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+export function stripHtml(html) {
+  return html.replace(/<[^>]+>/g, "");
+}
+
+export function countWords(text) {
+  return text.trim().split(/\s+/).filter(Boolean).length;
+}
+
+export function interpolate(template, variables) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+    return key in variables ? String(variables[key]) : `{{${key}}}`;
+  });
+}
+
+export function padStart(text, targetLength, padChar = " ") {
+  return String(text).padStart(targetLength, padChar);
+}
+
+export function camelToKebab(text) {
+  return text.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+
+export function kebabToCamel(text) {
+  return text.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
diff --git a/priv/combined_metrics/samples/function_design/no_unrelated_clauses_in_multi_clause_function/bad/notifications.ex b/priv/combined_metrics/samples/function_design/no_unrelated_clauses_in_multi_clause_function/bad/notifications.ex
new file mode 100644
index 0000000..720c89c
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_unrelated_clauses_in_multi_clause_function/bad/notifications.ex
@@ -0,0 +1,51 @@
+defmodule MyApp.Notifications do
+  @moduledoc """
+  Notification utilities.
+  """
+
+  alias MyApp.Notifications.{Email, Push, SMS}
+
+  # Bad: `process/1` groups completely unrelated operations under one name.
+  # Some clauses send notifications, one formats, one validates — all different logic.
+  def process(%Email{to: to, subject: subject, body: body}) do
+    # Sends email
+    MyApp.Mailer.deliver(%{to: to, subject: subject, body: body})
+  end
+
+  def process(%Push{device_token: token, title: title, message: message}) do
+    # Sends push notification
+    MyApp.PushGateway.send(token, %{title: title, body: message})
+  end
+
+  def process(%SMS{phone: phone, body: body}) do
+    # Sends SMS
+    MyApp.SMSGateway.send(phone, body)
+  end
+
+  # Bad: this clause does formatting, not sending — unrelated to the above
+  def process({:format, %Email{subject: subject}}) do
+    "Email: #{subject}"
+  end
+
+  # Bad: this clause does validation — entirely different concern
+  def process({:validate, %Email{to: to}}) do
+    String.contains?(to, "@")
+  end
+
+  # Bad: this clause handles retry logic — yet another unrelated responsibility
+  def process({:retry, notification, attempts}) when attempts > 0 do
+    case process(notification) do
+      :ok -> :ok
+      {:error, _} -> process({:retry, notification, attempts - 1})
+    end
+  end
+
+  def process({:retry, _notification, 0}), do: {:error, :exhausted}
+
+  # Bad: logging concern mixed in
+  def process({:log, notification}) do
+    require Logger
+    Logger.info("Notification: #{inspect(notification)}")
+    :ok
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/no_unrelated_clauses_in_multi_clause_function/good/notifications.ex b/priv/combined_metrics/samples/function_design/no_unrelated_clauses_in_multi_clause_function/good/notifications.ex
new file mode 100644
index 0000000..0f40c8a
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/no_unrelated_clauses_in_multi_clause_function/good/notifications.ex
@@ -0,0 +1,46 @@
+defmodule MyApp.Notifications do
+  @moduledoc """
+  Sends notifications through different channels. Each multi-clause
+  function groups only clauses that implement the same logical operation.
+  """
+
+  alias MyApp.Notifications.{Email, Push, SMS}
+
+  @doc """
+  Sends a notification through the appropriate channel based on the
+  notification struct type. All clauses implement the same `send/1` contract.
+  """
+  @spec send(Email.t() | Push.t() | SMS.t()) :: :ok | {:error, term()}
+  def send(%Email{to: to, subject: subject, body: body}) do
+    MyApp.Mailer.deliver(%{to: to, subject: subject, body: body})
+  end
+
+  def send(%Push{device_token: token, title: title, message: message}) do
+    MyApp.PushGateway.send(token, %{title: title, body: message})
+  end
+
+  def send(%SMS{phone: phone, body: body}) do
+    MyApp.SMSGateway.send(phone, body)
+  end
+
+  @doc """
+  Formats a notification for display in the UI. All clauses produce
+  a string representation of the same notification type.
+  """
+  @spec format(Email.t() | Push.t() | SMS.t()) :: String.t()
+  def format(%Email{subject: subject}), do: "Email: #{subject}"
+  def format(%Push{title: title}), do: "Push: #{title}"
+  def format(%SMS{body: body}), do: "SMS: #{String.slice(body, 0, 40)}"
+
+  @doc """
+  Retries a failed notification delivery up to `max_attempts` times.
+  """
+  @spec retry(Email.t() | Push.t() | SMS.t(), non_neg_integer()) :: :ok | {:error, :exhausted}
+  def retry(notification, 0), do: {:error, :exhausted}
+  def retry(notification, attempts_left) when attempts_left > 0 do
+    case send(notification) do
+      :ok -> :ok
+      {:error, _} -> retry(notification, attempts_left - 1)
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/parameter_count_under_4/bad/email_sender.ex b/priv/combined_metrics/samples/function_design/parameter_count_under_4/bad/email_sender.ex
new file mode 100644
index 0000000..e1e65c5
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/parameter_count_under_4/bad/email_sender.ex
@@ -0,0 +1,35 @@
+defmodule EmailSender do
+  def send_email(to, from, subject, body, cc, bcc, reply_to) do
+    headers = build_headers(from, subject, cc, bcc, reply_to)
+    deliver(to, headers, body)
+  end
+
+  def send_template_email(to, from, subject, template, assigns, locale, priority) do
+    rendered = render_template(template, assigns, locale)
+    headers = build_headers(from, subject, nil, nil, nil)
+    deliver_with_priority(to, headers, rendered, priority)
+  end
+
+  def send_notification(user_email, sender_email, notification_type, title, message, include_unsubscribe, tracking_id) do
+    body = compose_notification_body(notification_type, title, message, include_unsubscribe, tracking_id)
+    headers = build_headers(sender_email, title, nil, nil, nil)
+    deliver(user_email, headers, body)
+  end
+
+  def schedule_email(to, from, subject, body, send_at, timezone, retry_count) do
+    normalized_time = normalize_time(send_at, timezone)
+    job = %{to: to, from: from, subject: subject, body: body, send_at: normalized_time, retries: retry_count}
+    enqueue_job(job)
+  end
+
+  defp build_headers(from, subject, cc, bcc, reply_to) do
+    %{from: from, subject: subject, cc: cc, bcc: bcc, reply_to: reply_to}
+  end
+
+  defp deliver(to, headers, body), do: {:ok, %{to: to, headers: headers, body: body}}
+  defp deliver_with_priority(to, headers, body, priority), do: {:ok, %{to: to, headers: headers, body: body, priority: priority}}
+  defp render_template(template, assigns, locale), do: "rendered:#{template}:#{locale}:#{inspect(assigns)}"
+  defp compose_notification_body(type, title, message, unsub, tracking), do: "#{type}|#{title}|#{message}|#{unsub}|#{tracking}"
+  defp normalize_time(time, tz), do: {time, tz}
+  defp enqueue_job(job), do: {:ok, job}
+end
diff --git a/priv/combined_metrics/samples/function_design/parameter_count_under_4/config.yml b/priv/combined_metrics/samples/function_design/parameter_count_under_4/config.yml
new file mode 100644
index 0000000..796a325
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/parameter_count_under_4/config.yml
@@ -0,0 +1 @@
+doc: "Functions should take fewer than 4 parameters."
diff --git a/priv/combined_metrics/samples/function_design/parameter_count_under_4/good/email_sender.ex b/priv/combined_metrics/samples/function_design/parameter_count_under_4/good/email_sender.ex
new file mode 100644
index 0000000..6f3e1c2
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/parameter_count_under_4/good/email_sender.ex
@@ -0,0 +1,48 @@
+defmodule EmailSender do
+  defstruct [:to, :from, :subject, :body, :cc, :bcc, :reply_to]
+
+  def send_email(%__MODULE__{} = email) do
+    headers = build_headers(email)
+    deliver(email.to, headers, email.body)
+  end
+
+  def send_template_email(recipient, template, opts \\ %{}) do
+    body = render_template(template, opts)
+    email = %__MODULE__{to: recipient, from: opts[:from], subject: opts[:subject], body: body}
+    send_email(email)
+  end
+
+  def send_notification(user_email, notification) do
+    body = compose_notification_body(notification)
+    email = %__MODULE__{
+      to: user_email,
+      from: notification.sender,
+      subject: notification.title,
+      body: body
+    }
+    send_email(email)
+  end
+
+  def schedule_email(%__MODULE__{} = email, schedule_opts) do
+    normalized_time = normalize_time(schedule_opts.send_at, schedule_opts.timezone)
+    job = %{email: email, send_at: normalized_time, retries: schedule_opts[:retry_count] || 3}
+    enqueue_job(job)
+  end
+
+  defp build_headers(%__MODULE__{} = email) do
+    %{from: email.from, subject: email.subject, cc: email.cc, bcc: email.bcc, reply_to: email.reply_to}
+  end
+
+  defp render_template(template, opts) do
+    locale = Map.get(opts, :locale, "en")
+    "rendered:#{template}:#{locale}"
+  end
+
+  defp compose_notification_body(notification) do
+    "#{notification.type}|#{notification.title}|#{notification.message}"
+  end
+
+  defp deliver(to, headers, body), do: {:ok, %{to: to, headers: headers, body: body}}
+  defp normalize_time(time, tz), do: {time, tz}
+  defp enqueue_job(job), do: {:ok, job}
+end
diff --git a/priv/combined_metrics/samples/function_design/prefers_synchronous_functions/bad/validator.go b/priv/combined_metrics/samples/function_design/prefers_synchronous_functions/bad/validator.go
new file mode 100644
index 0000000..cd52591
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/prefers_synchronous_functions/bad/validator.go
@@ -0,0 +1,54 @@
+package validator
+
+import (
+	"strings"
+)
+
+// Report holds the result of validating an email address.
+type Report struct {
+	Valid      bool
+	Normalized string
+	Issues     []string
+}
+
+// EmailValidator checks whether an address meets format and domain rules.
+type EmailValidator struct {
+	blockedDomains []string
+}
+
+// New constructs an EmailValidator.
+func New(blockedDomains []string) *EmailValidator {
+	return &EmailValidator{blockedDomains: blockedDomains}
+}
+
+// Validate starts validation asynchronously and returns a channel.
+// Callers must receive from the channel to get the result, which complicates
+// error handling, makes composition harder, and adds unnecessary goroutine overhead
+// for work that is purely CPU-bound and completes immediately.
+func (v *EmailValidator) Validate(address string) <-chan *Report {
+	out := make(chan *Report, 1)
+	go func() {
+		report := &Report{}
+		normalized := strings.ToLower(strings.TrimSpace(address))
+
+		if !strings.Contains(normalized, "@") {
+			report.Issues = append(report.Issues, "missing @ symbol")
+		}
+
+		parts := strings.SplitN(normalized, "@", 2)
+		if len(parts) == 2 {
+			domain := parts[1]
+			for _, blocked := range v.blockedDomains {
+				if domain == blocked {
+					report.Issues = append(report.Issues, "domain is blocked")
+				}
+			}
+		}
+
+		report.Normalized = normalized
+		report.Valid = len(report.Issues) == 0
+		out <- report
+		close(out)
+	}()
+	return out
+}
diff --git a/priv/combined_metrics/samples/function_design/prefers_synchronous_functions/good/validator.go b/priv/combined_metrics/samples/function_design/prefers_synchronous_functions/good/validator.go
new file mode 100644
index 0000000..f28dd30
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/prefers_synchronous_functions/good/validator.go
@@ -0,0 +1,53 @@
+package validator
+
+import (
+	"context"
+	"errors"
+	"strings"
+)
+
+// Report holds the result of validating an email address.
+type Report struct {
+	Valid      bool
+	Normalized string
+	Issues     []string
+}
+
+// EmailValidator checks whether an address meets format and domain rules.
+type EmailValidator struct {
+	blockedDomains []string
+}
+
+// New constructs an EmailValidator.
+func New(blockedDomains []string) *EmailValidator {
+	return &EmailValidator{blockedDomains: blockedDomains}
+}
+
+// Validate returns a Report synchronously. The caller gets the result directly
+// without needing to receive from a channel or register a callback.
+func (v *EmailValidator) Validate(ctx context.Context, address string) (*Report, error) {
+	if ctx.Err() != nil {
+		return nil, ctx.Err()
+	}
+
+	report := &Report{}
+	normalized := strings.ToLower(strings.TrimSpace(address))
+
+	if !strings.Contains(normalized, "@") {
+		report.Issues = append(report.Issues, "missing @ symbol")
+	}
+
+	parts := strings.SplitN(normalized, "@", 2)
+	if len(parts) == 2 {
+		domain := parts[1]
+		for _, blocked := range v.blockedDomains {
+			if domain == blocked {
+				return nil, errors.New("domain is blocked")
+			}
+		}
+	}
+
+	report.Normalized = normalized
+	report.Valid = len(report.Issues) == 0
+	return report, nil
+}
diff --git a/priv/combined_metrics/samples/function_design/promise_returning_functions_are_async/bad/notification_handler.ts b/priv/combined_metrics/samples/function_design/promise_returning_functions_are_async/bad/notification_handler.ts
new file mode 100644
index 0000000..909600f
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/promise_returning_functions_are_async/bad/notification_handler.ts
@@ -0,0 +1,63 @@
+interface Notification {
+  id: string;
+  userId: string;
+  type: string;
+  title: string;
+  body: string;
+  sentAt: string | null;
+}
+
+interface SendResult {
+  notificationId: string;
+  success: boolean;
+  error?: string;
+}
+
+// Returns a Promise but is not marked async
+function fetchNotification(id: string): Promise<Notification> {
+  return fetch(`/api/notifications/${id}`)
+    .then((response) => {
+      if (!response.ok) throw new Error(`Notification not found: ${id}`);
+      return response.json() as Promise<Notification>;
+    });
+}
+
+// Returns a Promise but is not marked async
+function sendNotification(notification: Notification): Promise<SendResult> {
+  return fetch("/api/notifications/send", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ id: notification.id }),
+  }).then((response) => {
+    if (!response.ok) {
+      return { notificationId: notification.id, success: false, error: `HTTP ${response.status}` };
+    }
+    return { notificationId: notification.id, success: true };
+  });
+}
+
+// Returns a Promise but is not marked async
+function fetchAndSend(notificationId: string): Promise<SendResult> {
+  return fetchNotification(notificationId).then((notification) =>
+    sendNotification(notification)
+  );
+}
+
+// Returns a Promise but is not marked async
+function sendBatch(notificationIds: string[]): Promise<SendResult[]> {
+  return Promise.allSettled(
+    notificationIds.map((id) => fetchAndSend(id))
+  ).then((results) =>
+    results.map((result, index) => {
+      if (result.status === "fulfilled") return result.value;
+      return {
+        notificationId: notificationIds[index],
+        success: false,
+        error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+      };
+    })
+  );
+}
+
+export { fetchNotification, sendNotification, fetchAndSend, sendBatch };
+export type { Notification, SendResult };
diff --git a/priv/combined_metrics/samples/function_design/promise_returning_functions_are_async/good/notification_handler.ts b/priv/combined_metrics/samples/function_design/promise_returning_functions_are_async/good/notification_handler.ts
new file mode 100644
index 0000000..cdf660b
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/promise_returning_functions_are_async/good/notification_handler.ts
@@ -0,0 +1,62 @@
+interface Notification {
+  id: string;
+  userId: string;
+  type: string;
+  title: string;
+  body: string;
+  sentAt: string | null;
+}
+
+interface SendResult {
+  notificationId: string;
+  success: boolean;
+  error?: string;
+}
+
+async function fetchNotification(id: string): Promise<Notification> {
+  const response = await fetch(`/api/notifications/${id}`);
+  if (!response.ok) throw new Error(`Notification not found: ${id}`);
+  return response.json() as Promise<Notification>;
+}
+
+async function sendNotification(notification: Notification): Promise<SendResult> {
+  const response = await fetch("/api/notifications/send", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ id: notification.id }),
+  });
+
+  if (!response.ok) {
+    return { notificationId: notification.id, success: false, error: `HTTP ${response.status}` };
+  }
+
+  return { notificationId: notification.id, success: true };
+}
+
+async function fetchAndSend(notificationId: string): Promise<SendResult> {
+  const notification = await fetchNotification(notificationId);
+  return sendNotification(notification);
+}
+
+async function sendBatch(notificationIds: string[]): Promise<SendResult[]> {
+  const results = await Promise.allSettled(
+    notificationIds.map((id) => fetchAndSend(id))
+  );
+
+  return results.map((result, index) => {
+    if (result.status === "fulfilled") return result.value;
+    return {
+      notificationId: notificationIds[index],
+      success: false,
+      error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+    };
+  });
+}
+
+async function scheduleNotification(notification: Notification, delayMs: number): Promise<void> {
+  await new Promise<void>((resolve) => setTimeout(resolve, delayMs));
+  await sendNotification(notification);
+}
+
+export { fetchNotification, sendNotification, fetchAndSend, sendBatch, scheduleNotification };
+export type { Notification, SendResult };
diff --git a/priv/combined_metrics/samples/function_design/return_values_over_output_parameters/bad/Parser.cpp b/priv/combined_metrics/samples/function_design/return_values_over_output_parameters/bad/Parser.cpp
new file mode 100644
index 0000000..a507801
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/return_values_over_output_parameters/bad/Parser.cpp
@@ -0,0 +1,76 @@
+#include <string>
+#include <string_view>
+#include <vector>
+
+struct ParsedField {
+    std::string name;
+    std::string value;
+};
+
+struct ParsedRecord {
+    std::vector<ParsedField> fields;
+    int lineNumber;
+};
+
+// Output parameter instead of return value — caller must pre-declare result variable
+bool parseField(std::string_view line, ParsedField& outField) {  // output param
+    auto sep = line.find('=');
+    if (sep == std::string_view::npos)
+        return false;
+
+    outField.name  = std::string(line.substr(0, sep));
+    outField.value = std::string(line.substr(sep + 1));
+    return true;
+}
+
+// Output parameter for the main result — harder to chain/compose
+void parseRecord(const std::vector<std::string>& lines, int startLine,
+                 ParsedRecord& outRecord)  // output param
+{
+    outRecord.lineNumber = startLine;
+    outRecord.fields.clear();
+
+    for (const auto& line : lines) {
+        ParsedField field;  // must pre-declare for the out-param call below
+        if (parseField(line, field))
+            outRecord.fields.push_back(field);
+    }
+}
+
+// Two output parameters when a struct or pair would be cleaner
+bool validateField(const ParsedField& field,
+                   bool& outIsValid,       // output param
+                   std::string& outError)  // output param
+{
+    if (field.name.empty()) {
+        outIsValid = false;
+        outError = "Field name must not be empty";
+        return false;
+    }
+    if (field.value.empty()) {
+        outIsValid = false;
+        outError = "Field value must not be empty";
+        return false;
+    }
+    outIsValid = true;
+    return true;
+}
+
+// Three output parameters — function is hard to call and hard to read
+bool splitOnFirst(std::string_view text, char delimiter,
+                  std::string& outBefore,  // output param
+                  std::string& outAfter,   // output param
+                  bool& outFound)          // output param
+{
+    auto pos = text.find(delimiter);
+    if (pos == std::string_view::npos) {
+        outBefore = std::string(text);
+        outAfter.clear();
+        outFound = false;
+        return false;
+    }
+    outBefore = std::string(text.substr(0, pos));
+    outAfter  = std::string(text.substr(pos + 1));
+    outFound  = true;
+    return true;
+}
diff --git a/priv/combined_metrics/samples/function_design/return_values_over_output_parameters/good/Parser.cpp b/priv/combined_metrics/samples/function_design/return_values_over_output_parameters/good/Parser.cpp
new file mode 100644
index 0000000..9d966c2
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/return_values_over_output_parameters/good/Parser.cpp
@@ -0,0 +1,68 @@
+#include <optional>
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <vector>
+
+struct ParsedField {
+    std::string name;
+    std::string value;
+};
+
+struct ParsedRecord {
+    std::vector<ParsedField> fields;
+    int lineNumber;
+};
+
+// Returns value directly — caller receives a clear, named result
+std::optional<ParsedField> parseField(std::string_view line) {
+    auto sep = line.find('=');
+    if (sep == std::string_view::npos)
+        return std::nullopt;
+
+    return ParsedField{
+        std::string(line.substr(0, sep)),
+        std::string(line.substr(sep + 1))
+    };
+}
+
+// Returns by value — no output parameters needed
+ParsedRecord parseRecord(const std::vector<std::string>& lines, int startLine) {
+    ParsedRecord record;
+    record.lineNumber = startLine;
+
+    for (const auto& line : lines) {
+        auto field = parseField(line);
+        if (field)
+            record.fields.push_back(std::move(*field));
+    }
+
+    return record;
+}
+
+// Returns structured binding-friendly pair — no out-params
+std::pair<bool, std::string> validateField(const ParsedField& field) {
+    if (field.name.empty())
+        return {false, "Field name must not be empty"};
+    if (field.value.empty())
+        return {false, "Field value must not be empty"};
+    return {true, {}};
+}
+
+// Multiple values returned as a struct — readable and composable
+struct SplitResult {
+    std::string before;
+    std::string after;
+    bool found;
+};
+
+SplitResult splitOnFirst(std::string_view text, char delimiter) {
+    auto pos = text.find(delimiter);
+    if (pos == std::string_view::npos)
+        return {std::string(text), {}, false};
+    return {
+        std::string(text.substr(0, pos)),
+        std::string(text.substr(pos + 1)),
+        true
+    };
+}
diff --git a/priv/combined_metrics/samples/function_design/uses_assertive_map_access/bad/shipping.ex b/priv/combined_metrics/samples/function_design/uses_assertive_map_access/bad/shipping.ex
new file mode 100644
index 0000000..e55eb8d
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_assertive_map_access/bad/shipping.ex
@@ -0,0 +1,71 @@
+defmodule MyApp.Shipping do
+  @moduledoc """
+  Shipping label generation and address validation.
+  """
+
+  alias MyApp.Shipping.{Address, Label, Shipment}
+
+  # Bad: bracket access used for required fields — silently returns nil
+  # instead of crashing, making bugs harder to detect
+  @spec build_label(Shipment.t()) :: Label.t()
+  def build_label(%Shipment{} = shipment) do
+    # Bad: these are required — should use dot access
+    order_id = shipment[:order_id]
+    recipient = shipment[:recipient]
+    carrier = shipment[:carrier]
+
+    # Bad: required nested fields also use bracket access
+    to_name = recipient[:name]
+    raw_address = recipient[:address]
+
+    %Label{
+      order_id: order_id,
+      to_name: to_name,
+      to_address: format_address(raw_address),
+      carrier: carrier
+    }
+  end
+
+  # Bad: dot access on a plain map for optional fields that may not exist,
+  # causing a KeyError for optional data
+  @spec validate_address(map()) :: :ok | {:error, [String.t()]}
+  def validate_address(address) do
+    # Bad: dot access on a plain map will raise if key is missing
+    street = address.street
+    city = address.city
+    country = address.country
+    # Also bad for optional fields: should use bracket access, not dot
+    postal = address.postal_code
+    state = address.state
+
+    errors =
+      []
+      |> check_present(street, "street is required")
+      |> check_present(city, "city is required")
+      |> check_present(country, "country is required")
+
+    case errors do
+      [] -> :ok
+      errs -> {:error, errs}
+    end
+  end
+
+  # Bad: all fields accessed with bracket notation even required ones
+  @spec calculate_cost(Shipment.t()) :: float()
+  def calculate_cost(shipment) do
+    base_rate = shipment[:carrier_rate] || 0
+    weight = shipment[:weight_grams] || 0
+    insurance = shipment[:insurance_value] || 0
+    discount = shipment[:discount_rate] || 0.0
+
+    (base_rate + weight * 0.01 + insurance * 0.001) * (1.0 - discount)
+  end
+
+  defp check_present(errors, nil, msg), do: [msg | errors]
+  defp check_present(errors, "", msg), do: [msg | errors]
+  defp check_present(errors, _, _), do: errors
+
+  defp format_address(addr) when is_map(addr) do
+    "#{addr[:street]}, #{addr[:city]}, #{addr[:country]}"
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/uses_assertive_map_access/good/shipping.ex b/priv/combined_metrics/samples/function_design/uses_assertive_map_access/good/shipping.ex
new file mode 100644
index 0000000..7cee245
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_assertive_map_access/good/shipping.ex
@@ -0,0 +1,80 @@
+defmodule MyApp.Shipping do
+  @moduledoc """
+  Shipping label generation and address validation.
+  Uses dot-access (`map.key`) for required fields and
+  bracket-access (`map[:key]`) for optional fields.
+  """
+
+  alias MyApp.Shipping.{Address, Label, Shipment}
+
+  @doc """
+  Builds a shipping label from a shipment. Required fields are
+  accessed with dot notation; optional fields use bracket notation.
+  """
+  @spec build_label(Shipment.t()) :: Label.t()
+  def build_label(%Shipment{} = shipment) do
+    # Required fields: dot access — crash immediately if missing
+    order_id = shipment.order_id
+    recipient = shipment.recipient
+    carrier = shipment.carrier
+
+    # Optional field: bracket access — may be nil
+    reference = shipment[:reference_number]
+    instructions = shipment[:delivery_instructions]
+
+    %Label{
+      order_id: order_id,
+      to_name: recipient.name,
+      to_address: format_address(recipient.address),
+      carrier: carrier,
+      reference: reference,
+      instructions: instructions
+    }
+  end
+
+  @doc """
+  Validates a shipping address. Required fields accessed with dot notation.
+  """
+  @spec validate_address(Address.t()) :: :ok | {:error, [String.t()]}
+  def validate_address(%Address{} = address) do
+    # Dot access for required fields
+    errors =
+      []
+      |> check_present(address.street, "street is required")
+      |> check_present(address.city, "city is required")
+      |> check_present(address.country, "country is required")
+
+    # Bracket access for optional fields
+    _postal = address[:postal_code]
+    _state = address[:state]
+
+    case errors do
+      [] -> :ok
+      errs -> {:error, errs}
+    end
+  end
+
+  @doc """
+  Calculates the shipping cost for a shipment.
+  """
+  @spec calculate_cost(Shipment.t()) :: float()
+  def calculate_cost(%Shipment{} = shipment) do
+    # Required — dot access
+    base_rate = shipment.carrier_rate
+    weight = shipment.weight_grams
+
+    # Optional — bracket access
+    insurance = shipment[:insurance_value] || 0
+    discount = shipment[:discount_rate] || 0.0
+
+    (base_rate + weight * 0.01 + insurance * 0.001) * (1.0 - discount)
+  end
+
+  defp check_present(errors, nil, msg), do: [msg | errors]
+  defp check_present(errors, "", msg), do: [msg | errors]
+  defp check_present(errors, _, _), do: errors
+
+  defp format_address(%Address{} = addr) do
+    "#{addr.street}, #{addr.city}, #{addr.country}"
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/uses_assertive_pattern_matching/bad/inventory.ex b/priv/combined_metrics/samples/function_design/uses_assertive_pattern_matching/bad/inventory.ex
new file mode 100644
index 0000000..f4d63d2
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_assertive_pattern_matching/bad/inventory.ex
@@ -0,0 +1,62 @@
+defmodule MyApp.Inventory do
+  @moduledoc """
+  Inventory management.
+  """
+
+  alias MyApp.Inventory.{Product, StockLevel}
+  alias MyApp.Repo
+
+  # Bad: defensively wraps every operation in case, even when
+  # the caller should just crash on truly unexpected failures
+  @spec decrement_stock(integer(), pos_integer()) :: {:ok, StockLevel.t()} | {:error, atom()}
+  def decrement_stock(product_id, quantity) do
+    case Repo.get(Product, product_id) do
+      nil ->
+        {:error, :not_found}
+
+      product ->
+        case Map.get(product, :stock) do
+          nil ->
+            {:error, :no_stock_field}
+
+          current_stock ->
+            if current_stock >= quantity do
+              case product |> Product.changeset(%{stock: current_stock - quantity}) |> Repo.update() do
+                {:ok, updated} -> {:ok, updated}
+                {:error, changeset} -> {:error, changeset}
+              end
+            else
+              {:error, :insufficient_stock}
+            end
+        end
+    end
+  end
+
+  # Bad: wrapping every step in case when assertive matching would be clearer
+  @spec process_replenishment(map()) :: :ok | {:error, atom()}
+  def process_replenishment(event) do
+    case Map.get(event, :product_id) do
+      nil ->
+        {:error, :missing_product_id}
+
+      id ->
+        case Map.get(event, :quantity) do
+          nil ->
+            {:error, :missing_quantity}
+
+          qty ->
+            case Repo.get(Product, id) do
+              nil ->
+                {:error, :product_not_found}
+
+              product ->
+                product
+                |> Product.changeset(%{stock: product.stock + qty})
+                |> Repo.update()
+
+                :ok
+            end
+        end
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/uses_assertive_pattern_matching/good/inventory.ex b/priv/combined_metrics/samples/function_design/uses_assertive_pattern_matching/good/inventory.ex
new file mode 100644
index 0000000..c8755bb
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_assertive_pattern_matching/good/inventory.ex
@@ -0,0 +1,67 @@
+defmodule MyApp.Inventory do
+  @moduledoc """
+  Inventory management. Uses assertive pattern matching — functions
+  bind expected shapes directly and crash on unexpected input rather
+  than defensively guarding every case.
+  """
+
+  alias MyApp.Inventory.{Product, StockLevel}
+  alias MyApp.Repo
+
+  @doc """
+  Decrements stock for a product. Expects `{:ok, product}` from the
+  upstream call and binds it directly.
+  """
+  @spec decrement_stock(integer(), pos_integer()) :: {:ok, StockLevel.t()} | {:error, :insufficient_stock}
+  def decrement_stock(product_id, quantity) do
+    # Assertive: crash if get_product!/1 raises — we don't silently swallow missing products
+    product = Repo.get!(Product, product_id)
+
+    # Assertive: pattern match the struct's stock field directly
+    %Product{stock: current_stock} = product
+
+    if current_stock >= quantity do
+      product
+      |> Product.changeset(%{stock: current_stock - quantity})
+      |> Repo.update()
+    else
+      {:error, :insufficient_stock}
+    end
+  end
+
+  @doc """
+  Processes a stock replenishment event from the warehouse feed.
+  Asserts the expected map shape and crashes on malformed input.
+  """
+  @spec process_replenishment(map()) :: :ok
+  def process_replenishment(%{product_id: id, quantity: qty, warehouse: wh}) do
+    product = Repo.get!(Product, id)
+
+    product
+    |> Product.changeset(%{stock: product.stock + qty, last_warehouse: wh})
+    |> Repo.update!()
+
+    :ok
+  end
+
+  @doc """
+  Transfers stock between warehouses. Asserts both locations exist.
+  """
+  @spec transfer(integer(), String.t(), String.t(), pos_integer()) :: {:ok, map()} | {:error, term()}
+  def transfer(product_id, from_warehouse, to_warehouse, quantity) do
+    {:ok, product} = Repo.fetch(Product, product_id)
+    %Product{stock_by_warehouse: stock_map} = product
+
+    # Assertive access — crashes if warehouse key is missing
+    from_stock = Map.fetch!(stock_map, from_warehouse)
+
+    updated =
+      stock_map
+      |> Map.put(from_warehouse, from_stock - quantity)
+      |> Map.update!(to_warehouse, &(&1 + quantity))
+
+    product
+    |> Product.changeset(%{stock_by_warehouse: updated})
+    |> Repo.update()
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/uses_default_parameters_over_overloads/bad/EmailSender.kt b/priv/combined_metrics/samples/function_design/uses_default_parameters_over_overloads/bad/EmailSender.kt
new file mode 100644
index 0000000..21a9207
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_default_parameters_over_overloads/bad/EmailSender.kt
@@ -0,0 +1,48 @@
+package com.example.email
+
+class EmailSender(private val smtpClient: SmtpClient) {
+
+    // Multiple overloads instead of one function with default parameters
+
+    fun send(to: String, subject: String, body: String): SendResult {
+        return send(to, subject, body, emptyList())
+    }
+
+    fun send(to: String, subject: String, body: String, cc: List<String>): SendResult {
+        return send(to, subject, body, cc, emptyList())
+    }
+
+    fun send(to: String, subject: String, body: String, cc: List<String>, bcc: List<String>): SendResult {
+        return send(to, subject, body, cc, bcc, null)
+    }
+
+    fun send(to: String, subject: String, body: String, cc: List<String>, bcc: List<String>, replyTo: String?): SendResult {
+        return send(to, subject, body, cc, bcc, replyTo, false)
+    }
+
+    fun send(to: String, subject: String, body: String, cc: List<String>, bcc: List<String>, replyTo: String?, isHtml: Boolean): SendResult {
+        return send(to, subject, body, cc, bcc, replyTo, isHtml, EmailPriority.NORMAL)
+    }
+
+    fun send(
+        to: String,
+        subject: String,
+        body: String,
+        cc: List<String>,
+        bcc: List<String>,
+        replyTo: String?,
+        isHtml: Boolean,
+        priority: EmailPriority
+    ): SendResult {
+        val message = EmailMessage(to, subject, body, cc, bcc, replyTo, isHtml, priority)
+        return smtpClient.dispatch(message)
+    }
+
+    fun sendBatch(recipients: List<String>, subject: String, body: String): List<SendResult> {
+        return recipients.map { send(it, subject, body) }
+    }
+
+    fun sendBatchHtml(recipients: List<String>, subject: String, body: String): List<SendResult> {
+        return recipients.map { send(it, subject, body, emptyList(), emptyList(), null, true) }
+    }
+}
diff --git a/priv/combined_metrics/samples/function_design/uses_default_parameters_over_overloads/good/EmailSender.kt b/priv/combined_metrics/samples/function_design/uses_default_parameters_over_overloads/good/EmailSender.kt
new file mode 100644
index 0000000..c6ccb2f
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_default_parameters_over_overloads/good/EmailSender.kt
@@ -0,0 +1,49 @@
+package com.example.email
+
+data class EmailMessage(
+    val to: String,
+    val subject: String,
+    val body: String,
+    val cc: List<String> = emptyList(),
+    val bcc: List<String> = emptyList(),
+    val replyTo: String? = null,
+    val isHtml: Boolean = false,
+    val priority: EmailPriority = EmailPriority.NORMAL
+)
+
+class EmailSender(private val smtpClient: SmtpClient) {
+
+    // Single function with default parameters instead of multiple overloads
+    fun send(
+        to: String,
+        subject: String,
+        body: String,
+        cc: List<String> = emptyList(),
+        bcc: List<String> = emptyList(),
+        replyTo: String? = null,
+        isHtml: Boolean = false,
+        priority: EmailPriority = EmailPriority.NORMAL
+    ): SendResult {
+        val message = EmailMessage(
+            to = to,
+            subject = subject,
+            body = body,
+            cc = cc,
+            bcc = bcc,
+            replyTo = replyTo,
+            isHtml = isHtml,
+            priority = priority
+        )
+        return smtpClient.dispatch(message)
+    }
+
+    fun sendBatch(
+        recipients: List<String>,
+        subject: String,
+        body: String,
+        isHtml: Boolean = false,
+        priority: EmailPriority = EmailPriority.NORMAL
+    ): List<SendResult> {
+        return recipients.map { send(it, subject, body, isHtml = isHtml, priority = priority) }
+    }
+}
diff --git a/priv/combined_metrics/samples/function_design/uses_defer_for_cleanup/bad/filestore.go b/priv/combined_metrics/samples/function_design/uses_defer_for_cleanup/bad/filestore.go
new file mode 100644
index 0000000..c715e25
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_defer_for_cleanup/bad/filestore.go
@@ -0,0 +1,75 @@
+package filestore
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"sync"
+)
+
+// Record is a key-value pair written to disk.
+type Record struct {
+	Key   string `json:"key"`
+	Value string `json:"value"`
+}
+
+// FileStore persists records to a JSON file with a mutex protecting concurrent access.
+type FileStore struct {
+	path string
+	mu   sync.Mutex
+}
+
+// New constructs a FileStore for the given file path.
+func New(path string) *FileStore {
+	return &FileStore{path: path}
+}
+
+// Write appends a record to the store file.
+// Manual cleanup is easy to forget on error paths; if Encode fails, Unlock
+// is called but Close is skipped, leaking the file descriptor.
+func (s *FileStore) Write(rec Record) error {
+	s.mu.Lock() // no defer — must be manually unlocked on every path
+
+	f, err := os.OpenFile(s.path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		s.mu.Unlock() // easy to forget
+		return fmt.Errorf("write record %q: open file: %w", rec.Key, err)
+	}
+
+	enc := json.NewEncoder(f)
+	if err := enc.Encode(rec); err != nil {
+		// f.Close() missing here — file descriptor leaks on encode failure
+		s.mu.Unlock()
+		return fmt.Errorf("write record %q: encode: %w", rec.Key, err)
+	}
+
+	f.Close()
+	s.mu.Unlock()
+	return nil
+}
+
+// Read opens the store file and decodes all records.
+func (s *FileStore) Read() ([]Record, error) {
+	s.mu.Lock()
+
+	f, err := os.Open(s.path)
+	if err != nil {
+		s.mu.Unlock()
+		return nil, fmt.Errorf("read store: open: %w", err)
+	}
+
+	var records []Record
+	dec := json.NewDecoder(f)
+	for dec.More() {
+		var r Record
+		if err := dec.Decode(&r); err != nil {
+			// f.Close() and Unlock missing — both leak on decode error
+			return nil, fmt.Errorf("read store: decode: %w", err)
+		}
+		records = append(records, r)
+	}
+
+	f.Close()
+	s.mu.Unlock()
+	return records, nil
+}
diff --git a/priv/combined_metrics/samples/function_design/uses_defer_for_cleanup/good/filestore.go b/priv/combined_metrics/samples/function_design/uses_defer_for_cleanup/good/filestore.go
new file mode 100644
index 0000000..54e3b4d
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_defer_for_cleanup/good/filestore.go
@@ -0,0 +1,68 @@
+package filestore
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"sync"
+)
+
+// Record is a key-value pair written to disk.
+type Record struct {
+	Key   string `json:"key"`
+	Value string `json:"value"`
+}
+
+// FileStore persists records to a JSON file with a mutex protecting concurrent access.
+type FileStore struct {
+	path string
+	mu   sync.Mutex
+}
+
+// New constructs a FileStore for the given file path.
+func New(path string) *FileStore {
+	return &FileStore{path: path}
+}
+
+// Write appends a record to the store file.
+// defer is used immediately after acquiring the lock and after opening the file
+// so cleanup always runs, even if an error occurs mid-function.
+func (s *FileStore) Write(rec Record) error {
+	s.mu.Lock()
+	defer s.mu.Unlock() // released when Write returns, regardless of error path
+
+	f, err := os.OpenFile(s.path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		return fmt.Errorf("write record %q: open file: %w", rec.Key, err)
+	}
+	defer f.Close() // closed when Write returns, even if Encode fails
+
+	enc := json.NewEncoder(f)
+	if err := enc.Encode(rec); err != nil {
+		return fmt.Errorf("write record %q: encode: %w", rec.Key, err)
+	}
+	return nil
+}
+
+// Read opens the store file and decodes all records.
+func (s *FileStore) Read() ([]Record, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	f, err := os.Open(s.path)
+	if err != nil {
+		return nil, fmt.Errorf("read store: open: %w", err)
+	}
+	defer f.Close()
+
+	var records []Record
+	dec := json.NewDecoder(f)
+	for dec.More() {
+		var r Record
+		if err := dec.Decode(&r); err != nil {
+			return nil, fmt.Errorf("read store: decode: %w", err)
+		}
+		records = append(records, r)
+	}
+	return records, nil
+}
diff --git a/priv/combined_metrics/samples/function_design/uses_enumerate_not_range_len/bad/item_processor.py b/priv/combined_metrics/samples/function_design/uses_enumerate_not_range_len/bad/item_processor.py
new file mode 100644
index 0000000..46129e9
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_enumerate_not_range_len/bad/item_processor.py
@@ -0,0 +1,64 @@
+"""Item processor that validates, transforms, and ranks catalogue entries."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class CatalogueItem:
+    sku: str
+    name: str
+    price: float
+    stock: int
+
+
+def validate_items(items: list) -> list:
+    """Return a list of (index, error_message) for any invalid items."""
+    errors = []
+    for i in range(len(items)):          # range(len(...)) instead of enumerate
+        item = items[i]
+        if item.price < 0:
+            errors.append((i, f"Item {item.sku}: negative price {item.price}"))
+        if item.stock < 0:
+            errors.append((i, f"Item {item.sku}: negative stock {item.stock}"))
+        if not item.name.strip():
+            errors.append((i, f"Item {item.sku}: empty name"))
+    return errors
+
+
+def apply_discount(items: list, percent: float) -> list:
+    """Return new items with a discount applied."""
+    factor = 1.0 - percent / 100.0
+    result = []
+    for i in range(len(items)):          # range(len(...)) instead of a direct loop
+        item = items[i]
+        result.append(
+            CatalogueItem(
+                sku=item.sku,
+                name=item.name,
+                price=round(item.price * factor, 2),
+                stock=item.stock,
+            )
+        )
+    return result
+
+
+def find_duplicates(items: list) -> list:
+    """Return index pairs (i, j) where items share the same SKU."""
+    duplicates = []
+    for i in range(len(items)):
+        for j in range(i + 1, len(items)):   # nested range(len(...))
+            if items[i].sku == items[j].sku:
+                duplicates.append((i, j))
+    return duplicates
+
+
+def format_listing(items: list) -> list:
+    """Produce numbered display strings for each item."""
+    lines = []
+    for i in range(len(items)):          # range(len(...)) again
+        item = items[i]
+        lines.append(
+            f"{i + 1}. [{item.sku}] {item.name} — ${item.price:.2f} ({item.stock} in stock)"
+        )
+    return lines
diff --git a/priv/combined_metrics/samples/function_design/uses_enumerate_not_range_len/good/item_processor.py b/priv/combined_metrics/samples/function_design/uses_enumerate_not_range_len/good/item_processor.py
new file mode 100644
index 0000000..57aa7b3
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_enumerate_not_range_len/good/item_processor.py
@@ -0,0 +1,64 @@
+"""Item processor that validates, transforms, and ranks catalogue entries."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class CatalogueItem:
+    sku: str
+    name: str
+    price: float
+    stock: int
+
+
+def validate_items(items: list[CatalogueItem]) -> list[tuple[int, str]]:
+    """Return a list of (index, error_message) for any invalid items."""
+    errors: list[tuple[int, str]] = []
+    for index, item in enumerate(items):
+        if item.price < 0:
+            errors.append((index, f"Item {item.sku}: negative price {item.price}"))
+        if item.stock < 0:
+            errors.append((index, f"Item {item.sku}: negative stock {item.stock}"))
+        if not item.name.strip():
+            errors.append((index, f"Item {item.sku}: empty name"))
+    return errors
+
+
+def apply_discount(items: list[CatalogueItem], percent: float) -> list[CatalogueItem]:
+    """Return new items with a discount applied, preserving original order."""
+    factor = 1.0 - percent / 100.0
+    return [
+        CatalogueItem(
+            sku=item.sku,
+            name=item.name,
+            price=round(item.price * factor, 2),
+            stock=item.stock,
+        )
+        for item in items
+    ]
+
+
+def find_duplicates(items: list[CatalogueItem]) -> list[tuple[int, int]]:
+    """Return index pairs (i, j) where items share the same SKU."""
+    duplicates: list[tuple[int, int]] = []
+    for i, item_a in enumerate(items):
+        for j, item_b in enumerate(items[i + 1 :], start=i + 1):
+            if item_a.sku == item_b.sku:
+                duplicates.append((i, j))
+    return duplicates
+
+
+def rank_by_value(items: list[CatalogueItem]) -> list[tuple[int, CatalogueItem]]:
+    """Return items sorted by total value (price * stock), with their original index."""
+    indexed = list(enumerate(items))
+    return sorted(indexed, key=lambda pair: pair[1].price * pair[1].stock, reverse=True)
+
+
+def format_listing(items: list[CatalogueItem]) -> list[str]:
+    """Produce numbered display strings for each item."""
+    return [
+        f"{position + 1}. [{item.sku}] {item.name} — ${item.price:.2f} ({item.stock} in stock)"
+        for position, item in enumerate(items)
+    ]
diff --git a/priv/combined_metrics/samples/function_design/uses_generator_over_list_comprehension/bad/data_pipeline.py b/priv/combined_metrics/samples/function_design/uses_generator_over_list_comprehension/bad/data_pipeline.py
new file mode 100644
index 0000000..ce67c14
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_generator_over_list_comprehension/bad/data_pipeline.py
@@ -0,0 +1,52 @@
+"""Data pipeline that streams and transforms records from a CSV source."""
+from __future__ import annotations
+
+import csv
+import io
+
+
+def parse_rows(raw_csv: str) -> list[dict[str, str]]:
+    """Return ALL CSV rows as a list — entire dataset loaded into memory."""
+    reader = csv.DictReader(io.StringIO(raw_csv))
+    return [row for row in reader]  # unnecessary full materialisation
+
+
+def normalise_record(record: dict[str, str]) -> dict:
+    return {
+        "id": record.get("id", "").strip(),
+        "name": record.get("name", "").strip().title(),
+        "amount": float(record.get("amount", 0) or 0),
+        "active": record.get("active", "false").lower() == "true",
+    }
+
+
+def filter_active(records: list[dict]) -> list[dict]:
+    """Build a full list of active records even if we only need to iterate once."""
+    return [r for r in records if r.get("active")]  # list when a generator suffices
+
+
+def total_amount(records: list[dict]) -> float:
+    """Convert to list before summing — wastes memory for large record sets."""
+    amounts = [r["amount"] for r in records]  # builds full list just to sum it
+    return sum(amounts)
+
+
+def top_n_names(records: list[dict], n: int) -> list[str]:
+    """Creates multiple intermediate lists unnecessarily."""
+    filtered = [r for r in records if r.get("amount", 0) > 0]  # list 1
+    sorted_records = sorted(filtered, key=lambda r: r["amount"], reverse=True)
+    names = [r["name"] for r in sorted_records]  # list 2 — all names, not just n
+    return names[:n]
+
+
+def run_pipeline(raw_csv: str) -> dict:
+    """Executes the full pipeline — every step materialises a new list."""
+    rows = parse_rows(raw_csv)
+    normalised = [normalise_record(r) for r in rows]  # list
+    active = filter_active(normalised)                  # another list
+
+    return {
+        "total_records": len(active),
+        "total_amount": total_amount(active),
+        "top_3": top_n_names(active, 3),
+    }
diff --git a/priv/combined_metrics/samples/function_design/uses_generator_over_list_comprehension/good/data_pipeline.py b/priv/combined_metrics/samples/function_design/uses_generator_over_list_comprehension/good/data_pipeline.py
new file mode 100644
index 0000000..902c2dc
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_generator_over_list_comprehension/good/data_pipeline.py
@@ -0,0 +1,60 @@
+"""Data pipeline that streams and transforms records from a CSV source."""
+from __future__ import annotations
+
+import csv
+import io
+from typing import Generator, Iterable
+
+
+def parse_rows(raw_csv: str) -> Generator[dict[str, str], None, None]:
+    """Yield each CSV row as a dict without loading all rows into memory."""
+    reader = csv.DictReader(io.StringIO(raw_csv))
+    yield from reader
+
+
+def normalise_record(record: dict[str, str]) -> dict[str, str | float]:
+    """Return a cleaned copy of a single record."""
+    return {
+        "id": record.get("id", "").strip(),
+        "name": record.get("name", "").strip().title(),
+        "amount": float(record.get("amount", 0) or 0),
+        "active": record.get("active", "false").lower() == "true",
+    }
+
+
+def filter_active(
+    records: Iterable[dict],
+) -> Generator[dict, None, None]:
+    """Yield only records where active is True — generator, no full list built."""
+    return (r for r in records if r.get("active"))
+
+
+def total_amount(records: Iterable[dict]) -> float:
+    """Sum amounts across records using a generator expression — no intermediate list."""
+    return sum(r["amount"] for r in records)
+
+
+def top_n_names(records: Iterable[dict], n: int) -> list[str]:
+    """Return the n largest amounts' names.
+
+    We only need to iterate once; a generator feeds sorted() directly.
+    """
+    sorted_records = sorted(
+        (r for r in records if r.get("amount", 0) > 0),
+        key=lambda r: r["amount"],
+        reverse=True,
+    )
+    return [r["name"] for r in sorted_records[:n]]
+
+
+def run_pipeline(raw_csv: str) -> dict:
+    """Execute the full pipeline and return a summary."""
+    rows = parse_rows(raw_csv)
+    normalised = (normalise_record(r) for r in rows)  # generator, not list
+    active = list(filter_active(normalised))           # materialise only once
+
+    return {
+        "total_records": len(active),
+        "total_amount": total_amount(active),
+        "top_3": top_n_names(active, 3),
+    }
diff --git a/priv/combined_metrics/samples/function_design/uses_keyword_arguments_over_option_hash/bad/invoice.rb b/priv/combined_metrics/samples/function_design/uses_keyword_arguments_over_option_hash/bad/invoice.rb
new file mode 100644
index 0000000..2cfaac8
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_keyword_arguments_over_option_hash/bad/invoice.rb
@@ -0,0 +1,62 @@
+class InvoiceBuilder
+  def initialize(repository)
+    @repository = repository
+  end
+
+  # opts hash — callers cannot tell what keys are accepted or required
+  def build(customer_id, line_items, opts = {})
+    currency = opts[:currency] || "USD"
+    due_in_days = opts[:due_in_days] || 30
+    notes = opts[:notes]
+    tax_rate = opts[:tax_rate] || 0.0
+    discount_percent = opts[:discount_percent] || 0
+
+    subtotal = calculate_subtotal(line_items)
+    discount = apply_discount(subtotal, discount_percent)
+    tax = (subtotal - discount) * tax_rate
+    total = subtotal - discount + tax
+    due_date = Date.today + due_in_days
+
+    @repository.create!(
+      customer_id: customer_id,
+      line_items: line_items,
+      currency: currency,
+      subtotal: subtotal,
+      discount: discount,
+      tax: tax,
+      total: total,
+      due_date: due_date,
+      notes: notes,
+      status: :draft
+    )
+  end
+
+  # opts hash makes the interface opaque
+  def send_reminder(invoice_id, opts = {})
+    medium = opts[:medium] || :email
+    cc_addresses = opts[:cc_addresses] || []
+    include_pdf = opts.key?(:include_pdf) ? opts[:include_pdf] : true
+
+    invoice = @repository.find(invoice_id)
+    raise ArgumentError, "Invoice not found: #{invoice_id}" unless invoice
+    raise ArgumentError, "Invoice is already paid" if invoice.paid?
+
+    ReminderMailer.send(
+      invoice: invoice,
+      medium: medium,
+      cc_addresses: cc_addresses,
+      include_pdf: include_pdf
+    )
+  end
+
+  private
+
+  def calculate_subtotal(line_items)
+    line_items.sum { |item| item[:quantity] * item[:unit_price] }
+  end
+
+  def apply_discount(subtotal, discount_percent)
+    return 0.0 if discount_percent.zero?
+    subtotal * (discount_percent / 100.0)
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/uses_keyword_arguments_over_option_hash/good/invoice.rb b/priv/combined_metrics/samples/function_design/uses_keyword_arguments_over_option_hash/good/invoice.rb
new file mode 100644
index 0000000..be8fb1f
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_keyword_arguments_over_option_hash/good/invoice.rb
@@ -0,0 +1,58 @@
+class InvoiceBuilder
+  def initialize(repository)
+    @repository = repository
+  end
+
+  def build(
+    customer_id:,
+    line_items:,
+    currency: "USD",
+    due_in_days: 30,
+    notes: nil,
+    tax_rate: 0.0,
+    discount_percent: 0
+  )
+    subtotal = calculate_subtotal(line_items)
+    discount = apply_discount(subtotal, discount_percent)
+    tax = (subtotal - discount) * tax_rate
+    total = subtotal - discount + tax
+    due_date = Date.today + due_in_days
+
+    @repository.create!(
+      customer_id: customer_id,
+      line_items: line_items,
+      currency: currency,
+      subtotal: subtotal,
+      discount: discount,
+      tax: tax,
+      total: total,
+      due_date: due_date,
+      notes: notes,
+      status: :draft
+    )
+  end
+
+  def send_reminder(invoice_id:, medium: :email, cc_addresses: [], include_pdf: true)
+    invoice = @repository.find(invoice_id)
+    raise ArgumentError, "Invoice not found: #{invoice_id}" unless invoice
+    raise ArgumentError, "Invoice is already paid" if invoice.paid?
+
+    ReminderMailer.send(
+      invoice: invoice,
+      medium: medium,
+      cc_addresses: cc_addresses,
+      include_pdf: include_pdf
+    )
+  end
+
+  private
+
+  def calculate_subtotal(line_items)
+    line_items.sum { |item| item[:quantity] * item[:unit_price] }
+  end
+
+  def apply_discount(subtotal, discount_percent)
+    return 0.0 if discount_percent.zero?
+    subtotal * (discount_percent / 100.0)
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/uses_named_arguments_for_multiple_same_type_params/bad/SubscriptionService.kt b/priv/combined_metrics/samples/function_design/uses_named_arguments_for_multiple_same_type_params/bad/SubscriptionService.kt
new file mode 100644
index 0000000..4ccd34c
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_named_arguments_for_multiple_same_type_params/bad/SubscriptionService.kt
@@ -0,0 +1,39 @@
+package com.example.subscriptions
+
+import java.time.LocalDate
+
+class SubscriptionService(private val repository: SubscriptionRepository) {
+
+    fun createSubscription(userId: String, planId: String, referralCode: String? = null): Subscription {
+        val plan = repository.findPlan(planId) ?: throw PlanNotFoundException(planId)
+        val subscription = Subscription(userId = userId, planId = planId, referralCode = referralCode)
+        return repository.save(subscription)
+    }
+
+    fun transferSubscription(fromUserId: String, toUserId: String, subscriptionId: String): Boolean {
+        val sub = repository.findById(subscriptionId) ?: return false
+        if (sub.userId != fromUserId) return false
+        val transferred = sub.copy(userId = toUserId)
+        repository.save(transferred)
+        return true
+    }
+
+    fun scheduleRenewal(subscriptionId: String, renewalDate: LocalDate, graceEndDate: LocalDate) {
+        val sub = repository.findById(subscriptionId) ?: return
+        val scheduled = sub.copy(nextRenewalDate = renewalDate, graceEndDate = graceEndDate)
+        repository.save(scheduled)
+    }
+}
+
+fun main() {
+    val service = SubscriptionService(SubscriptionRepository())
+
+    // No named arguments — "user-123", "plan-pro", "FRIEND10" are positional, easy to swap
+    service.createSubscription("user-123", "plan-pro", "FRIEND10")
+
+    // fromUserId and toUserId have the same type — easy to accidentally swap them
+    service.transferSubscription("user-abc", "user-xyz", "sub-999")
+
+    // Two LocalDate params next to each other — renewalDate and graceEndDate order is guesswork
+    service.scheduleRenewal("sub-001", LocalDate.of(2026, 4, 1), LocalDate.of(2026, 4, 15))
+}
diff --git a/priv/combined_metrics/samples/function_design/uses_named_arguments_for_multiple_same_type_params/good/SubscriptionService.kt b/priv/combined_metrics/samples/function_design/uses_named_arguments_for_multiple_same_type_params/good/SubscriptionService.kt
new file mode 100644
index 0000000..cc34962
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_named_arguments_for_multiple_same_type_params/good/SubscriptionService.kt
@@ -0,0 +1,57 @@
+package com.example.subscriptions
+
+import java.time.LocalDate
+
+class SubscriptionService(private val repository: SubscriptionRepository) {
+
+    fun createSubscription(
+        userId: String,
+        planId: String,
+        referralCode: String? = null
+    ): Subscription {
+        val plan = repository.findPlan(planId) ?: throw PlanNotFoundException(planId)
+        val subscription = Subscription(userId = userId, planId = planId, referralCode = referralCode)
+        return repository.save(subscription)
+    }
+
+    fun transferSubscription(fromUserId: String, toUserId: String, subscriptionId: String): Boolean {
+        val sub = repository.findById(subscriptionId) ?: return false
+        if (sub.userId != fromUserId) return false
+        val transferred = sub.copy(userId = toUserId)
+        repository.save(transferred)
+        return true
+    }
+
+    fun scheduleRenewal(subscriptionId: String, renewalDate: LocalDate, graceEndDate: LocalDate) {
+        val sub = repository.findById(subscriptionId) ?: return
+        val scheduled = sub.copy(nextRenewalDate = renewalDate, graceEndDate = graceEndDate)
+        repository.save(scheduled)
+    }
+
+    fun findInDateRange(startDate: LocalDate, endDate: LocalDate): List<Subscription> {
+        return repository.findCreatedBetween(startDate = startDate, endDate = endDate)
+    }
+}
+
+fun main() {
+    val service = SubscriptionService(SubscriptionRepository())
+
+    // Named arguments make the call site unambiguous for multiple String params
+    service.createSubscription(
+        userId = "user-123",
+        planId = "plan-pro",
+        referralCode = "FRIEND10"
+    )
+
+    service.transferSubscription(
+        fromUserId = "user-abc",
+        toUserId = "user-xyz",
+        subscriptionId = "sub-999"
+    )
+
+    service.scheduleRenewal(
+        subscriptionId = "sub-001",
+        renewalDate = LocalDate.of(2026, 4, 1),
+        graceEndDate = LocalDate.of(2026, 4, 15)
+    )
+}
diff --git a/priv/combined_metrics/samples/function_design/uses_pattern_matching_over_conditionals/bad/orders.ex b/priv/combined_metrics/samples/function_design/uses_pattern_matching_over_conditionals/bad/orders.ex
new file mode 100644
index 0000000..8decf43
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_pattern_matching_over_conditionals/bad/orders.ex
@@ -0,0 +1,70 @@
+defmodule MyApp.Orders do
+  @moduledoc """
+  Order processing logic.
+  """
+
+  alias MyApp.Orders.Order
+  alias MyApp.Repo
+
+  # Bad: nested if/else chain instead of multi-clause functions
+  @spec transition(Order.t()) :: {:ok, Order.t()} | {:error, :invalid_transition}
+  def transition(order) do
+    if order.status == :pending do
+      order
+      |> Order.changeset(%{status: :confirmed})
+      |> Repo.update()
+    else
+      if order.status == :confirmed do
+        order
+        |> Order.changeset(%{status: :shipped})
+        |> Repo.update()
+      else
+        if order.status == :shipped do
+          order
+          |> Order.changeset(%{status: :delivered})
+          |> Repo.update()
+        else
+          {:error, :invalid_transition}
+        end
+      end
+    end
+  end
+
+  # Bad: case on a field value instead of pattern matching in clause head
+  @spec apply_discount(Order.t(), atom()) :: Order.t()
+  def apply_discount(order, tier) do
+    case tier do
+      :standard ->
+        order
+
+      :premium ->
+        %{order | total: order.total * 0.90}
+
+      :vip ->
+        %{order | total: order.total * 0.80}
+
+      _ ->
+        order
+    end
+  end
+
+  # Bad: conditional chain in function body instead of clause heads
+  @spec format_total(Order.t()) :: String.t()
+  def format_total(order) do
+    amount = :erlang.float_to_binary(order.total / 100, decimals: 2)
+
+    if order.currency == :usd do
+      "$#{amount}"
+    else
+      if order.currency == :eur do
+        "€#{amount}"
+      else
+        if order.currency == :gbp do
+          "£#{amount}"
+        else
+          "#{order.total} #{order.currency}"
+        end
+      end
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/uses_pattern_matching_over_conditionals/good/orders.ex b/priv/combined_metrics/samples/function_design/uses_pattern_matching_over_conditionals/good/orders.ex
new file mode 100644
index 0000000..47ba358
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_pattern_matching_over_conditionals/good/orders.ex
@@ -0,0 +1,57 @@
+defmodule MyApp.Orders do
+  @moduledoc """
+  Order processing logic. Uses multi-clause functions and pattern
+  matching instead of nested conditionals.
+  """
+
+  alias MyApp.Orders.Order
+  alias MyApp.Repo
+
+  @doc """
+  Transitions an order to the next state based on its current status.
+  Each clause handles exactly one state transition.
+  """
+  @spec transition(Order.t()) :: {:ok, Order.t()} | {:error, :invalid_transition}
+  def transition(%Order{status: :pending} = order) do
+    order
+    |> Order.changeset(%{status: :confirmed})
+    |> Repo.update()
+  end
+
+  def transition(%Order{status: :confirmed} = order) do
+    order
+    |> Order.changeset(%{status: :shipped})
+    |> Repo.update()
+  end
+
+  def transition(%Order{status: :shipped} = order) do
+    order
+    |> Order.changeset(%{status: :delivered})
+    |> Repo.update()
+  end
+
+  def transition(%Order{status: status}) when status in [:delivered, :cancelled] do
+    {:error, :invalid_transition}
+  end
+
+  @doc """
+  Applies a discount to the order based on the customer's membership tier.
+  """
+  @spec apply_discount(Order.t(), :standard | :premium | :vip) :: Order.t()
+  def apply_discount(%Order{} = order, :standard), do: order
+  def apply_discount(%Order{total: total} = order, :premium) do
+    %{order | total: total * 0.90}
+  end
+  def apply_discount(%Order{total: total} = order, :vip) do
+    %{order | total: total * 0.80}
+  end
+
+  @doc """
+  Formats the order total for display based on the currency.
+  """
+  @spec format_total(Order.t()) :: String.t()
+  def format_total(%Order{total: total, currency: :usd}), do: "$#{:erlang.float_to_binary(total / 100, decimals: 2)}"
+  def format_total(%Order{total: total, currency: :eur}), do: "€#{:erlang.float_to_binary(total / 100, decimals: 2)}"
+  def format_total(%Order{total: total, currency: :gbp}), do: "£#{:erlang.float_to_binary(total / 100, decimals: 2)}"
+  def format_total(%Order{total: total, currency: currency}), do: "#{total} #{currency}"
+end
diff --git a/priv/combined_metrics/samples/function_design/uses_ternary_expression/bad/formatter.ex b/priv/combined_metrics/samples/function_design/uses_ternary_expression/bad/formatter.ex
new file mode 100644
index 0000000..5cf10a0
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_ternary_expression/bad/formatter.ex
@@ -0,0 +1,65 @@
+defmodule Formatter do
+  def format_status(status) do
+    if status == :active do
+      "Active"
+    else
+      "Inactive"
+    end
+  end
+
+  def format_price(cents) do
+    if cents == 0 do
+      "Free"
+    else
+      "$#{:erlang.float_to_binary(cents / 100, decimals: 2)}"
+    end
+  end
+
+  def format_count(count) do
+    if count == 1 do
+      "1 item"
+    else
+      "#{count} items"
+    end
+  end
+
+  def format_user_label(user) do
+    if user.role == :admin do
+      "[Admin] #{user.name}"
+    else
+      user.name
+    end
+  end
+
+  def format_availability(stock) do
+    if stock > 0 do
+      "In stock"
+    else
+      "Out of stock"
+    end
+  end
+
+  def format_change(delta) do
+    if delta >= 0 do
+      "+#{delta}"
+    else
+      "#{delta}"
+    end
+  end
+
+  def format_verified(user) do
+    if user.verified do
+      "#{user.email} (verified)"
+    else
+      user.email
+    end
+  end
+
+  def format_priority(level) do
+    if level >= 8 do
+      "HIGH"
+    else
+      "NORMAL"
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/uses_ternary_expression/config.yml b/priv/combined_metrics/samples/function_design/uses_ternary_expression/config.yml
new file mode 100644
index 0000000..7c0adb8
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_ternary_expression/config.yml
@@ -0,0 +1 @@
+doc: "Simple conditional assignments should use inline expressions rather than full if-blocks."
diff --git a/priv/combined_metrics/samples/function_design/uses_ternary_expression/good/formatter.ex b/priv/combined_metrics/samples/function_design/uses_ternary_expression/good/formatter.ex
new file mode 100644
index 0000000..4d343e5
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_ternary_expression/good/formatter.ex
@@ -0,0 +1,32 @@
+defmodule Formatter do
+  def format_status(status) do
+    if status == :active, do: "Active", else: "Inactive"
+  end
+
+  def format_price(0), do: "Free"
+
+  def format_price(cents) do
+    "$#{:erlang.float_to_binary(cents / 100, decimals: 2)}"
+  end
+
+  def format_count(1), do: "1 item"
+  def format_count(count), do: "#{count} items"
+
+  def format_user_label(%{role: :admin, name: name}), do: "[Admin] #{name}"
+  def format_user_label(%{name: name}), do: name
+
+  def format_availability(stock) do
+    if stock > 0, do: "In stock", else: "Out of stock"
+  end
+
+  def format_change(delta) do
+    if delta >= 0, do: "+#{delta}", else: "#{delta}"
+  end
+
+  def format_verified(%{verified: true, email: email}), do: "#{email} (verified)"
+  def format_verified(%{email: email}), do: email
+
+  def format_priority(level) do
+    if level >= 8, do: "HIGH", else: "NORMAL"
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/uses_when_for_three_or_more_branches/bad/ShippingCalculator.kt b/priv/combined_metrics/samples/function_design/uses_when_for_three_or_more_branches/bad/ShippingCalculator.kt
new file mode 100644
index 0000000..9af1144
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_when_for_three_or_more_branches/bad/ShippingCalculator.kt
@@ -0,0 +1,62 @@
+package com.example.shipping
+
+import java.math.BigDecimal
+
+enum class ShippingZone { DOMESTIC, EU, INTERNATIONAL, REMOTE }
+enum class ShippingSpeed { STANDARD, EXPRESS, OVERNIGHT }
+
+data class ShippingRate(val baseCost: BigDecimal, val perKgCost: BigDecimal)
+
+class ShippingCalculator {
+
+    // 4 branches handled with if/else chain — should use when
+    fun rateForZone(zone: ShippingZone): ShippingRate {
+        if (zone == ShippingZone.DOMESTIC) {
+            return ShippingRate(BigDecimal("3.99"), BigDecimal("0.50"))
+        } else if (zone == ShippingZone.EU) {
+            return ShippingRate(BigDecimal("7.99"), BigDecimal("1.20"))
+        } else if (zone == ShippingZone.INTERNATIONAL) {
+            return ShippingRate(BigDecimal("14.99"), BigDecimal("2.50"))
+        } else {
+            return ShippingRate(BigDecimal("24.99"), BigDecimal("4.00"))
+        }
+    }
+
+    // 3 branches with if/else — should use when
+    fun speedMultiplier(speed: ShippingSpeed): BigDecimal {
+        if (speed == ShippingSpeed.STANDARD) {
+            return BigDecimal("1.0")
+        } else if (speed == ShippingSpeed.EXPRESS) {
+            return BigDecimal("1.75")
+        } else {
+            return BigDecimal("3.00")
+        }
+    }
+
+    fun isFreeShipping(orderTotal: BigDecimal): Boolean =
+        if (orderTotal >= BigDecimal("50.00")) true else false
+
+    fun calculate(zone: ShippingZone, speed: ShippingSpeed, weightKg: BigDecimal): BigDecimal {
+        val rate = rateForZone(zone)
+        val multiplier = speedMultiplier(speed)
+        val base = rate.baseCost.add(rate.perKgCost.multiply(weightKg))
+        return base.multiply(multiplier).setScale(2, java.math.RoundingMode.HALF_UP)
+    }
+
+    // 6 if/else branches — when would be far more readable
+    fun estimatedDays(zone: ShippingZone, speed: ShippingSpeed): Int {
+        if (speed == ShippingSpeed.OVERNIGHT) {
+            return 1
+        } else if (speed == ShippingSpeed.EXPRESS && zone == ShippingZone.DOMESTIC) {
+            return 2
+        } else if (speed == ShippingSpeed.EXPRESS) {
+            return 3
+        } else if (zone == ShippingZone.DOMESTIC) {
+            return 5
+        } else if (zone == ShippingZone.EU) {
+            return 10
+        } else {
+            return 21
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/function_design/uses_when_for_three_or_more_branches/good/ShippingCalculator.kt b/priv/combined_metrics/samples/function_design/uses_when_for_three_or_more_branches/good/ShippingCalculator.kt
new file mode 100644
index 0000000..c031d4a
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/uses_when_for_three_or_more_branches/good/ShippingCalculator.kt
@@ -0,0 +1,47 @@
+package com.example.shipping
+
+import java.math.BigDecimal
+
+enum class ShippingZone { DOMESTIC, EU, INTERNATIONAL, REMOTE }
+enum class ShippingSpeed { STANDARD, EXPRESS, OVERNIGHT }
+
+data class ShippingRate(val baseCost: BigDecimal, val perKgCost: BigDecimal)
+
+class ShippingCalculator {
+
+    // 4 branches — when is appropriate
+    fun rateForZone(zone: ShippingZone): ShippingRate = when (zone) {
+        ShippingZone.DOMESTIC      -> ShippingRate(BigDecimal("3.99"), BigDecimal("0.50"))
+        ShippingZone.EU            -> ShippingRate(BigDecimal("7.99"), BigDecimal("1.20"))
+        ShippingZone.INTERNATIONAL -> ShippingRate(BigDecimal("14.99"), BigDecimal("2.50"))
+        ShippingZone.REMOTE        -> ShippingRate(BigDecimal("24.99"), BigDecimal("4.00"))
+    }
+
+    // 3 branches — when is appropriate
+    fun speedMultiplier(speed: ShippingSpeed): BigDecimal = when (speed) {
+        ShippingSpeed.STANDARD  -> BigDecimal("1.0")
+        ShippingSpeed.EXPRESS   -> BigDecimal("1.75")
+        ShippingSpeed.OVERNIGHT -> BigDecimal("3.00")
+    }
+
+    // Simple binary — if/else is appropriate here
+    fun isFreeShipping(orderTotal: BigDecimal): Boolean =
+        if (orderTotal >= BigDecimal("50.00")) true else false
+
+    fun calculate(zone: ShippingZone, speed: ShippingSpeed, weightKg: BigDecimal): BigDecimal {
+        val rate = rateForZone(zone)
+        val multiplier = speedMultiplier(speed)
+        val base = rate.baseCost.add(rate.perKgCost.multiply(weightKg))
+        return base.multiply(multiplier).setScale(2, java.math.RoundingMode.HALF_UP)
+    }
+
+    // 4 ranges — when with conditions is cleaner than if/else chain
+    fun estimatedDays(zone: ShippingZone, speed: ShippingSpeed): Int = when {
+        speed == ShippingSpeed.OVERNIGHT                                -> 1
+        speed == ShippingSpeed.EXPRESS && zone == ShippingZone.DOMESTIC -> 2
+        speed == ShippingSpeed.EXPRESS                                  -> 3
+        zone == ShippingZone.DOMESTIC                                   -> 5
+        zone == ShippingZone.EU                                         -> 10
+        else                                                            -> 21
+    }
+}
diff --git a/priv/combined_metrics/samples/function_design/with_expression_handles_happy_path_only/bad/payments.ex b/priv/combined_metrics/samples/function_design/with_expression_handles_happy_path_only/bad/payments.ex
new file mode 100644
index 0000000..362b606
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/with_expression_handles_happy_path_only/bad/payments.ex
@@ -0,0 +1,59 @@
+defmodule MyApp.Payments do
+  @moduledoc """
+  Payment processing.
+  """
+
+  alias MyApp.Payments.{Charge, Receipt}
+  alias MyApp.Accounts
+  alias MyApp.Billing
+
+  # Bad: complex business logic in the `else` block of `with`
+  @spec charge_customer(integer(), integer(), String.t()) ::
+          {:ok, Receipt.t()} | {:error, atom()}
+  def charge_customer(customer_id, amount_cents, description) do
+    with {:ok, customer} <- Accounts.get_customer(customer_id),
+         :ok <- validate_amount(amount_cents),
+         {:ok, charge} <- Billing.create_charge(customer, amount_cents, description),
+         {:ok, receipt} <- create_receipt(charge) do
+      {:ok, receipt}
+    else
+      {:error, :not_found} ->
+        # Bad: doing work (side effects) inside the else block
+        Accounts.log_failed_lookup(customer_id)
+        {:error, :customer_not_found}
+
+      {:error, :invalid_amount} ->
+        # Bad: formatting error messages in else
+        msg = "Amount #{amount_cents} is invalid. Must be between 1 and 10_000_00."
+        {:error, {:invalid_amount, msg}}
+
+      {:error, :card_declined} ->
+        # Bad: complex retry logic inside else
+        case Billing.retry_charge(customer_id, amount_cents, description) do
+          {:ok, charge} -> create_receipt(charge)
+          {:error, _} -> {:error, :payment_declined}
+        end
+
+      {:error, :receipt_failed} ->
+        # Bad: compensating transaction inside else
+        Billing.void_charge(charge_id: customer_id)
+        notify_ops("Receipt creation failed for customer #{customer_id}")
+        {:error, :receipt_failed}
+
+      other ->
+        # Bad: logging and transforming in catch-all
+        require Logger
+        Logger.error("Unexpected error in charge_customer: #{inspect(other)}")
+        {:error, :unexpected}
+    end
+  end
+
+  defp validate_amount(amount) when amount > 0, do: :ok
+  defp validate_amount(_), do: {:error, :invalid_amount}
+
+  defp create_receipt(%Charge{} = charge) do
+    {:ok, %Receipt{charge_id: charge.id, created_at: DateTime.utc_now()}}
+  end
+
+  defp notify_ops(_msg), do: :ok
+end
diff --git a/priv/combined_metrics/samples/function_design/with_expression_handles_happy_path_only/good/payments.ex b/priv/combined_metrics/samples/function_design/with_expression_handles_happy_path_only/good/payments.ex
new file mode 100644
index 0000000..71f61ea
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/with_expression_handles_happy_path_only/good/payments.ex
@@ -0,0 +1,59 @@
+defmodule MyApp.Payments do
+  @moduledoc """
+  Payment processing. Uses `with` exclusively for the happy path,
+  keeping the `else` block minimal and declarative.
+  """
+
+  alias MyApp.Payments.{Charge, Receipt}
+  alias MyApp.Accounts
+  alias MyApp.Billing
+
+  @doc """
+  Charges a customer and creates a receipt. Returns `{:ok, receipt}`
+  or a tagged error tuple describing what went wrong.
+  """
+  @spec charge_customer(integer(), integer(), String.t()) ::
+          {:ok, Receipt.t()} | {:error, atom()}
+  def charge_customer(customer_id, amount_cents, description) do
+    with {:ok, customer} <- Accounts.get_customer(customer_id),
+         :ok <- validate_amount(amount_cents),
+         {:ok, charge} <- Billing.create_charge(customer, amount_cents, description),
+         {:ok, receipt} <- create_receipt(charge) do
+      {:ok, receipt}
+    else
+      {:error, :not_found} -> {:error, :customer_not_found}
+      {:error, :invalid_amount} -> {:error, :invalid_amount}
+      {:error, :card_declined} -> {:error, :payment_declined}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  @doc """
+  Refunds a charge partially or fully.
+  """
+  @spec refund(integer(), integer()) :: {:ok, Charge.t()} | {:error, atom()}
+  def refund(charge_id, amount_cents) do
+    with {:ok, charge} <- Billing.get_charge(charge_id),
+         :ok <- validate_refundable(charge, amount_cents),
+         {:ok, updated} <- Billing.apply_refund(charge, amount_cents) do
+      {:ok, updated}
+    else
+      {:error, :not_found} -> {:error, :charge_not_found}
+      {:error, :exceeds_original} -> {:error, :refund_exceeds_original}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  defp validate_amount(amount) when amount > 0 and amount <= 100_000_00, do: :ok
+  defp validate_amount(_), do: {:error, :invalid_amount}
+
+  defp validate_refundable(%Charge{refundable: false}, _), do: {:error, :not_refundable}
+  defp validate_refundable(%Charge{amount: orig}, refund) when refund > orig do
+    {:error, :exceeds_original}
+  end
+  defp validate_refundable(_, _), do: :ok
+
+  defp create_receipt(%Charge{} = charge) do
+    {:ok, %Receipt{charge_id: charge.id, created_at: DateTime.utc_now()}}
+  end
+end
diff --git a/priv/combined_metrics/samples/function_design/zero_value_is_usable/bad/buffer.go b/priv/combined_metrics/samples/function_design/zero_value_is_usable/bad/buffer.go
new file mode 100644
index 0000000..5f3e3f9
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/zero_value_is_usable/bad/buffer.go
@@ -0,0 +1,55 @@
+package buffer
+
+import (
+	"fmt"
+	"sync"
+)
+
+// MessageBuffer accumulates messages and flushes them on demand.
+// The zero value is NOT usable — callers must use New(), and any attempt to
+// use a zero-value MessageBuffer panics because messages is nil and
+// initialized is false.
+type MessageBuffer struct {
+	mu          sync.Mutex
+	messages    []string
+	initialized bool
+}
+
+// New constructs a usable MessageBuffer. Required — zero value panics.
+func New() *MessageBuffer {
+	return &MessageBuffer{
+		messages:    make([]string, 0),
+		initialized: true,
+	}
+}
+
+// Add appends a message to the buffer.
+// Panics if called on a zero-value MessageBuffer because initialized is false.
+func (b *MessageBuffer) Add(msg string) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	if !b.initialized {
+		panic(fmt.Sprintf("MessageBuffer not initialized: call New()"))
+	}
+	b.messages = append(b.messages, msg)
+}
+
+// Flush returns all buffered messages and resets the buffer.
+// Panics if called on a zero-value MessageBuffer.
+func (b *MessageBuffer) Flush() []string {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	if !b.initialized {
+		panic("MessageBuffer not initialized: call New()")
+	}
+	out := b.messages
+	b.messages = make([]string, 0)
+	return out
+}
+
+// Len returns the current number of buffered messages.
+func (b *MessageBuffer) Len() int {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return len(b.messages)
+}
diff --git a/priv/combined_metrics/samples/function_design/zero_value_is_usable/good/buffer.go b/priv/combined_metrics/samples/function_design/zero_value_is_usable/good/buffer.go
new file mode 100644
index 0000000..88aac16
--- /dev/null
+++ b/priv/combined_metrics/samples/function_design/zero_value_is_usable/good/buffer.go
@@ -0,0 +1,43 @@
+package buffer
+
+import "sync"
+
+// MessageBuffer accumulates messages and flushes them on demand.
+// The zero value is usable immediately — no constructor is required because
+// sync.Mutex, []string, and int all have sensible zero values.
+type MessageBuffer struct {
+	mu       sync.Mutex
+	messages []string
+	limit    int // 0 means unlimited
+}
+
+// Add appends a message to the buffer.
+// Safe to call on a zero-value MessageBuffer.
+func (b *MessageBuffer) Add(msg string) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	b.messages = append(b.messages, msg)
+}
+
+// Flush returns all buffered messages and resets the buffer.
+// Safe to call on a zero-value MessageBuffer — returns nil when empty.
+func (b *MessageBuffer) Flush() []string {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	out := b.messages
+	b.messages = nil
+	return out
+}
+
+// Len returns the current number of buffered messages.
+func (b *MessageBuffer) Len() int {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return len(b.messages)
+}
+
+// Usage: no constructor needed
+//
+//	var buf buffer.MessageBuffer
+//	buf.Add("hello")
+//	msgs := buf.Flush()
diff --git a/priv/combined_metrics/samples/naming_conventions/async_method_named_with_async_suffix/bad/PaymentGateway.cs b/priv/combined_metrics/samples/naming_conventions/async_method_named_with_async_suffix/bad/PaymentGateway.cs
new file mode 100644
index 0000000..6fe2170
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/async_method_named_with_async_suffix/bad/PaymentGateway.cs
@@ -0,0 +1,63 @@
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace Payments
+{
+    public class PaymentGateway
+    {
+        private readonly HttpClient _httpClient;
+        private readonly string _gatewayUrl;
+
+        public PaymentGateway(HttpClient httpClient, string gatewayUrl)
+        {
+            _httpClient = httpClient;
+            _gatewayUrl = gatewayUrl;
+        }
+
+        // Missing Async suffix — callers cannot tell this returns a Task without inspecting the signature
+        public async Task<ChargeResult> Charge(PaymentRequest request)
+        {
+            var payload = JsonSerializer.Serialize(request);
+            var content = new StringContent(payload, System.Text.Encoding.UTF8, "application/json");
+
+            var response = await _httpClient.PostAsync($"{_gatewayUrl}/charge", content);
+            var body = await response.Content.ReadAsStringAsync();
+
+            return JsonSerializer.Deserialize<ChargeResult>(body)!;
+        }
+
+        // Missing Async suffix — looks like a synchronous method
+        public async Task<RefundResult> Refund(string chargeId, decimal amount)
+        {
+            var payload = JsonSerializer.Serialize(new { chargeId, amount });
+            var content = new StringContent(payload, System.Text.Encoding.UTF8, "application/json");
+
+            var response = await _httpClient.PostAsync($"{_gatewayUrl}/refund", content);
+            var body = await response.Content.ReadAsStringAsync();
+
+            return JsonSerializer.Deserialize<RefundResult>(body)!;
+        }
+
+        // Missing Async suffix
+        public async Task<PaymentMethod> GetSavedPaymentMethod(int customerId)
+        {
+            var response = await _httpClient.GetAsync(
+                $"{_gatewayUrl}/customers/{customerId}/payment-method");
+            response.EnsureSuccessStatusCode();
+
+            var body = await response.Content.ReadAsStringAsync();
+            return JsonSerializer.Deserialize<PaymentMethod>(body)!;
+        }
+
+        // Missing Async suffix — hides the asynchronous nature from the caller
+        public async Task<bool> ValidateCard(CardDetails card)
+        {
+            var payload = JsonSerializer.Serialize(card);
+            var content = new StringContent(payload, System.Text.Encoding.UTF8, "application/json");
+
+            var response = await _httpClient.PostAsync($"{_gatewayUrl}/validate-card", content);
+            return response.IsSuccessStatusCode;
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/async_method_named_with_async_suffix/good/PaymentGateway.cs b/priv/combined_metrics/samples/naming_conventions/async_method_named_with_async_suffix/good/PaymentGateway.cs
new file mode 100644
index 0000000..9c8f22e
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/async_method_named_with_async_suffix/good/PaymentGateway.cs
@@ -0,0 +1,60 @@
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+namespace Payments
+{
+    public class PaymentGateway
+    {
+        private readonly HttpClient _httpClient;
+        private readonly string _gatewayUrl;
+
+        public PaymentGateway(HttpClient httpClient, string gatewayUrl)
+        {
+            _httpClient = httpClient;
+            _gatewayUrl = gatewayUrl;
+        }
+
+        // Async suffix clearly signals the method is asynchronous
+        public async Task<ChargeResult> ChargeAsync(PaymentRequest request)
+        {
+            var payload = JsonSerializer.Serialize(request);
+            var content = new StringContent(payload, System.Text.Encoding.UTF8, "application/json");
+
+            var response = await _httpClient.PostAsync($"{_gatewayUrl}/charge", content);
+            var body = await response.Content.ReadAsStringAsync();
+
+            return JsonSerializer.Deserialize<ChargeResult>(body)!;
+        }
+
+        public async Task<RefundResult> RefundAsync(string chargeId, decimal amount)
+        {
+            var payload = JsonSerializer.Serialize(new { chargeId, amount });
+            var content = new StringContent(payload, System.Text.Encoding.UTF8, "application/json");
+
+            var response = await _httpClient.PostAsync($"{_gatewayUrl}/refund", content);
+            var body = await response.Content.ReadAsStringAsync();
+
+            return JsonSerializer.Deserialize<RefundResult>(body)!;
+        }
+
+        public async Task<PaymentMethod> GetSavedPaymentMethodAsync(int customerId)
+        {
+            var response = await _httpClient.GetAsync(
+                $"{_gatewayUrl}/customers/{customerId}/payment-method");
+            response.EnsureSuccessStatusCode();
+
+            var body = await response.Content.ReadAsStringAsync();
+            return JsonSerializer.Deserialize<PaymentMethod>(body)!;
+        }
+
+        public async Task<bool> ValidateCardAsync(CardDetails card)
+        {
+            var payload = JsonSerializer.Serialize(card);
+            var content = new StringContent(payload, System.Text.Encoding.UTF8, "application/json");
+
+            var response = await _httpClient.PostAsync($"{_gatewayUrl}/validate-card", content);
+            return response.IsSuccessStatusCode;
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/bang_function_raises_on_failure/bad/accounts.ex b/priv/combined_metrics/samples/naming_conventions/bang_function_raises_on_failure/bad/accounts.ex
new file mode 100644
index 0000000..b6d85e7
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/bang_function_raises_on_failure/bad/accounts.ex
@@ -0,0 +1,68 @@
+defmodule MyApp.Accounts do
+  @moduledoc """
+  Manages user accounts.
+  """
+
+  alias MyApp.Accounts.User
+  alias MyApp.Repo
+
+  # Bad: bang function returns nil instead of raising
+  @spec get_user!(integer()) :: User.t() | nil
+  def get_user!(id) do
+    Repo.get(User, id)
+  end
+
+  # Bad: bang function returns a tuple instead of raising
+  @spec create_user!(map()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
+  def create_user!(attrs) do
+    %User{}
+    |> User.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  # Bad: non-bang function raises instead of returning a tuple
+  @spec update_user(User.t(), map()) :: User.t()
+  def update_user(%User{} = user, attrs) do
+    user
+    |> User.changeset(attrs)
+    |> Repo.update!()
+  end
+
+  # Bad: bang function swallows errors and returns nil
+  @spec delete_user!(integer()) :: User.t() | nil
+  def delete_user!(id) do
+    case Repo.get(User, id) do
+      nil -> nil
+      user ->
+        case Repo.delete(user) do
+          {:ok, deleted} -> deleted
+          {:error, _} -> nil
+        end
+    end
+  end
+
+  # Bad: non-bang function that raises for not-found
+  @spec find_by_email(String.t()) :: User.t()
+  def find_by_email(email) do
+    case Repo.get_by(User, email: email) do
+      nil -> raise "User with email #{email} not found"
+      user -> user
+    end
+  end
+
+  # Bad: bang function silently returning an error tuple
+  @spec authenticate_user!(String.t(), String.t()) :: {:ok, User.t()} | {:error, :unauthorized}
+  def authenticate_user!(email, password) do
+    case Repo.get_by(User, email: email) do
+      nil ->
+        {:error, :unauthorized}
+
+      user ->
+        if User.valid_password?(user, password) do
+          {:ok, user}
+        else
+          {:error, :unauthorized}
+        end
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/bang_function_raises_on_failure/config.yml b/priv/combined_metrics/samples/naming_conventions/bang_function_raises_on_failure/config.yml
new file mode 100644
index 0000000..bf1a1a5
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/bang_function_raises_on_failure/config.yml
@@ -0,0 +1 @@
+doc: "Bang functions (`foo!`) should raise on failure rather than returning an error tuple."
diff --git a/priv/combined_metrics/samples/naming_conventions/bang_function_raises_on_failure/good/accounts.ex b/priv/combined_metrics/samples/naming_conventions/bang_function_raises_on_failure/good/accounts.ex
new file mode 100644
index 0000000..f7130b3
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/bang_function_raises_on_failure/good/accounts.ex
@@ -0,0 +1,83 @@
+defmodule MyApp.Accounts do
+  @moduledoc """
+  Manages user accounts. Provides both safe tuple-returning variants
+  and bang variants that raise on failure.
+  """
+
+  alias MyApp.Accounts.User
+  alias MyApp.Repo
+
+  @doc """
+  Fetches a user by ID. Returns `{:ok, user}` on success or
+  `{:error, :not_found}` when no user exists with the given ID.
+  """
+  @spec get_user(integer()) :: {:ok, User.t()} | {:error, :not_found}
+  def get_user(id) do
+    case Repo.get(User, id) do
+      nil -> {:error, :not_found}
+      user -> {:ok, user}
+    end
+  end
+
+  @doc """
+  Fetches a user by ID. Raises `Ecto.NoResultsError` when no user
+  exists with the given ID. Use this when the caller expects the
+  record to always exist.
+  """
+  @spec get_user!(integer()) :: User.t()
+  def get_user!(id) do
+    Repo.get!(User, id)
+  end
+
+  @doc """
+  Creates a new user with the given attributes. Returns `{:ok, user}`
+  on success or `{:error, changeset}` on validation failure.
+  """
+  @spec create_user(map()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
+  def create_user(attrs) do
+    %User{}
+    |> User.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Creates a new user with the given attributes. Raises
+  `Ecto.InvalidChangesetError` on validation failure.
+  """
+  @spec create_user!(map()) :: User.t()
+  def create_user!(attrs) do
+    %User{}
+    |> User.changeset(attrs)
+    |> Repo.insert!()
+  end
+
+  @doc """
+  Updates an existing user. Returns `{:ok, user}` or `{:error, changeset}`.
+  """
+  @spec update_user(User.t(), map()) :: {:ok, User.t()} | {:error, Ecto.Changeset.t()}
+  def update_user(%User{} = user, attrs) do
+    user
+    |> User.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Updates an existing user. Raises on failure.
+  """
+  @spec update_user!(User.t(), map()) :: User.t()
+  def update_user!(%User{} = user, attrs) do
+    user
+    |> User.changeset(attrs)
+    |> Repo.update!()
+  end
+
+  @doc """
+  Deletes a user by ID. Returns `{:ok, user}` or `{:error, :not_found}`.
+  """
+  @spec delete_user(integer()) :: {:ok, User.t()} | {:error, :not_found | Ecto.Changeset.t()}
+  def delete_user(id) do
+    with {:ok, user} <- get_user(id) do
+      Repo.delete(user)
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/boolean_reads_as_assertion/bad/ProductCatalog.swift b/priv/combined_metrics/samples/naming_conventions/boolean_reads_as_assertion/bad/ProductCatalog.swift
new file mode 100644
index 0000000..94ee7fc
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/boolean_reads_as_assertion/bad/ProductCatalog.swift
@@ -0,0 +1,52 @@
+import Foundation
+
+struct Product {
+    let id: String
+    let name: String
+    var price: Decimal
+    var stockQuantity: Int
+    var tags: Set<String>
+    // "archived" and "featured" don't read as assertions
+    var archived: Bool
+    var featured: Bool
+}
+
+class ProductCatalog {
+    private var products: [String: Product] = [:]
+
+    // "empty" doesn't read as an assertion the way "isEmpty" does
+    var empty: Bool {
+        return products.isEmpty
+    }
+
+    // "featuredProducts" sounds like a collection, not a boolean
+    var featuredProducts: Bool {
+        return products.values.contains { $0.featured }
+    }
+
+    // "available" without "is" prefix reads ambiguously
+    func available(_ productID: String) -> Bool {
+        guard let product = products[productID] else { return false }
+        return product.stockQuantity > 0 && !product.archived
+    }
+
+    // "catalogIntersection" sounds like it returns a catalog, not a Bool
+    func catalogIntersection(_ otherCatalog: ProductCatalog) -> Bool {
+        let ownIDs = Set(products.keys)
+        let otherIDs = Set(otherCatalog.products.keys)
+        return !ownIDs.isDisjoint(with: otherIDs)
+    }
+
+    // "tagMatch" reads like a noun (a match object), not an assertion
+    func tagMatch(tag: String) -> Bool {
+        return products.values.contains { $0.tags.contains(tag) }
+    }
+
+    func product(for id: String) -> Product? {
+        return products[id]
+    }
+
+    func add(_ product: Product) {
+        products[product.id] = product
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/boolean_reads_as_assertion/good/ProductCatalog.swift b/priv/combined_metrics/samples/naming_conventions/boolean_reads_as_assertion/good/ProductCatalog.swift
new file mode 100644
index 0000000..eb33d9b
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/boolean_reads_as_assertion/good/ProductCatalog.swift
@@ -0,0 +1,50 @@
+import Foundation
+
+struct Product {
+    let id: String
+    let name: String
+    var price: Decimal
+    var stockQuantity: Int
+    var tags: Set<String>
+    var isArchived: Bool
+    var isFeatured: Bool
+}
+
+class ProductCatalog {
+    private var products: [String: Product] = [:]
+
+    var isEmpty: Bool {
+        return products.isEmpty
+    }
+
+    var hasFeaturedProducts: Bool {
+        return products.values.contains { $0.isFeatured }
+    }
+
+    func isAvailable(_ productID: String) -> Bool {
+        guard let product = products[productID] else { return false }
+        return product.stockQuantity > 0 && !product.isArchived
+    }
+
+    func intersects(_ otherCatalog: ProductCatalog) -> Bool {
+        let ownIDs = Set(products.keys)
+        let otherIDs = Set(otherCatalog.products.keys)
+        return !ownIDs.isDisjoint(with: otherIDs)
+    }
+
+    func matches(tag: String) -> Bool {
+        return products.values.contains { $0.tags.contains(tag) }
+    }
+
+    func product(for id: String) -> Product? {
+        return products[id]
+    }
+
+    func add(_ product: Product) {
+        products[product.id] = product
+    }
+
+    func archive(_ productID: String) {
+        products[productID]?.isArchived = true
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/class_name_is_noun/bad/modules.ex b/priv/combined_metrics/samples/naming_conventions/class_name_is_noun/bad/modules.ex
new file mode 100644
index 0000000..5543de7
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/class_name_is_noun/bad/modules.ex
@@ -0,0 +1,45 @@
+defmodule ProcessOrder do
+  def run(order) do
+    {:ok, %{order | status: :processed}}
+  end
+end
+
+defmodule ValidatingUser do
+  def run(user) do
+    if user.email != nil && user.name != nil do
+      {:ok, user}
+    else
+      {:error, :invalid}
+    end
+  end
+end
+
+defmodule RunningReport do
+  def run(params) do
+    {:ok, %{generated_at: DateTime.utc_now(), params: params}}
+  end
+end
+
+defmodule SendingEmail do
+  def run(user, subject, body) do
+    {:ok, %{to: user.email, subject: subject, body: body}}
+  end
+end
+
+defmodule FetchingProducts do
+  def run(filters) do
+    {:ok, [%{id: 1, name: "Product A", filters: filters}]}
+  end
+end
+
+defmodule CalculatingDiscount do
+  def run(price, rate) do
+    {:ok, price * (1 - rate)}
+  end
+end
+
+defmodule HandlingPayment do
+  def run(order, card) do
+    {:ok, %{order_id: order.id, card_last4: card.last4, status: :charged}}
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/class_name_is_noun/config.yml b/priv/combined_metrics/samples/naming_conventions/class_name_is_noun/config.yml
new file mode 100644
index 0000000..3ac9ae9
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/class_name_is_noun/config.yml
@@ -0,0 +1 @@
+doc: "Class and module names should be nouns describing what they represent, not verbs or gerunds."
diff --git a/priv/combined_metrics/samples/naming_conventions/class_name_is_noun/good/modules.ex b/priv/combined_metrics/samples/naming_conventions/class_name_is_noun/good/modules.ex
new file mode 100644
index 0000000..b61610b
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/class_name_is_noun/good/modules.ex
@@ -0,0 +1,45 @@
+defmodule OrderProcessor do
+  def process(order) do
+    {:ok, %{order | status: :processed}}
+  end
+end
+
+defmodule UserValidator do
+  def validate(user) do
+    if user.email != nil && user.name != nil do
+      {:ok, user}
+    else
+      {:error, :invalid}
+    end
+  end
+end
+
+defmodule ReportRunner do
+  def run(params) do
+    {:ok, %{generated_at: DateTime.utc_now(), params: params}}
+  end
+end
+
+defmodule EmailSender do
+  def send(user, subject, body) do
+    {:ok, %{to: user.email, subject: subject, body: body}}
+  end
+end
+
+defmodule ProductFetcher do
+  def fetch(filters) do
+    {:ok, [%{id: 1, name: "Product A", filters: filters}]}
+  end
+end
+
+defmodule DiscountCalculator do
+  def calculate(price, rate) do
+    {:ok, price * (1 - rate)}
+  end
+end
+
+defmodule PaymentHandler do
+  def handle(order, card) do
+    {:ok, %{order_id: order.id, card_last4: card.last4, status: :charged}}
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/classes_use_studly_caps/bad/OrderService.php b/priv/combined_metrics/samples/naming_conventions/classes_use_studly_caps/bad/OrderService.php
new file mode 100644
index 0000000..3750dfb
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/classes_use_studly_caps/bad/OrderService.php
@@ -0,0 +1,64 @@
+<?php
+
+namespace App\Service;
+
+// Violates PSR-1: class name uses snake_case instead of StudlyCaps
+class order_service
+{
+    public function __construct(
+        private $orderRepository,
+        private $lineItemRepository,
+        private $paymentProcessor
+    ) {
+    }
+
+    public function createOrder($customerId, $items)
+    {
+        // ...
+        return new order_entity($customerId);
+    }
+
+    public function findById($id)
+    {
+        return $this->orderRepository->findById($id);
+    }
+}
+
+// Violates PSR-1: uses mixed casing (camelCase for a class name)
+class orderSummaryBuilder
+{
+    public function build($order)
+    {
+        return new orderSummary(
+            orderId: $order->getId(),
+            total: $order->getTotal(),
+            itemCount: $order->getLineItemCount(),
+            status: $order->getStatus()
+        );
+    }
+}
+
+// Violates PSR-1: lowercase class name
+class orderSummary
+{
+    public function __construct(
+        public $orderId,
+        public $total,
+        public $itemCount,
+        public $status
+    ) {
+    }
+}
+
+// Violates PSR-1: all-uppercase class name (should be StudlyCaps)
+class ORDER_ENTITY
+{
+    public function __construct(public $customerId)
+    {
+    }
+}
+
+// Using a lowercase alias to try to match the bad naming
+class order_entity extends ORDER_ENTITY
+{
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/classes_use_studly_caps/good/OrderService.php b/priv/combined_metrics/samples/naming_conventions/classes_use_studly_caps/good/OrderService.php
new file mode 100644
index 0000000..8497c13
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/classes_use_studly_caps/good/OrderService.php
@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+use App\Entity\Order;
+use App\Entity\LineItem;
+use App\Exception\OrderNotFoundException;
+
+// Class names use StudlyCaps (PascalCase) — PSR-1
+class OrderService
+{
+    public function __construct(
+        private OrderRepository $orderRepository,
+        private LineItemRepository $lineItemRepository,
+        private PaymentProcessor $paymentProcessor
+    ) {
+    }
+
+    public function createOrder(int $customerId, array $items): Order
+    {
+        $order = new Order(customerId: $customerId);
+
+        foreach ($items as $item) {
+            $lineItem = new LineItem(
+                productId: $item['product_id'],
+                quantity: $item['quantity'],
+                unitPrice: $item['unit_price']
+            );
+            $order->addLineItem($lineItem);
+        }
+
+        $this->orderRepository->save($order);
+
+        return $order;
+    }
+
+    public function findById(int $id): ?Order
+    {
+        return $this->orderRepository->findById($id);
+    }
+}
+
+// Additional classes in the namespace also follow StudlyCaps
+class OrderSummaryBuilder
+{
+    public function build(Order $order): OrderSummary
+    {
+        return new OrderSummary(
+            orderId: $order->getId(),
+            total: $order->getTotal(),
+            itemCount: $order->getLineItemCount(),
+            status: $order->getStatus()
+        );
+    }
+}
+
+class OrderSummary
+{
+    public function __construct(
+        public readonly int $orderId,
+        public readonly float $total,
+        public readonly int $itemCount,
+        public readonly string $status
+    ) {
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/constants_are_screaming_snake_or_caps_words/bad/payment.rb b/priv/combined_metrics/samples/naming_conventions/constants_are_screaming_snake_or_caps_words/bad/payment.rb
new file mode 100644
index 0000000..124e010
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/constants_are_screaming_snake_or_caps_words/bad/payment.rb
@@ -0,0 +1,54 @@
+module Payments
+  # Non-class constants should be SCREAMING_SNAKE_CASE, not lowercase/mixed
+  DefaultCurrency = "USD"
+  maxRetryAttempts = 3
+  retry_delay_seconds = 5
+  supportedCurrencies = %w[USD EUR GBP CAD AUD].freeze
+  GatewayTimeoutMs = 10_000
+
+  # Classes/modules should be CapitalCase, not SCREAMING_SNAKE_CASE or lowercase
+  class PAYMENT_ERROR < StandardError; end
+  class card_declined_error < PAYMENT_ERROR; end
+  class gateway_timeout_error < PAYMENT_ERROR; end
+
+  module card_validation
+    luhnModulus = 10
+    MinCardLength = 13
+    MaxCardLength = 19
+
+    def self.valid_luhn?(number)
+      digits = number.digits.reverse
+      sum = digits.each_with_index.sum do |digit, index|
+        index.odd? ? [digit * 2 - 9, digit * 2].min : digit
+      end
+      (sum % luhnModulus).zero?
+    end
+  end
+
+  class Processor
+    ChargeEndpoint = "/v1/charges"
+    refundEndpoint = "/v1/refunds"
+
+    def initialize(api_key, currency: DefaultCurrency)
+      @api_key = api_key
+      @currency = currency
+    end
+
+    def charge(amount_cents, token)
+      validate_currency!
+      post(ChargeEndpoint, amount: amount_cents, currency: @currency, source: token)
+    end
+
+    private
+
+    def validate_currency!
+      unless supportedCurrencies.include?(@currency)
+        raise ArgumentError, "Unsupported currency: #{@currency}"
+      end
+    end
+
+    def post(endpoint, params)
+      # ... HTTP client logic
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/constants_are_screaming_snake_or_caps_words/good/payment.rb b/priv/combined_metrics/samples/naming_conventions/constants_are_screaming_snake_or_caps_words/good/payment.rb
new file mode 100644
index 0000000..c3b5204
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/constants_are_screaming_snake_or_caps_words/good/payment.rb
@@ -0,0 +1,54 @@
+module Payments
+  # Non-class constants use SCREAMING_SNAKE_CASE
+  DEFAULT_CURRENCY = "USD"
+  MAX_RETRY_ATTEMPTS = 3
+  RETRY_DELAY_SECONDS = 5
+  SUPPORTED_CURRENCIES = %w[USD EUR GBP CAD AUD].freeze
+  GATEWAY_TIMEOUT_MS = 10_000
+
+  # Classes/modules use CapitalCase (PascalCase)
+  class PaymentError < StandardError; end
+  class CardDeclinedError < PaymentError; end
+  class GatewayTimeoutError < PaymentError; end
+
+  module CardValidation
+    LUHN_MODULUS = 10
+    MIN_CARD_LENGTH = 13
+    MAX_CARD_LENGTH = 19
+
+    def self.valid_luhn?(number)
+      digits = number.digits.reverse
+      sum = digits.each_with_index.sum do |digit, index|
+        index.odd? ? [digit * 2 - 9, digit * 2].min : digit
+      end
+      (sum % LUHN_MODULUS).zero?
+    end
+  end
+
+  class Processor
+    CHARGE_ENDPOINT = "/v1/charges"
+    REFUND_ENDPOINT = "/v1/refunds"
+
+    def initialize(api_key, currency: DEFAULT_CURRENCY)
+      @api_key = api_key
+      @currency = currency
+    end
+
+    def charge(amount_cents, token)
+      validate_currency!
+      post(CHARGE_ENDPOINT, amount: amount_cents, currency: @currency, source: token)
+    end
+
+    private
+
+    def validate_currency!
+      unless SUPPORTED_CURRENCIES.include?(@currency)
+        raise ArgumentError, "Unsupported currency: #{@currency}"
+      end
+    end
+
+    def post(endpoint, params)
+      # ... HTTP client logic
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/constants_are_upper_case_with_underscores/bad/ProductCatalog.php b/priv/combined_metrics/samples/naming_conventions/constants_are_upper_case_with_underscores/bad/ProductCatalog.php
new file mode 100644
index 0000000..91289df
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/constants_are_upper_case_with_underscores/bad/ProductCatalog.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace App\Catalog;
+
+class ProductCatalog
+{
+    // Violates PSR-1: constants must use UPPER_CASE_WITH_UNDERSCORES
+
+    // camelCase constants — forbidden
+    public const statusActive = 'active';
+    public const statusInactive = 'inactive';
+    public const statusDiscontinued = 'discontinued';
+
+    // lowercase constants — forbidden
+    public const max_description_length = 5000;
+    public const max_name_length = 255;
+
+    // PascalCase constants — reserved for classes, not constants
+    public const DefaultPageSize = 20;
+    public const MaxPageSize = 100;
+
+    // Mixed — forbidden
+    protected const CacheTTLSeconds = 3600;
+    private const dbTable = 'products';
+
+    private array $products = [];
+
+    public function getStatus(string $sku): string
+    {
+        $product = $this->products[$sku] ?? null;
+
+        if ($product === null) {
+            return self::statusInactive;
+        }
+
+        return $product['status'];
+    }
+
+    public function isActive(string $sku): bool
+    {
+        return $this->getStatus($sku) === self::statusActive;
+    }
+
+    public function paginate(array $items, int $page, int $perPage = self::DefaultPageSize): array
+    {
+        $perPage = min($perPage, self::MaxPageSize);
+        $offset = ($page - 1) * $perPage;
+
+        return array_slice($items, $offset, $perPage);
+    }
+
+    public function validateDescription(string $description): bool
+    {
+        return mb_strlen($description) <= self::max_description_length;
+    }
+
+    public function validateName(string $name): bool
+    {
+        return mb_strlen($name) > 0 && mb_strlen($name) <= self::max_name_length;
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/constants_are_upper_case_with_underscores/good/ProductCatalog.php b/priv/combined_metrics/samples/naming_conventions/constants_are_upper_case_with_underscores/good/ProductCatalog.php
new file mode 100644
index 0000000..773c63e
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/constants_are_upper_case_with_underscores/good/ProductCatalog.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Catalog;
+
+class ProductCatalog
+{
+    // Class constants use UPPER_CASE_WITH_UNDERSCORES — PSR-1
+    public const STATUS_ACTIVE = 'active';
+    public const STATUS_INACTIVE = 'inactive';
+    public const STATUS_DISCONTINUED = 'discontinued';
+
+    public const MAX_DESCRIPTION_LENGTH = 5000;
+    public const MAX_NAME_LENGTH = 255;
+    public const DEFAULT_PAGE_SIZE = 20;
+    public const MAX_PAGE_SIZE = 100;
+
+    protected const CACHE_TTL_SECONDS = 3600;
+    private const DB_TABLE = 'products';
+
+    private array $products = [];
+
+    public function getStatus(string $sku): string
+    {
+        $product = $this->products[$sku] ?? null;
+
+        if ($product === null) {
+            return self::STATUS_INACTIVE;
+        }
+
+        return $product['status'];
+    }
+
+    public function isActive(string $sku): bool
+    {
+        return $this->getStatus($sku) === self::STATUS_ACTIVE;
+    }
+
+    public function paginate(array $items, int $page, int $perPage = self::DEFAULT_PAGE_SIZE): array
+    {
+        $perPage = min($perPage, self::MAX_PAGE_SIZE);
+        $offset = ($page - 1) * $perPage;
+
+        return array_slice($items, $offset, $perPage);
+    }
+
+    public function validateDescription(string $description): bool
+    {
+        return mb_strlen($description) <= self::MAX_DESCRIPTION_LENGTH;
+    }
+
+    public function validateName(string $name): bool
+    {
+        return mb_strlen($name) > 0 && mb_strlen($name) <= self::MAX_NAME_LENGTH;
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/constructor_named_new_or_with/bad/session.rs b/priv/combined_metrics/samples/naming_conventions/constructor_named_new_or_with/bad/session.rs
new file mode 100644
index 0000000..e1da86e
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/constructor_named_new_or_with/bad/session.rs
@@ -0,0 +1,58 @@
+use std::time::{Duration, Instant};
+
+#[derive(Debug, Clone)]
+pub struct Session {
+    pub token: String,
+    pub user_id: u64,
+    pub created_at: Instant,
+    pub expires_in: Duration,
+    pub read_only: bool,
+}
+
+impl Session {
+    // Bad: general constructor should be named `new`, not `create`
+    pub fn create(token: impl Into<String>, user_id: u64, expires_in: Duration) -> Self {
+        Self {
+            token: token.into(),
+            user_id,
+            created_at: Instant::now(),
+            expires_in,
+            read_only: false,
+        }
+    }
+
+    // Bad: `make_readonly` should be `with_readonly` to follow `with_*` convention
+    pub fn make_readonly(token: impl Into<String>, user_id: u64, expires_in: Duration) -> Self {
+        Self {
+            token: token.into(),
+            user_id,
+            created_at: Instant::now(),
+            expires_in,
+            read_only: true,
+        }
+    }
+
+    // Bad: conversion constructor should be `from_jwt`, not `build_from_jwt`
+    pub fn build_from_jwt(jwt: &str, user_id: u64) -> Result<Self, String> {
+        if jwt.starts_with("eyJ") {
+            Ok(Self::create(jwt, user_id, Duration::from_secs(3600)))
+        } else {
+            Err(format!("invalid JWT format"))
+        }
+    }
+
+    // Bad: `init` is not a Rust convention for constructors
+    pub fn init_guest() -> Self {
+        Self {
+            token: "guest".to_string(),
+            user_id: 0,
+            created_at: Instant::now(),
+            expires_in: Duration::from_secs(300),
+            read_only: true,
+        }
+    }
+
+    pub fn is_expired(&self) -> bool {
+        self.created_at.elapsed() > self.expires_in
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/constructor_named_new_or_with/good/session.rs b/priv/combined_metrics/samples/naming_conventions/constructor_named_new_or_with/good/session.rs
new file mode 100644
index 0000000..a9991f2
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/constructor_named_new_or_with/good/session.rs
@@ -0,0 +1,48 @@
+use std::time::{Duration, Instant};
+
+#[derive(Debug, Clone)]
+pub struct Session {
+    pub token: String,
+    pub user_id: u64,
+    pub created_at: Instant,
+    pub expires_in: Duration,
+    pub read_only: bool,
+}
+
+impl Session {
+    /// General constructor — named `new` per Rust convention.
+    pub fn new(token: impl Into<String>, user_id: u64, expires_in: Duration) -> Self {
+        Self {
+            token: token.into(),
+            user_id,
+            created_at: Instant::now(),
+            expires_in,
+            read_only: false,
+        }
+    }
+
+    /// Variant constructor using `with_` prefix for a specific configuration.
+    pub fn with_readonly(token: impl Into<String>, user_id: u64, expires_in: Duration) -> Self {
+        Self {
+            token: token.into(),
+            user_id,
+            created_at: Instant::now(),
+            expires_in,
+            read_only: true,
+        }
+    }
+
+    /// Conversion constructor — `from_` prefix for constructing from another type.
+    pub fn from_jwt(jwt: &str, user_id: u64) -> Result<Self, String> {
+        // Simulate token extraction from JWT
+        if jwt.starts_with("eyJ") {
+            Ok(Self::new(jwt, user_id, Duration::from_secs(3600)))
+        } else {
+            Err(format!("invalid JWT format"))
+        }
+    }
+
+    pub fn is_expired(&self) -> bool {
+        self.created_at.elapsed() > self.expires_in
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/dangerous_method_ends_with_bang/bad/invoice.rb b/priv/combined_metrics/samples/naming_conventions/dangerous_method_ends_with_bang/bad/invoice.rb
new file mode 100644
index 0000000..36faee2
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/dangerous_method_ends_with_bang/bad/invoice.rb
@@ -0,0 +1,66 @@
+class Invoice
+  attr_reader :status, :line_items, :customer
+
+  def initialize(attrs = {})
+    @status = attrs[:status] || :draft
+    @line_items = attrs[:line_items] || []
+    @customer = attrs[:customer]
+    @total = attrs[:total]
+  end
+
+  # Using `!` but there is no safe `finalize` counterpart — misleading convention
+  def finalize!
+    return nil unless draft?
+    return nil if line_items.empty?
+    calculate_totals
+    update_status(:finalized)
+    self
+  end
+
+  # Using `!` without a safe counterpart, and it does NOT raise — misleading
+  def void!
+    return false if paid?
+    return false if voided?
+    update_status(:voided)
+    true
+  end
+
+  # Mutating method that should have `!` but doesn't
+  def apply_discount(percent)
+    @discount_percent = percent
+    @total = @total * (1 - percent / 100.0) if @total
+  end
+
+  # Raises on failure but has no safe variant and no `!`
+  def send_to_customer
+    raise InvoiceError, "No customer assigned" unless customer
+    raise InvoiceError, "Invoice not finalized" unless finalized?
+    # ... sending logic
+  end
+
+  def draft?
+    status == :draft
+  end
+
+  def paid?
+    status == :paid
+  end
+
+  def voided?
+    status == :voided
+  end
+
+  def finalized?
+    status == :finalized
+  end
+
+  private
+
+  def calculate_totals
+    @total = line_items.sum(&:amount)
+  end
+
+  def update_status(new_status)
+    @status = new_status
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/dangerous_method_ends_with_bang/good/invoice.rb b/priv/combined_metrics/samples/naming_conventions/dangerous_method_ends_with_bang/good/invoice.rb
new file mode 100644
index 0000000..178053e
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/dangerous_method_ends_with_bang/good/invoice.rb
@@ -0,0 +1,70 @@
+class Invoice
+  attr_reader :status, :line_items, :customer
+
+  def initialize(attrs = {})
+    @status = attrs[:status] || :draft
+    @line_items = attrs[:line_items] || []
+    @customer = attrs[:customer]
+    @total = attrs[:total]
+  end
+
+  # Safe variant — returns nil on failure
+  def finalize
+    return nil unless draft?
+    return nil if line_items.empty?
+
+    calculate_totals
+    update_status(:finalized)
+    self
+  end
+
+  # Bang variant — raises on failure
+  def finalize!
+    raise InvoiceError, "Invoice is not in draft state" unless draft?
+    raise InvoiceError, "Cannot finalize an invoice with no line items" if line_items.empty?
+
+    calculate_totals
+    update_status(:finalized)
+    self
+  end
+
+  # Safe variant — returns false on failure
+  def void
+    return false if paid?
+    return false if voided?
+
+    update_status(:voided)
+    true
+  end
+
+  # Bang variant — raises on failure
+  def void!
+    raise InvoiceError, "Cannot void a paid invoice" if paid?
+    raise InvoiceError, "Invoice is already voided" if voided?
+
+    update_status(:voided)
+    true
+  end
+
+  def draft?
+    status == :draft
+  end
+
+  def paid?
+    status == :paid
+  end
+
+  def voided?
+    status == :voided
+  end
+
+  private
+
+  def calculate_totals
+    @total = line_items.sum(&:amount)
+  end
+
+  def update_status(new_status)
+    @status = new_status
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/does_not_repeat_module_name_in_type/bad/payment.rs b/priv/combined_metrics/samples/naming_conventions/does_not_repeat_module_name_in_type/bad/payment.rs
new file mode 100644
index 0000000..2d78f90
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/does_not_repeat_module_name_in_type/bad/payment.rs
@@ -0,0 +1,61 @@
+/// Module: payment
+/// Bad: every type is prefixed with "Payment", repeating the module name.
+/// Callers end up writing payment::PaymentMethod, payment::PaymentStatus, etc.
+pub mod payment {
+    // Bad: PaymentMethod inside the payment module — "Payment" is redundant
+    #[derive(Debug, Clone, PartialEq)]
+    pub enum PaymentMethod {
+        Card { last_four: String },
+        BankTransfer { iban: String },
+        Wallet { provider: String },
+    }
+
+    // Bad: PaymentStatus — callers write payment::PaymentStatus
+    #[derive(Debug, Clone, PartialEq)]
+    pub enum PaymentStatus {
+        Pending,
+        Authorized,
+        Captured,
+        Failed(String),
+        Refunded,
+    }
+
+    // Bad: PaymentIntent — using payment::PaymentIntent is stuttering
+    #[derive(Debug, Clone)]
+    pub struct PaymentIntent {
+        pub id: String,
+        pub amount_cents: u64,
+        pub currency: String,
+        pub method: PaymentMethod,
+        pub status: PaymentStatus,
+    }
+
+    impl PaymentIntent {
+        pub fn new(id: impl Into<String>, amount_cents: u64, currency: impl Into<String>, method: PaymentMethod) -> Self {
+            Self {
+                id: id.into(),
+                amount_cents,
+                currency: currency.into(),
+                method,
+                status: PaymentStatus::Pending,
+            }
+        }
+    }
+
+    // Bad: PaymentProcessor — caller writes payment::PaymentProcessor
+    #[derive(Debug)]
+    pub struct PaymentProcessor {
+        pub api_key: String,
+    }
+
+    impl PaymentProcessor {
+        pub fn new(api_key: impl Into<String>) -> Self {
+            Self { api_key: api_key.into() }
+        }
+
+        pub fn authorize(&self, intent: &mut PaymentIntent) -> Result<(), String> {
+            intent.status = PaymentStatus::Authorized;
+            Ok(())
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/does_not_repeat_module_name_in_type/good/payment.rs b/priv/combined_metrics/samples/naming_conventions/does_not_repeat_module_name_in_type/good/payment.rs
new file mode 100644
index 0000000..eef43cc
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/does_not_repeat_module_name_in_type/good/payment.rs
@@ -0,0 +1,62 @@
+/// Module: payment
+/// Good: types are named for what they represent, not prefixed with "Payment".
+/// Callers refer to them as payment::Method, payment::Status, etc., which
+/// already carries the module context.
+pub mod payment {
+    #[derive(Debug, Clone, PartialEq)]
+    pub enum Method {
+        Card { last_four: String },
+        BankTransfer { iban: String },
+        Wallet { provider: String },
+    }
+
+    #[derive(Debug, Clone, PartialEq)]
+    pub enum Status {
+        Pending,
+        Authorized,
+        Captured,
+        Failed(String),
+        Refunded,
+    }
+
+    #[derive(Debug, Clone)]
+    pub struct Intent {
+        pub id: String,
+        pub amount_cents: u64,
+        pub currency: String,
+        pub method: Method,
+        pub status: Status,
+    }
+
+    impl Intent {
+        pub fn new(id: impl Into<String>, amount_cents: u64, currency: impl Into<String>, method: Method) -> Self {
+            Self {
+                id: id.into(),
+                amount_cents,
+                currency: currency.into(),
+                method,
+                status: Status::Pending,
+            }
+        }
+
+        pub fn is_captured(&self) -> bool {
+            self.status == Status::Captured
+        }
+    }
+
+    #[derive(Debug)]
+    pub struct Processor {
+        pub api_key: String,
+    }
+
+    impl Processor {
+        pub fn new(api_key: impl Into<String>) -> Self {
+            Self { api_key: api_key.into() }
+        }
+
+        pub fn authorize(&self, intent: &mut Intent) -> Result<(), String> {
+            intent.status = Status::Authorized;
+            Ok(())
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/does_not_use_abbreviated_names/bad/SubscriptionManager.swift b/priv/combined_metrics/samples/naming_conventions/does_not_use_abbreviated_names/bad/SubscriptionManager.swift
new file mode 100644
index 0000000..999064c
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/does_not_use_abbreviated_names/bad/SubscriptionManager.swift
@@ -0,0 +1,53 @@
+import Foundation
+
+enum SubscriptionTier {
+    case free, std, prem, ent  // "std", "prem", "ent" are non-standard abbreviations
+}
+
+struct Subscription {
+    let id: String            // "id" is widely established — acceptable
+    var tier: SubscriptionTier
+    var startDt: Date         // "Dt" is a non-standard abbreviation for "Date"
+    var expDt: Date           // "exp" is ambiguous: expiration? experience?
+    var autoRenew: Bool       // "autoRenew" omits "is" prefix and abbreviates concept
+    var maxDevs: Int          // "maxDevs" abbreviates "maximumDevices"
+}
+
+class SubscriptionManager {
+    // "subs" is an abbreviation for "subscriptions"
+    private var subs: [String: Subscription] = [:]
+
+    // "uid" is a non-standard abbreviation (use "userIdentifier" or "userID")
+    func reg(_ sub: Subscription, for uid: String) {
+        subs[uid] = sub
+    }
+
+    // "sub" for subscription is unclear to new readers
+    func sub(for uid: String) -> Subscription? {
+        return subs[uid]
+    }
+
+    func isExp(for uid: String, refDt: Date = Date()) -> Bool {
+        guard let sub = subs[uid] else { return true }
+        return sub.expDt < refDt
+    }
+
+    // "upgr" is an unclear abbreviation
+    func upgr(uid: String, to tier: SubscriptionTier) -> Bool {
+        guard var sub = subs[uid] else { return false }
+        sub.tier = tier
+        subs[uid] = sub
+        return true
+    }
+
+    // "remDays" abbreviates "remainingDays"
+    func remDays(for uid: String, refDt: Date = Date()) -> Int? {
+        guard let sub = subs[uid] else { return nil }
+        let comps = Calendar.current.dateComponents([.day], from: refDt, to: sub.expDt)
+        return comps.day.map { max(0, $0) }
+    }
+
+    func activeSubs(refDt: Date = Date()) -> [Subscription] {
+        return subs.values.filter { $0.expDt >= refDt }
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/does_not_use_abbreviated_names/good/SubscriptionManager.swift b/priv/combined_metrics/samples/naming_conventions/does_not_use_abbreviated_names/good/SubscriptionManager.swift
new file mode 100644
index 0000000..a354692
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/does_not_use_abbreviated_names/good/SubscriptionManager.swift
@@ -0,0 +1,48 @@
+import Foundation
+
+enum SubscriptionTier {
+    case free, standard, premium, enterprise
+}
+
+struct Subscription {
+    let identifier: String
+    var tier: SubscriptionTier
+    var startDate: Date
+    var expirationDate: Date
+    var isAutoRenewing: Bool
+    var maximumDevices: Int
+}
+
+class SubscriptionManager {
+    private var subscriptions: [String: Subscription] = [:]
+
+    func register(_ subscription: Subscription, for userIdentifier: String) {
+        subscriptions[userIdentifier] = subscription
+    }
+
+    func subscription(for userIdentifier: String) -> Subscription? {
+        return subscriptions[userIdentifier]
+    }
+
+    func isExpired(for userIdentifier: String, referenceDate: Date = Date()) -> Bool {
+        guard let subscription = subscriptions[userIdentifier] else { return true }
+        return subscription.expirationDate < referenceDate
+    }
+
+    func upgrade(userIdentifier: String, to tier: SubscriptionTier) -> Bool {
+        guard var subscription = subscriptions[userIdentifier] else { return false }
+        subscription.tier = tier
+        subscriptions[userIdentifier] = subscription
+        return true
+    }
+
+    func remainingDays(for userIdentifier: String, referenceDate: Date = Date()) -> Int? {
+        guard let subscription = subscriptions[userIdentifier] else { return nil }
+        let components = Calendar.current.dateComponents([.day], from: referenceDate, to: subscription.expirationDate)
+        return components.day.map { max(0, $0) }
+    }
+
+    func activeSubscriptions(referenceDate: Date = Date()) -> [Subscription] {
+        return subscriptions.values.filter { $0.expirationDate >= referenceDate }
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/does_not_use_generic_package_names/bad/order.go b/priv/combined_metrics/samples/naming_conventions/does_not_use_generic_package_names/bad/order.go
new file mode 100644
index 0000000..d825897
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/does_not_use_generic_package_names/bad/order.go
@@ -0,0 +1,67 @@
+// Package util is a catch-all name that gives callers no information about what
+// is inside. Go style discourages names like util, common, misc, helpers, api,
+// types, and interfaces.
+package util
+
+import (
+	"context"
+	"errors"
+	"time"
+)
+
+// ErrInvalidAmount is returned when an order has a non-positive amount.
+var ErrInvalidAmount = errors.New("amount must be positive")
+
+// Status represents the lifecycle state of an order.
+type Status string
+
+const (
+	StatusPending   Status = "pending"
+	StatusConfirmed Status = "confirmed"
+	StatusShipped   Status = "shipped"
+)
+
+// Order captures a purchase made by a customer.
+type Order struct {
+	ID         string
+	CustomerID string
+	Amount     float64
+	Status     Status
+	PlacedAt   time.Time
+}
+
+// OrderRepository persists and retrieves orders.
+type OrderRepository interface {
+	Save(ctx context.Context, o Order) error
+	FindByCustomer(ctx context.Context, customerID string) ([]Order, error)
+}
+
+// OrderService contains the business rules for managing orders.
+type OrderService struct {
+	repo OrderRepository
+}
+
+// NewOrderService constructs an OrderService.
+func NewOrderService(repo OrderRepository) *OrderService {
+	return &OrderService{repo: repo}
+}
+
+// PlaceOrder creates a new order for the given customer.
+func (s *OrderService) PlaceOrder(ctx context.Context, customerID string, amount float64) (*Order, error) {
+	if amount <= 0 {
+		return nil, ErrInvalidAmount
+	}
+	o := Order{
+		ID:         generateID(),
+		CustomerID: customerID,
+		Amount:     amount,
+		Status:     StatusPending,
+		PlacedAt:   time.Now().UTC(),
+	}
+	if err := s.repo.Save(ctx, o); err != nil {
+		return nil, err
+	}
+	return &o, nil
+}
+
+func generateID() string { return "generated-id" }
diff --git a/priv/combined_metrics/samples/naming_conventions/does_not_use_generic_package_names/good/order.go b/priv/combined_metrics/samples/naming_conventions/does_not_use_generic_package_names/good/order.go
new file mode 100644
index 0000000..a8282f8
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/does_not_use_generic_package_names/good/order.go
@@ -0,0 +1,64 @@
+package order
+
+import (
+	"context"
+	"errors"
+	"time"
+)
+
+// ErrInvalidAmount is returned when an order has a non-positive amount.
+var ErrInvalidAmount = errors.New("amount must be positive")
+
+// Status represents the lifecycle state of an order.
+type Status string
+
+const (
+	StatusPending   Status = "pending"
+	StatusConfirmed Status = "confirmed"
+	StatusShipped   Status = "shipped"
+)
+
+// Order captures a purchase made by a customer.
+type Order struct {
+	ID         string
+	CustomerID string
+	Amount     float64
+	Status     Status
+	PlacedAt   time.Time
+}
+
+// Repository persists and retrieves orders.
+type Repository interface {
+	Save(ctx context.Context, o Order) error
+	FindByCustomer(ctx context.Context, customerID string) ([]Order, error)
+}
+
+// Service contains the business rules for managing orders.
+type Service struct {
+	repo Repository
+}
+
+// New constructs an order Service.
+func New(repo Repository) *Service {
+	return &Service{repo: repo}
+}
+
+// Place creates a new order for the given customer.
+func (s *Service) Place(ctx context.Context, customerID string, amount float64) (*Order, error) {
+	if amount <= 0 {
+		return nil, ErrInvalidAmount
+	}
+	o := Order{
+		ID:         newID(),
+		CustomerID: customerID,
+		Amount:     amount,
+		Status:     StatusPending,
+		PlacedAt:   time.Now().UTC(),
+	}
+	if err := s.repo.Save(ctx, o); err != nil {
+		return nil, err
+	}
+	return &o, nil
+}
+
+func newID() string { return "generated-id" }
diff --git a/priv/combined_metrics/samples/naming_conventions/does_not_use_get_prefix_for_accessors/bad/InventoryService.swift b/priv/combined_metrics/samples/naming_conventions/does_not_use_get_prefix_for_accessors/bad/InventoryService.swift
new file mode 100644
index 0000000..402fe92
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/does_not_use_get_prefix_for_accessors/bad/InventoryService.swift
@@ -0,0 +1,56 @@
+import Foundation
+
+struct StockRecord {
+    let productID: String
+    var quantity: Int
+    var reservedQuantity: Int
+    var warehouseLocation: String
+}
+
+class InventoryService {
+    private var stock: [String: StockRecord] = [:]
+
+    // Should be totalProducts — "get" prefix is redundant on computed properties
+    var getTotalProducts: Int {
+        return stock.count
+    }
+
+    // Should be totalUnitsAvailable — "get" prefix is not idiomatic Swift
+    var getTotalUnitsAvailable: Int {
+        return stock.values.reduce(0) { $0 + max(0, $1.quantity - $1.reservedQuantity) }
+    }
+
+    // Should be record(for:) — "get" is implicit in property/method access
+    func getRecord(for productID: String) -> StockRecord? {
+        return stock[productID]
+    }
+
+    // Should be availableQuantity(for:)
+    func getAvailableQuantity(for productID: String) -> Int {
+        guard let record = stock[productID] else { return 0 }
+        return max(0, record.quantity - record.reservedQuantity)
+    }
+
+    // Should be warehouseLocation(of:)
+    func getWarehouseLocation(of productID: String) -> String? {
+        return stock[productID]?.warehouseLocation
+    }
+
+    // Should be lowStockProductIDs(threshold:)
+    func getLowStockProductIDs(threshold: Int) -> [String] {
+        return stock.compactMap { id, _ in
+            getAvailableQuantity(for: id) < threshold ? id : nil
+        }
+    }
+
+    func restock(productID: String, quantity: Int) {
+        stock[productID]?.quantity += quantity
+    }
+
+    func reserve(productID: String, quantity: Int) -> Bool {
+        guard let record = stock[productID],
+              getAvailableQuantity(for: productID) >= quantity else { return false }
+        stock[productID]?.reservedQuantity += quantity
+        return true
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/does_not_use_get_prefix_for_accessors/good/InventoryService.swift b/priv/combined_metrics/samples/naming_conventions/does_not_use_get_prefix_for_accessors/good/InventoryService.swift
new file mode 100644
index 0000000..03d2b47
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/does_not_use_get_prefix_for_accessors/good/InventoryService.swift
@@ -0,0 +1,50 @@
+import Foundation
+
+struct StockRecord {
+    let productID: String
+    var quantity: Int
+    var reservedQuantity: Int
+    var warehouseLocation: String
+}
+
+class InventoryService {
+    private var stock: [String: StockRecord] = [:]
+
+    var totalProducts: Int {
+        return stock.count
+    }
+
+    var totalUnitsAvailable: Int {
+        return stock.values.reduce(0) { $0 + max(0, $1.quantity - $1.reservedQuantity) }
+    }
+
+    func record(for productID: String) -> StockRecord? {
+        return stock[productID]
+    }
+
+    func availableQuantity(for productID: String) -> Int {
+        guard let record = stock[productID] else { return 0 }
+        return max(0, record.quantity - record.reservedQuantity)
+    }
+
+    func warehouseLocation(of productID: String) -> String? {
+        return stock[productID]?.warehouseLocation
+    }
+
+    func lowStockProductIDs(threshold: Int) -> [String] {
+        return stock.compactMap { id, record in
+            availableQuantity(for: id) < threshold ? id : nil
+        }
+    }
+
+    func restock(productID: String, quantity: Int) {
+        stock[productID]?.quantity += quantity
+    }
+
+    func reserve(productID: String, quantity: Int) -> Bool {
+        guard let record = stock[productID],
+              availableQuantity(for: productID) >= quantity else { return false }
+        stock[productID]?.reservedQuantity += quantity
+        return true
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/exported_name_not_redundant_with_package/bad/product.go b/priv/combined_metrics/samples/naming_conventions/exported_name_not_redundant_with_package/bad/product.go
new file mode 100644
index 0000000..ee8878c
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/exported_name_not_redundant_with_package/bad/product.go
@@ -0,0 +1,48 @@
+package product
+
+import (
+	"context"
+	"errors"
+)
+
+// ErrProductOutOfStock is named with redundant package prefix.
+// Callers write product.ErrProductOutOfStock — "product" appears twice.
+var ErrProductOutOfStock = errors.New("out of stock")
+
+// ProductCategory is redundant — callers write product.ProductCategory.
+type ProductCategory string
+
+const (
+	ProductCategoryElectronics ProductCategory = "electronics"
+	ProductCategoryClothing    ProductCategory = "clothing"
+)
+
+// ProductItem is redundant — callers write product.ProductItem.
+type ProductItem struct {
+	ProductID       string
+	ProductName     string
+	ProductPrice    float64
+	ProductStock    int
+	ProductCategory ProductCategory
+}
+
+// ProductCatalog is redundant — callers write product.ProductCatalog.
+type ProductCatalog struct {
+	store ProductStore
+}
+
+// ProductStore is redundant — callers write product.ProductStore.
+type ProductStore interface {
+	GetProduct(ctx context.Context, id string) (*ProductItem, error)
+	ListProducts(ctx context.Context, category ProductCategory) ([]ProductItem, error)
+}
+
+// NewProductCatalog constructs a ProductCatalog backed by the given ProductStore.
+func NewProductCatalog(store ProductStore) *ProductCatalog {
+	return &ProductCatalog{store: store}
+}
+
+// FindProduct retrieves a product item by ID.
+func (c *ProductCatalog) FindProduct(ctx context.Context, id string) (*ProductItem, error) {
+	return c.store.GetProduct(ctx, id)
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/exported_name_not_redundant_with_package/good/product.go b/priv/combined_metrics/samples/naming_conventions/exported_name_not_redundant_with_package/good/product.go
new file mode 100644
index 0000000..dfb224e
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/exported_name_not_redundant_with_package/good/product.go
@@ -0,0 +1,54 @@
+package product
+
+import (
+	"context"
+	"errors"
+)
+
+// ErrOutOfStock is returned when a product has no available inventory.
+var ErrOutOfStock = errors.New("out of stock")
+
+// Category classifies a product into a top-level group.
+type Category string
+
+const (
+	CategoryElectronics Category = "electronics"
+	CategoryClothing    Category = "clothing"
+)
+
+// Item describes a purchasable product. Named Item, not ProductItem, because the
+// package name already provides the "product" context at call sites: product.Item.
+type Item struct {
+	ID       string
+	Name     string
+	Price    float64
+	Stock    int
+	Category Category
+}
+
+// Catalog manages the collection of available products.
+// Named Catalog, not ProductCatalog — callers use product.Catalog.
+type Catalog struct {
+	store Store
+}
+
+// Store is the persistence layer for product items.
+type Store interface {
+	Get(ctx context.Context, id string) (*Item, error)
+	List(ctx context.Context, category Category) ([]Item, error)
+}
+
+// NewCatalog constructs a Catalog backed by the given Store.
+func NewCatalog(store Store) *Catalog {
+	return &Catalog{store: store}
+}
+
+// Find retrieves a product item by ID.
+func (c *Catalog) Find(ctx context.Context, id string) (*Item, error) {
+	return c.store.Get(ctx, id)
+}
+
+// Browse lists all items in a category.
+func (c *Catalog) Browse(ctx context.Context, cat Category) ([]Item, error) {
+	return c.store.List(ctx, cat)
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/factory_method_starts_with_make/bad/ReportBuilder.swift b/priv/combined_metrics/samples/naming_conventions/factory_method_starts_with_make/bad/ReportBuilder.swift
new file mode 100644
index 0000000..db627ae
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/factory_method_starts_with_make/bad/ReportBuilder.swift
@@ -0,0 +1,79 @@
+import Foundation
+
+struct Report {
+    let title: String
+    let sections: [ReportSection]
+    let generatedAt: Date
+    let format: ReportFormat
+}
+
+struct ReportSection {
+    let heading: String
+    let body: String
+    let chartData: [Double]?
+}
+
+enum ReportFormat {
+    case pdf, html, plainText
+}
+
+struct ReportConfiguration {
+    var title: String
+    var includeSummary: Bool
+    var includeCharts: Bool
+    var format: ReportFormat
+}
+
+class ReportBuilder {
+    private let configuration: ReportConfiguration
+
+    init(configuration: ReportConfiguration) {
+        self.configuration = configuration
+    }
+
+    // Should be makeReport — "build" doesn't follow Swift factory naming
+    func buildReport(from data: [[String: Any]]) -> Report {
+        var sections: [ReportSection] = []
+
+        if configuration.includeSummary {
+            sections.append(createSummarySection(from: data))
+        }
+
+        sections.append(generateDetailSection(from: data))
+
+        if configuration.includeCharts {
+            sections.append(constructChartSection(from: data))
+        }
+
+        return Report(
+            title: configuration.title,
+            sections: sections,
+            generatedAt: Date(),
+            format: configuration.format
+        )
+    }
+
+    // Should be makeSummarySection — inconsistent "create" prefix
+    func createSummarySection(from data: [[String: Any]]) -> ReportSection {
+        return ReportSection(
+            heading: "Summary",
+            body: "Total records: \(data.count)",
+            chartData: nil
+        )
+    }
+
+    // Should be makeDetailSection — inconsistent "generate" prefix
+    func generateDetailSection(from data: [[String: Any]]) -> ReportSection {
+        let body = data.map { row in
+            row.map { "\($0.key): \($0.value)" }.joined(separator: ", ")
+        }.joined(separator: "\n")
+
+        return ReportSection(heading: "Details", body: body, chartData: nil)
+    }
+
+    // Should be makeChartSection — inconsistent "construct" prefix
+    func constructChartSection(from data: [[String: Any]]) -> ReportSection {
+        let values = data.compactMap { $0["value"] as? Double }
+        return ReportSection(heading: "Chart", body: "", chartData: values)
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/factory_method_starts_with_make/good/ReportBuilder.swift b/priv/combined_metrics/samples/naming_conventions/factory_method_starts_with_make/good/ReportBuilder.swift
new file mode 100644
index 0000000..685ba56
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/factory_method_starts_with_make/good/ReportBuilder.swift
@@ -0,0 +1,75 @@
+import Foundation
+
+struct Report {
+    let title: String
+    let sections: [ReportSection]
+    let generatedAt: Date
+    let format: ReportFormat
+}
+
+struct ReportSection {
+    let heading: String
+    let body: String
+    let chartData: [Double]?
+}
+
+enum ReportFormat {
+    case pdf, html, plainText
+}
+
+struct ReportConfiguration {
+    var title: String
+    var includeSummary: Bool
+    var includeCharts: Bool
+    var format: ReportFormat
+}
+
+class ReportBuilder {
+    private let configuration: ReportConfiguration
+
+    init(configuration: ReportConfiguration) {
+        self.configuration = configuration
+    }
+
+    func makeReport(from data: [[String: Any]]) -> Report {
+        var sections: [ReportSection] = []
+
+        if configuration.includeSummary {
+            sections.append(makeSummarySection(from: data))
+        }
+
+        sections.append(makeDetailSection(from: data))
+
+        if configuration.includeCharts {
+            sections.append(makeChartSection(from: data))
+        }
+
+        return Report(
+            title: configuration.title,
+            sections: sections,
+            generatedAt: Date(),
+            format: configuration.format
+        )
+    }
+
+    func makeSummarySection(from data: [[String: Any]]) -> ReportSection {
+        return ReportSection(
+            heading: "Summary",
+            body: "Total records: \(data.count)",
+            chartData: nil
+        )
+    }
+
+    func makeDetailSection(from data: [[String: Any]]) -> ReportSection {
+        let body = data.map { row in
+            row.map { "\($0.key): \($0.value)" }.joined(separator: ", ")
+        }.joined(separator: "\n")
+
+        return ReportSection(heading: "Details", body: body, chartData: nil)
+    }
+
+    func makeChartSection(from data: [[String: Any]]) -> ReportSection {
+        let values = data.compactMap { $0["value"] as? Double }
+        return ReportSection(heading: "Chart", body: "", chartData: values)
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/file_name_matches_primary_export/bad/helpers.ex b/priv/combined_metrics/samples/naming_conventions/file_name_matches_primary_export/bad/helpers.ex
new file mode 100644
index 0000000..6127e4a
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/file_name_matches_primary_export/bad/helpers.ex
@@ -0,0 +1,50 @@
+defmodule UserManager do
+  def create_user(attrs) do
+    with :ok <- validate_attrs(attrs),
+         {:ok, user} <- insert_user(attrs) do
+      {:ok, user}
+    end
+  end
+
+  def update_user(user, attrs) do
+    with :ok <- validate_attrs(attrs),
+         {:ok, updated} <- persist_update(user, attrs) do
+      {:ok, updated}
+    end
+  end
+
+  def deactivate_user(user) do
+    case user.status do
+      :active -> {:ok, %{user | status: :inactive}}
+      :inactive -> {:error, :already_inactive}
+    end
+  end
+
+  def find_by_email(email) do
+    case lookup_email(email) do
+      nil -> {:error, :not_found}
+      user -> {:ok, user}
+    end
+  end
+
+  def list_active_users do
+    [
+      %{id: 1, name: "Alice", email: "alice@example.com", status: :active},
+      %{id: 2, name: "Bob", email: "bob@example.com", status: :active}
+    ]
+  end
+
+  defp validate_attrs(%{email: email}) when is_binary(email), do: :ok
+  defp validate_attrs(_), do: {:error, :invalid_attrs}
+
+  defp insert_user(attrs) do
+    {:ok, Map.merge(%{id: System.unique_integer([:positive])}, attrs)}
+  end
+
+  defp persist_update(user, attrs) do
+    {:ok, Map.merge(user, attrs)}
+  end
+
+  defp lookup_email("alice@example.com"), do: %{id: 1, email: "alice@example.com", status: :active}
+  defp lookup_email(_), do: nil
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/file_name_matches_primary_export/config.yml b/priv/combined_metrics/samples/naming_conventions/file_name_matches_primary_export/config.yml
new file mode 100644
index 0000000..f363ce6
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/file_name_matches_primary_export/config.yml
@@ -0,0 +1 @@
+doc: "The file name should match the primary class or module it exports (e.g. `user.js` exports `User`)."
diff --git a/priv/combined_metrics/samples/naming_conventions/file_name_matches_primary_export/good/user_manager.ex b/priv/combined_metrics/samples/naming_conventions/file_name_matches_primary_export/good/user_manager.ex
new file mode 100644
index 0000000..6127e4a
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/file_name_matches_primary_export/good/user_manager.ex
@@ -0,0 +1,50 @@
+defmodule UserManager do
+  def create_user(attrs) do
+    with :ok <- validate_attrs(attrs),
+         {:ok, user} <- insert_user(attrs) do
+      {:ok, user}
+    end
+  end
+
+  def update_user(user, attrs) do
+    with :ok <- validate_attrs(attrs),
+         {:ok, updated} <- persist_update(user, attrs) do
+      {:ok, updated}
+    end
+  end
+
+  def deactivate_user(user) do
+    case user.status do
+      :active -> {:ok, %{user | status: :inactive}}
+      :inactive -> {:error, :already_inactive}
+    end
+  end
+
+  def find_by_email(email) do
+    case lookup_email(email) do
+      nil -> {:error, :not_found}
+      user -> {:ok, user}
+    end
+  end
+
+  def list_active_users do
+    [
+      %{id: 1, name: "Alice", email: "alice@example.com", status: :active},
+      %{id: 2, name: "Bob", email: "bob@example.com", status: :active}
+    ]
+  end
+
+  defp validate_attrs(%{email: email}) when is_binary(email), do: :ok
+  defp validate_attrs(_), do: {:error, :invalid_attrs}
+
+  defp insert_user(attrs) do
+    {:ok, Map.merge(%{id: System.unique_integer([:positive])}, attrs)}
+  end
+
+  defp persist_update(user, attrs) do
+    {:ok, Map.merge(user, attrs)}
+  end
+
+  defp lookup_email("alice@example.com"), do: %{id: 1, email: "alice@example.com", status: :active}
+  defp lookup_email(_), do: nil
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/function_name_is_not_single_word/bad/worker.ex b/priv/combined_metrics/samples/naming_conventions/function_name_is_not_single_word/bad/worker.ex
new file mode 100644
index 0000000..a1d2be1
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/function_name_is_not_single_word/bad/worker.ex
@@ -0,0 +1,46 @@
+defmodule Worker do
+  def run(job) do
+    job
+    |> fetch()
+    |> process()
+    |> handle()
+    |> finish()
+  end
+
+  def fetch(job) do
+    {:ok, Map.put(job, :data, load_data(job.id))}
+  end
+
+  def process({:ok, job}) do
+    {:ok, Map.put(job, :result, transform(job.data))}
+  end
+
+  def process({:error, _} = err), do: err
+
+  def handle({:ok, job}) do
+    {:ok, Map.put(job, :dispatched, true)}
+  end
+
+  def handle({:error, _} = err), do: err
+
+  def finish({:ok, job}) do
+    {:ok, Map.put(job, :status, :done)}
+  end
+
+  def finish({:error, reason}) do
+    {:error, reason}
+  end
+
+  def execute(queue_name) do
+    queue_name
+    |> pop()
+    |> run()
+  end
+
+  def pop(queue_name) do
+    %{id: 1, queue: queue_name, type: :default}
+  end
+
+  defp load_data(id), do: %{raw: "data_for_#{id}"}
+  defp transform(data), do: Map.put(data, :processed, true)
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/function_name_is_not_single_word/config.yml b/priv/combined_metrics/samples/naming_conventions/function_name_is_not_single_word/config.yml
new file mode 100644
index 0000000..c657e6b
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/function_name_is_not_single_word/config.yml
@@ -0,0 +1 @@
+doc: "Single-word function names like `run`, `process`, or `handle` are too vague to convey intent."
diff --git a/priv/combined_metrics/samples/naming_conventions/function_name_is_not_single_word/good/worker.ex b/priv/combined_metrics/samples/naming_conventions/function_name_is_not_single_word/good/worker.ex
new file mode 100644
index 0000000..c693841
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/function_name_is_not_single_word/good/worker.ex
@@ -0,0 +1,46 @@
+defmodule Worker do
+  def run_scheduled_job(job) do
+    job
+    |> fetch_job_data()
+    |> process_job_data()
+    |> dispatch_job_result()
+    |> mark_job_complete()
+  end
+
+  def fetch_job_data(job) do
+    {:ok, Map.put(job, :data, load_raw_data(job.id))}
+  end
+
+  def process_job_data({:ok, job}) do
+    {:ok, Map.put(job, :result, transform_raw_data(job.data))}
+  end
+
+  def process_job_data({:error, _} = err), do: err
+
+  def dispatch_job_result({:ok, job}) do
+    {:ok, Map.put(job, :dispatched, true)}
+  end
+
+  def dispatch_job_result({:error, _} = err), do: err
+
+  def mark_job_complete({:ok, job}) do
+    {:ok, Map.put(job, :status, :done)}
+  end
+
+  def mark_job_complete({:error, reason}) do
+    {:error, reason}
+  end
+
+  def drain_queue(queue_name) do
+    queue_name
+    |> pop_next_job()
+    |> run_scheduled_job()
+  end
+
+  def pop_next_job(queue_name) do
+    %{id: 1, queue: queue_name, type: :default}
+  end
+
+  defp load_raw_data(id), do: %{raw: "data_for_#{id}"}
+  defp transform_raw_data(data), do: Map.put(data, :processed, true)
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/function_name_matches_return_type/bad/queries.ex b/priv/combined_metrics/samples/naming_conventions/function_name_matches_return_type/bad/queries.ex
new file mode 100644
index 0000000..0378e9a
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/function_name_matches_return_type/bad/queries.ex
@@ -0,0 +1,46 @@
+defmodule Queries do
+  # get_* returns a boolean instead of data
+  def get_user_active(user_id) do
+    user = fetch_from_db(:users, user_id)
+    user.status == :active
+  end
+
+  # is_* returns data instead of a boolean
+  def is_user(user_id) do
+    fetch_from_db(:users, user_id)
+  end
+
+  # list_* returns a single item instead of a collection
+  def list_latest_order(user_id) do
+    fetch_from_db(:orders, {:latest, user_id})
+  end
+
+  # has_* returns data instead of a boolean
+  def has_permissions(user_id) do
+    fetch_from_db(:permissions, user_id)
+  end
+
+  # can_* returns data instead of a boolean
+  def can_role(user_id) do
+    user = fetch_from_db(:users, user_id)
+    user.role
+  end
+
+  # create_* returns a boolean instead of the new entity
+  def create_new_session(user_id) do
+    _session = %{user_id: user_id, token: "tok_#{user_id}"}
+    true
+  end
+
+  # get_* returns a collection instead of a single item
+  def get_products(category) do
+    [
+      %{id: 1, name: "Widget", category: category},
+      %{id: 2, name: "Gadget", category: category}
+    ]
+  end
+
+  defp fetch_from_db(:users, id), do: %{id: id, name: "User #{id}", status: :active, role: :member}
+  defp fetch_from_db(:orders, {:latest, uid}), do: %{id: 99, user_id: uid, status: :shipped}
+  defp fetch_from_db(:permissions, uid), do: %{user_id: uid, scopes: [:read, :write]}
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/function_name_matches_return_type/config.yml b/priv/combined_metrics/samples/naming_conventions/function_name_matches_return_type/config.yml
new file mode 100644
index 0000000..d5637b6
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/function_name_matches_return_type/config.yml
@@ -0,0 +1 @@
+doc: "Functions prefixed with `get_`, `fetch_`, or `find_` should return the thing they name."
diff --git a/priv/combined_metrics/samples/naming_conventions/function_name_matches_return_type/good/queries.ex b/priv/combined_metrics/samples/naming_conventions/function_name_matches_return_type/good/queries.ex
new file mode 100644
index 0000000..9d04c6a
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/function_name_matches_return_type/good/queries.ex
@@ -0,0 +1,46 @@
+defmodule Queries do
+  # get_* returns data
+  def get_user(user_id) do
+    fetch_from_db(:users, user_id)
+  end
+
+  # is_*/has_*/can_* return booleans
+  def is_user_active?(user_id) do
+    user = fetch_from_db(:users, user_id)
+    user.status == :active
+  end
+
+  # list_* returns a collection
+  def list_orders(user_id) do
+    [fetch_from_db(:orders, {:latest, user_id})]
+  end
+
+  # has_* returns a boolean
+  def has_permissions?(user_id) do
+    perms = fetch_from_db(:permissions, user_id)
+    length(perms.scopes) > 0
+  end
+
+  # can_* returns a boolean
+  def can_edit?(user_id) do
+    user = fetch_from_db(:users, user_id)
+    user.role in [:admin, :editor]
+  end
+
+  # create_* returns the new entity
+  def create_session(user_id) do
+    {:ok, %{user_id: user_id, token: "tok_#{user_id}"}}
+  end
+
+  # list_* returns a collection
+  def list_products_by_category(category) do
+    [
+      %{id: 1, name: "Widget", category: category},
+      %{id: 2, name: "Gadget", category: category}
+    ]
+  end
+
+  defp fetch_from_db(:users, id), do: %{id: id, name: "User #{id}", status: :active, role: :member}
+  defp fetch_from_db(:orders, {:latest, uid}), do: %{id: 99, user_id: uid, status: :shipped}
+  defp fetch_from_db(:permissions, uid), do: %{user_id: uid, scopes: [:read, :write]}
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/get_fetch_fetch_bang_contract_is_consistent/bad/sessions.ex b/priv/combined_metrics/samples/naming_conventions/get_fetch_fetch_bang_contract_is_consistent/bad/sessions.ex
new file mode 100644
index 0000000..39319f4
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/get_fetch_fetch_bang_contract_is_consistent/bad/sessions.ex
@@ -0,0 +1,53 @@
+defmodule MyApp.Sessions do
+  @moduledoc """
+  Session store operations.
+  """
+
+  alias MyApp.Sessions.Session
+
+  @sessions_table :sessions_cache
+
+  # Bad: `get_session` raises instead of returning nil/default
+  @spec get_session(String.t()) :: Session.t()
+  def get_session(token) when is_binary(token) do
+    case :ets.lookup(@sessions_table, token) do
+      [{^token, session}] -> session
+      [] -> raise KeyError, key: token, term: @sessions_table
+    end
+  end
+
+  # Bad: `fetch_session` returns nil instead of `{:ok, value}` or `:error`
+  @spec fetch_session(String.t()) :: Session.t() | nil
+  def fetch_session(token) when is_binary(token) do
+    case :ets.lookup(@sessions_table, token) do
+      [{^token, session}] -> session
+      [] -> nil
+    end
+  end
+
+  # Bad: `fetch_session!` returns a tuple like fetch, not raising
+  @spec fetch_session!(String.t()) :: {:ok, Session.t()} | {:error, :not_found}
+  def fetch_session!(token) when is_binary(token) do
+    case :ets.lookup(@sessions_table, token) do
+      [{^token, session}] -> {:ok, session}
+      [] -> {:error, :not_found}
+    end
+  end
+
+  # Bad: `get_value` returns `{:ok, val}` or `:error` like fetch_*
+  @spec get_value(Session.t(), atom()) :: {:ok, any()} | :error
+  def get_value(%Session{data: data}, key), do: Map.fetch(data, key)
+
+  # Bad: `fetch_value` returns nil (should be `{:ok, val}` or `:error`)
+  @spec fetch_value(Session.t(), atom()) :: any() | nil
+  def fetch_value(%Session{data: data}, key), do: Map.get(data, key)
+
+  # Bad: `fetch_value!` swallows the error and returns nil
+  @spec fetch_value!(Session.t(), atom()) :: any()
+  def fetch_value!(%Session{data: data}, key) do
+    case Map.fetch(data, key) do
+      {:ok, v} -> v
+      :error -> nil
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/get_fetch_fetch_bang_contract_is_consistent/good/sessions.ex b/priv/combined_metrics/samples/naming_conventions/get_fetch_fetch_bang_contract_is_consistent/good/sessions.ex
new file mode 100644
index 0000000..1e3c66e
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/get_fetch_fetch_bang_contract_is_consistent/good/sessions.ex
@@ -0,0 +1,78 @@
+defmodule MyApp.Sessions do
+  @moduledoc """
+  Session store operations. Follows the `get_*` / `fetch_*` / `fetch_*!` contract:
+  - `get_*` returns a value or a default (nil by default)
+  - `fetch_*` returns `{:ok, value}` or `:error`
+  - `fetch_*!` raises `KeyError` on missing key
+  """
+
+  alias MyApp.Sessions.Session
+
+  @sessions_table :sessions_cache
+
+  @doc """
+  Returns the session for the given token, or `nil` if not found.
+  Safe to call when the session may or may not exist.
+  """
+  @spec get_session(String.t()) :: Session.t() | nil
+  def get_session(token) when is_binary(token) do
+    case :ets.lookup(@sessions_table, token) do
+      [{^token, session}] -> session
+      [] -> nil
+    end
+  end
+
+  @doc """
+  Returns the session for the given token, or the `default` value
+  when no session is found.
+  """
+  @spec get_session(String.t(), any()) :: Session.t() | any()
+  def get_session(token, default) when is_binary(token) do
+    case :ets.lookup(@sessions_table, token) do
+      [{^token, session}] -> session
+      [] -> default
+    end
+  end
+
+  @doc """
+  Fetches a session by token. Returns `{:ok, session}` if found,
+  or `:error` if not found. Use when the caller handles the missing case.
+  """
+  @spec fetch_session(String.t()) :: {:ok, Session.t()} | :error
+  def fetch_session(token) when is_binary(token) do
+    case :ets.lookup(@sessions_table, token) do
+      [{^token, session}] -> {:ok, session}
+      [] -> :error
+    end
+  end
+
+  @doc """
+  Fetches a session by token. Raises `KeyError` if not found.
+  Use when the session must exist and absence is a programming error.
+  """
+  @spec fetch_session!(String.t()) :: Session.t()
+  def fetch_session!(token) when is_binary(token) do
+    case fetch_session(token) do
+      {:ok, session} -> session
+      :error -> raise KeyError, key: token, term: @sessions_table
+    end
+  end
+
+  @doc """
+  Returns the value for `key` in the session data, or `nil` if absent.
+  """
+  @spec get_value(Session.t(), atom()) :: any()
+  def get_value(%Session{data: data}, key), do: Map.get(data, key)
+
+  @doc """
+  Fetches `key` from session data. Returns `{:ok, value}` or `:error`.
+  """
+  @spec fetch_value(Session.t(), atom()) :: {:ok, any()} | :error
+  def fetch_value(%Session{data: data}, key), do: Map.fetch(data, key)
+
+  @doc """
+  Fetches `key` from session data. Raises `KeyError` if absent.
+  """
+  @spec fetch_value!(Session.t(), atom()) :: any()
+  def fetch_value!(%Session{data: data}, key), do: Map.fetch!(data, key)
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/getter_has_no_prefix/bad/user.rs b/priv/combined_metrics/samples/naming_conventions/getter_has_no_prefix/bad/user.rs
new file mode 100644
index 0000000..05a151d
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/getter_has_no_prefix/bad/user.rs
@@ -0,0 +1,45 @@
+#[derive(Debug, Clone)]
+pub struct User {
+    id: u64,
+    username: String,
+    email: String,
+    age: u32,
+    role: String,
+}
+
+impl User {
+    pub fn new(id: u64, username: impl Into<String>, email: impl Into<String>, age: u32, role: impl Into<String>) -> Self {
+        Self { id, username: username.into(), email: email.into(), age, role: role.into() }
+    }
+
+    // Bad: "get_" prefix is a Java/C++ convention — not idiomatic Rust
+    pub fn get_id(&self) -> u64 {
+        self.id
+    }
+
+    pub fn get_username(&self) -> &str {
+        &self.username
+    }
+
+    pub fn get_email(&self) -> &str {
+        &self.email
+    }
+
+    pub fn get_age(&self) -> u32 {
+        self.age
+    }
+
+    pub fn get_role(&self) -> &str {
+        &self.role
+    }
+
+    // Verbose and redundant: set_ on setters is fine, but callers now write
+    // user.get_email() instead of the idiomatic user.email()
+    pub fn set_email(&mut self, email: impl Into<String>) {
+        self.email = email.into();
+    }
+
+    pub fn set_role(&mut self, role: impl Into<String>) {
+        self.role = role.into();
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/getter_has_no_prefix/good/user.rs b/priv/combined_metrics/samples/naming_conventions/getter_has_no_prefix/good/user.rs
new file mode 100644
index 0000000..3f82c19
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/getter_has_no_prefix/good/user.rs
@@ -0,0 +1,51 @@
+#[derive(Debug, Clone)]
+pub struct User {
+    id: u64,
+    username: String,
+    email: String,
+    age: u32,
+    role: Role,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Role {
+    Admin,
+    Member,
+    Guest,
+}
+
+impl User {
+    pub fn new(id: u64, username: impl Into<String>, email: impl Into<String>, age: u32, role: Role) -> Self {
+        Self { id, username: username.into(), email: email.into(), age, role }
+    }
+
+    // Good: Rust convention — getters are named after the field, no "get_" prefix
+    pub fn id(&self) -> u64 {
+        self.id
+    }
+
+    pub fn username(&self) -> &str {
+        &self.username
+    }
+
+    pub fn email(&self) -> &str {
+        &self.email
+    }
+
+    pub fn age(&self) -> u32 {
+        self.age
+    }
+
+    pub fn role(&self) -> &Role {
+        &self.role
+    }
+
+    // Setters use "set_" prefix — that IS idiomatic for mutation
+    pub fn set_email(&mut self, email: impl Into<String>) {
+        self.email = email.into();
+    }
+
+    pub fn set_role(&mut self, role: Role) {
+        self.role = role;
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/getter_not_prefixed_with_get/bad/account.go b/priv/combined_metrics/samples/naming_conventions/getter_not_prefixed_with_get/bad/account.go
new file mode 100644
index 0000000..b6e5ba5
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/getter_not_prefixed_with_get/bad/account.go
@@ -0,0 +1,50 @@
+package account
+
+import "time"
+
+// Account holds financial balance information for a customer.
+type Account struct {
+	id        string
+	ownerName string
+	balance   float64
+	createdAt time.Time
+}
+
+// NewAccount constructs an Account with the given owner.
+func NewAccount(id, ownerName string) *Account {
+	return &Account{
+		id:        id,
+		ownerName: ownerName,
+		createdAt: time.Now().UTC(),
+	}
+}
+
+// GetID returns the account's unique identifier.
+// "Get" prefix is not idiomatic Go — should be ID().
+func (a *Account) GetID() string { return a.id }
+
+// GetOwner returns the name of the account owner.
+// "Get" prefix is not idiomatic Go — should be Owner().
+func (a *Account) GetOwner() string { return a.ownerName }
+
+// GetBalance returns the current account balance.
+// "Get" prefix is not idiomatic Go — should be Balance().
+func (a *Account) GetBalance() float64 { return a.balance }
+
+// GetCreatedAt returns the time the account was created.
+// "Get" prefix is not idiomatic Go — should be CreatedAt().
+func (a *Account) GetCreatedAt() time.Time { return a.createdAt }
+
+// Deposit adds funds to the account.
+func (a *Account) Deposit(amount float64) {
+	a.balance += amount
+}
+
+// Withdraw deducts funds from the account if sufficient balance exists.
+func (a *Account) Withdraw(amount float64) bool {
+	if a.balance < amount {
+		return false
+	}
+	a.balance -= amount
+	return true
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/getter_not_prefixed_with_get/good/account.go b/priv/combined_metrics/samples/naming_conventions/getter_not_prefixed_with_get/good/account.go
new file mode 100644
index 0000000..430531e
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/getter_not_prefixed_with_get/good/account.go
@@ -0,0 +1,49 @@
+package account
+
+import "time"
+
+// Account holds financial balance information for a customer.
+type Account struct {
+	id        string
+	ownerName string
+	balance   float64
+	createdAt time.Time
+}
+
+// NewAccount constructs an Account with the given owner.
+func NewAccount(id, ownerName string) *Account {
+	return &Account{
+		id:        id,
+		ownerName: ownerName,
+		createdAt: time.Now().UTC(),
+	}
+}
+
+// ID returns the account's unique identifier.
+// Named ID(), not GetID() — Go convention omits the "Get" prefix.
+func (a *Account) ID() string { return a.id }
+
+// Owner returns the name of the account owner.
+// Named Owner(), not GetOwner().
+func (a *Account) Owner() string { return a.ownerName }
+
+// Balance returns the current account balance.
+// Named Balance(), not GetBalance().
+func (a *Account) Balance() float64 { return a.balance }
+
+// CreatedAt returns the time the account was created.
+func (a *Account) CreatedAt() time.Time { return a.createdAt }
+
+// Deposit adds funds to the account.
+func (a *Account) Deposit(amount float64) {
+	a.balance += amount
+}
+
+// Withdraw deducts funds from the account if sufficient balance exists.
+func (a *Account) Withdraw(amount float64) bool {
+	if a.balance < amount {
+		return false
+	}
+	a.balance -= amount
+	return true
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/initialism_uses_consistent_casing/bad/api.go b/priv/combined_metrics/samples/naming_conventions/initialism_uses_consistent_casing/bad/api.go
new file mode 100644
index 0000000..f4e9fb9
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/initialism_uses_consistent_casing/bad/api.go
@@ -0,0 +1,40 @@
+package api
+
+import (
+	"net/http"
+	"net/url"
+)
+
+// Handler implements the Http interface for the REST Api.
+// Initialisms are inconsistently cased: Http instead of HTTP, Api instead of API,
+// Id instead of ID — mixing conventions makes the code harder to read.
+type Handler struct {
+	baseUrl *url.URL // should be baseURL
+	appId   string   // should be appID
+}
+
+// NewHandler constructs a Handler for the given base Url and application Id.
+func NewHandler(baseUrl *url.URL, appId string) *Handler {
+	return &Handler{baseUrl: baseUrl, appId: appId}
+}
+
+// ServeHttp satisfies http.Handler. Should be ServeHTTP.
+func (h *Handler) ServeHttp(w http.ResponseWriter, r *http.Request) {
+	userId := r.URL.Query().Get("user_id") // should be userID
+	if userId == "" {
+		http.Error(w, "user_id required", http.StatusBadRequest)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+}
+
+// ParseUrl converts a raw string to a *url.URL. Should be parseURL.
+func ParseUrl(raw string) (*url.URL, error) {
+	return url.Parse(raw)
+}
+
+// BuildApiPath constructs an Api path. Should be buildAPIPath.
+func BuildApiPath(resource, id string) string {
+	return "/" + resource + "/" + id
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/initialism_uses_consistent_casing/good/api.go b/priv/combined_metrics/samples/naming_conventions/initialism_uses_consistent_casing/good/api.go
new file mode 100644
index 0000000..198c2bb
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/initialism_uses_consistent_casing/good/api.go
@@ -0,0 +1,41 @@
+package api
+
+import (
+	"net/http"
+	"net/url"
+)
+
+// Handler implements the HTTP interface for the REST API.
+// Initialisms are uniformly uppercased: HTTP, URL, ID, JSON.
+type Handler struct {
+	baseURL *url.URL
+	appID   string
+}
+
+// NewHandler constructs a Handler for the given base URL and application ID.
+func NewHandler(baseURL *url.URL, appID string) *Handler {
+	return &Handler{baseURL: baseURL, appID: appID}
+}
+
+// ServeHTTP satisfies http.Handler. Named ServeHTTP, not ServeHttp.
+func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	userID := r.URL.Query().Get("user_id")
+	if userID == "" {
+		http.Error(w, "user_id required", http.StatusBadRequest)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+}
+
+// ParseURL converts a raw string to a validated *url.URL.
+// Named parseURL (camelCase with lowercase "url"), not parseUrl.
+func parseURL(raw string) (*url.URL, error) {
+	return url.Parse(raw)
+}
+
+// buildAPIPath constructs an API path for a given resource and ID.
+// Named buildAPIPath (uppercase API), not buildApiPath.
+func buildAPIPath(resource, id string) string {
+	return "/" + resource + "/" + id
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/interface_named_with_er_suffix/bad/notification.go b/priv/combined_metrics/samples/naming_conventions/interface_named_with_er_suffix/bad/notification.go
new file mode 100644
index 0000000..b3895c4
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/interface_named_with_er_suffix/bad/notification.go
@@ -0,0 +1,31 @@
+package notification
+
+import "context"
+
+// NotificationSendingInterface is a single-method interface with a vague,
+// verbose name. Go convention: a single Send method → the interface is Sender.
+type NotificationSendingInterface interface {
+	Send(ctx context.Context, to, subject, body string) error
+}
+
+// MessageFormattingInterface should be named Formatter.
+type MessageFormattingInterface interface {
+	Format(event map[string]string) (subject, body string)
+}
+
+// NotificationService composes the two interfaces to dispatch alerts.
+type NotificationService struct {
+	sender    NotificationSendingInterface
+	formatter MessageFormattingInterface
+}
+
+// New constructs a NotificationService.
+func New(sender NotificationSendingInterface, formatter MessageFormattingInterface) *NotificationService {
+	return &NotificationService{sender: sender, formatter: formatter}
+}
+
+// Notify formats and sends an event notification to the recipient.
+func (s *NotificationService) Notify(ctx context.Context, to string, event map[string]string) error {
+	subject, body := s.formatter.Format(event)
+	return s.sender.Send(ctx, to, subject, body)
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/interface_named_with_er_suffix/good/notification.go b/priv/combined_metrics/samples/naming_conventions/interface_named_with_er_suffix/good/notification.go
new file mode 100644
index 0000000..f4e3ad8
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/interface_named_with_er_suffix/good/notification.go
@@ -0,0 +1,32 @@
+package notification
+
+import "context"
+
+// Sender is a single-method interface named with the "-er" agent-noun suffix.
+// This follows Go's convention: the method is Send, so the interface is Sender.
+type Sender interface {
+	Send(ctx context.Context, to, subject, body string) error
+}
+
+// Formatter transforms a raw event into a human-readable message.
+// Single method Format → interface named Formatter.
+type Formatter interface {
+	Format(event map[string]string) (subject, body string)
+}
+
+// NotificationService composes a Sender and Formatter to dispatch alerts.
+type NotificationService struct {
+	sender    Sender
+	formatter Formatter
+}
+
+// New constructs a NotificationService.
+func New(sender Sender, formatter Formatter) *NotificationService {
+	return &NotificationService{sender: sender, formatter: formatter}
+}
+
+// Notify formats and sends an event notification to the recipient.
+func (s *NotificationService) Notify(ctx context.Context, to string, event map[string]string) error {
+	subject, body := s.formatter.Format(event)
+	return s.sender.Send(ctx, to, subject, body)
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/methods_use_camel_case/bad/PaymentGateway.php b/priv/combined_metrics/samples/naming_conventions/methods_use_camel_case/bad/PaymentGateway.php
new file mode 100644
index 0000000..2d2ab41
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/methods_use_camel_case/bad/PaymentGateway.php
@@ -0,0 +1,67 @@
+<?php
+
+namespace App\Payment;
+
+class PaymentGateway
+{
+    private string $apiKey;
+    private string $baseUrl;
+    private int $request_count = 0;
+
+    public function __construct(string $apiKey, string $baseUrl)
+    {
+        $this->apiKey = $apiKey;
+        $this->baseUrl = $baseUrl;
+    }
+
+    // Violates PSR-1: method uses snake_case instead of camelCase
+    public function charge_card($amountCents, $token)
+    {
+        $this->request_count++;
+        $response = $this->send_request('POST', '/v1/charges', [
+            'amount' => $amountCents,
+            'source' => $token,
+        ]);
+
+        return ['transaction_id' => $response['id']];
+    }
+
+    // Violates PSR-1: snake_case method name
+    public function issue_refund($transactionId, $amountCents)
+    {
+        $response = $this->send_request('POST', '/v1/refunds', [
+            'transaction_id' => $transactionId,
+            'amount'         => $amountCents,
+        ]);
+
+        return ['refund_id' => $response['refund_id']];
+    }
+
+    // Violates PSR-1: snake_case method name
+    public function get_transaction_status($transactionId)
+    {
+        $response = $this->send_request('GET', "/v1/charges/{$transactionId}");
+
+        return $response['status'];
+    }
+
+    // Violates PSR-1: snake_case method name
+    public function validate_webhook_signature($payload, $signature)
+    {
+        $expected = hash_hmac('sha256', $payload, $this->apiKey);
+
+        return hash_equals($expected, $signature);
+    }
+
+    // Violates PSR-1: snake_case method name
+    public function get_request_count()
+    {
+        return $this->request_count;
+    }
+
+    // Violates PSR-1: snake_case private method name
+    private function send_request($method, $path, $body = [])
+    {
+        return [];
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/methods_use_camel_case/good/PaymentGateway.php b/priv/combined_metrics/samples/naming_conventions/methods_use_camel_case/good/PaymentGateway.php
new file mode 100644
index 0000000..7a7c8a0
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/methods_use_camel_case/good/PaymentGateway.php
@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Payment;
+
+// Method names use camelCase — PSR-1
+class PaymentGateway
+{
+    private string $apiKey;
+    private string $baseUrl;
+    private int $requestCount = 0;
+
+    public function __construct(string $apiKey, string $baseUrl)
+    {
+        $this->apiKey = $apiKey;
+        $this->baseUrl = $baseUrl;
+    }
+
+    public function chargeCard(int $amountCents, string $token): ChargeResult
+    {
+        $this->requestCount++;
+        $response = $this->sendRequest('POST', '/v1/charges', [
+            'amount' => $amountCents,
+            'source' => $token,
+        ]);
+
+        return new ChargeResult(transactionId: $response['id']);
+    }
+
+    public function issueRefund(string $transactionId, int $amountCents): RefundResult
+    {
+        $response = $this->sendRequest('POST', '/v1/refunds', [
+            'transaction_id' => $transactionId,
+            'amount'         => $amountCents,
+        ]);
+
+        return new RefundResult(refundId: $response['refund_id']);
+    }
+
+    public function getTransactionStatus(string $transactionId): string
+    {
+        $response = $this->sendRequest('GET', "/v1/charges/{$transactionId}");
+
+        return $response['status'];
+    }
+
+    public function validateWebhookSignature(string $payload, string $signature): bool
+    {
+        $expected = hash_hmac('sha256', $payload, $this->apiKey);
+
+        return hash_equals($expected, $signature);
+    }
+
+    public function getRequestCount(): int
+    {
+        return $this->requestCount;
+    }
+
+    private function sendRequest(string $method, string $path, array $body = []): array
+    {
+        // HTTP client logic
+        return [];
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/mutating_method_uses_imperative_verb/bad/ShoppingCart.swift b/priv/combined_metrics/samples/naming_conventions/mutating_method_uses_imperative_verb/bad/ShoppingCart.swift
new file mode 100644
index 0000000..dec884f
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/mutating_method_uses_imperative_verb/bad/ShoppingCart.swift
@@ -0,0 +1,51 @@
+import Foundation
+
+struct CartItem {
+    let productID: String
+    let name: String
+    var quantity: Int
+    var unitPrice: Decimal
+}
+
+struct ShoppingCart {
+    private(set) var items: [CartItem] = []
+    private(set) var appliedCouponCode: String?
+
+    // Should be addItem — "adding" is gerund, not imperative
+    mutating func adding(_ item: CartItem) {
+        if let index = items.firstIndex(where: { $0.productID == item.productID }) {
+            items[index].quantity += item.quantity
+        } else {
+            items.append(item)
+        }
+    }
+
+    // Should be removeItem — "deletion" is a noun, not an imperative
+    mutating func deletion(productID: String) {
+        items.removeAll { $0.productID == productID }
+    }
+
+    // Should be applyCoupon — "couponApplication" is a noun phrase
+    mutating func couponApplication(_ code: String) {
+        appliedCouponCode = code
+    }
+
+    // Should be clear — "clearing" is gerund, not imperative
+    mutating func clearing() {
+        items.removeAll()
+        appliedCouponCode = nil
+    }
+
+    var subtotal: Decimal {
+        items.reduce(.zero) { $0 + $1.unitPrice * Decimal($1.quantity) }
+    }
+
+    // Should be sorted(by:) — "sort" implies mutation; non-mutating should use past tense
+    func sort(by keyPath: KeyPath<CartItem, String>) -> [CartItem] {
+        return items.sorted { $0[keyPath: keyPath] < $1[keyPath: keyPath] }
+    }
+
+    func item(for productID: String) -> CartItem? {
+        return items.first { $0.productID == productID }
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/mutating_method_uses_imperative_verb/good/ShoppingCart.swift b/priv/combined_metrics/samples/naming_conventions/mutating_method_uses_imperative_verb/good/ShoppingCart.swift
new file mode 100644
index 0000000..2047ad3
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/mutating_method_uses_imperative_verb/good/ShoppingCart.swift
@@ -0,0 +1,53 @@
+import Foundation
+
+struct CartItem {
+    let productID: String
+    let name: String
+    var quantity: Int
+    var unitPrice: Decimal
+}
+
+struct ShoppingCart {
+    private(set) var items: [CartItem] = []
+    private(set) var appliedCouponCode: String?
+
+    // Mutating method: imperative verb
+    mutating func addItem(_ item: CartItem) {
+        if let index = items.firstIndex(where: { $0.productID == item.productID }) {
+            items[index].quantity += item.quantity
+        } else {
+            items.append(item)
+        }
+    }
+
+    // Mutating method: imperative verb
+    mutating func removeItem(productID: String) {
+        items.removeAll { $0.productID == productID }
+    }
+
+    // Mutating method: imperative verb
+    mutating func applyCoupon(_ code: String) {
+        appliedCouponCode = code
+    }
+
+    // Mutating method: imperative verb
+    mutating func clear() {
+        items.removeAll()
+        appliedCouponCode = nil
+    }
+
+    // Non-mutating: noun describing the result
+    var subtotal: Decimal {
+        items.reduce(.zero) { $0 + $1.unitPrice * Decimal($1.quantity) }
+    }
+
+    // Non-mutating: past tense — returns a new value without side effects
+    func sorted(by keyPath: KeyPath<CartItem, String>) -> [CartItem] {
+        return items.sorted { $0[keyPath: keyPath] < $1[keyPath: keyPath] }
+    }
+
+    // Non-mutating: noun
+    func item(for productID: String) -> CartItem? {
+        return items.first { $0.productID == productID }
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/name_reflects_role_not_type/bad/OrderManager.swift b/priv/combined_metrics/samples/naming_conventions/name_reflects_role_not_type/bad/OrderManager.swift
new file mode 100644
index 0000000..a28dc2c
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/name_reflects_role_not_type/bad/OrderManager.swift
@@ -0,0 +1,69 @@
+import Foundation
+
+struct Order {
+    let id: String
+    var items: [OrderItem]
+    var status: OrderStatus
+    let placedAt: Date
+    var customerID: String
+}
+
+struct OrderItem {
+    let productID: String
+    var quantity: Int
+    var unitPrice: Decimal
+}
+
+enum OrderStatus {
+    case pending, confirmed, shipped, delivered, cancelled
+}
+
+class OrderManager {
+    // Name repeats type ("Dictionary") instead of describing its role
+    private var orderDictionary: [String: Order] = [:]
+
+    func place(_ order: Order) {
+        // Name repeats type ("Order") instead of describing role ("confirmed")
+        var orderObject = order
+        orderObject.status = .confirmed
+        orderDictionary[orderObject.id] = orderObject
+    }
+
+    func cancel(orderID: String, reason: String) -> Bool {
+        // "boolResult" repeats the type, not the meaning
+        var boolResult = false
+        if var existing = orderDictionary[orderID], existing.status == .pending {
+            existing.status = .cancelled
+            orderDictionary[orderID] = existing
+            boolResult = true
+        }
+        return boolResult
+    }
+
+    func pendingOrders(for customerID: String) -> [Order] {
+        // "arrayResult" tells us nothing about what's in the array
+        let arrayResult = orderDictionary.values.filter {
+            $0.customerID == customerID && $0.status == .pending
+        }
+        return arrayResult
+    }
+
+    func totalRevenue(in dateRange: ClosedRange<Date>) -> Decimal {
+        // "decimalValue" describes the type, not what the decimal represents
+        let decimalValue = orderDictionary.values
+            .filter { dateRange.contains($0.placedAt) && $0.status != .cancelled }
+            .reduce(Decimal.zero) { acc, order in
+                acc + order.items.reduce(Decimal.zero) { a, item in
+                    a + item.unitPrice * Decimal(item.quantity)
+                }
+            }
+        return decimalValue
+    }
+
+    func greeting(for customerID: String) -> String {
+        let intCount = pendingOrders(for: customerID).count
+        // "string" tells us the type but not what message this is
+        let string = intCount > 0 ? "You have \(intCount) pending order(s)." : "No pending orders."
+        return string
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/name_reflects_role_not_type/good/OrderManager.swift b/priv/combined_metrics/samples/naming_conventions/name_reflects_role_not_type/good/OrderManager.swift
new file mode 100644
index 0000000..61e4874
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/name_reflects_role_not_type/good/OrderManager.swift
@@ -0,0 +1,59 @@
+import Foundation
+
+struct Order {
+    let id: String
+    var items: [OrderItem]
+    var status: OrderStatus
+    let placedAt: Date
+    var customerID: String
+}
+
+struct OrderItem {
+    let productID: String
+    var quantity: Int
+    var unitPrice: Decimal
+}
+
+enum OrderStatus {
+    case pending, confirmed, shipped, delivered, cancelled
+}
+
+class OrderManager {
+    private var orders: [String: Order] = [:]
+
+    func place(_ order: Order) {
+        var confirmed = order
+        confirmed.status = .confirmed
+        orders[confirmed.id] = confirmed
+    }
+
+    func cancel(orderID: String, reason: String) -> Bool {
+        guard var existing = orders[orderID], existing.status == .pending else {
+            return false
+        }
+        existing.status = .cancelled
+        orders[orderID] = existing
+        return true
+    }
+
+    func pendingOrders(for customerID: String) -> [Order] {
+        return orders.values.filter {
+            $0.customerID == customerID && $0.status == .pending
+        }
+    }
+
+    func totalRevenue(in dateRange: ClosedRange<Date>) -> Decimal {
+        return orders.values
+            .filter { dateRange.contains($0.placedAt) && $0.status != .cancelled }
+            .reduce(Decimal.zero) { subtotal, order in
+                subtotal + order.items.reduce(Decimal.zero) { lineTotal, item in
+                    lineTotal + item.unitPrice * Decimal(item.quantity)
+                }
+            }
+    }
+
+    func greeting(for customerID: String) -> String {
+        let count = pendingOrders(for: customerID).count
+        return count > 0 ? "You have \(count) pending order(s)." : "No pending orders."
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/name_reflects_semantics_not_type/bad/SubscriptionManager.cs b/priv/combined_metrics/samples/naming_conventions/name_reflects_semantics_not_type/bad/SubscriptionManager.cs
new file mode 100644
index 0000000..4c22933
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/name_reflects_semantics_not_type/bad/SubscriptionManager.cs
@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+
+namespace Billing
+{
+    public class SubscriptionManager
+    {
+        private readonly ISubscriptionRepository _subscriptionRepository;
+
+        public SubscriptionManager(ISubscriptionRepository subscriptionRepository)
+        {
+            _subscriptionRepository = subscriptionRepository;
+        }
+
+        public Subscription CreateTrialSubscription(int customerId, Plan plan)
+        {
+            // Names describe type, not meaning: "dateTimeOffset" instead of "trialEndDate"
+            var dateTimeOffset = DateTimeOffset.UtcNow.AddDays(plan.TrialDurationDays);
+            var subscriptionObject = new Subscription  // "Object" suffix adds no meaning
+            {
+                CustomerId = customerId,
+                Plan = plan,
+                ExpiresAt = dateTimeOffset,
+                IsTrial = true
+            };
+            _subscriptionRepository.Add(subscriptionObject);
+            return subscriptionObject;
+        }
+
+        public void UpgradePlan(int subscriptionId, Plan plan)
+        {
+            // "subscriptionData" describes the type, not the role
+            var subscriptionData = _subscriptionRepository.GetById(subscriptionId)
+                ?? throw new SubscriptionNotFoundException(subscriptionId);
+
+            subscriptionData.Plan = plan;
+            subscriptionData.UpgradedAt = DateTimeOffset.UtcNow;
+            _subscriptionRepository.Update(subscriptionData);
+        }
+
+        public IReadOnlyList<Subscription> GetExpiringSoon(int days)
+        {
+            // "dateValue" describes the type — should be "cutoffDate"
+            var dateValue = DateTimeOffset.UtcNow.AddDays(days);
+            return _subscriptionRepository.FindExpiringBefore(dateValue);
+        }
+
+        public bool HasActivePaidSubscription(int customerId)
+        {
+            // "subscriptionRecord" — type-based name for what is just "subscription"
+            var subscriptionRecord = _subscriptionRepository.FindByCustomer(customerId);
+            // "boolResult" — type name instead of "hasActive" or just returning inline
+            bool boolResult = subscriptionRecord != null
+                && !subscriptionRecord.IsTrial
+                && subscriptionRecord.ExpiresAt > DateTimeOffset.UtcNow;
+            return boolResult;
+        }
+
+        public void CancelSubscription(int subscriptionId, string stringReason) // type name as param
+        {
+            var subscriptionInstance = _subscriptionRepository.GetById(subscriptionId)
+                ?? throw new SubscriptionNotFoundException(subscriptionId);
+
+            // "dateTimeValue" instead of "cancelledAt"
+            var dateTimeValue = DateTimeOffset.UtcNow;
+            subscriptionInstance.CancelledAt = dateTimeValue;
+            subscriptionInstance.CancellationReason = stringReason;
+            _subscriptionRepository.Update(subscriptionInstance);
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/name_reflects_semantics_not_type/good/SubscriptionManager.cs b/priv/combined_metrics/samples/naming_conventions/name_reflects_semantics_not_type/good/SubscriptionManager.cs
new file mode 100644
index 0000000..a1d5002
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/name_reflects_semantics_not_type/good/SubscriptionManager.cs
@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+
+namespace Billing
+{
+    public class SubscriptionManager
+    {
+        private readonly ISubscriptionRepository _subscriptionRepository;
+
+        public SubscriptionManager(ISubscriptionRepository subscriptionRepository)
+        {
+            _subscriptionRepository = subscriptionRepository;
+        }
+
+        public Subscription CreateTrialSubscription(int customerId, Plan plan)
+        {
+            var trialEndDate = DateTimeOffset.UtcNow.AddDays(plan.TrialDurationDays);
+            var subscription = new Subscription
+            {
+                CustomerId = customerId,
+                Plan = plan,
+                ExpiresAt = trialEndDate,
+                IsTrial = true
+            };
+            _subscriptionRepository.Add(subscription);
+            return subscription;
+        }
+
+        public void UpgradePlan(int subscriptionId, Plan newPlan)
+        {
+            var subscription = _subscriptionRepository.GetById(subscriptionId)
+                ?? throw new SubscriptionNotFoundException(subscriptionId);
+
+            subscription.Plan = newPlan;
+            subscription.UpgradedAt = DateTimeOffset.UtcNow;
+            _subscriptionRepository.Update(subscription);
+        }
+
+        public IReadOnlyList<Subscription> GetExpiringSoon(int daysUntilExpiration)
+        {
+            var cutoffDate = DateTimeOffset.UtcNow.AddDays(daysUntilExpiration);
+            return _subscriptionRepository.FindExpiringBefore(cutoffDate);
+        }
+
+        public bool HasActivePaidSubscription(int customerId)
+        {
+            var subscription = _subscriptionRepository.FindByCustomer(customerId);
+            return subscription != null
+                && !subscription.IsTrial
+                && subscription.ExpiresAt > DateTimeOffset.UtcNow;
+        }
+
+        public void CancelSubscription(int subscriptionId, string cancellationReason)
+        {
+            var subscription = _subscriptionRepository.GetById(subscriptionId)
+                ?? throw new SubscriptionNotFoundException(subscriptionId);
+
+            subscription.CancelledAt = DateTimeOffset.UtcNow;
+            subscription.CancellationReason = cancellationReason;
+            _subscriptionRepository.Update(subscription);
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/no_abbreviations_in_identifiers/bad/ShipmentTracker.cs b/priv/combined_metrics/samples/naming_conventions/no_abbreviations_in_identifiers/bad/ShipmentTracker.cs
new file mode 100644
index 0000000..39ba48e
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/no_abbreviations_in_identifiers/bad/ShipmentTracker.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+
+namespace Shipping
+{
+    public class ShipmentTracker
+    {
+        private readonly IShipmentRepository _repo;     // abbreviated
+        private readonly INotificationService _notifSvc; // abbreviated
+
+        public ShipmentTracker(IShipmentRepository repo, INotificationService notifSvc)
+        {
+            _repo = repo;
+            _notifSvc = notifSvc;
+        }
+
+        public ShipmentStatus GetCurrStatus(string trkNum) // abbreviated
+        {
+            var shpmnt = _repo.FindByTrackingNumber(trkNum) // abbreviated
+                ?? throw new ShipmentNotFoundException(trkNum);
+
+            return shpmnt.CurrentStatus;
+        }
+
+        public void RecordDlvAttempt(string trkNum, DeliveryAttemptDetails dtls) // abbreviated
+        {
+            var shpmnt = _repo.FindByTrackingNumber(trkNum)
+                ?? throw new ShipmentNotFoundException(trkNum);
+
+            shpmnt.DeliveryAttempts.Add(dtls);
+            _repo.Update(shpmnt);
+
+            if (dtls.WasSuccessful)
+            {
+                shpmnt.MarkDelivered(dtls.DeliveredAt);
+                _notifSvc.SendDeliveryConfirmation(shpmnt.RecipientEmail, trkNum);
+            }
+            else
+            {
+                _notifSvc.SendFailedAttemptNotification(
+                    shpmnt.RecipientEmail, trkNum, dtls.FailureReason);
+            }
+        }
+
+        public IReadOnlyList<Shipment> GetShipmentsWithEstDlvBefore(DateTimeOffset dl) // abbreviated
+        {
+            return _repo.FindByEstimatedDeliveryBefore(dl);
+        }
+
+        public ShipmentSummary GenSummForDtRng(DateTimeOffset stDt, DateTimeOffset endDt) // abbreviated
+        {
+            var shpmnts = _repo.FindByDispatchedBetween(stDt, endDt);
+            int dlvdCnt = 0;   // abbreviated
+            int pendCnt = 0;   // abbreviated
+
+            foreach (var s in shpmnts)
+            {
+                if (s.CurrentStatus == ShipmentStatus.Delivered) dlvdCnt++;
+                else pendCnt++;
+            }
+
+            return new ShipmentSummary(dlvdCnt, pendCnt, stDt, endDt);
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/no_abbreviations_in_identifiers/good/ShipmentTracker.cs b/priv/combined_metrics/samples/naming_conventions/no_abbreviations_in_identifiers/good/ShipmentTracker.cs
new file mode 100644
index 0000000..07760f0
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/no_abbreviations_in_identifiers/good/ShipmentTracker.cs
@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+
+namespace Shipping
+{
+    public class ShipmentTracker
+    {
+        private readonly IShipmentRepository _shipmentRepository;
+        private readonly INotificationService _notificationService;
+
+        public ShipmentTracker(
+            IShipmentRepository shipmentRepository,
+            INotificationService notificationService)
+        {
+            _shipmentRepository = shipmentRepository;
+            _notificationService = notificationService;
+        }
+
+        public ShipmentStatus GetCurrentStatus(string trackingNumber)
+        {
+            var shipment = _shipmentRepository.FindByTrackingNumber(trackingNumber)
+                ?? throw new ShipmentNotFoundException(trackingNumber);
+
+            return shipment.CurrentStatus;
+        }
+
+        public void RecordDeliveryAttempt(string trackingNumber, DeliveryAttemptDetails attemptDetails)
+        {
+            var shipment = _shipmentRepository.FindByTrackingNumber(trackingNumber)
+                ?? throw new ShipmentNotFoundException(trackingNumber);
+
+            shipment.DeliveryAttempts.Add(attemptDetails);
+            _shipmentRepository.Update(shipment);
+
+            if (attemptDetails.WasSuccessful)
+            {
+                shipment.MarkDelivered(attemptDetails.DeliveredAt);
+                _notificationService.SendDeliveryConfirmation(shipment.RecipientEmail, trackingNumber);
+            }
+            else
+            {
+                _notificationService.SendFailedAttemptNotification(
+                    shipment.RecipientEmail, trackingNumber, attemptDetails.FailureReason);
+            }
+        }
+
+        public IReadOnlyList<Shipment> GetShipmentsWithEstimatedDeliveryBefore(DateTimeOffset deadline)
+        {
+            return _shipmentRepository.FindByEstimatedDeliveryBefore(deadline);
+        }
+
+        public ShipmentSummary GenerateSummaryForDateRange(DateTimeOffset startDate, DateTimeOffset endDate)
+        {
+            var shipments = _shipmentRepository.FindByDispatchedBetween(startDate, endDate);
+            int deliveredCount = 0;
+            int pendingCount = 0;
+
+            foreach (var shipment in shipments)
+            {
+                if (shipment.CurrentStatus == ShipmentStatus.Delivered) deliveredCount++;
+                else pendingCount++;
+            }
+
+            return new ShipmentSummary(deliveredCount, pendingCount, startDate, endDate);
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/no_hungarian_notation/bad/InventoryService.cs b/priv/combined_metrics/samples/naming_conventions/no_hungarian_notation/bad/InventoryService.cs
new file mode 100644
index 0000000..f2137ff
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/no_hungarian_notation/bad/InventoryService.cs
@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+
+namespace Inventory
+{
+    public class InventoryService
+    {
+        private readonly IProductRepository _objProductRepository;
+        private readonly ILogger _objLogger;
+
+        public InventoryService(IProductRepository objProductRepository, ILogger objLogger)
+        {
+            _objProductRepository = objProductRepository;
+            _objLogger = objLogger;
+        }
+
+        public StockLevel GetStockLevel(string strProductCode)
+        {
+            var objProduct = _objProductRepository.FindByCode(strProductCode);
+            if (objProduct == null)
+                throw new ProductNotFoundException(strProductCode);
+
+            return new StockLevel(objProduct.Id, objProduct.QuantityOnHand, objProduct.ReorderThreshold);
+        }
+
+        public IReadOnlyList<Product> FindLowStockProducts(int iThreshold)
+        {
+            var lstAllProducts = _objProductRepository.GetAll();
+            var lstResults = new List<Product>();
+
+            foreach (var objProduct in lstAllProducts)
+            {
+                if (objProduct.QuantityOnHand < iThreshold)
+                    lstResults.Add(objProduct);
+            }
+
+            _objLogger.Info($"Found {lstResults.Count} low-stock products below threshold {iThreshold}");
+            return lstResults.AsReadOnly();
+        }
+
+        public void AdjustStock(string strProductCode, int iDelta, string strReason)
+        {
+            if (string.IsNullOrWhiteSpace(strReason))
+                throw new ArgumentException("Adjustment reason is required.", nameof(strReason));
+
+            var objProduct = _objProductRepository.FindByCode(strProductCode)
+                ?? throw new ProductNotFoundException(strProductCode);
+
+            int iUpdatedQuantity = objProduct.QuantityOnHand + iDelta;
+            if (iUpdatedQuantity < 0)
+                throw new InsufficientStockException(strProductCode, objProduct.QuantityOnHand, iDelta);
+
+            _objProductRepository.UpdateQuantity(objProduct.Id, iUpdatedQuantity);
+            _objLogger.Info($"Adjusted {strProductCode} by {iDelta}: {strReason}");
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/no_hungarian_notation/good/InventoryService.cs b/priv/combined_metrics/samples/naming_conventions/no_hungarian_notation/good/InventoryService.cs
new file mode 100644
index 0000000..a2acc45
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/no_hungarian_notation/good/InventoryService.cs
@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+
+namespace Inventory
+{
+    public class InventoryService
+    {
+        private readonly IProductRepository _productRepository;
+        private readonly ILogger _logger;
+
+        public InventoryService(IProductRepository productRepository, ILogger logger)
+        {
+            _productRepository = productRepository;
+            _logger = logger;
+        }
+
+        public StockLevel GetStockLevel(string productCode)
+        {
+            var product = _productRepository.FindByCode(productCode);
+            if (product == null)
+                throw new ProductNotFoundException(productCode);
+
+            return new StockLevel(product.Id, product.QuantityOnHand, product.ReorderThreshold);
+        }
+
+        public IReadOnlyList<Product> FindLowStockProducts(int threshold)
+        {
+            var allProducts = _productRepository.GetAll();
+            var results = new List<Product>();
+
+            foreach (var product in allProducts)
+            {
+                if (product.QuantityOnHand < threshold)
+                    results.Add(product);
+            }
+
+            _logger.Info($"Found {results.Count} low-stock products below threshold {threshold}");
+            return results.AsReadOnly();
+        }
+
+        public void AdjustStock(string productCode, int delta, string reason)
+        {
+            if (string.IsNullOrWhiteSpace(reason))
+                throw new ArgumentException("Adjustment reason is required.", nameof(reason));
+
+            var product = _productRepository.FindByCode(productCode)
+                ?? throw new ProductNotFoundException(productCode);
+
+            int updatedQuantity = product.QuantityOnHand + delta;
+            if (updatedQuantity < 0)
+                throw new InsufficientStockException(productCode, product.QuantityOnHand, delta);
+
+            _productRepository.UpdateQuantity(product.Id, updatedQuantity);
+            _logger.Info($"Adjusted {productCode} by {delta}: {reason}");
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/no_member_name_prefixes_suffixes/bad/CustomerAccount.java b/priv/combined_metrics/samples/naming_conventions/no_member_name_prefixes_suffixes/bad/CustomerAccount.java
new file mode 100644
index 0000000..a888c01
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/no_member_name_prefixes_suffixes/bad/CustomerAccount.java
@@ -0,0 +1,62 @@
+package com.example.accounts;
+
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+
+public class CustomerAccount {
+
+    // Hungarian notation / member prefix 'm' on instance fields
+    private final String mId;
+    private String mEmail;
+    private String mDisplayName;
+    private BigDecimal mBalance;
+    private AccountStatus mStatus;
+    private final Instant mCreatedAt;
+    private final List<Transaction> mTransactions;
+
+    // Static fields with 's' prefix
+    private static final BigDecimal sOverdraftLimit = new BigDecimal("-100.00");
+    private static final int sMaxDailyTransactions = 50;
+
+    // Constants with 'k' prefix (Android style)
+    private static final int kDefaultTimeout = 30;
+
+    public CustomerAccount(String id_, String email_, String displayName_) {
+        // Parameter suffixes with underscore
+        this.mId = id_;
+        this.mEmail = email_;
+        this.mDisplayName = displayName_;
+        this.mBalance = BigDecimal.ZERO;
+        this.mStatus = AccountStatus.ACTIVE;
+        this.mCreatedAt = Instant.now();
+        this.mTransactions = new ArrayList<>();
+    }
+
+    public void deposit(BigDecimal amount_) {
+        if (amount_.compareTo(BigDecimal.ZERO) <= 0) {
+            throw new IllegalArgumentException("Deposit amount must be positive");
+        }
+        mBalance = mBalance.add(amount_);
+        mTransactions.add(Transaction.deposit(amount_));
+    }
+
+    public void withdraw(BigDecimal amount_) {
+        if (amount_.compareTo(BigDecimal.ZERO) <= 0) {
+            throw new IllegalArgumentException("Withdrawal amount must be positive");
+        }
+        BigDecimal newBalance_ = mBalance.subtract(amount_);
+        if (newBalance_.compareTo(sOverdraftLimit) < 0) {
+            throw new InsufficientFundsException(mBalance, amount_);
+        }
+        mBalance = newBalance_;
+        mTransactions.add(Transaction.withdrawal(amount_));
+    }
+
+    public String getId() { return mId; }
+    public String getEmail() { return mEmail; }
+    public String getDisplayName() { return mDisplayName; }
+    public BigDecimal getBalance() { return mBalance; }
+    public AccountStatus getStatus() { return mStatus; }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/no_member_name_prefixes_suffixes/good/CustomerAccount.java b/priv/combined_metrics/samples/naming_conventions/no_member_name_prefixes_suffixes/good/CustomerAccount.java
new file mode 100644
index 0000000..38b9426
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/no_member_name_prefixes_suffixes/good/CustomerAccount.java
@@ -0,0 +1,58 @@
+package com.example.accounts;
+
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+
+public class CustomerAccount {
+
+    private final String id;
+    private String email;
+    private String displayName;
+    private BigDecimal balance;
+    private AccountStatus status;
+    private final Instant createdAt;
+    private final List<Transaction> transactions;
+
+    private static final BigDecimal OVERDRAFT_LIMIT = new BigDecimal("-100.00");
+    private static final int MAX_DAILY_TRANSACTIONS = 50;
+
+    public CustomerAccount(String id, String email, String displayName) {
+        this.id = id;
+        this.email = email;
+        this.displayName = displayName;
+        this.balance = BigDecimal.ZERO;
+        this.status = AccountStatus.ACTIVE;
+        this.createdAt = Instant.now();
+        this.transactions = new ArrayList<>();
+    }
+
+    public void deposit(BigDecimal amount) {
+        if (amount.compareTo(BigDecimal.ZERO) <= 0) {
+            throw new IllegalArgumentException("Deposit amount must be positive");
+        }
+        balance = balance.add(amount);
+        transactions.add(Transaction.deposit(amount));
+    }
+
+    public void withdraw(BigDecimal amount) {
+        if (amount.compareTo(BigDecimal.ZERO) <= 0) {
+            throw new IllegalArgumentException("Withdrawal amount must be positive");
+        }
+        BigDecimal newBalance = balance.subtract(amount);
+        if (newBalance.compareTo(OVERDRAFT_LIMIT) < 0) {
+            throw new InsufficientFundsException(balance, amount);
+        }
+        balance = newBalance;
+        transactions.add(Transaction.withdrawal(amount));
+    }
+
+    public String getId() { return id; }
+    public String getEmail() { return email; }
+    public String getDisplayName() { return displayName; }
+    public BigDecimal getBalance() { return balance; }
+    public AccountStatus getStatus() { return status; }
+    public Instant getCreatedAt() { return createdAt; }
+    public List<Transaction> getTransactions() { return List.copyOf(transactions); }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/no_predicate_method_with_is_prefix/bad/account.rb b/priv/combined_metrics/samples/naming_conventions/no_predicate_method_with_is_prefix/bad/account.rb
new file mode 100644
index 0000000..fa6ef51
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/no_predicate_method_with_is_prefix/bad/account.rb
@@ -0,0 +1,49 @@
+class Account
+  TRIAL_DAYS = 14
+
+  attr_reader :role, :status, :verified_at, :suspended_at, :created_at, :plan
+
+  def initialize(attrs = {})
+    @role = attrs[:role]
+    @status = attrs[:status] || :pending
+    @verified_at = attrs[:verified_at]
+    @suspended_at = attrs[:suspended_at]
+    @created_at = attrs[:created_at] || Time.current
+    @plan = attrs[:plan] || :free
+  end
+
+  # Forbidden `is_` prefix on predicate methods
+  def is_admin?
+    role == :admin
+  end
+
+  def is_verified?
+    verified_at.present?
+  end
+
+  def is_suspended?
+    suspended_at.present?
+  end
+
+  def is_active?
+    status == :active && !is_suspended?
+  end
+
+  def is_on_trial?
+    created_at > TRIAL_DAYS.days.ago && plan == :free
+  end
+
+  # `can_` prefix also violates the convention
+  def can_access_premium?
+    is_active? && !is_on_trial?
+  end
+
+  # `does_` prefix also violates the convention
+  def does_need_verification?
+    !is_verified? && is_active?
+  end
+
+  def eligible_for_upgrade?
+    !can_access_premium? && is_verified? && !is_suspended?
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/no_predicate_method_with_is_prefix/good/account.rb b/priv/combined_metrics/samples/naming_conventions/no_predicate_method_with_is_prefix/good/account.rb
new file mode 100644
index 0000000..394c47b
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/no_predicate_method_with_is_prefix/good/account.rb
@@ -0,0 +1,55 @@
+class Account
+  TRIAL_DAYS = 14
+
+  attr_reader :role, :status, :verified_at, :suspended_at, :created_at, :plan
+
+  def initialize(attrs = {})
+    @role = attrs[:role]
+    @status = attrs[:status] || :pending
+    @verified_at = attrs[:verified_at]
+    @suspended_at = attrs[:suspended_at]
+    @created_at = attrs[:created_at] || Time.current
+    @plan = attrs[:plan] || :free
+  end
+
+  def admin?
+    role == :admin
+  end
+
+  def verified?
+    verified_at.present?
+  end
+
+  def suspended?
+    suspended_at.present?
+  end
+
+  def active?
+    status == :active && !suspended?
+  end
+
+  def on_trial?
+    created_at > TRIAL_DAYS.days.ago && plan == :free
+  end
+
+  def paid?
+    plan != :free
+  end
+
+  def eligible_for_upgrade?
+    !paid? && verified? && !suspended?
+  end
+
+  def can_access_feature?(feature)
+    return false unless active?
+    return true if admin?
+
+    plan_features.include?(feature)
+  end
+
+  private
+
+  def plan_features
+    PLAN_FEATURES.fetch(plan, [])
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/no_single_char_variable_ambiguous/bad/matrix_transform.py b/priv/combined_metrics/samples/naming_conventions/no_single_char_variable_ambiguous/bad/matrix_transform.py
new file mode 100644
index 0000000..0b433f0
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/no_single_char_variable_ambiguous/bad/matrix_transform.py
@@ -0,0 +1,55 @@
+"""Matrix transformation utilities for 2D data processing."""
+from __future__ import annotations
+
+Matrix = list[list[float]]
+
+
+def zeros(r: int, c: int) -> Matrix:   # r and c are fine, but see below
+    return [[0.0] * c for _ in range(r)]
+
+
+def identity(n: int) -> Matrix:
+    m = zeros(n, n)     # m looks like matrix, but is also easily mistaken for a number
+    for I in range(n):  # I is visually identical to 1 (one) in many fonts — banned
+        m[I][I] = 1.0
+    return m
+
+
+def transpose(matrix: Matrix) -> Matrix:
+    if not matrix:
+        return []
+    r = len(matrix)
+    c = len(matrix[0])
+    result = zeros(c, r)
+    for I in range(r):      # I looks like 1
+        for l in range(c):  # l looks like 1 in many fonts — banned
+            result[l][I] = matrix[I][l]
+    return result
+
+
+def multiply(a: Matrix, b: Matrix) -> Matrix:
+    r = len(a)
+    c1 = len(a[0])
+    c2 = len(b[0])
+    O = zeros(r, c2)        # O looks exactly like 0 (zero) — banned
+    for I in range(r):      # I looks like 1 — banned
+        for l in range(c2): # l looks like 1 — banned
+            t = 0.0
+            for k in range(c1):
+                t += a[I][k] * b[k][l]
+            O[I][l] = t     # O, I, l all in use simultaneously — impossible to read
+    return O
+
+
+def scale(matrix: Matrix, f: float) -> Matrix:
+    return [[v * f for v in r] for r in matrix]
+
+
+def trace(m: Matrix) -> float:
+    """Sum the diagonal; uses l as loop variable — looks like 1."""
+    l = min(len(m), len(m[0]))   # l shadows the banned-name pattern
+    return sum(m[I][I] for I in range(l))  # I banned, l banned
+
+
+def flatten(m: Matrix) -> list[float]:
+    return [v for l in m for v in l]  # l again
diff --git a/priv/combined_metrics/samples/naming_conventions/no_single_char_variable_ambiguous/good/matrix_transform.py b/priv/combined_metrics/samples/naming_conventions/no_single_char_variable_ambiguous/good/matrix_transform.py
new file mode 100644
index 0000000..d0cac63
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/no_single_char_variable_ambiguous/good/matrix_transform.py
@@ -0,0 +1,62 @@
+"""Matrix transformation utilities for 2D data processing."""
+from __future__ import annotations
+
+from typing import Sequence
+
+Matrix = list[list[float]]
+
+
+def zeros(rows: int, cols: int) -> Matrix:
+    """Return a rows×cols matrix filled with zeros."""
+    return [[0.0] * cols for _ in range(rows)]
+
+
+def identity(size: int) -> Matrix:
+    """Return a size×size identity matrix."""
+    mat = zeros(size, size)
+    for idx in range(size):
+        mat[idx][idx] = 1.0
+    return mat
+
+
+def transpose(matrix: Matrix) -> Matrix:
+    """Return the transpose of the given matrix."""
+    if not matrix:
+        return []
+    row_count = len(matrix)
+    col_count = len(matrix[0])
+    result = zeros(col_count, row_count)
+    for row_idx in range(row_count):
+        for col_idx in range(col_count):
+            result[col_idx][row_idx] = matrix[row_idx][col_idx]
+    return result
+
+
+def multiply(mat_a: Matrix, mat_b: Matrix) -> Matrix:
+    """Return the matrix product of mat_a and mat_b."""
+    rows_a = len(mat_a)
+    cols_a = len(mat_a[0])
+    cols_b = len(mat_b[0])
+    result = zeros(rows_a, cols_b)
+    for row_idx in range(rows_a):
+        for col_idx in range(cols_b):
+            total = 0.0
+            for inner in range(cols_a):
+                total += mat_a[row_idx][inner] * mat_b[inner][col_idx]
+            result[row_idx][col_idx] = total
+    return result
+
+
+def scale(matrix: Matrix, factor: float) -> Matrix:
+    """Return the matrix scaled by factor."""
+    return [[cell * factor for cell in row] for row in matrix]
+
+
+def trace(matrix: Matrix) -> float:
+    """Return the sum of the diagonal elements."""
+    return sum(matrix[idx][idx] for idx in range(min(len(matrix), len(matrix[0]))))
+
+
+def flatten(matrix: Matrix) -> list[float]:
+    """Return all elements as a flat list in row-major order."""
+    return [cell for row in matrix for cell in row]
diff --git a/priv/combined_metrics/samples/naming_conventions/no_underscore_visibility_prefix/bad/UserRepository.php b/priv/combined_metrics/samples/naming_conventions/no_underscore_visibility_prefix/bad/UserRepository.php
new file mode 100644
index 0000000..81c0acc
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/no_underscore_visibility_prefix/bad/UserRepository.php
@@ -0,0 +1,92 @@
+<?php
+
+namespace App\Repository;
+
+use PDO;
+
+// Underscore prefix used to hint at visibility — PSR-12 violation
+class UserRepository
+{
+    // Single underscore used to signal "protected"
+    protected $_connection;
+    protected $_cache = [];
+    protected $_tableName = 'users';
+
+    // Double underscore used to signal "private"
+    private $__cacheEnabled = true;
+
+    public function __construct($connection)
+    {
+        $this->_connection = $connection;
+    }
+
+    public function findById($id)
+    {
+        if ($this->__cacheEnabled && isset($this->_cache[$id])) {
+            return $this->_cache[$id];
+        }
+
+        $user = $this->_fetchById($id);
+
+        if ($user !== null && $this->__cacheEnabled) {
+            $this->_cache[$id] = $user;
+        }
+
+        return $user;
+    }
+
+    public function findByEmail($email)
+    {
+        $stmt = $this->_connection->prepare(
+            "SELECT * FROM {$this->_tableName} WHERE email = :email AND deleted_at IS NULL"
+        );
+        $stmt->execute(['email' => strtolower($email)]);
+        $row = $stmt->fetch(PDO::FETCH_ASSOC);
+
+        return $row ? $this->_hydrateRow($row) : null;
+    }
+
+    public function save($user)
+    {
+        if ($user->getId() === null) {
+            $this->__insertRow($user);
+        } else {
+            $this->__updateRow($user);
+        }
+
+        $this->__invalidateCache($user->getId());
+    }
+
+    // Single underscore conventionally means "protected" — but explicit modifier is required
+    protected function _fetchById($id)
+    {
+        $stmt = $this->_connection->prepare(
+            "SELECT * FROM {$this->_tableName} WHERE id = :id AND deleted_at IS NULL"
+        );
+        $stmt->execute(['id' => $id]);
+        return $stmt->fetch(PDO::FETCH_ASSOC) ?: null;
+    }
+
+    // Double underscore conventionally means "private" — but explicit modifier is required
+    private function __hydrateRow($row)
+    {
+        return (object) $row;
+    }
+
+    private function __invalidateCache($id): void
+    {
+        if ($id !== null) {
+            unset($this->_cache[$id]);
+        }
+    }
+
+    private function __insertRow($user): void
+    {
+        // insert logic
+    }
+
+    private function __updateRow($user): void
+    {
+        // update logic
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/no_underscore_visibility_prefix/good/UserRepository.php b/priv/combined_metrics/samples/naming_conventions/no_underscore_visibility_prefix/good/UserRepository.php
new file mode 100644
index 0000000..9034e37
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/no_underscore_visibility_prefix/good/UserRepository.php
@@ -0,0 +1,98 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Repository;
+
+use App\Entity\User;
+use PDO;
+
+// Explicit visibility modifiers — no underscore prefix to hint at visibility
+class UserRepository
+{
+    private PDO $connection;
+    private array $cache = [];
+    protected string $tableName = 'users';
+    public bool $cacheEnabled = true;
+
+    public function __construct(PDO $connection)
+    {
+        $this->connection = $connection;
+    }
+
+    public function findById(int $id): ?User
+    {
+        if ($this->cacheEnabled && isset($this->cache[$id])) {
+            return $this->cache[$id];
+        }
+
+        $user = $this->fetchById($id);
+
+        if ($user !== null && $this->cacheEnabled) {
+            $this->cache[$id] = $user;
+        }
+
+        return $user;
+    }
+
+    public function findByEmail(string $email): ?User
+    {
+        $stmt = $this->connection->prepare(
+            "SELECT * FROM {$this->tableName} WHERE email = :email AND deleted_at IS NULL"
+        );
+        $stmt->execute(['email' => mb_strtolower($email)]);
+        $row = $stmt->fetch(PDO::FETCH_ASSOC);
+
+        return $row ? $this->hydrateRow($row) : null;
+    }
+
+    public function save(User $user): void
+    {
+        if ($user->getId() === null) {
+            $this->insertRow($user);
+        } else {
+            $this->updateRow($user);
+        }
+
+        $this->invalidateCache($user->getId());
+    }
+
+    protected function fetchById(int $id): ?User
+    {
+        $stmt = $this->connection->prepare(
+            "SELECT * FROM {$this->tableName} WHERE id = :id AND deleted_at IS NULL"
+        );
+        $stmt->execute(['id' => $id]);
+        $row = $stmt->fetch(PDO::FETCH_ASSOC);
+
+        return $row ? $this->hydrateRow($row) : null;
+    }
+
+    private function hydrateRow(array $row): User
+    {
+        return new User(id: (int) $row['id'], email: $row['email'], name: $row['name'], role: $row['role']);
+    }
+
+    private function invalidateCache(?int $id): void
+    {
+        if ($id !== null) {
+            unset($this->cache[$id]);
+        }
+    }
+
+    private function insertRow(User $user): void
+    {
+        $stmt = $this->connection->prepare(
+            "INSERT INTO {$this->tableName} (email, name, role, created_at) VALUES (:email, :name, :role, NOW())"
+        );
+        $stmt->execute(['email' => $user->getEmail(), 'name' => $user->getName(), 'role' => $user->getRole()]);
+    }
+
+    private function updateRow(User $user): void
+    {
+        $stmt = $this->connection->prepare(
+            "UPDATE {$this->tableName} SET email = :email, name = :name WHERE id = :id"
+        );
+        $stmt->execute(['email' => $user->getEmail(), 'name' => $user->getName(), 'id' => $user->getId()]);
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/no_util_or_meaningless_class_names/bad/PriceFormatter.kt b/priv/combined_metrics/samples/naming_conventions/no_util_or_meaningless_class_names/bad/PriceFormatter.kt
new file mode 100644
index 0000000..c9a1a4f
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/no_util_or_meaningless_class_names/bad/PriceFormatter.kt
@@ -0,0 +1,52 @@
+package com.example.pricing
+
+import java.math.BigDecimal
+import java.util.Currency
+import java.util.Locale
+
+/**
+ * Meaningless class name — "Util" says nothing about what the class does.
+ * Tends to become a dumping ground for unrelated functions.
+ */
+class PriceUtil(private val locale: Locale = Locale.US) {
+
+    fun format(amount: BigDecimal, currency: Currency): String {
+        val symbol = currency.getSymbol(locale)
+        val formatted = amount.setScale(currency.defaultFractionDigits, java.math.RoundingMode.HALF_UP)
+        return "$symbol$formatted"
+    }
+
+    fun formatWithCode(amount: BigDecimal, currency: Currency): String {
+        val formatted = format(amount, currency)
+        return "$formatted ${currency.currencyCode}"
+    }
+
+    fun formatRange(low: BigDecimal, high: BigDecimal, currency: Currency): String {
+        return "${format(low, currency)} – ${format(high, currency)}"
+    }
+}
+
+/**
+ * "Manager" is another meaningless name — vague and overloaded in the industry.
+ * Does not communicate whether this validates, transforms, stores, or orchestrates.
+ */
+class PriceManager {
+
+    fun isValidRetailPrice(price: BigDecimal): Boolean =
+        price > BigDecimal.ZERO && price <= BigDecimal("99999.99")
+
+    fun isBelowCost(price: BigDecimal, costPrice: BigDecimal): Boolean =
+        price < costPrice
+}
+
+/**
+ * "Helper" — another catch-all name that communicates nothing specific.
+ */
+object PriceHelper {
+
+    fun isReasonableDiscount(original: BigDecimal, discounted: BigDecimal): Boolean {
+        if (original <= BigDecimal.ZERO) return false
+        val discountPct = (original - discounted).divide(original) * BigDecimal("100")
+        return discountPct in BigDecimal.ZERO..BigDecimal("80")
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/no_util_or_meaningless_class_names/good/PriceFormatter.kt b/priv/combined_metrics/samples/naming_conventions/no_util_or_meaningless_class_names/good/PriceFormatter.kt
new file mode 100644
index 0000000..65245bd
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/no_util_or_meaningless_class_names/good/PriceFormatter.kt
@@ -0,0 +1,46 @@
+package com.example.pricing
+
+import java.math.BigDecimal
+import java.util.Currency
+import java.util.Locale
+
+/**
+ * Formats monetary amounts for display in various locales and currencies.
+ * Named after what it does — not a meaningless "Util" or "Helper".
+ */
+class PriceFormatter(private val locale: Locale = Locale.US) {
+
+    fun format(amount: BigDecimal, currency: Currency): String {
+        val symbol = currency.getSymbol(locale)
+        val formatted = amount.setScale(currency.defaultFractionDigits, java.math.RoundingMode.HALF_UP)
+        return "$symbol$formatted"
+    }
+
+    fun formatWithCode(amount: BigDecimal, currency: Currency): String {
+        val formatted = format(amount, currency)
+        return "$formatted ${currency.currencyCode}"
+    }
+
+    fun formatRange(low: BigDecimal, high: BigDecimal, currency: Currency): String {
+        return "${format(low, currency)} – ${format(high, currency)}"
+    }
+}
+
+/**
+ * Validates pricing rules for products.
+ * Named after its specific responsibility.
+ */
+class PriceValidator {
+
+    fun isValidRetailPrice(price: BigDecimal): Boolean =
+        price > BigDecimal.ZERO && price <= BigDecimal("99999.99")
+
+    fun isBelowCost(price: BigDecimal, costPrice: BigDecimal): Boolean =
+        price < costPrice
+
+    fun isReasonableDiscount(original: BigDecimal, discounted: BigDecimal): Boolean {
+        if (original <= BigDecimal.ZERO) return false
+        val discountPct = (original - discounted).divide(original) * BigDecimal("100")
+        return discountPct in BigDecimal.ZERO..BigDecimal("80")
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/package_name_is_single_lowercase_word/bad/user.go b/priv/combined_metrics/samples/naming_conventions/package_name_is_single_lowercase_word/bad/user.go
new file mode 100644
index 0000000..077d864
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/package_name_is_single_lowercase_word/bad/user.go
@@ -0,0 +1,50 @@
+// Package userManagement is named with mixed case and multiple words — violates Go conventions.
+// Package names should be a single lowercase word with no underscores or camel case.
+package userManagement
+
+import (
+	"context"
+	"errors"
+	"time"
+)
+
+// ErrNotFound is returned when a user cannot be located.
+var ErrNotFound = errors.New("not found")
+
+// User holds the core identity data for an account.
+type User struct {
+	ID        string
+	Email     string
+	CreatedAt time.Time
+}
+
+// UserStore persists and retrieves users.
+type UserStore interface {
+	Save(ctx context.Context, u User) error
+	FindByID(ctx context.Context, id string) (*User, error)
+}
+
+// UserService provides business-logic operations on users.
+type UserService struct {
+	store UserStore
+}
+
+// NewUserService constructs a UserService backed by the provided UserStore.
+func NewUserService(store UserStore) *UserService {
+	return &UserService{store: store}
+}
+
+// RegisterUser creates a new user account.
+func (s *UserService) RegisterUser(ctx context.Context, email string) (*User, error) {
+	u := User{
+		ID:        generateNewUserID(),
+		Email:     email,
+		CreatedAt: time.Now().UTC(),
+	}
+	if err := s.store.Save(ctx, u); err != nil {
+		return nil, err
+	}
+	return &u, nil
+}
+
+func generateNewUserID() string { return "generated-id" }
diff --git a/priv/combined_metrics/samples/naming_conventions/package_name_is_single_lowercase_word/good/user.go b/priv/combined_metrics/samples/naming_conventions/package_name_is_single_lowercase_word/good/user.go
new file mode 100644
index 0000000..9f279a5
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/package_name_is_single_lowercase_word/good/user.go
@@ -0,0 +1,48 @@
+package user
+
+import (
+	"context"
+	"errors"
+	"time"
+)
+
+// ErrNotFound is returned when a user cannot be located.
+var ErrNotFound = errors.New("not found")
+
+// User holds the core identity data for an account.
+type User struct {
+	ID        string
+	Email     string
+	CreatedAt time.Time
+}
+
+// Store persists and retrieves users.
+type Store interface {
+	Save(ctx context.Context, u User) error
+	FindByID(ctx context.Context, id string) (*User, error)
+}
+
+// Service provides business-logic operations on users.
+type Service struct {
+	store Store
+}
+
+// New constructs a Service backed by the provided Store.
+func New(store Store) *Service {
+	return &Service{store: store}
+}
+
+// Register creates a new user account.
+func (s *Service) Register(ctx context.Context, email string) (*User, error) {
+	u := User{
+		ID:        newID(),
+		Email:     email,
+		CreatedAt: time.Now().UTC(),
+	}
+	if err := s.store.Save(ctx, u); err != nil {
+		return nil, err
+	}
+	return &u, nil
+}
+
+func newID() string { return "generated-id" }
diff --git a/priv/combined_metrics/samples/naming_conventions/predicate_function_ends_with_question_mark/bad/subscriptions.ex b/priv/combined_metrics/samples/naming_conventions/predicate_function_ends_with_question_mark/bad/subscriptions.ex
new file mode 100644
index 0000000..893838c
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/predicate_function_ends_with_question_mark/bad/subscriptions.ex
@@ -0,0 +1,46 @@
+defmodule MyApp.Subscriptions do
+  @moduledoc """
+  Manages customer subscriptions.
+  """
+
+  alias MyApp.Subscriptions.Subscription
+
+  # Bad: predicate function missing `?` suffix
+  @spec active(Subscription.t()) :: boolean()
+  def active(%Subscription{status: :active, expires_at: expires_at}) do
+    DateTime.compare(expires_at, DateTime.utc_now()) == :gt
+  end
+
+  def active(%Subscription{}), do: false
+
+  # Bad: predicate named `is_paid` without being a guard
+  @spec is_paid(%Subscription{}) :: boolean()
+  def is_paid(%Subscription{plan: plan}), do: plan != :free
+
+  # Bad: returns boolean but named like a command, not a predicate
+  @spec check_quota(%Subscription{}) :: boolean()
+  def check_quota(%Subscription{used: used, quota: quota}), do: used >= quota
+
+  # Bad: using `has_` prefix instead of ending with `?`
+  @spec has_trial(%Subscription{}) :: boolean()
+  def has_trial(%Subscription{status: :trialing}), do: true
+  def has_trial(%Subscription{}), do: false
+
+  # Bad: `valid` instead of `valid?`
+  @spec valid(map()) :: boolean()
+  def valid(%{plan: plan, status: status}) do
+    plan in [:free, :starter, :pro, :enterprise] and
+      status in [:active, :trialing, :past_due]
+  end
+
+  def valid(_), do: false
+
+  # Bad: using `can_upgrade` instead of `upgradeable?`
+  @spec can_upgrade(%Subscription{}) :: boolean()
+  def can_upgrade(%Subscription{plan: :enterprise}), do: false
+  def can_upgrade(%Subscription{}), do: true
+
+  # Bad: using `get_auto_renew` for a boolean check
+  @spec get_auto_renew(%Subscription{}) :: boolean()
+  def get_auto_renew(%Subscription{auto_renew: auto_renew}), do: auto_renew == true
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/predicate_function_ends_with_question_mark/good/subscriptions.ex b/priv/combined_metrics/samples/naming_conventions/predicate_function_ends_with_question_mark/good/subscriptions.ex
new file mode 100644
index 0000000..9a5fde5
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/predicate_function_ends_with_question_mark/good/subscriptions.ex
@@ -0,0 +1,65 @@
+defmodule MyApp.Subscriptions do
+  @moduledoc """
+  Manages customer subscriptions. Predicate functions end with `?`
+  and guard-compatible checks use the `is_` prefix.
+  """
+
+  alias MyApp.Subscriptions.Subscription
+
+  @doc """
+  Returns true if the subscription is currently active.
+  """
+  @spec active?(Subscription.t()) :: boolean()
+  def active?(%Subscription{status: :active, expires_at: expires_at}) do
+    DateTime.compare(expires_at, DateTime.utc_now()) == :gt
+  end
+
+  def active?(%Subscription{}), do: false
+
+  @doc """
+  Returns true if the subscription is on a paid plan.
+  """
+  @spec paid?(%Subscription{}) :: boolean()
+  def paid?(%Subscription{plan: plan}), do: plan != :free
+
+  @doc """
+  Returns true if the subscription has exceeded its usage quota.
+  """
+  @spec over_quota?(%Subscription{}) :: boolean()
+  def over_quota?(%Subscription{used: used, quota: quota}), do: used >= quota
+
+  @doc """
+  Returns true if the subscription is in a trial period.
+  """
+  @spec trialing?(%Subscription{}) :: boolean()
+  def trialing?(%Subscription{status: :trialing}), do: true
+  def trialing?(%Subscription{}), do: false
+
+  @doc """
+  Guard-compatible check for a valid subscription map. Uses `is_` prefix
+  per Elixir convention for guard-safe predicates.
+  """
+  defguard is_subscription(value) when is_struct(value, Subscription)
+
+  @doc """
+  Returns true if the subscription will expire within the given number of days.
+  """
+  @spec expiring_soon?(%Subscription{}, non_neg_integer()) :: boolean()
+  def expiring_soon?(%Subscription{expires_at: expires_at}, days) do
+    threshold = DateTime.add(DateTime.utc_now(), days * 86_400, :second)
+    DateTime.compare(expires_at, threshold) == :lt
+  end
+
+  @doc """
+  Returns true if the subscription can be upgraded to a higher tier.
+  """
+  @spec upgradeable?(%Subscription{}) :: boolean()
+  def upgradeable?(%Subscription{plan: :enterprise}), do: false
+  def upgradeable?(%Subscription{}), do: true
+
+  @doc """
+  Returns true if the subscription has auto-renewal enabled.
+  """
+  @spec auto_renews?(%Subscription{}) :: boolean()
+  def auto_renews?(%Subscription{auto_renew: auto_renew}), do: auto_renew == true
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/predicate_method_ends_with_question_mark/bad/subscription.rb b/priv/combined_metrics/samples/naming_conventions/predicate_method_ends_with_question_mark/bad/subscription.rb
new file mode 100644
index 0000000..62eb2f1
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/predicate_method_ends_with_question_mark/bad/subscription.rb
@@ -0,0 +1,52 @@
+class Subscription
+  GRACE_PERIOD_DAYS = 3
+
+  attr_reader :status, :plan, :expires_at, :payment_method, :trial_ends_at
+
+  def initialize(attrs = {})
+    @status = attrs[:status]
+    @plan = attrs[:plan]
+    @expires_at = attrs[:expires_at]
+    @payment_method = attrs[:payment_method]
+    @trial_ends_at = attrs[:trial_ends_at]
+    @cancelled_at = attrs[:cancelled_at]
+  end
+
+  # Returns boolean but missing `?`
+  def active
+    status == :active && !expired
+  end
+
+  def expired
+    expires_at.present? && expires_at < Time.current
+  end
+
+  def in_grace_period
+    expired && expires_at >= GRACE_PERIOD_DAYS.days.ago
+  end
+
+  def trialing
+    trial_ends_at.present? && trial_ends_at > Time.current
+  end
+
+  def cancelled
+    status == :cancelled
+  end
+
+  def paid
+    plan.present? && plan != :free
+  end
+
+  def payment_method_expiring_soon
+    return false unless payment_method
+    payment_method.expires_at < 30.days.from_now
+  end
+
+  def eligible_for_discount
+    paid && !cancelled && !trialing
+  end
+
+  def renewable
+    (active || in_grace_period) && !cancelled
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/predicate_method_ends_with_question_mark/good/subscription.rb b/priv/combined_metrics/samples/naming_conventions/predicate_method_ends_with_question_mark/good/subscription.rb
new file mode 100644
index 0000000..278365f
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/predicate_method_ends_with_question_mark/good/subscription.rb
@@ -0,0 +1,51 @@
+class Subscription
+  GRACE_PERIOD_DAYS = 3
+
+  attr_reader :status, :plan, :expires_at, :payment_method, :trial_ends_at
+
+  def initialize(attrs = {})
+    @status = attrs[:status]
+    @plan = attrs[:plan]
+    @expires_at = attrs[:expires_at]
+    @payment_method = attrs[:payment_method]
+    @trial_ends_at = attrs[:trial_ends_at]
+    @cancelled_at = attrs[:cancelled_at]
+  end
+
+  def active?
+    status == :active && !expired?
+  end
+
+  def expired?
+    expires_at.present? && expires_at < Time.current
+  end
+
+  def in_grace_period?
+    expired? && expires_at >= GRACE_PERIOD_DAYS.days.ago
+  end
+
+  def trialing?
+    trial_ends_at.present? && trial_ends_at > Time.current
+  end
+
+  def cancelled?
+    status == :cancelled
+  end
+
+  def paid?
+    plan.present? && plan != :free
+  end
+
+  def payment_method_expiring_soon?
+    return false unless payment_method
+    payment_method.expires_at < 30.days.from_now
+  end
+
+  def eligible_for_discount?
+    paid? && !cancelled? && !trialing?
+  end
+
+  def renewable?
+    (active? || in_grace_period?) && !cancelled?
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/predicate_prefixed_with_is/bad/order.rs b/priv/combined_metrics/samples/naming_conventions/predicate_prefixed_with_is/bad/order.rs
new file mode 100644
index 0000000..3e81c79
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/predicate_prefixed_with_is/bad/order.rs
@@ -0,0 +1,59 @@
+#[derive(Debug, Clone, PartialEq)]
+pub enum OrderStatus {
+    Pending,
+    Confirmed,
+    Shipped,
+    Delivered,
+    Cancelled,
+    Refunded,
+}
+
+#[derive(Debug, Clone)]
+pub struct Order {
+    pub id: u64,
+    pub status: OrderStatus,
+    pub total_cents: u64,
+    pub item_count: u32,
+    pub discount_applied: bool,
+}
+
+impl Order {
+    pub fn new(id: u64, total_cents: u64, item_count: u32) -> Self {
+        Self {
+            id,
+            status: OrderStatus::Pending,
+            total_cents,
+            item_count,
+            discount_applied: false,
+        }
+    }
+
+    // Bad: boolean predicates should start with is_ or has_
+    pub fn pending(&self) -> bool {
+        self.status == OrderStatus::Pending
+    }
+
+    pub fn cancelled(&self) -> bool {
+        self.status == OrderStatus::Cancelled
+    }
+
+    // "fulfilled" reads like a noun or past-tense verb — ambiguous without "is_"
+    pub fn fulfilled(&self) -> bool {
+        matches!(self.status, OrderStatus::Shipped | OrderStatus::Delivered)
+    }
+
+    // "empty" without "is_" is unclear whether it's an adjective or a verb
+    pub fn empty(&self) -> bool {
+        self.item_count == 0
+    }
+
+    // "discount" alone is ambiguous — could mean apply a discount
+    pub fn discount(&self) -> bool {
+        self.discount_applied
+    }
+
+    // "high_value" reads oddly without the "is_" prefix
+    pub fn high_value(&self) -> bool {
+        self.total_cents >= 10_000_00
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/predicate_prefixed_with_is/good/order.rs b/priv/combined_metrics/samples/naming_conventions/predicate_prefixed_with_is/good/order.rs
new file mode 100644
index 0000000..a343242
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/predicate_prefixed_with_is/good/order.rs
@@ -0,0 +1,55 @@
+#[derive(Debug, Clone, PartialEq)]
+pub enum OrderStatus {
+    Pending,
+    Confirmed,
+    Shipped,
+    Delivered,
+    Cancelled,
+    Refunded,
+}
+
+#[derive(Debug, Clone)]
+pub struct Order {
+    pub id: u64,
+    pub status: OrderStatus,
+    pub total_cents: u64,
+    pub item_count: u32,
+    pub discount_applied: bool,
+}
+
+impl Order {
+    pub fn new(id: u64, total_cents: u64, item_count: u32) -> Self {
+        Self {
+            id,
+            status: OrderStatus::Pending,
+            total_cents,
+            item_count,
+            discount_applied: false,
+        }
+    }
+
+    // Good: boolean predicates use is_ or has_ prefix
+    pub fn is_pending(&self) -> bool {
+        self.status == OrderStatus::Pending
+    }
+
+    pub fn is_cancelled(&self) -> bool {
+        self.status == OrderStatus::Cancelled
+    }
+
+    pub fn is_fulfilled(&self) -> bool {
+        matches!(self.status, OrderStatus::Shipped | OrderStatus::Delivered)
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.item_count == 0
+    }
+
+    pub fn has_discount(&self) -> bool {
+        self.discount_applied
+    }
+
+    pub fn is_high_value(&self) -> bool {
+        self.total_cents >= 10_000_00
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/protocol_capability_uses_able_ible_ing_suffix/bad/DocumentPipeline.swift b/priv/combined_metrics/samples/naming_conventions/protocol_capability_uses_able_ible_ing_suffix/bad/DocumentPipeline.swift
new file mode 100644
index 0000000..4925926
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/protocol_capability_uses_able_ible_ing_suffix/bad/DocumentPipeline.swift
@@ -0,0 +1,60 @@
+import Foundation
+
+// Capability protocols with noun or adjective names that don't convey capability
+
+// Should be Exportable — "Export" is a noun/verb, not a capability descriptor
+protocol Export {
+    func exportedData(format: ExportFormat) -> Data
+}
+
+// Should be Filterable — "Filter" reads as an action, not a capability
+protocol Filter {
+    associatedtype Element
+    func filtered(by predicate: (Element) -> Bool) -> Self
+}
+
+// Should be Indexing — "Index" reads as a noun (an index), not a capability
+protocol Index {
+    associatedtype Key: Hashable
+    associatedtype Value
+    subscript(key: Key) -> Value? { get }
+}
+
+// Should be Archivable — "Archive" is a noun/verb, lacks capability suffix
+protocol Archive {
+    func archive() throws -> Data
+    static func unarchive(from data: Data) throws -> Self
+}
+
+enum ExportFormat {
+    case json, csv, xml
+}
+
+struct Document: Export, Archive {
+    let id: String
+    var title: String
+    var content: String
+    var tags: [String]
+
+    func exportedData(format: ExportFormat) -> Data {
+        switch format {
+        case .json:
+            let dict: [String: Any] = ["id": id, "title": title, "content": content]
+            return (try? JSONSerialization.data(withJSONObject: dict)) ?? Data()
+        case .csv:
+            return "\(id),\(title),\(content)".data(using: .utf8) ?? Data()
+        case .xml:
+            return "<doc><id>\(id)</id><title>\(title)</title></doc>".data(using: .utf8) ?? Data()
+        }
+    }
+
+    func archive() throws -> Data {
+        let dict: [String: String] = ["id": id, "title": title, "content": content]
+        return try JSONSerialization.data(withJSONObject: dict)
+    }
+
+    static func unarchive(from data: Data) throws -> Document {
+        let dict = try JSONSerialization.jsonObject(with: data) as? [String: String] ?? [:]
+        return Document(id: dict["id"] ?? "", title: dict["title"] ?? "", content: dict["content"] ?? "", tags: [])
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/protocol_capability_uses_able_ible_ing_suffix/good/DocumentPipeline.swift b/priv/combined_metrics/samples/naming_conventions/protocol_capability_uses_able_ible_ing_suffix/good/DocumentPipeline.swift
new file mode 100644
index 0000000..e7216ba
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/protocol_capability_uses_able_ible_ing_suffix/good/DocumentPipeline.swift
@@ -0,0 +1,56 @@
+import Foundation
+
+// Capability protocols using -able / -ible / -ing suffixes
+
+protocol Exportable {
+    func exportedData(format: ExportFormat) -> Data
+}
+
+protocol Filterable {
+    associatedtype Element
+    func filtered(by predicate: (Element) -> Bool) -> Self
+}
+
+protocol Indexing {
+    associatedtype Key: Hashable
+    associatedtype Value
+    subscript(key: Key) -> Value? { get }
+}
+
+protocol Archivable {
+    func archive() throws -> Data
+    static func unarchive(from data: Data) throws -> Self
+}
+
+enum ExportFormat {
+    case json, csv, xml
+}
+
+struct Document: Exportable, Archivable {
+    let id: String
+    var title: String
+    var content: String
+    var tags: [String]
+
+    func exportedData(format: ExportFormat) -> Data {
+        switch format {
+        case .json:
+            let dict: [String: Any] = ["id": id, "title": title, "content": content]
+            return (try? JSONSerialization.data(withJSONObject: dict)) ?? Data()
+        case .csv:
+            return "\(id),\(title),\(content)".data(using: .utf8) ?? Data()
+        case .xml:
+            return "<doc><id>\(id)</id><title>\(title)</title></doc>".data(using: .utf8) ?? Data()
+        }
+    }
+
+    func archive() throws -> Data {
+        let dict: [String: String] = ["id": id, "title": title, "content": content]
+        return try JSONSerialization.data(withJSONObject: dict)
+    }
+
+    static func unarchive(from data: Data) throws -> Document {
+        let dict = try JSONSerialization.jsonObject(with: data) as? [String: String] ?? [:]
+        return Document(id: dict["id"] ?? "", title: dict["title"] ?? "", content: dict["content"] ?? "", tags: [])
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/receiver_name_is_short_type_abbreviation/bad/session.go b/priv/combined_metrics/samples/naming_conventions/receiver_name_is_short_type_abbreviation/bad/session.go
new file mode 100644
index 0000000..98934a6
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/receiver_name_is_short_type_abbreviation/bad/session.go
@@ -0,0 +1,47 @@
+package session
+
+import (
+	"time"
+)
+
+// Session represents an authenticated user session.
+type Session struct {
+	Token     string
+	UserID    string
+	ExpiresAt time.Time
+}
+
+// Manager tracks active sessions.
+type Manager struct {
+	sessions map[string]*Session
+}
+
+// NewManager constructs an empty Manager.
+func NewManager() *Manager {
+	return &Manager{sessions: make(map[string]*Session)}
+}
+
+// IsExpired reports whether the session has passed its expiry time.
+// Receiver is named "self" — not idiomatic Go; should be "s".
+func (self *Session) IsExpired() bool {
+	return time.Now().After(self.ExpiresAt)
+}
+
+// Refresh extends the session expiry by the given duration.
+// Receiver is named "this" — not idiomatic Go; should be "s".
+func (this *Session) Refresh(d time.Duration) {
+	this.ExpiresAt = time.Now().Add(d)
+}
+
+// Add registers a new session with the manager.
+// Receiver is named "me" — not idiomatic Go; should be "m".
+func (me *Manager) Add(s *Session) {
+	me.sessions[s.Token] = s
+}
+
+// Lookup returns the session for the given token, if present.
+// Receiver is named "mgr" — verbose, inconsistent with other methods.
+func (mgr *Manager) Lookup(token string) (*Session, bool) {
+	s, ok := mgr.sessions[token]
+	return s, ok
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/receiver_name_is_short_type_abbreviation/good/session.go b/priv/combined_metrics/samples/naming_conventions/receiver_name_is_short_type_abbreviation/good/session.go
new file mode 100644
index 0000000..ee9c024
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/receiver_name_is_short_type_abbreviation/good/session.go
@@ -0,0 +1,48 @@
+package session
+
+import (
+	"time"
+)
+
+// Session represents an authenticated user session.
+type Session struct {
+	Token     string
+	UserID    string
+	ExpiresAt time.Time
+}
+
+// Manager tracks active sessions.
+// Receiver names use short abbreviations: s for Session, m for Manager.
+type Manager struct {
+	sessions map[string]*Session
+}
+
+// NewManager constructs an empty Manager.
+func NewManager() *Manager {
+	return &Manager{sessions: make(map[string]*Session)}
+}
+
+// IsExpired reports whether the session has passed its expiry time.
+// Receiver is s — a short abbreviation of Session.
+func (s *Session) IsExpired() bool {
+	return time.Now().After(s.ExpiresAt)
+}
+
+// Refresh extends the session expiry by the given duration.
+// Receiver is s — consistent with other Session methods.
+func (s *Session) Refresh(d time.Duration) {
+	s.ExpiresAt = time.Now().Add(d)
+}
+
+// Add registers a new session with the manager.
+// Receiver is m — a short abbreviation of Manager.
+func (m *Manager) Add(s *Session) {
+	m.sessions[s.Token] = s
+}
+
+// Lookup returns the session for the given token, if present.
+// Receiver is m — consistent abbreviation.
+func (m *Manager) Lookup(token string) (*Session, bool) {
+	s, ok := m.sessions[token]
+	return s, ok
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/size_vs_length_naming_is_consistent/bad/catalog.ex b/priv/combined_metrics/samples/naming_conventions/size_vs_length_naming_is_consistent/bad/catalog.ex
new file mode 100644
index 0000000..a24836c
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/size_vs_length_naming_is_consistent/bad/catalog.ex
@@ -0,0 +1,51 @@
+defmodule MyApp.Catalog do
+  @moduledoc """
+  Product catalog operations.
+  """
+
+  alias MyApp.Catalog.{Category, Product}
+
+  # Bad: `size` is used for an O(n) operation — traverses the list
+  @spec category_size([Product.t()]) :: non_neg_integer()
+  def category_size(products) when is_list(products) do
+    length(products)
+  end
+
+  # Bad: `size` is used for String.length/1 which is O(n) over grapheme clusters
+  @spec description_size(Product.t()) :: non_neg_integer()
+  def description_size(%Product{description: desc}) when is_binary(desc) do
+    String.length(desc)
+  end
+
+  def description_size(%Product{}), do: 0
+
+  # Bad: `length` is used for an O(1) byte_size operation
+  @spec payload_length(binary()) :: non_neg_integer()
+  def payload_length(payload) when is_binary(payload) do
+    byte_size(payload)
+  end
+
+  # Bad: `length` used for map_size which is O(1)
+  @spec attributes_length(map()) :: non_neg_integer()
+  def attributes_length(attrs) when is_map(attrs) do
+    map_size(attrs)
+  end
+
+  # Bad: `size` used on a linked list — O(n) traversal
+  @spec variant_size(Product.t()) :: non_neg_integer()
+  def variant_size(%Product{variants: variants}) when is_list(variants) do
+    length(variants)
+  end
+
+  # Bad: `length` used for tuple_size which is O(1)
+  @spec tuple_length(tuple()) :: non_neg_integer()
+  def tuple_length(t) when is_tuple(t) do
+    tuple_size(t)
+  end
+
+  # Bad: `size` used for Enum.count — O(n) for most enumerables
+  @spec tag_size(Enumerable.t()) :: non_neg_integer()
+  def tag_size(tags) do
+    Enum.count(tags)
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/size_vs_length_naming_is_consistent/good/catalog.ex b/priv/combined_metrics/samples/naming_conventions/size_vs_length_naming_is_consistent/good/catalog.ex
new file mode 100644
index 0000000..241c6aa
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/size_vs_length_naming_is_consistent/good/catalog.ex
@@ -0,0 +1,61 @@
+defmodule MyApp.Catalog do
+  @moduledoc """
+  Product catalog operations. Follows the `size`/`length` naming contract:
+  - `size` is O(1) — backed by a pre-computed count stored on the struct
+  - `length` is O(n) — traverses the collection to count items
+  """
+
+  alias MyApp.Catalog.{Category, Product}
+
+  @doc """
+  Returns the number of products in a category in O(1) time.
+  The count is pre-computed and stored on the category struct.
+  """
+  @spec category_size(Category.t()) :: non_neg_integer()
+  def category_size(%Category{product_count: count}), do: count
+
+  @doc """
+  Returns the number of tags on a product in O(1) time.
+  Tags are stored as a list but the count is maintained separately.
+  """
+  @spec tag_size(Product.t()) :: non_neg_integer()
+  def tag_size(%Product{tag_count: count}), do: count
+
+  @doc """
+  Returns the number of characters in a product's description in O(n) time.
+  This traverses the binary to count grapheme clusters.
+  """
+  @spec description_length(Product.t()) :: non_neg_integer()
+  def description_length(%Product{description: desc}) when is_binary(desc) do
+    String.length(desc)
+  end
+
+  def description_length(%Product{}), do: 0
+
+  @doc """
+  Returns the number of products in an in-memory list in O(n) time.
+  Traverses the list to produce the count.
+  """
+  @spec products_length([Product.t()]) :: non_neg_integer()
+  def products_length(products) when is_list(products) do
+    length(products)
+  end
+
+  @doc """
+  Returns the byte size of the serialized product payload in O(1) time.
+  `:erlang.byte_size/1` is O(1) on binaries.
+  """
+  @spec payload_size(binary()) :: non_neg_integer()
+  def payload_size(payload) when is_binary(payload) do
+    byte_size(payload)
+  end
+
+  @doc """
+  Returns the number of variants for a product in O(n) time by
+  enumerating the variants list.
+  """
+  @spec variants_length(Product.t()) :: non_neg_integer()
+  def variants_length(%Product{variants: variants}) when is_list(variants) do
+    length(variants)
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/test_name_starts_with_verb/bad/user_test.ex b/priv/combined_metrics/samples/naming_conventions/test_name_starts_with_verb/bad/user_test.ex
new file mode 100644
index 0000000..ae9ba14
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/test_name_starts_with_verb/bad/user_test.ex
@@ -0,0 +1,54 @@
+defmodule UserTest do
+  use ExUnit.Case, async: true
+
+  describe "create_user/1" do
+    test "valid input" do
+      attrs = %{name: "Alice", email: "alice@example.com", role: :member}
+      assert {:ok, user} = User.create(attrs)
+      assert user.name == "Alice"
+    end
+
+    test "missing email" do
+      attrs = %{name: "Alice", role: :member}
+      assert {:error, changeset} = User.create(attrs)
+      assert "can't be blank" in errors_on(changeset).email
+    end
+
+    test "duplicate email" do
+      attrs = %{name: "Bob", email: "bob@example.com", role: :member}
+      {:ok, _} = User.create(attrs)
+      assert {:error, changeset} = User.create(attrs)
+      assert "has already been taken" in errors_on(changeset).email
+    end
+  end
+
+  describe "update_user/2" do
+    test "the user with valid attrs" do
+      user = %{id: 1, name: "Alice", email: "alice@example.com"}
+      assert {:ok, updated} = User.update(user, %{name: "Alicia"})
+      assert updated.name == "Alicia"
+    end
+
+    test "invalid role value" do
+      user = %{id: 1, name: "Alice", email: "alice@example.com", role: :member}
+      assert {:error, _changeset} = User.update(user, %{role: :superuser})
+    end
+  end
+
+  describe "deactivate_user/1" do
+    test "active user" do
+      user = %{id: 1, status: :active}
+      assert {:ok, deactivated} = User.deactivate(user)
+      assert deactivated.status == :inactive
+    end
+
+    test "already inactive user" do
+      user = %{id: 1, status: :inactive}
+      assert {:error, :already_inactive} = User.deactivate(user)
+    end
+  end
+
+  defp errors_on(changeset) do
+    Ecto.Changeset.traverse_errors(changeset, fn {msg, _opts} -> msg end)
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/test_name_starts_with_verb/config.yml b/priv/combined_metrics/samples/naming_conventions/test_name_starts_with_verb/config.yml
new file mode 100644
index 0000000..393d9c8
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/test_name_starts_with_verb/config.yml
@@ -0,0 +1 @@
+doc: "Test descriptions should start with a verb: `creates`, `raises`, `returns`, not a noun phrase."
diff --git a/priv/combined_metrics/samples/naming_conventions/test_name_starts_with_verb/good/user_test.ex b/priv/combined_metrics/samples/naming_conventions/test_name_starts_with_verb/good/user_test.ex
new file mode 100644
index 0000000..fbd4d2d
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/test_name_starts_with_verb/good/user_test.ex
@@ -0,0 +1,54 @@
+defmodule UserTest do
+  use ExUnit.Case, async: true
+
+  describe "create_user/1" do
+    test "creates user when attrs are valid" do
+      attrs = %{name: "Alice", email: "alice@example.com", role: :member}
+      assert {:ok, user} = User.create(attrs)
+      assert user.name == "Alice"
+    end
+
+    test "returns error when email is missing" do
+      attrs = %{name: "Alice", role: :member}
+      assert {:error, changeset} = User.create(attrs)
+      assert "can't be blank" in errors_on(changeset).email
+    end
+
+    test "returns error when email is already taken" do
+      attrs = %{name: "Bob", email: "bob@example.com", role: :member}
+      {:ok, _} = User.create(attrs)
+      assert {:error, changeset} = User.create(attrs)
+      assert "has already been taken" in errors_on(changeset).email
+    end
+  end
+
+  describe "update_user/2" do
+    test "updates user name when attrs are valid" do
+      user = %{id: 1, name: "Alice", email: "alice@example.com"}
+      assert {:ok, updated} = User.update(user, %{name: "Alicia"})
+      assert updated.name == "Alicia"
+    end
+
+    test "rejects invalid role value" do
+      user = %{id: 1, name: "Alice", email: "alice@example.com", role: :member}
+      assert {:error, _changeset} = User.update(user, %{role: :superuser})
+    end
+  end
+
+  describe "deactivate_user/1" do
+    test "deactivates an active user" do
+      user = %{id: 1, status: :active}
+      assert {:ok, deactivated} = User.deactivate(user)
+      assert deactivated.status == :inactive
+    end
+
+    test "returns error when user is already inactive" do
+      user = %{id: 1, status: :inactive}
+      assert {:error, :already_inactive} = User.deactivate(user)
+    end
+  end
+
+  defp errors_on(changeset) do
+    Ecto.Changeset.traverse_errors(changeset, fn {msg, _opts} -> msg end)
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/type_parameter_is_descriptive_or_single_letter/bad/CacheStore.swift b/priv/combined_metrics/samples/naming_conventions/type_parameter_is_descriptive_or_single_letter/bad/CacheStore.swift
new file mode 100644
index 0000000..959a117
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/type_parameter_is_descriptive_or_single_letter/bad/CacheStore.swift
@@ -0,0 +1,56 @@
+import Foundation
+
+// Non-descriptive multi-letter names that aren't single letters or established names
+// "KT" and "VT" are neither single-letter nor descriptive
+struct CacheStore<KT: Hashable, VT> {
+    private var storage: [KT: CacheEntry<VT>] = [:]
+    private let capacity: Int
+    private let timeToLive: TimeInterval
+
+    init(capacity: Int, timeToLive: TimeInterval = 300) {
+        self.capacity = capacity
+        self.timeToLive = timeToLive
+    }
+
+    mutating func store(_ value: VT, for key: KT) {
+        if storage.count >= capacity {
+            evictOldest()
+        }
+        storage[key] = CacheEntry(value: value, storedAt: Date())
+    }
+
+    func value(for key: KT) -> VT? {
+        guard let entry = storage[key] else { return nil }
+        guard Date().timeIntervalSince(entry.storedAt) < timeToLive else { return nil }
+        return entry.value
+    }
+
+    mutating func remove(for key: KT) {
+        storage.removeValue(forKey: key)
+    }
+
+    mutating private func evictOldest() {
+        guard let oldest = storage.min(by: { $0.value.storedAt < $1.value.storedAt }) else { return }
+        storage.removeValue(forKey: oldest.key)
+    }
+}
+
+// "Obj" is an opaque multi-letter name, neither descriptive nor a single letter
+struct CacheEntry<Obj> {
+    let value: Obj
+    let storedAt: Date
+}
+
+// "Tp" is a non-standard two-letter abbreviation rather than single-letter T
+func firstNonNil<Tp>(_ values: Tp?...) -> Tp? {
+    return values.first { $0 != nil } ?? nil
+}
+
+// "Elm" is an abbreviation of "Element" — should be the full word or T
+extension Array {
+    func chunked(into size: Int) -> [[Elm]] where Elm == Element {
+        stride(from: 0, to: count, by: size).map {
+            Array(self[$0..<Swift.min($0 + size, count)])
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/type_parameter_is_descriptive_or_single_letter/good/CacheStore.swift b/priv/combined_metrics/samples/naming_conventions/type_parameter_is_descriptive_or_single_letter/good/CacheStore.swift
new file mode 100644
index 0000000..14e6a86
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/type_parameter_is_descriptive_or_single_letter/good/CacheStore.swift
@@ -0,0 +1,54 @@
+import Foundation
+
+// Descriptive type parameter: "Key" and "Value" describe the roles clearly
+struct CacheStore<Key: Hashable, Value> {
+    private var storage: [Key: CacheEntry<Value>] = [:]
+    private let capacity: Int
+    private let timeToLive: TimeInterval
+
+    init(capacity: Int, timeToLive: TimeInterval = 300) {
+        self.capacity = capacity
+        self.timeToLive = timeToLive
+    }
+
+    mutating func store(_ value: Value, for key: Key) {
+        if storage.count >= capacity {
+            evictOldest()
+        }
+        storage[key] = CacheEntry(value: value, storedAt: Date())
+    }
+
+    func value(for key: Key) -> Value? {
+        guard let entry = storage[key] else { return nil }
+        guard Date().timeIntervalSince(entry.storedAt) < timeToLive else { return nil }
+        return entry.value
+    }
+
+    mutating func remove(for key: Key) {
+        storage.removeValue(forKey: key)
+    }
+
+    mutating private func evictOldest() {
+        guard let oldest = storage.min(by: { $0.value.storedAt < $1.value.storedAt }) else { return }
+        storage.removeValue(forKey: oldest.key)
+    }
+}
+
+struct CacheEntry<Value> {
+    let value: Value
+    let storedAt: Date
+}
+
+// Single-letter T is acceptable when there is no meaningful relationship to express
+func firstNonNil<T>(_ values: T?...) -> T? {
+    return values.first { $0 != nil } ?? nil
+}
+
+// Descriptive name "Element" when the relationship to a sequence is meaningful
+extension Array {
+    func chunked(into size: Int) -> [[Element]] {
+        stride(from: 0, to: count, by: size).map {
+            Array(self[$0..<Swift.min($0 + size, count)])
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/uses_caps_words_for_classes/bad/session_manager.py b/priv/combined_metrics/samples/naming_conventions/uses_caps_words_for_classes/bad/session_manager.py
new file mode 100644
index 0000000..501e623
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/uses_caps_words_for_classes/bad/session_manager.py
@@ -0,0 +1,69 @@
+"""Session manager tracking authenticated user sessions."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from typing import Optional
+import secrets
+
+
+@dataclass
+class session_token:          # lowercase — should be SessionToken (CapWords)
+    value: str
+    created_at: datetime = field(default_factory=datetime.utcnow)
+
+
+@dataclass
+class user_session:           # lowercase with underscores — should be UserSession
+    session_id: str
+    user_id: int
+    token: session_token
+    expires_at: datetime
+    ip_address: str
+    user_agent: str
+
+
+class sessionStore:           # camelCase — should be SessionStore (CapWords)
+    """In-memory store for active sessions."""
+
+    def __init__(self) -> None:
+        self._sessions: dict[str, user_session] = {}
+
+    def put(self, session: user_session) -> None:
+        self._sessions[session.session_id] = session
+
+    def get(self, session_id: str) -> Optional[user_session]:
+        return self._sessions.get(session_id)
+
+    def remove(self, session_id: str) -> bool:
+        return self._sessions.pop(session_id, None) is not None
+
+    def active_count(self) -> int:
+        now = datetime.utcnow()
+        return sum(1 for s in self._sessions.values() if s.expires_at > now)
+
+
+class session_expired_error(Exception):   # lowercase — should be SessionExpiredError
+    """Raised when a session is accessed after expiry."""
+
+
+def create_session(
+    user_id: int,
+    ip_address: str,
+    user_agent: str,
+    ttl_minutes: int = 60,
+) -> user_session:            # return type references a badly named class
+    token = session_token(value=secrets.token_hex(32))
+    return user_session(
+        session_id=secrets.token_hex(16),
+        user_id=user_id,
+        token=token,
+        expires_at=datetime.utcnow() + timedelta(minutes=ttl_minutes),
+        ip_address=ip_address,
+        user_agent=user_agent,
+    )
+
+
+def validate_session(session: user_session) -> None:
+    if datetime.utcnow() > session.expires_at:
+        raise session_expired_error(f"Session {session.session_id} expired")
diff --git a/priv/combined_metrics/samples/naming_conventions/uses_caps_words_for_classes/good/session_manager.py b/priv/combined_metrics/samples/naming_conventions/uses_caps_words_for_classes/good/session_manager.py
new file mode 100644
index 0000000..ce061a0
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/uses_caps_words_for_classes/good/session_manager.py
@@ -0,0 +1,73 @@
+"""Session manager tracking authenticated user sessions."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from typing import Optional
+import secrets
+
+
+@dataclass
+class SessionToken:
+    """Wraps a raw token string with creation metadata."""
+    value: str
+    created_at: datetime = field(default_factory=datetime.utcnow)
+
+
+@dataclass
+class UserSession:
+    """Represents one authenticated session for a user."""
+    session_id: str
+    user_id: int
+    token: SessionToken
+    expires_at: datetime
+    ip_address: str
+    user_agent: str
+
+
+class SessionStore:
+    """In-memory store for active sessions."""
+
+    def __init__(self) -> None:
+        self._sessions: dict[str, UserSession] = {}
+
+    def put(self, session: UserSession) -> None:
+        self._sessions[session.session_id] = session
+
+    def get(self, session_id: str) -> Optional[UserSession]:
+        return self._sessions.get(session_id)
+
+    def remove(self, session_id: str) -> bool:
+        return self._sessions.pop(session_id, None) is not None
+
+    def active_count(self) -> int:
+        now = datetime.utcnow()
+        return sum(1 for s in self._sessions.values() if s.expires_at > now)
+
+
+class SessionExpiredError(Exception):
+    """Raised when a session is accessed after expiry."""
+
+
+def create_session(
+    user_id: int,
+    ip_address: str,
+    user_agent: str,
+    ttl_minutes: int = 60,
+) -> UserSession:
+    """Create a new session with a cryptographically secure token."""
+    token = SessionToken(value=secrets.token_hex(32))
+    return UserSession(
+        session_id=secrets.token_hex(16),
+        user_id=user_id,
+        token=token,
+        expires_at=datetime.utcnow() + timedelta(minutes=ttl_minutes),
+        ip_address=ip_address,
+        user_agent=user_agent,
+    )
+
+
+def validate_session(session: UserSession) -> None:
+    """Raise SessionExpiredError if the session has expired."""
+    if datetime.utcnow() > session.expires_at:
+        raise SessionExpiredError(f"Session {session.session_id} expired")
diff --git a/priv/combined_metrics/samples/naming_conventions/uses_snake_case_for_functions/bad/invoice_handler.py b/priv/combined_metrics/samples/naming_conventions/uses_snake_case_for_functions/bad/invoice_handler.py
new file mode 100644
index 0000000..be654e2
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/uses_snake_case_for_functions/bad/invoice_handler.py
@@ -0,0 +1,74 @@
+"""Invoice handler that generates, validates, and sends customer invoices."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date, timedelta
+from decimal import Decimal
+from typing import Optional
+import uuid
+
+
+@dataclass
+class InvoiceLineItem:
+    description: str
+    quantity: int
+    unitPrice: Decimal        # camelCase field — should be unit_price
+
+
+@dataclass
+class Invoice:
+    id: str
+    customerName: str         # camelCase — should be customer_name
+    customerEmail: str        # camelCase — should be customer_email
+    lineItems: list = field(default_factory=list)  # camelCase — should be line_items
+    issuedOn: date = field(default_factory=date.today)
+    dueDays: int = 30
+    paidOn: Optional[date] = None
+
+
+def createInvoice(                   # camelCase function — should be create_invoice
+    customerName: str,
+    customerEmail: str,
+    lineItems: list,
+    dueDays: int = 30,
+) -> Invoice:
+    return Invoice(
+        id=f"INV-{uuid.uuid4().hex[:8].upper()}",
+        customerName=customerName,
+        customerEmail=customerEmail,
+        lineItems=lineItems,
+        dueDays=dueDays,
+    )
+
+
+def calculateSubtotal(invoice: Invoice) -> Decimal:  # camelCase — should be calculate_subtotal
+    return sum(item.quantity * item.unitPrice for item in invoice.lineItems)
+
+
+def calculateTax(invoice: Invoice, taxRate: Decimal) -> Decimal:  # camelCase params too
+    return calculateSubtotal(invoice) * taxRate
+
+
+def calculateTotal(invoice: Invoice, taxRate: Decimal = Decimal("0")) -> Decimal:
+    return calculateSubtotal(invoice) + calculateTax(invoice, taxRate)
+
+
+def getDueDate(invoice: Invoice) -> date:           # camelCase — should be get_due_date
+    return invoice.issuedOn + timedelta(days=invoice.dueDays)
+
+
+def markAsPaid(invoice: Invoice, paidOn: Optional[date] = None) -> Invoice:
+    invoice.paidOn = paidOn or date.today()
+    return invoice
+
+
+def isOverdue(invoice: Invoice) -> bool:            # camelCase — should be is_overdue
+    if invoice.paidOn is not None:
+        return False
+    return date.today() > getDueDate(invoice)
+
+
+def formatSummary(invoice: Invoice) -> str:         # camelCase — should be format_summary
+    subtotal = calculateSubtotal(invoice)
+    status = "PAID" if invoice.paidOn else ("OVERDUE" if isOverdue(invoice) else "PENDING")
+    return f"{invoice.id} | {invoice.customerName} | ${subtotal:.2f} | {status}"
diff --git a/priv/combined_metrics/samples/naming_conventions/uses_snake_case_for_functions/good/invoice_handler.py b/priv/combined_metrics/samples/naming_conventions/uses_snake_case_for_functions/good/invoice_handler.py
new file mode 100644
index 0000000..582e1ee
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/uses_snake_case_for_functions/good/invoice_handler.py
@@ -0,0 +1,82 @@
+"""Invoice handler that generates, validates, and sends customer invoices."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date, timedelta
+from decimal import Decimal
+from typing import Optional
+import uuid
+
+
+@dataclass
+class InvoiceLineItem:
+    description: str
+    quantity: int
+    unit_price: Decimal
+
+
+@dataclass
+class Invoice:
+    id: str
+    customer_name: str
+    customer_email: str
+    line_items: list[InvoiceLineItem] = field(default_factory=list)
+    issued_on: date = field(default_factory=date.today)
+    due_days: int = 30
+    paid_on: Optional[date] = None
+
+
+def create_invoice(
+    customer_name: str,
+    customer_email: str,
+    line_items: list[InvoiceLineItem],
+    due_days: int = 30,
+) -> Invoice:
+    """Create and return a new Invoice with a generated ID."""
+    return Invoice(
+        id=f"INV-{uuid.uuid4().hex[:8].upper()}",
+        customer_name=customer_name,
+        customer_email=customer_email,
+        line_items=line_items,
+        due_days=due_days,
+    )
+
+
+def calculate_subtotal(invoice: Invoice) -> Decimal:
+    """Sum all line item totals."""
+    return sum(item.quantity * item.unit_price for item in invoice.line_items)
+
+
+def calculate_tax(invoice: Invoice, tax_rate: Decimal) -> Decimal:
+    """Return the tax amount for the given rate."""
+    return calculate_subtotal(invoice) * tax_rate
+
+
+def calculate_total(invoice: Invoice, tax_rate: Decimal = Decimal("0")) -> Decimal:
+    """Return the grand total including tax."""
+    return calculate_subtotal(invoice) + calculate_tax(invoice, tax_rate)
+
+
+def get_due_date(invoice: Invoice) -> date:
+    """Return the payment due date based on issue date and due_days."""
+    return invoice.issued_on + timedelta(days=invoice.due_days)
+
+
+def mark_as_paid(invoice: Invoice, paid_on: Optional[date] = None) -> Invoice:
+    """Return a new Invoice marked as paid."""
+    invoice.paid_on = paid_on or date.today()
+    return invoice
+
+
+def is_overdue(invoice: Invoice) -> bool:
+    """Return True if the invoice is unpaid and past its due date."""
+    if invoice.paid_on is not None:
+        return False
+    return date.today() > get_due_date(invoice)
+
+
+def format_summary(invoice: Invoice) -> str:
+    """Return a human-readable one-line summary of the invoice."""
+    subtotal = calculate_subtotal(invoice)
+    status = "PAID" if invoice.paid_on else ("OVERDUE" if is_overdue(invoice) else "PENDING")
+    return f"{invoice.id} | {invoice.customer_name} | ${subtotal:.2f} | {status}"
diff --git a/priv/combined_metrics/samples/naming_conventions/uses_snake_case_for_methods/bad/cart.rb b/priv/combined_metrics/samples/naming_conventions/uses_snake_case_for_methods/bad/cart.rb
new file mode 100644
index 0000000..bcd9499
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/uses_snake_case_for_methods/bad/cart.rb
@@ -0,0 +1,54 @@
+class ShoppingCart
+  attr_reader :lineItems, :customerId, :couponCode
+
+  def initialize(customerId)
+    @customerId = customerId
+    @lineItems = []
+    @couponCode = nil
+  end
+
+  # camelCase method names violate Ruby convention
+  def addItem(productId, quantity = 1, unitPrice:)
+    existing = findLineItem(productId)
+
+    if existing
+      existing.incrementQuantity(quantity)
+    else
+      @lineItems << LineItem.new(productId: productId, quantity: quantity, unitPrice: unitPrice)
+    end
+
+    self
+  end
+
+  def removeItem(productId)
+    @lineItems.reject! { |item| item.productId == productId }
+    self
+  end
+
+  def applyCouponCode(code)
+    @couponCode = code
+    self
+  end
+
+  def calculateSubtotal
+    lineItems.sum(&:lineTotal)
+  end
+
+  def calculateTax(rate:)
+    calculateSubtotal * rate
+  end
+
+  def totalItemCount
+    lineItems.sum(&:quantity)
+  end
+
+  def isEmpty
+    lineItems.empty?
+  end
+
+  private
+
+  def findLineItem(productId)
+    lineItems.find { |item| item.productId == productId }
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/uses_snake_case_for_methods/good/cart.rb b/priv/combined_metrics/samples/naming_conventions/uses_snake_case_for_methods/good/cart.rb
new file mode 100644
index 0000000..8156e49
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/uses_snake_case_for_methods/good/cart.rb
@@ -0,0 +1,53 @@
+class ShoppingCart
+  attr_reader :line_items, :customer_id, :coupon_code
+
+  def initialize(customer_id)
+    @customer_id = customer_id
+    @line_items = []
+    @coupon_code = nil
+  end
+
+  def add_item(product_id, quantity: 1, unit_price:)
+    existing = find_line_item(product_id)
+
+    if existing
+      existing.increment_quantity(quantity)
+    else
+      @line_items << LineItem.new(product_id: product_id, quantity: quantity, unit_price: unit_price)
+    end
+
+    self
+  end
+
+  def remove_item(product_id)
+    @line_items.reject! { |item| item.product_id == product_id }
+    self
+  end
+
+  def apply_coupon_code(code)
+    @coupon_code = code
+    self
+  end
+
+  def calculate_subtotal
+    line_items.sum(&:line_total)
+  end
+
+  def calculate_tax(rate:)
+    calculate_subtotal * rate
+  end
+
+  def total_item_count
+    line_items.sum(&:quantity)
+  end
+
+  def empty?
+    line_items.empty?
+  end
+
+  private
+
+  def find_line_item(product_id)
+    line_items.find { |item| item.product_id == product_id }
+  end
+end
diff --git a/priv/combined_metrics/samples/naming_conventions/verb_phrase_distinguishes_mutation_vs_return/bad/ProductInventory.kt b/priv/combined_metrics/samples/naming_conventions/verb_phrase_distinguishes_mutation_vs_return/bad/ProductInventory.kt
new file mode 100644
index 0000000..ce21cb7
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/verb_phrase_distinguishes_mutation_vs_return/bad/ProductInventory.kt
@@ -0,0 +1,39 @@
+package com.example.inventory
+
+data class StockItem(val productId: String, val sku: String, var quantity: Int, val warehouseId: String)
+
+class ProductInventory(private val items: MutableList<StockItem> = mutableListOf()) {
+
+    // "add" is fine here
+    fun add(item: StockItem) {
+        items.add(item)
+    }
+
+    // "remove" is fine here
+    fun remove(productId: String) {
+        items.removeIf { it.productId == productId }
+    }
+
+    // "sort" suggests in-place mutation — but this actually returns a new list
+    // Caller might expect the original `items` to be reordered
+    fun sort(): List<StockItem> = items.sortedBy { it.sku }
+
+    // "filter" suggests in-place removal — but this returns a new list
+    // Misleading: callers might think items is reduced
+    fun filter(warehouseId: String): List<StockItem> =
+        items.filter { it.warehouseId == warehouseId }
+
+    // "double" could mean either mutation or return — ambiguous
+    fun double(): List<StockItem> =
+        items.map { it.copy(quantity = it.quantity * 2) }
+
+    // "group" is ambiguous — rearranges or returns?
+    fun group(): Map<String, List<StockItem>> =
+        items.groupBy { it.warehouseId }
+
+    // "adjustQuantity" sounds like mutation — but this returns a new item copy instead
+    fun adjustQuantity(item: StockItem, delta: Int): StockItem =
+        item.copy(quantity = item.quantity + delta)
+
+    fun count(): Int = items.size
+}
diff --git a/priv/combined_metrics/samples/naming_conventions/verb_phrase_distinguishes_mutation_vs_return/good/ProductInventory.kt b/priv/combined_metrics/samples/naming_conventions/verb_phrase_distinguishes_mutation_vs_return/good/ProductInventory.kt
new file mode 100644
index 0000000..d63f0db
--- /dev/null
+++ b/priv/combined_metrics/samples/naming_conventions/verb_phrase_distinguishes_mutation_vs_return/good/ProductInventory.kt
@@ -0,0 +1,39 @@
+package com.example.inventory
+
+data class StockItem(val productId: String, val sku: String, var quantity: Int, val warehouseId: String)
+
+class ProductInventory(private val items: MutableList<StockItem> = mutableListOf()) {
+
+    // Mutates the list in place — verb with no qualifier (imperative mood)
+    fun add(item: StockItem) {
+        items.add(item)
+    }
+
+    // Mutates the list in place — removes matching entry
+    fun remove(productId: String) {
+        items.removeIf { it.productId == productId }
+    }
+
+    // Mutates quantity of an existing item — imperative verb
+    fun adjustQuantity(productId: String, delta: Int) {
+        items.find { it.productId == productId }?.quantity =
+            (items.find { it.productId == productId }?.quantity ?: 0) + delta
+    }
+
+    // Returns a new sorted list without touching the original — past-tense / adjective form
+    fun sortedBySku(): List<StockItem> = items.sortedBy { it.sku }
+
+    // Returns a new filtered list — past-tense form signals no mutation
+    fun filteredByWarehouse(warehouseId: String): List<StockItem> =
+        items.filter { it.warehouseId == warehouseId }
+
+    // Returns a new list with quantities doubled — "doubled" signals a return value
+    fun doubledQuantities(): List<StockItem> =
+        items.map { it.copy(quantity = it.quantity * 2) }
+
+    // Returns a transformed snapshot — "grouped" signals a new structure returned
+    fun groupedByWarehouse(): Map<String, List<StockItem>> =
+        items.groupBy { it.warehouseId }
+
+    fun count(): Int = items.size
+}
diff --git a/priv/combined_metrics/samples/scope_and_assignment/declared_close_to_use/bad/processor.ex b/priv/combined_metrics/samples/scope_and_assignment/declared_close_to_use/bad/processor.ex
new file mode 100644
index 0000000..8af6c54
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/declared_close_to_use/bad/processor.ex
@@ -0,0 +1,94 @@
+defmodule Pipeline.Processor do
+  @moduledoc """
+  Data processing pipeline — BAD: variables declared far from their use.
+  """
+
+  def process_order(order) do
+    # All variables declared upfront, used much later
+    tax_rate = 0.08
+    discount_threshold = 100
+    premium_discount = 0.15
+    standard_discount = 0.05
+    currency = "USD"
+    max_items = 50
+    min_price = 0.01
+
+    items = order.items
+
+    validated =
+      Enum.filter(items, fn item ->
+        item.quantity > 0 and item.price >= min_price and length(items) <= max_items
+      end)
+
+    subtotal =
+      Enum.reduce(validated, 0, fn item, acc ->
+        acc + item.price * item.quantity
+      end)
+
+    # discount_threshold, premium_discount, standard_discount declared ~15 lines ago
+    discount =
+      if subtotal > discount_threshold do
+        subtotal * premium_discount
+      else
+        subtotal * standard_discount
+      end
+
+    discounted = subtotal - discount
+
+    # tax_rate declared ~20 lines ago
+    tax = discounted * tax_rate
+
+    total = discounted + tax
+
+    # currency declared ~22 lines ago
+    %{total: total, currency: currency, item_count: length(validated)}
+  end
+
+  def process_batch(orders) do
+    # Variables declared at top, used at different depths
+    batch_id = System.unique_integer([:positive])
+    started_at = DateTime.utc_now()
+    max_batch_size = 200
+    error_tag = :batch_error
+
+    if length(orders) > max_batch_size do
+      # error_tag used for the first time ~7 lines after declaration
+      {error_tag, :too_large}
+    else
+      results =
+        Enum.map(orders, fn order ->
+          case process_order(order) do
+            %{total: t} when t > 0 -> {:ok, t}
+            # error_tag used again here, many lines from declaration
+            _ -> {error_tag, order.id}
+          end
+        end)
+
+      # started_at and batch_id used ~20 lines after declaration
+      successes = Enum.count(results, &match?({:ok, _}, &1))
+
+      %{
+        batch_id: batch_id,
+        started_at: started_at,
+        total: length(orders),
+        successes: successes
+      }
+    end
+  end
+
+  def summarize(results) do
+    label = "Summary"
+    separator = String.duplicate("-", 40)
+    format = :detailed
+
+    lines = Enum.map(results, fn {status, val} -> "#{status}: #{val}" end)
+    body = Enum.join(lines, "\n")
+
+    # label, separator, format all declared ~8 lines ago
+    if format == :detailed do
+      "#{label}\n#{separator}\n#{body}"
+    else
+      "#{label}: #{length(lines)} results"
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/scope_and_assignment/declared_close_to_use/config.yml b/priv/combined_metrics/samples/scope_and_assignment/declared_close_to_use/config.yml
new file mode 100644
index 0000000..eb039d3
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/declared_close_to_use/config.yml
@@ -0,0 +1 @@
+doc: "Variables should be declared near their first use, not hoisted to the top of the function."
diff --git a/priv/combined_metrics/samples/scope_and_assignment/declared_close_to_use/good/processor.ex b/priv/combined_metrics/samples/scope_and_assignment/declared_close_to_use/good/processor.ex
new file mode 100644
index 0000000..83f3ee0
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/declared_close_to_use/good/processor.ex
@@ -0,0 +1,76 @@
+defmodule Pipeline.Processor do
+  @moduledoc """
+  Data processing pipeline — GOOD: variables declared immediately before use.
+  """
+
+  def process_order(order) do
+    min_price = 0.01
+    max_items = 50
+
+    validated =
+      Enum.filter(order.items, fn item ->
+        item.quantity > 0 and item.price >= min_price and length(order.items) <= max_items
+      end)
+
+    subtotal =
+      Enum.reduce(validated, 0, fn item, acc ->
+        acc + item.price * item.quantity
+      end)
+
+    discount_threshold = 100
+    premium_discount = 0.15
+    standard_discount = 0.05
+
+    discount =
+      if subtotal > discount_threshold do
+        subtotal * premium_discount
+      else
+        subtotal * standard_discount
+      end
+
+    discounted = subtotal - discount
+    tax_rate = 0.08
+    tax = discounted * tax_rate
+    total = discounted + tax
+
+    currency = "USD"
+    %{total: total, currency: currency, item_count: length(validated)}
+  end
+
+  def process_batch(orders) do
+    max_batch_size = 200
+
+    if length(orders) > max_batch_size do
+      {:batch_error, :too_large}
+    else
+      results =
+        Enum.map(orders, fn order ->
+          case process_order(order) do
+            %{total: t} when t > 0 -> {:ok, t}
+            _ -> {:batch_error, order.id}
+          end
+        end)
+
+      successes = Enum.count(results, &match?({:ok, _}, &1))
+      batch_id = System.unique_integer([:positive])
+      started_at = DateTime.utc_now()
+
+      %{
+        batch_id: batch_id,
+        started_at: started_at,
+        total: length(orders),
+        successes: successes
+      }
+    end
+  end
+
+  def summarize(results) do
+    lines = Enum.map(results, fn {status, val} -> "#{status}: #{val}" end)
+    body = Enum.join(lines, "\n")
+
+    label = "Summary"
+    separator = String.duplicate("-", 40)
+
+    "#{label}\n#{separator}\n#{body}"
+  end
+end
diff --git a/priv/combined_metrics/samples/scope_and_assignment/mutated_after_initial_assignment/bad/aggregator.ex b/priv/combined_metrics/samples/scope_and_assignment/mutated_after_initial_assignment/bad/aggregator.ex
new file mode 100644
index 0000000..e3bd7b1
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/mutated_after_initial_assignment/bad/aggregator.ex
@@ -0,0 +1,75 @@
+defmodule Data.Aggregator do
+  @moduledoc """
+  Data aggregation — BAD: variables reassigned multiple times without reduce.
+  """
+
+  def aggregate_sales(transactions) do
+    total = 0
+    count = 0
+    max_sale = 0
+    min_sale = nil
+
+    total = total + Enum.sum(Enum.map(transactions, & &1.amount))
+    count = count + length(transactions)
+
+    max_sale = Enum.max_by(transactions, & &1.amount).amount
+    min_sale = Enum.min_by(transactions, & &1.amount).amount
+
+    average = if count > 0, do: total / count, else: 0
+
+    %{total: total, count: count, max: max_sale, min: min_sale, average: average}
+  end
+
+  def group_by_category(items) do
+    result = %{}
+
+    electronics = Enum.filter(items, &(&1.category == :electronics))
+    result = Map.put(result, :electronics, electronics)
+
+    clothing = Enum.filter(items, &(&1.category == :clothing))
+    result = Map.put(result, :clothing, clothing)
+
+    food = Enum.filter(items, &(&1.category == :food))
+    result = Map.put(result, :food, food)
+
+    other = Enum.filter(items, &(&1.category not in [:electronics, :clothing, :food]))
+    result = Map.put(result, :other, other)
+
+    result
+  end
+
+  def compute_stats(numbers) do
+    stats = %{}
+
+    sum = Enum.sum(numbers)
+    stats = Map.put(stats, :sum, sum)
+
+    count = length(numbers)
+    stats = Map.put(stats, :count, count)
+
+    mean = if count > 0, do: sum / count, else: 0
+    stats = Map.put(stats, :mean, mean)
+
+    sorted = Enum.sort(numbers)
+    median = Enum.at(sorted, div(count, 2))
+    stats = Map.put(stats, :median, median)
+
+    stats
+  end
+
+  def tally_results(events) do
+    passed = 0
+    failed = 0
+    skipped = 0
+
+    passed = Enum.count(events, &(&1.status == :passed))
+    failed = Enum.count(events, &(&1.status == :failed))
+    skipped = Enum.count(events, &(&1.status == :skipped))
+
+    total = passed + failed + skipped
+
+    pass_rate = if total > 0, do: passed / total * 100, else: 0
+
+    %{passed: passed, failed: failed, skipped: skipped, pass_rate: pass_rate}
+  end
+end
diff --git a/priv/combined_metrics/samples/scope_and_assignment/mutated_after_initial_assignment/config.yml b/priv/combined_metrics/samples/scope_and_assignment/mutated_after_initial_assignment/config.yml
new file mode 100644
index 0000000..9e5b2f2
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/mutated_after_initial_assignment/config.yml
@@ -0,0 +1 @@
+doc: "Variables should not be reassigned after their initial value — prefer introducing a new name."
diff --git a/priv/combined_metrics/samples/scope_and_assignment/mutated_after_initial_assignment/good/aggregator.ex b/priv/combined_metrics/samples/scope_and_assignment/mutated_after_initial_assignment/good/aggregator.ex
new file mode 100644
index 0000000..084d8b9
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/mutated_after_initial_assignment/good/aggregator.ex
@@ -0,0 +1,55 @@
+defmodule Data.Aggregator do
+  @moduledoc """
+  Data aggregation — GOOD: uses Enum.reduce and immutable transformations.
+  """
+
+  def aggregate_sales(transactions) do
+    %{total: total, count: count, max: max_sale, min: min_sale} =
+      Enum.reduce(transactions, %{total: 0, count: 0, max: 0, min: nil}, fn t, acc ->
+        %{
+          total: acc.total + t.amount,
+          count: acc.count + 1,
+          max: max(acc.max, t.amount),
+          min: if(is_nil(acc.min), do: t.amount, else: min(acc.min, t.amount))
+        }
+      end)
+
+    average = if count > 0, do: total / count, else: 0
+
+    %{total: total, count: count, max: max_sale, min: min_sale, average: average}
+  end
+
+  def group_by_category(items) do
+    Enum.reduce(items, %{electronics: [], clothing: [], food: [], other: []}, fn item, acc ->
+      key =
+        if item.category in [:electronics, :clothing, :food],
+          do: item.category,
+          else: :other
+
+      Map.update!(acc, key, &[item | &1])
+    end)
+  end
+
+  def compute_stats(numbers) do
+    count = length(numbers)
+    sum = Enum.sum(numbers)
+    mean = if count > 0, do: sum / count, else: 0
+
+    sorted = Enum.sort(numbers)
+    median = Enum.at(sorted, div(count, 2))
+
+    %{sum: sum, count: count, mean: mean, median: median}
+  end
+
+  def tally_results(events) do
+    %{passed: passed, failed: failed, skipped: skipped} =
+      Enum.reduce(events, %{passed: 0, failed: 0, skipped: 0}, fn event, acc ->
+        Map.update!(acc, event.status, &(&1 + 1))
+      end)
+
+    total = passed + failed + skipped
+    pass_rate = if total > 0, do: passed / total * 100, else: 0
+
+    %{passed: passed, failed: failed, skipped: skipped, pass_rate: pass_rate}
+  end
+end
diff --git a/priv/combined_metrics/samples/scope_and_assignment/no_var_declarations/bad/search_index.js b/priv/combined_metrics/samples/scope_and_assignment/no_var_declarations/bad/search_index.js
new file mode 100644
index 0000000..7c327ef
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/no_var_declarations/bad/search_index.js
@@ -0,0 +1,64 @@
+var STOP_WORDS = ["the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for"];
+
+function tokenize(text) {
+  var normalized = text.toLowerCase().replace(/[^\w\s]/g, " ");
+  var parts = normalized.split(/\s+/);
+  var result = [];
+  for (var i = 0; i < parts.length; i++) {
+    var token = parts[i];
+    if (token.length > 1 && STOP_WORDS.indexOf(token) === -1) {
+      result.push(token);
+    }
+  }
+  return result;
+}
+
+function buildIndex(documents) {
+  var index = {};
+
+  for (var d = 0; d < documents.length; d++) {
+    var doc = documents[d];
+    var tokens = tokenize(doc.content);
+    var seen = {};
+
+    for (var t = 0; t < tokens.length; t++) {
+      var token = tokens[t];
+      if (!seen[token]) {
+        seen[token] = true;
+        if (!index[token]) {
+          index[token] = [];
+        }
+        index[token].push(doc.id);
+      }
+    }
+  }
+
+  return index;
+}
+
+function search(index, query) {
+  var queryTokens = tokenize(query);
+  if (queryTokens.length === 0) return [];
+
+  var results = null;
+
+  for (var i = 0; i < queryTokens.length; i++) {
+    var token = queryTokens[i];
+    var matches = index[token] || [];
+    if (results === null) {
+      results = matches.slice();
+    } else {
+      var filtered = [];
+      for (var j = 0; j < results.length; j++) {
+        if (matches.indexOf(results[j]) !== -1) {
+          filtered.push(results[j]);
+        }
+      }
+      results = filtered;
+    }
+  }
+
+  return results || [];
+}
+
+export { buildIndex, search, tokenize };
diff --git a/priv/combined_metrics/samples/scope_and_assignment/no_var_declarations/good/search_index.js b/priv/combined_metrics/samples/scope_and_assignment/no_var_declarations/good/search_index.js
new file mode 100644
index 0000000..deae759
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/no_var_declarations/good/search_index.js
@@ -0,0 +1,57 @@
+const STOP_WORDS = new Set(["the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for"]);
+
+function tokenize(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^\w\s]/g, " ")
+    .split(/\s+/)
+    .filter((token) => token.length > 1 && !STOP_WORDS.has(token));
+}
+
+function buildIndex(documents) {
+  const index = new Map();
+
+  for (const doc of documents) {
+    const tokens = tokenize(doc.content);
+    const uniqueTokens = new Set(tokens);
+
+    for (const token of uniqueTokens) {
+      if (!index.has(token)) {
+        index.set(token, []);
+      }
+      index.get(token).push(doc.id);
+    }
+  }
+
+  return index;
+}
+
+function search(index, query) {
+  const queryTokens = tokenize(query);
+
+  if (queryTokens.length === 0) return [];
+
+  const matchingSets = queryTokens.map((token) => new Set(index.get(token) ?? []));
+
+  const [first, ...rest] = matchingSets;
+  const results = [...first].filter((docId) =>
+    rest.every((set) => set.has(docId))
+  );
+
+  return results;
+}
+
+function rankResults(results, index, queryTokens) {
+  const scores = results.map((docId) => {
+    const score = queryTokens.reduce((total, token) => {
+      const docs = index.get(token) ?? [];
+      const termFrequency = docs.filter((id) => id === docId).length;
+      return total + termFrequency;
+    }, 0);
+    return { docId, score };
+  });
+
+  return scores.sort((a, b) => b.score - a.score).map((r) => r.docId);
+}
+
+export { buildIndex, search, rankResults, tokenize };
diff --git a/priv/combined_metrics/samples/scope_and_assignment/prefers_val_over_var/bad/ReportGenerator.kt b/priv/combined_metrics/samples/scope_and_assignment/prefers_val_over_var/bad/ReportGenerator.kt
new file mode 100644
index 0000000..9bd9a94
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/prefers_val_over_var/bad/ReportGenerator.kt
@@ -0,0 +1,61 @@
+package com.example.reporting
+
+import java.time.LocalDate
+import java.math.BigDecimal
+
+data class SalesReport(
+    val period: DateRange,
+    val totalRevenue: BigDecimal,
+    val orderCount: Int,
+    val averageOrderValue: BigDecimal,
+    val topProducts: List<ProductSummary>
+)
+
+class ReportGenerator(
+    private val orderRepository: OrderRepository,
+    private val productRepository: ProductRepository
+) {
+
+    fun generateSalesReport(from: LocalDate, to: LocalDate): SalesReport {
+        // var used even though these values are never reassigned
+        var period = DateRange(from, to)
+        var orders = orderRepository.findInRange(from, to)
+        var totalRevenue = orders.sumOf { it.total }
+        var orderCount = orders.size
+        var averageOrderValue: BigDecimal
+
+        if (orderCount > 0) {
+            averageOrderValue = totalRevenue.divide(BigDecimal.valueOf(orderCount.toLong()))
+        } else {
+            averageOrderValue = BigDecimal.ZERO
+        }
+
+        var productFrequency = orders
+            .flatMap { it.lineItems }
+            .groupingBy { it.productId }
+            .eachCount()
+
+        var topProductIds = productFrequency.entries
+            .sortedByDescending { it.value }
+            .take(5)
+            .map { it.key }
+
+        var topProducts = topProductIds
+            .mapNotNull { productRepository.findById(it) }
+            .map { ProductSummary(it.id, it.name, productFrequency[it.id] ?: 0) }
+
+        return SalesReport(period, totalRevenue, orderCount, averageOrderValue, topProducts)
+    }
+
+    fun dailyTotals(from: LocalDate, to: LocalDate): Map<LocalDate, BigDecimal> {
+        var orders = orderRepository.findInRange(from, to)
+        var result = mutableMapOf<LocalDate, BigDecimal>()
+        // Manual accumulation with var when groupBy + mapValues would suffice
+        for (order in orders) {
+            var date = order.placedAt.toLocalDate()
+            var current = result[date] ?: BigDecimal.ZERO
+            result[date] = current.add(order.total)
+        }
+        return result
+    }
+}
diff --git a/priv/combined_metrics/samples/scope_and_assignment/prefers_val_over_var/good/ReportGenerator.kt b/priv/combined_metrics/samples/scope_and_assignment/prefers_val_over_var/good/ReportGenerator.kt
new file mode 100644
index 0000000..51618e2
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/prefers_val_over_var/good/ReportGenerator.kt
@@ -0,0 +1,54 @@
+package com.example.reporting
+
+import java.time.LocalDate
+import java.math.BigDecimal
+
+data class SalesReport(
+    val period: DateRange,
+    val totalRevenue: BigDecimal,
+    val orderCount: Int,
+    val averageOrderValue: BigDecimal,
+    val topProducts: List<ProductSummary>
+)
+
+class ReportGenerator(
+    private val orderRepository: OrderRepository,
+    private val productRepository: ProductRepository
+) {
+
+    fun generateSalesReport(from: LocalDate, to: LocalDate): SalesReport {
+        val period = DateRange(from, to)
+        val orders = orderRepository.findInRange(from, to)
+
+        // val throughout — nothing is reassigned
+        val totalRevenue = orders.sumOf { it.total }
+        val orderCount = orders.size
+        val averageOrderValue = if (orderCount > 0)
+            totalRevenue.divide(BigDecimal.valueOf(orderCount.toLong()))
+        else
+            BigDecimal.ZERO
+
+        val productFrequency = orders
+            .flatMap { it.lineItems }
+            .groupingBy { it.productId }
+            .eachCount()
+
+        val topProductIds = productFrequency.entries
+            .sortedByDescending { it.value }
+            .take(5)
+            .map { it.key }
+
+        val topProducts = topProductIds
+            .mapNotNull { productRepository.findById(it) }
+            .map { ProductSummary(it.id, it.name, productFrequency[it.id] ?: 0) }
+
+        return SalesReport(period, totalRevenue, orderCount, averageOrderValue, topProducts)
+    }
+
+    fun dailyTotals(from: LocalDate, to: LocalDate): Map<LocalDate, BigDecimal> {
+        val orders = orderRepository.findInRange(from, to)
+        // val for result — computed once, not mutated
+        return orders.groupBy { it.placedAt.toLocalDate() }
+            .mapValues { (_, dayOrders) -> dayOrders.sumOf { it.total } }
+    }
+}
diff --git a/priv/combined_metrics/samples/scope_and_assignment/reassigned_multiple_times/bad/transformer.ex b/priv/combined_metrics/samples/scope_and_assignment/reassigned_multiple_times/bad/transformer.ex
new file mode 100644
index 0000000..d122ef4
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/reassigned_multiple_times/bad/transformer.ex
@@ -0,0 +1,49 @@
+defmodule Data.Transformer do
+  @moduledoc """
+  Data transformation — BAD: same variable name reassigned many times in one function.
+  """
+
+  def normalize_user(raw) do
+    data = raw
+    data = Map.put(data, :name, String.trim(data.name))
+    data = Map.put(data, :email, String.downcase(data.email))
+    data = Map.put(data, :email, String.trim(data.email))
+    data = Map.put(data, :age, max(data.age, 0))
+    data = Map.put(data, :role, data.role || :guest)
+    data = Map.delete(data, :password)
+    data = Map.put(data, :normalized_at, DateTime.utc_now())
+    data
+  end
+
+  def format_product(product) do
+    result = product
+    result = Map.put(result, :title, String.trim(result.title))
+    result = Map.put(result, :title, String.capitalize(result.title))
+    result = Map.put(result, :price, Float.round(result.price * 1.0, 2))
+    result = Map.put(result, :sku, String.upcase(result.sku))
+    result = Map.put(result, :sku, String.replace(result.sku, " ", "-"))
+    result = Map.put(result, :available, result.stock > 0)
+    result
+  end
+
+  def prepare_event(event) do
+    payload = event
+    payload = Map.put(payload, :type, Atom.to_string(payload.type))
+    payload = Map.put(payload, :type, String.upcase(payload.type))
+    payload = Map.put(payload, :timestamp, DateTime.to_unix(payload.timestamp))
+    payload = Map.put(payload, :source, payload.source || "unknown")
+    payload = Map.put(payload, :id, to_string(payload.id))
+    payload = Map.put(payload, :id, String.pad_leading(payload.id, 8, "0"))
+    payload
+  end
+
+  def clean_address(address) do
+    addr = address
+    addr = Map.put(addr, :street, String.trim(addr.street))
+    addr = Map.put(addr, :city, String.trim(addr.city))
+    addr = Map.put(addr, :city, String.capitalize(addr.city))
+    addr = Map.put(addr, :zip, String.replace(addr.zip, " ", ""))
+    addr = Map.put(addr, :country, String.upcase(addr.country))
+    addr
+  end
+end
diff --git a/priv/combined_metrics/samples/scope_and_assignment/reassigned_multiple_times/config.yml b/priv/combined_metrics/samples/scope_and_assignment/reassigned_multiple_times/config.yml
new file mode 100644
index 0000000..6edf336
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/reassigned_multiple_times/config.yml
@@ -0,0 +1 @@
+doc: "A variable reassigned many times is a sign the name is too generic or the function does too much."
diff --git a/priv/combined_metrics/samples/scope_and_assignment/reassigned_multiple_times/good/transformer.ex b/priv/combined_metrics/samples/scope_and_assignment/reassigned_multiple_times/good/transformer.ex
new file mode 100644
index 0000000..d92c691
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/reassigned_multiple_times/good/transformer.ex
@@ -0,0 +1,47 @@
+defmodule Data.Transformer do
+  @moduledoc """
+  Data transformation — GOOD: each step uses pipes or descriptive bindings.
+  """
+
+  def normalize_user(raw) do
+    raw
+    |> Map.put(:name, String.trim(raw.name))
+    |> Map.put(:email, raw.email |> String.downcase() |> String.trim())
+    |> Map.put(:age, max(raw.age, 0))
+    |> Map.put(:role, raw.role || :guest)
+    |> Map.delete(:password)
+    |> Map.put(:normalized_at, DateTime.utc_now())
+  end
+
+  def format_product(product) do
+    normalized_title = product.title |> String.trim() |> String.capitalize()
+    normalized_sku = product.sku |> String.upcase() |> String.replace(" ", "-")
+    rounded_price = Float.round(product.price * 1.0, 2)
+
+    product
+    |> Map.put(:title, normalized_title)
+    |> Map.put(:sku, normalized_sku)
+    |> Map.put(:price, rounded_price)
+    |> Map.put(:available, product.stock > 0)
+  end
+
+  def prepare_event(event) do
+    event_type = event.type |> Atom.to_string() |> String.upcase()
+    unix_timestamp = DateTime.to_unix(event.timestamp)
+    padded_id = event.id |> to_string() |> String.pad_leading(8, "0")
+
+    event
+    |> Map.put(:type, event_type)
+    |> Map.put(:timestamp, unix_timestamp)
+    |> Map.put(:source, event.source || "unknown")
+    |> Map.put(:id, padded_id)
+  end
+
+  def clean_address(address) do
+    address
+    |> Map.put(:street, String.trim(address.street))
+    |> Map.put(:city, address.city |> String.trim() |> String.capitalize())
+    |> Map.put(:zip, String.replace(address.zip, " ", ""))
+    |> Map.put(:country, String.upcase(address.country))
+  end
+end
diff --git a/priv/combined_metrics/samples/scope_and_assignment/scope_is_minimal/bad/handler.ex b/priv/combined_metrics/samples/scope_and_assignment/scope_is_minimal/bad/handler.ex
new file mode 100644
index 0000000..f299313
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/scope_is_minimal/bad/handler.ex
@@ -0,0 +1,71 @@
+defmodule Web.Handler do
+  @moduledoc """
+  Request handler — BAD: variables bound in outer scope and passed deep into nested blocks.
+  """
+
+  def handle_request(conn, params) do
+    user_id = conn.assigns.current_user.id
+    request_id = conn.assigns.request_id
+    ip_address = conn.remote_ip |> Tuple.to_list() |> Enum.join(".")
+    timestamp = DateTime.utc_now()
+    log_prefix = "[#{request_id}]"
+
+    action = params["action"]
+    resource = params["resource"]
+    payload = params["data"]
+
+    # user_id, ip_address, timestamp, log_prefix all carried far down
+    case action do
+      "create" ->
+        case validate_payload(payload) do
+          {:ok, validated} ->
+            case check_permissions(user_id, resource, :write) do
+              :allowed ->
+                # log_prefix, timestamp, ip_address passed even deeper
+                case persist(resource, validated, user_id) do
+                  {:ok, record} ->
+                    log_access(log_prefix, user_id, ip_address, timestamp, :create, :success)
+                    {:ok, record}
+
+                  {:error, reason} ->
+                    log_access(log_prefix, user_id, ip_address, timestamp, :create, :failure)
+                    {:error, reason}
+                end
+
+              :denied ->
+                log_access(log_prefix, user_id, ip_address, timestamp, :create, :denied)
+                {:error, :forbidden}
+            end
+
+          {:error, errors} ->
+            {:error, {:validation, errors}}
+        end
+
+      "delete" ->
+        case check_permissions(user_id, resource, :delete) do
+          :allowed ->
+            case persist_delete(resource, user_id) do
+              {:ok, _} ->
+                log_access(log_prefix, user_id, ip_address, timestamp, :delete, :success)
+                :ok
+
+              {:error, reason} ->
+                log_access(log_prefix, user_id, ip_address, timestamp, :delete, :failure)
+                {:error, reason}
+            end
+
+          :denied ->
+            {:error, :forbidden}
+        end
+
+      _ ->
+        {:error, :unknown_action}
+    end
+  end
+
+  defp validate_payload(payload), do: {:ok, payload}
+  defp check_permissions(_uid, _res, _mode), do: :allowed
+  defp persist(_res, data, _uid), do: {:ok, data}
+  defp persist_delete(_res, _uid), do: {:ok, nil}
+  defp log_access(_prefix, _uid, _ip, _ts, _action, _result), do: :ok
+end
diff --git a/priv/combined_metrics/samples/scope_and_assignment/scope_is_minimal/config.yml b/priv/combined_metrics/samples/scope_and_assignment/scope_is_minimal/config.yml
new file mode 100644
index 0000000..463fb01
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/scope_is_minimal/config.yml
@@ -0,0 +1 @@
+doc: "Variables should be scoped as narrowly as possible — not declared at a wider scope than needed."
diff --git a/priv/combined_metrics/samples/scope_and_assignment/scope_is_minimal/good/handler.ex b/priv/combined_metrics/samples/scope_and_assignment/scope_is_minimal/good/handler.ex
new file mode 100644
index 0000000..aaf501e
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/scope_is_minimal/good/handler.ex
@@ -0,0 +1,62 @@
+defmodule Web.Handler do
+  @moduledoc """
+  Request handler — GOOD: variables bound close to where they are needed.
+  """
+
+  def handle_request(conn, params) do
+    action = params["action"]
+    resource = params["resource"]
+    payload = params["data"]
+
+    case action do
+      "create" -> handle_create(conn, resource, payload)
+      "delete" -> handle_delete(conn, resource)
+      _ -> {:error, :unknown_action}
+    end
+  end
+
+  defp handle_create(conn, resource, payload) do
+    with {:ok, validated} <- validate_payload(payload),
+         :allowed <- check_permissions(conn.assigns.current_user.id, resource, :write),
+         {:ok, record} <- persist(resource, validated, conn.assigns.current_user.id) do
+      log_access(conn, :create, :success)
+      {:ok, record}
+    else
+      {:error, {:validation, _} = err} -> {:error, err}
+      :denied -> {:error, :forbidden}
+      {:error, reason} ->
+        log_access(conn, :create, :failure)
+        {:error, reason}
+    end
+  end
+
+  defp handle_delete(conn, resource) do
+    user_id = conn.assigns.current_user.id
+
+    with :allowed <- check_permissions(user_id, resource, :delete),
+         {:ok, _} <- persist_delete(resource, user_id) do
+      log_access(conn, :delete, :success)
+      :ok
+    else
+      :denied -> {:error, :forbidden}
+      {:error, reason} ->
+        log_access(conn, :delete, :failure)
+        {:error, reason}
+    end
+  end
+
+  defp log_access(conn, action, result) do
+    request_id = conn.assigns.request_id
+    user_id = conn.assigns.current_user.id
+    ip_address = conn.remote_ip |> Tuple.to_list() |> Enum.join(".")
+    timestamp = DateTime.utc_now()
+
+    _ = "[#{request_id}] user=#{user_id} ip=#{ip_address} action=#{action} result=#{result} at=#{timestamp}"
+    :ok
+  end
+
+  defp validate_payload(payload), do: {:ok, payload}
+  defp check_permissions(_uid, _res, _mode), do: :allowed
+  defp persist(_res, data, _uid), do: {:ok, data}
+  defp persist_delete(_res, _uid), do: {:ok, nil}
+end
diff --git a/priv/combined_metrics/samples/scope_and_assignment/shadowed_by_inner_scope/bad/nested.ex b/priv/combined_metrics/samples/scope_and_assignment/shadowed_by_inner_scope/bad/nested.ex
new file mode 100644
index 0000000..e722ae9
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/shadowed_by_inner_scope/bad/nested.ex
@@ -0,0 +1,66 @@
+defmodule Data.Nested do
+  @moduledoc """
+  Nested data transformation — BAD: inner scopes shadow outer variable names.
+  """
+
+  def transform_catalog(catalog) do
+    items = catalog.items
+
+    # outer `item` variable
+    item = catalog.default_item
+
+    result =
+      Enum.map(items, fn item ->
+        # `item` shadows the outer `item` binding above
+        tags = item.tags
+
+        enriched =
+          Enum.map(tags, fn tag ->
+            # `tag` is fine, but reusing `item` inside map over tags shadows again
+            item = Map.put(item, :primary_tag, tag)
+            item
+          end)
+
+        %{id: item.id, enriched: enriched}
+      end)
+
+    {item, result}
+  end
+
+  def process_orders(user, orders) do
+    # outer `order`
+    order = List.first(orders)
+
+    summaries =
+      Enum.map(orders, fn order ->
+        # `order` shadows outer binding
+        lines =
+          Enum.map(order.line_items, fn item ->
+            # `item` is new here, but then rebound below
+            item = Map.put(item, :taxed_price, item.price * 1.08)
+            item
+          end)
+
+        Map.put(order, :lines, lines)
+      end)
+
+    %{user: user.id, first: order, summaries: summaries}
+  end
+
+  def flatten_groups(groups) do
+    # outer `group`
+    group = hd(groups)
+
+    all =
+      Enum.flat_map(groups, fn group ->
+        # `group` shadows outer
+        Enum.map(group.members, fn member ->
+          group = Map.take(group, [:id, :name])
+          # `group` shadowed again inside inner Enum.map
+          Map.put(member, :group, group)
+        end)
+      end)
+
+    {group.id, all}
+  end
+end
diff --git a/priv/combined_metrics/samples/scope_and_assignment/shadowed_by_inner_scope/config.yml b/priv/combined_metrics/samples/scope_and_assignment/shadowed_by_inner_scope/config.yml
new file mode 100644
index 0000000..78d6158
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/shadowed_by_inner_scope/config.yml
@@ -0,0 +1 @@
+doc: "Inner-scope names that shadow outer-scope names cause confusion about which value is in play."
diff --git a/priv/combined_metrics/samples/scope_and_assignment/shadowed_by_inner_scope/good/nested.ex b/priv/combined_metrics/samples/scope_and_assignment/shadowed_by_inner_scope/good/nested.ex
new file mode 100644
index 0000000..f5c8331
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/shadowed_by_inner_scope/good/nested.ex
@@ -0,0 +1,52 @@
+defmodule Data.Nested do
+  @moduledoc """
+  Nested data transformation — GOOD: inner scopes use distinct variable names.
+  """
+
+  def transform_catalog(catalog) do
+    default_item = catalog.default_item
+
+    enriched_items =
+      Enum.map(catalog.items, fn catalog_item ->
+        enriched_variants =
+          Enum.map(catalog_item.tags, fn tag ->
+            Map.put(catalog_item, :primary_tag, tag)
+          end)
+
+        %{id: catalog_item.id, enriched: enriched_variants}
+      end)
+
+    {default_item, enriched_items}
+  end
+
+  def process_orders(user, orders) do
+    first_order = List.first(orders)
+
+    summaries =
+      Enum.map(orders, fn order ->
+        taxed_lines =
+          Enum.map(order.line_items, fn line_item ->
+            Map.put(line_item, :taxed_price, line_item.price * 1.08)
+          end)
+
+        Map.put(order, :lines, taxed_lines)
+      end)
+
+    %{user: user.id, first: first_order, summaries: summaries}
+  end
+
+  def flatten_groups(groups) do
+    first_group = hd(groups)
+
+    all_members =
+      Enum.flat_map(groups, fn group ->
+        group_summary = Map.take(group, [:id, :name])
+
+        Enum.map(group.members, fn member ->
+          Map.put(member, :group, group_summary)
+        end)
+      end)
+
+    {first_group.id, all_members}
+  end
+end
diff --git a/priv/combined_metrics/samples/scope_and_assignment/used_only_once/bad/builder.ex b/priv/combined_metrics/samples/scope_and_assignment/used_only_once/bad/builder.ex
new file mode 100644
index 0000000..135c333
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/used_only_once/bad/builder.ex
@@ -0,0 +1,57 @@
+defmodule Query.Builder do
+  @moduledoc """
+  Query/struct builder — BAD: intermediate variables used exactly once and could be inlined.
+  """
+
+  def build_search_query(filters) do
+    base = from(p in "products")
+    with_category = where(base, category: ^filters.category)
+    with_price = where(with_category, [p], p.price <= ^filters.max_price)
+    with_stock = where(with_price, [p], p.stock > 0)
+    ordered = order_by(with_stock, :inserted_at)
+    limited = limit(ordered, ^filters.limit)
+    limited
+  end
+
+  def build_user_struct(attrs) do
+    name = String.trim(attrs.name)
+    email = String.downcase(attrs.email)
+    role = attrs.role || :guest
+    struct = %{name: name, email: email, role: role}
+    struct
+  end
+
+  def format_report(data) do
+    title = String.upcase(data.title)
+    header = "=== #{title} ==="
+    rows = Enum.map(data.rows, &format_row/1)
+    body = Enum.join(rows, "\n")
+    report = "#{header}\n#{body}"
+    report
+  end
+
+  def build_notification(event) do
+    subject = "Event: #{event.name}"
+    recipient = event.user.email
+    template = load_template(event.type)
+    rendered = render_template(template, event)
+    notification = %{subject: subject, to: recipient, body: rendered}
+    notification
+  end
+
+  def compose_url(base_url, path, query_params) do
+    encoded = URI.encode_query(query_params)
+    full_path = "#{path}?#{encoded}"
+    url = "#{base_url}#{full_path}"
+    url
+  end
+
+  defp format_row(row), do: "#{row.label}: #{row.value}"
+  defp load_template(type), do: "template_#{type}"
+  defp render_template(t, _e), do: t
+  defp from(q), do: q
+  defp where(q, _), do: q
+  defp where(q, _, _), do: q
+  defp order_by(q, _), do: q
+  defp limit(q, _), do: q
+end
diff --git a/priv/combined_metrics/samples/scope_and_assignment/used_only_once/config.yml b/priv/combined_metrics/samples/scope_and_assignment/used_only_once/config.yml
new file mode 100644
index 0000000..2984ae7
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/used_only_once/config.yml
@@ -0,0 +1 @@
+doc: "A variable used only once is a candidate for inlining — it rarely adds clarity over a direct expression."
diff --git a/priv/combined_metrics/samples/scope_and_assignment/used_only_once/good/builder.ex b/priv/combined_metrics/samples/scope_and_assignment/used_only_once/good/builder.ex
new file mode 100644
index 0000000..59ba959
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/used_only_once/good/builder.ex
@@ -0,0 +1,49 @@
+defmodule Query.Builder do
+  @moduledoc """
+  Query/struct builder — GOOD: intermediate results are inlined or piped.
+  """
+
+  def build_search_query(filters) do
+    from(p in "products")
+    |> where(category: ^filters.category)
+    |> where([p], p.price <= ^filters.max_price)
+    |> where([p], p.stock > 0)
+    |> order_by(:inserted_at)
+    |> limit(^filters.limit)
+  end
+
+  def build_user_struct(attrs) do
+    %{
+      name: String.trim(attrs.name),
+      email: String.downcase(attrs.email),
+      role: attrs.role || :guest
+    }
+  end
+
+  def format_report(data) do
+    header = "=== #{String.upcase(data.title)} ==="
+    body = data.rows |> Enum.map(&format_row/1) |> Enum.join("\n")
+    "#{header}\n#{body}"
+  end
+
+  def build_notification(event) do
+    %{
+      subject: "Event: #{event.name}",
+      to: event.user.email,
+      body: event.type |> load_template() |> render_template(event)
+    }
+  end
+
+  def compose_url(base_url, path, query_params) do
+    "#{base_url}#{path}?#{URI.encode_query(query_params)}"
+  end
+
+  defp format_row(row), do: "#{row.label}: #{row.value}"
+  defp load_template(type), do: "template_#{type}"
+  defp render_template(t, _e), do: t
+  defp from(q), do: q
+  defp where(q, _), do: q
+  defp where(q, _, _), do: q
+  defp order_by(q, _), do: q
+  defp limit(q, _), do: q
+end
diff --git a/priv/combined_metrics/samples/scope_and_assignment/uses_const_by_default/bad/invoice_calculator.js b/priv/combined_metrics/samples/scope_and_assignment/uses_const_by_default/bad/invoice_calculator.js
new file mode 100644
index 0000000..8161beb
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/uses_const_by_default/bad/invoice_calculator.js
@@ -0,0 +1,62 @@
+let TAX_RATES = {
+  US: 0.08,
+  CA: 0.13,
+  GB: 0.2,
+  DE: 0.19,
+};
+
+let DEFAULT_CURRENCY = "USD";
+
+function calculateLineTotal(item) {
+  let basePrice = item.unitPrice * item.quantity;
+  let discountAmount = item.discountPercent
+    ? basePrice * (item.discountPercent / 100)
+    : 0;
+  return basePrice - discountAmount;
+}
+
+function calculateSubtotal(items) {
+  let sum = 0;
+  for (let item of items) {
+    sum += calculateLineTotal(item);
+  }
+  return sum;
+}
+
+function calculateTax(subtotal, countryCode) {
+  let rate = TAX_RATES[countryCode] ?? 0;
+  return subtotal * rate;
+}
+
+function formatCurrency(amount, currency = DEFAULT_CURRENCY) {
+  let formatter = new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency,
+  });
+  return formatter.format(amount);
+}
+
+function buildInvoice(order) {
+  let items = order.lineItems.map((item) => ({
+    ...item,
+    lineTotal: calculateLineTotal(item),
+  }));
+
+  let subtotal = calculateSubtotal(items);
+  let tax = calculateTax(subtotal, order.countryCode);
+  let total = subtotal + tax;
+  let formattedTotal = formatCurrency(total, order.currency);
+
+  return {
+    orderId: order.id,
+    items,
+    subtotal,
+    tax,
+    total,
+    formattedTotal,
+    currency: order.currency ?? DEFAULT_CURRENCY,
+    issuedAt: new Date().toISOString(),
+  };
+}
+
+export { buildInvoice, calculateSubtotal, calculateTax, formatCurrency };
diff --git a/priv/combined_metrics/samples/scope_and_assignment/uses_const_by_default/good/invoice_calculator.js b/priv/combined_metrics/samples/scope_and_assignment/uses_const_by_default/good/invoice_calculator.js
new file mode 100644
index 0000000..bf88db0
--- /dev/null
+++ b/priv/combined_metrics/samples/scope_and_assignment/uses_const_by_default/good/invoice_calculator.js
@@ -0,0 +1,58 @@
+const TAX_RATES = {
+  US: 0.08,
+  CA: 0.13,
+  GB: 0.2,
+  DE: 0.19,
+};
+
+const DEFAULT_CURRENCY = "USD";
+
+function calculateLineTotal(item) {
+  const basePrice = item.unitPrice * item.quantity;
+  const discountAmount = item.discountPercent
+    ? basePrice * (item.discountPercent / 100)
+    : 0;
+  return basePrice - discountAmount;
+}
+
+function calculateSubtotal(items) {
+  return items.reduce((sum, item) => sum + calculateLineTotal(item), 0);
+}
+
+function calculateTax(subtotal, countryCode) {
+  const rate = TAX_RATES[countryCode] ?? 0;
+  return subtotal * rate;
+}
+
+function formatCurrency(amount, currency = DEFAULT_CURRENCY) {
+  const formatter = new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency,
+  });
+  return formatter.format(amount);
+}
+
+function buildInvoice(order) {
+  const items = order.lineItems.map((item) => ({
+    ...item,
+    lineTotal: calculateLineTotal(item),
+  }));
+
+  const subtotal = calculateSubtotal(items);
+  const tax = calculateTax(subtotal, order.countryCode);
+  const total = subtotal + tax;
+  const formattedTotal = formatCurrency(total, order.currency);
+
+  return {
+    orderId: order.id,
+    items,
+    subtotal,
+    tax,
+    total,
+    formattedTotal,
+    currency: order.currency ?? DEFAULT_CURRENCY,
+    issuedAt: new Date().toISOString(),
+  };
+}
+
+export { buildInvoice, calculateSubtotal, calculateTax, formatCurrency };
diff --git a/priv/combined_metrics/samples/testing/reasonable_test_to_code_ratio/bad/sparse_test.ex b/priv/combined_metrics/samples/testing/reasonable_test_to_code_ratio/bad/sparse_test.ex
new file mode 100644
index 0000000..fe2c9e3
--- /dev/null
+++ b/priv/combined_metrics/samples/testing/reasonable_test_to_code_ratio/bad/sparse_test.ex
@@ -0,0 +1,58 @@
+defmodule Math.CalculatorTest do
+  @moduledoc """
+  Tests for Calculator — BAD: many public functions but only 1-2 tests.
+  The Calculator module has add, subtract, multiply, divide, power, sqrt,
+  percentage, and clamp — but almost none are tested.
+  """
+  use ExUnit.Case
+
+  # Only two tests for a module with 8 public functions
+
+  test "add works" do
+    assert Math.Calculator.add(1, 2) == 3
+  end
+
+  test "divide" do
+    assert Math.Calculator.divide(10, 2) == {:ok, 5.0}
+  end
+
+  # subtract/2 — not tested
+  # multiply/2 — not tested
+  # power/2 — not tested
+  # sqrt/1 — not tested
+  # percentage/2 — not tested
+  # clamp/3 — not tested
+end
+
+defmodule Math.Calculator do
+  @moduledoc "Simple calculator with multiple public functions."
+
+  @spec add(number(), number()) :: number()
+  def add(a, b), do: a + b
+
+  @spec subtract(number(), number()) :: number()
+  def subtract(a, b), do: a - b
+
+  @spec multiply(number(), number()) :: number()
+  def multiply(a, b), do: a * b
+
+  @spec divide(number(), number()) :: {:ok, float()} | {:error, :division_by_zero}
+  def divide(_a, 0), do: {:error, :division_by_zero}
+  def divide(a, b), do: {:ok, a / b}
+
+  @spec power(number(), non_neg_integer()) :: number()
+  def power(base, exp), do: :math.pow(base, exp)
+
+  @spec sqrt(number()) :: {:ok, float()} | {:error, :negative_input}
+  def sqrt(n) when n < 0, do: {:error, :negative_input}
+  def sqrt(n), do: {:ok, :math.sqrt(n)}
+
+  @spec percentage(number(), number()) :: float()
+  def percentage(value, total) when total != 0, do: value / total * 100.0
+  def percentage(_value, 0), do: 0.0
+
+  @spec clamp(number(), number(), number()) :: number()
+  def clamp(value, min, max) do
+    value |> max(min) |> min(max)
+  end
+end
diff --git a/priv/combined_metrics/samples/testing/reasonable_test_to_code_ratio/config.yml b/priv/combined_metrics/samples/testing/reasonable_test_to_code_ratio/config.yml
new file mode 100644
index 0000000..dc0d296
--- /dev/null
+++ b/priv/combined_metrics/samples/testing/reasonable_test_to_code_ratio/config.yml
@@ -0,0 +1 @@
+doc: "There should be an adequate number of test cases relative to the code being tested."
diff --git a/priv/combined_metrics/samples/testing/reasonable_test_to_code_ratio/good/thorough_test.ex b/priv/combined_metrics/samples/testing/reasonable_test_to_code_ratio/good/thorough_test.ex
new file mode 100644
index 0000000..b937de3
--- /dev/null
+++ b/priv/combined_metrics/samples/testing/reasonable_test_to_code_ratio/good/thorough_test.ex
@@ -0,0 +1,100 @@
+defmodule Math.CalculatorTest do
+  @moduledoc """
+  Tests for Calculator — GOOD: multiple test cases per public function.
+  """
+  use ExUnit.Case
+
+  describe "add/2" do
+    test "sums two positive integers" do
+      assert Math.Calculator.add(2, 3) == 5
+    end
+
+    test "handles negative numbers" do
+      assert Math.Calculator.add(-1, 1) == 0
+    end
+  end
+
+  describe "subtract/2" do
+    test "subtracts second from first" do
+      assert Math.Calculator.subtract(10, 4) == 6
+    end
+
+    test "returns negative when second is larger" do
+      assert Math.Calculator.subtract(3, 7) == -4
+    end
+  end
+
+  describe "divide/2" do
+    test "returns {:ok, float} for valid division" do
+      assert Math.Calculator.divide(10, 4) == {:ok, 2.5}
+    end
+
+    test "returns {:error, :division_by_zero} when divisor is zero" do
+      assert Math.Calculator.divide(5, 0) == {:error, :division_by_zero}
+    end
+  end
+
+  describe "sqrt/1" do
+    test "returns {:ok, float} for positive input" do
+      assert Math.Calculator.sqrt(9) == {:ok, 3.0}
+    end
+
+    test "returns {:error, :negative_input} for negative number" do
+      assert Math.Calculator.sqrt(-4) == {:error, :negative_input}
+    end
+
+    test "returns {:ok, 0.0} for zero" do
+      assert Math.Calculator.sqrt(0) == {:ok, 0.0}
+    end
+  end
+
+  describe "percentage/2" do
+    test "calculates percentage of total" do
+      assert Math.Calculator.percentage(25, 200) == 12.5
+    end
+
+    test "returns 0.0 when total is zero" do
+      assert Math.Calculator.percentage(10, 0) == 0.0
+    end
+  end
+
+  describe "clamp/3" do
+    test "returns value when within range" do
+      assert Math.Calculator.clamp(5, 1, 10) == 5
+    end
+
+    test "returns min when value is below range" do
+      assert Math.Calculator.clamp(-3, 0, 100) == 0
+    end
+
+    test "returns max when value is above range" do
+      assert Math.Calculator.clamp(200, 0, 100) == 100
+    end
+  end
+end
+
+defmodule Math.Calculator do
+  @spec add(number(), number()) :: number()
+  def add(a, b), do: a + b
+
+  @spec subtract(number(), number()) :: number()
+  def subtract(a, b), do: a - b
+
+  @spec multiply(number(), number()) :: number()
+  def multiply(a, b), do: a * b
+
+  @spec divide(number(), number()) :: {:ok, float()} | {:error, :division_by_zero}
+  def divide(_a, 0), do: {:error, :division_by_zero}
+  def divide(a, b), do: {:ok, a / b}
+
+  @spec sqrt(number()) :: {:ok, float()} | {:error, :negative_input}
+  def sqrt(n) when n < 0, do: {:error, :negative_input}
+  def sqrt(n), do: {:ok, :math.sqrt(n)}
+
+  @spec percentage(number(), number()) :: float()
+  def percentage(_value, 0), do: 0.0
+  def percentage(value, total), do: value / total * 100.0
+
+  @spec clamp(number(), number(), number()) :: number()
+  def clamp(value, min, max), do: value |> max(min) |> min(max)
+end
diff --git a/priv/combined_metrics/samples/testing/test_has_assertion/bad/empty_assertions_test.ex b/priv/combined_metrics/samples/testing/test_has_assertion/bad/empty_assertions_test.ex
new file mode 100644
index 0000000..cfe41ed
--- /dev/null
+++ b/priv/combined_metrics/samples/testing/test_has_assertion/bad/empty_assertions_test.ex
@@ -0,0 +1,62 @@
+defmodule Accounts.UserTest do
+  @moduledoc """
+  User tests — BAD: test blocks with setup code but no assertions.
+  """
+  use ExUnit.Case
+
+  test "create user" do
+    attrs = %{name: "Alice", email: "alice@example.com", role: :member}
+    # calls the function but never asserts on the result
+    Accounts.User.create(attrs)
+  end
+
+  test "user email validation" do
+    user = %{name: "Bob", email: "not-an-email", role: :guest}
+    # assigns result but never asserts
+    _result = Accounts.User.validate(user)
+  end
+
+  test "user with admin role" do
+    user = Accounts.User.create(%{name: "Carol", email: "carol@example.com", role: :admin})
+    # inspects but never asserts
+    IO.inspect(user)
+  end
+
+  test "update user name" do
+    user = %{id: 1, name: "Dave", email: "dave@example.com"}
+    # sets up the update but no assertion follows
+    Accounts.User.update(user, %{name: "David"})
+    :ok
+  end
+
+  test "deactivate user" do
+    user = %{id: 2, name: "Eve", active: true}
+    updated = Accounts.User.deactivate(user)
+    # logs rather than asserts
+    IO.puts("Deactivated: #{inspect(updated)}")
+  end
+
+  test "user roles" do
+    roles = [:admin, :member, :guest]
+    Enum.each(roles, fn role ->
+      Accounts.User.create(%{name: "Test", email: "t@t.com", role: role})
+    end)
+    # no assertion — just iterates
+  end
+
+  test "delete user" do
+    user = %{id: 3, name: "Frank"}
+    Accounts.User.delete(user)
+    # returns truthy but never checked
+    true
+  end
+end
+
+defmodule Accounts.User do
+  def create(attrs), do: {:ok, Map.put(attrs, :id, System.unique_integer([:positive]))}
+  def validate(%{email: email} = user) when is_binary(email), do: {:ok, user}
+  def validate(_), do: {:error, :invalid_email}
+  def update(user, attrs), do: {:ok, Map.merge(user, attrs)}
+  def deactivate(user), do: {:ok, Map.put(user, :active, false)}
+  def delete(_user), do: :ok
+end
diff --git a/priv/combined_metrics/samples/testing/test_has_assertion/config.yml b/priv/combined_metrics/samples/testing/test_has_assertion/config.yml
new file mode 100644
index 0000000..9ef4a18
--- /dev/null
+++ b/priv/combined_metrics/samples/testing/test_has_assertion/config.yml
@@ -0,0 +1 @@
+doc: "Every test body must contain at least one assertion — a test without assertions proves nothing."
diff --git a/priv/combined_metrics/samples/testing/test_has_assertion/good/proper_assertions_test.ex b/priv/combined_metrics/samples/testing/test_has_assertion/good/proper_assertions_test.ex
new file mode 100644
index 0000000..d4bee85
--- /dev/null
+++ b/priv/combined_metrics/samples/testing/test_has_assertion/good/proper_assertions_test.ex
@@ -0,0 +1,50 @@
+defmodule Accounts.UserTest do
+  @moduledoc """
+  User tests — GOOD: every test has at least one meaningful assertion.
+  """
+  use ExUnit.Case
+
+  test "create/1 returns {:ok, user} with assigned id" do
+    attrs = %{name: "Alice", email: "alice@example.com", role: :member}
+    assert {:ok, user} = Accounts.User.create(attrs)
+    assert user.name == "Alice"
+    assert is_integer(user.id)
+  end
+
+  test "validate/1 returns {:error, :invalid_email} for malformed email" do
+    user = %{name: "Bob", email: "not-an-email", role: :guest}
+    assert {:error, :invalid_email} = Accounts.User.validate(user)
+  end
+
+  test "create/1 succeeds with admin role" do
+    assert {:ok, user} = Accounts.User.create(%{name: "Carol", email: "carol@example.com", role: :admin})
+    assert user.role == :admin
+  end
+
+  test "update/2 merges new attributes onto existing user" do
+    user = %{id: 1, name: "Dave", email: "dave@example.com"}
+    assert {:ok, updated} = Accounts.User.update(user, %{name: "David"})
+    assert updated.name == "David"
+    assert updated.email == "dave@example.com"
+  end
+
+  test "deactivate/1 sets active to false" do
+    user = %{id: 2, name: "Eve", active: true}
+    assert {:ok, updated} = Accounts.User.deactivate(user)
+    assert updated.active == false
+  end
+
+  test "delete/1 returns :ok" do
+    user = %{id: 3, name: "Frank"}
+    assert :ok = Accounts.User.delete(user)
+  end
+end
+
+defmodule Accounts.User do
+  def create(attrs), do: {:ok, Map.put(attrs, :id, System.unique_integer([:positive]))}
+  def validate(%{email: email} = user) when is_binary(email), do: {:ok, user}
+  def validate(_), do: {:error, :invalid_email}
+  def update(user, attrs), do: {:ok, Map.merge(user, attrs)}
+  def deactivate(user), do: {:ok, Map.put(user, :active, false)}
+  def delete(_user), do: :ok
+end
diff --git a/priv/combined_metrics/samples/testing/test_name_describes_behavior/bad/vague_test.ex b/priv/combined_metrics/samples/testing/test_name_describes_behavior/bad/vague_test.ex
new file mode 100644
index 0000000..8af92fa
--- /dev/null
+++ b/priv/combined_metrics/samples/testing/test_name_describes_behavior/bad/vague_test.ex
@@ -0,0 +1,49 @@
+defmodule Auth.SessionTest do
+  @moduledoc """
+  Auth tests — BAD: test names are vague and give no indication of expected behavior.
+  """
+  use ExUnit.Case
+
+  test "test 1" do
+    assert Auth.Session.login("alice@example.com", "secret") == {:ok, "token_alice"}
+  end
+
+  test "works" do
+    assert Auth.Session.login("bob@example.com", "wrongpass") == {:error, :invalid_credentials}
+  end
+
+  test "test user" do
+    assert Auth.Session.logout("token_alice") == :ok
+  end
+
+  test "it works fine" do
+    assert Auth.Session.verify("token_alice") == {:ok, %{email: "alice@example.com"}}
+  end
+
+  test "bad token" do
+    assert Auth.Session.verify("garbage") == {:error, :invalid_token}
+  end
+
+  test "refresh" do
+    assert Auth.Session.refresh("token_alice") == {:ok, "token_alice_new"}
+  end
+
+  test "test expired" do
+    assert Auth.Session.verify("expired_token") == {:error, :token_expired}
+  end
+
+  test "stuff" do
+    assert Auth.Session.login("", "") == {:error, :invalid_credentials}
+  end
+end
+
+defmodule Auth.Session do
+  def login("alice@example.com", "secret"), do: {:ok, "token_alice"}
+  def login(_, _), do: {:error, :invalid_credentials}
+  def logout(_token), do: :ok
+  def verify("token_alice"), do: {:ok, %{email: "alice@example.com"}}
+  def verify("expired_token"), do: {:error, :token_expired}
+  def verify(_), do: {:error, :invalid_token}
+  def refresh("token_alice"), do: {:ok, "token_alice_new"}
+  def refresh(_), do: {:error, :invalid_token}
+end
diff --git a/priv/combined_metrics/samples/testing/test_name_describes_behavior/config.yml b/priv/combined_metrics/samples/testing/test_name_describes_behavior/config.yml
new file mode 100644
index 0000000..ac733ad
--- /dev/null
+++ b/priv/combined_metrics/samples/testing/test_name_describes_behavior/config.yml
@@ -0,0 +1 @@
+doc: "Test names should describe the expected behaviour, not just the method under test."
diff --git a/priv/combined_metrics/samples/testing/test_name_describes_behavior/good/descriptive_test.ex b/priv/combined_metrics/samples/testing/test_name_describes_behavior/good/descriptive_test.ex
new file mode 100644
index 0000000..1cd3b68
--- /dev/null
+++ b/priv/combined_metrics/samples/testing/test_name_describes_behavior/good/descriptive_test.ex
@@ -0,0 +1,62 @@
+defmodule Auth.SessionTest do
+  @moduledoc """
+  Auth tests — GOOD: test names describe the expected behavior and conditions.
+  """
+  use ExUnit.Case
+
+  describe "login/2" do
+    test "returns {:ok, token} when credentials are valid" do
+      assert {:ok, token} = Auth.Session.login("alice@example.com", "secret")
+      assert is_binary(token)
+    end
+
+    test "returns {:error, :invalid_credentials} when password is wrong" do
+      assert Auth.Session.login("bob@example.com", "wrongpass") == {:error, :invalid_credentials}
+    end
+
+    test "returns {:error, :invalid_credentials} when email and password are empty" do
+      assert Auth.Session.login("", "") == {:error, :invalid_credentials}
+    end
+  end
+
+  describe "logout/1" do
+    test "returns :ok for any valid token" do
+      assert Auth.Session.logout("token_alice") == :ok
+    end
+  end
+
+  describe "verify/1" do
+    test "returns {:ok, user_info} for a valid token" do
+      assert Auth.Session.verify("token_alice") == {:ok, %{email: "alice@example.com"}}
+    end
+
+    test "returns {:error, :token_expired} for an expired token" do
+      assert Auth.Session.verify("expired_token") == {:error, :token_expired}
+    end
+
+    test "returns {:error, :invalid_token} for a malformed token" do
+      assert Auth.Session.verify("garbage") == {:error, :invalid_token}
+    end
+  end
+
+  describe "refresh/1" do
+    test "returns {:ok, new_token} when token is valid and active" do
+      assert Auth.Session.refresh("token_alice") == {:ok, "token_alice_new"}
+    end
+
+    test "returns {:error, :invalid_token} when token does not exist" do
+      assert Auth.Session.refresh("nonexistent") == {:error, :invalid_token}
+    end
+  end
+end
+
+defmodule Auth.Session do
+  def login("alice@example.com", "secret"), do: {:ok, "token_alice"}
+  def login(_, _), do: {:error, :invalid_credentials}
+  def logout(_token), do: :ok
+  def verify("token_alice"), do: {:ok, %{email: "alice@example.com"}}
+  def verify("expired_token"), do: {:error, :token_expired}
+  def verify(_), do: {:error, :invalid_token}
+  def refresh("token_alice"), do: {:ok, "token_alice_new"}
+  def refresh(_), do: {:error, :invalid_token}
+end
diff --git a/priv/combined_metrics/samples/testing/test_single_concept/bad/kitchen_sink_test.ex b/priv/combined_metrics/samples/testing/test_single_concept/bad/kitchen_sink_test.ex
new file mode 100644
index 0000000..b0924fb
--- /dev/null
+++ b/priv/combined_metrics/samples/testing/test_single_concept/bad/kitchen_sink_test.ex
@@ -0,0 +1,62 @@
+defmodule Store.OrderTest do
+  @moduledoc """
+  Order tests — BAD: one test asserts many unrelated behaviors at once.
+  """
+  use ExUnit.Case
+
+  test "order lifecycle" do
+    # Creation
+    attrs = %{user_id: 1, items: [%{sku: "A1", qty: 2, price: 10.0}]}
+    assert {:ok, order} = Store.Order.create(attrs)
+    assert order.status == :pending
+    assert order.total == 20.0
+    assert is_integer(order.id)
+
+    # Adding an item
+    assert {:ok, updated} = Store.Order.add_item(order, %{sku: "B2", qty: 1, price: 5.0})
+    assert updated.total == 25.0
+    assert length(updated.items) == 2
+
+    # Applying a discount
+    assert {:ok, discounted} = Store.Order.apply_discount(updated, 10)
+    assert discounted.total == 22.5
+    assert discounted.discount_percent == 10
+
+    # Payment
+    assert {:ok, paid} = Store.Order.pay(discounted, %{method: :card, last4: "1234"})
+    assert paid.status == :paid
+    assert paid.payment.method == :card
+
+    # Shipping
+    assert {:ok, shipped} = Store.Order.ship(paid, %{tracking: "TRK123"})
+    assert shipped.status == :shipped
+    assert shipped.tracking == "TRK123"
+
+    # Cancellation not allowed on shipped orders
+    assert {:error, :cannot_cancel} = Store.Order.cancel(shipped)
+
+    # Refund
+    assert {:ok, refunded} = Store.Order.refund(paid)
+    assert refunded.status == :refunded
+  end
+end
+
+defmodule Store.Order do
+  def create(attrs) do
+    total = Enum.sum(Enum.map(attrs.items, fn i -> i.qty * i.price end))
+    {:ok, %{id: 1, status: :pending, items: attrs.items, total: total, user_id: attrs.user_id}}
+  end
+
+  def add_item(order, item) do
+    items = [item | order.items]
+    total = Enum.sum(Enum.map(items, fn i -> i.qty * i.price end))
+    {:ok, %{order | items: items, total: total}}
+  end
+
+  def apply_discount(order, pct), do: {:ok, %{order | total: order.total * (1 - pct / 100), discount_percent: pct}}
+  def pay(order, payment), do: {:ok, %{order | status: :paid, payment: payment}}
+  def ship(order, %{tracking: t}), do: {:ok, %{order | status: :shipped, tracking: t}}
+  def cancel(%{status: :shipped}), do: {:error, :cannot_cancel}
+  def cancel(order), do: {:ok, %{order | status: :cancelled}}
+  def refund(order), do: {:ok, %{order | status: :refunded}}
+end
diff --git a/priv/combined_metrics/samples/testing/test_single_concept/config.yml b/priv/combined_metrics/samples/testing/test_single_concept/config.yml
new file mode 100644
index 0000000..ba62672
--- /dev/null
+++ b/priv/combined_metrics/samples/testing/test_single_concept/config.yml
@@ -0,0 +1 @@
+doc: "Each test should verify a single concept — tests covering multiple things are harder to diagnose when they fail."
diff --git a/priv/combined_metrics/samples/testing/test_single_concept/good/focused_test.ex b/priv/combined_metrics/samples/testing/test_single_concept/good/focused_test.ex
new file mode 100644
index 0000000..0989bac
--- /dev/null
+++ b/priv/combined_metrics/samples/testing/test_single_concept/good/focused_test.ex
@@ -0,0 +1,99 @@
+defmodule Store.OrderTest do
+  @moduledoc """
+  Order tests — GOOD: each test covers exactly one behavior.
+  """
+  use ExUnit.Case
+
+  defp pending_order do
+    attrs = %{user_id: 1, items: [%{sku: "A1", qty: 2, price: 10.0}]}
+    {:ok, order} = Store.Order.create(attrs)
+    order
+  end
+
+  describe "create/1" do
+    test "sets status to :pending" do
+      order = pending_order()
+      assert order.status == :pending
+    end
+
+    test "calculates total from line items" do
+      order = pending_order()
+      assert order.total == 20.0
+    end
+
+    test "assigns a numeric id" do
+      order = pending_order()
+      assert is_integer(order.id)
+    end
+  end
+
+  describe "add_item/2" do
+    test "increases total by the new item's value" do
+      order = pending_order()
+      assert {:ok, updated} = Store.Order.add_item(order, %{sku: "B2", qty: 1, price: 5.0})
+      assert updated.total == 25.0
+    end
+
+    test "appends the item to the items list" do
+      order = pending_order()
+      assert {:ok, updated} = Store.Order.add_item(order, %{sku: "B2", qty: 1, price: 5.0})
+      assert length(updated.items) == 2
+    end
+  end
+
+  describe "apply_discount/2" do
+    test "reduces total by the given percentage" do
+      order = pending_order()
+      assert {:ok, discounted} = Store.Order.apply_discount(order, 10)
+      assert discounted.total == 18.0
+    end
+
+    test "stores the discount percentage on the order" do
+      order = pending_order()
+      assert {:ok, discounted} = Store.Order.apply_discount(order, 10)
+      assert discounted.discount_percent == 10
+    end
+  end
+
+  describe "pay/2" do
+    test "sets status to :paid" do
+      order = pending_order()
+      assert {:ok, paid} = Store.Order.pay(order, %{method: :card, last4: "1234"})
+      assert paid.status == :paid
+    end
+  end
+
+  describe "cancel/1" do
+    test "returns {:error, :cannot_cancel} for shipped orders" do
+      order = pending_order()
+      {:ok, paid} = Store.Order.pay(order, %{method: :card, last4: "1234"})
+      {:ok, shipped} = Store.Order.ship(paid, %{tracking: "TRK123"})
+      assert Store.Order.cancel(shipped) == {:error, :cannot_cancel}
+    end
+
+    test "sets status to :cancelled for pending orders" do
+      order = pending_order()
+      assert {:ok, cancelled} = Store.Order.cancel(order)
+      assert cancelled.status == :cancelled
+    end
+  end
+end
+
+defmodule Store.Order do
+  def create(attrs) do
+    total = Enum.sum(Enum.map(attrs.items, fn i -> i.qty * i.price end))
+    {:ok, %{id: 1, status: :pending, items: attrs.items, total: total, user_id: attrs.user_id}}
+  end
+
+  def add_item(order, item) do
+    items = [item | order.items]
+    {:ok, %{order | items: items, total: Enum.sum(Enum.map(items, fn i -> i.qty * i.price end))}}
+  end
+
+  def apply_discount(order, pct), do: {:ok, %{order | total: order.total * (1 - pct / 100), discount_percent: pct}}
+  def pay(order, payment), do: {:ok, %{order | status: :paid, payment: payment}}
+  def ship(order, %{tracking: t}), do: {:ok, %{order | status: :shipped, tracking: t}}
+  def cancel(%{status: :shipped}), do: {:error, :cannot_cancel}
+  def cancel(order), do: {:ok, %{order | status: :cancelled}}
+  def refund(order), do: {:ok, %{order | status: :refunded}}
+end
diff --git a/priv/combined_metrics/samples/type_and_value/boolean_assigned_from_comparison/bad/checker.ex b/priv/combined_metrics/samples/type_and_value/boolean_assigned_from_comparison/bad/checker.ex
new file mode 100644
index 0000000..7985cd4
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/boolean_assigned_from_comparison/bad/checker.ex
@@ -0,0 +1,76 @@
+defmodule Status.Checker do
+  @moduledoc """
+  Status checking — BAD: boolean variables derived from nested logic instead of direct comparison.
+  """
+
+  def check_user(user) do
+    is_active =
+      if user.status == :active do
+        if user.confirmed do
+          true
+        else
+          false
+        end
+      else
+        false
+      end
+
+    is_admin =
+      cond do
+        user.role == :admin -> true
+        user.role == :superadmin -> true
+        true -> false
+      end
+
+    is_premium =
+      case user.plan do
+        :premium -> true
+        :enterprise -> true
+        _ -> false
+      end
+
+    can_post =
+      if is_active do
+        if not user.banned do
+          true
+        else
+          false
+        end
+      else
+        false
+      end
+
+    %{active: is_active, admin: is_admin, premium: is_premium, can_post: can_post}
+  end
+
+  def check_product(product) do
+    is_available =
+      if product.stock > 0 do
+        true
+      else
+        false
+      end
+
+    is_discounted =
+      if product.discount > 0 do
+        if product.discount < 100 do
+          true
+        else
+          false
+        end
+      else
+        false
+      end
+
+    is_featured =
+      case product.tags do
+        tags when is_list(tags) ->
+          if :featured in tags, do: true, else: false
+
+        _ ->
+          false
+      end
+
+    %{available: is_available, discounted: is_discounted, featured: is_featured}
+  end
+end
diff --git a/priv/combined_metrics/samples/type_and_value/boolean_assigned_from_comparison/config.yml b/priv/combined_metrics/samples/type_and_value/boolean_assigned_from_comparison/config.yml
new file mode 100644
index 0000000..b17508c
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/boolean_assigned_from_comparison/config.yml
@@ -0,0 +1 @@
+doc: "Boolean variables should be assigned directly from comparisons or predicate calls, not set via conditionals."
diff --git a/priv/combined_metrics/samples/type_and_value/boolean_assigned_from_comparison/good/checker.ex b/priv/combined_metrics/samples/type_and_value/boolean_assigned_from_comparison/good/checker.ex
new file mode 100644
index 0000000..d1354e7
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/boolean_assigned_from_comparison/good/checker.ex
@@ -0,0 +1,31 @@
+defmodule Status.Checker do
+  @moduledoc """
+  Status checking — GOOD: booleans assigned via direct comparison expressions.
+  """
+
+  def check_user(user) do
+    is_active = user.status == :active and user.confirmed
+    is_admin = user.role in [:admin, :superadmin]
+    is_premium = user.plan in [:premium, :enterprise]
+    can_post = is_active and not user.banned
+
+    %{active: is_active, admin: is_admin, premium: is_premium, can_post: can_post}
+  end
+
+  def check_product(product) do
+    is_available = product.stock > 0
+    is_discounted = product.discount > 0 and product.discount < 100
+    is_featured = is_list(product.tags) and :featured in product.tags
+
+    %{available: is_available, discounted: is_discounted, featured: is_featured}
+  end
+
+  def check_order(order) do
+    is_paid = order.status == :paid
+    is_shippable = order.status in [:paid, :processing] and order.address != nil
+    is_overdue = order.status == :pending and DateTime.diff(DateTime.utc_now(), order.created_at, :day) > 3
+    has_discount = not is_nil(order.coupon_code) and order.discount_total > 0
+
+    %{paid: is_paid, shippable: is_shippable, overdue: is_overdue, has_discount: has_discount}
+  end
+end
diff --git a/priv/combined_metrics/samples/type_and_value/copy_not_assumed_to_be_deep/bad/OrderDraft.kt b/priv/combined_metrics/samples/type_and_value/copy_not_assumed_to_be_deep/bad/OrderDraft.kt
new file mode 100644
index 0000000..72005fb
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/copy_not_assumed_to_be_deep/bad/OrderDraft.kt
@@ -0,0 +1,45 @@
+package com.example.orders
+
+import java.math.BigDecimal
+
+data class LineItem(val productId: String, var quantity: Int, val unitPrice: BigDecimal)
+
+data class OrderDraft(
+    val customerId: String,
+    val items: MutableList<LineItem>,
+    val notes: String?
+)
+
+class OrderDraftService {
+
+    /**
+     * Assumes copy() performs a deep copy — it does not.
+     * Both `draft` and the returned copy share the same `items` MutableList reference.
+     */
+    fun withPromoItems(draft: OrderDraft, promoProductId: String): OrderDraft {
+        // copy() is SHALLOW — promoCopy.items and draft.items point to the same list
+        val promoCopy = draft.copy()
+        promoCopy.items.add(LineItem(promoProductId, 1, BigDecimal.ZERO))
+        // This mutation also affects the original draft!
+        return promoCopy
+    }
+
+    /**
+     * Modifies quantity on the "copy" — but since items list is shared,
+     * this also mutates the original.
+     */
+    fun withAdjustedQuantity(draft: OrderDraft, productId: String, newQty: Int): OrderDraft {
+        val adjusted = draft.copy()  // shallow copy only
+        adjusted.items.find { it.productId == productId }?.quantity = newQty
+        // Mutates the original draft's items as well
+        return adjusted
+    }
+
+    /**
+     * Attempts to snapshot for audit, believing copy() isolates state.
+     * Both the live draft and this "snapshot" share the same mutable items list.
+     */
+    fun snapshot(draft: OrderDraft): OrderDraft {
+        return draft.copy()  // NOT a deep copy — shared mutable state
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/copy_not_assumed_to_be_deep/good/OrderDraft.kt b/priv/combined_metrics/samples/type_and_value/copy_not_assumed_to_be_deep/good/OrderDraft.kt
new file mode 100644
index 0000000..d7453a0
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/copy_not_assumed_to_be_deep/good/OrderDraft.kt
@@ -0,0 +1,47 @@
+package com.example.orders
+
+import java.math.BigDecimal
+
+data class LineItem(val productId: String, var quantity: Int, val unitPrice: BigDecimal)
+
+data class OrderDraft(
+    val customerId: String,
+    val items: List<LineItem>,   // List, not MutableList — prevents external mutation
+    val notes: String?
+)
+
+class OrderDraftService {
+
+    /**
+     * Creates a promotional copy of the draft with an explicit deep copy of items,
+     * because copy() only shallow-copies the list reference.
+     */
+    fun withPromoItems(draft: OrderDraft, promoProductId: String): OrderDraft {
+        // Deep copy items list explicitly — copy() would share the same list object
+        val newItems = draft.items.map { it.copy() } + LineItem(promoProductId, 1, BigDecimal.ZERO)
+        return draft.copy(items = newItems)
+    }
+
+    /**
+     * Applies a quantity adjustment. Uses an explicit deep copy so the original draft is untouched.
+     */
+    fun withAdjustedQuantity(draft: OrderDraft, productId: String, newQty: Int): OrderDraft {
+        // Explicitly rebuilding the items list — not assuming copy() is deep
+        val updatedItems = draft.items.map { item ->
+            if (item.productId == productId) item.copy(quantity = newQty) else item.copy()
+        }
+        return draft.copy(items = updatedItems)
+    }
+
+    /**
+     * Snapshots the draft for audit purposes — explicitly materialises new item instances
+     * so the audit record is fully independent from any future mutations of the source.
+     */
+    fun snapshot(draft: OrderDraft): OrderDraft {
+        return OrderDraft(
+            customerId = draft.customerId,
+            items = draft.items.map { it.copy() },  // explicit deep copy
+            notes = draft.notes
+        )
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/copyability_is_explicitly_declared/bad/Matrix.cpp b/priv/combined_metrics/samples/type_and_value/copyability_is_explicitly_declared/bad/Matrix.cpp
new file mode 100644
index 0000000..558aa38
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/copyability_is_explicitly_declared/bad/Matrix.cpp
@@ -0,0 +1,64 @@
+#include <cstring>
+#include <stdexcept>
+
+// Copyability is NOT explicitly declared — relies on compiler-generated defaults.
+// The compiler-generated copy performs a shallow copy of the raw pointer,
+// resulting in double-free and use-after-free bugs.
+
+class Matrix {
+public:
+    Matrix(std::size_t rows, std::size_t cols)
+        : rows_(rows), cols_(cols)
+        , data_(new double[rows * cols])
+    {
+        for (std::size_t i = 0; i < rows * cols; ++i)
+            data_[i] = 0.0;
+    }
+
+    // Destructor defined — but copy/move not declared.
+    // This violates the Rule of Three/Five: compiler-generated copy will shallow-copy data_.
+    ~Matrix() {
+        delete[] data_;
+    }
+
+    // No copy constructor declared:
+    // Matrix a(3, 3);
+    // Matrix b = a;  // compiler copies data_ pointer — both a and b point to same memory
+    //                // ~Matrix() called twice on same pointer → double-free (UB)
+
+    // No copy assignment declared:
+    // Matrix a(3, 3), b(2, 2);
+    // b = a;  // shallow copy of data_ → memory leak of b's old data_, double-free on destruction
+
+    // No move constructor declared:
+    // std::vector<Matrix> v;
+    // v.push_back(Matrix(4, 4));  // may copy (shallow) instead of move → double-free
+
+    // No move assignment declared
+
+    double& at(std::size_t r, std::size_t c) {
+        return data_[r * cols_ + c];
+    }
+
+    double at(std::size_t r, std::size_t c) const {
+        return data_[r * cols_ + c];
+    }
+
+    std::size_t rows() const { return rows_; }
+    std::size_t cols() const { return cols_; }
+
+private:
+    std::size_t rows_;
+    std::size_t cols_;
+    double* data_; // raw owning pointer — copy semantics are wrong without explicit Rule of Five
+};
+
+void demonstrateBug() {
+    Matrix a(3, 3);
+    a.at(0, 0) = 42.0;
+
+    Matrix b = a;          // shallow copy: b.data_ == a.data_
+    b.at(0, 0) = 99.0;    // modifies a.data_ too — unintentional aliasing
+
+    // When a and b go out of scope, delete[] is called twice on the same pointer — UB
+}
diff --git a/priv/combined_metrics/samples/type_and_value/copyability_is_explicitly_declared/good/Matrix.cpp b/priv/combined_metrics/samples/type_and_value/copyability_is_explicitly_declared/good/Matrix.cpp
new file mode 100644
index 0000000..ec0c981
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/copyability_is_explicitly_declared/good/Matrix.cpp
@@ -0,0 +1,79 @@
+#include <algorithm>
+#include <cstring>
+#include <memory>
+#include <stdexcept>
+
+// Copyability is explicitly declared — nothing is left to compiler defaults.
+// The Rule of Five is fully stated.
+
+class Matrix {
+public:
+    Matrix(std::size_t rows, std::size_t cols)
+        : rows_(rows), cols_(cols)
+        , data_(std::make_unique<double[]>(rows * cols))
+    {
+        std::fill(data_.get(), data_.get() + rows * cols, 0.0);
+    }
+
+    // Explicit copy constructor — deep copies the heap data
+    Matrix(const Matrix& other)
+        : rows_(other.rows_), cols_(other.cols_)
+        , data_(std::make_unique<double[]>(other.rows_ * other.cols_))
+    {
+        std::copy(other.data_.get(),
+                  other.data_.get() + rows_ * cols_,
+                  data_.get());
+    }
+
+    // Explicit copy assignment — copy-and-swap for strong exception safety
+    Matrix& operator=(const Matrix& other) {
+        Matrix tmp(other);
+        swap(tmp);
+        return *this;
+    }
+
+    // Explicit move constructor — noexcept: just pointer/integer transfer
+    Matrix(Matrix&& other) noexcept
+        : rows_(other.rows_), cols_(other.cols_)
+        , data_(std::move(other.data_))
+    {
+        other.rows_ = 0;
+        other.cols_ = 0;
+    }
+
+    // Explicit move assignment
+    Matrix& operator=(Matrix&& other) noexcept {
+        if (this != &other) {
+            data_ = std::move(other.data_);
+            rows_ = other.rows_;
+            cols_ = other.cols_;
+            other.rows_ = 0;
+            other.cols_ = 0;
+        }
+        return *this;
+    }
+
+    ~Matrix() = default;
+
+    double& at(std::size_t r, std::size_t c) {
+        return data_[r * cols_ + c];
+    }
+
+    double at(std::size_t r, std::size_t c) const {
+        return data_[r * cols_ + c];
+    }
+
+    std::size_t rows() const noexcept { return rows_; }
+    std::size_t cols() const noexcept { return cols_; }
+
+private:
+    std::size_t rows_;
+    std::size_t cols_;
+    std::unique_ptr<double[]> data_;
+
+    void swap(Matrix& other) noexcept {
+        std::swap(rows_, other.rows_);
+        std::swap(cols_, other.cols_);
+        std::swap(data_, other.data_);
+    }
+};
diff --git a/priv/combined_metrics/samples/type_and_value/does_not_use_lossy_numeric_cast/bad/converter.rs b/priv/combined_metrics/samples/type_and_value/does_not_use_lossy_numeric_cast/bad/converter.rs
new file mode 100644
index 0000000..d301cd4
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/does_not_use_lossy_numeric_cast/bad/converter.rs
@@ -0,0 +1,40 @@
+/// Converts a file size reported as i64 to a usize page index.
+/// BAD: as cast silently truncates on 32-bit targets or wraps on negatives.
+pub fn size_to_usize(size: i64) -> usize {
+    // If size is negative this wraps to a huge usize — memory corruption risk
+    size as usize
+}
+
+/// Converts a packet length from u64 to u16 for a protocol field.
+/// BAD: values above 65535 are silently truncated to (value % 65536).
+pub fn payload_len(total: u64) -> u16 {
+    total as u16
+}
+
+/// Converts a sampling rate f64 to an integer rate.
+/// BAD: if rate > u32::MAX the result wraps; NaN becomes 0; negative becomes 0.
+pub fn sample_rate_to_u32(rate: f64) -> u32 {
+    rate as u32
+}
+
+/// Accumulates byte counts — BAD: individual casts and sum may silently overflow.
+pub fn total_bytes(counts: &[u32]) -> usize {
+    let mut total: usize = 0;
+    for &n in counts {
+        // Cast to usize is safe here, but the addition can silently overflow
+        // on 32-bit targets where usize is 32 bits
+        total += n as usize;
+    }
+    total
+}
+
+/// Computes a score from a large value — BAD: lossy f32 cast loses precision.
+pub fn score(raw: u64) -> f32 {
+    // u64 values above 2^24 cannot be represented exactly in f32
+    raw as f32 / 1_000_000.0
+}
+
+/// Maps an i32 row count to an i16 display limit — BAD: values above 32767 wrap.
+pub fn row_display_limit(count: i32) -> i16 {
+    count as i16
+}
diff --git a/priv/combined_metrics/samples/type_and_value/does_not_use_lossy_numeric_cast/good/converter.rs b/priv/combined_metrics/samples/type_and_value/does_not_use_lossy_numeric_cast/good/converter.rs
new file mode 100644
index 0000000..032e80e
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/does_not_use_lossy_numeric_cast/good/converter.rs
@@ -0,0 +1,69 @@
+use std::num::TryFromIntError;
+
+#[derive(Debug)]
+pub enum ConversionError {
+    Overflow { from: &'static str, to: &'static str, value: i64 },
+    NegativeToUnsigned(i64),
+}
+
+impl std::fmt::Display for ConversionError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ConversionError::Overflow { from, to, value } => {
+                write!(f, "value {value} overflows when converting {from} to {to}")
+            }
+            ConversionError::NegativeToUnsigned(v) => {
+                write!(f, "cannot convert negative value {v} to unsigned type")
+            }
+        }
+    }
+}
+
+impl From<TryFromIntError> for ConversionError {
+    fn from(_: TryFromIntError) -> Self {
+        ConversionError::Overflow { from: "integer", to: "integer", value: 0 }
+    }
+}
+
+/// Converts a file size reported as i64 to a usize page index safely.
+pub fn size_to_usize(size: i64) -> Result<usize, ConversionError> {
+    if size < 0 {
+        return Err(ConversionError::NegativeToUnsigned(size));
+    }
+    usize::try_from(size as u64).map_err(|_| ConversionError::Overflow {
+        from: "i64",
+        to: "usize",
+        value: size,
+    })
+}
+
+/// Converts a packet length from u64 to u16 for a protocol field.
+pub fn payload_len(total: u64) -> Result<u16, ConversionError> {
+    u16::try_from(total).map_err(|_| ConversionError::Overflow {
+        from: "u64",
+        to: "u16",
+        value: total as i64,
+    })
+}
+
+/// Converts a sampling rate (f64 samples/sec) to an integer rate, checking range.
+pub fn sample_rate_to_u32(rate: f64) -> Result<u32, ConversionError> {
+    if rate < 0.0 || rate > u32::MAX as f64 {
+        return Err(ConversionError::Overflow {
+            from: "f64",
+            to: "u32",
+            value: rate as i64,
+        });
+    }
+    Ok(rate as u32)
+}
+
+/// Accumulates byte counts from multiple sources, guarding against overflow.
+pub fn total_bytes(counts: &[u32]) -> Result<u64, ConversionError> {
+    counts
+        .iter()
+        .try_fold(0u64, |acc, &n| {
+            acc.checked_add(n as u64)
+                .ok_or(ConversionError::Overflow { from: "u64", to: "u64", value: 0 })
+        })
+}
diff --git a/priv/combined_metrics/samples/type_and_value/fields_defined_in_constructor/bad/session_manager.js b/priv/combined_metrics/samples/type_and_value/fields_defined_in_constructor/bad/session_manager.js
new file mode 100644
index 0000000..d5c9439
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/fields_defined_in_constructor/bad/session_manager.js
@@ -0,0 +1,84 @@
+class Session {
+  constructor(userId, options = {}) {
+    this.userId = userId;
+    this.id = crypto.randomUUID();
+    this.createdAt = Date.now();
+  }
+
+  get(key) {
+    return this.data[key];
+  }
+
+  set(key, value) {
+    if (!this.data) {
+      this.data = {};
+    }
+    this.data[key] = value;
+  }
+
+  isExpired() {
+    return Date.now() > this.expiresAt;
+  }
+
+  setExpiry(ttlMs) {
+    this.expiresAt = this.createdAt + ttlMs;
+  }
+
+  setMetadata(userAgent, ipAddress) {
+    this.metadata = { userAgent, ipAddress };
+  }
+
+  refresh(ttlMs) {
+    this.expiresAt = Date.now() + ttlMs;
+    if (!this.refreshCount) {
+      this.refreshCount = 0;
+    }
+    this.refreshCount++;
+  }
+
+  invalidate() {
+    this.isActive = false;
+  }
+
+  activate() {
+    this.isActive = true;
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      userId: this.userId,
+      createdAt: this.createdAt,
+      expiresAt: this.expiresAt,
+      refreshCount: this.refreshCount,
+      isActive: this.isActive,
+    };
+  }
+}
+
+class SessionManager {
+  constructor(store) {
+    this._store = store;
+  }
+
+  async create(userId, options) {
+    const session = new Session(userId, options);
+    session.setExpiry(options.ttlMs ?? 30 * 60 * 1000);
+    session.setMetadata(options.userAgent, options.ipAddress);
+    session.activate();
+    this._localCache = this._localCache ?? new Map();
+    this._localCache.set(session.id, session);
+    await this._store.set(session.id, session.toJSON());
+    return session;
+  }
+
+  async get(sessionId) {
+    if (this._localCache && this._localCache.has(sessionId)) {
+      return this._localCache.get(sessionId);
+    }
+    const data = await this._store.get(sessionId);
+    return data ?? null;
+  }
+}
+
+export { Session, SessionManager };
diff --git a/priv/combined_metrics/samples/type_and_value/fields_defined_in_constructor/good/session_manager.js b/priv/combined_metrics/samples/type_and_value/fields_defined_in_constructor/good/session_manager.js
new file mode 100644
index 0000000..e8b9c83
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/fields_defined_in_constructor/good/session_manager.js
@@ -0,0 +1,76 @@
+class Session {
+  constructor(userId, options = {}) {
+    this.userId = userId;
+    this.id = crypto.randomUUID();
+    this.createdAt = Date.now();
+    this.expiresAt = this.createdAt + (options.ttlMs ?? 30 * 60 * 1000);
+    this.data = {};
+    this.metadata = {
+      userAgent: options.userAgent ?? null,
+      ipAddress: options.ipAddress ?? null,
+    };
+    this.refreshCount = 0;
+    this.isActive = true;
+  }
+
+  get(key) {
+    return this.data[key];
+  }
+
+  set(key, value) {
+    this.data[key] = value;
+  }
+
+  isExpired() {
+    return Date.now() > this.expiresAt;
+  }
+
+  refresh(ttlMs) {
+    this.expiresAt = Date.now() + ttlMs;
+    this.refreshCount++;
+  }
+
+  invalidate() {
+    this.isActive = false;
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      userId: this.userId,
+      createdAt: this.createdAt,
+      expiresAt: this.expiresAt,
+      refreshCount: this.refreshCount,
+      isActive: this.isActive,
+    };
+  }
+}
+
+class SessionManager {
+  constructor(store) {
+    this._store = store;
+    this._localCache = new Map();
+  }
+
+  async create(userId, options) {
+    const session = new Session(userId, options);
+    await this._store.set(session.id, session.toJSON());
+    this._localCache.set(session.id, session);
+    return session;
+  }
+
+  async get(sessionId) {
+    if (this._localCache.has(sessionId)) {
+      return this._localCache.get(sessionId);
+    }
+    const data = await this._store.get(sessionId);
+    return data ?? null;
+  }
+
+  async destroy(sessionId) {
+    this._localCache.delete(sessionId);
+    await this._store.delete(sessionId);
+  }
+}
+
+export { Session, SessionManager };
diff --git a/priv/combined_metrics/samples/type_and_value/hardcoded_url_or_path/bad/client.ex b/priv/combined_metrics/samples/type_and_value/hardcoded_url_or_path/bad/client.ex
new file mode 100644
index 0000000..d06183b
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/hardcoded_url_or_path/bad/client.ex
@@ -0,0 +1,53 @@
+defmodule Http.Client do
+  @moduledoc """
+  HTTP API client — BAD: URLs and paths are hardcoded throughout function bodies.
+  """
+
+  def fetch_user(id) do
+    url = "https://api.example.com/v1/users/#{id}"
+    get(url)
+  end
+
+  def create_order(params) do
+    url = "https://api.example.com/v1/orders"
+    post(url, params)
+  end
+
+  def upload_file(content, filename) do
+    path = "/tmp/uploads/#{filename}"
+    File.write!(path, content)
+    url = "https://api.example.com/v1/files"
+    post(url, %{path: path})
+  end
+
+  def fetch_product_catalog do
+    url = "https://api.example.com/v1/products?page=1&per_page=100"
+    get(url)
+  end
+
+  def send_webhook(event) do
+    url = "https://hooks.example.com/incoming/abc123xyz"
+    post(url, event)
+  end
+
+  def download_report(report_id) do
+    url = "https://reports.example.com/api/v2/reports/#{report_id}/export"
+    dest = "/var/app/downloads/report_#{report_id}.pdf"
+    content = get(url)
+    File.write!(dest, content)
+    dest
+  end
+
+  def fetch_exchange_rates do
+    url = "https://api.exchangerate.host/latest?base=USD"
+    get(url)
+  end
+
+  def post_to_slack(message) do
+    url = "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXX"
+    post(url, %{text: message})
+  end
+
+  defp get(url), do: {:ok, %{url: url, body: ""}}
+  defp post(url, body), do: {:ok, %{url: url, body: body}}
+end
diff --git a/priv/combined_metrics/samples/type_and_value/hardcoded_url_or_path/config.yml b/priv/combined_metrics/samples/type_and_value/hardcoded_url_or_path/config.yml
new file mode 100644
index 0000000..2b1d812
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/hardcoded_url_or_path/config.yml
@@ -0,0 +1 @@
+doc: "URLs, file paths, and host names should be configuration values, not inline string literals."
diff --git a/priv/combined_metrics/samples/type_and_value/hardcoded_url_or_path/good/client.ex b/priv/combined_metrics/samples/type_and_value/hardcoded_url_or_path/good/client.ex
new file mode 100644
index 0000000..b9f6d49
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/hardcoded_url_or_path/good/client.ex
@@ -0,0 +1,55 @@
+defmodule Http.Client do
+  @moduledoc """
+  HTTP API client — GOOD: URLs and paths are defined as module attributes or fetched from config.
+  """
+
+  @api_base Application.compile_env(:my_app, :api_base_url, "https://api.example.com/v1")
+  @webhook_url Application.compile_env(:my_app, :webhook_url, "https://hooks.example.com/incoming")
+  @reports_base Application.compile_env(:my_app, :reports_base_url, "https://reports.example.com/api/v2")
+
+  defp upload_dir, do: Application.get_env(:my_app, :upload_dir, "/tmp/uploads")
+  defp download_dir, do: Application.get_env(:my_app, :download_dir, "/var/app/downloads")
+  defp slack_webhook_url, do: Application.fetch_env!(:my_app, :slack_webhook_url)
+  defp exchange_rates_url, do: Application.get_env(:my_app, :exchange_rates_url, "https://api.exchangerate.host/latest")
+
+  def fetch_user(id) do
+    get("#{@api_base}/users/#{id}")
+  end
+
+  def create_order(params) do
+    post("#{@api_base}/orders", params)
+  end
+
+  def upload_file(content, filename) do
+    path = Path.join(upload_dir(), filename)
+    File.write!(path, content)
+    post("#{@api_base}/files", %{path: path})
+  end
+
+  def fetch_product_catalog do
+    get("#{@api_base}/products?page=1&per_page=100")
+  end
+
+  def send_webhook(event) do
+    post(@webhook_url, event)
+  end
+
+  def download_report(report_id) do
+    url = "#{@reports_base}/reports/#{report_id}/export"
+    dest = Path.join(download_dir(), "report_#{report_id}.pdf")
+    content = get(url)
+    File.write!(dest, content)
+    dest
+  end
+
+  def fetch_exchange_rates do
+    get("#{exchange_rates_url()}?base=USD")
+  end
+
+  def post_to_slack(message) do
+    post(slack_webhook_url(), %{text: message})
+  end
+
+  defp get(url), do: {:ok, %{url: url, body: ""}}
+  defp post(url, body), do: {:ok, %{url: url, body: body}}
+end
diff --git a/priv/combined_metrics/samples/type_and_value/no_any_type_annotation/bad/order_handler.py b/priv/combined_metrics/samples/type_and_value/no_any_type_annotation/bad/order_handler.py
new file mode 100644
index 0000000..55cdf22
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_any_type_annotation/bad/order_handler.py
@@ -0,0 +1,72 @@
+"""Order handler that processes, validates, and fulfils customer orders."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from decimal import Decimal
+from enum import Enum
+from typing import Any
+
+
+class OrderStatus(str, Enum):
+    PENDING = "pending"
+    CONFIRMED = "confirmed"
+    SHIPPED = "shipped"
+    CANCELLED = "cancelled"
+
+
+@dataclass
+class LineItem:
+    sku: str
+    quantity: Any   # should be int — Any disables type checking here
+    unit_price: Any # should be Decimal
+
+
+@dataclass
+class Order:
+    id: Any             # should be str
+    customer_id: Any    # should be str
+    status: Any         # should be OrderStatus
+    items: Any = field(default_factory=list)  # should be list[LineItem]
+    notes: Any = ""
+
+
+def calculate_total(order: Any) -> Any:  # Any on both sides opts out entirely
+    """Return the sum of all line item totals."""
+    return sum(item.quantity * item.unit_price for item in order.items)
+
+
+def apply_coupon(order: Any, discount: Any) -> Any:
+    """Apply a discount — Any parameters make this impossible to type-check."""
+    total = calculate_total(order)
+    if isinstance(discount, int):
+        return total * (1 - Decimal(discount) / 100)
+    return total - discount
+
+
+def transition(order: Any, new_status: Any) -> Any:
+    """Transition an order — all types erased with Any."""
+    allowed: Any = {  # dict type annotation erased
+        OrderStatus.PENDING: {OrderStatus.CONFIRMED, OrderStatus.CANCELLED},
+        OrderStatus.CONFIRMED: {OrderStatus.SHIPPED, OrderStatus.CANCELLED},
+        OrderStatus.SHIPPED: set(),
+        OrderStatus.CANCELLED: set(),
+    }
+    if new_status not in allowed[order.status]:
+        raise ValueError(f"Invalid transition to {new_status}")
+    return Order(
+        id=order.id,
+        customer_id=order.customer_id,
+        status=new_status,
+        items=order.items,
+        notes=order.notes,
+    )
+
+
+def serialize(order: Any) -> Any:  # return type is opaque to callers
+    """Serialize an order — Any return type gives callers no information."""
+    return {
+        "id": order.id,
+        "customer_id": order.customer_id,
+        "status": order.status,
+        "total": str(calculate_total(order)),
+    }
diff --git a/priv/combined_metrics/samples/type_and_value/no_any_type_annotation/good/order_handler.py b/priv/combined_metrics/samples/type_and_value/no_any_type_annotation/good/order_handler.py
new file mode 100644
index 0000000..bf4f2b3
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_any_type_annotation/good/order_handler.py
@@ -0,0 +1,82 @@
+"""Order handler that processes, validates, and fulfils customer orders."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from decimal import Decimal
+from enum import Enum
+from typing import Union
+
+
+class OrderStatus(str, Enum):
+    PENDING = "pending"
+    CONFIRMED = "confirmed"
+    SHIPPED = "shipped"
+    CANCELLED = "cancelled"
+
+
+@dataclass
+class LineItem:
+    sku: str
+    quantity: int
+    unit_price: Decimal
+
+
+@dataclass
+class Order:
+    id: str
+    customer_id: str
+    status: OrderStatus
+    items: list[LineItem] = field(default_factory=list)
+    notes: str = ""
+
+
+def calculate_total(order: Order) -> Decimal:
+    """Return the sum of all line item totals."""
+    return sum(item.quantity * item.unit_price for item in order.items)
+
+
+def apply_coupon(
+    order: Order,
+    discount: Union[Decimal, int],  # explicit union instead of Any
+) -> Decimal:
+    """Apply a flat or percentage discount and return the final total."""
+    total = calculate_total(order)
+    if isinstance(discount, int):
+        # treat int as a percentage
+        return total * (1 - Decimal(discount) / 100)
+    return total - discount
+
+
+def transition(order: Order, new_status: OrderStatus) -> Order:
+    """Return a new Order with the updated status after validating the transition."""
+    allowed: dict[OrderStatus, set[OrderStatus]] = {
+        OrderStatus.PENDING: {OrderStatus.CONFIRMED, OrderStatus.CANCELLED},
+        OrderStatus.CONFIRMED: {OrderStatus.SHIPPED, OrderStatus.CANCELLED},
+        OrderStatus.SHIPPED: set(),
+        OrderStatus.CANCELLED: set(),
+    }
+    if new_status not in allowed[order.status]:
+        raise ValueError(
+            f"Cannot transition order {order.id} from {order.status} to {new_status}"
+        )
+    return Order(
+        id=order.id,
+        customer_id=order.customer_id,
+        status=new_status,
+        items=order.items,
+        notes=order.notes,
+    )
+
+
+def serialize(order: Order) -> dict[str, str | list[dict[str, str | int]]]:
+    """Serialize an order to a JSON-compatible dict with fully typed signature."""
+    return {
+        "id": order.id,
+        "customer_id": order.customer_id,
+        "status": order.status.value,
+        "total": str(calculate_total(order)),
+        "items": [
+            {"sku": item.sku, "quantity": item.quantity, "unit_price": str(item.unit_price)}
+            for item in order.items
+        ],
+    }
diff --git a/priv/combined_metrics/samples/type_and_value/no_boolean_obsession/bad/notifications.ex b/priv/combined_metrics/samples/type_and_value/no_boolean_obsession/bad/notifications.ex
new file mode 100644
index 0000000..075896c
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_boolean_obsession/bad/notifications.ex
@@ -0,0 +1,62 @@
+defmodule MyApp.Notifications do
+  @moduledoc """
+  Notification delivery.
+  """
+
+  alias MyApp.Notifications.{Email, Message}
+
+  # Bad: four boolean flags for mutually exclusive/overlapping states.
+  # What does `send(msg, true, false, false, true)` mean?
+  # Callers must read the source to understand argument order and meaning.
+  @spec send(Message.t(), boolean(), boolean(), boolean(), boolean()) ::
+          :ok | {:error, term()}
+  def send(%Message{} = message, is_async, is_urgent, is_scheduled, is_high_priority) do
+    urgent_message =
+      if is_urgent || is_high_priority do
+        %{message | urgent: true}
+      else
+        message
+      end
+
+    if is_scheduled do
+      Email.schedule(urgent_message)
+    else
+      if is_async do
+        Email.deliver_later(urgent_message)
+      else
+        Email.deliver_now(urgent_message)
+      end
+    end
+  end
+
+  # Bad: boolean to select between email, push, sms — states are mutually exclusive
+  @spec configure_channel(integer(), boolean(), boolean(), boolean()) :: :ok
+  def configure_channel(user_id, use_email, use_push, use_sms) do
+    channel =
+      if use_email do
+        :email
+      else
+        if use_push do
+          :push
+        else
+          if use_sms do
+            :sms
+          else
+            :none
+          end
+        end
+      end
+
+    MyApp.UserPreferences.set(user_id, :notification_channel, channel)
+  end
+
+  # Bad: boolean for batch vs single, and another for async
+  @spec process(Message.t() | [Message.t()], boolean(), boolean()) :: :ok
+  def process(messages, batch, async) do
+    if batch do
+      Enum.each(List.wrap(messages), fn m -> send(m, async, false, false, false) end)
+    else
+      send(messages, async, false, false, false)
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/type_and_value/no_boolean_obsession/good/notifications.ex b/priv/combined_metrics/samples/type_and_value/no_boolean_obsession/good/notifications.ex
new file mode 100644
index 0000000..59b687c
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_boolean_obsession/good/notifications.ex
@@ -0,0 +1,51 @@
+defmodule MyApp.Notifications do
+  @moduledoc """
+  Notification delivery. Uses atoms to represent mutually exclusive
+  modes instead of multiple boolean flags.
+  """
+
+  alias MyApp.Notifications.{Email, Message}
+
+  @type delivery_mode :: :sync | :async | :scheduled
+  @type priority :: :low | :normal | :high | :critical
+
+  @doc """
+  Sends a notification with a given delivery mode and priority.
+  Uses atoms instead of boolean flags for mutually exclusive states.
+  """
+  @spec send(Message.t(), delivery_mode(), priority()) :: :ok | {:error, term()}
+  def send(%Message{} = message, delivery_mode, priority) do
+    message
+    |> maybe_prioritize(priority)
+    |> dispatch(delivery_mode)
+  end
+
+  @doc """
+  Enqueues a batch of notifications using the specified delivery mode.
+  """
+  @spec enqueue_batch([Message.t()], delivery_mode()) :: {:ok, integer()} | {:error, term()}
+  def enqueue_batch(messages, delivery_mode) when is_list(messages) do
+    messages
+    |> Enum.map(&enqueue(&1, delivery_mode))
+    |> Enum.split_with(&match?({:ok, _}, &1))
+    |> then(fn {successes, _failures} -> {:ok, length(successes)} end)
+  end
+
+  @doc """
+  Configures the notification channel. Mode is one of `:email`, `:push`, `:sms`.
+  """
+  @spec configure_channel(integer(), :email | :push | :sms) :: :ok
+  def configure_channel(user_id, channel_type) when channel_type in [:email, :push, :sms] do
+    MyApp.UserPreferences.set(user_id, :notification_channel, channel_type)
+  end
+
+  defp maybe_prioritize(message, :critical), do: %{message | urgent: true}
+  defp maybe_prioritize(message, :high), do: %{message | urgent: true}
+  defp maybe_prioritize(message, _), do: message
+
+  defp dispatch(message, :sync), do: Email.deliver_now(message)
+  defp dispatch(message, :async), do: Email.deliver_later(message)
+  defp dispatch(message, :scheduled), do: Email.schedule(message)
+
+  defp enqueue(message, mode), do: dispatch(message, mode)
+end
diff --git a/priv/combined_metrics/samples/type_and_value/no_c_style_casts/bad/Buffer.cpp b/priv/combined_metrics/samples/type_and_value/no_c_style_casts/bad/Buffer.cpp
new file mode 100644
index 0000000..e14615f
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_c_style_casts/bad/Buffer.cpp
@@ -0,0 +1,65 @@
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <stdexcept>
+#include <vector>
+
+class Buffer {
+public:
+    explicit Buffer(std::size_t capacity)
+        : data_(new uint8_t[capacity])
+        , capacity_(capacity)
+        , size_(0)
+    {}
+
+    ~Buffer() { delete[] data_; }
+
+    void writeInt32(int32_t value) {
+        if (size_ + sizeof(int32_t) > capacity_)
+            throw std::overflow_error("Buffer capacity exceeded");
+
+        // C-style cast: unclear whether this is a reinterpret, static, or const cast
+        std::memcpy(data_ + size_, (const uint8_t*)(&value), sizeof(int32_t));
+        size_ += sizeof(int32_t);
+    }
+
+    int32_t readInt32(std::size_t offset) const {
+        if (offset + sizeof(int32_t) > size_)
+            throw std::out_of_range("Read past end of buffer");
+
+        int32_t value;
+        std::memcpy(&value, data_ + offset, sizeof(int32_t));
+        return value;
+    }
+
+    // C-style cast: hides potential narrowing from uint64_t to double
+    double averageByteValue() const {
+        if (size_ == 0) return 0.0;
+        uint64_t sum = 0;
+        for (std::size_t i = 0; i < size_; ++i)
+            sum += data_[i];
+        return (double)sum / (double)size_; // C-style cast — intent unclear
+    }
+
+    // C-style cast removes const — silent and dangerous; no indication it's intentional
+    void legacyCopy(const uint8_t* src, std::size_t length) {
+        uint8_t* mutableSrc = (uint8_t*)src; // strips const — could allow modification
+        std::memcpy(data_ + size_, mutableSrc, length);
+        size_ += length;
+    }
+
+    // C-style cast from unrelated pointer types — undefined behavior; reinterpret_cast
+    // would at least make the danger explicit
+    void writeRawObject(const void* obj, std::size_t bytes) {
+        const uint8_t* raw = (const uint8_t*)obj; // C-style cast of void*
+        std::memcpy(data_ + size_, raw, bytes);
+        size_ += bytes;
+    }
+
+    std::size_t size() const { return size_; }
+
+private:
+    uint8_t* data_;
+    std::size_t capacity_;
+    std::size_t size_;
+};
diff --git a/priv/combined_metrics/samples/type_and_value/no_c_style_casts/good/Buffer.cpp b/priv/combined_metrics/samples/type_and_value/no_c_style_casts/good/Buffer.cpp
new file mode 100644
index 0000000..b69d3d9
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_c_style_casts/good/Buffer.cpp
@@ -0,0 +1,60 @@
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <stdexcept>
+#include <vector>
+
+// All type conversions use named C++ casts — intent is explicit and greppable
+
+class Buffer {
+public:
+    explicit Buffer(std::size_t capacity)
+        : data_(std::make_unique<uint8_t[]>(capacity))
+        , capacity_(capacity)
+        , size_(0)
+    {}
+
+    void writeInt32(int32_t value) {
+        if (size_ + sizeof(int32_t) > capacity_)
+            throw std::overflow_error("Buffer capacity exceeded");
+
+        // reinterpret_cast: deliberately reinterpreting an int as raw bytes
+        std::memcpy(data_.get() + size_,
+                    reinterpret_cast<const uint8_t*>(&value), sizeof(int32_t));
+        size_ += sizeof(int32_t);
+    }
+
+    int32_t readInt32(std::size_t offset) const {
+        if (offset + sizeof(int32_t) > size_)
+            throw std::out_of_range("Read past end of buffer");
+
+        int32_t value;
+        std::memcpy(&value, data_.get() + offset, sizeof(int32_t));
+        return value;
+    }
+
+    // static_cast: safe numeric widening
+    double averageByteValue() const noexcept {
+        if (size_ == 0) return 0.0;
+        uint64_t sum = 0;
+        for (std::size_t i = 0; i < size_; ++i)
+            sum += data_[i];
+        return static_cast<double>(sum) / static_cast<double>(size_);
+    }
+
+    // const_cast: explicitly removing const to call a legacy C API that promises
+    // not to modify the data — documented and intentional
+    void legacyCopy(const uint8_t* src, std::size_t length) {
+        (void)const_cast<uint8_t*>(src); // would be used to pass to a non-const C API
+        std::memcpy(data_.get() + size_, src, length);
+        size_ += length;
+    }
+
+    std::size_t size() const noexcept { return size_; }
+    std::size_t capacity() const noexcept { return capacity_; }
+
+private:
+    std::unique_ptr<uint8_t[]> data_;
+    std::size_t capacity_;
+    std::size_t size_;
+};
diff --git a/priv/combined_metrics/samples/type_and_value/no_comparison_to_true_false/bad/feature_flags.py b/priv/combined_metrics/samples/type_and_value/no_comparison_to_true_false/bad/feature_flags.py
new file mode 100644
index 0000000..0873a1e
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_comparison_to_true_false/bad/feature_flags.py
@@ -0,0 +1,69 @@
+"""Feature flag service that controls rollout of product features."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class Flag:
+    name: str
+    enabled: bool
+    description: str
+    rollout_percent: int = 100
+
+
+_FLAGS: dict[str, Flag] = {}
+
+
+def register(flag: Flag) -> None:
+    _FLAGS[flag.name] = flag
+
+
+def is_enabled(name: str) -> bool:
+    """Boolean comparison via == True instead of truthiness test."""
+    flag = _FLAGS.get(name)
+    if flag is None:
+        return False
+    if flag.enabled == True:    # unnecessary — bool is already truthy/falsy
+        return True
+    return False
+
+
+def is_disabled(name: str) -> bool:
+    """Boolean comparison via == False instead of 'not'."""
+    flag = _FLAGS.get(name)
+    if flag is None:
+        return True
+    if flag.enabled == False:   # unnecessary — just use 'not flag.enabled'
+        return True
+    return False
+
+
+def get_active_flags() -> list[Flag]:
+    """List comprehension filters via == True."""
+    return [f for f in _FLAGS.values() if f.enabled == True]   # redundant comparison
+
+
+def get_inactive_flags() -> list[Flag]:
+    """List comprehension filters via == False."""
+    return [f for f in _FLAGS.values() if f.enabled == False]  # redundant comparison
+
+
+def toggle(name: str, enabled: bool) -> Optional[Flag]:
+    flag = _FLAGS.get(name)
+    if flag is None:
+        return None
+    if enabled == True:         # 'if enabled:' is sufficient
+        flag.enabled = True
+    elif enabled == False:      # 'else' is sufficient
+        flag.enabled = False
+    return flag
+
+
+def summarise() -> dict[str, bool]:
+    """Build mapping — compares booleans redundantly before storing."""
+    return {
+        name: True if flag.enabled == True else False  # triple redundancy
+        for name, flag in _FLAGS.items()
+    }
diff --git a/priv/combined_metrics/samples/type_and_value/no_comparison_to_true_false/good/feature_flags.py b/priv/combined_metrics/samples/type_and_value/no_comparison_to_true_false/good/feature_flags.py
new file mode 100644
index 0000000..3469f66
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_comparison_to_true_false/good/feature_flags.py
@@ -0,0 +1,61 @@
+"""Feature flag service that controls rollout of product features."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class Flag:
+    name: str
+    enabled: bool
+    description: str
+    rollout_percent: int = 100
+
+
+_FLAGS: dict[str, Flag] = {}
+
+
+def register(flag: Flag) -> None:
+    """Register a feature flag."""
+    _FLAGS[flag.name] = flag
+
+
+def is_enabled(name: str) -> bool:
+    """Return True if the named flag exists and is enabled."""
+    flag = _FLAGS.get(name)
+    if flag is None:
+        return False
+    return flag.enabled  # truthiness, not == True
+
+
+def is_disabled(name: str) -> bool:
+    """Return True if the flag is explicitly disabled."""
+    flag = _FLAGS.get(name)
+    if flag is None:
+        return True
+    return not flag.enabled  # negate truthiness, not == False
+
+
+def get_active_flags() -> list[Flag]:
+    """Return all flags that are currently enabled."""
+    return [f for f in _FLAGS.values() if f.enabled]   # truthiness test
+
+
+def get_inactive_flags() -> list[Flag]:
+    """Return all flags that are currently disabled."""
+    return [f for f in _FLAGS.values() if not f.enabled]
+
+
+def toggle(name: str, enabled: bool) -> Optional[Flag]:
+    """Set the enabled state of a flag and return the updated flag."""
+    flag = _FLAGS.get(name)
+    if flag is None:
+        return None
+    flag.enabled = enabled
+    return flag
+
+
+def summarise() -> dict[str, bool]:
+    """Return a name → enabled mapping for all registered flags."""
+    return {name: flag.enabled for name, flag in _FLAGS.items()}
diff --git a/priv/combined_metrics/samples/type_and_value/no_double_type_assertion/bad/user_service.ts b/priv/combined_metrics/samples/type_and_value/no_double_type_assertion/bad/user_service.ts
new file mode 100644
index 0000000..6740cb2
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_double_type_assertion/bad/user_service.ts
@@ -0,0 +1,44 @@
+interface AdminUser {
+  id: string;
+  email: string;
+  role: "admin";
+  permissions: string[];
+}
+
+interface GuestUser {
+  sessionId: string;
+  role: "guest";
+  expiresAt: number;
+}
+
+type AnyUser = AdminUser | GuestUser;
+
+function getAdminPermissions(user: AnyUser): string[] {
+  // Double type assertion: AnyUser -> unknown -> AdminUser
+  const admin = user as unknown as AdminUser;
+  return admin.permissions;
+}
+
+function parseApiResponse(raw: unknown): AnyUser {
+  // Double type assertion bypasses structural check
+  return raw as unknown as AnyUser;
+}
+
+function coerceToAdminUser(obj: object): AdminUser {
+  // Double assertion to force incompatible type
+  return obj as unknown as AdminUser;
+}
+
+function extractUserId(data: Response): string {
+  // Double assertion through unrelated types
+  const user = data as unknown as AdminUser;
+  return user.id;
+}
+
+function forceGuestUser(user: AdminUser): GuestUser {
+  // Double assertion between two unrelated types
+  return user as unknown as GuestUser;
+}
+
+export { getAdminPermissions, parseApiResponse, coerceToAdminUser, extractUserId, forceGuestUser };
+export type { AdminUser, GuestUser, AnyUser };
diff --git a/priv/combined_metrics/samples/type_and_value/no_double_type_assertion/good/user_service.ts b/priv/combined_metrics/samples/type_and_value/no_double_type_assertion/good/user_service.ts
new file mode 100644
index 0000000..0b9c52f
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_double_type_assertion/good/user_service.ts
@@ -0,0 +1,67 @@
+interface AdminUser {
+  id: string;
+  email: string;
+  role: "admin";
+  permissions: string[];
+}
+
+interface GuestUser {
+  sessionId: string;
+  role: "guest";
+  expiresAt: number;
+}
+
+type AnyUser = AdminUser | GuestUser;
+
+function isAdminUser(user: AnyUser): user is AdminUser {
+  return user.role === "admin";
+}
+
+function isGuestUser(user: AnyUser): user is GuestUser {
+  return user.role === "guest";
+}
+
+function getAdminPermissions(user: AnyUser): string[] {
+  if (!isAdminUser(user)) {
+    throw new Error("User is not an admin");
+  }
+  return user.permissions;
+}
+
+function parseApiResponse(raw: unknown): AnyUser {
+  if (typeof raw !== "object" || raw === null) {
+    throw new TypeError("Expected an object");
+  }
+
+  const obj = raw as Record<string, unknown>;
+
+  if (obj["role"] === "admin") {
+    if (typeof obj["id"] !== "string" || typeof obj["email"] !== "string") {
+      throw new TypeError("Invalid admin user shape");
+    }
+    return {
+      id: obj["id"],
+      email: obj["email"],
+      role: "admin",
+      permissions: Array.isArray(obj["permissions"])
+        ? (obj["permissions"] as string[])
+        : [],
+    };
+  }
+
+  if (obj["role"] === "guest") {
+    if (typeof obj["sessionId"] !== "string" || typeof obj["expiresAt"] !== "number") {
+      throw new TypeError("Invalid guest user shape");
+    }
+    return {
+      sessionId: obj["sessionId"],
+      role: "guest",
+      expiresAt: obj["expiresAt"],
+    };
+  }
+
+  throw new TypeError(`Unknown user role: ${obj["role"]}`);
+}
+
+export { getAdminPermissions, parseApiResponse, isAdminUser, isGuestUser };
+export type { AdminUser, GuestUser, AnyUser };
diff --git a/priv/combined_metrics/samples/type_and_value/no_duplicate_enum_values/bad/notification_handler.ts b/priv/combined_metrics/samples/type_and_value/no_duplicate_enum_values/bad/notification_handler.ts
new file mode 100644
index 0000000..7775c42
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_duplicate_enum_values/bad/notification_handler.ts
@@ -0,0 +1,51 @@
+enum NotificationPriority {
+  Low = 1,
+  Medium = 2,
+  Normal = 2,   // Duplicate of Medium
+  High = 3,
+  Urgent = 3,   // Duplicate of High
+  Critical = 4,
+}
+
+enum NotificationChannel {
+  Email = "email",
+  EmailDigest = "email",  // Duplicate of Email
+  Push = "push",
+  MobilePush = "push",    // Duplicate of Push
+  Sms = "sms",
+  InApp = "in_app",
+}
+
+enum NotificationStatus {
+  Queued = "queued",
+  Pending = "queued",     // Duplicate of Queued
+  Sending = "sending",
+  InFlight = "sending",   // Duplicate of Sending
+  Delivered = "delivered",
+  Failed = "failed",
+  Cancelled = "cancelled",
+}
+
+interface Notification {
+  id: string;
+  priority: NotificationPriority;
+  channel: NotificationChannel;
+  status: NotificationStatus;
+  title: string;
+  body: string;
+  scheduledAt: number;
+}
+
+function shouldSendImmediately(notification: Notification): boolean {
+  return notification.priority >= NotificationPriority.High;
+}
+
+function isDeliverable(notification: Notification): boolean {
+  return (
+    notification.status === NotificationStatus.Queued ||
+    notification.status === NotificationStatus.Sending
+  );
+}
+
+export { NotificationPriority, NotificationChannel, NotificationStatus, shouldSendImmediately, isDeliverable };
+export type { Notification };
diff --git a/priv/combined_metrics/samples/type_and_value/no_duplicate_enum_values/good/notification_handler.ts b/priv/combined_metrics/samples/type_and_value/no_duplicate_enum_values/good/notification_handler.ts
new file mode 100644
index 0000000..2c62f62
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_duplicate_enum_values/good/notification_handler.ts
@@ -0,0 +1,58 @@
+enum NotificationPriority {
+  Low = 1,
+  Medium = 2,
+  High = 3,
+  Critical = 4,
+}
+
+enum NotificationChannel {
+  Email = "email",
+  Push = "push",
+  Sms = "sms",
+  InApp = "in_app",
+}
+
+enum NotificationStatus {
+  Queued = "queued",
+  Sending = "sending",
+  Delivered = "delivered",
+  Failed = "failed",
+  Cancelled = "cancelled",
+}
+
+interface Notification {
+  id: string;
+  priority: NotificationPriority;
+  channel: NotificationChannel;
+  status: NotificationStatus;
+  title: string;
+  body: string;
+  scheduledAt: number;
+}
+
+function shouldSendImmediately(notification: Notification): boolean {
+  return notification.priority >= NotificationPriority.High;
+}
+
+function getRetryDelay(priority: NotificationPriority): number {
+  switch (priority) {
+    case NotificationPriority.Critical:
+      return 5_000;
+    case NotificationPriority.High:
+      return 30_000;
+    case NotificationPriority.Medium:
+      return 60_000;
+    case NotificationPriority.Low:
+      return 300_000;
+  }
+}
+
+function isDeliverable(notification: Notification): boolean {
+  return (
+    notification.status === NotificationStatus.Queued ||
+    notification.status === NotificationStatus.Sending
+  );
+}
+
+export { NotificationPriority, NotificationChannel, NotificationStatus, shouldSendImmediately, getRetryDelay, isDeliverable };
+export type { Notification };
diff --git a/priv/combined_metrics/samples/type_and_value/no_dynamic_atom_creation_from_external_input/bad/analytics.ex b/priv/combined_metrics/samples/type_and_value/no_dynamic_atom_creation_from_external_input/bad/analytics.ex
new file mode 100644
index 0000000..fa4dcd9
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_dynamic_atom_creation_from_external_input/bad/analytics.ex
@@ -0,0 +1,46 @@
+defmodule MyApp.Analytics do
+  @moduledoc """
+  Event tracking.
+  """
+
+  # Bad: converts user-supplied event names directly to atoms.
+  # Atoms are never garbage collected — an attacker can exhaust
+  # the atom table by sending many unique event names.
+  @spec record_event(String.t(), map()) :: :ok
+  def record_event(event_name, properties) when is_binary(event_name) do
+    event_atom = String.to_atom(event_name)
+    :telemetry.execute([:my_app, :analytics, event_atom], properties, %{})
+    :ok
+  end
+
+  # Bad: converts an HTTP query parameter directly to an atom
+  @spec resolve_metric(String.t()) :: atom()
+  def resolve_metric(metric_name) when is_binary(metric_name) do
+    String.to_atom(metric_name)
+  end
+
+  # Bad: converting user-supplied field names to atoms for Map.get
+  @spec get_property(map(), String.t()) :: any()
+  def get_property(event, field_name) when is_binary(field_name) do
+    key = String.to_atom(field_name)
+    Map.get(event, key)
+  end
+
+  # Bad: building a struct from user-controlled keys by converting to atoms
+  @spec build_filter(map()) :: map()
+  def build_filter(params) when is_map(params) do
+    params
+    |> Enum.map(fn {k, v} -> {String.to_atom(k), v} end)
+    |> Map.new()
+  end
+
+  # Bad: using String.to_atom on data from an external JSON payload
+  @spec process_webhook(map()) :: :ok
+  def process_webhook(%{"type" => type} = payload) do
+    event_type = String.to_atom(type)
+    handle_event(event_type, payload)
+    :ok
+  end
+
+  defp handle_event(_type, _payload), do: :ok
+end
diff --git a/priv/combined_metrics/samples/type_and_value/no_dynamic_atom_creation_from_external_input/good/analytics.ex b/priv/combined_metrics/samples/type_and_value/no_dynamic_atom_creation_from_external_input/good/analytics.ex
new file mode 100644
index 0000000..2f53124
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_dynamic_atom_creation_from_external_input/good/analytics.ex
@@ -0,0 +1,53 @@
+defmodule MyApp.Analytics do
+  @moduledoc """
+  Event tracking. Safely converts external string event names to atoms
+  using a whitelist — never calls `String.to_atom/1` on user input.
+  """
+
+  @allowed_events ~w[page_view button_click form_submit purchase checkout_start]
+
+  @doc """
+  Records a named event from external input. Validates the event name
+  against an allowed list before converting to atom.
+  """
+  @spec record_event(String.t(), map()) :: :ok | {:error, :unknown_event}
+  def record_event(event_name, properties) when is_binary(event_name) do
+    with {:ok, event_atom} <- to_event_atom(event_name) do
+      :telemetry.execute([:my_app, :analytics, event_atom], properties, %{})
+      :ok
+    end
+  end
+
+  @doc """
+  Looks up a metric type from a string key provided by an API client.
+  Uses `String.to_existing_atom/1` only after validating against known atoms.
+  """
+  @spec resolve_metric(String.t()) :: {:ok, atom()} | {:error, :unknown_metric}
+  def resolve_metric(metric_name) when is_binary(metric_name) do
+    case metric_name do
+      "revenue" -> {:ok, :revenue}
+      "orders" -> {:ok, :orders}
+      "sessions" -> {:ok, :sessions}
+      "conversion_rate" -> {:ok, :conversion_rate}
+      _ -> {:error, :unknown_metric}
+    end
+  end
+
+  @doc """
+  Parses a filter operator from a query parameter string.
+  Uses a known-good mapping rather than dynamic atom creation.
+  """
+  @spec parse_operator(String.t()) :: {:ok, :eq | :gt | :lt | :gte | :lte} | {:error, :invalid_operator}
+  def parse_operator("eq"), do: {:ok, :eq}
+  def parse_operator("gt"), do: {:ok, :gt}
+  def parse_operator("lt"), do: {:ok, :lt}
+  def parse_operator("gte"), do: {:ok, :gte}
+  def parse_operator("lte"), do: {:ok, :lte}
+  def parse_operator(_), do: {:error, :invalid_operator}
+
+  defp to_event_atom(name) when name in @allowed_events do
+    {:ok, String.to_existing_atom(name)}
+  end
+
+  defp to_event_atom(_), do: {:error, :unknown_event}
+end
diff --git a/priv/combined_metrics/samples/type_and_value/no_empty_string_initial/bad/builder.ex b/priv/combined_metrics/samples/type_and_value/no_empty_string_initial/bad/builder.ex
new file mode 100644
index 0000000..1ef4446
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_empty_string_initial/bad/builder.ex
@@ -0,0 +1,88 @@
+defmodule Message.Builder do
+  @moduledoc """
+  String/message builder — BAD: variables initialized to empty string as sentinel values.
+  """
+
+  def build_greeting(user) do
+    salutation = ""
+    name = ""
+
+    salutation =
+      if user.gender == :female do
+        "Ms."
+      else
+        "Mr."
+      end
+
+    name =
+      if user.preferred_name != nil do
+        user.preferred_name
+      else
+        user.first_name
+      end
+
+    "Dear #{salutation} #{name},"
+  end
+
+  def format_address(address) do
+    line1 = ""
+    line2 = ""
+    city_line = ""
+
+    line1 = address.street
+
+    line2 =
+      if address.unit != nil do
+        "Unit #{address.unit}"
+      else
+        ""
+      end
+
+    city_line = "#{address.city}, #{address.state} #{address.zip}"
+
+    parts =
+      if line2 == "" do
+        [line1, city_line]
+      else
+        [line1, line2, city_line]
+      end
+
+    Enum.join(parts, "\n")
+  end
+
+  def build_subject(event) do
+    prefix = ""
+    suffix = ""
+
+    prefix =
+      if event.priority == :high do
+        "[URGENT] "
+      else
+        ""
+      end
+
+    suffix =
+      if event.reference != nil do
+        " (ref: #{event.reference})"
+      else
+        ""
+      end
+
+    "#{prefix}#{event.title}#{suffix}"
+  end
+
+  def compose_footer(opts) do
+    disclaimer = ""
+    unsubscribe = ""
+
+    if opts.legal do
+      disclaimer = "This message is confidential."
+    end
+
+    if opts.marketing do
+      unsubscribe = "Unsubscribe at any time."
+    end
+
+    Enum.join(Enum.reject([disclaimer, unsubscribe], &(&1 == "")), " | ")
+  end
+end
diff --git a/priv/combined_metrics/samples/type_and_value/no_empty_string_initial/config.yml b/priv/combined_metrics/samples/type_and_value/no_empty_string_initial/config.yml
new file mode 100644
index 0000000..fd377b3
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_empty_string_initial/config.yml
@@ -0,0 +1 @@
+doc: "Initialising a variable to an empty string and reassigning later signals missing structure."
diff --git a/priv/combined_metrics/samples/type_and_value/no_empty_string_initial/good/builder.ex b/priv/combined_metrics/samples/type_and_value/no_empty_string_initial/good/builder.ex
new file mode 100644
index 0000000..c131c28
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_empty_string_initial/good/builder.ex
@@ -0,0 +1,48 @@
+defmodule Message.Builder do
+  @moduledoc """
+  String/message builder — GOOD: nil or pattern matching used instead of empty string sentinels.
+  """
+
+  def build_greeting(%{gender: :female} = user) do
+    name = user.preferred_name || user.first_name
+    "Dear Ms. #{name},"
+  end
+
+  def build_greeting(user) do
+    name = user.preferred_name || user.first_name
+    "Dear Mr. #{name},"
+  end
+
+  def format_address(address) do
+    parts =
+      [
+        address.street,
+        unit_line(address.unit),
+        "#{address.city}, #{address.state} #{address.zip}"
+      ]
+      |> Enum.reject(&is_nil/1)
+
+    Enum.join(parts, "\n")
+  end
+
+  def build_subject(event) do
+    prefix = if event.priority == :high, do: "[URGENT] ", else: nil
+    suffix = if event.reference, do: " (ref: #{event.reference})", else: nil
+
+    [prefix, event.title, suffix]
+    |> Enum.reject(&is_nil/1)
+    |> Enum.join()
+  end
+
+  def compose_footer(opts) do
+    [
+      if(opts.legal, do: "This message is confidential.", else: nil),
+      if(opts.marketing, do: "Unsubscribe at any time.", else: nil)
+    ]
+    |> Enum.reject(&is_nil/1)
+    |> Enum.join(" | ")
+  end
+
+  defp unit_line(nil), do: nil
+  defp unit_line(unit), do: "Unit #{unit}"
+end
diff --git a/priv/combined_metrics/samples/type_and_value/no_explicit_any/bad/user_service.ts b/priv/combined_metrics/samples/type_and_value/no_explicit_any/bad/user_service.ts
new file mode 100644
index 0000000..a8774c5
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_explicit_any/bad/user_service.ts
@@ -0,0 +1,55 @@
+async function fetchUser(userId: string): Promise<any> {
+  const response = await fetch(`/api/users/${userId}`);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch user ${userId}: ${response.status}`);
+  }
+
+  return response.json();
+}
+
+async function createUser(payload: any): Promise<any> {
+  const response = await fetch("/api/users", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload),
+  });
+
+  if (!response.ok) {
+    const error: any = await response.json();
+    throw new Error(error.message);
+  }
+
+  return response.json();
+}
+
+async function updateUser(userId: string, changes: any): Promise<any> {
+  const response = await fetch(`/api/users/${userId}`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(changes),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to update user: ${response.status}`);
+  }
+
+  return response.json();
+}
+
+function isAdmin(user: any): boolean {
+  return user.role === "admin";
+}
+
+function formatUserDisplay(user: any): string {
+  return `${user.displayName} (${user.email})`;
+}
+
+function processUserList(users: any[]): any[] {
+  return users.filter((u: any) => u.role !== "viewer").map((u: any) => ({
+    id: u.id,
+    label: formatUserDisplay(u),
+  }));
+}
+
+export { fetchUser, createUser, updateUser, isAdmin, processUserList };
diff --git a/priv/combined_metrics/samples/type_and_value/no_explicit_any/good/user_service.ts b/priv/combined_metrics/samples/type_and_value/no_explicit_any/good/user_service.ts
new file mode 100644
index 0000000..2519b1d
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_explicit_any/good/user_service.ts
@@ -0,0 +1,75 @@
+interface User {
+  id: string;
+  email: string;
+  displayName: string;
+  role: "admin" | "member" | "viewer";
+  createdAt: string;
+}
+
+interface CreateUserPayload {
+  email: string;
+  displayName: string;
+  role: User["role"];
+}
+
+interface UpdateUserPayload {
+  displayName?: string;
+  role?: User["role"];
+}
+
+interface ApiResponse<T> {
+  data: T;
+  meta: {
+    requestId: string;
+    timestamp: string;
+  };
+}
+
+async function fetchUser(userId: string): Promise<User> {
+  const response = await fetch(`/api/users/${userId}`);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch user ${userId}: ${response.status}`);
+  }
+
+  const body: ApiResponse<User> = await response.json();
+  return body.data;
+}
+
+async function createUser(payload: CreateUserPayload): Promise<User> {
+  const response = await fetch("/api/users", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload),
+  });
+
+  if (!response.ok) {
+    const error: { message: string } = await response.json();
+    throw new Error(error.message);
+  }
+
+  const body: ApiResponse<User> = await response.json();
+  return body.data;
+}
+
+async function updateUser(userId: string, changes: UpdateUserPayload): Promise<User> {
+  const response = await fetch(`/api/users/${userId}`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(changes),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to update user: ${response.status}`);
+  }
+
+  const body: ApiResponse<User> = await response.json();
+  return body.data;
+}
+
+function isAdmin(user: User): boolean {
+  return user.role === "admin";
+}
+
+export { fetchUser, createUser, updateUser, isAdmin };
+export type { User, CreateUserPayload, UpdateUserPayload };
diff --git a/priv/combined_metrics/samples/type_and_value/no_implicit_null_initial/bad/loader.ex b/priv/combined_metrics/samples/type_and_value/no_implicit_null_initial/bad/loader.ex
new file mode 100644
index 0000000..3db9109
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_implicit_null_initial/bad/loader.ex
@@ -0,0 +1,89 @@
+defmodule Data.Loader do
+  @moduledoc """
+  Data loader — BAD: variables initialized to nil then conditionally assigned.
+  """
+
+  def load_user_profile(user_id) do
+    profile = nil
+    avatar = nil
+    preferences = nil
+
+    user = fetch_user(user_id)
+
+    if user != nil do
+      profile = build_profile(user)
+
+      if user.has_avatar do
+        avatar = fetch_avatar(user.id)
+      end
+
+      if user.preferences_enabled do
+        preferences = load_preferences(user.id)
+      end
+    end
+
+    %{profile: profile, avatar: avatar, preferences: preferences}
+  end
+
+  def resolve_config(env) do
+    db_url = nil
+    pool_size = nil
+    log_level = nil
+
+    if env == :prod do
+      db_url = System.get_env("DATABASE_URL")
+      pool_size = 20
+      log_level = :warn
+    end
+
+    if env == :dev do
+      db_url = "postgres://localhost/myapp_dev"
+      pool_size = 5
+      log_level = :debug
+    end
+
+    %{db_url: db_url, pool_size: pool_size, log_level: log_level}
+  end
+
+  def fetch_report(report_id, opts) do
+    result = nil
+    cached = nil
+
+    if opts[:cache] do
+      cached = lookup_cache(report_id)
+    end
+
+    if cached != nil do
+      result = cached
+    else
+      result = generate_report(report_id)
+    end
+
+    result
+  end
+
+  def load_order_details(order_id) do
+    order = nil
+    items = nil
+    shipping = nil
+
+    order = fetch_order(order_id)
+
+    if order != nil do
+      items = fetch_items(order.id)
+      shipping = fetch_shipping(order.id)
+    end
+
+    {order, items, shipping}
+  end
+
+  defp fetch_user(id), do: %{id: id, has_avatar: true, preferences_enabled: false}
+  defp build_profile(u), do: %{id: u.id}
+  defp fetch_avatar(id), do: "avatar_#{id}.png"
+  defp load_preferences(id), do: %{theme: :dark, id: id}
+  defp lookup_cache(_id), do: nil
+  defp generate_report(id), do: %{id: id, data: []}
+  defp fetch_order(id), do: %{id: id}
+  defp fetch_items(id), do: [%{order_id: id}]
+  defp fetch_shipping(id), do: %{order_id: id}
+end
diff --git a/priv/combined_metrics/samples/type_and_value/no_implicit_null_initial/config.yml b/priv/combined_metrics/samples/type_and_value/no_implicit_null_initial/config.yml
new file mode 100644
index 0000000..beda133
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_implicit_null_initial/config.yml
@@ -0,0 +1 @@
+doc: "Initialising a variable to `nil`/`null` and assigning it later in a branch signals missing structure."
diff --git a/priv/combined_metrics/samples/type_and_value/no_implicit_null_initial/good/loader.ex b/priv/combined_metrics/samples/type_and_value/no_implicit_null_initial/good/loader.ex
new file mode 100644
index 0000000..186927c
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_implicit_null_initial/good/loader.ex
@@ -0,0 +1,68 @@
+defmodule Data.Loader do
+  @moduledoc """
+  Data loader — GOOD: values assigned directly from expressions, with/case used for branching.
+  """
+
+  def load_user_profile(user_id) do
+    case fetch_user(user_id) do
+      nil ->
+        %{profile: nil, avatar: nil, preferences: nil}
+
+      user ->
+        avatar = if user.has_avatar, do: fetch_avatar(user.id), else: nil
+        preferences = if user.preferences_enabled, do: load_preferences(user.id), else: nil
+
+        %{profile: build_profile(user), avatar: avatar, preferences: preferences}
+    end
+  end
+
+  def resolve_config(:prod) do
+    %{
+      db_url: System.get_env("DATABASE_URL"),
+      pool_size: 20,
+      log_level: :warn
+    }
+  end
+
+  def resolve_config(:dev) do
+    %{
+      db_url: "postgres://localhost/myapp_dev",
+      pool_size: 5,
+      log_level: :debug
+    }
+  end
+
+  def resolve_config(_env) do
+    %{db_url: nil, pool_size: nil, log_level: nil}
+  end
+
+  def fetch_report(report_id, opts) do
+    if opts[:cache] do
+      lookup_cache(report_id) || generate_report(report_id)
+    else
+      generate_report(report_id)
+    end
+  end
+
+  def load_order_details(order_id) do
+    case fetch_order(order_id) do
+      nil ->
+        {nil, nil, nil}
+
+      order ->
+        items = fetch_items(order.id)
+        shipping = fetch_shipping(order.id)
+        {order, items, shipping}
+    end
+  end
+
+  defp fetch_user(id), do: %{id: id, has_avatar: true, preferences_enabled: false}
+  defp build_profile(u), do: %{id: u.id}
+  defp fetch_avatar(id), do: "avatar_#{id}.png"
+  defp load_preferences(id), do: %{theme: :dark, id: id}
+  defp lookup_cache(_id), do: nil
+  defp generate_report(id), do: %{id: id, data: []}
+  defp fetch_order(id), do: %{id: id}
+  defp fetch_items(id), do: [%{order_id: id}]
+  defp fetch_shipping(id), do: %{order_id: id}
+end
diff --git a/priv/combined_metrics/samples/type_and_value/no_magic_value_assigned/bad/roles.ex b/priv/combined_metrics/samples/type_and_value/no_magic_value_assigned/bad/roles.ex
new file mode 100644
index 0000000..ccd3041
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_magic_value_assigned/bad/roles.ex
@@ -0,0 +1,64 @@
+defmodule Access.Roles do
+  @moduledoc """
+  Role/permission management — BAD: hardcoded magic strings used for statuses and roles.
+  """
+
+  def assign_role(user, role_name) do
+    case role_name do
+      "superadmin_lvl2" ->
+        %{user | role: "superadmin_lvl2", permissions: "all_access_unrestricted"}
+
+      "admin_standard" ->
+        %{user | role: "admin_standard", permissions: "read_write_no_delete"}
+
+      "moderator_basic" ->
+        %{user | role: "moderator_basic", permissions: "read_write_flag"}
+
+      "member_verified" ->
+        %{user | role: "member_verified", permissions: "read_write"}
+
+      "member_unverified" ->
+        %{user | role: "member_unverified", permissions: "read_only"}
+
+      _ ->
+        %{user | role: "guest_anonymous", permissions: "read_only_public"}
+    end
+  end
+
+  def can_access?(user, resource) do
+    status = user.account_status
+
+    if status == "active_premium_verified" or status == "active_standard_verified" do
+      check_resource_permission(user.permissions, resource)
+    else
+      false
+    end
+  end
+
+  defp check_resource_permission(permissions, _resource) do
+    permissions in ["all_access_unrestricted", "read_write_no_delete", "read_write"]
+  end
+
+  def get_subscription_tier(user) do
+    case user.plan_code do
+      "plan_free_tier_v1" -> "Free"
+      "plan_basic_monthly_v2" -> "Basic"
+      "plan_pro_annual_v3" -> "Pro"
+      "plan_enterprise_custom_v4" -> "Enterprise"
+      _ -> "Unknown"
+    end
+  end
+
+  def set_account_status(user, event) do
+    new_status =
+      case event do
+        "email_confirmed" -> "active_standard_verified"
+        "upgrade_to_premium" -> "active_premium_verified"
+        "account_suspended" -> "suspended_policy_violation"
+        "account_closed" -> "closed_user_request"
+        _ -> "pending_review_required"
+      end
+
+    %{user | account_status: new_status}
+  end
+end
diff --git a/priv/combined_metrics/samples/type_and_value/no_magic_value_assigned/config.yml b/priv/combined_metrics/samples/type_and_value/no_magic_value_assigned/config.yml
new file mode 100644
index 0000000..bb184e6
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_magic_value_assigned/config.yml
@@ -0,0 +1 @@
+doc: "Literal strings and numbers assigned to variables should be named constants, not inline values."
diff --git a/priv/combined_metrics/samples/type_and_value/no_magic_value_assigned/good/roles.ex b/priv/combined_metrics/samples/type_and_value/no_magic_value_assigned/good/roles.ex
new file mode 100644
index 0000000..0fb27cb
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_magic_value_assigned/good/roles.ex
@@ -0,0 +1,57 @@
+defmodule Access.Roles do
+  @moduledoc """
+  Role/permission management — GOOD: atoms used for roles, statuses, and named constants.
+  """
+
+  @roles [:superadmin, :admin, :moderator, :member, :guest]
+  @verified_statuses [:active_premium, :active_standard]
+  @full_access_permissions [:all_access, :read_write, :read_write_no_delete]
+
+  def assign_role(user, role) do
+    permissions = permissions_for(role)
+    %{user | role: role, permissions: permissions}
+  end
+
+  defp permissions_for(:superadmin), do: :all_access
+  defp permissions_for(:admin), do: :read_write_no_delete
+  defp permissions_for(:moderator), do: :read_write_flag
+  defp permissions_for(:member), do: :read_write
+  defp permissions_for(:guest), do: :read_only
+
+  def can_access?(user, resource) do
+    if user.account_status in @verified_statuses do
+      check_resource_permission(user.permissions, resource)
+    else
+      false
+    end
+  end
+
+  defp check_resource_permission(permissions, _resource) do
+    permissions in @full_access_permissions
+  end
+
+  def get_subscription_tier(user) do
+    case user.plan do
+      :free -> "Free"
+      :basic -> "Basic"
+      :pro -> "Pro"
+      :enterprise -> "Enterprise"
+      _ -> "Unknown"
+    end
+  end
+
+  def set_account_status(user, event) do
+    new_status =
+      case event do
+        :email_confirmed -> :active_standard
+        :upgrade_to_premium -> :active_premium
+        :account_suspended -> :suspended
+        :account_closed -> :closed
+        _ -> :pending_review
+      end
+
+    %{user | account_status: new_status}
+  end
+
+  def valid_role?(role), do: role in @roles
+end
diff --git a/priv/combined_metrics/samples/type_and_value/no_mutable_exported_variables/bad/feature_flags.js b/priv/combined_metrics/samples/type_and_value/no_mutable_exported_variables/bad/feature_flags.js
new file mode 100644
index 0000000..e73b5d3
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_mutable_exported_variables/bad/feature_flags.js
@@ -0,0 +1,50 @@
+export let flags = {
+  darkMode: false,
+  betaCheckout: false,
+  newDashboard: false,
+  analyticsV2: true,
+};
+
+export let initialized = false;
+
+export let currentUser = null;
+
+export let requestCount = 0;
+
+export async function initializeFlags(fetchFn) {
+  if (initialized) return;
+  try {
+    const remote = await fetchFn("/api/feature-flags");
+    flags = { ...flags, ...remote };
+  } catch {
+    // ignore
+  }
+  initialized = true;
+}
+
+export function isEnabled(flagName) {
+  return flags[flagName] === true;
+}
+
+export function setCurrentUser(user) {
+  currentUser = user;
+}
+
+export function incrementRequestCount() {
+  requestCount++;
+}
+
+export function overrideFlag(name, value) {
+  flags[name] = value;
+}
+
+export function resetFlags() {
+  flags = {
+    darkMode: false,
+    betaCheckout: false,
+    newDashboard: false,
+    analyticsV2: true,
+  };
+  initialized = false;
+  requestCount = 0;
+}
diff --git a/priv/combined_metrics/samples/type_and_value/no_mutable_exported_variables/good/feature_flags.js b/priv/combined_metrics/samples/type_and_value/no_mutable_exported_variables/good/feature_flags.js
new file mode 100644
index 0000000..d5bfbb8
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_mutable_exported_variables/good/feature_flags.js
@@ -0,0 +1,43 @@
+const DEFAULT_FLAGS = {
+  darkMode: false,
+  betaCheckout: false,
+  newDashboard: false,
+  analyticsV2: true,
+};
+
+let _flags = { ...DEFAULT_FLAGS };
+let _initialized = false;
+
+export async function initializeFlags(fetchFn) {
+  if (_initialized) return;
+  try {
+    const remote = await fetchFn("/api/feature-flags");
+    _flags = { ...DEFAULT_FLAGS, ...remote };
+  } catch {
+    // Remote fetch failed; fall back to defaults silently
+    _flags = { ...DEFAULT_FLAGS };
+  }
+  _initialized = true;
+}
+
+export function isEnabled(flagName) {
+  return _flags[flagName] === true;
+}
+
+export function getFlags() {
+  return { ..._flags };
+}
+
+export function overrideFlag(name, value) {
+  if (!(name in DEFAULT_FLAGS)) {
+    throw new Error(`Unknown feature flag: '${name}'`);
+  }
+  _flags = { ..._flags, [name]: value };
+}
+
+export function resetFlags() {
+  _flags = { ...DEFAULT_FLAGS };
+  _initialized = false;
+}
+
+export const FLAG_NAMES = Object.freeze(Object.keys(DEFAULT_FLAGS));
diff --git a/priv/combined_metrics/samples/type_and_value/no_non_null_assertion/bad/notification_handler.ts b/priv/combined_metrics/samples/type_and_value/no_non_null_assertion/bad/notification_handler.ts
new file mode 100644
index 0000000..cd169b6
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_non_null_assertion/bad/notification_handler.ts
@@ -0,0 +1,57 @@
+interface Notification {
+  id: string;
+  userId: string;
+  type: string;
+  title: string;
+  body: string;
+  readAt: string | null;
+  actionUrl: string | null;
+}
+
+interface NotificationStore {
+  get(id: string): Notification | undefined;
+  getAll(userId: string): Notification[];
+}
+
+function markAsRead(store: NotificationStore, notificationId: string): Notification {
+  // Non-null assertion instead of explicit check
+  const notification = store.get(notificationId)!;
+  return { ...notification, readAt: new Date().toISOString() };
+}
+
+function getActionUrl(notification: Notification): string {
+  // Non-null assertion on a nullable field
+  return notification.actionUrl!;
+}
+
+function getLatestUnread(notifications: Notification[]): Notification {
+  const unread = notifications.filter((n) => n.readAt === null);
+  // Non-null assertion assuming there is always at least one unread
+  return unread[0]!;
+}
+
+function getFirstNotification(store: NotificationStore, userId: string): Notification {
+  const all = store.getAll(userId);
+  return all[0]!;
+}
+
+function renderNotificationBadge(notifications: Notification[]): string {
+  const count = notifications.filter((n) => n.readAt === null).length;
+  if (count === 0) return "";
+  if (count > 99) return "99+";
+  return String(count);
+}
+
+function getNotificationTitle(store: NotificationStore, id: string): string {
+  return store.get(id)!.title;
+}
+
+export {
+  markAsRead,
+  getActionUrl,
+  getLatestUnread,
+  getFirstNotification,
+  renderNotificationBadge,
+  getNotificationTitle,
+};
+export type { Notification, NotificationStore };
diff --git a/priv/combined_metrics/samples/type_and_value/no_non_null_assertion/good/notification_handler.ts b/priv/combined_metrics/samples/type_and_value/no_non_null_assertion/good/notification_handler.ts
new file mode 100644
index 0000000..6345008
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_non_null_assertion/good/notification_handler.ts
@@ -0,0 +1,61 @@
+interface Notification {
+  id: string;
+  userId: string;
+  type: string;
+  title: string;
+  body: string;
+  readAt: string | null;
+  actionUrl: string | null;
+}
+
+interface NotificationStore {
+  get(id: string): Notification | undefined;
+  getAll(userId: string): Notification[];
+}
+
+function markAsRead(store: NotificationStore, notificationId: string): Notification {
+  const notification = store.get(notificationId);
+
+  if (notification === undefined) {
+    throw new Error(`Notification not found: ${notificationId}`);
+  }
+
+  return { ...notification, readAt: new Date().toISOString() };
+}
+
+function getActionUrl(notification: Notification): string {
+  if (notification.actionUrl === null) {
+    return "/notifications";
+  }
+  return notification.actionUrl;
+}
+
+function countUnread(notifications: Notification[]): number {
+  return notifications.filter((n) => n.readAt === null).length;
+}
+
+function getLatestUnread(notifications: Notification[]): Notification | null {
+  const unread = notifications.filter((n) => n.readAt === null);
+  if (unread.length === 0) return null;
+  return unread.reduce((latest, n) =>
+    n.id > latest.id ? n : latest
+  );
+}
+
+function renderNotificationBadge(notifications: Notification[]): string {
+  const count = countUnread(notifications);
+  if (count === 0) return "";
+  if (count > 99) return "99+";
+  return String(count);
+}
+
+function groupByType(notifications: Notification[]): Map<string, Notification[]> {
+  return notifications.reduce((groups, notification) => {
+    const existing = groups.get(notification.type) ?? [];
+    groups.set(notification.type, [...existing, notification]);
+    return groups;
+  }, new Map<string, Notification[]>());
+}
+
+export { markAsRead, getActionUrl, countUnread, getLatestUnread, renderNotificationBadge, groupByType };
+export type { Notification, NotificationStore };
diff --git a/priv/combined_metrics/samples/type_and_value/no_non_null_assertion_operator/bad/UserProfile.kt b/priv/combined_metrics/samples/type_and_value/no_non_null_assertion_operator/bad/UserProfile.kt
new file mode 100644
index 0000000..48db14d
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_non_null_assertion_operator/bad/UserProfile.kt
@@ -0,0 +1,48 @@
+package com.example.users
+
+data class UserProfile(
+    val id: String,
+    val email: String,
+    val displayName: String?,
+    val avatarUrl: String?,
+    val bio: String?
+)
+
+class UserProfileService(
+    private val repository: UserProfileRepository,
+    private val storage: AvatarStorage
+) {
+
+    fun getDisplayName(profile: UserProfile): String {
+        // !! forces non-null — will throw KotlinNullPointerException if displayName is null
+        return profile.displayName!!
+    }
+
+    fun getAvatarOrDefault(profile: UserProfile): String {
+        // !! again — crashes if avatarUrl is null instead of falling back
+        return profile.avatarUrl!!
+    }
+
+    fun buildProfileSummary(userId: String): ProfileSummary {
+        // !! on repository result — crashes if user is not found
+        val profile = repository.findById(userId)!!
+
+        return ProfileSummary(
+            name = profile.displayName!!,
+            avatar = profile.avatarUrl!!,
+            bio = profile.bio!!
+        )
+    }
+
+    fun updateBio(userId: String, newBio: String) {
+        // !! instead of handling the not-found case gracefully
+        val profile = repository.findById(userId)!!
+        val updated = profile.copy(bio = newBio)
+        repository.save(updated)
+    }
+
+    fun firstMatch(query: String): UserProfile {
+        // !! on firstOrNull — will explode on empty results
+        return repository.search(query).firstOrNull()!!
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/no_non_null_assertion_operator/good/UserProfile.kt b/priv/combined_metrics/samples/type_and_value/no_non_null_assertion_operator/good/UserProfile.kt
new file mode 100644
index 0000000..6ce37bd
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_non_null_assertion_operator/good/UserProfile.kt
@@ -0,0 +1,49 @@
+package com.example.users
+
+data class UserProfile(
+    val id: String,
+    val email: String,
+    val displayName: String?,
+    val avatarUrl: String?,
+    val bio: String?
+)
+
+class UserProfileService(
+    private val repository: UserProfileRepository,
+    private val storage: AvatarStorage
+) {
+
+    fun getDisplayName(profile: UserProfile): String {
+        // Elvis operator instead of !! — provides a safe fallback
+        return profile.displayName ?: profile.email
+    }
+
+    fun getAvatarOrDefault(profile: UserProfile): String {
+        // Safe call with Elvis instead of !! — no risk of NPE
+        return profile.avatarUrl ?: storage.defaultAvatarUrl()
+    }
+
+    fun buildProfileSummary(userId: String): ProfileSummary? {
+        // Safe call chain — returns null rather than crashing if profile is absent
+        val profile = repository.findById(userId) ?: return null
+
+        return ProfileSummary(
+            name = profile.displayName ?: profile.email,
+            avatar = profile.avatarUrl ?: storage.defaultAvatarUrl(),
+            bio = profile.bio ?: "No bio provided"
+        )
+    }
+
+    fun updateBio(userId: String, newBio: String): Boolean {
+        val profile = repository.findById(userId) ?: return false
+        val updated = profile.copy(bio = newBio)
+        repository.save(updated)
+        return true
+    }
+
+    fun searchProfiles(query: String): List<UserProfile> {
+        return repository.search(query)
+            .filter { it.displayName?.contains(query, ignoreCase = true) == true
+                    || it.email.contains(query, ignoreCase = true) }
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/no_primitive_obsession/bad/payments.ex b/priv/combined_metrics/samples/type_and_value/no_primitive_obsession/bad/payments.ex
new file mode 100644
index 0000000..e8feaf2
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_primitive_obsession/bad/payments.ex
@@ -0,0 +1,48 @@
+defmodule MyApp.Payments do
+  @moduledoc """
+  Payment processing.
+  """
+
+  # Bad: money is a raw integer with no currency attached.
+  # Nothing prevents mixing USD cents and EUR cents — silent bugs.
+  @spec create_charge(integer(), integer()) :: {:ok, map()} | {:error, term()}
+  def create_charge(order_id, amount_cents) do
+    MyApp.PaymentGateway.charge(%{
+      order_id: order_id,
+      amount: amount_cents
+    })
+  end
+
+  # Bad: tax calculation takes raw integers — no type safety,
+  # result could be added to a different currency total by accident
+  @spec calculate_tax(integer(), float()) :: integer()
+  def calculate_tax(amount_cents, rate) do
+    round(amount_cents * rate)
+  end
+
+  # Bad: applying discount to raw integer — what currency? what precision?
+  @spec apply_discount(integer(), float()) :: integer()
+  def apply_discount(amount_cents, discount_percent) do
+    round(amount_cents * (1.0 - discount_percent / 100))
+  end
+
+  # Bad: function has no idea if `a` and `b` are same currency
+  @spec add_amounts(integer(), integer()) :: integer()
+  def add_amounts(a, b), do: a + b
+
+  # Bad: passing a raw string for email, integer for user_id, integer for amount —
+  # no domain types, caller must know implicit conventions (is this cents? dollars?)
+  @spec send_receipt(integer(), String.t(), integer(), String.t()) :: :ok
+  def send_receipt(user_id, email, amount_cents, currency_code) do
+    formatted = :erlang.float_to_binary(amount_cents / 100, decimals: 2)
+    MyApp.Mailer.send_text(email, "Receipt for user #{user_id}: #{currency_code} #{formatted}")
+    :ok
+  end
+
+  # Bad: using a plain tuple to represent money — no struct enforcement
+  @spec split(tuple(), integer()) :: [tuple()]
+  def split({amount, currency}, parts) when parts > 0 do
+    each = div(amount, parts)
+    List.duplicate({each, currency}, parts)
+  end
+end
diff --git a/priv/combined_metrics/samples/type_and_value/no_primitive_obsession/good/payments.ex b/priv/combined_metrics/samples/type_and_value/no_primitive_obsession/good/payments.ex
new file mode 100644
index 0000000..aa03f8c
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_primitive_obsession/good/payments.ex
@@ -0,0 +1,63 @@
+defmodule MyApp.Payments do
+  @moduledoc """
+  Payment processing. Domain concepts like money are represented as
+  dedicated structs rather than raw primitives.
+  """
+
+  defmodule Money do
+    @moduledoc "Represents a monetary amount with an explicit currency."
+    @enforce_keys [:amount, :currency]
+    defstruct [:amount, :currency]
+
+    @type t :: %__MODULE__{amount: integer(), currency: :usd | :eur | :gbp}
+
+    def new(amount, currency) when is_integer(amount) and amount >= 0 do
+      %__MODULE__{amount: amount, currency: currency}
+    end
+
+    def add(%__MODULE__{amount: a, currency: c}, %__MODULE__{amount: b, currency: c}) do
+      %__MODULE__{amount: a + b, currency: c}
+    end
+
+    def add(_, _), do: raise(ArgumentError, "cannot add money with different currencies")
+
+    def format(%__MODULE__{amount: amount, currency: :usd}) do
+      "$#{:erlang.float_to_binary(amount / 100, decimals: 2)}"
+    end
+
+    def format(%__MODULE__{amount: amount, currency: :eur}) do
+      "€#{:erlang.float_to_binary(amount / 100, decimals: 2)}"
+    end
+  end
+
+  defmodule OrderId do
+    @moduledoc "Typed wrapper for an order identifier."
+    @enforce_keys [:value]
+    defstruct [:value]
+
+    @type t :: %__MODULE__{value: integer()}
+
+    def new(id) when is_integer(id) and id > 0, do: %__MODULE__{value: id}
+  end
+
+  @doc """
+  Creates a charge for an order. Accepts typed structs, not raw integers.
+  """
+  @spec create_charge(OrderId.t(), Money.t()) :: {:ok, map()} | {:error, term()}
+  def create_charge(%OrderId{value: order_id}, %Money{amount: amount, currency: currency}) do
+    MyApp.PaymentGateway.charge(%{
+      order_id: order_id,
+      amount: amount,
+      currency: currency
+    })
+  end
+
+  @doc """
+  Calculates tax as a Money struct, preserving currency information.
+  """
+  @spec calculate_tax(Money.t(), float()) :: Money.t()
+  def calculate_tax(%Money{amount: amount, currency: currency}, rate) do
+    tax = round(amount * rate)
+    Money.new(tax, currency)
+  end
+end
diff --git a/priv/combined_metrics/samples/type_and_value/no_rtti/bad/Connection.cpp b/priv/combined_metrics/samples/type_and_value/no_rtti/bad/Connection.cpp
new file mode 100644
index 0000000..d301559
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_rtti/bad/Connection.cpp
@@ -0,0 +1,69 @@
+#include <memory>
+#include <string>
+#include <typeinfo>
+#include <vector>
+
+class Connection {
+public:
+    virtual ~Connection() = default;
+    virtual void send(const std::string& data) = 0;
+    virtual std::string receive(std::size_t maxBytes) = 0;
+    virtual bool isAlive() const noexcept = 0;
+};
+
+class TcpConnection : public Connection {
+public:
+    explicit TcpConnection(std::string host, int port)
+        : host_(std::move(host)), port_(port), alive_(true) {}
+
+    void send(const std::string& data) override { (void)data; }
+    std::string receive(std::size_t maxBytes) override { (void)maxBytes; return {}; }
+    bool isAlive() const noexcept override { return alive_; }
+
+private:
+    std::string host_;
+    int port_;
+    bool alive_;
+};
+
+class TlsConnection : public Connection {
+public:
+    explicit TlsConnection(std::string host, int port)
+        : host_(std::move(host)), port_(port), alive_(true) {}
+
+    void send(const std::string& data) override { (void)data; }
+    std::string receive(std::size_t maxBytes) override { (void)maxBytes; return {}; }
+    bool isAlive() const noexcept override { return alive_; }
+    void flush() { /* flush TLS buffer */ }
+
+private:
+    std::string host_;
+    int port_;
+    bool alive_;
+};
+
+// Uses dynamic_cast to discover the runtime type — brittle, must be updated
+// every time a new Connection subtype is added
+void broadcastMessage(const std::vector<std::unique_ptr<Connection>>& connections,
+                      const std::string& message)
+{
+    for (const auto& conn : connections) {
+        if (!conn->isAlive()) continue;
+        conn->send(message);
+
+        // dynamic_cast to access TLS-specific behavior — should be a virtual method
+        if (auto* tls = dynamic_cast<TlsConnection*>(conn.get())) {
+            tls->flush(); // RTTI cast to reach subtype-specific functionality
+        }
+    }
+}
+
+std::string describeConnection(const Connection& conn) {
+    // typeid used to branch on type — fragile, does not work with type hierarchies
+    if (typeid(conn) == typeid(TcpConnection))
+        return "plain TCP connection";
+    else if (typeid(conn) == typeid(TlsConnection))
+        return "TLS connection";
+    else
+        return "unknown connection type";
+}
diff --git a/priv/combined_metrics/samples/type_and_value/no_rtti/good/Connection.cpp b/priv/combined_metrics/samples/type_and_value/no_rtti/good/Connection.cpp
new file mode 100644
index 0000000..d09c56c
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_rtti/good/Connection.cpp
@@ -0,0 +1,69 @@
+#include <memory>
+#include <string>
+#include <vector>
+
+// Polymorphism via virtual methods — no dynamic_cast or typeid needed
+
+class Connection {
+public:
+    virtual ~Connection() = default;
+
+    virtual void send(const std::string& data) = 0;
+    virtual std::string receive(std::size_t maxBytes) = 0;
+    virtual bool isAlive() const noexcept = 0;
+    virtual std::string description() const = 0;
+
+    // Type-specific behavior exposed through the interface — no casting required
+    virtual void flush() {}
+    virtual bool supportsTls() const noexcept = 0;
+};
+
+class TcpConnection : public Connection {
+public:
+    explicit TcpConnection(std::string host, int port)
+        : host_(std::move(host)), port_(port), alive_(true) {}
+
+    void send(const std::string& data) override { (void)data; }
+    std::string receive(std::size_t maxBytes) override { (void)maxBytes; return {}; }
+    bool isAlive() const noexcept override { return alive_; }
+    bool supportsTls() const noexcept override { return false; }
+    std::string description() const override {
+        return "TCP:" + host_ + ":" + std::to_string(port_);
+    }
+
+private:
+    std::string host_;
+    int port_;
+    bool alive_;
+};
+
+class TlsConnection : public Connection {
+public:
+    explicit TlsConnection(std::string host, int port)
+        : host_(std::move(host)), port_(port), alive_(true) {}
+
+    void send(const std::string& data) override { (void)data; }
+    std::string receive(std::size_t maxBytes) override { (void)maxBytes; return {}; }
+    bool isAlive() const noexcept override { return alive_; }
+    bool supportsTls() const noexcept override { return true; }
+    void flush() override { /* flush TLS buffer */ }
+    std::string description() const override {
+        return "TLS:" + host_ + ":" + std::to_string(port_);
+    }
+
+private:
+    std::string host_;
+    int port_;
+    bool alive_;
+};
+
+// Works with any Connection subtype via the interface — no RTTI needed
+void broadcastMessage(const std::vector<std::unique_ptr<Connection>>& connections,
+                      const std::string& message)
+{
+    for (const auto& conn : connections) {
+        if (!conn->isAlive()) continue;
+        conn->send(message);
+        conn->flush(); // virtual dispatch — no type check needed
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/no_unparameterized_generic/bad/product_service.py b/priv/combined_metrics/samples/type_and_value/no_unparameterized_generic/bad/product_service.py
new file mode 100644
index 0000000..9a78422
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_unparameterized_generic/bad/product_service.py
@@ -0,0 +1,65 @@
+"""Product service managing catalogue items, pricing tiers, and inventory."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from decimal import Decimal
+from typing import Dict, List, Set  # old-style imports, unparameterized below
+
+
+@dataclass
+class PricingTier:
+    name: str
+    multiplier: Decimal
+
+
+@dataclass
+class Product:
+    id: str
+    name: str
+    base_price: Decimal
+    tags: List = field(default_factory=list)        # bare List — implies List[Any]
+    attributes: Dict = field(default_factory=dict)  # bare Dict — implies Dict[Any, Any]
+
+
+def find_by_tags(
+    products: List,       # bare List — what kind of items?
+    tags: Set,            # bare Set — what kind of elements?
+) -> List:               # bare List — return element type unknown
+    """Return products that have at least one matching tag."""
+    return [p for p in products if set(p.tags) & tags]
+
+
+def build_price_map(
+    products: List,       # bare List
+    tier: PricingTier,
+) -> Dict:               # bare Dict — key/value types unknown to type checker
+    """Return a mapping of product ID to adjusted price for the given tier."""
+    return {p.id: p.base_price * tier.multiplier for p in products}
+
+
+def group_by_attribute(
+    products: List,       # bare List
+    attribute_key: str,
+) -> Dict:               # bare Dict — caller cannot know it's Dict[str, List[Product]]
+    """Group products by the value of a given attribute key."""
+    groups: Dict = {}    # bare Dict annotation
+    for product in products:
+        value = product.attributes.get(attribute_key, "")
+        groups.setdefault(value, []).append(product)
+    return groups
+
+
+def summarise_inventory(
+    stock: Dict,          # bare Dict — key/value types invisible
+    products: List,       # bare List
+) -> List:               # bare List
+    index: Dict = {p.id: p for p in products}  # bare Dict
+    return [
+        {
+            "id": product_id,
+            "name": index[product_id].name,
+            "quantity": quantity,
+        }
+        for product_id, quantity in stock.items()
+        if product_id in index
+    ]
diff --git a/priv/combined_metrics/samples/type_and_value/no_unparameterized_generic/good/product_service.py b/priv/combined_metrics/samples/type_and_value/no_unparameterized_generic/good/product_service.py
new file mode 100644
index 0000000..fc660c5
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_unparameterized_generic/good/product_service.py
@@ -0,0 +1,80 @@
+"""Product service managing catalogue items, pricing tiers, and inventory."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from decimal import Decimal
+from typing import Optional
+
+
+@dataclass
+class PricingTier:
+    name: str
+    multiplier: Decimal
+
+
+@dataclass
+class Product:
+    id: str
+    name: str
+    base_price: Decimal
+    tags: list[str] = field(default_factory=list)
+    attributes: dict[str, str] = field(default_factory=dict)
+
+
+def find_by_tags(
+    products: list[Product],
+    tags: set[str],
+) -> list[Product]:
+    """Return products that have at least one matching tag."""
+    return [p for p in products if set(p.tags) & tags]
+
+
+def build_price_map(
+    products: list[Product],
+    tier: PricingTier,
+) -> dict[str, Decimal]:
+    """Return a mapping of product ID to adjusted price for the given tier."""
+    return {p.id: p.base_price * tier.multiplier for p in products}
+
+
+def group_by_attribute(
+    products: list[Product],
+    attribute_key: str,
+) -> dict[str, list[Product]]:
+    """Group products by the value of a given attribute key."""
+    groups: dict[str, list[Product]] = {}
+    for product in products:
+        value = product.attributes.get(attribute_key, "")
+        groups.setdefault(value, []).append(product)
+    return groups
+
+
+def summarise_inventory(
+    stock: dict[str, int],
+    products: list[Product],
+) -> list[dict[str, str | int | Decimal]]:
+    """Combine stock counts with product data into summary records."""
+    index: dict[str, Product] = {p.id: p for p in products}
+    return [
+        {
+            "id": product_id,
+            "name": index[product_id].name,
+            "quantity": quantity,
+            "total_value": index[product_id].base_price * quantity,
+        }
+        for product_id, quantity in stock.items()
+        if product_id in index
+    ]
+
+
+def apply_bulk_discount(
+    prices: dict[str, Decimal],
+    discount_ids: set[str],
+    percent: int,
+) -> dict[str, Decimal]:
+    """Return a new price map with discounts applied to the specified IDs."""
+    factor = Decimal(1) - Decimal(percent) / 100
+    return {
+        pid: (price * factor if pid in discount_ids else price)
+        for pid, price in prices.items()
+    }
diff --git a/priv/combined_metrics/samples/type_and_value/no_unsafe_assignment/bad/product_repository.ts b/priv/combined_metrics/samples/type_and_value/no_unsafe_assignment/bad/product_repository.ts
new file mode 100644
index 0000000..a8b5234
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_unsafe_assignment/bad/product_repository.ts
@@ -0,0 +1,56 @@
+interface Product {
+  id: string;
+  name: string;
+  price: number;
+  category: string;
+  stock: number;
+  tags: string[];
+}
+
+async function fetchProducts(categorySlug: string): Promise<Product[]> {
+  const response = await fetch(`/api/products?category=${categorySlug}`);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch products: ${response.status}`);
+  }
+
+  // Unsafe: any assigned directly to typed variable
+  const rawProducts: any = await response.json();
+  const products: Product[] = rawProducts;
+  return products;
+}
+
+async function fetchProduct(productId: string): Promise<Product> {
+  const response = await fetch(`/api/products/${productId}`);
+
+  if (!response.ok) {
+    throw new Error(`Product not found: ${productId}`);
+  }
+
+  const data: any = await response.json();
+  const product: Product = data.product;
+  return product;
+}
+
+function enrichProduct(product: Product, extraData: any): Product {
+  const enriched: Product = { ...product, ...extraData };
+  return enriched;
+}
+
+function parseProductList(payload: any): Product[] {
+  const items: Product[] = payload.items;
+  return items;
+}
+
+function filterInStock(products: Product[]): Product[] {
+  return products.filter((p) => p.stock > 0);
+}
+
+function sortByPrice(products: Product[], direction: "asc" | "desc" = "asc"): Product[] {
+  return [...products].sort((a, b) =>
+    direction === "asc" ? a.price - b.price : b.price - a.price
+  );
+}
+
+export { fetchProducts, fetchProduct, enrichProduct, parseProductList, filterInStock, sortByPrice };
+export type { Product };
diff --git a/priv/combined_metrics/samples/type_and_value/no_unsafe_assignment/good/product_repository.ts b/priv/combined_metrics/samples/type_and_value/no_unsafe_assignment/good/product_repository.ts
new file mode 100644
index 0000000..a6477f4
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_unsafe_assignment/good/product_repository.ts
@@ -0,0 +1,63 @@
+interface Product {
+  id: string;
+  name: string;
+  price: number;
+  category: string;
+  stock: number;
+  tags: string[];
+}
+
+interface RawApiProduct {
+  id: string;
+  name: string;
+  price_cents: number;
+  category_slug: string;
+  inventory_count: number;
+  tag_list: string;
+}
+
+function parseProduct(raw: RawApiProduct): Product {
+  return {
+    id: raw.id,
+    name: raw.name,
+    price: raw.price_cents / 100,
+    category: raw.category_slug,
+    stock: raw.inventory_count,
+    tags: raw.tag_list ? raw.tag_list.split(",").map((t) => t.trim()) : [],
+  };
+}
+
+async function fetchProducts(categorySlug: string): Promise<Product[]> {
+  const response = await fetch(`/api/products?category=${categorySlug}`);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch products: ${response.status}`);
+  }
+
+  const rawProducts: RawApiProduct[] = await response.json();
+  return rawProducts.map(parseProduct);
+}
+
+async function fetchProduct(productId: string): Promise<Product> {
+  const response = await fetch(`/api/products/${productId}`);
+
+  if (!response.ok) {
+    throw new Error(`Product not found: ${productId}`);
+  }
+
+  const raw: RawApiProduct = await response.json();
+  return parseProduct(raw);
+}
+
+function filterInStock(products: Product[]): Product[] {
+  return products.filter((p) => p.stock > 0);
+}
+
+function sortByPrice(products: Product[], direction: "asc" | "desc" = "asc"): Product[] {
+  return [...products].sort((a, b) =>
+    direction === "asc" ? a.price - b.price : b.price - a.price
+  );
+}
+
+export { fetchProducts, fetchProduct, filterInStock, sortByPrice };
+export type { Product };
diff --git a/priv/combined_metrics/samples/type_and_value/no_unsafe_return/bad/payment_gateway.ts b/priv/combined_metrics/samples/type_and_value/no_unsafe_return/bad/payment_gateway.ts
new file mode 100644
index 0000000..1c4ff5f
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_unsafe_return/bad/payment_gateway.ts
@@ -0,0 +1,58 @@
+interface PaymentMethod {
+  id: string;
+  type: "card" | "bank_transfer" | "wallet";
+  last4?: string;
+  brand?: string;
+}
+
+interface ChargeResult {
+  chargeId: string;
+  status: "succeeded" | "pending" | "failed";
+  amount: number;
+  currency: string;
+}
+
+async function fetchPaymentMethod(id: string): Promise<PaymentMethod> {
+  const response = await fetch(`/api/payment-methods/${id}`);
+  if (!response.ok) throw new Error(`Payment method not found: ${id}`);
+
+  const body: any = await response.json();
+  // Unsafe return: body.paymentMethod is typed as any
+  return body.paymentMethod;
+}
+
+async function chargePaymentMethod(
+  paymentMethodId: string,
+  amount: number,
+  currency: string
+): Promise<ChargeResult> {
+  const response = await fetch("/api/charges", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ paymentMethodId, amount, currency }),
+  });
+
+  if (!response.ok) throw new Error(`Charge failed: ${response.status}`);
+
+  const data: any = await response.json();
+  return data.charge;
+}
+
+function buildChargePayload(paymentMethodId: string, amount: number): ChargeResult {
+  const raw: any = {
+    chargeId: "temp",
+    status: "pending",
+    amount,
+    currency: "USD",
+    paymentMethodId,
+    createdAt: Date.now(),
+  };
+  return raw;
+}
+
+function parseWebhookEvent(payload: any): ChargeResult {
+  return payload.data.object;
+}
+
+export { fetchPaymentMethod, chargePaymentMethod, buildChargePayload, parseWebhookEvent };
+export type { PaymentMethod, ChargeResult };
diff --git a/priv/combined_metrics/samples/type_and_value/no_unsafe_return/good/payment_gateway.ts b/priv/combined_metrics/samples/type_and_value/no_unsafe_return/good/payment_gateway.ts
new file mode 100644
index 0000000..52680e9
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_unsafe_return/good/payment_gateway.ts
@@ -0,0 +1,73 @@
+interface PaymentMethod {
+  id: string;
+  type: "card" | "bank_transfer" | "wallet";
+  last4?: string;
+  brand?: string;
+}
+
+interface ChargeResult {
+  chargeId: string;
+  status: "succeeded" | "pending" | "failed";
+  amount: number;
+  currency: string;
+}
+
+interface RefundResult {
+  refundId: string;
+  chargeId: string;
+  amount: number;
+  status: "pending" | "succeeded";
+}
+
+async function fetchPaymentMethod(id: string): Promise<PaymentMethod> {
+  const response = await fetch(`/api/payment-methods/${id}`);
+  if (!response.ok) throw new Error(`Payment method not found: ${id}`);
+
+  const body: { paymentMethod: PaymentMethod } = await response.json();
+  return body.paymentMethod;
+}
+
+async function chargePaymentMethod(
+  paymentMethodId: string,
+  amount: number,
+  currency: string
+): Promise<ChargeResult> {
+  const response = await fetch("/api/charges", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ paymentMethodId, amount, currency }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Charge failed: ${response.status}`);
+  }
+
+  const body: { charge: ChargeResult } = await response.json();
+  return body.charge;
+}
+
+async function refundCharge(chargeId: string, amount?: number): Promise<RefundResult> {
+  const response = await fetch("/api/refunds", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ chargeId, amount }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Refund failed: ${response.status}`);
+  }
+
+  const body: { refund: RefundResult } = await response.json();
+  return body.refund;
+}
+
+function formatPaymentMethodLabel(pm: PaymentMethod): string {
+  if (pm.type === "card" && pm.last4) {
+    return `${pm.brand ?? "Card"} ending in ${pm.last4}`;
+  }
+  if (pm.type === "bank_transfer") return "Bank Transfer";
+  return "Wallet";
+}
+
+export { fetchPaymentMethod, chargePaymentMethod, refundCharge, formatPaymentMethodLabel };
+export type { PaymentMethod, ChargeResult, RefundResult };
diff --git a/priv/combined_metrics/samples/type_and_value/no_var_keyword_for_properties/bad/PaymentGateway.php b/priv/combined_metrics/samples/type_and_value/no_var_keyword_for_properties/bad/PaymentGateway.php
new file mode 100644
index 0000000..c8506c1
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_var_keyword_for_properties/bad/PaymentGateway.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace App\Payment;
+
+class PaymentGateway
+{
+    // `var` is a PHP 4 remnant — it implies public visibility and is forbidden by PSR-12
+    var $apiKey;
+    var $baseUrl;
+    var $timeoutMs;
+    var $currency;
+    var $sandboxMode;
+
+    var $requestCount = 0;
+
+    public function __construct(
+        $apiKey,
+        $baseUrl,
+        $timeoutMs = 5000,
+        $sandboxMode = false
+    ) {
+        $this->apiKey = $apiKey;
+        $this->baseUrl = $baseUrl;
+        $this->timeoutMs = $timeoutMs;
+        $this->sandboxMode = $sandboxMode;
+        $this->currency = 'USD';
+    }
+
+    public function charge($amountCents, $token)
+    {
+        $this->requestCount++;
+
+        $payload = [
+            'amount'   => $amountCents,
+            'currency' => $this->currency,
+            'source'   => $token,
+        ];
+
+        return $this->post('/v1/charges', $payload);
+    }
+
+    public function setCurrency($currency)
+    {
+        $this->currency = strtoupper($currency);
+    }
+
+    public function getRequestCount()
+    {
+        return $this->requestCount;
+    }
+
+    private function post($path, $payload)
+    {
+        return ['transaction_id' => uniqid('txn_')];
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/no_var_keyword_for_properties/good/PaymentGateway.php b/priv/combined_metrics/samples/type_and_value/no_var_keyword_for_properties/good/PaymentGateway.php
new file mode 100644
index 0000000..1a713ea
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/no_var_keyword_for_properties/good/PaymentGateway.php
@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Payment;
+
+class PaymentGateway
+{
+    private string $apiKey;
+    private string $baseUrl;
+    private int $timeoutMs;
+    protected string $currency;
+    public bool $sandboxMode;
+
+    private static int $requestCount = 0;
+    private const string DEFAULT_CURRENCY = 'USD';
+
+    public function __construct(
+        string $apiKey,
+        string $baseUrl,
+        int $timeoutMs = 5000,
+        bool $sandboxMode = false
+    ) {
+        $this->apiKey = $apiKey;
+        $this->baseUrl = $baseUrl;
+        $this->timeoutMs = $timeoutMs;
+        $this->sandboxMode = $sandboxMode;
+        $this->currency = self::DEFAULT_CURRENCY;
+    }
+
+    public function charge(int $amountCents, string $token): ChargeResult
+    {
+        self::$requestCount++;
+
+        $payload = [
+            'amount'   => $amountCents,
+            'currency' => $this->currency,
+            'source'   => $token,
+        ];
+
+        return $this->post('/v1/charges', $payload);
+    }
+
+    public function setCurrency(string $currency): void
+    {
+        $this->currency = strtoupper($currency);
+    }
+
+    public static function getRequestCount(): int
+    {
+        return self::$requestCount;
+    }
+
+    private function post(string $path, array $payload): ChargeResult
+    {
+        // HTTP client logic
+        return new ChargeResult(transactionId: uniqid('txn_'));
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/nullable_boolean_compared_explicitly/bad/NotificationHandler.kt b/priv/combined_metrics/samples/type_and_value/nullable_boolean_compared_explicitly/bad/NotificationHandler.kt
new file mode 100644
index 0000000..58ae84e
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/nullable_boolean_compared_explicitly/bad/NotificationHandler.kt
@@ -0,0 +1,50 @@
+package com.example.notifications
+
+data class NotificationPreferences(
+    val emailEnabled: Boolean?,
+    val pushEnabled: Boolean?,
+    val smsEnabled: Boolean?,
+    val marketingOptIn: Boolean?
+)
+
+class NotificationHandler(
+    private val emailSender: EmailSender,
+    private val pushSender: PushSender,
+    private val smsSender: SmsSender
+) {
+
+    fun dispatch(userId: String, prefs: NotificationPreferences?, message: String) {
+        // Treating nullable Boolean as truthy — null will NOT enter the block,
+        // but this is ambiguous: is null "not set" or "disabled"?
+        if (prefs?.emailEnabled!!) {
+            emailSender.send(userId, message)
+        }
+
+        // Using ?: true coerces null to true — silently sends even without consent
+        if (prefs?.pushEnabled ?: true) {
+            pushSender.send(userId, message)
+        }
+
+        // Direct truthiness check on nullable — unclear intent
+        if (prefs?.smsEnabled != null && prefs.smsEnabled) {
+            smsSender.send(userId, message)
+        }
+    }
+
+    fun isMarketingAllowed(prefs: NotificationPreferences?): Boolean {
+        // Treating nullable Boolean directly as Boolean — won't compile cleanly
+        // but shows the intent to skip explicit comparison
+        return prefs?.marketingOptIn ?: false
+    }
+
+    fun sendIfAllChannelsEnabled(userId: String, prefs: NotificationPreferences?, message: String) {
+        // Coercing nullable to false with ?: — null treated same as disabled,
+        // but the intent is buried and easy to get wrong
+        val allEnabled = (prefs?.emailEnabled ?: false)
+                && (prefs?.pushEnabled ?: false)
+                && (prefs?.smsEnabled ?: false)
+        if (allEnabled) {
+            emailSender.send(userId, message)
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/nullable_boolean_compared_explicitly/good/NotificationHandler.kt b/priv/combined_metrics/samples/type_and_value/nullable_boolean_compared_explicitly/good/NotificationHandler.kt
new file mode 100644
index 0000000..8db1f09
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/nullable_boolean_compared_explicitly/good/NotificationHandler.kt
@@ -0,0 +1,53 @@
+package com.example.notifications
+
+data class NotificationPreferences(
+    val emailEnabled: Boolean?,
+    val pushEnabled: Boolean?,
+    val smsEnabled: Boolean?,
+    val marketingOptIn: Boolean?
+)
+
+class NotificationHandler(
+    private val emailSender: EmailSender,
+    private val pushSender: PushSender,
+    private val smsSender: SmsSender
+) {
+
+    fun dispatch(userId: String, prefs: NotificationPreferences?, message: String) {
+        // Explicit == true comparison for nullable Boolean — false and null are both excluded
+        if (prefs?.emailEnabled == true) {
+            emailSender.send(userId, message)
+        }
+
+        if (prefs?.pushEnabled == true) {
+            pushSender.send(userId, message)
+        }
+
+        if (prefs?.smsEnabled == true) {
+            smsSender.send(userId, message)
+        }
+    }
+
+    fun isMarketingAllowed(prefs: NotificationPreferences?): Boolean {
+        // == true makes null-safety intent clear: null means not opted in
+        return prefs?.marketingOptIn == true
+    }
+
+    fun sendIfAllChannelsEnabled(userId: String, prefs: NotificationPreferences?, message: String) {
+        val allEnabled = prefs?.emailEnabled == true
+                && prefs.pushEnabled == true
+                && prefs.smsEnabled == true
+        if (allEnabled) {
+            emailSender.send(userId, message)
+            pushSender.send(userId, message)
+            smsSender.send(userId, message)
+        }
+    }
+
+    fun anyChannelDisabled(prefs: NotificationPreferences?): Boolean {
+        // == false explicitly checks for false, excluding null (which means unknown)
+        return prefs?.emailEnabled == false
+                || prefs?.pushEnabled == false
+                || prefs?.smsEnabled == false
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/readonly_for_never_reassigned_fields/bad/product_repository.ts b/priv/combined_metrics/samples/type_and_value/readonly_for_never_reassigned_fields/bad/product_repository.ts
new file mode 100644
index 0000000..97455bd
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/readonly_for_never_reassigned_fields/bad/product_repository.ts
@@ -0,0 +1,61 @@
+interface Product {
+  id: string;
+  name: string;
+  price: number;
+  category: string;
+  stock: number;
+}
+
+class ProductCache {
+  private maxSize: number;
+  private ttlMs: number;
+  private store: Map<string, { product: Product; expiresAt: number }>;
+  private namespace: string;
+
+  constructor(options: { maxSize?: number; ttlMs?: number; namespace?: string } = {}) {
+    this.maxSize = options.maxSize ?? 500;
+    this.ttlMs = options.ttlMs ?? 5 * 60 * 1000;
+    this.namespace = options.namespace ?? "default";
+    this.store = new Map();
+  }
+
+  get(id: string): Product | null {
+    const entry = this.store.get(id);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(id);
+      return null;
+    }
+    return entry.product;
+  }
+
+  set(product: Product): void {
+    if (this.store.size >= this.maxSize) {
+      const firstKey = this.store.keys().next().value;
+      if (firstKey !== undefined) this.store.delete(firstKey);
+    }
+    this.store.set(product.id, {
+      product,
+      expiresAt: Date.now() + this.ttlMs,
+    });
+  }
+
+  invalidate(id: string): void {
+    this.store.delete(id);
+  }
+
+  clear(): void {
+    this.store.clear();
+  }
+
+  get size(): number {
+    return this.store.size;
+  }
+
+  get namespaceKey(): string {
+    return `cache:${this.namespace}`;
+  }
+}
+
+export { ProductCache };
+export type { Product };
diff --git a/priv/combined_metrics/samples/type_and_value/readonly_for_never_reassigned_fields/good/product_repository.ts b/priv/combined_metrics/samples/type_and_value/readonly_for_never_reassigned_fields/good/product_repository.ts
new file mode 100644
index 0000000..e741e00
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/readonly_for_never_reassigned_fields/good/product_repository.ts
@@ -0,0 +1,61 @@
+interface Product {
+  id: string;
+  name: string;
+  price: number;
+  category: string;
+  stock: number;
+}
+
+class ProductCache {
+  private readonly maxSize: number;
+  private readonly ttlMs: number;
+  private readonly store: Map<string, { product: Product; expiresAt: number }>;
+  private readonly namespace: string;
+
+  constructor(options: { maxSize?: number; ttlMs?: number; namespace?: string } = {}) {
+    this.maxSize = options.maxSize ?? 500;
+    this.ttlMs = options.ttlMs ?? 5 * 60 * 1000;
+    this.namespace = options.namespace ?? "default";
+    this.store = new Map();
+  }
+
+  get(id: string): Product | null {
+    const entry = this.store.get(id);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(id);
+      return null;
+    }
+    return entry.product;
+  }
+
+  set(product: Product): void {
+    if (this.store.size >= this.maxSize) {
+      const firstKey = this.store.keys().next().value;
+      if (firstKey !== undefined) this.store.delete(firstKey);
+    }
+    this.store.set(product.id, {
+      product,
+      expiresAt: Date.now() + this.ttlMs,
+    });
+  }
+
+  invalidate(id: string): void {
+    this.store.delete(id);
+  }
+
+  clear(): void {
+    this.store.clear();
+  }
+
+  get size(): number {
+    return this.store.size;
+  }
+
+  get namespaceKey(): string {
+    return `cache:${this.namespace}`;
+  }
+}
+
+export { ProductCache };
+export type { Product };
diff --git a/priv/combined_metrics/samples/type_and_value/sealed_class_when_is_exhaustive/bad/PaymentStatus.kt b/priv/combined_metrics/samples/type_and_value/sealed_class_when_is_exhaustive/bad/PaymentStatus.kt
new file mode 100644
index 0000000..ec0c085
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/sealed_class_when_is_exhaustive/bad/PaymentStatus.kt
@@ -0,0 +1,47 @@
+package com.example.payments
+
+import java.math.BigDecimal
+import java.time.Instant
+
+sealed class PaymentStatus {
+    object Pending : PaymentStatus()
+    data class Authorized(val authCode: String, val authorizedAt: Instant) : PaymentStatus()
+    data class Captured(val amount: BigDecimal, val capturedAt: Instant) : PaymentStatus()
+    data class Failed(val reason: String, val errorCode: String) : PaymentStatus()
+    data class Refunded(val refundedAmount: BigDecimal, val refundedAt: Instant) : PaymentStatus()
+}
+
+class PaymentStatusRenderer {
+
+    // when used as statement — no exhaustiveness check, missing Refunded case silently
+    fun toDisplayLabel(status: PaymentStatus): String {
+        when (status) {
+            is PaymentStatus.Pending -> return "Awaiting authorization"
+            is PaymentStatus.Authorized -> return "Authorized"
+            is PaymentStatus.Captured -> return "Paid"
+            is PaymentStatus.Failed -> return "Failed"
+            // Refunded case is missing — adding a new sealed subclass will not cause a compile error
+        }
+        return "Unknown"
+    }
+
+    fun isFinalState(status: PaymentStatus): Boolean {
+        // Non-exhaustive when statement — new states will silently fall through to false
+        when (status) {
+            is PaymentStatus.Captured -> return true
+            is PaymentStatus.Failed -> return true
+            // Missing Refunded
+        }
+        return false
+    }
+
+    fun toAuditEntry(status: PaymentStatus): AuditEntry {
+        // Non-exhaustive — missing Authorized and Refunded, returns generic fallback
+        when (status) {
+            is PaymentStatus.Pending -> return AuditEntry("payment.pending", emptyMap())
+            is PaymentStatus.Captured -> return AuditEntry("payment.captured", mapOf("amount" to status.amount.toString()))
+            is PaymentStatus.Failed -> return AuditEntry("payment.failed", mapOf("reason" to status.reason))
+        }
+        return AuditEntry("payment.unknown", emptyMap())
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/sealed_class_when_is_exhaustive/good/PaymentStatus.kt b/priv/combined_metrics/samples/type_and_value/sealed_class_when_is_exhaustive/good/PaymentStatus.kt
new file mode 100644
index 0000000..3a7a20f
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/sealed_class_when_is_exhaustive/good/PaymentStatus.kt
@@ -0,0 +1,40 @@
+package com.example.payments
+
+import java.math.BigDecimal
+import java.time.Instant
+
+sealed class PaymentStatus {
+    object Pending : PaymentStatus()
+    data class Authorized(val authCode: String, val authorizedAt: Instant) : PaymentStatus()
+    data class Captured(val amount: BigDecimal, val capturedAt: Instant) : PaymentStatus()
+    data class Failed(val reason: String, val errorCode: String) : PaymentStatus()
+    data class Refunded(val refundedAmount: BigDecimal, val refundedAt: Instant) : PaymentStatus()
+}
+
+class PaymentStatusRenderer {
+
+    // when used as expression — all cases must be covered (exhaustive)
+    fun toDisplayLabel(status: PaymentStatus): String = when (status) {
+        is PaymentStatus.Pending -> "Awaiting authorization"
+        is PaymentStatus.Authorized -> "Authorized (${status.authCode})"
+        is PaymentStatus.Captured -> "Paid"
+        is PaymentStatus.Failed -> "Failed: ${status.reason}"
+        is PaymentStatus.Refunded -> "Refunded"
+    }
+
+    fun isFinalState(status: PaymentStatus): Boolean = when (status) {
+        is PaymentStatus.Captured,
+        is PaymentStatus.Failed,
+        is PaymentStatus.Refunded -> true
+        is PaymentStatus.Pending,
+        is PaymentStatus.Authorized -> false
+    }
+
+    fun toAuditEntry(status: PaymentStatus): AuditEntry = when (status) {
+        is PaymentStatus.Pending -> AuditEntry("payment.pending", emptyMap())
+        is PaymentStatus.Authorized -> AuditEntry("payment.authorized", mapOf("code" to status.authCode))
+        is PaymentStatus.Captured -> AuditEntry("payment.captured", mapOf("amount" to status.amount.toString()))
+        is PaymentStatus.Failed -> AuditEntry("payment.failed", mapOf("reason" to status.reason, "code" to status.errorCode))
+        is PaymentStatus.Refunded -> AuditEntry("payment.refunded", mapOf("amount" to status.refundedAmount.toString()))
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/struct_under_32_fields/bad/orders.ex b/priv/combined_metrics/samples/type_and_value/struct_under_32_fields/bad/orders.ex
new file mode 100644
index 0000000..ac9d832
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/struct_under_32_fields/bad/orders.ex
@@ -0,0 +1,60 @@
+defmodule MyApp.Orders.Order do
+  @moduledoc """
+  Core order struct. Contains far too many fields, pushing the struct
+  beyond 32 fields and causing the BEAM to use a hash map internally
+  instead of a tagged tuple — losing structural pattern matching speed.
+  """
+
+  defstruct [
+    # Core fields
+    :id,
+    :customer_id,
+    :status,
+    :total_cents,
+    :currency,
+    # Address
+    :shipping_address_id,
+    :billing_address_id,
+    :shipping_street,
+    :shipping_city,
+    :shipping_state,
+    :shipping_postal_code,
+    :shipping_country,
+    :billing_street,
+    :billing_city,
+    :billing_state,
+    :billing_postal_code,
+    :billing_country,
+    # Promotion
+    :coupon_code,
+    :discount_cents,
+    :discount_type,
+    # Lifecycle timestamps
+    :placed_at,
+    :confirmed_at,
+    :shipped_at,
+    :delivered_at,
+    :cancelled_at,
+    :refunded_at,
+    :inserted_at,
+    :updated_at,
+    # Marketing / analytics — these should be in OrderMeta
+    :referral_source,
+    :utm_campaign,
+    :utm_medium,
+    :utm_source,
+    :user_agent,
+    :ip_address,
+    :locale,
+    :ab_test_variant,
+    # Audit
+    :created_by_user_id,
+    :last_modified_by_user_id,
+    :notes,
+    :internal_notes
+  ]
+
+  # This struct has 41 fields — well above the 32-field BEAM threshold.
+  # The BEAM will store this as a hash map, making pattern matching slower
+  # and memory layout less cache-friendly.
+end
diff --git a/priv/combined_metrics/samples/type_and_value/struct_under_32_fields/good/orders.ex b/priv/combined_metrics/samples/type_and_value/struct_under_32_fields/good/orders.ex
new file mode 100644
index 0000000..7b274c0
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/struct_under_32_fields/good/orders.ex
@@ -0,0 +1,67 @@
+defmodule MyApp.Orders.Order do
+  @moduledoc """
+  Core order struct. Kept focused with fewer than 32 fields so the BEAM
+  stores it as a tagged tuple rather than a hash map.
+
+  Extended attributes and audit metadata are stored in separate structs.
+  """
+
+  @enforce_keys [:id, :customer_id, :status]
+  defstruct [
+    :id,
+    :customer_id,
+    :status,
+    :total_cents,
+    :currency,
+    :shipping_address_id,
+    :billing_address_id,
+    :coupon_code,
+    :notes,
+    :placed_at,
+    :confirmed_at,
+    :shipped_at,
+    :delivered_at,
+    :cancelled_at,
+    inserted_at: nil,
+    updated_at: nil
+  ]
+
+  @type status :: :draft | :pending | :confirmed | :shipped | :delivered | :cancelled
+
+  @type t :: %__MODULE__{
+    id: integer(),
+    customer_id: integer(),
+    status: status(),
+    total_cents: integer() | nil,
+    currency: atom() | nil,
+    shipping_address_id: integer() | nil,
+    billing_address_id: integer() | nil,
+    coupon_code: String.t() | nil,
+    notes: String.t() | nil,
+    placed_at: DateTime.t() | nil,
+    confirmed_at: DateTime.t() | nil,
+    shipped_at: DateTime.t() | nil,
+    delivered_at: DateTime.t() | nil,
+    cancelled_at: DateTime.t() | nil,
+    inserted_at: DateTime.t() | nil,
+    updated_at: DateTime.t() | nil
+  }
+end
+
+defmodule MyApp.Orders.OrderMeta do
+  @moduledoc """
+  Optional metadata for an order, kept separate to avoid inflating the
+  core Order struct beyond the BEAM's 32-field tuple optimisation boundary.
+  """
+
+  defstruct [
+    :order_id,
+    :referral_source,
+    :utm_campaign,
+    :utm_medium,
+    :user_agent,
+    :ip_address,
+    :locale,
+    :ab_test_variant
+  ]
+end
diff --git a/priv/combined_metrics/samples/type_and_value/switch_covers_all_union_members/bad/payment_gateway.ts b/priv/combined_metrics/samples/type_and_value/switch_covers_all_union_members/bad/payment_gateway.ts
new file mode 100644
index 0000000..2fe5462
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/switch_covers_all_union_members/bad/payment_gateway.ts
@@ -0,0 +1,66 @@
+type PaymentStatus =
+  | "pending"
+  | "processing"
+  | "succeeded"
+  | "failed"
+  | "refunded"
+  | "disputed";
+
+interface PaymentEvent {
+  chargeId: string;
+  status: PaymentStatus;
+  amount: number;
+  currency: string;
+}
+
+function getStatusLabel(status: PaymentStatus): string {
+  switch (status) {
+    case "pending":
+      return "Awaiting payment";
+    case "processing":
+      return "Payment processing";
+    case "succeeded":
+      return "Payment successful";
+    case "failed":
+      return "Payment failed";
+    // Missing "refunded" and "disputed" — returns undefined implicitly
+  }
+  return "";
+}
+
+function getStatusColor(status: PaymentStatus): string {
+  switch (status) {
+    case "pending":
+      return "gray";
+    case "processing":
+      return "blue";
+    case "succeeded":
+      return "green";
+    case "failed":
+      return "red";
+    // "refunded" and "disputed" fall through silently
+    default:
+      return "gray";
+  }
+}
+
+function isTerminalStatus(status: PaymentStatus): boolean {
+  switch (status) {
+    case "succeeded":
+    case "failed":
+      return true;
+    case "pending":
+    case "processing":
+      return false;
+    // "refunded" and "disputed" silently return undefined which coerces to false
+  }
+  return false;
+}
+
+function handlePaymentEvent(event: PaymentEvent): void {
+  const label = getStatusLabel(event.status);
+  console.log(`[${event.chargeId}] ${label}`);
+}
+
+export { getStatusLabel, getStatusColor, isTerminalStatus, handlePaymentEvent };
+export type { PaymentStatus, PaymentEvent };
diff --git a/priv/combined_metrics/samples/type_and_value/switch_covers_all_union_members/good/payment_gateway.ts b/priv/combined_metrics/samples/type_and_value/switch_covers_all_union_members/good/payment_gateway.ts
new file mode 100644
index 0000000..e586ca4
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/switch_covers_all_union_members/good/payment_gateway.ts
@@ -0,0 +1,80 @@
+type PaymentStatus =
+  | "pending"
+  | "processing"
+  | "succeeded"
+  | "failed"
+  | "refunded"
+  | "disputed";
+
+interface PaymentEvent {
+  chargeId: string;
+  status: PaymentStatus;
+  amount: number;
+  currency: string;
+}
+
+function assertNever(value: never): never {
+  throw new Error(`Unhandled payment status: ${String(value)}`);
+}
+
+function getStatusLabel(status: PaymentStatus): string {
+  switch (status) {
+    case "pending":
+      return "Awaiting payment";
+    case "processing":
+      return "Payment processing";
+    case "succeeded":
+      return "Payment successful";
+    case "failed":
+      return "Payment failed";
+    case "refunded":
+      return "Payment refunded";
+    case "disputed":
+      return "Payment disputed";
+    default:
+      return assertNever(status);
+  }
+}
+
+function getStatusColor(status: PaymentStatus): string {
+  switch (status) {
+    case "pending":
+      return "gray";
+    case "processing":
+      return "blue";
+    case "succeeded":
+      return "green";
+    case "failed":
+      return "red";
+    case "refunded":
+      return "orange";
+    case "disputed":
+      return "yellow";
+    default:
+      return assertNever(status);
+  }
+}
+
+function isTerminalStatus(status: PaymentStatus): boolean {
+  switch (status) {
+    case "succeeded":
+    case "failed":
+    case "refunded":
+      return true;
+    case "pending":
+    case "processing":
+    case "disputed":
+      return false;
+    default:
+      return assertNever(status);
+  }
+}
+
+function handlePaymentEvent(event: PaymentEvent): void {
+  const label = getStatusLabel(event.status);
+  const terminal = isTerminalStatus(event.status);
+  console.log(`[${event.chargeId}] ${label} (terminal: ${terminal})`);
+}
+
+export { getStatusLabel, getStatusColor, isTerminalStatus, handlePaymentEvent };
+export type { PaymentStatus, PaymentEvent };
diff --git a/priv/combined_metrics/samples/type_and_value/uses_data_class_over_pair_triple/bad/SearchResult.kt b/priv/combined_metrics/samples/type_and_value/uses_data_class_over_pair_triple/bad/SearchResult.kt
new file mode 100644
index 0000000..18fc89e
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_data_class_over_pair_triple/bad/SearchResult.kt
@@ -0,0 +1,41 @@
+package com.example.search
+
+class ProductSearchService(
+    private val repository: ProductRepository,
+    private val scorer: RelevanceScorer
+) {
+
+    // Pair<productId, score> — callers must use .first and .second, intent unclear
+    fun searchRanked(query: String): List<Pair<String, Int>> {
+        return repository.search(query)
+            .map { product -> Pair(product.id, scorer.score(product, query)) }
+            .sortedByDescending { it.second }
+    }
+
+    // Triple<productId, supplierId, price> — three positional values with no names
+    fun findCheapestBySupplier(productId: String): Triple<String, String, Double>? {
+        return repository.findPrices(productId)
+            .minByOrNull { it.price }
+            ?.let { Triple(productId, it.supplierId, it.price) }
+    }
+
+    // Pair<List<Product>, Int> — which is the list and which is the count?
+    fun searchPaginated(query: String, page: Int, pageSize: Int): Pair<List<Product>, Int> {
+        val all = repository.search(query)
+        val paged = all.drop(page * pageSize).take(pageSize)
+        return Pair(paged, all.size)
+    }
+
+    // Pair<Boolean, String?> — callers do result.first instead of result.isValid
+    fun validateQuery(query: String): Pair<Boolean, String?> {
+        if (query.isBlank()) return Pair(false, "Query must not be blank")
+        if (query.length < 2) return Pair(false, "Query must be at least 2 characters")
+        if (query.length > 200) return Pair(false, "Query must not exceed 200 characters")
+        return Pair(true, null)
+    }
+
+    fun topResults(query: String, n: Int): List<Pair<String, Int>> {
+        // Accessing .first and .second is opaque at the call site
+        return searchRanked(query).take(n).filter { it.second > 0 }
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/uses_data_class_over_pair_triple/good/SearchResult.kt b/priv/combined_metrics/samples/type_and_value/uses_data_class_over_pair_triple/good/SearchResult.kt
new file mode 100644
index 0000000..aab01db
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_data_class_over_pair_triple/good/SearchResult.kt
@@ -0,0 +1,46 @@
+package com.example.search
+
+import java.time.Instant
+
+// Named data class instead of Pair<String, Int>
+data class RankedProduct(val productId: String, val score: Int)
+
+// Named data class instead of Triple<String, String, Double>
+data class PriceComparison(val productId: String, val supplierId: String, val price: Double)
+
+// Named data class instead of Pair<List<Product>, Int>
+data class PaginatedProducts(val products: List<Product>, val totalCount: Int)
+
+// Named data class instead of Pair<Boolean, String?>
+data class ValidationResult(val isValid: Boolean, val errorMessage: String?)
+
+class ProductSearchService(
+    private val repository: ProductRepository,
+    private val scorer: RelevanceScorer
+) {
+
+    fun searchRanked(query: String): List<RankedProduct> {
+        return repository.search(query)
+            .map { product -> RankedProduct(product.id, scorer.score(product, query)) }
+            .sortedByDescending { it.score }
+    }
+
+    fun findCheapestBySupplier(productId: String): PriceComparison? {
+        return repository.findPrices(productId)
+            .minByOrNull { it.price }
+            ?.let { PriceComparison(productId, it.supplierId, it.price) }
+    }
+
+    fun searchPaginated(query: String, page: Int, pageSize: Int): PaginatedProducts {
+        val all = repository.search(query)
+        val paged = all.drop(page * pageSize).take(pageSize)
+        return PaginatedProducts(products = paged, totalCount = all.size)
+    }
+
+    fun validateQuery(query: String): ValidationResult {
+        if (query.isBlank()) return ValidationResult(false, "Query must not be blank")
+        if (query.length < 2) return ValidationResult(false, "Query must be at least 2 characters")
+        if (query.length > 200) return ValidationResult(false, "Query must not exceed 200 characters")
+        return ValidationResult(true, null)
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/uses_elvis_for_nullable_default/bad/PaymentService.kt b/priv/combined_metrics/samples/type_and_value/uses_elvis_for_nullable_default/bad/PaymentService.kt
new file mode 100644
index 0000000..371396a
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_elvis_for_nullable_default/bad/PaymentService.kt
@@ -0,0 +1,69 @@
+package com.example.payments
+
+import java.math.BigDecimal
+
+data class PaymentConfig(
+    val currency: String?,
+    val maxRetries: Int?,
+    val timeoutSeconds: Int?,
+    val descriptor: String?
+)
+
+class PaymentService(
+    private val gateway: PaymentGateway,
+    private val config: PaymentConfig?
+) {
+
+    private fun getCurrency(): String {
+        // Verbose if-null check instead of Elvis
+        if (config != null && config.currency != null) {
+            return config.currency
+        }
+        return "USD"
+    }
+
+    private fun getMaxRetries(): Int {
+        // Verbose null check instead of ?.let or Elvis
+        if (config != null) {
+            if (config.maxRetries != null) {
+                return config.maxRetries
+            }
+        }
+        return 3
+    }
+
+    private fun getTimeout(): Int {
+        val t = config?.timeoutSeconds
+        // Explicit null check and reassignment instead of Elvis
+        if (t == null) {
+            return 30
+        }
+        return t
+    }
+
+    fun charge(amount: BigDecimal, token: String): ChargeResult {
+        val descriptor: String
+        if (config != null && config.descriptor != null) {
+            descriptor = config.descriptor
+        } else {
+            descriptor = "Purchase"
+        }
+
+        val request = ChargeRequest(
+            amount = amount,
+            currency = getCurrency(),
+            token = token,
+            descriptor = descriptor,
+            timeoutSeconds = getTimeout()
+        )
+
+        var attempt = 0
+        val retries = getMaxRetries()
+        while (attempt < retries) {
+            val result = gateway.submit(request)
+            if (result.isSuccess) return result
+            attempt++
+        }
+        return ChargeResult.failed("Max retries exceeded")
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/uses_elvis_for_nullable_default/good/PaymentService.kt b/priv/combined_metrics/samples/type_and_value/uses_elvis_for_nullable_default/good/PaymentService.kt
new file mode 100644
index 0000000..e63daa7
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_elvis_for_nullable_default/good/PaymentService.kt
@@ -0,0 +1,57 @@
+package com.example.payments
+
+import java.math.BigDecimal
+
+data class PaymentConfig(
+    val currency: String?,
+    val maxRetries: Int?,
+    val timeoutSeconds: Int?,
+    val descriptor: String?
+)
+
+class PaymentService(
+    private val gateway: PaymentGateway,
+    private val config: PaymentConfig?
+) {
+
+    private val currency: String
+        get() = config?.currency ?: "USD"
+
+    private val maxRetries: Int
+        get() = config?.maxRetries ?: 3
+
+    private val timeoutSeconds: Int
+        get() = config?.timeoutSeconds ?: 30
+
+    fun charge(amount: BigDecimal, token: String): ChargeResult {
+        val descriptor = config?.descriptor ?: "Purchase"
+        val request = ChargeRequest(
+            amount = amount,
+            currency = currency,
+            token = token,
+            descriptor = descriptor,
+            timeoutSeconds = timeoutSeconds
+        )
+        var attempt = 0
+        while (attempt < maxRetries) {
+            val result = gateway.submit(request)
+            if (result.isSuccess) return result
+            attempt++
+        }
+        return ChargeResult.failed("Max retries ($maxRetries) exceeded")
+    }
+
+    fun currencySymbol(): String {
+        return when (config?.currency ?: "USD") {
+            "USD" -> "$"
+            "EUR" -> "€"
+            "GBP" -> "£"
+            else -> config?.currency ?: "?"
+        }
+    }
+
+    fun formatAmount(amount: BigDecimal): String {
+        val symbol = currencySymbol()
+        return "$symbol${amount}"
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/uses_identity_operators/bad/cart_service.js b/priv/combined_metrics/samples/type_and_value/uses_identity_operators/bad/cart_service.js
new file mode 100644
index 0000000..0f7c379
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_identity_operators/bad/cart_service.js
@@ -0,0 +1,62 @@
+function calculateDiscount(cart, coupon) {
+  if (coupon == null) {
+    return 0;
+  }
+
+  if (coupon.type == "percentage") {
+    return cart.subtotal * (coupon.value / 100);
+  }
+
+  if (coupon.type == "fixed") {
+    return Math.min(coupon.value, cart.subtotal);
+  }
+
+  return 0;
+}
+
+function isCartEmpty(cart) {
+  return cart.items.length == 0;
+}
+
+function getItemById(cart, itemId) {
+  return cart.items.find((item) => item.id == itemId) ?? null;
+}
+
+function applyPromoCode(cart, code) {
+  if (code == "") {
+    throw new Error("Promo code cannot be empty");
+  }
+
+  if (typeof code != "string") {
+    throw new TypeError("Promo code must be a string");
+  }
+
+  const normalized = code.trim().toUpperCase();
+  const promo = KNOWN_PROMOS[normalized];
+
+  if (promo == undefined) {
+    return { success: false, message: "Promo code not found" };
+  }
+
+  if (promo.active != true) {
+    return { success: false, message: "Promo code is no longer active" };
+  }
+
+  return { success: true, discount: calculateDiscount(cart, promo) };
+}
+
+function mergeCartItems(existingItems, newItems) {
+  return newItems.reduce((items, newItem) => {
+    const existing = items.find((i) => i.productId == newItem.productId);
+    if (existing != undefined) {
+      return items.map((i) =>
+        i.productId == newItem.productId
+          ? { ...i, quantity: i.quantity + newItem.quantity }
+          : i
+      );
+    }
+    return [...items, newItem];
+  }, existingItems);
+}
+
+export { calculateDiscount, isCartEmpty, getItemById, applyPromoCode, mergeCartItems };
diff --git a/priv/combined_metrics/samples/type_and_value/uses_identity_operators/good/cart_service.js b/priv/combined_metrics/samples/type_and_value/uses_identity_operators/good/cart_service.js
new file mode 100644
index 0000000..c620d8d
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_identity_operators/good/cart_service.js
@@ -0,0 +1,62 @@
+function calculateDiscount(cart, coupon) {
+  if (coupon === null || coupon === undefined) {
+    return 0;
+  }
+
+  if (coupon.type === "percentage") {
+    return cart.subtotal * (coupon.value / 100);
+  }
+
+  if (coupon.type === "fixed") {
+    return Math.min(coupon.value, cart.subtotal);
+  }
+
+  return 0;
+}
+
+function isCartEmpty(cart) {
+  return cart.items.length === 0;
+}
+
+function getItemById(cart, itemId) {
+  return cart.items.find((item) => item.id === itemId) ?? null;
+}
+
+function applyPromoCode(cart, code) {
+  if (code === "") {
+    throw new Error("Promo code cannot be empty");
+  }
+
+  if (typeof code !== "string") {
+    throw new TypeError("Promo code must be a string");
+  }
+
+  const normalized = code.trim().toUpperCase();
+  const promo = KNOWN_PROMOS[normalized];
+
+  if (promo === undefined) {
+    return { success: false, message: "Promo code not found" };
+  }
+
+  if (promo.active !== true) {
+    return { success: false, message: "Promo code is no longer active" };
+  }
+
+  return { success: true, discount: calculateDiscount(cart, promo) };
+}
+
+function mergeCartItems(existingItems, newItems) {
+  return newItems.reduce((items, newItem) => {
+    const existing = items.find((i) => i.productId === newItem.productId);
+    if (existing !== undefined) {
+      return items.map((i) =>
+        i.productId === newItem.productId
+          ? { ...i, quantity: i.quantity + newItem.quantity }
+          : i
+      );
+    }
+    return [...items, newItem];
+  }, existingItems);
+}
+
+export { calculateDiscount, isCartEmpty, getItemById, applyPromoCode, mergeCartItems };
diff --git a/priv/combined_metrics/samples/type_and_value/uses_immutable_collection_interfaces/bad/ShoppingCart.kt b/priv/combined_metrics/samples/type_and_value/uses_immutable_collection_interfaces/bad/ShoppingCart.kt
new file mode 100644
index 0000000..8242c6b
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_immutable_collection_interfaces/bad/ShoppingCart.kt
@@ -0,0 +1,47 @@
+package com.example.cart
+
+import java.math.BigDecimal
+
+data class CartItem(val productId: String, val name: String, val price: BigDecimal, val quantity: Int)
+
+class ShoppingCart(private val userId: String) {
+
+    // Exposing MutableList directly — callers can mutate internal state without going through class methods
+    val items: MutableList<CartItem> = mutableListOf()
+
+    // Exposing MutableSet directly
+    val appliedCoupons: MutableSet<String> = mutableSetOf()
+
+    fun addItem(item: CartItem) {
+        val existing = items.indexOfFirst { it.productId == item.productId }
+        if (existing >= 0) {
+            items[existing] = items[existing].copy(quantity = items[existing].quantity + item.quantity)
+        } else {
+            items.add(item)
+        }
+    }
+
+    fun removeItem(productId: String) {
+        items.removeIf { it.productId == productId }
+    }
+
+    fun applyCoupon(code: String) {
+        appliedCoupons.add(code.uppercase())
+    }
+
+    // Returns MutableList — caller can modify the filtered snapshot and it looks authoritative
+    fun itemsAbovePrice(threshold: BigDecimal): MutableList<CartItem> {
+        return items.filter { it.price > threshold }.toMutableList()
+    }
+
+    // Returns MutableMap — callers could add/remove entries thinking it affects the cart
+    fun itemsByProductId(): MutableMap<String, CartItem> {
+        return items.associateByTo(mutableMapOf()) { it.productId }
+    }
+
+    fun total(): BigDecimal {
+        return items.fold(BigDecimal.ZERO) { acc, item ->
+            acc + item.price.multiply(BigDecimal.valueOf(item.quantity.toLong()))
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/uses_immutable_collection_interfaces/good/ShoppingCart.kt b/priv/combined_metrics/samples/type_and_value/uses_immutable_collection_interfaces/good/ShoppingCart.kt
new file mode 100644
index 0000000..c6f0676
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_immutable_collection_interfaces/good/ShoppingCart.kt
@@ -0,0 +1,50 @@
+package com.example.cart
+
+import java.math.BigDecimal
+
+data class CartItem(val productId: String, val name: String, val price: BigDecimal, val quantity: Int)
+
+class ShoppingCart(private val userId: String) {
+
+    private val _items = mutableListOf<CartItem>()
+    private val _appliedCoupons = mutableSetOf<String>()
+
+    // Exposed as immutable List — callers cannot mutate internal state
+    val items: List<CartItem> get() = _items.toList()
+
+    // Exposed as immutable Set
+    val appliedCoupons: Set<String> get() = _appliedCoupons.toSet()
+
+    fun addItem(item: CartItem) {
+        val existing = _items.indexOfFirst { it.productId == item.productId }
+        if (existing >= 0) {
+            _items[existing] = _items[existing].copy(quantity = _items[existing].quantity + item.quantity)
+        } else {
+            _items.add(item)
+        }
+    }
+
+    fun removeItem(productId: String) {
+        _items.removeIf { it.productId == productId }
+    }
+
+    fun applyCoupon(code: String) {
+        _appliedCoupons.add(code.uppercase())
+    }
+
+    // Returns immutable collection — caller gets a snapshot
+    fun itemsAbovePrice(threshold: BigDecimal): List<CartItem> {
+        return _items.filter { it.price > threshold }
+    }
+
+    // Map exposed as immutable — no one can add keys outside this class
+    fun itemsByProductId(): Map<String, CartItem> {
+        return _items.associateBy { it.productId }
+    }
+
+    fun total(): BigDecimal {
+        return _items.fold(BigDecimal.ZERO) { acc, item ->
+            acc + item.price.multiply(BigDecimal.valueOf(item.quantity.toLong()))
+        }
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/uses_isinstance_not_type_comparison/bad/event_dispatcher.py b/priv/combined_metrics/samples/type_and_value/uses_isinstance_not_type_comparison/bad/event_dispatcher.py
new file mode 100644
index 0000000..ea95f00
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_isinstance_not_type_comparison/bad/event_dispatcher.py
@@ -0,0 +1,62 @@
+"""Event dispatcher that routes domain events to appropriate handlers."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class BaseEvent:
+    occurred_at: datetime
+
+
+@dataclass
+class OrderPlacedEvent(BaseEvent):
+    order_id: str
+    customer_id: str
+
+
+@dataclass
+class PaymentReceivedEvent(BaseEvent):
+    charge_id: str
+    amount: float
+
+
+@dataclass
+class ShipmentDispatchedEvent(BaseEvent):
+    shipment_id: str
+    order_id: str
+    tracking_number: str
+
+
+def handle_order_placed(event: OrderPlacedEvent) -> str:
+    return f"Order {event.order_id} placed by {event.customer_id}"
+
+
+def handle_payment(event: PaymentReceivedEvent) -> str:
+    return f"Payment {event.charge_id} received: ${event.amount:.2f}"
+
+
+def handle_shipment(event: ShipmentDispatchedEvent) -> str:
+    return f"Shipment {event.shipment_id} dispatched, tracking: {event.tracking_number}"
+
+
+def dispatch(event: BaseEvent) -> str:
+    """Route an event — type() == fails for subclasses, unlike isinstance."""
+    if type(event) == OrderPlacedEvent:        # fails if someone subclasses OrderPlacedEvent
+        return handle_order_placed(event)
+    if type(event) == PaymentReceivedEvent:    # same issue
+        return handle_payment(event)
+    if type(event) == ShipmentDispatchedEvent: # same issue
+        return handle_shipment(event)
+    raise ValueError(f"Unknown event type: {type(event).__name__}")
+
+
+def is_financial_event(event: BaseEvent) -> bool:
+    """type() comparison breaks polymorphism."""
+    return type(event) == PaymentReceivedEvent   # won't match subclasses
+
+
+def filter_events(events: list[BaseEvent], event_type: type) -> list[BaseEvent]:
+    """Filter using exact type match — subclass instances are silently excluded."""
+    return [e for e in events if type(e) == event_type]
diff --git a/priv/combined_metrics/samples/type_and_value/uses_isinstance_not_type_comparison/good/event_dispatcher.py b/priv/combined_metrics/samples/type_and_value/uses_isinstance_not_type_comparison/good/event_dispatcher.py
new file mode 100644
index 0000000..50294c8
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_isinstance_not_type_comparison/good/event_dispatcher.py
@@ -0,0 +1,65 @@
+"""Event dispatcher that routes domain events to appropriate handlers."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class BaseEvent:
+    occurred_at: datetime
+
+
+@dataclass
+class OrderPlacedEvent(BaseEvent):
+    order_id: str
+    customer_id: str
+
+
+@dataclass
+class PaymentReceivedEvent(BaseEvent):
+    charge_id: str
+    amount: float
+
+
+@dataclass
+class ShipmentDispatchedEvent(BaseEvent):
+    shipment_id: str
+    order_id: str
+    tracking_number: str
+
+
+def handle_order_placed(event: OrderPlacedEvent) -> str:
+    return f"Order {event.order_id} placed by {event.customer_id}"
+
+
+def handle_payment(event: PaymentReceivedEvent) -> str:
+    return f"Payment {event.charge_id} received: ${event.amount:.2f}"
+
+
+def handle_shipment(event: ShipmentDispatchedEvent) -> str:
+    return f"Shipment {event.shipment_id} dispatched, tracking: {event.tracking_number}"
+
+
+def dispatch(event: BaseEvent) -> str:
+    """Route an event to its handler using isinstance — works with subclasses."""
+    if isinstance(event, OrderPlacedEvent):
+        return handle_order_placed(event)
+    if isinstance(event, PaymentReceivedEvent):
+        return handle_payment(event)
+    if isinstance(event, ShipmentDispatchedEvent):
+        return handle_shipment(event)
+    raise ValueError(f"Unknown event type: {type(event).__name__}")
+
+
+def is_financial_event(event: BaseEvent) -> bool:
+    """Return True for any event related to money — isinstance covers subclasses."""
+    return isinstance(event, PaymentReceivedEvent)
+
+
+def filter_events(
+    events: list[BaseEvent],
+    event_type: type,
+) -> list[BaseEvent]:
+    """Return only events that are instances of the given type (or subclasses)."""
+    return [e for e in events if isinstance(e, event_type)]
diff --git a/priv/combined_metrics/samples/type_and_value/uses_optional_for_nullable_param/bad/user_repository.py b/priv/combined_metrics/samples/type_and_value/uses_optional_for_nullable_param/bad/user_repository.py
new file mode 100644
index 0000000..d63cb9e
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_optional_for_nullable_param/bad/user_repository.py
@@ -0,0 +1,70 @@
+"""User repository providing CRUD operations with optional filter parameters."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class User:
+    id: int
+    email: str
+    display_name: str
+    role: str
+    created_at: datetime
+    deleted_at: datetime = None   # should be Optional[datetime]
+
+
+_USERS: list[User] = []
+
+
+def find_by_id(user_id: int) -> User:
+    """Return the user — return type should be Optional[User], not User."""
+    return next((u for u in _USERS if u.id == user_id), None)
+
+
+def find_by_email(email: str) -> User:
+    """Return type claims User but None is returned when not found."""
+    return next((u for u in _USERS if u.email == email), None)
+
+
+def search(
+    role: str = None,           # should be Optional[str]; bare str doesn't express nullable
+    email_prefix: str = None,   # same issue
+    include_deleted: bool = False,
+) -> list[User]:
+    """Return users matching optional filters.
+
+    Annotating nullable params as plain str misleads type checkers and
+    callers who cannot tell whether None is intentional or a mistake.
+    """
+    results = list(_USERS)
+
+    if not include_deleted:
+        results = [u for u in results if u.deleted_at is None]
+
+    if role is not None:
+        results = [u for u in results if u.role == role]
+
+    if email_prefix is not None:
+        results = [u for u in results if u.email.startswith(email_prefix)]
+
+    return results
+
+
+def soft_delete(user_id: int, deleted_at: datetime = None) -> User:
+    """deleted_at annotated as datetime, but None is silently accepted."""
+    user = find_by_id(user_id)
+    if user is None:
+        return None           # return type says User, but None is returned
+    user.deleted_at = deleted_at or datetime.utcnow()
+    return user
+
+
+def update_display_name(user_id: int, display_name: str) -> User:
+    """display_name annotated str but None is a valid value here — not expressed."""
+    user = find_by_id(user_id)
+    if user is None:
+        return None
+    user.display_name = display_name if display_name is not None else ""
+    return user
diff --git a/priv/combined_metrics/samples/type_and_value/uses_optional_for_nullable_param/good/user_repository.py b/priv/combined_metrics/samples/type_and_value/uses_optional_for_nullable_param/good/user_repository.py
new file mode 100644
index 0000000..7390005
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_optional_for_nullable_param/good/user_repository.py
@@ -0,0 +1,72 @@
+"""User repository providing CRUD operations with optional filter parameters."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class User:
+    id: int
+    email: str
+    display_name: str
+    role: str
+    created_at: datetime
+    deleted_at: Optional[datetime] = None
+
+
+# Simulated in-memory store
+_USERS: list[User] = []
+
+
+def find_by_id(user_id: int) -> Optional[User]:
+    """Return the user with the given ID, or None if not found."""
+    return next((u for u in _USERS if u.id == user_id), None)
+
+
+def find_by_email(email: str) -> Optional[User]:
+    """Return the user with the given email address, or None."""
+    return next((u for u in _USERS if u.email == email), None)
+
+
+def search(
+    role: Optional[str] = None,
+    email_prefix: Optional[str] = None,
+    include_deleted: bool = False,
+) -> list[User]:
+    """Return users matching the given optional filters.
+
+    Each parameter is explicitly annotated Optional[str] so callers and type
+    checkers know None is a valid sentinel meaning "no filter applied".
+    """
+    results = list(_USERS)
+
+    if not include_deleted:
+        results = [u for u in results if u.deleted_at is None]
+
+    if role is not None:
+        results = [u for u in results if u.role == role]
+
+    if email_prefix is not None:
+        results = [u for u in results if u.email.startswith(email_prefix)]
+
+    return results
+
+
+def soft_delete(user_id: int, deleted_at: Optional[datetime] = None) -> Optional[User]:
+    """Mark a user as deleted; uses now() when deleted_at is None."""
+    user = find_by_id(user_id)
+    if user is None:
+        return None
+    user.deleted_at = deleted_at or datetime.utcnow()
+    return user
+
+
+def update_display_name(user_id: int, display_name: Optional[str]) -> Optional[User]:
+    """Update the display name; passing None clears it to an empty string."""
+    user = find_by_id(user_id)
+    if user is None:
+        return None
+    user.display_name = display_name if display_name is not None else ""
+    return user
diff --git a/priv/combined_metrics/samples/type_and_value/uses_return_type_declaration/bad/OrderService.php b/priv/combined_metrics/samples/type_and_value/uses_return_type_declaration/bad/OrderService.php
new file mode 100644
index 0000000..244b22a
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_return_type_declaration/bad/OrderService.php
@@ -0,0 +1,86 @@
+<?php
+
+namespace App\Service;
+
+use App\Entity\Order;
+use App\Entity\LineItem;
+use App\Exception\OrderNotFoundException;
+
+class OrderService
+{
+    public function __construct(
+        private $orders,
+        private $inventory,
+        private $payments
+    ) {
+    }
+
+    // No return type declared — caller cannot know if null is possible
+    public function findById(int $id)
+    {
+        return $this->orders->findById($id);
+    }
+
+    // No return type — is this an Order? array? null?
+    public function createFromCart(int $customerId, array $cartItems)
+    {
+        $order = new Order(customerId: $customerId, status: 'pending');
+
+        foreach ($cartItems as $item) {
+            $order->addLineItem(new LineItem(
+                productId: $item['product_id'],
+                quantity: $item['quantity'],
+                unitPrice: $item['unit_price']
+            ));
+        }
+
+        $this->orders->save($order);
+
+        return $order;
+    }
+
+    // No return type — returns bool but also throws
+    public function cancel(int $orderId)
+    {
+        $order = $this->orders->findById($orderId);
+
+        if ($order === null) {
+            throw new OrderNotFoundException("Order {$orderId} not found");
+        }
+
+        $order->setStatus('cancelled');
+        $this->orders->save($order);
+
+        return true;
+    }
+
+    // No return type — could be float, int, or null
+    public function getTotalForCustomer(int $customerId)
+    {
+        $orders = $this->orders->findByCustomer($customerId, status: 'completed');
+
+        return array_reduce($orders, fn($carry, $o) => $carry + $o->getTotal(), 0.0);
+    }
+
+    // No return type — could be string or throw
+    public function getStatusLabel(int $orderId)
+    {
+        $order = $this->orders->findById($orderId);
+
+        if ($order === null) {
+            throw new OrderNotFoundException("Order {$orderId} not found");
+        }
+
+        return match ($order->getStatus()) {
+            'pending'   => 'Awaiting Confirmation',
+            'confirmed' => 'Confirmed',
+            default     => 'Unknown',
+        };
+    }
+
+    // No return type — caller doesn't know it returns array
+    public function listByStatus(int $status, int $limit = 20)
+    {
+        return $this->orders->findByStatus($status, $limit);
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/uses_return_type_declaration/good/OrderService.php b/priv/combined_metrics/samples/type_and_value/uses_return_type_declaration/good/OrderService.php
new file mode 100644
index 0000000..c1a515f
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_return_type_declaration/good/OrderService.php
@@ -0,0 +1,91 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Service;
+
+use App\Entity\Order;
+use App\Entity\LineItem;
+use App\Exception\OrderNotFoundException;
+use App\Exception\InvalidOrderStateException;
+
+class OrderService
+{
+    public function __construct(
+        private OrderRepository $orders,
+        private InventoryService $inventory,
+        private PaymentService $payments
+    ) {
+    }
+
+    public function findById(int $id): ?Order
+    {
+        return $this->orders->findById($id);
+    }
+
+    public function createFromCart(int $customerId, array $cartItems): Order
+    {
+        $order = new Order(customerId: $customerId, status: 'pending');
+
+        foreach ($cartItems as $item) {
+            $order->addLineItem(new LineItem(
+                productId: $item['product_id'],
+                quantity: $item['quantity'],
+                unitPrice: $item['unit_price']
+            ));
+        }
+
+        $this->orders->save($order);
+
+        return $order;
+    }
+
+    public function cancel(int $orderId): bool
+    {
+        $order = $this->orders->findById($orderId);
+
+        if ($order === null) {
+            throw new OrderNotFoundException("Order {$orderId} not found");
+        }
+
+        if (!in_array($order->getStatus(), ['pending', 'confirmed'], true)) {
+            throw new InvalidOrderStateException("Cannot cancel order in state: {$order->getStatus()}");
+        }
+
+        $order->setStatus('cancelled');
+        $this->orders->save($order);
+        $this->inventory->releaseReservations($orderId);
+
+        return true;
+    }
+
+    public function getTotalForCustomer(int $customerId): float
+    {
+        $orders = $this->orders->findByCustomer($customerId, status: 'completed');
+
+        return array_reduce($orders, fn(float $carry, Order $o) => $carry + $o->getTotal(), 0.0);
+    }
+
+    public function getStatusLabel(int $orderId): string
+    {
+        $order = $this->orders->findById($orderId);
+
+        if ($order === null) {
+            throw new OrderNotFoundException("Order {$orderId} not found");
+        }
+
+        return match ($order->getStatus()) {
+            'pending'   => 'Awaiting Confirmation',
+            'confirmed' => 'Confirmed',
+            'shipped'   => 'Shipped',
+            'completed' => 'Delivered',
+            'cancelled' => 'Cancelled',
+            default     => 'Unknown',
+        };
+    }
+
+    public function listByStatus(string $status, int $limit = 20): array
+    {
+        return $this->orders->findByStatus($status, $limit);
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/uses_safe_call_over_null_check/bad/OrderManager.kt b/priv/combined_metrics/samples/type_and_value/uses_safe_call_over_null_check/bad/OrderManager.kt
new file mode 100644
index 0000000..9ab9969
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_safe_call_over_null_check/bad/OrderManager.kt
@@ -0,0 +1,61 @@
+package com.example.orders
+
+data class Address(val street: String, val city: String, val postalCode: String)
+data class Customer(val id: String, val name: String, val address: Address?)
+data class Order(val id: String, val customer: Customer?, val notes: String?)
+
+class OrderManager(private val repository: OrderRepository) {
+
+    fun getShippingCity(orderId: String): String? {
+        // Verbose nested null checks instead of safe call chain
+        val order = repository.findById(orderId)
+        if (order != null) {
+            val customer = order.customer
+            if (customer != null) {
+                val address = customer.address
+                if (address != null) {
+                    return address.city
+                }
+            }
+        }
+        return null
+    }
+
+    fun getOrderNoteLength(orderId: String): Int {
+        val order = repository.findById(orderId)
+        if (order != null) {
+            val notes = order.notes
+            if (notes != null) {
+                return notes.length
+            }
+        }
+        return 0
+    }
+
+    fun formatShippingLabel(orderId: String): String? {
+        val order = repository.findById(orderId)
+        if (order != null) {
+            val customer = order.customer
+            if (customer != null) {
+                val address = customer.address
+                if (address != null) {
+                    return "${customer.name}, ${address.city} ${address.postalCode}"
+                }
+            }
+        }
+        return null
+    }
+
+    fun notifyCustomer(orderId: String, message: String): Boolean {
+        val order = repository.findById(orderId)
+        if (order != null) {
+            val customer = order.customer
+            if (customer != null) {
+                return notificationService.send(customer.id, message)
+            }
+        }
+        return false
+    }
+
+    private val notificationService = NotificationService()
+}
diff --git a/priv/combined_metrics/samples/type_and_value/uses_safe_call_over_null_check/good/OrderManager.kt b/priv/combined_metrics/samples/type_and_value/uses_safe_call_over_null_check/good/OrderManager.kt
new file mode 100644
index 0000000..85b47a7
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_safe_call_over_null_check/good/OrderManager.kt
@@ -0,0 +1,40 @@
+package com.example.orders
+
+data class Address(val street: String, val city: String, val postalCode: String)
+data class Customer(val id: String, val name: String, val address: Address?)
+data class Order(val id: String, val customer: Customer?, val notes: String?)
+
+class OrderManager(private val repository: OrderRepository) {
+
+    fun getShippingCity(orderId: String): String? {
+        // Safe call chain — concise and null-safe without nested if checks
+        return repository.findById(orderId)?.customer?.address?.city
+    }
+
+    fun getOrderNoteLength(orderId: String): Int {
+        // Safe call with Elvis for default
+        return repository.findById(orderId)?.notes?.length ?: 0
+    }
+
+    fun formatShippingLabel(orderId: String): String? {
+        val order = repository.findById(orderId) ?: return null
+        // Safe call chain instead of repeated null checks
+        val city = order.customer?.address?.city ?: return null
+        val postalCode = order.customer?.address?.postalCode ?: return null
+        val customerName = order.customer?.name ?: "Unknown"
+        return "$customerName, $city $postalCode"
+    }
+
+    fun notifyCustomer(orderId: String, message: String): Boolean {
+        // Safe call — no NPE risk, cleanly returns null/false if absent
+        val customerId = repository.findById(orderId)?.customer?.id ?: return false
+        return notificationService.send(customerId, message)
+    }
+
+    fun upperCaseNotes(orderId: String): String? {
+        // Chained safe calls — readable transformation pipeline
+        return repository.findById(orderId)?.notes?.uppercase()?.trim()
+    }
+
+    private val notificationService = NotificationService()
+}
diff --git a/priv/combined_metrics/samples/type_and_value/uses_short_type_keywords/bad/ProductCatalog.php b/priv/combined_metrics/samples/type_and_value/uses_short_type_keywords/bad/ProductCatalog.php
new file mode 100644
index 0000000..c2da625
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_short_type_keywords/bad/ProductCatalog.php
@@ -0,0 +1,71 @@
+<?php
+
+namespace App\Catalog;
+
+class ProductCatalog
+{
+    private array $products = [];
+
+    // PSR-12 requires `int`, `bool`, `float` — not `integer`, `boolean`, `double`
+    public function addProduct(
+        string $sku,
+        string $name,
+        double $price,
+        integer $stockQuantity,
+        boolean $isActive = true
+    ): void {
+        $this->products[$sku] = [
+            'sku'    => $sku,
+            'name'   => $name,
+            'price'  => $price,
+            'stock'  => $stockQuantity,
+            'active' => $isActive,
+        ];
+    }
+
+    public function isInStock(string $sku): boolean
+    {
+        return isset($this->products[$sku]) && $this->products[$sku]['stock'] > 0;
+    }
+
+    public function getStockCount(string $sku): integer
+    {
+        return $this->products[$sku]['stock'] ?? 0;
+    }
+
+    public function getPrice(string $sku): double
+    {
+        if (!isset($this->products[$sku])) {
+            throw new \InvalidArgumentException("Unknown SKU: {$sku}");
+        }
+
+        return $this->products[$sku]['price'];
+    }
+
+    public function search(string $query, boolean $activeOnly = true): array
+    {
+        return array_filter($this->products, function (array $product) use ($query, $activeOnly): boolean {
+            if ($activeOnly && !$product['active']) {
+                return false;
+            }
+
+            return str_contains(strtolower($product['name']), strtolower($query));
+        });
+    }
+
+    public function countActive(): integer
+    {
+        return count(array_filter($this->products, fn(array $p): boolean => $p['active']));
+    }
+
+    public function deactivate(string $sku): boolean
+    {
+        if (!isset($this->products[$sku])) {
+            return false;
+        }
+
+        $this->products[$sku]['active'] = false;
+
+        return true;
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/uses_short_type_keywords/good/ProductCatalog.php b/priv/combined_metrics/samples/type_and_value/uses_short_type_keywords/good/ProductCatalog.php
new file mode 100644
index 0000000..008a458
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_short_type_keywords/good/ProductCatalog.php
@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Catalog;
+
+class ProductCatalog
+{
+    private array $products = [];
+
+    public function addProduct(
+        string $sku,
+        string $name,
+        float $price,
+        int $stockQuantity,
+        bool $isActive = true
+    ): void {
+        $this->products[$sku] = [
+            'sku'           => $sku,
+            'name'          => $name,
+            'price'         => $price,
+            'stock'         => $stockQuantity,
+            'active'        => $isActive,
+        ];
+    }
+
+    public function isInStock(string $sku): bool
+    {
+        return isset($this->products[$sku]) && $this->products[$sku]['stock'] > 0;
+    }
+
+    public function getStockCount(string $sku): int
+    {
+        return $this->products[$sku]['stock'] ?? 0;
+    }
+
+    public function getPrice(string $sku): float
+    {
+        if (!isset($this->products[$sku])) {
+            throw new \InvalidArgumentException("Unknown SKU: {$sku}");
+        }
+
+        return $this->products[$sku]['price'];
+    }
+
+    public function search(string $query, bool $activeOnly = true): array
+    {
+        return array_filter($this->products, function (array $product) use ($query, $activeOnly): bool {
+            if ($activeOnly && !$product['active']) {
+                return false;
+            }
+
+            return str_contains(strtolower($product['name']), strtolower($query));
+        });
+    }
+
+    public function countActive(): int
+    {
+        return count(array_filter($this->products, fn(array $p): bool => $p['active']));
+    }
+
+    public function deactivate(string $sku): bool
+    {
+        if (!isset($this->products[$sku])) {
+            return false;
+        }
+
+        $this->products[$sku]['active'] = false;
+
+        return true;
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/uses_type_declarations_on_parameters/bad/UserRepository.php b/priv/combined_metrics/samples/type_and_value/uses_type_declarations_on_parameters/bad/UserRepository.php
new file mode 100644
index 0000000..2f0f7f7
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_type_declarations_on_parameters/bad/UserRepository.php
@@ -0,0 +1,108 @@
+<?php
+
+namespace App\Repository;
+
+use App\Entity\User;
+use PDO;
+
+class UserRepository
+{
+    public function __construct($connection)  // no type hint
+    {
+        $this->connection = $connection;
+    }
+
+    // No type hints on parameters
+    public function findById($id)
+    {
+        $stmt = $this->connection->prepare(
+            'SELECT * FROM users WHERE id = :id AND deleted_at IS NULL'
+        );
+        $stmt->execute(['id' => $id]);
+        $row = $stmt->fetch(PDO::FETCH_ASSOC);
+
+        return $row ? $this->hydrate($row) : null;
+    }
+
+    // No type hints — $email could be anything
+    public function findByEmail($email)
+    {
+        $stmt = $this->connection->prepare(
+            'SELECT * FROM users WHERE email = :email AND deleted_at IS NULL'
+        );
+        $stmt->execute(['email' => strtolower($email)]);
+        $row = $stmt->fetch(PDO::FETCH_ASSOC);
+
+        return $row ? $this->hydrate($row) : null;
+    }
+
+    // No type hints — $role, $limit, $offset unconstrained
+    public function findActiveByRole($role, $limit = 50, $offset = 0)
+    {
+        $stmt = $this->connection->prepare(
+            'SELECT * FROM users WHERE role = :role AND status = :status LIMIT :limit OFFSET :offset'
+        );
+        $stmt->execute(['role' => $role, 'status' => 'active', 'limit' => $limit, 'offset' => $offset]);
+
+        return array_map([$this, 'hydrate'], $stmt->fetchAll(PDO::FETCH_ASSOC));
+    }
+
+    // No type hint on $user
+    public function save($user)
+    {
+        if ($user->getId() === null) {
+            $this->insert($user);
+        } else {
+            $this->update($user);
+        }
+    }
+
+    // No type hints on $id or $deletedAt
+    public function softDelete($id, $deletedAt)
+    {
+        $stmt = $this->connection->prepare(
+            'UPDATE users SET deleted_at = :deleted_at WHERE id = :id'
+        );
+        $stmt->execute(['deleted_at' => $deletedAt->format('Y-m-d H:i:s'), 'id' => $id]);
+
+        return $stmt->rowCount() > 0;
+    }
+
+    private function hydrate($row)
+    {
+        return new User(
+            id: (int) $row['id'],
+            email: $row['email'],
+            name: $row['name'],
+            role: $row['role'],
+            status: $row['status']
+        );
+    }
+
+    private function insert($user)
+    {
+        $stmt = $this->connection->prepare(
+            'INSERT INTO users (email, name, role, status, created_at) VALUES (:email, :name, :role, :status, NOW())'
+        );
+        $stmt->execute([
+            'email' => $user->getEmail(),
+            'name' => $user->getName(),
+            'role' => $user->getRole(),
+            'status' => $user->getStatus(),
+        ]);
+    }
+
+    private function update($user)
+    {
+        $stmt = $this->connection->prepare(
+            'UPDATE users SET email = :email, name = :name, role = :role, status = :status WHERE id = :id'
+        );
+        $stmt->execute([
+            'email' => $user->getEmail(),
+            'name' => $user->getName(),
+            'role' => $user->getRole(),
+            'status' => $user->getStatus(),
+            'id' => $user->getId(),
+        ]);
+    }
+}
diff --git a/priv/combined_metrics/samples/type_and_value/uses_type_declarations_on_parameters/good/UserRepository.php b/priv/combined_metrics/samples/type_and_value/uses_type_declarations_on_parameters/good/UserRepository.php
new file mode 100644
index 0000000..eeb26a5
--- /dev/null
+++ b/priv/combined_metrics/samples/type_and_value/uses_type_declarations_on_parameters/good/UserRepository.php
@@ -0,0 +1,106 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Repository;
+
+use App\Entity\User;
+use App\Exception\UserNotFoundException;
+use DateTimeImmutable;
+use PDO;
+
+class UserRepository
+{
+    public function __construct(private PDO $connection)
+    {
+    }
+
+    public function findById(int $id): ?User
+    {
+        $stmt = $this->connection->prepare(
+            'SELECT * FROM users WHERE id = :id AND deleted_at IS NULL'
+        );
+        $stmt->execute(['id' => $id]);
+        $row = $stmt->fetch(PDO::FETCH_ASSOC);
+
+        return $row ? $this->hydrate($row) : null;
+    }
+
+    public function findByEmail(string $email): ?User
+    {
+        $stmt = $this->connection->prepare(
+            'SELECT * FROM users WHERE email = :email AND deleted_at IS NULL'
+        );
+        $stmt->execute(['email' => strtolower($email)]);
+        $row = $stmt->fetch(PDO::FETCH_ASSOC);
+
+        return $row ? $this->hydrate($row) : null;
+    }
+
+    public function findActiveByRole(string $role, int $limit = 50, int $offset = 0): array
+    {
+        $stmt = $this->connection->prepare(
+            'SELECT * FROM users WHERE role = :role AND status = :status LIMIT :limit OFFSET :offset'
+        );
+        $stmt->execute(['role' => $role, 'status' => 'active', 'limit' => $limit, 'offset' => $offset]);
+
+        return array_map([$this, 'hydrate'], $stmt->fetchAll(PDO::FETCH_ASSOC));
+    }
+
+    public function save(User $user): void
+    {
+        if ($user->getId() === null) {
+            $this->insert($user);
+        } else {
+            $this->update($user);
+        }
+    }
+
+    public function softDelete(int $id, DateTimeImmutable $deletedAt): bool
+    {
+        $stmt = $this->connection->prepare(
+            'UPDATE users SET deleted_at = :deleted_at WHERE id = :id'
+        );
+        $stmt->execute(['deleted_at' => $deletedAt->format('Y-m-d H:i:s'), 'id' => $id]);
+
+        return $stmt->rowCount() > 0;
+    }
+
+    private function hydrate(array $row): User
+    {
+        return new User(
+            id: (int) $row['id'],
+            email: $row['email'],
+            name: $row['name'],
+            role: $row['role'],
+            status: $row['status']
+        );
+    }
+
+    private function insert(User $user): void
+    {
+        $stmt = $this->connection->prepare(
+            'INSERT INTO users (email, name, role, status, created_at) VALUES (:email, :name, :role, :status, NOW())'
+        );
+        $stmt->execute([
+            'email' => $user->getEmail(),
+            'name' => $user->getName(),
+            'role' => $user->getRole(),
+            'status' => $user->getStatus(),
+        ]);
+    }
+
+    private function update(User $user): void
+    {
+        $stmt = $this->connection->prepare(
+            'UPDATE users SET email = :email, name = :name, role = :role, status = :status WHERE id = :id'
+        );
+        $stmt->execute([
+            'email' => $user->getEmail(),
+            'name' => $user->getName(),
+            'role' => $user->getRole(),
+            'status' => $user->getStatus(),
+            'id' => $user->getId(),
+        ]);
+    }
+}
diff --git a/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/bad/users.ex b/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/bad/users.ex
new file mode 100644
index 0000000..d2f3fca
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/bad/users.ex
@@ -0,0 +1,75 @@
+defmodule UserManager do
+  def process_user(user) do
+    active = user.status == :active
+    verified = user.email_confirmed_at != nil
+    admin = user.role == :admin
+    loaded = user.profile != nil
+    banned = user.banned_at != nil
+
+    if active && verified && !banned do
+      permissions = build_permissions(admin, loaded)
+      {:ok, Map.put(user, :permissions, permissions)}
+    else
+      {:error, :access_denied}
+    end
+  end
+
+  def build_permissions(admin, loaded) do
+    base = [:read]
+    with_write = if admin, do: [:write | base], else: base
+    with_profile = if loaded, do: [:edit_profile | with_write], else: with_write
+    with_profile
+  end
+
+  def can_access_dashboard?(user) do
+    active = user.status == :active
+    verified = user.email_confirmed_at != nil
+    premium = user.plan == :premium
+    active && verified && premium
+  end
+
+  def filter_active(users) do
+    Enum.filter(users, fn user ->
+      active = user.status == :active
+      deleted = user.deleted_at != nil
+      active && !deleted
+    end)
+  end
+
+  def send_notification(user, message) do
+    subscribed = user.notifications_enabled
+    verified = user.email_confirmed_at != nil
+    reachable = user.email != nil
+
+    if subscribed && verified && reachable do
+      Mailer.send(user.email, message)
+    else
+      {:error, :not_reachable}
+    end
+  end
+
+  def update_status(user, new_status) do
+    valid = new_status in [:active, :inactive, :suspended]
+    changed = user.status != new_status
+    locked = user.locked_at != nil
+
+    if valid && changed && !locked do
+      {:ok, Map.put(user, :status, new_status)}
+    else
+      {:error, :invalid_transition}
+    end
+  end
+
+  def summarize(user) do
+    active = user.status == :active
+    admin = user.role == :admin
+    verified = user.email_confirmed_at != nil
+
+    %{
+      id: user.id,
+      active: active,
+      admin: admin,
+      verified: verified
+    }
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/bad/users.js b/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/bad/users.js
new file mode 100644
index 0000000..a744833
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/bad/users.js
@@ -0,0 +1,69 @@
+class UserManager {
+  processUser(user) {
+    const active = user.status === 'active';
+    const verified = user.emailConfirmedAt !== null;
+    const admin = user.role === 'admin';
+    const loaded = user.profile !== null;
+    const banned = user.bannedAt !== null;
+
+    if (active && verified && !banned) {
+      const permissions = this.buildPermissions(admin, loaded);
+      return { ...user, permissions };
+    }
+    return { error: 'access_denied' };
+  }
+
+  buildPermissions(admin, loaded) {
+    const base = ['read'];
+    const withWrite = admin ? ['write', ...base] : base;
+    const withProfile = loaded ? ['edit_profile', ...withWrite] : withWrite;
+    return withProfile;
+  }
+
+  canAccessDashboard(user) {
+    const active = user.status === 'active';
+    const verified = user.emailConfirmedAt !== null;
+    const premium = user.plan === 'premium';
+    return active && verified && premium;
+  }
+
+  filterActive(users) {
+    return users.filter(user => {
+      const active = user.status === 'active';
+      const deleted = user.deletedAt !== null;
+      return active && !deleted;
+    });
+  }
+
+  sendNotification(user, message) {
+    const subscribed = user.notificationsEnabled;
+    const verified = user.emailConfirmedAt !== null;
+    const reachable = user.email !== null;
+
+    if (subscribed && verified && reachable) {
+      mailer.send(user.email, message);
+      return true;
+    }
+    return false;
+  }
+
+  updateStatus(user, newStatus) {
+    const valid = ['active', 'inactive', 'suspended'].includes(newStatus);
+    const changed = user.status !== newStatus;
+    const locked = user.lockedAt !== null;
+
+    if (valid && changed && !locked) {
+      return { ...user, status: newStatus };
+    }
+    return null;
+  }
+
+  summarize(user) {
+    const active = user.status === 'active';
+    const admin = user.role === 'admin';
+    const verified = user.emailConfirmedAt !== null;
+    return { id: user.id, active, admin, verified };
+  }
+}
+
+module.exports = UserManager;
diff --git a/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/bad/users.rb b/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/bad/users.rb
new file mode 100644
index 0000000..dbf88cc
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/bad/users.rb
@@ -0,0 +1,69 @@
+class UserManager
+  def process_user(user)
+    active = user[:status] == :active
+    verified = user[:email_confirmed_at] != nil
+    admin = user[:role] == :admin
+    loaded = user[:profile] != nil
+    banned = user[:banned_at] != nil
+
+    if active && verified && !banned
+      permissions = build_permissions(admin, loaded)
+      user.merge(permissions: permissions)
+    else
+      { error: :access_denied }
+    end
+  end
+
+  def build_permissions(admin, loaded)
+    base = [:read]
+    with_write = admin ? [:write] + base : base
+    with_profile = loaded ? [:edit_profile] + with_write : with_write
+    with_profile
+  end
+
+  def can_access_dashboard?(user)
+    active = user[:status] == :active
+    verified = user[:email_confirmed_at] != nil
+    premium = user[:plan] == :premium
+    active && verified && premium
+  end
+
+  def filter_active(users)
+    users.select do |user|
+      active = user[:status] == :active
+      deleted = user[:deleted_at] != nil
+      active && !deleted
+    end
+  end
+
+  def send_notification(user, message)
+    subscribed = user[:notifications_enabled]
+    verified = user[:email_confirmed_at] != nil
+    reachable = user[:email] != nil
+
+    if subscribed && verified && reachable
+      Mailer.send(user[:email], message)
+    else
+      { error: :not_reachable }
+    end
+  end
+
+  def update_status(user, new_status)
+    valid = [:active, :inactive, :suspended].include?(new_status)
+    changed = user[:status] != new_status
+    locked = user[:locked_at] != nil
+
+    if valid && changed && !locked
+      user.merge(status: new_status)
+    else
+      { error: :invalid_transition }
+    end
+  end
+
+  def summarize(user)
+    active = user[:status] == :active
+    admin = user[:role] == :admin
+    verified = user[:email_confirmed_at] != nil
+    { id: user[:id], active: active, admin: admin, verified: verified }
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/config.yml b/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/config.yml
new file mode 100644
index 0000000..da65fa6
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/config.yml
@@ -0,0 +1 @@
+doc: "Boolean variables should be prefixed with `is_`, `has_`, or `can_`."
diff --git a/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/good/users.ex b/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/good/users.ex
new file mode 100644
index 0000000..621f7f7
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/good/users.ex
@@ -0,0 +1,75 @@
+defmodule UserManager do
+  def process_user(user) do
+    is_active = user.status == :active
+    is_verified = user.email_confirmed_at != nil
+    is_admin = user.role == :admin
+    has_profile = user.profile != nil
+    is_banned = user.banned_at != nil
+
+    if is_active && is_verified && !is_banned do
+      permissions = build_permissions(is_admin, has_profile)
+      {:ok, Map.put(user, :permissions, permissions)}
+    else
+      {:error, :access_denied}
+    end
+  end
+
+  def build_permissions(is_admin, has_profile) do
+    base = [:read]
+    with_write = if is_admin, do: [:write | base], else: base
+    with_profile = if has_profile, do: [:edit_profile | with_write], else: with_write
+    with_profile
+  end
+
+  def can_access_dashboard?(user) do
+    is_active = user.status == :active
+    is_verified = user.email_confirmed_at != nil
+    is_premium = user.plan == :premium
+    is_active && is_verified && is_premium
+  end
+
+  def filter_active(users) do
+    Enum.filter(users, fn user ->
+      is_active = user.status == :active
+      is_deleted = user.deleted_at != nil
+      is_active && !is_deleted
+    end)
+  end
+
+  def send_notification(user, message) do
+    has_notifications_enabled = user.notifications_enabled
+    is_verified = user.email_confirmed_at != nil
+    has_email = user.email != nil
+
+    if has_notifications_enabled && is_verified && has_email do
+      Mailer.send(user.email, message)
+    else
+      {:error, :not_reachable}
+    end
+  end
+
+  def update_status(user, new_status) do
+    is_valid_status = new_status in [:active, :inactive, :suspended]
+    has_status_changed = user.status != new_status
+    is_locked = user.locked_at != nil
+
+    if is_valid_status && has_status_changed && !is_locked do
+      {:ok, Map.put(user, :status, new_status)}
+    else
+      {:error, :invalid_transition}
+    end
+  end
+
+  def summarize(user) do
+    is_active = user.status == :active
+    is_admin = user.role == :admin
+    is_verified = user.email_confirmed_at != nil
+
+    %{
+      id: user.id,
+      is_active: is_active,
+      is_admin: is_admin,
+      is_verified: is_verified
+    }
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/good/users.js b/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/good/users.js
new file mode 100644
index 0000000..dbbd96c
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/good/users.js
@@ -0,0 +1,69 @@
+class UserManager {
+  processUser(user) {
+    const isActive = user.status === 'active';
+    const isVerified = user.emailConfirmedAt !== null;
+    const isAdmin = user.role === 'admin';
+    const hasProfile = user.profile !== null;
+    const isBanned = user.bannedAt !== null;
+
+    if (isActive && isVerified && !isBanned) {
+      const permissions = this.buildPermissions(isAdmin, hasProfile);
+      return { ...user, permissions };
+    }
+    return { error: 'access_denied' };
+  }
+
+  buildPermissions(isAdmin, hasProfile) {
+    const base = ['read'];
+    const withWrite = isAdmin ? ['write', ...base] : base;
+    const withProfile = hasProfile ? ['edit_profile', ...withWrite] : withWrite;
+    return withProfile;
+  }
+
+  canAccessDashboard(user) {
+    const isActive = user.status === 'active';
+    const isVerified = user.emailConfirmedAt !== null;
+    const isPremium = user.plan === 'premium';
+    return isActive && isVerified && isPremium;
+  }
+
+  filterActive(users) {
+    return users.filter(user => {
+      const isActive = user.status === 'active';
+      const isDeleted = user.deletedAt !== null;
+      return isActive && !isDeleted;
+    });
+  }
+
+  sendNotification(user, message) {
+    const hasNotificationsEnabled = user.notificationsEnabled;
+    const isVerified = user.emailConfirmedAt !== null;
+    const hasEmail = user.email !== null;
+
+    if (hasNotificationsEnabled && isVerified && hasEmail) {
+      mailer.send(user.email, message);
+      return true;
+    }
+    return false;
+  }
+
+  updateStatus(user, newStatus) {
+    const isValidStatus = ['active', 'inactive', 'suspended'].includes(newStatus);
+    const hasStatusChanged = user.status !== newStatus;
+    const isLocked = user.lockedAt !== null;
+
+    if (isValidStatus && hasStatusChanged && !isLocked) {
+      return { ...user, status: newStatus };
+    }
+    return null;
+  }
+
+  summarize(user) {
+    const isActive = user.status === 'active';
+    const isAdmin = user.role === 'admin';
+    const isVerified = user.emailConfirmedAt !== null;
+    return { id: user.id, isActive, isAdmin, isVerified };
+  }
+}
+
+module.exports = UserManager;
diff --git a/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/good/users.rb b/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/good/users.rb
new file mode 100644
index 0000000..d17bb0c
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/boolean_has_is_has_prefix/good/users.rb
@@ -0,0 +1,69 @@
+class UserManager
+  def process_user(user)
+    is_active = user[:status] == :active
+    is_verified = user[:email_confirmed_at] != nil
+    is_admin = user[:role] == :admin
+    has_profile = user[:profile] != nil
+    is_banned = user[:banned_at] != nil
+
+    if is_active && is_verified && !is_banned
+      permissions = build_permissions(is_admin, has_profile)
+      user.merge(permissions: permissions)
+    else
+      { error: :access_denied }
+    end
+  end
+
+  def build_permissions(is_admin, has_profile)
+    base = [:read]
+    with_write = is_admin ? [:write] + base : base
+    with_profile = has_profile ? [:edit_profile] + with_write : with_write
+    with_profile
+  end
+
+  def can_access_dashboard?(user)
+    is_active = user[:status] == :active
+    is_verified = user[:email_confirmed_at] != nil
+    is_premium = user[:plan] == :premium
+    is_active && is_verified && is_premium
+  end
+
+  def filter_active(users)
+    users.select do |user|
+      is_active = user[:status] == :active
+      is_deleted = user[:deleted_at] != nil
+      is_active && !is_deleted
+    end
+  end
+
+  def send_notification(user, message)
+    has_notifications_enabled = user[:notifications_enabled]
+    is_verified = user[:email_confirmed_at] != nil
+    has_email = user[:email] != nil
+
+    if has_notifications_enabled && is_verified && has_email
+      Mailer.send(user[:email], message)
+    else
+      { error: :not_reachable }
+    end
+  end
+
+  def update_status(user, new_status)
+    is_valid_status = [:active, :inactive, :suspended].include?(new_status)
+    has_status_changed = user[:status] != new_status
+    is_locked = user[:locked_at] != nil
+
+    if is_valid_status && has_status_changed && !is_locked
+      user.merge(status: new_status)
+    else
+      { error: :invalid_transition }
+    end
+  end
+
+  def summarize(user)
+    is_active = user[:status] == :active
+    is_admin = user[:role] == :admin
+    is_verified = user[:email_confirmed_at] != nil
+    { id: user[:id], is_active: is_active, is_admin: is_admin, is_verified: is_verified }
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/bad/catalog.ex b/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/bad/catalog.ex
new file mode 100644
index 0000000..0c9e37a
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/bad/catalog.ex
@@ -0,0 +1,68 @@
+defmodule Catalog do
+  def load_catalog do
+    product = fetch_products()
+    category = fetch_categories()
+    tag = fetch_tags()
+
+    %{products: product, categories: category, tags: tag}
+  end
+
+  def filter_by_category(product, category_id) do
+    Enum.filter(product, fn item ->
+      item.category_id == category_id
+    end)
+  end
+
+  def apply_tags(product, tag) do
+    Enum.map(product, fn item ->
+      matching_tag = Enum.filter(tag, fn t -> t.product_id == item.id end)
+      Map.put(item, :tags, matching_tag)
+    end)
+  end
+
+  def group_by_category(product, category) do
+    category_map = Map.new(category, fn c -> {c.id, c} end)
+
+    Enum.group_by(product, fn item ->
+      cat = Map.get(category_map, item.category_id)
+      if cat, do: cat.name, else: :uncategorized
+    end)
+  end
+
+  def search(product, query) do
+    normalized = String.downcase(query)
+    Enum.filter(product, fn item ->
+      String.contains?(String.downcase(item.name), normalized) ||
+        String.contains?(String.downcase(item.description), normalized)
+    end)
+  end
+
+  def price_range(product, min, max) do
+    Enum.filter(product, fn item ->
+      item.price >= min && item.price <= max
+    end)
+  end
+
+  def enrich(product, tag, category) do
+    cat_map = Map.new(category, &{&1.id, &1})
+    tag_map = Enum.group_by(tag, & &1.product_id)
+
+    Enum.map(product, fn item ->
+      cat = Map.get(cat_map, item.category_id, %{})
+      associated_tag = Map.get(tag_map, item.id, [])
+      item |> Map.put(:category, cat) |> Map.put(:tags, associated_tag)
+    end)
+  end
+
+  def summarize(product, category) do
+    %{
+      total_products: length(product),
+      total_categories: length(category),
+      avg_price: Enum.sum(Enum.map(product, & &1.price)) / max(length(product), 1)
+    }
+  end
+
+  defp fetch_products, do: []
+  defp fetch_categories, do: []
+  defp fetch_tags, do: []
+end
diff --git a/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/bad/catalog.js b/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/bad/catalog.js
new file mode 100644
index 0000000..5cda460
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/bad/catalog.js
@@ -0,0 +1,72 @@
+class Catalog {
+  loadCatalog() {
+    const product = this.fetchProducts();
+    const category = this.fetchCategories();
+    const tag = this.fetchTags();
+    return { products: product, categories: category, tags: tag };
+  }
+
+  filterByCategory(product, categoryId) {
+    return product.filter(item => item.categoryId === categoryId);
+  }
+
+  applyTags(product, tag) {
+    return product.map(item => {
+      const matchingTag = tag.filter(t => t.productId === item.id);
+      return { ...item, tags: matchingTag };
+    });
+  }
+
+  groupByCategory(product, category) {
+    const categoryMap = Object.fromEntries(category.map(c => [c.id, c]));
+    return product.reduce((acc, item) => {
+      const cat = categoryMap[item.categoryId];
+      const key = cat ? cat.name : 'uncategorized';
+      if (!acc[key]) acc[key] = [];
+      acc[key].push(item);
+      return acc;
+    }, {});
+  }
+
+  search(product, query) {
+    const normalized = query.toLowerCase();
+    return product.filter(item =>
+      item.name.toLowerCase().includes(normalized) ||
+      item.description.toLowerCase().includes(normalized)
+    );
+  }
+
+  priceRange(product, min, max) {
+    return product.filter(item => item.price >= min && item.price <= max);
+  }
+
+  enrich(product, tag, category) {
+    const catMap = Object.fromEntries(category.map(c => [c.id, c]));
+    const tagMap = tag.reduce((acc, t) => {
+      if (!acc[t.productId]) acc[t.productId] = [];
+      acc[t.productId].push(t);
+      return acc;
+    }, {});
+
+    return product.map(item => ({
+      ...item,
+      category: catMap[item.categoryId] || {},
+      tags: tagMap[item.id] || []
+    }));
+  }
+
+  summarize(product, category) {
+    const total = product.reduce((sum, item) => sum + item.price, 0);
+    return {
+      totalProducts: product.length,
+      totalCategories: category.length,
+      avgPrice: product.length ? total / product.length : 0
+    };
+  }
+
+  fetchProducts() { return []; }
+  fetchCategories() { return []; }
+  fetchTags() { return []; }
+}
+
+module.exports = Catalog;
diff --git a/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/bad/catalog.rb b/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/bad/catalog.rb
new file mode 100644
index 0000000..a0a073a
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/bad/catalog.rb
@@ -0,0 +1,65 @@
+class Catalog
+  def load_catalog
+    product = fetch_products
+    category = fetch_categories
+    tag = fetch_tags
+    { products: product, categories: category, tags: tag }
+  end
+
+  def filter_by_category(product, category_id)
+    product.select { |item| item[:category_id] == category_id }
+  end
+
+  def apply_tags(product, tag)
+    product.map do |item|
+      matching_tag = tag.select { |t| t[:product_id] == item[:id] }
+      item.merge(tags: matching_tag)
+    end
+  end
+
+  def group_by_category(product, category)
+    category_map = category.each_with_object({}) { |c, h| h[c[:id]] = c }
+    product.group_by do |item|
+      cat = category_map[item[:category_id]]
+      cat ? cat[:name] : :uncategorized
+    end
+  end
+
+  def search(product, query)
+    normalized = query.downcase
+    product.select do |item|
+      item[:name].downcase.include?(normalized) ||
+        item[:description].downcase.include?(normalized)
+    end
+  end
+
+  def price_range(product, min, max)
+    product.select { |item| item[:price] >= min && item[:price] <= max }
+  end
+
+  def enrich(product, tag, category)
+    cat_map = category.each_with_object({}) { |c, h| h[c[:id]] = c }
+    tag_map = tag.group_by { |t| t[:product_id] }
+
+    product.map do |item|
+      cat = cat_map[item[:category_id]] || {}
+      associated_tag = tag_map[item[:id]] || []
+      item.merge(category: cat, tags: associated_tag)
+    end
+  end
+
+  def summarize(product, category)
+    total = product.sum { |item| item[:price] }
+    {
+      total_products: product.length,
+      total_categories: category.length,
+      avg_price: product.empty? ? 0 : total / product.length
+    }
+  end
+
+  private
+
+  def fetch_products = []
+  def fetch_categories = []
+  def fetch_tags = []
+end
diff --git a/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/config.yml b/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/config.yml
new file mode 100644
index 0000000..2408ba5
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/config.yml
@@ -0,0 +1 @@
+doc: "Variables holding a collection should use a plural name."
diff --git a/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/good/catalog.ex b/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/good/catalog.ex
new file mode 100644
index 0000000..d4eee3b
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/good/catalog.ex
@@ -0,0 +1,68 @@
+defmodule Catalog do
+  def load_catalog do
+    products = fetch_products()
+    categories = fetch_categories()
+    tags = fetch_tags()
+
+    %{products: products, categories: categories, tags: tags}
+  end
+
+  def filter_by_category(products, category_id) do
+    Enum.filter(products, fn product ->
+      product.category_id == category_id
+    end)
+  end
+
+  def apply_tags(products, tags) do
+    Enum.map(products, fn product ->
+      matching_tags = Enum.filter(tags, fn tag -> tag.product_id == product.id end)
+      Map.put(product, :tags, matching_tags)
+    end)
+  end
+
+  def group_by_category(products, categories) do
+    category_map = Map.new(categories, fn category -> {category.id, category} end)
+
+    Enum.group_by(products, fn product ->
+      category = Map.get(category_map, product.category_id)
+      if category, do: category.name, else: :uncategorized
+    end)
+  end
+
+  def search(products, query) do
+    normalized = String.downcase(query)
+    Enum.filter(products, fn product ->
+      String.contains?(String.downcase(product.name), normalized) ||
+        String.contains?(String.downcase(product.description), normalized)
+    end)
+  end
+
+  def price_range(products, min, max) do
+    Enum.filter(products, fn product ->
+      product.price >= min && product.price <= max
+    end)
+  end
+
+  def enrich(products, tags, categories) do
+    category_map = Map.new(categories, &{&1.id, &1})
+    tags_by_product = Enum.group_by(tags, & &1.product_id)
+
+    Enum.map(products, fn product ->
+      category = Map.get(category_map, product.category_id, %{})
+      product_tags = Map.get(tags_by_product, product.id, [])
+      product |> Map.put(:category, category) |> Map.put(:tags, product_tags)
+    end)
+  end
+
+  def summarize(products, categories) do
+    %{
+      total_products: length(products),
+      total_categories: length(categories),
+      avg_price: Enum.sum(Enum.map(products, & &1.price)) / max(length(products), 1)
+    }
+  end
+
+  defp fetch_products, do: []
+  defp fetch_categories, do: []
+  defp fetch_tags, do: []
+end
diff --git a/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/good/catalog.js b/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/good/catalog.js
new file mode 100644
index 0000000..72f6761
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/good/catalog.js
@@ -0,0 +1,72 @@
+class Catalog {
+  loadCatalog() {
+    const products = this.fetchProducts();
+    const categories = this.fetchCategories();
+    const tags = this.fetchTags();
+    return { products, categories, tags };
+  }
+
+  filterByCategory(products, categoryId) {
+    return products.filter(product => product.categoryId === categoryId);
+  }
+
+  applyTags(products, tags) {
+    return products.map(product => {
+      const matchingTags = tags.filter(tag => tag.productId === product.id);
+      return { ...product, tags: matchingTags };
+    });
+  }
+
+  groupByCategory(products, categories) {
+    const categoryMap = Object.fromEntries(categories.map(category => [category.id, category]));
+    return products.reduce((grouped, product) => {
+      const category = categoryMap[product.categoryId];
+      const key = category ? category.name : 'uncategorized';
+      if (!grouped[key]) grouped[key] = [];
+      grouped[key].push(product);
+      return grouped;
+    }, {});
+  }
+
+  search(products, query) {
+    const normalized = query.toLowerCase();
+    return products.filter(product =>
+      product.name.toLowerCase().includes(normalized) ||
+      product.description.toLowerCase().includes(normalized)
+    );
+  }
+
+  priceRange(products, min, max) {
+    return products.filter(product => product.price >= min && product.price <= max);
+  }
+
+  enrich(products, tags, categories) {
+    const categoryMap = Object.fromEntries(categories.map(c => [c.id, c]));
+    const tagsByProduct = tags.reduce((acc, tag) => {
+      if (!acc[tag.productId]) acc[tag.productId] = [];
+      acc[tag.productId].push(tag);
+      return acc;
+    }, {});
+
+    return products.map(product => ({
+      ...product,
+      category: categoryMap[product.categoryId] || {},
+      tags: tagsByProduct[product.id] || []
+    }));
+  }
+
+  summarize(products, categories) {
+    const totalPrice = products.reduce((sum, product) => sum + product.price, 0);
+    return {
+      totalProducts: products.length,
+      totalCategories: categories.length,
+      avgPrice: products.length ? totalPrice / products.length : 0
+    };
+  }
+
+  fetchProducts() { return []; }
+  fetchCategories() { return []; }
+  fetchTags() { return []; }
+}
+
+module.exports = Catalog;
diff --git a/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/good/catalog.rb b/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/good/catalog.rb
new file mode 100644
index 0000000..14d038b
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/collection_name_is_plural/good/catalog.rb
@@ -0,0 +1,65 @@
+class Catalog
+  def load_catalog
+    products = fetch_products
+    categories = fetch_categories
+    tags = fetch_tags
+    { products: products, categories: categories, tags: tags }
+  end
+
+  def filter_by_category(products, category_id)
+    products.select { |product| product[:category_id] == category_id }
+  end
+
+  def apply_tags(products, tags)
+    products.map do |product|
+      matching_tags = tags.select { |tag| tag[:product_id] == product[:id] }
+      product.merge(tags: matching_tags)
+    end
+  end
+
+  def group_by_category(products, categories)
+    category_map = categories.each_with_object({}) { |category, map| map[category[:id]] = category }
+    products.group_by do |product|
+      category = category_map[product[:category_id]]
+      category ? category[:name] : :uncategorized
+    end
+  end
+
+  def search(products, query)
+    normalized = query.downcase
+    products.select do |product|
+      product[:name].downcase.include?(normalized) ||
+        product[:description].downcase.include?(normalized)
+    end
+  end
+
+  def price_range(products, min, max)
+    products.select { |product| product[:price] >= min && product[:price] <= max }
+  end
+
+  def enrich(products, tags, categories)
+    category_map = categories.each_with_object({}) { |category, map| map[category[:id]] = category }
+    tags_by_product = tags.group_by { |tag| tag[:product_id] }
+
+    products.map do |product|
+      category = category_map[product[:category_id]] || {}
+      product_tags = tags_by_product[product[:id]] || []
+      product.merge(category: category, tags: product_tags)
+    end
+  end
+
+  def summarize(products, categories)
+    total_price = products.sum { |product| product[:price] }
+    {
+      total_products: products.length,
+      total_categories: categories.length,
+      avg_price: products.empty? ? 0 : total_price / products.length
+    }
+  end
+
+  private
+
+  def fetch_products = []
+  def fetch_categories = []
+  def fetch_tags = []
+end
diff --git a/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/bad/matrix.ex b/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/bad/matrix.ex
new file mode 100644
index 0000000..3c5b864
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/bad/matrix.ex
@@ -0,0 +1,81 @@
+defmodule Matrix.Bad do
+  @moduledoc """
+  Matrix operations using verbose loop counter names.
+  BAD: numeric loop counters use long descriptive names instead of i, j, k.
+  """
+
+  @spec multiply(list(list(number())), list(list(number()))) :: list(list(number()))
+  def multiply(matrix_a, matrix_b) do
+    row_count = length(matrix_a)
+    col_count = length(hd(matrix_b))
+    inner_count = length(matrix_b)
+
+    for current_row_position <- 0..(row_count - 1) do
+      for current_col_position <- 0..(col_count - 1) do
+        Enum.reduce(0..(inner_count - 1), 0, fn element_index, acc ->
+          a_val = matrix_a |> Enum.at(current_row_position) |> Enum.at(element_index)
+          b_val = matrix_b |> Enum.at(element_index) |> Enum.at(current_col_position)
+          acc + a_val * b_val
+        end)
+      end
+    end
+  end
+
+  @spec transpose(list(list(number()))) :: list(list(number()))
+  def transpose(matrix) do
+    row_count = length(matrix)
+    col_count = length(hd(matrix))
+
+    for current_col_position <- 0..(col_count - 1) do
+      for current_row_position <- 0..(row_count - 1) do
+        matrix |> Enum.at(current_row_position) |> Enum.at(current_col_position)
+      end
+    end
+  end
+
+  @spec sum_diagonal(list(list(number()))) :: number()
+  def sum_diagonal(matrix) do
+    size = length(matrix)
+
+    Enum.reduce(0..(size - 1), 0, fn diagonal_element_index, acc ->
+      val = matrix |> Enum.at(diagonal_element_index) |> Enum.at(diagonal_element_index)
+      acc + val
+    end)
+  end
+
+  @spec fill(number(), number(), number()) :: list(list(number()))
+  def fill(rows, cols, value) do
+    for current_row_position <- 1..rows do
+      for current_col_position <- 1..cols do
+        current_row_position * current_col_position * value
+      end
+    end
+  end
+
+  @spec find_max_in_row(list(list(number()))) :: list(number())
+  def find_max_in_row(matrix) do
+    Enum.map(matrix, fn row ->
+      Enum.reduce(row, hd(row), fn element, current_max ->
+        if element > current_max, do: element, else: current_max
+      end)
+    end)
+  end
+
+  @spec rotate_90(list(list(number()))) :: list(list(number()))
+  def rotate_90(matrix) do
+    size = length(matrix)
+
+    for current_col_position <- 0..(size - 1) do
+      for current_row_position <- (size - 1)..0//-1 do
+        matrix |> Enum.at(current_row_position) |> Enum.at(current_col_position)
+      end
+    end
+  end
+
+  @spec flatten(list(list(number()))) :: list(number())
+  def flatten(matrix) do
+    Enum.reduce(matrix, [], fn row, acc ->
+      acc ++ row
+    end)
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/bad/matrix.js b/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/bad/matrix.js
new file mode 100644
index 0000000..f231371
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/bad/matrix.js
@@ -0,0 +1,92 @@
+// Matrix operations using verbose loop counter names.
+// BAD: numeric loop counters use long descriptive names instead of i, j, k.
+
+function multiply(matrixA, matrixB) {
+  const rowCount = matrixA.length;
+  const colCount = matrixB[0].length;
+  const innerCount = matrixB.length;
+  const result = [];
+
+  for (let currentRowPosition = 0; currentRowPosition < rowCount; currentRowPosition++) {
+    result[currentRowPosition] = [];
+    for (let currentColPosition = 0; currentColPosition < colCount; currentColPosition++) {
+      let sum = 0;
+      for (let elementIndex = 0; elementIndex < innerCount; elementIndex++) {
+        sum += matrixA[currentRowPosition][elementIndex] * matrixB[elementIndex][currentColPosition];
+      }
+      result[currentRowPosition][currentColPosition] = sum;
+    }
+  }
+
+  return result;
+}
+
+function transpose(matrix) {
+  const rowCount = matrix.length;
+  const colCount = matrix[0].length;
+  const result = [];
+
+  for (let currentColPosition = 0; currentColPosition < colCount; currentColPosition++) {
+    result[currentColPosition] = [];
+    for (let currentRowPosition = 0; currentRowPosition < rowCount; currentRowPosition++) {
+      result[currentColPosition][currentRowPosition] = matrix[currentRowPosition][currentColPosition];
+    }
+  }
+
+  return result;
+}
+
+function sumDiagonal(matrix) {
+  let total = 0;
+  for (let diagonalElementIndex = 0; diagonalElementIndex < matrix.length; diagonalElementIndex++) {
+    total += matrix[diagonalElementIndex][diagonalElementIndex];
+  }
+  return total;
+}
+
+function fill(rows, cols, value) {
+  const result = [];
+  for (let currentRowPosition = 0; currentRowPosition < rows; currentRowPosition++) {
+    result[currentRowPosition] = [];
+    for (let currentColPosition = 0; currentColPosition < cols; currentColPosition++) {
+      result[currentRowPosition][currentColPosition] = (currentRowPosition + 1) * (currentColPosition + 1) * value;
+    }
+  }
+  return result;
+}
+
+function findMaxInRow(matrix) {
+  return matrix.map(row => {
+    let max = row[0];
+    for (let elementPosition = 1; elementPosition < row.length; elementPosition++) {
+      if (row[elementPosition] > max) max = row[elementPosition];
+    }
+    return max;
+  });
+}
+
+function rotate90(matrix) {
+  const size = matrix.length;
+  const result = [];
+
+  for (let currentColPosition = 0; currentColPosition < size; currentColPosition++) {
+    result[currentColPosition] = [];
+    for (let currentRowPosition = size - 1; currentRowPosition >= 0; currentRowPosition--) {
+      result[currentColPosition][size - 1 - currentRowPosition] = matrix[currentRowPosition][currentColPosition];
+    }
+  }
+
+  return result;
+}
+
+function flatten(matrix) {
+  const result = [];
+  for (let currentRowPosition = 0; currentRowPosition < matrix.length; currentRowPosition++) {
+    for (let currentColPosition = 0; currentColPosition < matrix[currentRowPosition].length; currentColPosition++) {
+      result.push(matrix[currentRowPosition][currentColPosition]);
+    }
+  }
+  return result;
+}
+
+module.exports = { multiply, transpose, sumDiagonal, fill, findMaxInRow, rotate90, flatten };
diff --git a/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/bad/matrix.rb b/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/bad/matrix.rb
new file mode 100644
index 0000000..e0072e5
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/bad/matrix.rb
@@ -0,0 +1,89 @@
+# Matrix operations using verbose loop counter names.
+# BAD: numeric loop counters use long descriptive names instead of i, j, k.
+
+class MatrixBad
+  def multiply(matrix_a, matrix_b)
+    row_count = matrix_a.length
+    col_count = matrix_b[0].length
+    inner_count = matrix_b.length
+    result = Array.new(row_count) { Array.new(col_count, 0) }
+
+    (0...row_count).each do |current_row_position|
+      (0...col_count).each do |current_col_position|
+        (0...inner_count).each do |element_index|
+          result[current_row_position][current_col_position] +=
+            matrix_a[current_row_position][element_index] * matrix_b[element_index][current_col_position]
+        end
+      end
+    end
+
+    result
+  end
+
+  def transpose(matrix)
+    row_count = matrix.length
+    col_count = matrix[0].length
+    result = Array.new(col_count) { Array.new(row_count) }
+
+    (0...col_count).each do |current_col_position|
+      (0...row_count).each do |current_row_position|
+        result[current_col_position][current_row_position] = matrix[current_row_position][current_col_position]
+      end
+    end
+
+    result
+  end
+
+  def sum_diagonal(matrix)
+    total = 0
+    (0...matrix.length).each do |diagonal_element_index|
+      total += matrix[diagonal_element_index][diagonal_element_index]
+    end
+    total
+  end
+
+  def fill(rows, cols, value)
+    result = []
+    (1..rows).each do |current_row_position|
+      row = []
+      (1..cols).each do |current_col_position|
+        row << current_row_position * current_col_position * value
+      end
+      result << row
+    end
+    result
+  end
+
+  def find_max_in_row(matrix)
+    matrix.map do |row|
+      max = row[0]
+      (1...row.length).each do |element_position|
+        max = row[element_position] if row[element_position] > max
+      end
+      max
+    end
+  end
+
+  def rotate_90(matrix)
+    size = matrix.length
+    result = Array.new(size) { Array.new(size) }
+
+    (0...size).each do |current_col_position|
+      (0...size).each do |current_row_position|
+        result[current_col_position][size - 1 - current_row_position] = matrix[current_row_position][current_col_position]
+      end
+    end
+
+    result
+  end
+
+  def flatten(matrix)
+    result = []
+    (0...matrix.length).each do |current_row_position|
+      (0...matrix[current_row_position].length).each do |current_col_position|
+        result << matrix[current_row_position][current_col_position]
+      end
+    end
+    result
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/config.yml b/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/config.yml
new file mode 100644
index 0000000..1397235
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/config.yml
@@ -0,0 +1 @@
+doc: "Loop index variables (`i`, `j`, `k`) are acceptable inside loop bodies."
diff --git a/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/good/matrix.ex b/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/good/matrix.ex
new file mode 100644
index 0000000..8daf50a
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/good/matrix.ex
@@ -0,0 +1,81 @@
+defmodule Matrix.Good do
+  @moduledoc """
+  Matrix operations using single-letter loop counters.
+  GOOD: numeric loop counters use i, j, k; element variables use descriptive names.
+  """
+
+  @spec multiply(list(list(number())), list(list(number()))) :: list(list(number()))
+  def multiply(matrix_a, matrix_b) do
+    row_count = length(matrix_a)
+    col_count = length(hd(matrix_b))
+    inner_count = length(matrix_b)
+
+    for i <- 0..(row_count - 1) do
+      for j <- 0..(col_count - 1) do
+        Enum.reduce(0..(inner_count - 1), 0, fn k, acc ->
+          a_val = matrix_a |> Enum.at(i) |> Enum.at(k)
+          b_val = matrix_b |> Enum.at(k) |> Enum.at(j)
+          acc + a_val * b_val
+        end)
+      end
+    end
+  end
+
+  @spec transpose(list(list(number()))) :: list(list(number()))
+  def transpose(matrix) do
+    row_count = length(matrix)
+    col_count = length(hd(matrix))
+
+    for j <- 0..(col_count - 1) do
+      for i <- 0..(row_count - 1) do
+        matrix |> Enum.at(i) |> Enum.at(j)
+      end
+    end
+  end
+
+  @spec sum_diagonal(list(list(number()))) :: number()
+  def sum_diagonal(matrix) do
+    size = length(matrix)
+
+    Enum.reduce(0..(size - 1), 0, fn i, acc ->
+      value = matrix |> Enum.at(i) |> Enum.at(i)
+      acc + value
+    end)
+  end
+
+  @spec fill(number(), number(), number()) :: list(list(number()))
+  def fill(rows, cols, value) do
+    for i <- 1..rows do
+      for j <- 1..cols do
+        i * j * value
+      end
+    end
+  end
+
+  @spec find_max_in_row(list(list(number()))) :: list(number())
+  def find_max_in_row(matrix) do
+    Enum.map(matrix, fn row ->
+      Enum.reduce(row, hd(row), fn element, current_max ->
+        if element > current_max, do: element, else: current_max
+      end)
+    end)
+  end
+
+  @spec rotate_90(list(list(number()))) :: list(list(number()))
+  def rotate_90(matrix) do
+    size = length(matrix)
+
+    for j <- 0..(size - 1) do
+      for i <- (size - 1)..0//-1 do
+        matrix |> Enum.at(i) |> Enum.at(j)
+      end
+    end
+  end
+
+  @spec flatten(list(list(number()))) :: list(number())
+  def flatten(matrix) do
+    Enum.reduce(matrix, [], fn row, acc ->
+      acc ++ row
+    end)
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/good/matrix.js b/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/good/matrix.js
new file mode 100644
index 0000000..ee09878
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/good/matrix.js
@@ -0,0 +1,92 @@
+// Matrix operations using single-letter loop counters.
+// GOOD: numeric loop counters use i, j, k; element variables use descriptive names.
+
+function multiply(matrixA, matrixB) {
+  const rowCount = matrixA.length;
+  const colCount = matrixB[0].length;
+  const innerCount = matrixB.length;
+  const result = [];
+
+  for (let i = 0; i < rowCount; i++) {
+    result[i] = [];
+    for (let j = 0; j < colCount; j++) {
+      let sum = 0;
+      for (let k = 0; k < innerCount; k++) {
+        sum += matrixA[i][k] * matrixB[k][j];
+      }
+      result[i][j] = sum;
+    }
+  }
+
+  return result;
+}
+
+function transpose(matrix) {
+  const rowCount = matrix.length;
+  const colCount = matrix[0].length;
+  const result = [];
+
+  for (let j = 0; j < colCount; j++) {
+    result[j] = [];
+    for (let i = 0; i < rowCount; i++) {
+      result[j][i] = matrix[i][j];
+    }
+  }
+
+  return result;
+}
+
+function sumDiagonal(matrix) {
+  let total = 0;
+  for (let i = 0; i < matrix.length; i++) {
+    total += matrix[i][i];
+  }
+  return total;
+}
+
+function fill(rows, cols, value) {
+  const result = [];
+  for (let i = 0; i < rows; i++) {
+    result[i] = [];
+    for (let j = 0; j < cols; j++) {
+      result[i][j] = (i + 1) * (j + 1) * value;
+    }
+  }
+  return result;
+}
+
+function findMaxInRow(matrix) {
+  return matrix.map(row => {
+    let max = row[0];
+    for (let i = 1; i < row.length; i++) {
+      if (row[i] > max) max = row[i];
+    }
+    return max;
+  });
+}
+
+function rotate90(matrix) {
+  const size = matrix.length;
+  const result = [];
+
+  for (let j = 0; j < size; j++) {
+    result[j] = [];
+    for (let i = size - 1; i >= 0; i--) {
+      result[j][size - 1 - i] = matrix[i][j];
+    }
+  }
+
+  return result;
+}
+
+function flatten(matrix) {
+  const result = [];
+  for (let i = 0; i < matrix.length; i++) {
+    for (let j = 0; j < matrix[i].length; j++) {
+      result.push(matrix[i][j]);
+    }
+  }
+  return result;
+}
+
+module.exports = { multiply, transpose, sumDiagonal, fill, findMaxInRow, rotate90, flatten };
diff --git a/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/good/matrix.rb b/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/good/matrix.rb
new file mode 100644
index 0000000..214ffc6
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/loop_var_is_single_letter/good/matrix.rb
@@ -0,0 +1,88 @@
+# Matrix operations using single-letter loop counters.
+# GOOD: numeric loop counters use i, j, k; element variables use descriptive names.
+
+class MatrixGood
+  def multiply(matrix_a, matrix_b)
+    row_count = matrix_a.length
+    col_count = matrix_b[0].length
+    inner_count = matrix_b.length
+    result = Array.new(row_count) { Array.new(col_count, 0) }
+
+    (0...row_count).each do |i|
+      (0...col_count).each do |j|
+        (0...inner_count).each do |k|
+          result[i][j] += matrix_a[i][k] * matrix_b[k][j]
+        end
+      end
+    end
+
+    result
+  end
+
+  def transpose(matrix)
+    row_count = matrix.length
+    col_count = matrix[0].length
+    result = Array.new(col_count) { Array.new(row_count) }
+
+    (0...col_count).each do |j|
+      (0...row_count).each do |i|
+        result[j][i] = matrix[i][j]
+      end
+    end
+
+    result
+  end
+
+  def sum_diagonal(matrix)
+    total = 0
+    (0...matrix.length).each do |i|
+      total += matrix[i][i]
+    end
+    total
+  end
+
+  def fill(rows, cols, value)
+    result = []
+    (1..rows).each do |i|
+      row = []
+      (1..cols).each do |j|
+        row << i * j * value
+      end
+      result << row
+    end
+    result
+  end
+
+  def find_max_in_row(matrix)
+    matrix.map do |row|
+      max = row[0]
+      (1...row.length).each do |i|
+        max = row[i] if row[i] > max
+      end
+      max
+    end
+  end
+
+  def rotate_90(matrix)
+    size = matrix.length
+    result = Array.new(size) { Array.new(size) }
+
+    (0...size).each do |j|
+      (0...size).each do |i|
+        result[j][size - 1 - i] = matrix[i][j]
+      end
+    end
+
+    result
+  end
+
+  def flatten(matrix)
+    result = []
+    (0...matrix.length).each do |i|
+      (0...matrix[i].length).each do |j|
+        result << matrix[i][j]
+      end
+    end
+    result
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_contains_and/bad/checkout.ex b/priv/combined_metrics/samples/variable_naming/name_contains_and/bad/checkout.ex
new file mode 100644
index 0000000..258bc06
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_contains_and/bad/checkout.ex
@@ -0,0 +1,76 @@
+defmodule Checkout.Bad do
+  @moduledoc """
+  Checkout and payment processing with compound variable names using 'and'.
+  BAD: variables combine two concepts with 'and' instead of being split.
+  """
+
+  @spec process_order(map()) :: {:ok, map()} | {:error, String.t()}
+  def process_order(order) do
+    user_and_address = fetch_user_and_address(order.user_id)
+    price_and_tax = calculate_price_and_tax(order.items)
+    shipping_and_handling = calculate_shipping_and_handling(user_and_address, order.items)
+
+    total = price_and_tax.subtotal + price_and_tax.tax + shipping_and_handling
+
+    {:ok, %{
+      user: user_and_address.user,
+      address: user_and_address.address,
+      total: total
+    }}
+  end
+
+  @spec apply_discounts(map(), list()) :: map()
+  def apply_discounts(cart, coupons) do
+    price_and_discount = compute_price_and_discount(cart, coupons)
+
+    %{
+      original: price_and_discount.price,
+      savings: price_and_discount.discount,
+      final: price_and_discount.price - price_and_discount.discount
+    }
+  end
+
+  @spec build_receipt(map()) :: map()
+  def build_receipt(order) do
+    name_and_email = get_name_and_email(order.user_id)
+    items_and_quantities = group_items_and_quantities(order.line_items)
+    date_and_time = get_date_and_time()
+
+    %{
+      customer: name_and_email.name,
+      contact: name_and_email.email,
+      lines: items_and_quantities,
+      issued_at: date_and_time
+    }
+  end
+
+  @spec validate_payment(map()) :: {:ok, map()} | {:error, String.t()}
+  def validate_payment(payment) do
+    card_and_billing = extract_card_and_billing(payment)
+
+    if valid_card_and_billing?(card_and_billing) do
+      {:ok, card_and_billing}
+    else
+      {:error, "Invalid card or billing details"}
+    end
+  end
+
+  @spec split_order(map(), list()) :: list(map())
+  def split_order(order, vendor_ids) do
+    Enum.map(vendor_ids, fn vendor_id ->
+      items_and_totals = filter_items_and_totals(order, vendor_id)
+      %{vendor_id: vendor_id, items: items_and_totals.items, subtotal: items_and_totals.total}
+    end)
+  end
+
+  defp fetch_user_and_address(user_id), do: %{user: %{id: user_id}, address: %{}}
+  defp calculate_price_and_tax(items), do: %{subtotal: length(items) * 10, tax: length(items) * 1}
+  defp calculate_shipping_and_handling(_user_and_address, _items), do: 5
+  defp compute_price_and_discount(cart, _coupons), do: %{price: cart.total, discount: 0}
+  defp get_name_and_email(_id), do: %{name: "Alice", email: "alice@example.com"}
+  defp group_items_and_quantities(items), do: items
+  defp get_date_and_time, do: DateTime.utc_now()
+  defp extract_card_and_billing(payment), do: payment
+  defp valid_card_and_billing?(_), do: true
+  defp filter_items_and_totals(order, _vendor_id), do: %{items: order.line_items, total: 0}
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_contains_and/bad/checkout.js b/priv/combined_metrics/samples/variable_naming/name_contains_and/bad/checkout.js
new file mode 100644
index 0000000..c526228
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_contains_and/bad/checkout.js
@@ -0,0 +1,94 @@
+// Checkout and payment processing with compound variable names using 'and'.
+// BAD: variables combine two concepts with 'and' instead of being split.
+
+async function processOrder(order) {
+  const userAndAddress = await fetchUserAndAddress(order.userId);
+  const priceAndTax = calculatePriceAndTax(order.items);
+  const shippingAndHandling = calculateShippingAndHandling(userAndAddress, order.items);
+
+  const total = priceAndTax.subtotal + priceAndTax.tax + shippingAndHandling;
+
+  return {
+    user: userAndAddress.user,
+    address: userAndAddress.address,
+    total,
+  };
+}
+
+function applyDiscounts(cart, coupons) {
+  const priceAndDiscount = computePriceAndDiscount(cart, coupons);
+
+  return {
+    original: priceAndDiscount.price,
+    savings: priceAndDiscount.discount,
+    final: priceAndDiscount.price - priceAndDiscount.discount,
+  };
+}
+
+async function buildReceipt(order) {
+  const nameAndEmail = await getNameAndEmail(order.userId);
+  const itemsAndQuantities = groupItemsAndQuantities(order.lineItems);
+  const dateAndTime = new Date();
+
+  return {
+    customer: nameAndEmail.name,
+    contact: nameAndEmail.email,
+    lines: itemsAndQuantities,
+    issuedAt: dateAndTime,
+  };
+}
+
+async function validatePayment(payment) {
+  const cardAndBilling = extractCardAndBilling(payment);
+
+  if (!isValidCardAndBilling(cardAndBilling)) {
+    throw new Error('Invalid card or billing details');
+  }
+
+  return cardAndBilling;
+}
+
+function splitOrder(order, vendorIds) {
+  return vendorIds.map(vendorId => {
+    const itemsAndTotals = filterItemsAndTotals(order, vendorId);
+    return {
+      vendorId,
+      items: itemsAndTotals.items,
+      subtotal: itemsAndTotals.total,
+    };
+  });
+}
+
+function summarizeCart(cart) {
+  const countAndWeight = computeCountAndWeight(cart.items);
+  const taxAndFees = computeTaxAndFees(cart.subtotal, cart.region);
+
+  return {
+    itemCount: countAndWeight.count,
+    totalWeight: countAndWeight.weight,
+    tax: taxAndFees.tax,
+    fees: taxAndFees.fees,
+    grandTotal: cart.subtotal + taxAndFees.tax + taxAndFees.fees,
+  };
+}
+
+async function fetchUserAndAddress(userId) {
+  return { user: { id: userId }, address: {} };
+}
+
+function calculatePriceAndTax(items) {
+  const subtotal = items.length * 10;
+  return { subtotal, tax: subtotal * 0.1 };
+}
+
+function calculateShippingAndHandling() { return 5; }
+function computePriceAndDiscount(cart) { return { price: cart.total, discount: 0 }; }
+async function getNameAndEmail() { return { name: 'Alice', email: 'alice@example.com' }; }
+function groupItemsAndQuantities(items) { return items; }
+function extractCardAndBilling(payment) { return payment; }
+function isValidCardAndBilling() { return true; }
+function filterItemsAndTotals(order) { return { items: order.lineItems, total: 0 }; }
+function computeCountAndWeight(items) { return { count: items.length, weight: 0 }; }
+function computeTaxAndFees(subtotal) { return { tax: subtotal * 0.1, fees: 2 }; }
+
+module.exports = { processOrder, applyDiscounts, buildReceipt, validatePayment, splitOrder, summarizeCart };
diff --git a/priv/combined_metrics/samples/variable_naming/name_contains_and/bad/checkout.rb b/priv/combined_metrics/samples/variable_naming/name_contains_and/bad/checkout.rb
new file mode 100644
index 0000000..313547a
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_contains_and/bad/checkout.rb
@@ -0,0 +1,83 @@
+# Checkout and payment processing with compound variable names using 'and'.
+# BAD: variables combine two concepts with 'and' instead of being split.
+
+class CheckoutBad
+  def process_order(order)
+    user_and_address = fetch_user_and_address(order[:user_id])
+    price_and_tax = calculate_price_and_tax(order[:items])
+    shipping_and_handling = calculate_shipping_and_handling(user_and_address, order[:items])
+
+    total = price_and_tax[:subtotal] + price_and_tax[:tax] + shipping_and_handling
+
+    {
+      user: user_and_address[:user],
+      address: user_and_address[:address],
+      total: total
+    }
+  end
+
+  def apply_discounts(cart, coupons)
+    price_and_discount = compute_price_and_discount(cart, coupons)
+
+    {
+      original: price_and_discount[:price],
+      savings: price_and_discount[:discount],
+      final: price_and_discount[:price] - price_and_discount[:discount]
+    }
+  end
+
+  def build_receipt(order)
+    name_and_email = get_name_and_email(order[:user_id])
+    items_and_quantities = group_items_and_quantities(order[:line_items])
+    date_and_time = Time.now
+
+    {
+      customer: name_and_email[:name],
+      contact: name_and_email[:email],
+      lines: items_and_quantities,
+      issued_at: date_and_time
+    }
+  end
+
+  def validate_payment(payment)
+    card_and_billing = extract_card_and_billing(payment)
+
+    raise 'Invalid card or billing details' unless valid_card_and_billing?(card_and_billing)
+
+    card_and_billing
+  end
+
+  def split_order(order, vendor_ids)
+    vendor_ids.map do |vendor_id|
+      items_and_totals = filter_items_and_totals(order, vendor_id)
+      { vendor_id: vendor_id, items: items_and_totals[:items], subtotal: items_and_totals[:total] }
+    end
+  end
+
+  def summarize_cart(cart)
+    count_and_weight = compute_count_and_weight(cart[:items])
+    tax_and_fees = compute_tax_and_fees(cart[:subtotal], cart[:region])
+
+    {
+      item_count: count_and_weight[:count],
+      total_weight: count_and_weight[:weight],
+      tax: tax_and_fees[:tax],
+      fees: tax_and_fees[:fees],
+      grand_total: cart[:subtotal] + tax_and_fees[:tax] + tax_and_fees[:fees]
+    }
+  end
+
+  private
+
+  def fetch_user_and_address(user_id) = { user: { id: user_id }, address: {} }
+  def calculate_price_and_tax(items) = { subtotal: items.length * 10, tax: items.length * 1 }
+  def calculate_shipping_and_handling(_u, _i) = 5
+  def compute_price_and_discount(cart, _coupons) = { price: cart[:total], discount: 0 }
+  def get_name_and_email(_id) = { name: 'Alice', email: 'alice@example.com' }
+  def group_items_and_quantities(items) = items
+  def extract_card_and_billing(payment) = payment
+  def valid_card_and_billing?(_) = true
+  def filter_items_and_totals(order, _vid) = { items: order[:line_items], total: 0 }
+  def compute_count_and_weight(items) = { count: items.length, weight: 0 }
+  def compute_tax_and_fees(subtotal, _r) = { tax: subtotal * 0.1, fees: 2 }
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_contains_and/config.yml b/priv/combined_metrics/samples/variable_naming/name_contains_and/config.yml
new file mode 100644
index 0000000..4b481f3
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_contains_and/config.yml
@@ -0,0 +1 @@
+doc: "Variable names containing `and` signal a variable that holds two concerns."
diff --git a/priv/combined_metrics/samples/variable_naming/name_contains_and/good/checkout.ex b/priv/combined_metrics/samples/variable_naming/name_contains_and/good/checkout.ex
new file mode 100644
index 0000000..0f6aab7
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_contains_and/good/checkout.ex
@@ -0,0 +1,78 @@
+defmodule Checkout.Good do
+  @moduledoc """
+  Checkout and payment processing with separate, focused variable names.
+  GOOD: each variable holds one concept; compound data uses structs or tuples.
+  """
+
+  @spec process_order(map()) :: {:ok, map()} | {:error, String.t()}
+  def process_order(order) do
+    user = fetch_user(order.user_id)
+    address = fetch_address(order.user_id)
+    subtotal = calculate_subtotal(order.items)
+    tax = calculate_tax(subtotal)
+    shipping = calculate_shipping(address, order.items)
+
+    total = subtotal + tax + shipping
+
+    {:ok, %{user: user, address: address, total: total}}
+  end
+
+  @spec apply_discounts(map(), list()) :: map()
+  def apply_discounts(cart, coupons) do
+    price = cart.total
+    discount = compute_discount(cart, coupons)
+
+    %{
+      original: price,
+      savings: discount,
+      final: price - discount
+    }
+  end
+
+  @spec build_receipt(map()) :: map()
+  def build_receipt(order) do
+    name = fetch_customer_name(order.user_id)
+    email = fetch_customer_email(order.user_id)
+    line_items = group_line_items(order.line_items)
+    issued_at = DateTime.utc_now()
+
+    %{customer: name, contact: email, lines: line_items, issued_at: issued_at}
+  end
+
+  @spec validate_payment(map()) :: {:ok, map()} | {:error, String.t()}
+  def validate_payment(payment) do
+    card = extract_card(payment)
+    billing = extract_billing(payment)
+
+    if valid_card?(card) && valid_billing?(billing) do
+      {:ok, %{card: card, billing: billing}}
+    else
+      {:error, "Invalid card or billing details"}
+    end
+  end
+
+  @spec split_order(map(), list()) :: list(map())
+  def split_order(order, vendor_ids) do
+    Enum.map(vendor_ids, fn vendor_id ->
+      items = filter_items_by_vendor(order, vendor_id)
+      subtotal = sum_items(items)
+      %{vendor_id: vendor_id, items: items, subtotal: subtotal}
+    end)
+  end
+
+  defp fetch_user(user_id), do: %{id: user_id}
+  defp fetch_address(_user_id), do: %{}
+  defp calculate_subtotal(items), do: length(items) * 10
+  defp calculate_tax(subtotal), do: subtotal * 0.1
+  defp calculate_shipping(_address, _items), do: 5
+  defp compute_discount(_cart, _coupons), do: 0
+  defp fetch_customer_name(_id), do: "Alice"
+  defp fetch_customer_email(_id), do: "alice@example.com"
+  defp group_line_items(items), do: items
+  defp extract_card(payment), do: Map.get(payment, :card)
+  defp extract_billing(payment), do: Map.get(payment, :billing)
+  defp valid_card?(_), do: true
+  defp valid_billing?(_), do: true
+  defp filter_items_by_vendor(order, _vendor_id), do: order.line_items
+  defp sum_items(items), do: length(items) * 10
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_contains_and/good/checkout.js b/priv/combined_metrics/samples/variable_naming/name_contains_and/good/checkout.js
new file mode 100644
index 0000000..1cee5fd
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_contains_and/good/checkout.js
@@ -0,0 +1,89 @@
+// Checkout and payment processing with separate, focused variable names.
+// GOOD: each variable holds one concept; compound data uses plain objects.
+
+async function processOrder(order) {
+  const user = await fetchUser(order.userId);
+  const address = await fetchAddress(order.userId);
+  const subtotal = calculateSubtotal(order.items);
+  const tax = calculateTax(subtotal);
+  const shipping = calculateShipping(address, order.items);
+
+  const total = subtotal + tax + shipping;
+
+  return { user, address, total };
+}
+
+function applyDiscounts(cart, coupons) {
+  const price = cart.total;
+  const discount = computeDiscount(cart, coupons);
+
+  return {
+    original: price,
+    savings: discount,
+    final: price - discount,
+  };
+}
+
+async function buildReceipt(order) {
+  const name = await fetchCustomerName(order.userId);
+  const email = await fetchCustomerEmail(order.userId);
+  const lineItems = groupLineItems(order.lineItems);
+  const issuedAt = new Date();
+
+  return { customer: name, contact: email, lines: lineItems, issuedAt };
+}
+
+async function validatePayment(payment) {
+  const card = extractCard(payment);
+  const billing = extractBilling(payment);
+
+  if (!isValidCard(card) || !isValidBilling(billing)) {
+    throw new Error('Invalid card or billing details');
+  }
+
+  return { card, billing };
+}
+
+function splitOrder(order, vendorIds) {
+  return vendorIds.map(vendorId => {
+    const items = filterItemsByVendor(order, vendorId);
+    const subtotal = sumItems(items);
+    return { vendorId, items, subtotal };
+  });
+}
+
+function summarizeCart(cart) {
+  const count = cart.items.length;
+  const weight = computeWeight(cart.items);
+  const tax = computeTax(cart.subtotal, cart.region);
+  const fees = computeFees(cart.subtotal, cart.region);
+
+  return {
+    itemCount: count,
+    totalWeight: weight,
+    tax,
+    fees,
+    grandTotal: cart.subtotal + tax + fees,
+  };
+}
+
+async function fetchUser(userId) { return { id: userId }; }
+async function fetchAddress() { return {}; }
+function calculateSubtotal(items) { return items.length * 10; }
+function calculateTax(subtotal) { return subtotal * 0.1; }
+function calculateShipping() { return 5; }
+function computeDiscount() { return 0; }
+async function fetchCustomerName() { return 'Alice'; }
+async function fetchCustomerEmail() { return 'alice@example.com'; }
+function groupLineItems(items) { return items; }
+function extractCard(payment) { return payment.card; }
+function extractBilling(payment) { return payment.billing; }
+function isValidCard() { return true; }
+function isValidBilling() { return true; }
+function filterItemsByVendor(order) { return order.lineItems; }
+function sumItems(items) { return items.length * 10; }
+function computeWeight() { return 0; }
+function computeTax(subtotal) { return subtotal * 0.1; }
+function computeFees() { return 2; }
+
+module.exports = { processOrder, applyDiscounts, buildReceipt, validatePayment, splitOrder, summarizeCart };
diff --git a/priv/combined_metrics/samples/variable_naming/name_contains_and/good/checkout.rb b/priv/combined_metrics/samples/variable_naming/name_contains_and/good/checkout.rb
new file mode 100644
index 0000000..a0cf45f
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_contains_and/good/checkout.rb
@@ -0,0 +1,89 @@
+# Checkout and payment processing with separate, focused variable names.
+# GOOD: each variable holds one concept; compound data uses plain hashes.
+
+class CheckoutGood
+  def process_order(order)
+    user = fetch_user(order[:user_id])
+    address = fetch_address(order[:user_id])
+    subtotal = calculate_subtotal(order[:items])
+    tax = calculate_tax(subtotal)
+    shipping = calculate_shipping(address, order[:items])
+
+    total = subtotal + tax + shipping
+
+    { user: user, address: address, total: total }
+  end
+
+  def apply_discounts(cart, coupons)
+    price = cart[:total]
+    discount = compute_discount(cart, coupons)
+
+    {
+      original: price,
+      savings: discount,
+      final: price - discount
+    }
+  end
+
+  def build_receipt(order)
+    name = fetch_customer_name(order[:user_id])
+    email = fetch_customer_email(order[:user_id])
+    line_items = group_line_items(order[:line_items])
+    issued_at = Time.now
+
+    { customer: name, contact: email, lines: line_items, issued_at: issued_at }
+  end
+
+  def validate_payment(payment)
+    card = extract_card(payment)
+    billing = extract_billing(payment)
+
+    raise 'Invalid card or billing details' unless valid_card?(card) && valid_billing?(billing)
+
+    { card: card, billing: billing }
+  end
+
+  def split_order(order, vendor_ids)
+    vendor_ids.map do |vendor_id|
+      items = filter_items_by_vendor(order, vendor_id)
+      subtotal = sum_items(items)
+      { vendor_id: vendor_id, items: items, subtotal: subtotal }
+    end
+  end
+
+  def summarize_cart(cart)
+    count = cart[:items].length
+    weight = compute_weight(cart[:items])
+    tax = compute_tax(cart[:subtotal], cart[:region])
+    fees = compute_fees(cart[:subtotal], cart[:region])
+
+    {
+      item_count: count,
+      total_weight: weight,
+      tax: tax,
+      fees: fees,
+      grand_total: cart[:subtotal] + tax + fees
+    }
+  end
+
+  private
+
+  def fetch_user(user_id) = { id: user_id }
+  def fetch_address(_user_id) = {}
+  def calculate_subtotal(items) = items.length * 10
+  def calculate_tax(subtotal) = subtotal * 0.1
+  def calculate_shipping(_address, _items) = 5
+  def compute_discount(_cart, _coupons) = 0
+  def fetch_customer_name(_id) = 'Alice'
+  def fetch_customer_email(_id) = 'alice@example.com'
+  def group_line_items(items) = items
+  def extract_card(payment) = payment[:card]
+  def extract_billing(payment) = payment[:billing]
+  def valid_card?(_) = true
+  def valid_billing?(_) = true
+  def filter_items_by_vendor(order, _vid) = order[:line_items]
+  def sum_items(items) = items.length * 10
+  def compute_weight(_items) = 0
+  def compute_tax(subtotal, _region) = subtotal * 0.1
+  def compute_fees(_subtotal, _region) = 2
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/bad/report.ex b/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/bad/report.ex
new file mode 100644
index 0000000..af388aa
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/bad/report.ex
@@ -0,0 +1,87 @@
+defmodule Report.Bad do
+  @moduledoc """
+  Report generation with type suffixes in variable names.
+  BAD: variables include redundant type suffixes like _string, _list, _integer, _map.
+  """
+
+  @spec generate(map()) :: map()
+  def generate(params) do
+    user_string = format_user_string(params.user)
+    date_string = Calendar.strftime(params.date, "%Y-%m-%d")
+    title_string = build_title_string(params.report_type)
+
+    row_list = fetch_row_list(params.filters)
+    column_list = params.columns
+    tag_list = params.tags || []
+
+    count_integer = length(row_list)
+    page_count_integer = ceil(count_integer / params.page_size)
+    total_integer = sum_total_integer(row_list)
+
+    result_map = build_result_map(row_list, column_list)
+    summary_map = compute_summary_map(row_list)
+
+    %{
+      title: title_string,
+      generated_by: user_string,
+      generated_on: date_string,
+      rows: row_list,
+      tags: tag_list,
+      count: count_integer,
+      pages: page_count_integer,
+      total: total_integer,
+      result: result_map,
+      summary: summary_map
+    }
+  end
+
+  @spec export(map(), String.t()) :: {:ok, binary()} | {:error, String.t()}
+  def export(report, format_string) do
+    header_list = extract_header_list(report)
+    data_list = extract_data_list(report)
+
+    case format_string do
+      "csv" ->
+        csv_string = render_csv_string(header_list, data_list)
+        {:ok, csv_string}
+
+      "json" ->
+        json_string = Jason.encode!(report)
+        {:ok, json_string}
+
+      _ ->
+        {:error, "Unsupported format: #{format_string}"}
+    end
+  end
+
+  @spec filter_rows(list(), map()) :: list()
+  def filter_rows(row_list, criteria_map) do
+    Enum.filter(row_list, fn row ->
+      Enum.all?(criteria_map, fn {key_string, value} ->
+        Map.get(row, key_string) == value
+      end)
+    end)
+  end
+
+  @spec aggregate(list(), list()) :: map()
+  def aggregate(row_list, group_by_list) do
+    row_list
+    |> Enum.group_by(fn row ->
+      Enum.map(group_by_list, &Map.get(row, &1))
+    end)
+    |> Enum.map(fn {key_list, group_list} ->
+      {key_list, length(group_list)}
+    end)
+    |> Map.new()
+  end
+
+  defp format_user_string(user), do: "#{user.first_name} #{user.last_name}"
+  defp build_title_string(type), do: "#{type} Report"
+  defp fetch_row_list(_filters), do: []
+  defp sum_total_integer(rows), do: Enum.sum(Enum.map(rows, &Map.get(&1, :amount, 0)))
+  defp build_result_map(rows, cols), do: %{rows: rows, columns: cols}
+  defp compute_summary_map(rows), do: %{count: length(rows)}
+  defp extract_header_list(report), do: Map.keys(report)
+  defp extract_data_list(report), do: [Map.values(report)]
+  defp render_csv_string(headers, data), do: Enum.join(headers, ",") <> "\n" <> inspect(data)
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/bad/report.js b/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/bad/report.js
new file mode 100644
index 0000000..edc1b93
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/bad/report.js
@@ -0,0 +1,84 @@
+// Report generation with type suffixes in variable names.
+// BAD: variables include redundant type suffixes like String, List, Integer, Array, Hash.
+
+function generate(params) {
+  const userString = formatUserString(params.user);
+  const dateString = params.date.toISOString().slice(0, 10);
+  const titleString = buildTitleString(params.reportType);
+
+  const rowArray = fetchRowArray(params.filters);
+  const columnArray = params.columns;
+  const tagArray = params.tags || [];
+
+  const countInteger = rowArray.length;
+  const pageCountInteger = Math.ceil(countInteger / params.pageSize);
+  const totalInteger = sumTotalInteger(rowArray);
+
+  const resultHash = buildResultHash(rowArray, columnArray);
+  const summaryHash = computeSummaryHash(rowArray);
+
+  return {
+    title: titleString,
+    generatedBy: userString,
+    generatedOn: dateString,
+    rows: rowArray,
+    tags: tagArray,
+    count: countInteger,
+    pages: pageCountInteger,
+    total: totalInteger,
+    result: resultHash,
+    summary: summaryHash,
+  };
+}
+
+function exportReport(report, formatString) {
+  const headerArray = extractHeaderArray(report);
+  const dataArray = extractDataArray(report);
+
+  if (formatString === 'csv') {
+    const csvString = renderCsvString(headerArray, dataArray);
+    return { ok: true, data: csvString };
+  }
+
+  if (formatString === 'json') {
+    const jsonString = JSON.stringify(report);
+    return { ok: true, data: jsonString };
+  }
+
+  return { ok: false, error: `Unsupported format: ${formatString}` };
+}
+
+function filterRows(rowArray, criteriaHash) {
+  return rowArray.filter(row =>
+    Object.entries(criteriaHash).every(([keyString, value]) => row[keyString] === value)
+  );
+}
+
+function aggregate(rowArray, groupByArray) {
+  const resultHash = {};
+
+  for (const row of rowArray) {
+    const keyString = groupByArray.map(field => row[field]).join('|');
+    resultHash[keyString] = (resultHash[keyString] || 0) + 1;
+  }
+
+  return resultHash;
+}
+
+function paginate(rowArray, pageInteger, pageSizeInteger) {
+  const startInteger = (pageInteger - 1) * pageSizeInteger;
+  const endInteger = startInteger + pageSizeInteger;
+  return rowArray.slice(startInteger, endInteger);
+}
+
+function formatUserString(user) { return `${user.firstName} ${user.lastName}`; }
+function buildTitleString(type) { return `${type} Report`; }
+function fetchRowArray() { return []; }
+function sumTotalInteger(rows) { return rows.reduce((acc, r) => acc + (r.amount || 0), 0); }
+function buildResultHash(rows, cols) { return { rows, columns: cols }; }
+function computeSummaryHash(rows) { return { count: rows.length }; }
+function extractHeaderArray(report) { return Object.keys(report); }
+function extractDataArray(report) { return [Object.values(report)]; }
+function renderCsvString(headers, data) { return headers.join(',') + '\n' + JSON.stringify(data); }
+
+module.exports = { generate, exportReport, filterRows, aggregate, paginate };
diff --git a/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/bad/report.rb b/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/bad/report.rb
new file mode 100644
index 0000000..a44fe53
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/bad/report.rb
@@ -0,0 +1,82 @@
+# Report generation with type suffixes in variable names.
+# BAD: variables include redundant type suffixes like _string, _list, _integer, _array, _hash.
+
+class ReportBad
+  def generate(params)
+    user_string = format_user_string(params[:user])
+    date_string = params[:date].strftime('%Y-%m-%d')
+    title_string = build_title_string(params[:report_type])
+
+    row_array = fetch_row_array(params[:filters])
+    column_array = params[:columns]
+    tag_array = params[:tags] || []
+
+    count_integer = row_array.length
+    page_count_integer = (count_integer.to_f / params[:page_size]).ceil
+    total_integer = sum_total_integer(row_array)
+
+    result_hash = build_result_hash(row_array, column_array)
+    summary_hash = compute_summary_hash(row_array)
+
+    {
+      title: title_string,
+      generated_by: user_string,
+      generated_on: date_string,
+      rows: row_array,
+      tags: tag_array,
+      count: count_integer,
+      pages: page_count_integer,
+      total: total_integer,
+      result: result_hash,
+      summary: summary_hash
+    }
+  end
+
+  def export_report(report, format_string)
+    header_array = extract_header_array(report)
+    data_array = extract_data_array(report)
+
+    case format_string
+    when 'csv'
+      csv_string = render_csv_string(header_array, data_array)
+      { ok: true, data: csv_string }
+    when 'json'
+      json_string = report.to_json
+      { ok: true, data: json_string }
+    else
+      { ok: false, error: "Unsupported format: #{format_string}" }
+    end
+  end
+
+  def filter_rows(row_array, criteria_hash)
+    row_array.select do |row|
+      criteria_hash.all? { |key_string, value| row[key_string.to_sym] == value }
+    end
+  end
+
+  def aggregate(row_array, group_by_array)
+    result_hash = {}
+    row_array.each do |row|
+      key_string = group_by_array.map { |field| row[field] }.join('|')
+      result_hash[key_string] = (result_hash[key_string] || 0) + 1
+    end
+    result_hash
+  end
+
+  def paginate(row_array, page_integer, page_size_integer)
+    start_integer = (page_integer - 1) * page_size_integer
+    row_array[start_integer, page_size_integer] || []
+  end
+
+  private
+
+  def format_user_string(user) = "#{user[:first_name]} #{user[:last_name]}"
+  def build_title_string(type) = "#{type} Report"
+  def fetch_row_array(_filters) = []
+  def sum_total_integer(rows) = rows.sum { |r| r[:amount] || 0 }
+  def build_result_hash(rows, cols) = { rows: rows, columns: cols }
+  def compute_summary_hash(rows) = { count: rows.length }
+  def extract_header_array(report) = report.keys
+  def extract_data_array(report) = [report.values]
+  def render_csv_string(headers, data) = "#{headers.join(',')}\n#{data.inspect}"
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/config.yml b/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/config.yml
new file mode 100644
index 0000000..b3fa9f8
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/config.yml
@@ -0,0 +1 @@
+doc: "Type suffixes in names (`userString`, `nameList`) are redundant noise."
diff --git a/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/good/report.ex b/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/good/report.ex
new file mode 100644
index 0000000..5eb7f86
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/good/report.ex
@@ -0,0 +1,87 @@
+defmodule Report.Good do
+  @moduledoc """
+  Report generation without type suffixes in variable names.
+  GOOD: variable names express what the data is, not what type it has.
+  """
+
+  @spec generate(map()) :: map()
+  def generate(params) do
+    user = format_user(params.user)
+    date = Calendar.strftime(params.date, "%Y-%m-%d")
+    title = build_title(params.report_type)
+
+    rows = fetch_rows(params.filters)
+    columns = params.columns
+    tags = params.tags || []
+
+    count = length(rows)
+    page_count = ceil(count / params.page_size)
+    total = sum_total(rows)
+
+    result = build_result(rows, columns)
+    summary = compute_summary(rows)
+
+    %{
+      title: title,
+      generated_by: user,
+      generated_on: date,
+      rows: rows,
+      tags: tags,
+      count: count,
+      pages: page_count,
+      total: total,
+      result: result,
+      summary: summary
+    }
+  end
+
+  @spec export(map(), String.t()) :: {:ok, binary()} | {:error, String.t()}
+  def export(report, format) do
+    headers = extract_headers(report)
+    data = extract_data(report)
+
+    case format do
+      "csv" ->
+        csv = render_csv(headers, data)
+        {:ok, csv}
+
+      "json" ->
+        json = Jason.encode!(report)
+        {:ok, json}
+
+      _ ->
+        {:error, "Unsupported format: #{format}"}
+    end
+  end
+
+  @spec filter_rows(list(), map()) :: list()
+  def filter_rows(rows, criteria) do
+    Enum.filter(rows, fn row ->
+      Enum.all?(criteria, fn {key, value} ->
+        Map.get(row, key) == value
+      end)
+    end)
+  end
+
+  @spec aggregate(list(), list()) :: map()
+  def aggregate(rows, group_by) do
+    rows
+    |> Enum.group_by(fn row ->
+      Enum.map(group_by, &Map.get(row, &1))
+    end)
+    |> Enum.map(fn {key, group} ->
+      {key, length(group)}
+    end)
+    |> Map.new()
+  end
+
+  defp format_user(user), do: "#{user.first_name} #{user.last_name}"
+  defp build_title(type), do: "#{type} Report"
+  defp fetch_rows(_filters), do: []
+  defp sum_total(rows), do: Enum.sum(Enum.map(rows, &Map.get(&1, :amount, 0)))
+  defp build_result(rows, cols), do: %{rows: rows, columns: cols}
+  defp compute_summary(rows), do: %{count: length(rows)}
+  defp extract_headers(report), do: Map.keys(report)
+  defp extract_data(report), do: [Map.values(report)]
+  defp render_csv(headers, data), do: Enum.join(headers, ",") <> "\n" <> inspect(data)
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/good/report.js b/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/good/report.js
new file mode 100644
index 0000000..e1302bb
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/good/report.js
@@ -0,0 +1,84 @@
+// Report generation without type suffixes in variable names.
+// GOOD: variable names express what the data is, not what type it has.
+
+function generate(params) {
+  const user = formatUser(params.user);
+  const date = params.date.toISOString().slice(0, 10);
+  const title = buildTitle(params.reportType);
+
+  const rows = fetchRows(params.filters);
+  const columns = params.columns;
+  const tags = params.tags || [];
+
+  const count = rows.length;
+  const pageCount = Math.ceil(count / params.pageSize);
+  const total = sumTotal(rows);
+
+  const result = buildResult(rows, columns);
+  const summary = computeSummary(rows);
+
+  return {
+    title,
+    generatedBy: user,
+    generatedOn: date,
+    rows,
+    tags,
+    count,
+    pages: pageCount,
+    total,
+    result,
+    summary,
+  };
+}
+
+function exportReport(report, format) {
+  const headers = extractHeaders(report);
+  const data = extractData(report);
+
+  if (format === 'csv') {
+    const csv = renderCsv(headers, data);
+    return { ok: true, data: csv };
+  }
+
+  if (format === 'json') {
+    const json = JSON.stringify(report);
+    return { ok: true, data: json };
+  }
+
+  return { ok: false, error: `Unsupported format: ${format}` };
+}
+
+function filterRows(rows, criteria) {
+  return rows.filter(row =>
+    Object.entries(criteria).every(([key, value]) => row[key] === value)
+  );
+}
+
+function aggregate(rows, groupBy) {
+  const result = {};
+
+  for (const row of rows) {
+    const key = groupBy.map(field => row[field]).join('|');
+    result[key] = (result[key] || 0) + 1;
+  }
+
+  return result;
+}
+
+function paginate(rows, page, pageSize) {
+  const start = (page - 1) * pageSize;
+  const end = start + pageSize;
+  return rows.slice(start, end);
+}
+
+function formatUser(user) { return `${user.firstName} ${user.lastName}`; }
+function buildTitle(type) { return `${type} Report`; }
+function fetchRows() { return []; }
+function sumTotal(rows) { return rows.reduce((acc, r) => acc + (r.amount || 0), 0); }
+function buildResult(rows, cols) { return { rows, columns: cols }; }
+function computeSummary(rows) { return { count: rows.length }; }
+function extractHeaders(report) { return Object.keys(report); }
+function extractData(report) { return [Object.values(report)]; }
+function renderCsv(headers, data) { return headers.join(',') + '\n' + JSON.stringify(data); }
+
+module.exports = { generate, exportReport, filterRows, aggregate, paginate };
diff --git a/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/good/report.rb b/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/good/report.rb
new file mode 100644
index 0000000..2264e82
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_contains_type_suffix/good/report.rb
@@ -0,0 +1,82 @@
+# Report generation without type suffixes in variable names.
+# GOOD: variable names express what the data is, not what type it has.
+
+class ReportGood
+  def generate(params)
+    user = format_user(params[:user])
+    date = params[:date].strftime('%Y-%m-%d')
+    title = build_title(params[:report_type])
+
+    rows = fetch_rows(params[:filters])
+    columns = params[:columns]
+    tags = params[:tags] || []
+
+    count = rows.length
+    page_count = (count.to_f / params[:page_size]).ceil
+    total = sum_total(rows)
+
+    result = build_result(rows, columns)
+    summary = compute_summary(rows)
+
+    {
+      title: title,
+      generated_by: user,
+      generated_on: date,
+      rows: rows,
+      tags: tags,
+      count: count,
+      pages: page_count,
+      total: total,
+      result: result,
+      summary: summary
+    }
+  end
+
+  def export_report(report, format)
+    headers = extract_headers(report)
+    data = extract_data(report)
+
+    case format
+    when 'csv'
+      csv = render_csv(headers, data)
+      { ok: true, data: csv }
+    when 'json'
+      json = report.to_json
+      { ok: true, data: json }
+    else
+      { ok: false, error: "Unsupported format: #{format}" }
+    end
+  end
+
+  def filter_rows(rows, criteria)
+    rows.select do |row|
+      criteria.all? { |key, value| row[key.to_sym] == value }
+    end
+  end
+
+  def aggregate(rows, group_by)
+    result = {}
+    rows.each do |row|
+      key = group_by.map { |field| row[field] }.join('|')
+      result[key] = (result[key] || 0) + 1
+    end
+    result
+  end
+
+  def paginate(rows, page, page_size)
+    start = (page - 1) * page_size
+    rows[start, page_size] || []
+  end
+
+  private
+
+  def format_user(user) = "#{user[:first_name]} #{user[:last_name]}"
+  def build_title(type) = "#{type} Report"
+  def fetch_rows(_filters) = []
+  def sum_total(rows) = rows.sum { |r| r[:amount] || 0 }
+  def build_result(rows, cols) = { rows: rows, columns: cols }
+  def compute_summary(rows) = { count: rows.length }
+  def extract_headers(report) = report.keys
+  def extract_data(report) = [report.values]
+  def render_csv(headers, data) = "#{headers.join(',')}\n#{data.inspect}"
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/bad/api_client.ex b/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/bad/api_client.ex
new file mode 100644
index 0000000..ad4e115
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/bad/api_client.ex
@@ -0,0 +1,88 @@
+defmodule ApiClient.Bad do
+  @moduledoc """
+  HTTP API client using abbreviated variable names.
+  BAD: variables like usr, cfg, req, res, addr, msg obscure intent.
+  """
+
+  @spec send_request(map(), map()) :: {:ok, map()} | {:error, String.t()}
+  def send_request(cfg, usr) do
+    req = build_req(cfg, usr)
+    addr = cfg.base_url <> req.path
+
+    case HTTPoison.post(addr, req.body, req.headers) do
+      {:ok, res} ->
+        msg = parse_res(res)
+        {:ok, msg}
+
+      {:error, err} ->
+        {:error, "Request failed: #{inspect(err)}"}
+    end
+  end
+
+  @spec fetch_product(map(), String.t()) :: {:ok, map()} | {:error, String.t()}
+  def fetch_product(cfg, prd_id) do
+    addr = "#{cfg.base_url}/products/#{prd_id}"
+    req = %{method: :get, path: "/products/#{prd_id}", headers: auth_headers(cfg)}
+
+    case HTTPoison.get(addr, req.headers) do
+      {:ok, res} when res.status_code == 200 ->
+        prd = Jason.decode!(res.body)
+        {:ok, prd}
+
+      {:ok, res} ->
+        msg = "Unexpected status: #{res.status_code}"
+        {:error, msg}
+
+      {:error, err} ->
+        {:error, inspect(err)}
+    end
+  end
+
+  @spec create_order(map(), map(), integer()) :: {:ok, map()} | {:error, String.t()}
+  def create_order(cfg, usr, qty) do
+    addr = "#{cfg.base_url}/orders"
+    req_body = Jason.encode!(%{user_id: usr.id, quantity: qty})
+    req_headers = auth_headers(cfg) ++ [{"Content-Type", "application/json"}]
+
+    case HTTPoison.post(addr, req_body, req_headers) do
+      {:ok, res} when res.status_code in [200, 201] ->
+        {:ok, Jason.decode!(res.body)}
+
+      {:ok, res} ->
+        msg = extract_error_msg(res)
+        {:error, msg}
+
+      {:error, err} ->
+        {:error, inspect(err)}
+    end
+  end
+
+  @spec paginate(map(), map()) :: {:ok, list()} | {:error, String.t()}
+  def paginate(cfg, params) do
+    addr = "#{cfg.base_url}/items"
+    req = %{path: "/items", headers: auth_headers(cfg), query: params}
+
+    case HTTPoison.get(addr, req.headers, params: req.query) do
+      {:ok, res} ->
+        {:ok, Jason.decode!(res.body)}
+
+      {:error, err} ->
+        {:error, inspect(err)}
+    end
+  end
+
+  defp build_req(cfg, usr) do
+    %{
+      path: "/requests",
+      body: Jason.encode!(%{user_id: usr.id}),
+      headers: auth_headers(cfg)
+    }
+  end
+
+  defp auth_headers(cfg) do
+    [{"Authorization", "Bearer #{cfg.api_key}"}]
+  end
+
+  defp parse_res(res), do: Jason.decode!(res.body)
+  defp extract_error_msg(res), do: "Error #{res.status_code}: #{res.body}"
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/bad/api_client.js b/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/bad/api_client.js
new file mode 100644
index 0000000..9c01645
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/bad/api_client.js
@@ -0,0 +1,98 @@
+// HTTP API client using abbreviated variable names.
+// BAD: variables like usr, cfg, req, res, addr, msg obscure intent.
+
+async function sendRequest(cfg, usr) {
+  const req = buildReq(cfg, usr);
+  const addr = cfg.baseUrl + req.path;
+
+  try {
+    const res = await fetch(addr, {
+      method: req.method,
+      headers: req.headers,
+      body: req.body,
+    });
+
+    const msg = await res.json();
+    return { ok: true, data: msg };
+  } catch (err) {
+    return { ok: false, error: `Request failed: ${err.message}` };
+  }
+}
+
+async function fetchProduct(cfg, prdId) {
+  const addr = `${cfg.baseUrl}/products/${prdId}`;
+  const req = { headers: authHeaders(cfg) };
+
+  try {
+    const res = await fetch(addr, req);
+
+    if (!res.ok) {
+      const msg = `Unexpected status: ${res.status}`;
+      return { ok: false, error: msg };
+    }
+
+    const prd = await res.json();
+    return { ok: true, data: prd };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+async function createOrder(cfg, usr, qty) {
+  const addr = `${cfg.baseUrl}/orders`;
+  const req = {
+    method: 'POST',
+    headers: { ...authHeaders(cfg), 'Content-Type': 'application/json' },
+    body: JSON.stringify({ userId: usr.id, quantity: qty }),
+  };
+
+  try {
+    const res = await fetch(addr, req);
+    const msg = await res.json();
+
+    if (!res.ok) return { ok: false, error: extractErrMsg(msg) };
+
+    return { ok: true, data: msg };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+async function paginate(cfg, params) {
+  const qry = new URLSearchParams(params).toString();
+  const addr = `${cfg.baseUrl}/items?${qry}`;
+  const req = { headers: authHeaders(cfg) };
+
+  try {
+    const res = await fetch(addr, req);
+    const msg = await res.json();
+    return { ok: true, data: msg };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+async function uploadFile(cfg, usr, buf) {
+  const addr = `${cfg.baseUrl}/uploads`;
+  const frm = new FormData();
+  frm.append('file', buf);
+  frm.append('userId', usr.id);
+
+  const res = await fetch(addr, { method: 'POST', headers: authHeaders(cfg), body: frm });
+  const msg = await res.json();
+  return { ok: res.ok, data: msg };
+}
+
+function buildReq(cfg, usr) {
+  return { method: 'POST', path: '/requests', body: JSON.stringify({ userId: usr.id }), headers: authHeaders(cfg) };
+}
+
+function authHeaders(cfg) {
+  return { Authorization: `Bearer ${cfg.apiKey}` };
+}
+
+function extractErrMsg(msg) {
+  return msg.error || 'Unknown error';
+}
+
+module.exports = { sendRequest, fetchProduct, createOrder, paginate, uploadFile };
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/bad/api_client.rb b/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/bad/api_client.rb
new file mode 100644
index 0000000..462d0ff
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/bad/api_client.rb
@@ -0,0 +1,91 @@
+# HTTP API client using abbreviated variable names.
+# BAD: variables like usr, cfg, req, res, addr, msg obscure intent.
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+class ApiClientBad
+  def send_request(cfg, usr)
+    req = build_req(cfg, usr)
+    addr = URI("#{cfg[:base_url]}#{req[:path]}")
+
+    res = Net::HTTP.post(addr, req[:body], req[:headers])
+    msg = JSON.parse(res.body)
+
+    { ok: res.is_a?(Net::HTTPSuccess), data: msg }
+  rescue => err
+    { ok: false, error: "Request failed: #{err.message}" }
+  end
+
+  def fetch_product(cfg, prd_id)
+    addr = URI("#{cfg[:base_url]}/products/#{prd_id}")
+    req = Net::HTTP::Get.new(addr)
+    req['Authorization'] = "Bearer #{cfg[:api_key]}"
+
+    res = Net::HTTP.start(addr.host, addr.port) { |http| http.request(req) }
+
+    unless res.is_a?(Net::HTTPSuccess)
+      msg = "Unexpected status: #{res.code}"
+      return { ok: false, error: msg }
+    end
+
+    prd = JSON.parse(res.body)
+    { ok: true, data: prd }
+  rescue => err
+    { ok: false, error: err.message }
+  end
+
+  def create_order(cfg, usr, qty)
+    addr = URI("#{cfg[:base_url]}/orders")
+    req = Net::HTTP::Post.new(addr)
+    req['Authorization'] = "Bearer #{cfg[:api_key]}"
+    req['Content-Type'] = 'application/json'
+    req.body = JSON.dump({ user_id: usr[:id], quantity: qty })
+
+    res = Net::HTTP.start(addr.host, addr.port) { |http| http.request(req) }
+    msg = JSON.parse(res.body)
+
+    return { ok: false, error: extract_err_msg(msg) } unless res.is_a?(Net::HTTPSuccess)
+
+    { ok: true, data: msg }
+  rescue => err
+    { ok: false, error: err.message }
+  end
+
+  def paginate(cfg, params)
+    qry = URI.encode_www_form(params)
+    addr = URI("#{cfg[:base_url]}/items?#{qry}")
+    req = Net::HTTP::Get.new(addr)
+    req['Authorization'] = "Bearer #{cfg[:api_key]}"
+
+    res = Net::HTTP.start(addr.host, addr.port) { |http| http.request(req) }
+    msg = JSON.parse(res.body)
+
+    { ok: res.is_a?(Net::HTTPSuccess), data: msg }
+  rescue => err
+    { ok: false, error: err.message }
+  end
+
+  def upload_file(cfg, usr, buf)
+    addr = URI("#{cfg[:base_url]}/uploads")
+    req = Net::HTTP::Post.new(addr)
+    req['Authorization'] = "Bearer #{cfg[:api_key]}"
+    req.body = buf
+    req['X-User-Id'] = usr[:id].to_s
+
+    res = Net::HTTP.start(addr.host, addr.port) { |http| http.request(req) }
+    msg = JSON.parse(res.body)
+
+    { ok: res.is_a?(Net::HTTPSuccess), data: msg }
+  end
+
+  private
+
+  def build_req(cfg, usr)
+    { path: '/requests', body: JSON.dump({ user_id: usr[:id] }), headers: auth_headers(cfg) }
+  end
+
+  def auth_headers(cfg) = { 'Authorization' => "Bearer #{cfg[:api_key]}" }
+  def extract_err_msg(msg) = msg['error'] || 'Unknown error'
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/config.yml b/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/config.yml
new file mode 100644
index 0000000..c498d18
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/config.yml
@@ -0,0 +1 @@
+doc: "Abbreviated names (`usr`, `cfg`, `mgr`) reduce readability."
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/good/api_client.ex b/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/good/api_client.ex
new file mode 100644
index 0000000..ed4603e
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/good/api_client.ex
@@ -0,0 +1,88 @@
+defmodule ApiClient.Good do
+  @moduledoc """
+  HTTP API client using descriptive variable names.
+  GOOD: variables like user, config, request, response, address, message are clear.
+  """
+
+  @spec send_request(map(), map()) :: {:ok, map()} | {:error, String.t()}
+  def send_request(config, user) do
+    request = build_request(config, user)
+    url = config.base_url <> request.path
+
+    case HTTPoison.post(url, request.body, request.headers) do
+      {:ok, response} ->
+        message = parse_response(response)
+        {:ok, message}
+
+      {:error, error} ->
+        {:error, "Request failed: #{inspect(error)}"}
+    end
+  end
+
+  @spec fetch_product(map(), String.t()) :: {:ok, map()} | {:error, String.t()}
+  def fetch_product(config, product_id) do
+    url = "#{config.base_url}/products/#{product_id}"
+    headers = auth_headers(config)
+
+    case HTTPoison.get(url, headers) do
+      {:ok, response} when response.status_code == 200 ->
+        product = Jason.decode!(response.body)
+        {:ok, product}
+
+      {:ok, response} ->
+        message = "Unexpected status: #{response.status_code}"
+        {:error, message}
+
+      {:error, error} ->
+        {:error, inspect(error)}
+    end
+  end
+
+  @spec create_order(map(), map(), integer()) :: {:ok, map()} | {:error, String.t()}
+  def create_order(config, user, quantity) do
+    url = "#{config.base_url}/orders"
+    body = Jason.encode!(%{user_id: user.id, quantity: quantity})
+    headers = auth_headers(config) ++ [{"Content-Type", "application/json"}]
+
+    case HTTPoison.post(url, body, headers) do
+      {:ok, response} when response.status_code in [200, 201] ->
+        {:ok, Jason.decode!(response.body)}
+
+      {:ok, response} ->
+        message = extract_error_message(response)
+        {:error, message}
+
+      {:error, error} ->
+        {:error, inspect(error)}
+    end
+  end
+
+  @spec paginate(map(), map()) :: {:ok, list()} | {:error, String.t()}
+  def paginate(config, params) do
+    url = "#{config.base_url}/items"
+    headers = auth_headers(config)
+
+    case HTTPoison.get(url, headers, params: params) do
+      {:ok, response} ->
+        {:ok, Jason.decode!(response.body)}
+
+      {:error, error} ->
+        {:error, inspect(error)}
+    end
+  end
+
+  defp build_request(config, user) do
+    %{
+      path: "/requests",
+      body: Jason.encode!(%{user_id: user.id}),
+      headers: auth_headers(config)
+    }
+  end
+
+  defp auth_headers(config) do
+    [{"Authorization", "Bearer #{config.api_key}"}]
+  end
+
+  defp parse_response(response), do: Jason.decode!(response.body)
+  defp extract_error_message(response), do: "Error #{response.status_code}: #{response.body}"
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/good/api_client.js b/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/good/api_client.js
new file mode 100644
index 0000000..44905b0
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/good/api_client.js
@@ -0,0 +1,98 @@
+// HTTP API client using descriptive variable names.
+// GOOD: variables like user, config, request, response, address, message are clear.
+
+async function sendRequest(config, user) {
+  const request = buildRequest(config, user);
+  const url = config.baseUrl + request.path;
+
+  try {
+    const response = await fetch(url, {
+      method: request.method,
+      headers: request.headers,
+      body: request.body,
+    });
+
+    const message = await response.json();
+    return { ok: true, data: message };
+  } catch (error) {
+    return { ok: false, error: `Request failed: ${error.message}` };
+  }
+}
+
+async function fetchProduct(config, productId) {
+  const url = `${config.baseUrl}/products/${productId}`;
+  const headers = authHeaders(config);
+
+  try {
+    const response = await fetch(url, { headers });
+
+    if (!response.ok) {
+      const message = `Unexpected status: ${response.status}`;
+      return { ok: false, error: message };
+    }
+
+    const product = await response.json();
+    return { ok: true, data: product };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+
+async function createOrder(config, user, quantity) {
+  const url = `${config.baseUrl}/orders`;
+  const request = {
+    method: 'POST',
+    headers: { ...authHeaders(config), 'Content-Type': 'application/json' },
+    body: JSON.stringify({ userId: user.id, quantity }),
+  };
+
+  try {
+    const response = await fetch(url, request);
+    const message = await response.json();
+
+    if (!response.ok) return { ok: false, error: extractErrorMessage(message) };
+
+    return { ok: true, data: message };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+
+async function paginate(config, params) {
+  const queryString = new URLSearchParams(params).toString();
+  const url = `${config.baseUrl}/items?${queryString}`;
+  const headers = authHeaders(config);
+
+  try {
+    const response = await fetch(url, { headers });
+    const data = await response.json();
+    return { ok: true, data };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+
+async function uploadFile(config, user, buffer) {
+  const url = `${config.baseUrl}/uploads`;
+  const form = new FormData();
+  form.append('file', buffer);
+  form.append('userId', user.id);
+
+  const response = await fetch(url, { method: 'POST', headers: authHeaders(config), body: form });
+  const message = await response.json();
+  return { ok: response.ok, data: message };
+}
+
+function buildRequest(config, user) {
+  return { method: 'POST', path: '/requests', body: JSON.stringify({ userId: user.id }), headers: authHeaders(config) };
+}
+
+function authHeaders(config) {
+  return { Authorization: `Bearer ${config.apiKey}` };
+}
+
+function extractErrorMessage(message) {
+  return message.error || 'Unknown error';
+}
+
+module.exports = { sendRequest, fetchProduct, createOrder, paginate, uploadFile };
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/good/api_client.rb b/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/good/api_client.rb
new file mode 100644
index 0000000..3435d46
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_abbreviation/good/api_client.rb
@@ -0,0 +1,91 @@
+# HTTP API client using descriptive variable names.
+# GOOD: variables like user, config, request, response, address, message are clear.
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+class ApiClientGood
+  def send_request(config, user)
+    request_data = build_request(config, user)
+    address = URI("#{config[:base_url]}#{request_data[:path]}")
+
+    response = Net::HTTP.post(address, request_data[:body], request_data[:headers])
+    message = JSON.parse(response.body)
+
+    { ok: response.is_a?(Net::HTTPSuccess), data: message }
+  rescue => error
+    { ok: false, error: "Request failed: #{error.message}" }
+  end
+
+  def fetch_product(config, product_id)
+    address = URI("#{config[:base_url]}/products/#{product_id}")
+    request = Net::HTTP::Get.new(address)
+    request['Authorization'] = "Bearer #{config[:api_key]}"
+
+    response = Net::HTTP.start(address.host, address.port) { |http| http.request(request) }
+
+    unless response.is_a?(Net::HTTPSuccess)
+      message = "Unexpected status: #{response.code}"
+      return { ok: false, error: message }
+    end
+
+    product = JSON.parse(response.body)
+    { ok: true, data: product }
+  rescue => error
+    { ok: false, error: error.message }
+  end
+
+  def create_order(config, user, quantity)
+    address = URI("#{config[:base_url]}/orders")
+    request = Net::HTTP::Post.new(address)
+    request['Authorization'] = "Bearer #{config[:api_key]}"
+    request['Content-Type'] = 'application/json'
+    request.body = JSON.dump({ user_id: user[:id], quantity: quantity })
+
+    response = Net::HTTP.start(address.host, address.port) { |http| http.request(request) }
+    message = JSON.parse(response.body)
+
+    return { ok: false, error: extract_error_message(message) } unless response.is_a?(Net::HTTPSuccess)
+
+    { ok: true, data: message }
+  rescue => error
+    { ok: false, error: error.message }
+  end
+
+  def paginate(config, params)
+    query_string = URI.encode_www_form(params)
+    address = URI("#{config[:base_url]}/items?#{query_string}")
+    request = Net::HTTP::Get.new(address)
+    request['Authorization'] = "Bearer #{config[:api_key]}"
+
+    response = Net::HTTP.start(address.host, address.port) { |http| http.request(request) }
+    data = JSON.parse(response.body)
+
+    { ok: response.is_a?(Net::HTTPSuccess), data: data }
+  rescue => error
+    { ok: false, error: error.message }
+  end
+
+  def upload_file(config, user, buffer)
+    address = URI("#{config[:base_url]}/uploads")
+    request = Net::HTTP::Post.new(address)
+    request['Authorization'] = "Bearer #{config[:api_key]}"
+    request.body = buffer
+    request['X-User-Id'] = user[:id].to_s
+
+    response = Net::HTTP.start(address.host, address.port) { |http| http.request(request) }
+    message = JSON.parse(response.body)
+
+    { ok: response.is_a?(Net::HTTPSuccess), data: message }
+  end
+
+  private
+
+  def build_request(config, user)
+    { path: '/requests', body: JSON.dump({ user_id: user[:id] }), headers: auth_headers(config) }
+  end
+
+  def auth_headers(config) = { 'Authorization' => "Bearer #{config[:api_key]}" }
+  def extract_error_message(message) = message['error'] || 'Unknown error'
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_generic/bad/orders.ex b/priv/combined_metrics/samples/variable_naming/name_is_generic/bad/orders.ex
new file mode 100644
index 0000000..90381e2
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_generic/bad/orders.ex
@@ -0,0 +1,96 @@
+defmodule OrderProcessor do
+  def process(data) do
+    result = Enum.reduce(data, [], fn item, acc ->
+      val = item.price * item.quantity
+      tmp = %{id: item.id, total: val, status: item.status}
+
+      obj =
+        if val > 100 do
+          x = apply_discount(tmp, 0.1)
+          y = add_tax(x, 0.2)
+          y
+        else
+          z = add_tax(tmp, 0.2)
+          z
+        end
+
+      [obj | acc]
+    end)
+
+    Enum.reverse(result)
+  end
+
+  def apply_discount(obj, val) do
+    tmp = obj.total * (1 - val)
+    Map.put(obj, :total, tmp)
+  end
+
+  def add_tax(obj, val) do
+    tmp = obj.total * (1 + val)
+    Map.put(obj, :total, tmp)
+  end
+
+  def filter(data, val) do
+    Enum.filter(data, fn item ->
+      item.total > val
+    end)
+  end
+
+  def summarize(data) do
+    result = Enum.map(data, fn item ->
+      tmp = Float.round(item.total, 2)
+      obj = %{id: item.id, total: tmp, status: item.status}
+      obj
+    end)
+
+    info = Enum.reduce(result, 0.0, fn item, acc ->
+      acc + item.total
+    end)
+
+    %{items: result, sum: info}
+  end
+
+  def group(data, val) do
+    Enum.group_by(data, fn item ->
+      if item.total > val, do: :high, else: :low
+    end)
+  end
+
+  def validate(data) do
+    Enum.filter(data, fn item ->
+      result = item.price > 0 && item.quantity > 0 && item.status != nil
+      result
+    end)
+  end
+
+  def enrich(data, obj) do
+    Enum.map(data, fn item ->
+      tmp = Map.get(obj, item.id, %{})
+      val = Map.merge(item, tmp)
+      val
+    end)
+  end
+
+  def format_output(data) do
+    result = Enum.map(data, fn item ->
+      tmp = %{
+        id: item.id,
+        total: "$#{:erlang.float_to_binary(item.total / 1, decimals: 2)}",
+        status: String.upcase(to_string(item.status))
+      }
+      tmp
+    end)
+    result
+  end
+
+  def sort(data, val) do
+    Enum.sort_by(data, fn item -> item[val] end)
+  end
+
+  def paginate(data, obj) do
+    info = obj[:page] || 1
+    tmp = obj[:per_page] || 10
+    val = (info - 1) * tmp
+    Enum.slice(data, val, tmp)
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_generic/bad/orders.js b/priv/combined_metrics/samples/variable_naming/name_is_generic/bad/orders.js
new file mode 100644
index 0000000..cfe338e
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_generic/bad/orders.js
@@ -0,0 +1,94 @@
+class OrderProcessor {
+  process(data) {
+    const result = data.reduce((acc, item) => {
+      const val = item.price * item.quantity;
+      const tmp = { id: item.id, total: val, status: item.status };
+
+      let obj;
+      if (val > 100) {
+        const x = this.applyDiscount(tmp, 0.1);
+        obj = this.addTax(x, 0.2);
+      } else {
+        obj = this.addTax(tmp, 0.2);
+      }
+
+      acc.push(obj);
+      return acc;
+    }, []);
+
+    return result;
+  }
+
+  applyDiscount(obj, val) {
+    const tmp = obj.total * (1 - val);
+    return { ...obj, total: tmp };
+  }
+
+  addTax(obj, val) {
+    const tmp = obj.total * (1 + val);
+    return { ...obj, total: tmp };
+  }
+
+  filter(data, val) {
+    return data.filter(item => item.total > val);
+  }
+
+  summarize(data) {
+    const result = data.map(item => {
+      const tmp = Math.round(item.total * 100) / 100;
+      return { id: item.id, total: tmp, status: item.status };
+    });
+
+    const info = result.reduce((acc, item) => acc + item.total, 0);
+
+    return { items: result, sum: info };
+  }
+
+  group(data, val) {
+    return data.reduce((acc, item) => {
+      const key = item.total > val ? 'high' : 'low';
+      if (!acc[key]) acc[key] = [];
+      acc[key].push(item);
+      return acc;
+    }, {});
+  }
+
+  validate(data) {
+    return data.filter(item => {
+      const result = item.price > 0 && item.quantity > 0 && item.status != null;
+      return result;
+    });
+  }
+
+  enrich(data, obj) {
+    return data.map(item => {
+      const tmp = obj[item.id] || {};
+      const val = { ...item, ...tmp };
+      return val;
+    });
+  }
+
+  formatOutput(data) {
+    return data.map(item => {
+      const tmp = {
+        id: item.id,
+        total: `$${item.total.toFixed(2)}`,
+        status: item.status.toUpperCase()
+      };
+      return tmp;
+    });
+  }
+
+  sort(data, val) {
+    return [...data].sort((a, b) => a[val] - b[val]);
+  }
+
+  paginate(data, obj) {
+    const info = obj.page || 1;
+    const tmp = obj.perPage || 10;
+    const val = (info - 1) * tmp;
+    return data.slice(val, val + tmp);
+  }
+}
+
+module.exports = OrderProcessor;
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_generic/bad/orders.rb b/priv/combined_metrics/samples/variable_naming/name_is_generic/bad/orders.rb
new file mode 100644
index 0000000..c7bea45
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_generic/bad/orders.rb
@@ -0,0 +1,87 @@
+class OrderProcessor
+  def process(data)
+    result = data.reduce([]) do |acc, item|
+      val = item[:price] * item[:quantity]
+      tmp = { id: item[:id], total: val, status: item[:status] }
+
+      obj = if val > 100
+        x = apply_discount(tmp, 0.1)
+        add_tax(x, 0.2)
+      else
+        add_tax(tmp, 0.2)
+      end
+
+      acc + [obj]
+    end
+
+    result
+  end
+
+  def apply_discount(obj, val)
+    tmp = obj[:total] * (1 - val)
+    obj.merge(total: tmp)
+  end
+
+  def add_tax(obj, val)
+    tmp = obj[:total] * (1 + val)
+    obj.merge(total: tmp)
+  end
+
+  def filter(data, val)
+    data.select { |item| item[:total] > val }
+  end
+
+  def summarize(data)
+    result = data.map do |item|
+      tmp = item[:total].round(2)
+      { id: item[:id], total: tmp, status: item[:status] }
+    end
+
+    info = result.reduce(0.0) { |acc, item| acc + item[:total] }
+
+    { items: result, sum: info }
+  end
+
+  def group(data, val)
+    data.group_by do |item|
+      item[:total] > val ? :high : :low
+    end
+  end
+
+  def validate(data)
+    data.select do |item|
+      result = item[:price] > 0 && item[:quantity] > 0 && !item[:status].nil?
+      result
+    end
+  end
+
+  def enrich(data, obj)
+    data.map do |item|
+      tmp = obj[item[:id]] || {}
+      val = item.merge(tmp)
+      val
+    end
+  end
+
+  def format_output(data)
+    data.map do |item|
+      tmp = {
+        id: item[:id],
+        total: "$#{format('%.2f', item[:total])}",
+        status: item[:status].to_s.upcase
+      }
+      tmp
+    end
+  end
+
+  def sort(data, val)
+    data.sort_by { |item| item[val] }
+  end
+
+  def paginate(data, obj)
+    info = obj[:page] || 1
+    tmp = obj[:per_page] || 10
+    val = (info - 1) * tmp
+    data[val, tmp] || []
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_generic/config.yml b/priv/combined_metrics/samples/variable_naming/name_is_generic/config.yml
new file mode 100644
index 0000000..51e0490
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_generic/config.yml
@@ -0,0 +1 @@
+doc: "Generic names (`data`, `result`, `tmp`, `val`, `obj`) convey no domain meaning."
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_generic/good/orders.ex b/priv/combined_metrics/samples/variable_naming/name_is_generic/good/orders.ex
new file mode 100644
index 0000000..66a3d50
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_generic/good/orders.ex
@@ -0,0 +1,122 @@
+defmodule OrderProcessor do
+  @tax_rate 0.2
+  @discount_rate 0.1
+  @discount_threshold 100
+
+  def calculate_order_totals(orders) do
+    orders
+    |> Enum.map(&process_single_order/1)
+  end
+
+  defp process_single_order(order) do
+    order
+    |> build_order_summary()
+    |> maybe_apply_discount()
+    |> add_tax(@tax_rate)
+  end
+
+  defp build_order_summary(order) do
+    %{id: order.id, total: order.price * order.quantity, status: order.status}
+  end
+
+  defp maybe_apply_discount(order_summary) do
+    if order_summary.total > @discount_threshold do
+      apply_discount(order_summary, @discount_rate)
+    else
+      order_summary
+    end
+  end
+
+  def apply_discount(order, discount_rate) do
+    order
+    |> then(fn o -> o.total * (1 - discount_rate) end)
+    |> then(fn discounted_total -> Map.put(order, :total, discounted_total) end)
+  end
+
+  def add_tax(order, tax_rate) do
+    order
+    |> then(fn o -> o.total * (1 + tax_rate) end)
+    |> then(fn taxed_total -> Map.put(order, :total, taxed_total) end)
+  end
+
+  def filter_by_minimum_total(orders, minimum_total) do
+    orders
+    |> Enum.filter(&(&1.total > minimum_total))
+  end
+
+  def summarize_orders(orders) do
+    rounded_items =
+      orders
+      |> Enum.map(&round_order_total/1)
+
+    grand_total =
+      rounded_items
+      |> Enum.reduce(0.0, fn item, acc -> acc + item.total end)
+
+    %{items: rounded_items, grand_total: grand_total}
+  end
+
+  defp round_order_total(order) do
+    order
+    |> then(fn o -> Float.round(o.total, 2) end)
+    |> then(fn rounded_total -> %{id: order.id, total: rounded_total, status: order.status} end)
+  end
+
+  def group_by_total_threshold(orders, threshold) do
+    orders
+    |> Enum.group_by(&total_threshold_key(&1, threshold))
+  end
+
+  defp total_threshold_key(order, threshold), do: if(order.total > threshold, do: :high_value, else: :low_value)
+
+  def validate_orders(orders) do
+    orders
+    |> Enum.filter(&order_valid?/1)
+  end
+
+  defp order_valid?(order) do
+    order.price > 0 and order.quantity > 0 and order.status != nil
+  end
+
+  def enrich_with_customer_data(orders, customer_map) do
+    orders
+    |> Enum.map(&merge_customer_data(&1, customer_map))
+  end
+
+  defp merge_customer_data(order, customer_map) do
+    order
+    |> then(fn o -> Map.get(customer_map, o.id, %{}) end)
+    |> then(fn customer_data -> Map.merge(order, customer_data) end)
+  end
+
+  def format_orders_for_display(orders) do
+    orders
+    |> Enum.map(&format_single_order/1)
+  end
+
+  defp format_single_order(order) do
+    total_display =
+      order.total
+      |> Kernel./(1)
+      |> :erlang.float_to_binary(decimals: 2)
+      |> then(&"$#{&1}")
+
+    status_display = order.status |> to_string() |> String.upcase()
+
+    %{id: order.id, total: total_display, status: status_display}
+  end
+
+  def sort_orders_by_field(orders, sort_field) do
+    orders
+    |> Enum.sort_by(& &1[sort_field])
+  end
+
+  def paginate_orders(orders, pagination_opts) do
+    page = pagination_opts[:page] || 1
+    per_page = pagination_opts[:per_page] || 10
+    offset = (page - 1) * per_page
+
+    orders
+    |> Enum.slice(offset, per_page)
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_generic/good/orders.js b/priv/combined_metrics/samples/variable_naming/name_is_generic/good/orders.js
new file mode 100644
index 0000000..e260c2b
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_generic/good/orders.js
@@ -0,0 +1,96 @@
+class OrderProcessor {
+  calculateOrderTotals(orders) {
+    const processedOrders = orders.reduce((accumulator, order) => {
+      const orderSubtotal = order.price * order.quantity;
+      const orderSummary = { id: order.id, total: orderSubtotal, status: order.status };
+
+      let finalizedOrder;
+      if (orderSubtotal > 100) {
+        const discountedOrder = this.applyDiscount(orderSummary, 0.1);
+        finalizedOrder = this.addTax(discountedOrder, 0.2);
+      } else {
+        finalizedOrder = this.addTax(orderSummary, 0.2);
+      }
+
+      accumulator.push(finalizedOrder);
+      return accumulator;
+    }, []);
+
+    return processedOrders;
+  }
+
+  applyDiscount(order, discountRate) {
+    const discountedTotal = order.total * (1 - discountRate);
+    return { ...order, total: discountedTotal };
+  }
+
+  addTax(order, taxRate) {
+    const taxedTotal = order.total * (1 + taxRate);
+    return { ...order, total: taxedTotal };
+  }
+
+  filterByMinimumTotal(orders, minimumTotal) {
+    return orders.filter(order => order.total > minimumTotal);
+  }
+
+  summarizeOrders(orders) {
+    const roundedOrders = orders.map(order => {
+      const roundedTotal = Math.round(order.total * 100) / 100;
+      return { id: order.id, total: roundedTotal, status: order.status };
+    });
+
+    const grandTotal = roundedOrders.reduce((runningTotal, order) => runningTotal + order.total, 0);
+
+    return { items: roundedOrders, grandTotal };
+  }
+
+  groupByTotalThreshold(orders, threshold) {
+    return orders.reduce((groupedOrders, order) => {
+      const groupKey = order.total > threshold ? 'highValue' : 'lowValue';
+      if (!groupedOrders[groupKey]) groupedOrders[groupKey] = [];
+      groupedOrders[groupKey].push(order);
+      return groupedOrders;
+    }, {});
+  }
+
+  validateOrders(orders) {
+    return orders.filter(order => {
+      const hasPositivePrice = order.price > 0;
+      const hasPositiveQuantity = order.quantity > 0;
+      const hasStatus = order.status != null;
+      return hasPositivePrice && hasPositiveQuantity && hasStatus;
+    });
+  }
+
+  enrichWithCustomerData(orders, customerMap) {
+    return orders.map(order => {
+      const customerData = customerMap[order.id] || {};
+      const enrichedOrder = { ...order, ...customerData };
+      return enrichedOrder;
+    });
+  }
+
+  formatOrdersForDisplay(orders) {
+    return orders.map(order => {
+      const formattedOrder = {
+        id: order.id,
+        total: `$${order.total.toFixed(2)}`,
+        status: order.status.toUpperCase()
+      };
+      return formattedOrder;
+    });
+  }
+
+  sortOrdersByField(orders, sortField) {
+    return [...orders].sort((orderA, orderB) => orderA[sortField] - orderB[sortField]);
+  }
+
+  paginateOrders(orders, paginationOpts) {
+    const currentPage = paginationOpts.page || 1;
+    const ordersPerPage = paginationOpts.perPage || 10;
+    const offset = (currentPage - 1) * ordersPerPage;
+    return orders.slice(offset, offset + ordersPerPage);
+  }
+}
+
+module.exports = OrderProcessor;
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_generic/good/orders.rb b/priv/combined_metrics/samples/variable_naming/name_is_generic/good/orders.rb
new file mode 100644
index 0000000..9706846
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_generic/good/orders.rb
@@ -0,0 +1,89 @@
+class OrderProcessor
+  def calculate_order_totals(orders)
+    processed_orders = orders.reduce([]) do |finalized_orders, order|
+      order_subtotal = order[:price] * order[:quantity]
+      order_summary = { id: order[:id], total: order_subtotal, status: order[:status] }
+
+      finalized_order = if order_subtotal > 100
+        discounted_order = apply_discount(order_summary, 0.1)
+        add_tax(discounted_order, 0.2)
+      else
+        add_tax(order_summary, 0.2)
+      end
+
+      finalized_orders + [finalized_order]
+    end
+
+    processed_orders
+  end
+
+  def apply_discount(order, discount_rate)
+    discounted_total = order[:total] * (1 - discount_rate)
+    order.merge(total: discounted_total)
+  end
+
+  def add_tax(order, tax_rate)
+    taxed_total = order[:total] * (1 + tax_rate)
+    order.merge(total: taxed_total)
+  end
+
+  def filter_by_minimum_total(orders, minimum_total)
+    orders.select { |order| order[:total] > minimum_total }
+  end
+
+  def summarize_orders(orders)
+    rounded_orders = orders.map do |order|
+      rounded_total = order[:total].round(2)
+      { id: order[:id], total: rounded_total, status: order[:status] }
+    end
+
+    grand_total = rounded_orders.reduce(0.0) { |running_total, order| running_total + order[:total] }
+
+    { items: rounded_orders, grand_total: grand_total }
+  end
+
+  def group_by_total_threshold(orders, threshold)
+    orders.group_by do |order|
+      order[:total] > threshold ? :high_value : :low_value
+    end
+  end
+
+  def validate_orders(orders)
+    orders.select do |order|
+      has_positive_price = order[:price] > 0
+      has_positive_quantity = order[:quantity] > 0
+      has_status = !order[:status].nil?
+      has_positive_price && has_positive_quantity && has_status
+    end
+  end
+
+  def enrich_with_customer_data(orders, customer_map)
+    orders.map do |order|
+      customer_data = customer_map[order[:id]] || {}
+      enriched_order = order.merge(customer_data)
+      enriched_order
+    end
+  end
+
+  def format_orders_for_display(orders)
+    orders.map do |order|
+      formatted_order = {
+        id: order[:id],
+        total: "$#{format('%.2f', order[:total])}",
+        status: order[:status].to_s.upcase
+      }
+      formatted_order
+    end
+  end
+
+  def sort_orders_by_field(orders, sort_field)
+    orders.sort_by { |order| order[sort_field] }
+  end
+
+  def paginate_orders(orders, pagination_opts)
+    current_page = pagination_opts[:page] || 1
+    orders_per_page = pagination_opts[:per_page] || 10
+    offset = (current_page - 1) * orders_per_page
+    orders[offset, orders_per_page] || []
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_number_like/bad/pipeline.ex b/priv/combined_metrics/samples/variable_naming/name_is_number_like/bad/pipeline.ex
new file mode 100644
index 0000000..2d62e9a
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_number_like/bad/pipeline.ex
@@ -0,0 +1,86 @@
+defmodule Pipeline.Bad do
+  @moduledoc """
+  Data pipeline with number-suffixed variable names.
+  BAD: variables like var1, user2, item3, step2 give no hint about their purpose.
+  """
+
+  @spec run(map()) :: {:ok, map()} | {:error, String.t()}
+  def run(input) do
+    var1 = validate(input)
+    var2 = normalize(var1)
+    var3 = enrich(var2)
+    var4 = transform(var3)
+    var5 = format_output(var4)
+    {:ok, var5}
+  rescue
+    e -> {:error, Exception.message(e)}
+  end
+
+  @spec process_users(list()) :: list()
+  def process_users(users) do
+    user1 = filter_active(users)
+    user2 = load_profiles(user1)
+    user3 = apply_permissions(user2)
+    user4 = sort_users(user3)
+    user4
+  end
+
+  @spec deduplicate(list()) :: list()
+  def deduplicate(items) do
+    item1 = Enum.sort(items)
+    item2 = Enum.dedup(item1)
+    item3 = Enum.reject(item2, &is_nil/1)
+    item3
+  end
+
+  @spec retry(function(), integer()) :: {:ok, any()} | {:error, String.t()}
+  def retry(func, max_attempts) do
+    result1 = attempt(func)
+
+    if success?(result1) do
+      result1
+    else
+      result2 = attempt(func)
+      if success?(result2) do
+        result2
+      else
+        result3 = attempt(func)
+        if success?(result3), do: result3, else: {:error, "All retries failed"}
+      end
+    end
+  end
+
+  @spec merge_records(map(), map()) :: map()
+  def merge_records(record1, record2) do
+    step1 = Map.merge(record1, record2)
+    step2 = clean_nulls(step1)
+    step3 = add_metadata(step2)
+    phase1 = validate_merged(step3)
+    phase1
+  end
+
+  @spec batch_process(list(), integer()) :: list()
+  def batch_process(items, size) do
+    value1 = Enum.chunk_every(items, size)
+    value2 = Enum.map(value1, &process_batch/1)
+    value3 = List.flatten(value2)
+    value3
+  end
+
+  defp validate(input), do: input
+  defp normalize(data), do: data
+  defp enrich(data), do: data
+  defp transform(data), do: data
+  defp format_output(data), do: data
+  defp filter_active(users), do: Enum.filter(users, & &1.active)
+  defp load_profiles(users), do: users
+  defp apply_permissions(users), do: users
+  defp sort_users(users), do: Enum.sort_by(users, & &1.name)
+  defp attempt(func), do: func.()
+  defp success?({:ok, _}), do: true
+  defp success?(_), do: false
+  defp clean_nulls(map), do: Map.reject(map, fn {_, v} -> is_nil(v) end)
+  defp add_metadata(map), do: Map.put(map, :processed_at, DateTime.utc_now())
+  defp validate_merged(map), do: map
+  defp process_batch(batch), do: batch
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_number_like/bad/pipeline.js b/priv/combined_metrics/samples/variable_naming/name_is_number_like/bad/pipeline.js
new file mode 100644
index 0000000..64a32cc
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_number_like/bad/pipeline.js
@@ -0,0 +1,84 @@
+// Data pipeline with number-suffixed variable names.
+// BAD: variables like var1, user2, item3, step2 give no hint about their purpose.
+
+async function run(input) {
+  try {
+    const var1 = validate(input);
+    const var2 = normalize(var1);
+    const var3 = await enrich(var2);
+    const var4 = transform(var3);
+    const var5 = formatOutput(var4);
+    return { ok: true, data: var5 };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+function processUsers(users) {
+  const user1 = filterActive(users);
+  const user2 = loadProfiles(user1);
+  const user3 = applyPermissions(user2);
+  const user4 = sortUsers(user3);
+  return user4;
+}
+
+function deduplicate(items) {
+  const item1 = [...items].sort();
+  const item2 = [...new Set(item1)];
+  const item3 = item2.filter(x => x != null);
+  return item3;
+}
+
+async function retry(func, maxAttempts) {
+  const result1 = await attempt(func);
+  if (result1.ok) return result1;
+
+  const result2 = await attempt(func);
+  if (result2.ok) return result2;
+
+  const result3 = await attempt(func);
+  if (result3.ok) return result3;
+
+  return { ok: false, error: 'All retries failed' };
+}
+
+function mergeRecords(record1, record2) {
+  const step1 = { ...record1, ...record2 };
+  const step2 = cleanNulls(step1);
+  const step3 = addMetadata(step2);
+  const phase1 = validateMerged(step3);
+  return phase1;
+}
+
+function batchProcess(items, size) {
+  const value1 = chunkArray(items, size);
+  const value2 = value1.map(processBatch);
+  const value3 = value2.flat();
+  return value3;
+}
+
+function buildPipeline(stage1, stage2, stage3) {
+  return function (thing1) {
+    const thing2 = stage1(thing1);
+    const thing3 = stage2(thing2);
+    return stage3(thing3);
+  };
+}
+
+function validate(input) { return input; }
+function normalize(data) { return data; }
+async function enrich(data) { return data; }
+function transform(data) { return data; }
+function formatOutput(data) { return data; }
+function filterActive(users) { return users.filter(u => u.active); }
+function loadProfiles(users) { return users; }
+function applyPermissions(users) { return users; }
+function sortUsers(users) { return users.sort((a, b) => a.name.localeCompare(b.name)); }
+async function attempt(func) { try { return { ok: true, data: await func() }; } catch (e) { return { ok: false }; } }
+function cleanNulls(obj) { return Object.fromEntries(Object.entries(obj).filter(([, v]) => v != null)); }
+function addMetadata(obj) { return { ...obj, processedAt: new Date() }; }
+function validateMerged(obj) { return obj; }
+function processBatch(batch) { return batch; }
+function chunkArray(arr, size) { const chunks = []; for (let i = 0; i < arr.length; i += size) chunks.push(arr.slice(i, i + size)); return chunks; }
+
+module.exports = { run, processUsers, deduplicate, retry, mergeRecords, batchProcess, buildPipeline };
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_number_like/bad/pipeline.rb b/priv/combined_metrics/samples/variable_naming/name_is_number_like/bad/pipeline.rb
new file mode 100644
index 0000000..55ffc54
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_number_like/bad/pipeline.rb
@@ -0,0 +1,87 @@
+# Data pipeline with number-suffixed variable names.
+# BAD: variables like var1, user2, item3, step2 give no hint about their purpose.
+
+class PipelineBad
+  def run(input)
+    var1 = validate(input)
+    var2 = normalize(var1)
+    var3 = enrich(var2)
+    var4 = transform(var3)
+    var5 = format_output(var4)
+    { ok: true, data: var5 }
+  rescue => e
+    { ok: false, error: e.message }
+  end
+
+  def process_users(users)
+    user1 = filter_active(users)
+    user2 = load_profiles(user1)
+    user3 = apply_permissions(user2)
+    user4 = sort_users(user3)
+    user4
+  end
+
+  def deduplicate(items)
+    item1 = items.sort
+    item2 = item1.uniq
+    item3 = item2.compact
+    item3
+  end
+
+  def retry_operation(func, max_attempts)
+    result1 = attempt(func)
+    return result1 if result1[:ok]
+
+    result2 = attempt(func)
+    return result2 if result2[:ok]
+
+    result3 = attempt(func)
+    return result3 if result3[:ok]
+
+    { ok: false, error: 'All retries failed' }
+  end
+
+  def merge_records(record1, record2)
+    step1 = record1.merge(record2)
+    step2 = clean_nulls(step1)
+    step3 = add_metadata(step2)
+    phase1 = validate_merged(step3)
+    phase1
+  end
+
+  def batch_process(items, size)
+    value1 = items.each_slice(size).to_a
+    value2 = value1.map { |batch| process_batch(batch) }
+    value3 = value2.flatten(1)
+    value3
+  end
+
+  def build_pipeline(stage1, stage2, stage3)
+    lambda do |thing1|
+      thing2 = stage1.call(thing1)
+      thing3 = stage2.call(thing2)
+      stage3.call(thing3)
+    end
+  end
+
+  private
+
+  def validate(input) = input
+  def normalize(data) = data
+  def enrich(data) = data
+  def transform(data) = data
+  def format_output(data) = data
+  def filter_active(users) = users.select { |u| u[:active] }
+  def load_profiles(users) = users
+  def apply_permissions(users) = users
+  def sort_users(users) = users.sort_by { |u| u[:name] }
+  def attempt(func)
+    { ok: true, data: func.call }
+  rescue
+    { ok: false }
+  end
+  def clean_nulls(hash) = hash.compact
+  def add_metadata(hash) = hash.merge(processed_at: Time.now)
+  def validate_merged(hash) = hash
+  def process_batch(batch) = batch
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_number_like/config.yml b/priv/combined_metrics/samples/variable_naming/name_is_number_like/config.yml
new file mode 100644
index 0000000..14a76b6
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_number_like/config.yml
@@ -0,0 +1 @@
+doc: "Number-suffixed names (`var1`, `thing2`) signal a missing abstraction."
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_number_like/good/pipeline.ex b/priv/combined_metrics/samples/variable_naming/name_is_number_like/good/pipeline.ex
new file mode 100644
index 0000000..5695ec5
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_number_like/good/pipeline.ex
@@ -0,0 +1,86 @@
+defmodule Pipeline.Good do
+  @moduledoc """
+  Data pipeline with meaningful variable names.
+  GOOD: variables like validated_input, normalized_data, enriched_record describe their state.
+  """
+
+  @spec run(map()) :: {:ok, map()} | {:error, String.t()}
+  def run(input) do
+    validated_input = validate(input)
+    normalized_data = normalize(validated_input)
+    enriched_record = enrich(normalized_data)
+    transformed_record = transform(enriched_record)
+    formatted_output = format_output(transformed_record)
+    {:ok, formatted_output}
+  rescue
+    e -> {:error, Exception.message(e)}
+  end
+
+  @spec process_users(list()) :: list()
+  def process_users(users) do
+    active_users = filter_active(users)
+    users_with_profiles = load_profiles(active_users)
+    authorized_users = apply_permissions(users_with_profiles)
+    sorted_users = sort_users(authorized_users)
+    sorted_users
+  end
+
+  @spec deduplicate(list()) :: list()
+  def deduplicate(items) do
+    sorted_items = Enum.sort(items)
+    unique_items = Enum.dedup(sorted_items)
+    present_items = Enum.reject(unique_items, &is_nil/1)
+    present_items
+  end
+
+  @spec retry(function(), integer()) :: {:ok, any()} | {:error, String.t()}
+  def retry(func, max_attempts) do
+    initial_result = attempt(func)
+
+    if success?(initial_result) do
+      initial_result
+    else
+      retry_result = attempt(func)
+      if success?(retry_result) do
+        retry_result
+      else
+        final_result = attempt(func)
+        if success?(final_result), do: final_result, else: {:error, "All retries failed"}
+      end
+    end
+  end
+
+  @spec merge_records(map(), map()) :: map()
+  def merge_records(primary_record, secondary_record) do
+    merged = Map.merge(primary_record, secondary_record)
+    cleaned = clean_nulls(merged)
+    with_metadata = add_metadata(cleaned)
+    validated_result = validate_merged(with_metadata)
+    validated_result
+  end
+
+  @spec batch_process(list(), integer()) :: list()
+  def batch_process(items, batch_size) do
+    batches = Enum.chunk_every(items, batch_size)
+    processed_batches = Enum.map(batches, &process_batch/1)
+    flattened_results = List.flatten(processed_batches)
+    flattened_results
+  end
+
+  defp validate(input), do: input
+  defp normalize(data), do: data
+  defp enrich(data), do: data
+  defp transform(data), do: data
+  defp format_output(data), do: data
+  defp filter_active(users), do: Enum.filter(users, & &1.active)
+  defp load_profiles(users), do: users
+  defp apply_permissions(users), do: users
+  defp sort_users(users), do: Enum.sort_by(users, & &1.name)
+  defp attempt(func), do: func.()
+  defp success?({:ok, _}), do: true
+  defp success?(_), do: false
+  defp clean_nulls(map), do: Map.reject(map, fn {_, v} -> is_nil(v) end)
+  defp add_metadata(map), do: Map.put(map, :processed_at, DateTime.utc_now())
+  defp validate_merged(map), do: map
+  defp process_batch(batch), do: batch
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_number_like/good/pipeline.js b/priv/combined_metrics/samples/variable_naming/name_is_number_like/good/pipeline.js
new file mode 100644
index 0000000..30bcbbf
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_number_like/good/pipeline.js
@@ -0,0 +1,84 @@
+// Data pipeline with meaningful variable names.
+// GOOD: variables like validatedInput, normalizedData, enrichedRecord describe their state.
+
+async function run(input) {
+  try {
+    const validatedInput = validate(input);
+    const normalizedData = normalize(validatedInput);
+    const enrichedRecord = await enrich(normalizedData);
+    const transformedRecord = transform(enrichedRecord);
+    const formattedOutput = formatOutput(transformedRecord);
+    return { ok: true, data: formattedOutput };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+
+function processUsers(users) {
+  const activeUsers = filterActive(users);
+  const usersWithProfiles = loadProfiles(activeUsers);
+  const authorizedUsers = applyPermissions(usersWithProfiles);
+  const sortedUsers = sortUsers(authorizedUsers);
+  return sortedUsers;
+}
+
+function deduplicate(items) {
+  const sortedItems = [...items].sort();
+  const uniqueItems = [...new Set(sortedItems)];
+  const presentItems = uniqueItems.filter(item => item != null);
+  return presentItems;
+}
+
+async function retry(func, maxAttempts) {
+  const initialResult = await attempt(func);
+  if (initialResult.ok) return initialResult;
+
+  const retryResult = await attempt(func);
+  if (retryResult.ok) return retryResult;
+
+  const finalResult = await attempt(func);
+  if (finalResult.ok) return finalResult;
+
+  return { ok: false, error: 'All retries failed' };
+}
+
+function mergeRecords(primaryRecord, secondaryRecord) {
+  const merged = { ...primaryRecord, ...secondaryRecord };
+  const cleaned = cleanNulls(merged);
+  const withMetadata = addMetadata(cleaned);
+  const validatedResult = validateMerged(withMetadata);
+  return validatedResult;
+}
+
+function batchProcess(items, batchSize) {
+  const batches = chunkArray(items, batchSize);
+  const processedBatches = batches.map(processBatch);
+  const flattenedResults = processedBatches.flat();
+  return flattenedResults;
+}
+
+function buildPipeline(firstStage, secondStage, thirdStage) {
+  return function (input) {
+    const afterFirst = firstStage(input);
+    const afterSecond = secondStage(afterFirst);
+    return thirdStage(afterSecond);
+  };
+}
+
+function validate(input) { return input; }
+function normalize(data) { return data; }
+async function enrich(data) { return data; }
+function transform(data) { return data; }
+function formatOutput(data) { return data; }
+function filterActive(users) { return users.filter(u => u.active); }
+function loadProfiles(users) { return users; }
+function applyPermissions(users) { return users; }
+function sortUsers(users) { return users.sort((a, b) => a.name.localeCompare(b.name)); }
+async function attempt(func) { try { return { ok: true, data: await func() }; } catch (e) { return { ok: false }; } }
+function cleanNulls(obj) { return Object.fromEntries(Object.entries(obj).filter(([, v]) => v != null)); }
+function addMetadata(obj) { return { ...obj, processedAt: new Date() }; }
+function validateMerged(obj) { return obj; }
+function processBatch(batch) { return batch; }
+function chunkArray(arr, size) { const chunks = []; for (let i = 0; i < arr.length; i += size) chunks.push(arr.slice(i, i + size)); return chunks; }
+
+module.exports = { run, processUsers, deduplicate, retry, mergeRecords, batchProcess, buildPipeline };
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_number_like/good/pipeline.rb b/priv/combined_metrics/samples/variable_naming/name_is_number_like/good/pipeline.rb
new file mode 100644
index 0000000..9e15969
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_number_like/good/pipeline.rb
@@ -0,0 +1,87 @@
+# Data pipeline with meaningful variable names.
+# GOOD: variables like validated_input, normalized_data, enriched_record describe their state.
+
+class PipelineGood
+  def run(input)
+    validated_input = validate(input)
+    normalized_data = normalize(validated_input)
+    enriched_record = enrich(normalized_data)
+    transformed_record = transform(enriched_record)
+    formatted_output = format_output(transformed_record)
+    { ok: true, data: formatted_output }
+  rescue => error
+    { ok: false, error: error.message }
+  end
+
+  def process_users(users)
+    active_users = filter_active(users)
+    users_with_profiles = load_profiles(active_users)
+    authorized_users = apply_permissions(users_with_profiles)
+    sorted_users = sort_users(authorized_users)
+    sorted_users
+  end
+
+  def deduplicate(items)
+    sorted_items = items.sort
+    unique_items = sorted_items.uniq
+    present_items = unique_items.compact
+    present_items
+  end
+
+  def retry_operation(func, max_attempts)
+    initial_result = attempt(func)
+    return initial_result if initial_result[:ok]
+
+    retry_result = attempt(func)
+    return retry_result if retry_result[:ok]
+
+    final_result = attempt(func)
+    return final_result if final_result[:ok]
+
+    { ok: false, error: 'All retries failed' }
+  end
+
+  def merge_records(primary_record, secondary_record)
+    merged = primary_record.merge(secondary_record)
+    cleaned = clean_nulls(merged)
+    with_metadata = add_metadata(cleaned)
+    validated_result = validate_merged(with_metadata)
+    validated_result
+  end
+
+  def batch_process(items, batch_size)
+    batches = items.each_slice(batch_size).to_a
+    processed_batches = batches.map { |batch| process_batch(batch) }
+    flattened_results = processed_batches.flatten(1)
+    flattened_results
+  end
+
+  def build_pipeline(first_stage, second_stage, third_stage)
+    lambda do |input|
+      after_first = first_stage.call(input)
+      after_second = second_stage.call(after_first)
+      third_stage.call(after_second)
+    end
+  end
+
+  private
+
+  def validate(input) = input
+  def normalize(data) = data
+  def enrich(data) = data
+  def transform(data) = data
+  def format_output(data) = data
+  def filter_active(users) = users.select { |u| u[:active] }
+  def load_profiles(users) = users
+  def apply_permissions(users) = users
+  def sort_users(users) = users.sort_by { |u| u[:name] }
+  def attempt(func)
+    { ok: true, data: func.call }
+  rescue
+    { ok: false }
+  end
+  def clean_nulls(hash) = hash.compact
+  def add_metadata(hash) = hash.merge(processed_at: Time.now)
+  def validate_merged(hash) = hash
+  def process_batch(batch) = batch
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_single_letter/bad/calculator.ex b/priv/combined_metrics/samples/variable_naming/name_is_single_letter/bad/calculator.ex
new file mode 100644
index 0000000..2afaf65
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_single_letter/bad/calculator.ex
@@ -0,0 +1,72 @@
+defmodule Calculator.Bad do
+  @moduledoc """
+  Pricing and discount calculator with single-letter variable names.
+  BAD: function params and local vars named x, y, z, a, b, n, m lose all meaning.
+  """
+
+  @spec apply_discount(number(), number()) :: number()
+  def apply_discount(x, y) do
+    z = x * (1 - y / 100)
+    Float.round(z, 2)
+  end
+
+  @spec calculate_total(list(), number()) :: number()
+  def calculate_total(a, b) do
+    n = Enum.reduce(a, 0, fn x, acc -> acc + x end)
+    m = n * (1 + b / 100)
+    Float.round(m, 2)
+  end
+
+  @spec tiered_price(number(), list()) :: number()
+  def tiered_price(x, y) do
+    Enum.reduce_while(y, x, fn {a, b}, acc ->
+      if acc > a do
+        {:cont, acc * (1 - b / 100)}
+      else
+        {:halt, acc}
+      end
+    end)
+  end
+
+  @spec split_payment(number(), integer()) :: list(number())
+  def split_payment(a, n) do
+    b = Float.round(a / n, 2)
+    m = a - b * (n - 1)
+    List.duplicate(b, n - 1) ++ [Float.round(m, 2)]
+  end
+
+  @spec compound_discount(number(), list()) :: number()
+  def compound_discount(x, y) do
+    Enum.reduce(y, x, fn a, b ->
+      b * (1 - a / 100)
+    end)
+    |> Float.round(2)
+  end
+
+  @spec price_with_tax(number(), number(), number()) :: map()
+  def price_with_tax(x, y, z) do
+    a = x * y
+    b = a * z / 100
+    %{
+      subtotal: Float.round(a, 2),
+      tax: Float.round(b, 2),
+      total: Float.round(a + b, 2)
+    }
+  end
+
+  @spec bulk_pricing(number(), integer(), integer()) :: number()
+  def bulk_pricing(x, n, m) do
+    cond do
+      n >= m -> x * 0.75
+      n >= div(m, 2) -> x * 0.9
+      true -> x
+    end
+    |> Float.round(2)
+  end
+
+  @spec margin(number(), number()) :: number()
+  def margin(x, y) do
+    z = (x - y) / x * 100
+    Float.round(z, 2)
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_single_letter/bad/calculator.js b/priv/combined_metrics/samples/variable_naming/name_is_single_letter/bad/calculator.js
new file mode 100644
index 0000000..49293ce
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_single_letter/bad/calculator.js
@@ -0,0 +1,69 @@
+// Pricing and discount calculator with single-letter variable names.
+// BAD: function params and local vars named x, y, z, a, b, n, m lose all meaning.
+
+function applyDiscount(x, y) {
+  const z = x * (1 - y / 100);
+  return Math.round(z * 100) / 100;
+}
+
+function calculateTotal(a, b) {
+  const n = a.reduce((acc, x) => acc + x, 0);
+  const m = n * (1 + b / 100);
+  return Math.round(m * 100) / 100;
+}
+
+function tieredPrice(x, y) {
+  return y.reduce((acc, [a, b]) => {
+    if (acc > a) return acc * (1 - b / 100);
+    return acc;
+  }, x);
+}
+
+function splitPayment(a, n) {
+  const b = Math.round((a / n) * 100) / 100;
+  const m = Math.round((a - b * (n - 1)) * 100) / 100;
+  return [...Array(n - 1).fill(b), m];
+}
+
+function compoundDiscount(x, y) {
+  const z = y.reduce((b, a) => b * (1 - a / 100), x);
+  return Math.round(z * 100) / 100;
+}
+
+function priceWithTax(x, y, z) {
+  const a = x * y;
+  const b = a * z / 100;
+  return {
+    subtotal: Math.round(a * 100) / 100,
+    tax: Math.round(b * 100) / 100,
+    total: Math.round((a + b) * 100) / 100,
+  };
+}
+
+function bulkPricing(x, n, m) {
+  if (n >= m) return Math.round(x * 0.75 * 100) / 100;
+  if (n >= m / 2) return Math.round(x * 0.9 * 100) / 100;
+  return x;
+}
+
+function margin(x, y) {
+  const z = (x - y) / x * 100;
+  return Math.round(z * 100) / 100;
+}
+
+function currencyConvert(a, b, c) {
+  const n = a * b;
+  const m = n - n * c / 100;
+  return Math.round(m * 100) / 100;
+}
+
+function installmentSchedule(x, n, y) {
+  const a = x * (1 + y / 100);
+  const b = Math.round((a / n) * 100) / 100;
+  return Array.from({ length: n }, (_, m) => ({
+    installment: m + 1,
+    amount: m < n - 1 ? b : Math.round((a - b * (n - 1)) * 100) / 100,
+  }));
+}
+
+module.exports = { applyDiscount, calculateTotal, tieredPrice, splitPayment, compoundDiscount, priceWithTax, bulkPricing, margin, currencyConvert, installmentSchedule };
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_single_letter/bad/calculator.rb b/priv/combined_metrics/samples/variable_naming/name_is_single_letter/bad/calculator.rb
new file mode 100644
index 0000000..b1579c4
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_single_letter/bad/calculator.rb
@@ -0,0 +1,73 @@
+# Pricing and discount calculator with single-letter variable names.
+# BAD: function params and local vars named x, y, z, a, b, n, m lose all meaning.
+
+class CalculatorBad
+  def apply_discount(x, y)
+    z = x * (1 - y / 100.0)
+    z.round(2)
+  end
+
+  def calculate_total(a, b)
+    n = a.sum
+    m = n * (1 + b / 100.0)
+    m.round(2)
+  end
+
+  def tiered_price(x, y)
+    y.reduce(x) do |acc, (a, b)|
+      acc > a ? acc * (1 - b / 100.0) : acc
+    end
+  end
+
+  def split_payment(a, n)
+    b = (a / n).round(2)
+    m = (a - b * (n - 1)).round(2)
+    Array.new(n - 1, b) + [m]
+  end
+
+  def compound_discount(x, y)
+    z = y.reduce(x) { |b, a| b * (1 - a / 100.0) }
+    z.round(2)
+  end
+
+  def price_with_tax(x, y, z)
+    a = x * y
+    b = a * z / 100.0
+    {
+      subtotal: a.round(2),
+      tax: b.round(2),
+      total: (a + b).round(2)
+    }
+  end
+
+  def bulk_pricing(x, n, m)
+    if n >= m
+      (x * 0.75).round(2)
+    elsif n >= m / 2
+      (x * 0.9).round(2)
+    else
+      x
+    end
+  end
+
+  def margin(x, y)
+    z = (x - y) / x.to_f * 100
+    z.round(2)
+  end
+
+  def currency_convert(a, b, c)
+    n = a * b
+    m = n - n * c / 100.0
+    m.round(2)
+  end
+
+  def installment_schedule(x, n, y)
+    a = x * (1 + y / 100.0)
+    b = (a / n).round(2)
+
+    (1..n).map do |m|
+      amount = m < n ? b : (a - b * (n - 1)).round(2)
+      { installment: m, amount: amount }
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_single_letter/config.yml b/priv/combined_metrics/samples/variable_naming/name_is_single_letter/config.yml
new file mode 100644
index 0000000..dbffbdb
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_single_letter/config.yml
@@ -0,0 +1 @@
+doc: "Single-letter names outside loop indices are too opaque."
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_single_letter/good/calculator.ex b/priv/combined_metrics/samples/variable_naming/name_is_single_letter/good/calculator.ex
new file mode 100644
index 0000000..789cc68
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_single_letter/good/calculator.ex
@@ -0,0 +1,72 @@
+defmodule Calculator.Good do
+  @moduledoc """
+  Pricing and discount calculator with descriptive variable names.
+  GOOD: params and locals named price, discount, quantity, amount make intent clear.
+  """
+
+  @spec apply_discount(number(), number()) :: number()
+  def apply_discount(price, discount_percent) do
+    discounted = price * (1 - discount_percent / 100)
+    Float.round(discounted, 2)
+  end
+
+  @spec calculate_total(list(), number()) :: number()
+  def calculate_total(amounts, tax_rate) do
+    subtotal = Enum.reduce(amounts, 0, fn amount, acc -> acc + amount end)
+    total = subtotal * (1 + tax_rate / 100)
+    Float.round(total, 2)
+  end
+
+  @spec tiered_price(number(), list()) :: number()
+  def tiered_price(price, tiers) do
+    Enum.reduce_while(tiers, price, fn {threshold, discount_percent}, current_price ->
+      if current_price > threshold do
+        {:cont, current_price * (1 - discount_percent / 100)}
+      else
+        {:halt, current_price}
+      end
+    end)
+  end
+
+  @spec split_payment(number(), integer()) :: list(number())
+  def split_payment(amount, count) do
+    installment = Float.round(amount / count, 2)
+    last_installment = amount - installment * (count - 1)
+    List.duplicate(installment, count - 1) ++ [Float.round(last_installment, 2)]
+  end
+
+  @spec compound_discount(number(), list()) :: number()
+  def compound_discount(price, discount_percents) do
+    Enum.reduce(discount_percents, price, fn discount_percent, current_price ->
+      current_price * (1 - discount_percent / 100)
+    end)
+    |> Float.round(2)
+  end
+
+  @spec price_with_tax(number(), number(), number()) :: map()
+  def price_with_tax(unit_price, quantity, tax_rate) do
+    subtotal = unit_price * quantity
+    tax = subtotal * tax_rate / 100
+    %{
+      subtotal: Float.round(subtotal, 2),
+      tax: Float.round(tax, 2),
+      total: Float.round(subtotal + tax, 2)
+    }
+  end
+
+  @spec bulk_pricing(number(), integer(), integer()) :: number()
+  def bulk_pricing(price, quantity, bulk_threshold) do
+    cond do
+      quantity >= bulk_threshold -> price * 0.75
+      quantity >= div(bulk_threshold, 2) -> price * 0.9
+      true -> price
+    end
+    |> Float.round(2)
+  end
+
+  @spec margin(number(), number()) :: number()
+  def margin(selling_price, cost) do
+    margin_percent = (selling_price - cost) / selling_price * 100
+    Float.round(margin_percent, 2)
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_single_letter/good/calculator.js b/priv/combined_metrics/samples/variable_naming/name_is_single_letter/good/calculator.js
new file mode 100644
index 0000000..9ed5768
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_single_letter/good/calculator.js
@@ -0,0 +1,72 @@
+// Pricing and discount calculator with descriptive variable names.
+// GOOD: params and locals named price, discount, quantity, amount make intent clear.
+
+function applyDiscount(price, discountPercent) {
+  const discounted = price * (1 - discountPercent / 100);
+  return Math.round(discounted * 100) / 100;
+}
+
+function calculateTotal(amounts, taxRate) {
+  const subtotal = amounts.reduce((acc, amount) => acc + amount, 0);
+  const total = subtotal * (1 + taxRate / 100);
+  return Math.round(total * 100) / 100;
+}
+
+function tieredPrice(price, tiers) {
+  return tiers.reduce((currentPrice, [threshold, discountPercent]) => {
+    if (currentPrice > threshold) return currentPrice * (1 - discountPercent / 100);
+    return currentPrice;
+  }, price);
+}
+
+function splitPayment(amount, count) {
+  const installment = Math.round((amount / count) * 100) / 100;
+  const lastInstallment = Math.round((amount - installment * (count - 1)) * 100) / 100;
+  return [...Array(count - 1).fill(installment), lastInstallment];
+}
+
+function compoundDiscount(price, discountPercents) {
+  const finalPrice = discountPercents.reduce(
+    (currentPrice, discountPercent) => currentPrice * (1 - discountPercent / 100),
+    price
+  );
+  return Math.round(finalPrice * 100) / 100;
+}
+
+function priceWithTax(unitPrice, quantity, taxRate) {
+  const subtotal = unitPrice * quantity;
+  const tax = subtotal * taxRate / 100;
+  return {
+    subtotal: Math.round(subtotal * 100) / 100,
+    tax: Math.round(tax * 100) / 100,
+    total: Math.round((subtotal + tax) * 100) / 100,
+  };
+}
+
+function bulkPricing(price, quantity, bulkThreshold) {
+  if (quantity >= bulkThreshold) return Math.round(price * 0.75 * 100) / 100;
+  if (quantity >= bulkThreshold / 2) return Math.round(price * 0.9 * 100) / 100;
+  return price;
+}
+
+function margin(sellingPrice, cost) {
+  const marginPercent = (sellingPrice - cost) / sellingPrice * 100;
+  return Math.round(marginPercent * 100) / 100;
+}
+
+function currencyConvert(amount, exchangeRate, conversionFee) {
+  const converted = amount * exchangeRate;
+  const afterFee = converted - converted * conversionFee / 100;
+  return Math.round(afterFee * 100) / 100;
+}
+
+function installmentSchedule(principal, count, annualRate) {
+  const totalAmount = principal * (1 + annualRate / 100);
+  const installment = Math.round((totalAmount / count) * 100) / 100;
+  return Array.from({ length: count }, (_, index) => ({
+    installment: index + 1,
+    amount: index < count - 1 ? installment : Math.round((totalAmount - installment * (count - 1)) * 100) / 100,
+  }));
+}
+
+module.exports = { applyDiscount, calculateTotal, tieredPrice, splitPayment, compoundDiscount, priceWithTax, bulkPricing, margin, currencyConvert, installmentSchedule };
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_single_letter/good/calculator.rb b/priv/combined_metrics/samples/variable_naming/name_is_single_letter/good/calculator.rb
new file mode 100644
index 0000000..6c6801a
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_single_letter/good/calculator.rb
@@ -0,0 +1,75 @@
+# Pricing and discount calculator with descriptive variable names.
+# GOOD: params and locals named price, discount, quantity, amount make intent clear.
+
+class CalculatorGood
+  def apply_discount(price, discount_percent)
+    discounted = price * (1 - discount_percent / 100.0)
+    discounted.round(2)
+  end
+
+  def calculate_total(amounts, tax_rate)
+    subtotal = amounts.sum
+    total = subtotal * (1 + tax_rate / 100.0)
+    total.round(2)
+  end
+
+  def tiered_price(price, tiers)
+    tiers.reduce(price) do |current_price, (threshold, discount_percent)|
+      current_price > threshold ? current_price * (1 - discount_percent / 100.0) : current_price
+    end
+  end
+
+  def split_payment(amount, count)
+    installment = (amount / count).round(2)
+    last_installment = (amount - installment * (count - 1)).round(2)
+    Array.new(count - 1, installment) + [last_installment]
+  end
+
+  def compound_discount(price, discount_percents)
+    final_price = discount_percents.reduce(price) do |current_price, discount_percent|
+      current_price * (1 - discount_percent / 100.0)
+    end
+    final_price.round(2)
+  end
+
+  def price_with_tax(unit_price, quantity, tax_rate)
+    subtotal = unit_price * quantity
+    tax = subtotal * tax_rate / 100.0
+    {
+      subtotal: subtotal.round(2),
+      tax: tax.round(2),
+      total: (subtotal + tax).round(2)
+    }
+  end
+
+  def bulk_pricing(price, quantity, bulk_threshold)
+    if quantity >= bulk_threshold
+      (price * 0.75).round(2)
+    elsif quantity >= bulk_threshold / 2
+      (price * 0.9).round(2)
+    else
+      price
+    end
+  end
+
+  def margin(selling_price, cost)
+    margin_percent = (selling_price - cost) / selling_price.to_f * 100
+    margin_percent.round(2)
+  end
+
+  def currency_convert(amount, exchange_rate, conversion_fee)
+    converted = amount * exchange_rate
+    after_fee = converted - converted * conversion_fee / 100.0
+    after_fee.round(2)
+  end
+
+  def installment_schedule(principal, count, annual_rate)
+    total_amount = principal * (1 + annual_rate / 100.0)
+    installment = (total_amount / count).round(2)
+
+    (1..count).map do |index|
+      payment = index < count ? installment : (total_amount - installment * (count - 1)).round(2)
+      { installment: index, amount: payment }
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_too_long/bad/session.ex b/priv/combined_metrics/samples/variable_naming/name_is_too_long/bad/session.ex
new file mode 100644
index 0000000..88ffc33
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_too_long/bad/session.ex
@@ -0,0 +1,72 @@
+defmodule Session.Bad do
+  @moduledoc """
+  Session and auth management with excessively long variable names.
+  BAD: variables like the_currently_authenticated_and_logged_in_user_object are unwieldy.
+  """
+
+  @spec start_session(String.t(), String.t()) :: {:ok, map()} | {:error, String.t()}
+  def start_session(email_address_of_the_user, plain_text_password_entered_by_the_user) do
+    the_user_account_that_was_looked_up_from_the_database = fetch_user_by_email(email_address_of_the_user)
+
+    if verify_password(plain_text_password_entered_by_the_user, the_user_account_that_was_looked_up_from_the_database.password_hash) do
+      the_newly_generated_session_token_string = generate_secure_random_session_token()
+      the_session_expiry_timestamp_in_utc = DateTime.add(DateTime.utc_now(), 86_400, :second)
+
+      {:ok, %{
+        token: the_newly_generated_session_token_string,
+        expires_at: the_session_expiry_timestamp_in_utc,
+        user_id: the_user_account_that_was_looked_up_from_the_database.id
+      }}
+    else
+      {:error, "Invalid credentials"}
+    end
+  end
+
+  @spec validate_session(String.t()) :: {:ok, map()} | {:error, String.t()}
+  def validate_session(the_session_token_string_provided_by_the_client) do
+    the_session_record_retrieved_from_the_database =
+      lookup_session_in_database(the_session_token_string_provided_by_the_client)
+
+    the_current_date_and_time_in_utc_timezone = DateTime.utc_now()
+
+    if DateTime.before?(the_current_date_and_time_in_utc_timezone, the_session_record_retrieved_from_the_database.expires_at) do
+      {:ok, the_session_record_retrieved_from_the_database}
+    else
+      {:error, "Session expired"}
+    end
+  end
+
+  @spec refresh_session(String.t()) :: {:ok, map()} | {:error, String.t()}
+  def refresh_session(the_existing_session_token_that_needs_to_be_refreshed) do
+    with {:ok, the_current_session_data_from_the_database} <-
+           validate_session(the_existing_session_token_that_needs_to_be_refreshed) do
+      the_new_session_token_that_replaces_the_old_one = generate_secure_random_session_token()
+      the_updated_expiry_time_for_the_refreshed_session = DateTime.add(DateTime.utc_now(), 86_400, :second)
+
+      {:ok, %{
+        token: the_new_session_token_that_replaces_the_old_one,
+        expires_at: the_updated_expiry_time_for_the_refreshed_session,
+        user_id: the_current_session_data_from_the_database.user_id
+      }}
+    end
+  end
+
+  @spec list_active_sessions(integer()) :: list(map())
+  def list_active_sessions(the_unique_identifier_of_the_user_account) do
+    the_maximum_allowed_number_of_retry_attempts_before_giving_up = 3
+    the_complete_list_of_all_sessions_belonging_to_the_specified_user =
+      fetch_all_sessions_for_user(the_unique_identifier_of_the_user_account, the_maximum_allowed_number_of_retry_attempts_before_giving_up)
+
+    the_current_timestamp_used_to_filter_expired_sessions = DateTime.utc_now()
+
+    Enum.filter(the_complete_list_of_all_sessions_belonging_to_the_specified_user, fn each_individual_session_record ->
+      DateTime.before?(the_current_timestamp_used_to_filter_expired_sessions, each_individual_session_record.expires_at)
+    end)
+  end
+
+  defp fetch_user_by_email(email), do: %{id: 1, email: email, password_hash: "hash"}
+  defp verify_password(password, _hash), do: String.length(password) > 0
+  defp generate_secure_random_session_token, do: :crypto.strong_rand_bytes(32) |> Base.encode64()
+  defp lookup_session_in_database(_token), do: %{user_id: 1, expires_at: DateTime.add(DateTime.utc_now(), 3600, :second)}
+  defp fetch_all_sessions_for_user(_id, _retries), do: []
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_too_long/bad/session.js b/priv/combined_metrics/samples/variable_naming/name_is_too_long/bad/session.js
new file mode 100644
index 0000000..d9e4e3e
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_too_long/bad/session.js
@@ -0,0 +1,81 @@
+// Session and auth management with excessively long variable names.
+// BAD: variables like theCurrentlyAuthenticatedAndLoggedInUserObject are unwieldy.
+
+async function startSession(emailAddressOfTheUser, plainTextPasswordEnteredByTheUser) {
+  const theUserAccountThatWasLookedUpFromTheDatabase = await fetchUserByEmail(emailAddressOfTheUser);
+
+  const isPasswordCorrectAndMatchesTheStoredHash = await verifyPassword(
+    plainTextPasswordEnteredByTheUser,
+    theUserAccountThatWasLookedUpFromTheDatabase.passwordHash
+  );
+
+  if (!isPasswordCorrectAndMatchesTheStoredHash) {
+    throw new Error('Invalid credentials');
+  }
+
+  const theNewlyGeneratedSessionTokenString = generateSecureRandomSessionToken();
+  const theSessionExpiryTimestampInUtc = new Date(Date.now() + 86_400_000);
+
+  return {
+    token: theNewlyGeneratedSessionTokenString,
+    expiresAt: theSessionExpiryTimestampInUtc,
+    userId: theUserAccountThatWasLookedUpFromTheDatabase.id,
+  };
+}
+
+async function validateSession(theSessionTokenStringProvidedByTheClient) {
+  const theSessionRecordRetrievedFromTheDatabase =
+    await lookupSessionInDatabase(theSessionTokenStringProvidedByTheClient);
+
+  const theCurrentDateAndTimeInUtcTimezone = new Date();
+
+  if (theCurrentDateAndTimeInUtcTimezone > theSessionRecordRetrievedFromTheDatabase.expiresAt) {
+    throw new Error('Session expired');
+  }
+
+  return theSessionRecordRetrievedFromTheDatabase;
+}
+
+async function refreshSession(theExistingSessionTokenThatNeedsToBeRefreshed) {
+  const theCurrentSessionDataFromTheDatabase =
+    await validateSession(theExistingSessionTokenThatNeedsToBeRefreshed);
+
+  const theNewSessionTokenThatReplacesTheOldOne = generateSecureRandomSessionToken();
+  const theUpdatedExpiryTimeForTheRefreshedSession = new Date(Date.now() + 86_400_000);
+
+  return {
+    token: theNewSessionTokenThatReplacesTheOldOne,
+    expiresAt: theUpdatedExpiryTimeForTheRefreshedSession,
+    userId: theCurrentSessionDataFromTheDatabase.userId,
+  };
+}
+
+async function listActiveSessions(theUniqueIdentifierOfTheUserAccount) {
+  const theMaximumAllowedNumberOfRetryAttemptsBeforeGivingUp = 3;
+  const theCompleteListOfAllSessionsBelongingToTheSpecifiedUser = await fetchAllSessionsForUser(
+    theUniqueIdentifierOfTheUserAccount,
+    theMaximumAllowedNumberOfRetryAttemptsBeforeGivingUp
+  );
+
+  const theCurrentTimestampUsedToFilterExpiredSessions = new Date();
+
+  return theCompleteListOfAllSessionsBelongingToTheSpecifiedUser.filter(
+    eachIndividualSessionRecord =>
+      eachIndividualSessionRecord.expiresAt > theCurrentTimestampUsedToFilterExpiredSessions
+  );
+}
+
+async function getCurrentlyAuthenticatedAndLoggedInUserObject(theSessionTokenStringProvidedByTheClient) {
+  const theValidatedSessionRecordFromTheDatabase =
+    await validateSession(theSessionTokenStringProvidedByTheClient);
+  return fetchUserByIdFromTheDatabase(theValidatedSessionRecordFromTheDatabase.userId);
+}
+
+async function fetchUserByEmail(email) { return { id: 1, email, passwordHash: 'hash' }; }
+async function verifyPassword(password) { return password.length > 0; }
+function generateSecureRandomSessionToken() { return Math.random().toString(36).slice(2); }
+async function lookupSessionInDatabase() { return { userId: 1, expiresAt: new Date(Date.now() + 3600_000) }; }
+async function fetchAllSessionsForUser() { return []; }
+async function fetchUserByIdFromTheDatabase(id) { return { id }; }
+
+module.exports = { startSession, validateSession, refreshSession, listActiveSessions, getCurrentlyAuthenticatedAndLoggedInUserObject };
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_too_long/bad/session.rb b/priv/combined_metrics/samples/variable_naming/name_is_too_long/bad/session.rb
new file mode 100644
index 0000000..b1804da
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_too_long/bad/session.rb
@@ -0,0 +1,80 @@
+# Session and auth management with excessively long variable names.
+# BAD: variables like the_currently_authenticated_and_logged_in_user_object are unwieldy.
+
+class SessionBad
+  def start_session(email_address_of_the_user, plain_text_password_entered_by_the_user)
+    the_user_account_that_was_looked_up_from_the_database = fetch_user_by_email(email_address_of_the_user)
+
+    is_password_correct_and_matches_the_stored_hash = verify_password(
+      plain_text_password_entered_by_the_user,
+      the_user_account_that_was_looked_up_from_the_database[:password_hash]
+    )
+
+    raise 'Invalid credentials' unless is_password_correct_and_matches_the_stored_hash
+
+    the_newly_generated_session_token_string = generate_secure_random_session_token
+    the_session_expiry_timestamp_in_utc = Time.now + 86_400
+
+    {
+      token: the_newly_generated_session_token_string,
+      expires_at: the_session_expiry_timestamp_in_utc,
+      user_id: the_user_account_that_was_looked_up_from_the_database[:id]
+    }
+  end
+
+  def validate_session(the_session_token_string_provided_by_the_client)
+    the_session_record_retrieved_from_the_database =
+      lookup_session_in_database(the_session_token_string_provided_by_the_client)
+
+    the_current_date_and_time_in_utc_timezone = Time.now
+
+    if the_current_date_and_time_in_utc_timezone > the_session_record_retrieved_from_the_database[:expires_at]
+      raise 'Session expired'
+    end
+
+    the_session_record_retrieved_from_the_database
+  end
+
+  def refresh_session(the_existing_session_token_that_needs_to_be_refreshed)
+    the_current_session_data_from_the_database =
+      validate_session(the_existing_session_token_that_needs_to_be_refreshed)
+
+    the_new_session_token_that_replaces_the_old_one = generate_secure_random_session_token
+    the_updated_expiry_time_for_the_refreshed_session = Time.now + 86_400
+
+    {
+      token: the_new_session_token_that_replaces_the_old_one,
+      expires_at: the_updated_expiry_time_for_the_refreshed_session,
+      user_id: the_current_session_data_from_the_database[:user_id]
+    }
+  end
+
+  def list_active_sessions(the_unique_identifier_of_the_user_account)
+    the_maximum_allowed_number_of_retry_attempts_before_giving_up = 3
+    the_complete_list_of_all_sessions_belonging_to_the_specified_user = fetch_all_sessions_for_user(
+      the_unique_identifier_of_the_user_account,
+      the_maximum_allowed_number_of_retry_attempts_before_giving_up
+    )
+
+    the_current_timestamp_used_to_filter_expired_sessions = Time.now
+
+    the_complete_list_of_all_sessions_belonging_to_the_specified_user.select do |each_individual_session_record|
+      each_individual_session_record[:expires_at] > the_current_timestamp_used_to_filter_expired_sessions
+    end
+  end
+
+  def get_the_currently_authenticated_and_logged_in_user_object(the_session_token_string_provided_by_the_client)
+    the_validated_session_record_from_the_database =
+      validate_session(the_session_token_string_provided_by_the_client)
+    fetch_user_by_id_from_the_database(the_validated_session_record_from_the_database[:user_id])
+  end
+
+  private
+
+  def fetch_user_by_email(email) = { id: 1, email: email, password_hash: 'hash' }
+  def verify_password(password, _hash) = password.length > 0
+  def generate_secure_random_session_token = SecureRandom.hex(32)
+  def lookup_session_in_database(_token) = { user_id: 1, expires_at: Time.now + 3600 }
+  def fetch_all_sessions_for_user(_id, _retries) = []
+  def fetch_user_by_id_from_the_database(id) = { id: id }
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_too_long/config.yml b/priv/combined_metrics/samples/variable_naming/name_is_too_long/config.yml
new file mode 100644
index 0000000..128a045
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_too_long/config.yml
@@ -0,0 +1 @@
+doc: "Names longer than ~30 characters harm readability."
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_too_long/good/session.ex b/priv/combined_metrics/samples/variable_naming/name_is_too_long/good/session.ex
new file mode 100644
index 0000000..911bf18
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_too_long/good/session.ex
@@ -0,0 +1,76 @@
+defmodule Session.Good do
+  @moduledoc """
+  Session and auth management with concise, clear variable names.
+  GOOD: current_user, max_retries, selected_product — short but descriptive.
+  """
+
+  @spec start_session(String.t(), String.t()) :: {:ok, map()} | {:error, String.t()}
+  def start_session(email, password) do
+    user = fetch_user_by_email(email)
+
+    if verify_password(password, user.password_hash) do
+      token = generate_session_token()
+      expires_at = DateTime.add(DateTime.utc_now(), 86_400, :second)
+
+      {:ok, %{token: token, expires_at: expires_at, user_id: user.id}}
+    else
+      {:error, "Invalid credentials"}
+    end
+  end
+
+  @spec validate_session(String.t()) :: {:ok, map()} | {:error, String.t()}
+  def validate_session(token) do
+    session = lookup_session(token)
+    now = DateTime.utc_now()
+
+    if DateTime.before?(now, session.expires_at) do
+      {:ok, session}
+    else
+      {:error, "Session expired"}
+    end
+  end
+
+  @spec refresh_session(String.t()) :: {:ok, map()} | {:error, String.t()}
+  def refresh_session(old_token) do
+    with {:ok, current_session} <- validate_session(old_token) do
+      new_token = generate_session_token()
+      expires_at = DateTime.add(DateTime.utc_now(), 86_400, :second)
+
+      {:ok, %{token: new_token, expires_at: expires_at, user_id: current_session.user_id}}
+    end
+  end
+
+  @spec list_active_sessions(integer()) :: list(map())
+  def list_active_sessions(user_id) do
+    max_retries = 3
+    sessions = fetch_all_sessions(user_id, max_retries)
+    now = DateTime.utc_now()
+
+    Enum.filter(sessions, fn session ->
+      DateTime.before?(now, session.expires_at)
+    end)
+  end
+
+  @spec invalidate_all_sessions(integer()) :: :ok
+  def invalidate_all_sessions(user_id) do
+    active_sessions = list_active_sessions(user_id)
+    Enum.each(active_sessions, &delete_session/1)
+    :ok
+  end
+
+  @spec current_user(String.t()) :: {:ok, map()} | {:error, String.t()}
+  def current_user(token) do
+    with {:ok, session} <- validate_session(token) do
+      user = fetch_user_by_id(session.user_id)
+      {:ok, user}
+    end
+  end
+
+  defp fetch_user_by_email(email), do: %{id: 1, email: email, password_hash: "hash"}
+  defp fetch_user_by_id(id), do: %{id: id}
+  defp verify_password(password, _hash), do: String.length(password) > 0
+  defp generate_session_token, do: :crypto.strong_rand_bytes(32) |> Base.encode64()
+  defp lookup_session(_token), do: %{user_id: 1, expires_at: DateTime.add(DateTime.utc_now(), 3600, :second)}
+  defp fetch_all_sessions(_user_id, _max_retries), do: []
+  defp delete_session(_session), do: :ok
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_too_long/good/session.js b/priv/combined_metrics/samples/variable_naming/name_is_too_long/good/session.js
new file mode 100644
index 0000000..6fbbe9b
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_too_long/good/session.js
@@ -0,0 +1,63 @@
+// Session and auth management with concise, clear variable names.
+// GOOD: currentUser, maxRetries, selectedProduct — short but descriptive.
+
+async function startSession(email, password) {
+  const user = await fetchUserByEmail(email);
+  const isValid = await verifyPassword(password, user.passwordHash);
+
+  if (!isValid) {
+    throw new Error('Invalid credentials');
+  }
+
+  const token = generateSessionToken();
+  const expiresAt = new Date(Date.now() + 86_400_000);
+
+  return { token, expiresAt, userId: user.id };
+}
+
+async function validateSession(token) {
+  const session = await lookupSession(token);
+  const now = new Date();
+
+  if (now > session.expiresAt) {
+    throw new Error('Session expired');
+  }
+
+  return session;
+}
+
+async function refreshSession(oldToken) {
+  const currentSession = await validateSession(oldToken);
+  const newToken = generateSessionToken();
+  const expiresAt = new Date(Date.now() + 86_400_000);
+
+  return { token: newToken, expiresAt, userId: currentSession.userId };
+}
+
+async function listActiveSessions(userId) {
+  const maxRetries = 3;
+  const sessions = await fetchAllSessions(userId, maxRetries);
+  const now = new Date();
+
+  return sessions.filter(session => session.expiresAt > now);
+}
+
+async function currentUser(token) {
+  const session = await validateSession(token);
+  return fetchUserById(session.userId);
+}
+
+async function invalidateAllSessions(userId) {
+  const activeSessions = await listActiveSessions(userId);
+  await Promise.all(activeSessions.map(session => deleteSession(session.id)));
+}
+
+async function fetchUserByEmail(email) { return { id: 1, email, passwordHash: 'hash' }; }
+async function verifyPassword(password) { return password.length > 0; }
+function generateSessionToken() { return Math.random().toString(36).slice(2); }
+async function lookupSession() { return { userId: 1, expiresAt: new Date(Date.now() + 3600_000) }; }
+async function fetchAllSessions() { return []; }
+async function fetchUserById(id) { return { id }; }
+async function deleteSession() {}
+
+module.exports = { startSession, validateSession, refreshSession, listActiveSessions, currentUser, invalidateAllSessions };
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_too_long/good/session.rb b/priv/combined_metrics/samples/variable_naming/name_is_too_long/good/session.rb
new file mode 100644
index 0000000..77e3a99
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_too_long/good/session.rb
@@ -0,0 +1,61 @@
+# Session and auth management with concise, clear variable names.
+# GOOD: current_user, max_retries, selected_product — short but descriptive.
+
+class SessionGood
+  def start_session(email, password)
+    user = fetch_user_by_email(email)
+    is_valid = verify_password(password, user[:password_hash])
+
+    raise 'Invalid credentials' unless is_valid
+
+    token = generate_session_token
+    expires_at = Time.now + 86_400
+
+    { token: token, expires_at: expires_at, user_id: user[:id] }
+  end
+
+  def validate_session(token)
+    session = lookup_session(token)
+    now = Time.now
+
+    raise 'Session expired' if now > session[:expires_at]
+
+    session
+  end
+
+  def refresh_session(old_token)
+    current_session = validate_session(old_token)
+    new_token = generate_session_token
+    expires_at = Time.now + 86_400
+
+    { token: new_token, expires_at: expires_at, user_id: current_session[:user_id] }
+  end
+
+  def list_active_sessions(user_id)
+    max_retries = 3
+    sessions = fetch_all_sessions(user_id, max_retries)
+    now = Time.now
+
+    sessions.select { |session| session[:expires_at] > now }
+  end
+
+  def current_user(token)
+    session = validate_session(token)
+    fetch_user_by_id(session[:user_id])
+  end
+
+  def invalidate_all_sessions(user_id)
+    active_sessions = list_active_sessions(user_id)
+    active_sessions.each { |session| delete_session(session[:id]) }
+  end
+
+  private
+
+  def fetch_user_by_email(email) = { id: 1, email: email, password_hash: 'hash' }
+  def fetch_user_by_id(id) = { id: id }
+  def verify_password(password, _hash) = password.length > 0
+  def generate_session_token = SecureRandom.hex(32)
+  def lookup_session(_token) = { user_id: 1, expires_at: Time.now + 3600 }
+  def fetch_all_sessions(_user_id, _max_retries) = []
+  def delete_session(_session_id) = nil
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_too_short/bad/contact.ex b/priv/combined_metrics/samples/variable_naming/name_is_too_short/bad/contact.ex
new file mode 100644
index 0000000..4fe42a7
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_too_short/bad/contact.ex
@@ -0,0 +1,78 @@
+defmodule Contact.Bad do
+  @moduledoc """
+  Contact and profile management with overly short variable names.
+  BAD: variables like u, pr, ct, nm, st, em, ph are cryptic non-loop identifiers.
+  """
+
+  @spec create(map()) :: {:ok, map()} | {:error, String.t()}
+  def create(attrs) do
+    nm = Map.get(attrs, :name)
+    em = Map.get(attrs, :email)
+    ph = Map.get(attrs, :phone)
+    st = Map.get(attrs, :status, :active)
+
+    with :ok <- validate_em(em),
+         :ok <- validate_ph(ph) do
+      ct = %{name: nm, email: em, phone: ph, status: st, id: generate_id()}
+      {:ok, ct}
+    end
+  end
+
+  @spec update(map(), map()) :: {:ok, map()} | {:error, String.t()}
+  def update(ct, attrs) do
+    nm = Map.get(attrs, :name, ct.name)
+    em = Map.get(attrs, :email, ct.email)
+    ph = Map.get(attrs, :phone, ct.phone)
+    st = Map.get(attrs, :status, ct.status)
+
+    with :ok <- validate_em(em),
+         :ok <- validate_ph(ph) do
+      {:ok, %{ct | name: nm, email: em, phone: ph, status: st}}
+    end
+  end
+
+  @spec search(list(map()), String.t()) :: list(map())
+  def search(ct_list, qr) do
+    Enum.filter(ct_list, fn ct ->
+      String.contains?(String.downcase(ct.name), String.downcase(qr)) ||
+        String.contains?(String.downcase(ct.email), String.downcase(qr))
+    end)
+  end
+
+  @spec group_by_status(list(map())) :: map()
+  def group_by_status(ct_list) do
+    Enum.group_by(ct_list, fn ct -> ct.status end)
+  end
+
+  @spec send_message(map(), String.t()) :: {:ok, map()} | {:error, String.t()}
+  def send_message(ct, mg) do
+    em = ct.email
+    nm = ct.name
+
+    case deliver_email(em, nm, mg) do
+      :ok -> {:ok, %{to: em, body: mg, sent_at: DateTime.utc_now()}}
+      {:error, rs} -> {:error, rs}
+    end
+  end
+
+  @spec format_display(map()) :: String.t()
+  def format_display(ct) do
+    nm = ct.name
+    em = ct.email
+    ph = ct.phone
+    st = ct.status
+
+    "#{nm} <#{em}> | #{ph} [#{st}]"
+  end
+
+  defp validate_em(em) do
+    if String.contains?(em, "@"), do: :ok, else: {:error, "Invalid email"}
+  end
+
+  defp validate_ph(ph) do
+    if Regex.match?(~r/^\+?\d{7,15}$/, ph), do: :ok, else: {:error, "Invalid phone"}
+  end
+
+  defp generate_id, do: System.unique_integer([:positive])
+  defp deliver_email(_em, _nm, _mg), do: :ok
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_too_short/bad/contact.js b/priv/combined_metrics/samples/variable_naming/name_is_too_short/bad/contact.js
new file mode 100644
index 0000000..67dd8a8
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_too_short/bad/contact.js
@@ -0,0 +1,87 @@
+// Contact and profile management with overly short variable names.
+// BAD: variables like u, pr, ct, nm, st, em, ph are cryptic non-loop identifiers.
+
+function createContact(attrs) {
+  const nm = attrs.name;
+  const em = attrs.email;
+  const ph = attrs.phone;
+  const st = attrs.status || 'active';
+
+  const emErr = validateEm(em);
+  if (emErr) return { ok: false, error: emErr };
+
+  const phErr = validatePh(ph);
+  if (phErr) return { ok: false, error: phErr };
+
+  const ct = { id: generateId(), name: nm, email: em, phone: ph, status: st };
+  return { ok: true, data: ct };
+}
+
+function updateContact(ct, attrs) {
+  const nm = attrs.name ?? ct.name;
+  const em = attrs.email ?? ct.email;
+  const ph = attrs.phone ?? ct.phone;
+  const st = attrs.status ?? ct.status;
+
+  const emErr = validateEm(em);
+  if (emErr) return { ok: false, error: emErr };
+
+  return { ok: true, data: { ...ct, name: nm, email: em, phone: ph, status: st } };
+}
+
+function searchContacts(ctList, qr) {
+  const lq = qr.toLowerCase();
+  return ctList.filter(ct =>
+    ct.name.toLowerCase().includes(lq) || ct.email.toLowerCase().includes(lq)
+  );
+}
+
+function groupByStatus(ctList) {
+  return ctList.reduce((acc, ct) => {
+    const st = ct.status;
+    acc[st] = acc[st] || [];
+    acc[st].push(ct);
+    return acc;
+  }, {});
+}
+
+async function sendMessage(ct, mg) {
+  const em = ct.email;
+  const nm = ct.name;
+
+  try {
+    await deliverEmail(em, nm, mg);
+    return { ok: true, data: { to: em, body: mg, sentAt: new Date() } };
+  } catch (er) {
+    return { ok: false, error: er.message };
+  }
+}
+
+function formatDisplay(ct) {
+  const nm = ct.name;
+  const em = ct.email;
+  const ph = ct.phone;
+  const st = ct.status;
+  return `${nm} <${em}> | ${ph} [${st}]`;
+}
+
+function mergeContacts(ct1, ct2) {
+  const nm = ct1.name || ct2.name;
+  const em = ct1.email || ct2.email;
+  const ph = ct1.phone || ct2.phone;
+  const st = ct1.status === 'active' ? ct1.status : ct2.status;
+  return { id: ct1.id, name: nm, email: em, phone: ph, status: st };
+}
+
+function validateEm(em) {
+  return em && em.includes('@') ? null : 'Invalid email';
+}
+
+function validatePh(ph) {
+  return ph && /^\+?\d{7,15}$/.test(ph) ? null : 'Invalid phone';
+}
+
+function generateId() { return Math.random().toString(36).slice(2); }
+async function deliverEmail(em, nm, mg) { console.log(`Sending to ${nm} at ${em}: ${mg}`); }
+
+module.exports = { createContact, updateContact, searchContacts, groupByStatus, sendMessage, formatDisplay, mergeContacts };
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_too_short/bad/contact.rb b/priv/combined_metrics/samples/variable_naming/name_is_too_short/bad/contact.rb
new file mode 100644
index 0000000..aa6fad7
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_too_short/bad/contact.rb
@@ -0,0 +1,82 @@
+# Contact and profile management with overly short variable names.
+# BAD: variables like u, pr, ct, nm, st, em, ph are cryptic non-loop identifiers.
+
+class ContactBad
+  def create(attrs)
+    nm = attrs[:name]
+    em = attrs[:email]
+    ph = attrs[:phone]
+    st = attrs[:status] || :active
+
+    em_err = validate_em(em)
+    return { ok: false, error: em_err } if em_err
+
+    ph_err = validate_ph(ph)
+    return { ok: false, error: ph_err } if ph_err
+
+    ct = { id: generate_id, name: nm, email: em, phone: ph, status: st }
+    { ok: true, data: ct }
+  end
+
+  def update(ct, attrs)
+    nm = attrs[:name] || ct[:name]
+    em = attrs[:email] || ct[:email]
+    ph = attrs[:phone] || ct[:phone]
+    st = attrs[:status] || ct[:status]
+
+    em_err = validate_em(em)
+    return { ok: false, error: em_err } if em_err
+
+    { ok: true, data: ct.merge(name: nm, email: em, phone: ph, status: st) }
+  end
+
+  def search(ct_list, qr)
+    lq = qr.downcase
+    ct_list.select do |ct|
+      ct[:name].downcase.include?(lq) || ct[:email].downcase.include?(lq)
+    end
+  end
+
+  def group_by_status(ct_list)
+    ct_list.group_by { |ct| ct[:status] }
+  end
+
+  def send_message(ct, mg)
+    em = ct[:email]
+    nm = ct[:name]
+
+    deliver_email(em, nm, mg)
+    { ok: true, data: { to: em, body: mg, sent_at: Time.now } }
+  rescue => er
+    { ok: false, error: er.message }
+  end
+
+  def format_display(ct)
+    nm = ct[:name]
+    em = ct[:email]
+    ph = ct[:phone]
+    st = ct[:status]
+    "#{nm} <#{em}> | #{ph} [#{st}]"
+  end
+
+  def merge_contacts(ct1, ct2)
+    nm = ct1[:name] || ct2[:name]
+    em = ct1[:email] || ct2[:email]
+    ph = ct1[:phone] || ct2[:phone]
+    st = ct1[:status] == :active ? ct1[:status] : ct2[:status]
+    { id: ct1[:id], name: nm, email: em, phone: ph, status: st }
+  end
+
+  private
+
+  def validate_em(em)
+    em&.include?('@') ? nil : 'Invalid email'
+  end
+
+  def validate_ph(ph)
+    ph&.match?(/^\+?\d{7,15}$/) ? nil : 'Invalid phone'
+  end
+
+  def generate_id = SecureRandom.hex(8)
+  def deliver_email(em, nm, mg) = puts("Sending to #{nm} at #{em}: #{mg}")
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_too_short/config.yml b/priv/combined_metrics/samples/variable_naming/name_is_too_short/config.yml
new file mode 100644
index 0000000..d10296d
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_too_short/config.yml
@@ -0,0 +1 @@
+doc: "Names shorter than 3 characters (outside loops) are too opaque."
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_too_short/good/contact.ex b/priv/combined_metrics/samples/variable_naming/name_is_too_short/good/contact.ex
new file mode 100644
index 0000000..1641d46
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_too_short/good/contact.ex
@@ -0,0 +1,78 @@
+defmodule Contact.Good do
+  @moduledoc """
+  Contact and profile management with clear, readable variable names.
+  GOOD: user, price, count, name, status, email, phone — obvious at a glance.
+  """
+
+  @spec create(map()) :: {:ok, map()} | {:error, String.t()}
+  def create(attrs) do
+    name = Map.get(attrs, :name)
+    email = Map.get(attrs, :email)
+    phone = Map.get(attrs, :phone)
+    status = Map.get(attrs, :status, :active)
+
+    with :ok <- validate_email(email),
+         :ok <- validate_phone(phone) do
+      contact = %{name: name, email: email, phone: phone, status: status, id: generate_id()}
+      {:ok, contact}
+    end
+  end
+
+  @spec update(map(), map()) :: {:ok, map()} | {:error, String.t()}
+  def update(contact, attrs) do
+    name = Map.get(attrs, :name, contact.name)
+    email = Map.get(attrs, :email, contact.email)
+    phone = Map.get(attrs, :phone, contact.phone)
+    status = Map.get(attrs, :status, contact.status)
+
+    with :ok <- validate_email(email),
+         :ok <- validate_phone(phone) do
+      {:ok, %{contact | name: name, email: email, phone: phone, status: status}}
+    end
+  end
+
+  @spec search(list(map()), String.t()) :: list(map())
+  def search(contacts, query) do
+    Enum.filter(contacts, fn contact ->
+      String.contains?(String.downcase(contact.name), String.downcase(query)) ||
+        String.contains?(String.downcase(contact.email), String.downcase(query))
+    end)
+  end
+
+  @spec group_by_status(list(map())) :: map()
+  def group_by_status(contacts) do
+    Enum.group_by(contacts, fn contact -> contact.status end)
+  end
+
+  @spec send_message(map(), String.t()) :: {:ok, map()} | {:error, String.t()}
+  def send_message(contact, message) do
+    email = contact.email
+    name = contact.name
+
+    case deliver_email(email, name, message) do
+      :ok -> {:ok, %{to: email, body: message, sent_at: DateTime.utc_now()}}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  @spec format_display(map()) :: String.t()
+  def format_display(contact) do
+    name = contact.name
+    email = contact.email
+    phone = contact.phone
+    status = contact.status
+
+    "#{name} <#{email}> | #{phone} [#{status}]"
+  end
+
+  defp validate_email(email) do
+    if String.contains?(email, "@"), do: :ok, else: {:error, "Invalid email"}
+  end
+
+  defp validate_phone(phone) do
+    if Regex.match?(~r/^\+?\d{7,15}$/, phone), do: :ok, else: {:error, "Invalid phone"}
+  end
+
+  defp generate_id, do: System.unique_integer([:positive])
+  defp deliver_email(_email, _name, _message), do: :ok
+end
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_too_short/good/contact.js b/priv/combined_metrics/samples/variable_naming/name_is_too_short/good/contact.js
new file mode 100644
index 0000000..d5dbc8a
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_too_short/good/contact.js
@@ -0,0 +1,88 @@
+// Contact and profile management with clear, readable variable names.
+// GOOD: user, price, count, name, status, email, phone — obvious at a glance.
+
+function createContact(attrs) {
+  const name = attrs.name;
+  const email = attrs.email;
+  const phone = attrs.phone;
+  const status = attrs.status || 'active';
+
+  const emailError = validateEmail(email);
+  if (emailError) return { ok: false, error: emailError };
+
+  const phoneError = validatePhone(phone);
+  if (phoneError) return { ok: false, error: phoneError };
+
+  const contact = { id: generateId(), name, email, phone, status };
+  return { ok: true, data: contact };
+}
+
+function updateContact(contact, attrs) {
+  const name = attrs.name ?? contact.name;
+  const email = attrs.email ?? contact.email;
+  const phone = attrs.phone ?? contact.phone;
+  const status = attrs.status ?? contact.status;
+
+  const emailError = validateEmail(email);
+  if (emailError) return { ok: false, error: emailError };
+
+  return { ok: true, data: { ...contact, name, email, phone, status } };
+}
+
+function searchContacts(contacts, query) {
+  const lowerQuery = query.toLowerCase();
+  return contacts.filter(contact =>
+    contact.name.toLowerCase().includes(lowerQuery) ||
+    contact.email.toLowerCase().includes(lowerQuery)
+  );
+}
+
+function groupByStatus(contacts) {
+  return contacts.reduce((acc, contact) => {
+    const status = contact.status;
+    acc[status] = acc[status] || [];
+    acc[status].push(contact);
+    return acc;
+  }, {});
+}
+
+async function sendMessage(contact, message) {
+  const email = contact.email;
+  const name = contact.name;
+
+  try {
+    await deliverEmail(email, name, message);
+    return { ok: true, data: { to: email, body: message, sentAt: new Date() } };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+
+function formatDisplay(contact) {
+  const name = contact.name;
+  const email = contact.email;
+  const phone = contact.phone;
+  const status = contact.status;
+  return `${name} <${email}> | ${phone} [${status}]`;
+}
+
+function mergeContacts(primary, secondary) {
+  const name = primary.name || secondary.name;
+  const email = primary.email || secondary.email;
+  const phone = primary.phone || secondary.phone;
+  const status = primary.status === 'active' ? primary.status : secondary.status;
+  return { id: primary.id, name, email, phone, status };
+}
+
+function validateEmail(email) {
+  return email && email.includes('@') ? null : 'Invalid email';
+}
+
+function validatePhone(phone) {
+  return phone && /^\+?\d{7,15}$/.test(phone) ? null : 'Invalid phone';
+}
+
+function generateId() { return Math.random().toString(36).slice(2); }
+async function deliverEmail(email, name, message) { console.log(`Sending to ${name} at ${email}: ${message}`); }
+
+module.exports = { createContact, updateContact, searchContacts, groupByStatus, sendMessage, formatDisplay, mergeContacts };
diff --git a/priv/combined_metrics/samples/variable_naming/name_is_too_short/good/contact.rb b/priv/combined_metrics/samples/variable_naming/name_is_too_short/good/contact.rb
new file mode 100644
index 0000000..ca3dd92
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/name_is_too_short/good/contact.rb
@@ -0,0 +1,82 @@
+# Contact and profile management with clear, readable variable names.
+# GOOD: user, price, count, name, status, email, phone — obvious at a glance.
+
+class ContactGood
+  def create(attrs)
+    name = attrs[:name]
+    email = attrs[:email]
+    phone = attrs[:phone]
+    status = attrs[:status] || :active
+
+    email_error = validate_email(email)
+    return { ok: false, error: email_error } if email_error
+
+    phone_error = validate_phone(phone)
+    return { ok: false, error: phone_error } if phone_error
+
+    contact = { id: generate_id, name: name, email: email, phone: phone, status: status }
+    { ok: true, data: contact }
+  end
+
+  def update(contact, attrs)
+    name = attrs[:name] || contact[:name]
+    email = attrs[:email] || contact[:email]
+    phone = attrs[:phone] || contact[:phone]
+    status = attrs[:status] || contact[:status]
+
+    email_error = validate_email(email)
+    return { ok: false, error: email_error } if email_error
+
+    { ok: true, data: contact.merge(name: name, email: email, phone: phone, status: status) }
+  end
+
+  def search(contacts, query)
+    lower_query = query.downcase
+    contacts.select do |contact|
+      contact[:name].downcase.include?(lower_query) || contact[:email].downcase.include?(lower_query)
+    end
+  end
+
+  def group_by_status(contacts)
+    contacts.group_by { |contact| contact[:status] }
+  end
+
+  def send_message(contact, message)
+    email = contact[:email]
+    name = contact[:name]
+
+    deliver_email(email, name, message)
+    { ok: true, data: { to: email, body: message, sent_at: Time.now } }
+  rescue => error
+    { ok: false, error: error.message }
+  end
+
+  def format_display(contact)
+    name = contact[:name]
+    email = contact[:email]
+    phone = contact[:phone]
+    status = contact[:status]
+    "#{name} <#{email}> | #{phone} [#{status}]"
+  end
+
+  def merge_contacts(primary, secondary)
+    name = primary[:name] || secondary[:name]
+    email = primary[:email] || secondary[:email]
+    phone = primary[:phone] || secondary[:phone]
+    status = primary[:status] == :active ? primary[:status] : secondary[:status]
+    { id: primary[:id], name: name, email: email, phone: phone, status: status }
+  end
+
+  private
+
+  def validate_email(email)
+    email&.include?('@') ? nil : 'Invalid email'
+  end
+
+  def validate_phone(phone)
+    phone&.match?(/^\+?\d{7,15}$/) ? nil : 'Invalid phone'
+  end
+
+  def generate_id = SecureRandom.hex(8)
+  def deliver_email(email, name, message) = puts("Sending to #{name} at #{email}: #{message}")
+end
diff --git a/priv/combined_metrics/samples/variable_naming/negated_boolean_name/bad/validator.ex b/priv/combined_metrics/samples/variable_naming/negated_boolean_name/bad/validator.ex
new file mode 100644
index 0000000..07dd9fd
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/negated_boolean_name/bad/validator.ex
@@ -0,0 +1,84 @@
+defmodule Validator.Bad do
+  @moduledoc """
+  Form and data validation using negated boolean variable names.
+  BAD: is_not_valid, not_active, is_disabled, no_access, not_found — double negatives obscure logic.
+  """
+
+  @spec validate_user(map()) :: {:ok, map()} | {:error, list(String.t())}
+  def validate_user(user) do
+    is_not_valid_email = not valid_email?(user.email)
+    not_active_account = user.status != :active
+    is_not_empty_name = user.name == "" or is_nil(user.name)
+
+    errors =
+      []
+      |> maybe_add("Email is invalid", is_not_valid_email)
+      |> maybe_add("Account is not active", not_active_account)
+      |> maybe_add("Name cannot be blank", is_not_empty_name)
+
+    if errors == [], do: {:ok, user}, else: {:error, errors}
+  end
+
+  @spec check_access(map(), String.t()) :: boolean()
+  def check_access(user, resource) do
+    no_access = user.role not in [:admin, :editor]
+    is_disabled = user.status == :disabled
+    not_found = not resource_exists?(resource)
+
+    not (no_access or is_disabled or not_found)
+  end
+
+  @spec validate_payment(map()) :: {:ok, map()} | {:error, String.t()}
+  def validate_payment(payment) do
+    is_not_valid_amount = payment.amount <= 0
+    not_supported_currency = payment.currency not in ["USD", "EUR", "GBP"]
+    is_expired_card = card_expired?(payment.card)
+
+    cond do
+      is_not_valid_amount -> {:error, "Amount must be positive"}
+      not_supported_currency -> {:error, "Currency not supported"}
+      is_expired_card -> {:error, "Card has expired"}
+      true -> {:ok, payment}
+    end
+  end
+
+  @spec validate_password(String.t()) :: {:ok, String.t()} | {:error, list(String.t())}
+  def validate_password(password) do
+    is_not_long_enough = String.length(password) < 8
+    is_not_complex_enough = not has_special_char?(password)
+    no_uppercase = not has_uppercase?(password)
+    no_digit = not has_digit?(password)
+
+    errors =
+      []
+      |> maybe_add("Must be at least 8 characters", is_not_long_enough)
+      |> maybe_add("Must contain a special character", is_not_complex_enough)
+      |> maybe_add("Must contain an uppercase letter", no_uppercase)
+      |> maybe_add("Must contain a digit", no_digit)
+
+    if errors == [], do: {:ok, password}, else: {:error, errors}
+  end
+
+  @spec validate_form(map()) :: {:ok, map()} | {:error, map()}
+  def validate_form(form) do
+    is_not_valid_email = not valid_email?(form[:email] || "")
+    not_accepted_terms = not form[:terms_accepted]
+    is_not_empty_message = is_nil(form[:message]) or String.trim(form[:message]) == ""
+
+    errors = %{}
+    errors = if is_not_valid_email, do: Map.put(errors, :email, "Invalid email"), else: errors
+    errors = if not_accepted_terms, do: Map.put(errors, :terms, "Must accept terms"), else: errors
+    errors = if is_not_empty_message, do: Map.put(errors, :message, "Message is required"), else: errors
+
+    if map_size(errors) == 0, do: {:ok, form}, else: {:error, errors}
+  end
+
+  defp valid_email?(email), do: String.contains?(email, "@")
+  defp resource_exists?(_resource), do: true
+  defp card_expired?(_card), do: false
+  defp has_special_char?(pw), do: Regex.match?(~r/[!@#$%^&*]/, pw)
+  defp has_uppercase?(pw), do: Regex.match?(~r/[A-Z]/, pw)
+  defp has_digit?(pw), do: Regex.match?(~r/\d/, pw)
+  defp maybe_add(errors, msg, true), do: [msg | errors]
+  defp maybe_add(errors, _msg, false), do: errors
+end
diff --git a/priv/combined_metrics/samples/variable_naming/negated_boolean_name/bad/validator.js b/priv/combined_metrics/samples/variable_naming/negated_boolean_name/bad/validator.js
new file mode 100644
index 0000000..5dfd5f3
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/negated_boolean_name/bad/validator.js
@@ -0,0 +1,86 @@
+// Form and data validation using negated boolean variable names.
+// BAD: isNotValid, notActive, isDisabled, noAccess, notFound — double negatives obscure logic.
+
+function validateUser(user) {
+  const isNotValidEmail = !isValidEmail(user.email);
+  const notActiveAccount = user.status !== 'active';
+  const isNotEmptyName = !user.name || user.name.trim() === '';
+
+  const errors = [];
+  if (isNotValidEmail) errors.push('Email is invalid');
+  if (notActiveAccount) errors.push('Account is not active');
+  if (isNotEmptyName) errors.push('Name cannot be blank');
+
+  return errors.length === 0 ? { ok: true, data: user } : { ok: false, errors };
+}
+
+function checkAccess(user, resource) {
+  const noAccess = !['admin', 'editor'].includes(user.role);
+  const isDisabled = user.status === 'disabled';
+  const notFound = !resourceExists(resource);
+
+  return !(noAccess || isDisabled || notFound);
+}
+
+function validatePayment(payment) {
+  const isNotValidAmount = payment.amount <= 0;
+  const notSupportedCurrency = !['USD', 'EUR', 'GBP'].includes(payment.currency);
+  const isExpiredCard = isCardExpired(payment.card);
+
+  if (isNotValidAmount) return { ok: false, error: 'Amount must be positive' };
+  if (notSupportedCurrency) return { ok: false, error: 'Currency not supported' };
+  if (isExpiredCard) return { ok: false, error: 'Card has expired' };
+
+  return { ok: true, data: payment };
+}
+
+function validatePassword(password) {
+  const isNotLongEnough = password.length < 8;
+  const isNotComplexEnough = !hasSpecialChar(password);
+  const noUppercase = !hasUppercase(password);
+  const noDigit = !hasDigit(password);
+
+  const errors = [];
+  if (isNotLongEnough) errors.push('Must be at least 8 characters');
+  if (isNotComplexEnough) errors.push('Must contain a special character');
+  if (noUppercase) errors.push('Must contain an uppercase letter');
+  if (noDigit) errors.push('Must contain a digit');
+
+  return errors.length === 0 ? { ok: true } : { ok: false, errors };
+}
+
+function validateForm(form) {
+  const isNotValidEmail = !isValidEmail(form.email || '');
+  const notAcceptedTerms = !form.termsAccepted;
+  const isNotEmptyMessage = !form.message || form.message.trim() === '';
+
+  const errors = {};
+  if (isNotValidEmail) errors.email = 'Invalid email';
+  if (notAcceptedTerms) errors.terms = 'Must accept terms';
+  if (isNotEmptyMessage) errors.message = 'Message is required';
+
+  return Object.keys(errors).length === 0 ? { ok: true, data: form } : { ok: false, errors };
+}
+
+function validateAddress(address) {
+  const isNotPresent = !address.street || address.street.trim() === '';
+  const noPostalCode = !address.postalCode;
+  const isNotValidCountry = !isSupportedCountry(address.country);
+
+  return {
+    isValid: !isNotPresent && !noPostalCode && !isNotValidCountry,
+    missingStreet: isNotPresent,
+    missingPostalCode: noPostalCode,
+    unsupportedCountry: isNotValidCountry,
+  };
+}
+
+function isValidEmail(email) { return email.includes('@'); }
+function resourceExists() { return true; }
+function isCardExpired() { return false; }
+function hasSpecialChar(pw) { return /[!@#$%^&*]/.test(pw); }
+function hasUppercase(pw) { return /[A-Z]/.test(pw); }
+function hasDigit(pw) { return /\d/.test(pw); }
+function isSupportedCountry(country) { return ['US', 'DE', 'GB'].includes(country); }
+
+module.exports = { validateUser, checkAccess, validatePayment, validatePassword, validateForm, validateAddress };
diff --git a/priv/combined_metrics/samples/variable_naming/negated_boolean_name/bad/validator.rb b/priv/combined_metrics/samples/variable_naming/negated_boolean_name/bad/validator.rb
new file mode 100644
index 0000000..6e7a514
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/negated_boolean_name/bad/validator.rb
@@ -0,0 +1,88 @@
+# Form and data validation using negated boolean variable names.
+# BAD: is_not_valid, not_active, is_disabled, no_access, not_found — double negatives obscure logic.
+
+class ValidatorBad
+  def validate_user(user)
+    is_not_valid_email = !valid_email?(user[:email])
+    not_active_account = user[:status] != :active
+    is_not_empty_name = user[:name].nil? || user[:name].strip.empty?
+
+    errors = []
+    errors << 'Email is invalid' if is_not_valid_email
+    errors << 'Account is not active' if not_active_account
+    errors << 'Name cannot be blank' if is_not_empty_name
+
+    errors.empty? ? { ok: true, data: user } : { ok: false, errors: errors }
+  end
+
+  def check_access(user, resource)
+    no_access = !%i[admin editor].include?(user[:role])
+    is_disabled = user[:status] == :disabled
+    not_found = !resource_exists?(resource)
+
+    !(no_access || is_disabled || not_found)
+  end
+
+  def validate_payment(payment)
+    is_not_valid_amount = payment[:amount] <= 0
+    not_supported_currency = !%w[USD EUR GBP].include?(payment[:currency])
+    is_expired_card = card_expired?(payment[:card])
+
+    return { ok: false, error: 'Amount must be positive' } if is_not_valid_amount
+    return { ok: false, error: 'Currency not supported' } if not_supported_currency
+    return { ok: false, error: 'Card has expired' } if is_expired_card
+
+    { ok: true, data: payment }
+  end
+
+  def validate_password(password)
+    is_not_long_enough = password.length < 8
+    is_not_complex_enough = !has_special_char?(password)
+    no_uppercase = !has_uppercase?(password)
+    no_digit = !has_digit?(password)
+
+    errors = []
+    errors << 'Must be at least 8 characters' if is_not_long_enough
+    errors << 'Must contain a special character' if is_not_complex_enough
+    errors << 'Must contain an uppercase letter' if no_uppercase
+    errors << 'Must contain a digit' if no_digit
+
+    errors.empty? ? { ok: true } : { ok: false, errors: errors }
+  end
+
+  def validate_form(form)
+    is_not_valid_email = !valid_email?(form[:email] || '')
+    not_accepted_terms = !form[:terms_accepted]
+    is_not_empty_message = form[:message].nil? || form[:message].strip.empty?
+
+    errors = {}
+    errors[:email] = 'Invalid email' if is_not_valid_email
+    errors[:terms] = 'Must accept terms' if not_accepted_terms
+    errors[:message] = 'Message is required' if is_not_empty_message
+
+    errors.empty? ? { ok: true, data: form } : { ok: false, errors: errors }
+  end
+
+  def validate_address(address)
+    is_not_present = address[:street].nil? || address[:street].strip.empty?
+    no_postal_code = address[:postal_code].nil?
+    is_not_valid_country = !supported_country?(address[:country])
+
+    {
+      is_valid: !is_not_present && !no_postal_code && !is_not_valid_country,
+      missing_street: is_not_present,
+      missing_postal_code: no_postal_code,
+      unsupported_country: is_not_valid_country
+    }
+  end
+
+  private
+
+  def valid_email?(email) = email.include?('@')
+  def resource_exists?(_resource) = true
+  def card_expired?(_card) = false
+  def has_special_char?(pw) = pw.match?(/[!@#$%^&*]/)
+  def has_uppercase?(pw) = pw.match?(/[A-Z]/)
+  def has_digit?(pw) = pw.match?(/\d/)
+  def supported_country?(country) = %w[US DE GB].include?(country)
+end
diff --git a/priv/combined_metrics/samples/variable_naming/negated_boolean_name/config.yml b/priv/combined_metrics/samples/variable_naming/negated_boolean_name/config.yml
new file mode 100644
index 0000000..c906ce0
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/negated_boolean_name/config.yml
@@ -0,0 +1 @@
+doc: "Negated boolean names (`isNotValid`, `notActive`) are harder to reason about."
diff --git a/priv/combined_metrics/samples/variable_naming/negated_boolean_name/good/validator.ex b/priv/combined_metrics/samples/variable_naming/negated_boolean_name/good/validator.ex
new file mode 100644
index 0000000..6613deb
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/negated_boolean_name/good/validator.ex
@@ -0,0 +1,84 @@
+defmodule Validator.Good do
+  @moduledoc """
+  Form and data validation using positive boolean variable names.
+  GOOD: is_valid, is_active, is_enabled, has_access, is_found — positive names read naturally.
+  """
+
+  @spec validate_user(map()) :: {:ok, map()} | {:error, list(String.t())}
+  def validate_user(user) do
+    is_valid_email = valid_email?(user.email)
+    is_active_account = user.status == :active
+    has_name = not (user.name == "" or is_nil(user.name))
+
+    errors =
+      []
+      |> maybe_add("Email is invalid", not is_valid_email)
+      |> maybe_add("Account is not active", not is_active_account)
+      |> maybe_add("Name cannot be blank", not has_name)
+
+    if errors == [], do: {:ok, user}, else: {:error, errors}
+  end
+
+  @spec check_access(map(), String.t()) :: boolean()
+  def check_access(user, resource) do
+    has_access = user.role in [:admin, :editor]
+    is_enabled = user.status != :disabled
+    is_found = resource_exists?(resource)
+
+    has_access and is_enabled and is_found
+  end
+
+  @spec validate_payment(map()) :: {:ok, map()} | {:error, String.t()}
+  def validate_payment(payment) do
+    is_valid_amount = payment.amount > 0
+    is_supported_currency = payment.currency in ["USD", "EUR", "GBP"]
+    is_valid_card = not card_expired?(payment.card)
+
+    cond do
+      not is_valid_amount -> {:error, "Amount must be positive"}
+      not is_supported_currency -> {:error, "Currency not supported"}
+      not is_valid_card -> {:error, "Card has expired"}
+      true -> {:ok, payment}
+    end
+  end
+
+  @spec validate_password(String.t()) :: {:ok, String.t()} | {:error, list(String.t())}
+  def validate_password(password) do
+    is_long_enough = String.length(password) >= 8
+    is_complex_enough = has_special_char?(password)
+    has_uppercase = has_uppercase_char?(password)
+    has_digit = has_digit_char?(password)
+
+    errors =
+      []
+      |> maybe_add("Must be at least 8 characters", not is_long_enough)
+      |> maybe_add("Must contain a special character", not is_complex_enough)
+      |> maybe_add("Must contain an uppercase letter", not has_uppercase)
+      |> maybe_add("Must contain a digit", not has_digit)
+
+    if errors == [], do: {:ok, password}, else: {:error, errors}
+  end
+
+  @spec validate_form(map()) :: {:ok, map()} | {:error, map()}
+  def validate_form(form) do
+    is_valid_email = valid_email?(form[:email] || "")
+    has_accepted_terms = form[:terms_accepted] == true
+    has_message = not (is_nil(form[:message]) or String.trim(form[:message] || "") == "")
+
+    errors = %{}
+    errors = if not is_valid_email, do: Map.put(errors, :email, "Invalid email"), else: errors
+    errors = if not has_accepted_terms, do: Map.put(errors, :terms, "Must accept terms"), else: errors
+    errors = if not has_message, do: Map.put(errors, :message, "Message is required"), else: errors
+
+    if map_size(errors) == 0, do: {:ok, form}, else: {:error, errors}
+  end
+
+  defp valid_email?(email), do: String.contains?(email, "@")
+  defp resource_exists?(_resource), do: true
+  defp card_expired?(_card), do: false
+  defp has_special_char?(pw), do: Regex.match?(~r/[!@#$%^&*]/, pw)
+  defp has_uppercase_char?(pw), do: Regex.match?(~r/[A-Z]/, pw)
+  defp has_digit_char?(pw), do: Regex.match?(~r/\d/, pw)
+  defp maybe_add(errors, msg, true), do: [msg | errors]
+  defp maybe_add(errors, _msg, false), do: errors
+end
diff --git a/priv/combined_metrics/samples/variable_naming/negated_boolean_name/good/validator.js b/priv/combined_metrics/samples/variable_naming/negated_boolean_name/good/validator.js
new file mode 100644
index 0000000..cd6ea43
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/negated_boolean_name/good/validator.js
@@ -0,0 +1,86 @@
+// Form and data validation using positive boolean variable names.
+// GOOD: isValid, isActive, isEnabled, hasAccess, isFound — positive names read naturally.
+
+function validateUser(user) {
+  const isValidEmail = checkValidEmail(user.email);
+  const isActiveAccount = user.status === 'active';
+  const hasName = user.name && user.name.trim() !== '';
+
+  const errors = [];
+  if (!isValidEmail) errors.push('Email is invalid');
+  if (!isActiveAccount) errors.push('Account is not active');
+  if (!hasName) errors.push('Name cannot be blank');
+
+  return errors.length === 0 ? { ok: true, data: user } : { ok: false, errors };
+}
+
+function checkAccess(user, resource) {
+  const hasAccess = ['admin', 'editor'].includes(user.role);
+  const isEnabled = user.status !== 'disabled';
+  const isFound = resourceExists(resource);
+
+  return hasAccess && isEnabled && isFound;
+}
+
+function validatePayment(payment) {
+  const isValidAmount = payment.amount > 0;
+  const isSupportedCurrency = ['USD', 'EUR', 'GBP'].includes(payment.currency);
+  const isValidCard = !isCardExpired(payment.card);
+
+  if (!isValidAmount) return { ok: false, error: 'Amount must be positive' };
+  if (!isSupportedCurrency) return { ok: false, error: 'Currency not supported' };
+  if (!isValidCard) return { ok: false, error: 'Card has expired' };
+
+  return { ok: true, data: payment };
+}
+
+function validatePassword(password) {
+  const isLongEnough = password.length >= 8;
+  const isComplexEnough = hasSpecialChar(password);
+  const hasUppercase = hasUppercaseChar(password);
+  const hasDigit = hasDigitChar(password);
+
+  const errors = [];
+  if (!isLongEnough) errors.push('Must be at least 8 characters');
+  if (!isComplexEnough) errors.push('Must contain a special character');
+  if (!hasUppercase) errors.push('Must contain an uppercase letter');
+  if (!hasDigit) errors.push('Must contain a digit');
+
+  return errors.length === 0 ? { ok: true } : { ok: false, errors };
+}
+
+function validateForm(form) {
+  const isValidEmail = checkValidEmail(form.email || '');
+  const hasAcceptedTerms = form.termsAccepted === true;
+  const hasMessage = form.message && form.message.trim() !== '';
+
+  const errors = {};
+  if (!isValidEmail) errors.email = 'Invalid email';
+  if (!hasAcceptedTerms) errors.terms = 'Must accept terms';
+  if (!hasMessage) errors.message = 'Message is required';
+
+  return Object.keys(errors).length === 0 ? { ok: true, data: form } : { ok: false, errors };
+}
+
+function validateAddress(address) {
+  const hasStreet = address.street && address.street.trim() !== '';
+  const hasPostalCode = !!address.postalCode;
+  const isSupportedCountry = checkSupportedCountry(address.country);
+
+  return {
+    isValid: hasStreet && hasPostalCode && isSupportedCountry,
+    hasStreet,
+    hasPostalCode,
+    isSupportedCountry,
+  };
+}
+
+function checkValidEmail(email) { return email.includes('@'); }
+function resourceExists() { return true; }
+function isCardExpired() { return false; }
+function hasSpecialChar(pw) { return /[!@#$%^&*]/.test(pw); }
+function hasUppercaseChar(pw) { return /[A-Z]/.test(pw); }
+function hasDigitChar(pw) { return /\d/.test(pw); }
+function checkSupportedCountry(country) { return ['US', 'DE', 'GB'].includes(country); }
+
+module.exports = { validateUser, checkAccess, validatePayment, validatePassword, validateForm, validateAddress };
diff --git a/priv/combined_metrics/samples/variable_naming/negated_boolean_name/good/validator.rb b/priv/combined_metrics/samples/variable_naming/negated_boolean_name/good/validator.rb
new file mode 100644
index 0000000..0e44ad5
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/negated_boolean_name/good/validator.rb
@@ -0,0 +1,88 @@
+# Form and data validation using positive boolean variable names.
+# GOOD: is_valid, is_active, is_enabled, has_access, is_found — positive names read naturally.
+
+class ValidatorGood
+  def validate_user(user)
+    is_valid_email = valid_email?(user[:email])
+    is_active_account = user[:status] == :active
+    has_name = !user[:name].nil? && !user[:name].strip.empty?
+
+    errors = []
+    errors << 'Email is invalid' unless is_valid_email
+    errors << 'Account is not active' unless is_active_account
+    errors << 'Name cannot be blank' unless has_name
+
+    errors.empty? ? { ok: true, data: user } : { ok: false, errors: errors }
+  end
+
+  def check_access(user, resource)
+    has_access = %i[admin editor].include?(user[:role])
+    is_enabled = user[:status] != :disabled
+    is_found = resource_exists?(resource)
+
+    has_access && is_enabled && is_found
+  end
+
+  def validate_payment(payment)
+    is_valid_amount = payment[:amount] > 0
+    is_supported_currency = %w[USD EUR GBP].include?(payment[:currency])
+    is_valid_card = !card_expired?(payment[:card])
+
+    return { ok: false, error: 'Amount must be positive' } unless is_valid_amount
+    return { ok: false, error: 'Currency not supported' } unless is_supported_currency
+    return { ok: false, error: 'Card has expired' } unless is_valid_card
+
+    { ok: true, data: payment }
+  end
+
+  def validate_password(password)
+    is_long_enough = password.length >= 8
+    is_complex_enough = has_special_char?(password)
+    has_uppercase = has_uppercase_char?(password)
+    has_digit = has_digit_char?(password)
+
+    errors = []
+    errors << 'Must be at least 8 characters' unless is_long_enough
+    errors << 'Must contain a special character' unless is_complex_enough
+    errors << 'Must contain an uppercase letter' unless has_uppercase
+    errors << 'Must contain a digit' unless has_digit
+
+    errors.empty? ? { ok: true } : { ok: false, errors: errors }
+  end
+
+  def validate_form(form)
+    is_valid_email = valid_email?(form[:email] || '')
+    has_accepted_terms = form[:terms_accepted] == true
+    has_message = !form[:message].nil? && !form[:message].strip.empty?
+
+    errors = {}
+    errors[:email] = 'Invalid email' unless is_valid_email
+    errors[:terms] = 'Must accept terms' unless has_accepted_terms
+    errors[:message] = 'Message is required' unless has_message
+
+    errors.empty? ? { ok: true, data: form } : { ok: false, errors: errors }
+  end
+
+  def validate_address(address)
+    has_street = !address[:street].nil? && !address[:street].strip.empty?
+    has_postal_code = !address[:postal_code].nil?
+    is_supported_country = supported_country?(address[:country])
+
+    {
+      is_valid: has_street && has_postal_code && is_supported_country,
+      has_street: has_street,
+      has_postal_code: has_postal_code,
+      is_supported_country: is_supported_country
+    }
+  end
+
+  private
+
+  def valid_email?(email) = email.include?('@')
+  def resource_exists?(_resource) = true
+  def card_expired?(_card) = false
+  def has_special_char?(pw) = pw.match?(/[!@#$%^&*]/)
+  def has_uppercase_char?(pw) = pw.match?(/[A-Z]/)
+  def has_digit_char?(pw) = pw.match?(/\d/)
+  def supported_country?(country) = %w[US DE GB].include?(country)
+end
diff --git a/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/bad/inventory.ex b/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/bad/inventory.ex
new file mode 100644
index 0000000..3e7b045
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/bad/inventory.ex
@@ -0,0 +1,87 @@
+defmodule Inventory.Bad do
+  @moduledoc """
+  Inventory management using Hungarian notation prefixes.
+  BAD: str_name, b_active, n_count, arr_items, int_age, obj_user, fn_callback, d_price.
+  """
+
+  @spec add_item(map()) :: {:ok, map()} | {:error, String.t()}
+  def add_item(obj_item) do
+    str_name = obj_item.name
+    str_sku = obj_item.sku
+    n_quantity = obj_item.quantity
+    d_price = obj_item.price
+    b_active = Map.get(obj_item, :active, true)
+
+    if str_name == "" or is_nil(str_name) do
+      {:error, "Name is required"}
+    else
+      {:ok, %{
+        id: generate_id(),
+        name: str_name,
+        sku: str_sku,
+        quantity: n_quantity,
+        price: d_price,
+        active: b_active
+      }}
+    end
+  end
+
+  @spec update_stock(String.t(), integer()) :: {:ok, map()} | {:error, String.t()}
+  def update_stock(str_item_id, n_delta) do
+    obj_item = fetch_item(str_item_id)
+    n_new_quantity = obj_item.quantity + n_delta
+
+    if n_new_quantity < 0 do
+      {:error, "Insufficient stock"}
+    else
+      {:ok, %{obj_item | quantity: n_new_quantity}}
+    end
+  end
+
+  @spec search_items(String.t(), list()) :: list(map())
+  def search_items(str_query, arr_items) do
+    str_lower_query = String.downcase(str_query)
+
+    Enum.filter(arr_items, fn obj_item ->
+      String.contains?(String.downcase(obj_item.name), str_lower_query) ||
+        String.contains?(String.downcase(obj_item.sku), str_lower_query)
+    end)
+  end
+
+  @spec calculate_value(list()) :: float()
+  def calculate_value(arr_items) do
+    Enum.reduce(arr_items, 0.0, fn obj_item, n_acc ->
+      n_acc + obj_item.quantity * obj_item.price
+    end)
+  end
+
+  @spec apply_discount(list(), float(), function()) :: list(map())
+  def apply_discount(arr_items, d_discount_rate, fn_filter) do
+    arr_items
+    |> Enum.filter(fn_filter)
+    |> Enum.map(fn obj_item ->
+      d_new_price = Float.round(obj_item.price * (1 - d_discount_rate), 2)
+      %{obj_item | price: d_new_price}
+    end)
+  end
+
+  @spec group_by_category(list()) :: map()
+  def group_by_category(arr_items) do
+    Enum.group_by(arr_items, fn obj_item -> obj_item.category end)
+  end
+
+  @spec low_stock_report(list(), integer()) :: list(map())
+  def low_stock_report(arr_items, n_threshold) do
+    b_include_inactive = false
+
+    arr_items
+    |> Enum.filter(fn obj_item ->
+      obj_item.quantity <= n_threshold &&
+        (b_include_inactive || obj_item.active)
+    end)
+    |> Enum.sort_by(fn obj_item -> obj_item.quantity end)
+  end
+
+  defp fetch_item(str_id), do: %{id: str_id, name: "Item", sku: "SKU", quantity: 10, price: 9.99, active: true, category: "misc"}
+  defp generate_id, do: System.unique_integer([:positive]) |> to_string()
+end
diff --git a/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/bad/inventory.js b/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/bad/inventory.js
new file mode 100644
index 0000000..e16a584
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/bad/inventory.js
@@ -0,0 +1,83 @@
+// Inventory management using Hungarian notation prefixes.
+// BAD: strName, bActive, nCount, arrItems, intAge, objUser, fnCallback, dPrice.
+
+function addItem(objItem) {
+  const strName = objItem.name;
+  const strSku = objItem.sku;
+  const nQuantity = objItem.quantity;
+  const dPrice = objItem.price;
+  const bActive = objItem.active ?? true;
+
+  if (!strName || strName.trim() === '') {
+    return { ok: false, error: 'Name is required' };
+  }
+
+  return {
+    ok: true,
+    data: { id: generateId(), name: strName, sku: strSku, quantity: nQuantity, price: dPrice, active: bActive },
+  };
+}
+
+function updateStock(strItemId, nDelta) {
+  const objItem = fetchItem(strItemId);
+  const nNewQuantity = objItem.quantity + nDelta;
+
+  if (nNewQuantity < 0) {
+    return { ok: false, error: 'Insufficient stock' };
+  }
+
+  return { ok: true, data: { ...objItem, quantity: nNewQuantity } };
+}
+
+function searchItems(strQuery, arrItems) {
+  const strLowerQuery = strQuery.toLowerCase();
+
+  return arrItems.filter(objItem =>
+    objItem.name.toLowerCase().includes(strLowerQuery) ||
+    objItem.sku.toLowerCase().includes(strLowerQuery)
+  );
+}
+
+function calculateValue(arrItems) {
+  return arrItems.reduce((nAcc, objItem) => nAcc + objItem.quantity * objItem.price, 0);
+}
+
+function applyDiscount(arrItems, dDiscountRate, fnFilter) {
+  return arrItems
+    .filter(fnFilter)
+    .map(objItem => {
+      const dNewPrice = Math.round(objItem.price * (1 - dDiscountRate) * 100) / 100;
+      return { ...objItem, price: dNewPrice };
+    });
+}
+
+function groupByCategory(arrItems) {
+  return arrItems.reduce((objAcc, objItem) => {
+    const strCategory = objItem.category;
+    objAcc[strCategory] = objAcc[strCategory] || [];
+    objAcc[strCategory].push(objItem);
+    return objAcc;
+  }, {});
+}
+
+function lowStockReport(arrItems, nThreshold) {
+  const bIncludeInactive = false;
+
+  return arrItems
+    .filter(objItem => objItem.quantity <= nThreshold && (bIncludeInactive || objItem.active))
+    .sort((objA, objB) => objA.quantity - objB.quantity);
+}
+
+function importItems(arrRawData, fnTransform, fnValidate) {
+  const arrTransformed = arrRawData.map(fnTransform);
+  const arrValid = arrTransformed.filter(fnValidate);
+  const nImported = arrValid.length;
+  const nSkipped = arrRawData.length - nImported;
+
+  return { imported: nImported, skipped: nSkipped, items: arrValid };
+}
+
+function fetchItem(strId) { return { id: strId, name: 'Item', sku: 'SKU', quantity: 10, price: 9.99, active: true, category: 'misc' }; }
+function generateId() { return Math.random().toString(36).slice(2); }
+
+module.exports = { addItem, updateStock, searchItems, calculateValue, applyDiscount, groupByCategory, lowStockReport, importItems };
diff --git a/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/bad/inventory.rb b/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/bad/inventory.rb
new file mode 100644
index 0000000..7fa0f84
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/bad/inventory.rb
@@ -0,0 +1,79 @@
+# Inventory management using Hungarian notation prefixes.
+# BAD: str_name, b_active, n_count, arr_items, int_age, obj_user, fn_callback, d_price.
+
+class InventoryBad
+  def add_item(obj_item)
+    str_name = obj_item[:name]
+    str_sku = obj_item[:sku]
+    n_quantity = obj_item[:quantity]
+    d_price = obj_item[:price]
+    b_active = obj_item.fetch(:active, true)
+
+    return { ok: false, error: 'Name is required' } if str_name.nil? || str_name.strip.empty?
+
+    {
+      ok: true,
+      data: { id: generate_id, name: str_name, sku: str_sku, quantity: n_quantity, price: d_price, active: b_active }
+    }
+  end
+
+  def update_stock(str_item_id, n_delta)
+    obj_item = fetch_item(str_item_id)
+    n_new_quantity = obj_item[:quantity] + n_delta
+
+    return { ok: false, error: 'Insufficient stock' } if n_new_quantity < 0
+
+    { ok: true, data: obj_item.merge(quantity: n_new_quantity) }
+  end
+
+  def search_items(str_query, arr_items)
+    str_lower_query = str_query.downcase
+
+    arr_items.select do |obj_item|
+      obj_item[:name].downcase.include?(str_lower_query) ||
+        obj_item[:sku].downcase.include?(str_lower_query)
+    end
+  end
+
+  def calculate_value(arr_items)
+    arr_items.sum { |obj_item| obj_item[:quantity] * obj_item[:price] }
+  end
+
+  def apply_discount(arr_items, d_discount_rate, fn_filter)
+    arr_items
+      .select(&fn_filter)
+      .map do |obj_item|
+        d_new_price = (obj_item[:price] * (1 - d_discount_rate)).round(2)
+        obj_item.merge(price: d_new_price)
+      end
+  end
+
+  def group_by_category(arr_items)
+    arr_items.group_by { |obj_item| obj_item[:category] }
+  end
+
+  def low_stock_report(arr_items, n_threshold)
+    b_include_inactive = false
+
+    arr_items
+      .select { |obj_item| obj_item[:quantity] <= n_threshold && (b_include_inactive || obj_item[:active]) }
+      .sort_by { |obj_item| obj_item[:quantity] }
+  end
+
+  def import_items(arr_raw_data, fn_transform, fn_validate)
+    arr_transformed = arr_raw_data.map(&fn_transform)
+    arr_valid = arr_transformed.select(&fn_validate)
+    n_imported = arr_valid.length
+    n_skipped = arr_raw_data.length - n_imported
+
+    { imported: n_imported, skipped: n_skipped, items: arr_valid }
+  end
+
+  private
+
+  def fetch_item(str_id)
+    { id: str_id, name: 'Item', sku: 'SKU', quantity: 10, price: 9.99, active: true, category: 'misc' }
+  end
+
+  def generate_id = SecureRandom.hex(8)
+end
diff --git a/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/config.yml b/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/config.yml
new file mode 100644
index 0000000..24764c2
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/config.yml
@@ -0,0 +1 @@
+doc: "Hungarian notation prefixes (`strName`, `bFlag`) add noise without type safety."
diff --git a/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/good/inventory.ex b/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/good/inventory.ex
new file mode 100644
index 0000000..573700d
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/good/inventory.ex
@@ -0,0 +1,87 @@
+defmodule Inventory.Good do
+  @moduledoc """
+  Inventory management without Hungarian notation prefixes.
+  GOOD: name, is_active, count, items, age, user, callback, price — no type prefixes.
+  """
+
+  @spec add_item(map()) :: {:ok, map()} | {:error, String.t()}
+  def add_item(item) do
+    name = item.name
+    sku = item.sku
+    quantity = item.quantity
+    price = item.price
+    is_active = Map.get(item, :active, true)
+
+    if name == "" or is_nil(name) do
+      {:error, "Name is required"}
+    else
+      {:ok, %{
+        id: generate_id(),
+        name: name,
+        sku: sku,
+        quantity: quantity,
+        price: price,
+        active: is_active
+      }}
+    end
+  end
+
+  @spec update_stock(String.t(), integer()) :: {:ok, map()} | {:error, String.t()}
+  def update_stock(item_id, delta) do
+    item = fetch_item(item_id)
+    new_quantity = item.quantity + delta
+
+    if new_quantity < 0 do
+      {:error, "Insufficient stock"}
+    else
+      {:ok, %{item | quantity: new_quantity}}
+    end
+  end
+
+  @spec search_items(String.t(), list()) :: list(map())
+  def search_items(query, items) do
+    lower_query = String.downcase(query)
+
+    Enum.filter(items, fn item ->
+      String.contains?(String.downcase(item.name), lower_query) ||
+        String.contains?(String.downcase(item.sku), lower_query)
+    end)
+  end
+
+  @spec calculate_value(list()) :: float()
+  def calculate_value(items) do
+    Enum.reduce(items, 0.0, fn item, acc ->
+      acc + item.quantity * item.price
+    end)
+  end
+
+  @spec apply_discount(list(), float(), function()) :: list(map())
+  def apply_discount(items, discount_rate, filter) do
+    items
+    |> Enum.filter(filter)
+    |> Enum.map(fn item ->
+      new_price = Float.round(item.price * (1 - discount_rate), 2)
+      %{item | price: new_price}
+    end)
+  end
+
+  @spec group_by_category(list()) :: map()
+  def group_by_category(items) do
+    Enum.group_by(items, fn item -> item.category end)
+  end
+
+  @spec low_stock_report(list(), integer()) :: list(map())
+  def low_stock_report(items, threshold) do
+    include_inactive = false
+
+    items
+    |> Enum.filter(fn item ->
+      item.quantity <= threshold &&
+        (include_inactive || item.active)
+    end)
+    |> Enum.sort_by(fn item -> item.quantity end)
+  end
+
+  defp fetch_item(id), do: %{id: id, name: "Item", sku: "SKU", quantity: 10, price: 9.99, active: true, category: "misc"}
+  defp generate_id, do: System.unique_integer([:positive]) |> to_string()
+end
diff --git a/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/good/inventory.js b/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/good/inventory.js
new file mode 100644
index 0000000..6c93455
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/good/inventory.js
@@ -0,0 +1,83 @@
+// Inventory management without Hungarian notation prefixes.
+// GOOD: name, isActive, count, items, age, user, callback, price — no type prefixes.
+
+function addItem(item) {
+  const name = item.name;
+  const sku = item.sku;
+  const quantity = item.quantity;
+  const price = item.price;
+  const isActive = item.active ?? true;
+
+  if (!name || name.trim() === '') {
+    return { ok: false, error: 'Name is required' };
+  }
+
+  return {
+    ok: true,
+    data: { id: generateId(), name, sku, quantity, price, active: isActive },
+  };
+}
+
+function updateStock(itemId, delta) {
+  const item = fetchItem(itemId);
+  const newQuantity = item.quantity + delta;
+
+  if (newQuantity < 0) {
+    return { ok: false, error: 'Insufficient stock' };
+  }
+
+  return { ok: true, data: { ...item, quantity: newQuantity } };
+}
+
+function searchItems(query, items) {
+  const lowerQuery = query.toLowerCase();
+
+  return items.filter(item =>
+    item.name.toLowerCase().includes(lowerQuery) ||
+    item.sku.toLowerCase().includes(lowerQuery)
+  );
+}
+
+function calculateValue(items) {
+  return items.reduce((acc, item) => acc + item.quantity * item.price, 0);
+}
+
+function applyDiscount(items, discountRate, filter) {
+  return items
+    .filter(filter)
+    .map(item => {
+      const newPrice = Math.round(item.price * (1 - discountRate) * 100) / 100;
+      return { ...item, price: newPrice };
+    });
+}
+
+function groupByCategory(items) {
+  return items.reduce((acc, item) => {
+    const category = item.category;
+    acc[category] = acc[category] || [];
+    acc[category].push(item);
+    return acc;
+  }, {});
+}
+
+function lowStockReport(items, threshold) {
+  const includeInactive = false;
+
+  return items
+    .filter(item => item.quantity <= threshold && (includeInactive || item.active))
+    .sort((a, b) => a.quantity - b.quantity);
+}
+
+function importItems(rawData, transform, validate) {
+  const transformed = rawData.map(transform);
+  const valid = transformed.filter(validate);
+  const imported = valid.length;
+  const skipped = rawData.length - imported;
+
+  return { imported, skipped, items: valid };
+}
+
+function fetchItem(id) { return { id, name: 'Item', sku: 'SKU', quantity: 10, price: 9.99, active: true, category: 'misc' }; }
+function generateId() { return Math.random().toString(36).slice(2); }
+
+module.exports = { addItem, updateStock, searchItems, calculateValue, applyDiscount, groupByCategory, lowStockReport, importItems };
diff --git a/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/good/inventory.rb b/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/good/inventory.rb
new file mode 100644
index 0000000..7cfb980
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/no_hungarian_notation/good/inventory.rb
@@ -0,0 +1,79 @@
+# Inventory management without Hungarian notation prefixes.
+# GOOD: name, is_active, count, items, age, user, callback, price — no type prefixes.
+
+class InventoryGood
+  def add_item(item)
+    name = item[:name]
+    sku = item[:sku]
+    quantity = item[:quantity]
+    price = item[:price]
+    is_active = item.fetch(:active, true)
+
+    return { ok: false, error: 'Name is required' } if name.nil? || name.strip.empty?
+
+    {
+      ok: true,
+      data: { id: generate_id, name: name, sku: sku, quantity: quantity, price: price, active: is_active }
+    }
+  end
+
+  def update_stock(item_id, delta)
+    item = fetch_item(item_id)
+    new_quantity = item[:quantity] + delta
+
+    return { ok: false, error: 'Insufficient stock' } if new_quantity < 0
+
+    { ok: true, data: item.merge(quantity: new_quantity) }
+  end
+
+  def search_items(query, items)
+    lower_query = query.downcase
+
+    items.select do |item|
+      item[:name].downcase.include?(lower_query) ||
+        item[:sku].downcase.include?(lower_query)
+    end
+  end
+
+  def calculate_value(items)
+    items.sum { |item| item[:quantity] * item[:price] }
+  end
+
+  def apply_discount(items, discount_rate, filter)
+    items
+      .select(&filter)
+      .map do |item|
+        new_price = (item[:price] * (1 - discount_rate)).round(2)
+        item.merge(price: new_price)
+      end
+  end
+
+  def group_by_category(items)
+    items.group_by { |item| item[:category] }
+  end
+
+  def low_stock_report(items, threshold)
+    include_inactive = false
+
+    items
+      .select { |item| item[:quantity] <= threshold && (include_inactive || item[:active]) }
+      .sort_by { |item| item[:quantity] }
+  end
+
+  def import_items(raw_data, transform, validate)
+    transformed = raw_data.map(&transform)
+    valid = transformed.select(&validate)
+    imported = valid.length
+    skipped = raw_data.length - imported
+
+    { imported: imported, skipped: skipped, items: valid }
+  end
+
+  private
+
+  def fetch_item(id)
+    { id: id, name: 'Item', sku: 'SKU', quantity: 10, price: 9.99, active: true, category: 'misc' }
+  end
+
+  def generate_id = SecureRandom.hex(8)
+end
diff --git a/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/bad/config.ex b/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/bad/config.ex
new file mode 100644
index 0000000..811a211
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/bad/config.ex
@@ -0,0 +1,90 @@
+defmodule Config.Bad do
+  @moduledoc """
+  Application config and HTTP client using incorrectly-cased module constants.
+  BAD: module-level constants use camelCase or lowercase instead of SCREAMING_SNAKE_CASE.
+  """
+
+  @maxRetries 3
+  @defaultTimeout 5_000
+  @apiBaseUrl "https://api.example.com/v1"
+  @pageSize 25
+  @retryDelay 1_000
+  @maxPageSize 100
+  @connectTimeout 2_000
+  @defaultHeaders [{"Content-Type", "application/json"}, {"Accept", "application/json"}]
+
+  @spec fetch(String.t()) :: {:ok, map()} | {:error, String.t()}
+  def fetch(path) do
+    url = @apiBaseUrl <> path
+    do_request_with_retry(url, @maxRetries, @defaultTimeout)
+  end
+
+  @spec fetch_page(String.t(), integer()) :: {:ok, map()} | {:error, String.t()}
+  def fetch_page(path, page) do
+    size = min(page, @maxPageSize)
+    url = "#{@apiBaseUrl}#{path}?page=#{page}&size=#{size}"
+    do_request_with_retry(url, @maxRetries, @defaultTimeout)
+  end
+
+  @spec paginate_all(String.t()) :: {:ok, list()} | {:error, String.t()}
+  def paginate_all(path) do
+    Stream.iterate(1, &(&1 + 1))
+    |> Stream.map(fn page ->
+      fetch_page(path, page)
+    end)
+    |> Stream.take_while(fn
+      {:ok, %{items: items}} -> length(items) == @pageSize
+      _ -> false
+    end)
+    |> Enum.to_list()
+    |> then(fn results ->
+      if Enum.all?(results, &match?({:ok, _}, &1)),
+        do: {:ok, Enum.flat_map(results, fn {:ok, %{items: i}} -> i end)},
+        else: {:error, "Pagination failed"}
+    end)
+  end
+
+  @spec post(String.t(), map()) :: {:ok, map()} | {:error, String.t()}
+  def post(path, body) do
+    url = @apiBaseUrl <> path
+    do_post_with_retry(url, body, @maxRetries)
+  end
+
+  defp do_request_with_retry(url, retries_left, timeout) do
+    case HTTPoison.get(url, @defaultHeaders, recv_timeout: timeout, connect_timeout: @connectTimeout) do
+      {:ok, %{status_code: 200, body: body}} ->
+        {:ok, Jason.decode!(body)}
+
+      {:ok, %{status_code: status}} when status >= 500 and retries_left > 0 ->
+        Process.sleep(@retryDelay)
+        do_request_with_retry(url, retries_left - 1, timeout)
+
+      {:ok, %{status_code: status}} ->
+        {:error, "HTTP #{status}"}
+
+      {:error, err} when retries_left > 0 ->
+        Process.sleep(@retryDelay)
+        do_request_with_retry(url, retries_left - 1, timeout)
+
+      {:error, err} ->
+        {:error, inspect(err)}
+    end
+  end
+
+  defp do_post_with_retry(url, body, retries_left) do
+    case HTTPoison.post(url, Jason.encode!(body), @defaultHeaders, recv_timeout: @defaultTimeout) do
+      {:ok, %{status_code: code, body: resp}} when code in [200, 201] ->
+        {:ok, Jason.decode!(resp)}
+
+      {:ok, _} when retries_left > 0 ->
+        Process.sleep(@retryDelay)
+        do_post_with_retry(url, body, retries_left - 1)
+
+      {:ok, %{status_code: code}} ->
+        {:error, "HTTP #{code}"}
+
+      {:error, _} ->
+        {:error, "Request failed"}
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/bad/config.js b/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/bad/config.js
new file mode 100644
index 0000000..5fbb8d1
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/bad/config.js
@@ -0,0 +1,105 @@
+// Application config and HTTP client using incorrectly-cased module constants.
+// BAD: module-level constants use camelCase or lowercase instead of SCREAMING_SNAKE_CASE.
+
+const maxRetries = 3;
+const defaultTimeout = 5000;
+const apiBaseUrl = 'https://api.example.com/v1';
+const pageSize = 25;
+const retryDelay = 1000;
+const maxPageSize = 100;
+const connectTimeout = 2000;
+const defaultHeaders = {
+  'Content-Type': 'application/json',
+  'Accept': 'application/json',
+};
+
+async function fetchData(path) {
+  const url = apiBaseUrl + path;
+  return requestWithRetry(url, maxRetries, defaultTimeout);
+}
+
+async function fetchPage(path, page) {
+  const size = Math.min(page, maxPageSize);
+  const url = `${apiBaseUrl}${path}?page=${page}&size=${size}`;
+  return requestWithRetry(url, maxRetries, defaultTimeout);
+}
+
+async function paginateAll(path) {
+  const allItems = [];
+  let page = 1;
+
+  while (true) {
+    const result = await fetchPage(path, page);
+    if (!result.ok) return result;
+
+    allItems.push(...result.data.items);
+
+    if (result.data.items.length < pageSize) break;
+    page++;
+  }
+
+  return { ok: true, data: allItems };
+}
+
+async function postData(path, body) {
+  const url = apiBaseUrl + path;
+  return postWithRetry(url, body, maxRetries);
+}
+
+async function requestWithRetry(url, retriesLeft, timeout) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const response = await fetch(url, {
+      headers: defaultHeaders,
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    if (response.status >= 500 && retriesLeft > 0) {
+      await sleep(retryDelay);
+      return requestWithRetry(url, retriesLeft - 1, timeout);
+    }
+
+    if (!response.ok) return { ok: false, error: `HTTP ${response.status}` };
+
+    const data = await response.json();
+    return { ok: true, data };
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (retriesLeft > 0) {
+      await sleep(retryDelay);
+      return requestWithRetry(url, retriesLeft - 1, timeout);
+    }
+    return { ok: false, error: error.message };
+  }
+}
+
+async function postWithRetry(url, body, retriesLeft) {
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: defaultHeaders,
+      body: JSON.stringify(body),
+    });
+
+    if ([200, 201].includes(response.status)) {
+      return { ok: true, data: await response.json() };
+    }
+
+    if (retriesLeft > 0) {
+      await sleep(retryDelay);
+      return postWithRetry(url, body, retriesLeft - 1);
+    }
+
+    return { ok: false, error: `HTTP ${response.status}` };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+
+function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); }
+
+module.exports = { fetchData, fetchPage, paginateAll, postData };
diff --git a/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/bad/config.rb b/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/bad/config.rb
new file mode 100644
index 0000000..852e02c
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/bad/config.rb
@@ -0,0 +1,107 @@
+# Application config and HTTP client using incorrectly-cased module constants.
+# BAD: module-level constants use camelCase or lowercase instead of SCREAMING_SNAKE_CASE.
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+class ConfigBad
+  maxRetries = 3
+  defaultTimeout = 5
+  apiBaseUrl = 'https://api.example.com/v1'
+  pageSize = 25
+  retryDelay = 1
+  maxPageSize = 100
+  connectTimeout = 2
+
+  MaxRetries = maxRetries
+  DefaultTimeout = defaultTimeout
+  ApiBaseUrl = apiBaseUrl
+  PageSize = pageSize
+  RetryDelay = retryDelay
+  MaxPageSize = maxPageSize
+  ConnectTimeout = connectTimeout
+  DefaultHeaders = { 'Content-Type' => 'application/json', 'Accept' => 'application/json' }.freeze
+
+  def fetch_data(path)
+    url = URI(ApiBaseUrl + path)
+    request_with_retry(url, MaxRetries, DefaultTimeout)
+  end
+
+  def fetch_page(path, page)
+    size = [page, MaxPageSize].min
+    url = URI("#{ApiBaseUrl}#{path}?page=#{page}&size=#{size}")
+    request_with_retry(url, MaxRetries, DefaultTimeout)
+  end
+
+  def paginate_all(path)
+    all_items = []
+    page = 1
+
+    loop do
+      result = fetch_page(path, page)
+      return { ok: false, error: result[:error] } unless result[:ok]
+
+      all_items.concat(result[:data][:items])
+      break if result[:data][:items].length < PageSize
+
+      page += 1
+    end
+
+    { ok: true, data: all_items }
+  end
+
+  def post_data(path, body)
+    url = URI(ApiBaseUrl + path)
+    post_with_retry(url, body, MaxRetries)
+  end
+
+  private
+
+  def request_with_retry(url, retries_left, timeout)
+    http = Net::HTTP.new(url.host, url.port)
+    http.read_timeout = timeout
+    http.open_timeout = ConnectTimeout
+
+    request = Net::HTTP::Get.new(url)
+    DefaultHeaders.each { |k, v| request[k] = v }
+
+    response = http.request(request)
+
+    if response.code.to_i >= 500 && retries_left > 0
+      sleep(RetryDelay)
+      return request_with_retry(url, retries_left - 1, timeout)
+    end
+
+    return { ok: false, error: "HTTP #{response.code}" } unless response.is_a?(Net::HTTPSuccess)
+
+    { ok: true, data: JSON.parse(response.body, symbolize_names: true) }
+  rescue => error
+    if retries_left > 0
+      sleep(RetryDelay)
+      request_with_retry(url, retries_left - 1, timeout)
+    else
+      { ok: false, error: error.message }
+    end
+  end
+
+  def post_with_retry(url, body, retries_left)
+    http = Net::HTTP.new(url.host, url.port)
+    request = Net::HTTP::Post.new(url)
+    DefaultHeaders.each { |k, v| request[k] = v }
+    request.body = body.to_json
+
+    response = http.request(request)
+
+    return { ok: true, data: JSON.parse(response.body, symbolize_names: true) } if %w[200 201].include?(response.code)
+
+    if retries_left > 0
+      sleep(RetryDelay)
+      return post_with_retry(url, body, retries_left - 1)
+    end
+
+    { ok: false, error: "HTTP #{response.code}" }
+  rescue => error
+    { ok: false, error: error.message }
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/config.yml b/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/config.yml
new file mode 100644
index 0000000..36596fb
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/config.yml
@@ -0,0 +1 @@
+doc: "Module-level constants should use SCREAMING_SNAKE_CASE."
diff --git a/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/good/config.ex b/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/good/config.ex
new file mode 100644
index 0000000..6651c41
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/good/config.ex
@@ -0,0 +1,90 @@
+defmodule Config.Good do
+  @moduledoc """
+  Application config and HTTP client using correctly-cased module constants.
+  GOOD: module-level constants use SCREAMING_SNAKE_CASE as Elixir convention.
+  """
+
+  @MAX_RETRIES 3
+  @DEFAULT_TIMEOUT 5_000
+  @API_BASE_URL "https://api.example.com/v1"
+  @PAGE_SIZE 25
+  @RETRY_DELAY 1_000
+  @MAX_PAGE_SIZE 100
+  @CONNECT_TIMEOUT 2_000
+  @DEFAULT_HEADERS [{"Content-Type", "application/json"}, {"Accept", "application/json"}]
+
+  @spec fetch(String.t()) :: {:ok, map()} | {:error, String.t()}
+  def fetch(path) do
+    url = @API_BASE_URL <> path
+    do_request_with_retry(url, @MAX_RETRIES, @DEFAULT_TIMEOUT)
+  end
+
+  @spec fetch_page(String.t(), integer()) :: {:ok, map()} | {:error, String.t()}
+  def fetch_page(path, page) do
+    size = min(page, @MAX_PAGE_SIZE)
+    url = "#{@API_BASE_URL}#{path}?page=#{page}&size=#{size}"
+    do_request_with_retry(url, @MAX_RETRIES, @DEFAULT_TIMEOUT)
+  end
+
+  @spec paginate_all(String.t()) :: {:ok, list()} | {:error, String.t()}
+  def paginate_all(path) do
+    Stream.iterate(1, &(&1 + 1))
+    |> Stream.map(fn page ->
+      fetch_page(path, page)
+    end)
+    |> Stream.take_while(fn
+      {:ok, %{items: items}} -> length(items) == @PAGE_SIZE
+      _ -> false
+    end)
+    |> Enum.to_list()
+    |> then(fn results ->
+      if Enum.all?(results, &match?({:ok, _}, &1)),
+        do: {:ok, Enum.flat_map(results, fn {:ok, %{items: i}} -> i end)},
+        else: {:error, "Pagination failed"}
+    end)
+  end
+
+  @spec post(String.t(), map()) :: {:ok, map()} | {:error, String.t()}
+  def post(path, body) do
+    url = @API_BASE_URL <> path
+    do_post_with_retry(url, body, @MAX_RETRIES)
+  end
+
+  defp do_request_with_retry(url, retries_left, timeout) do
+    case HTTPoison.get(url, @DEFAULT_HEADERS, recv_timeout: timeout, connect_timeout: @CONNECT_TIMEOUT) do
+      {:ok, %{status_code: 200, body: body}} ->
+        {:ok, Jason.decode!(body)}
+
+      {:ok, %{status_code: status}} when status >= 500 and retries_left > 0 ->
+        Process.sleep(@RETRY_DELAY)
+        do_request_with_retry(url, retries_left - 1, timeout)
+
+      {:ok, %{status_code: status}} ->
+        {:error, "HTTP #{status}"}
+
+      {:error, err} when retries_left > 0 ->
+        Process.sleep(@RETRY_DELAY)
+        do_request_with_retry(url, retries_left - 1, timeout)
+
+      {:error, err} ->
+        {:error, inspect(err)}
+    end
+  end
+
+  defp do_post_with_retry(url, body, retries_left) do
+    case HTTPoison.post(url, Jason.encode!(body), @DEFAULT_HEADERS, recv_timeout: @DEFAULT_TIMEOUT) do
+      {:ok, %{status_code: code, body: resp}} when code in [200, 201] ->
+        {:ok, Jason.decode!(resp)}
+
+      {:ok, _} when retries_left > 0 ->
+        Process.sleep(@RETRY_DELAY)
+        do_post_with_retry(url, body, retries_left - 1)
+
+      {:ok, %{status_code: code}} ->
+        {:error, "HTTP #{code}"}
+
+      {:error, _} ->
+        {:error, "Request failed"}
+    end
+  end
+end
diff --git a/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/good/config.js b/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/good/config.js
new file mode 100644
index 0000000..8f5fea9
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/good/config.js
@@ -0,0 +1,105 @@
+// Application config and HTTP client using correctly-cased module constants.
+// GOOD: module-level constants use SCREAMING_SNAKE_CASE to distinguish them from variables.
+
+const MAX_RETRIES = 3;
+const DEFAULT_TIMEOUT = 5000;
+const API_BASE_URL = 'https://api.example.com/v1';
+const PAGE_SIZE = 25;
+const RETRY_DELAY = 1000;
+const MAX_PAGE_SIZE = 100;
+const CONNECT_TIMEOUT = 2000;
+const DEFAULT_HEADERS = {
+  'Content-Type': 'application/json',
+  'Accept': 'application/json',
+};
+
+async function fetchData(path) {
+  const url = API_BASE_URL + path;
+  return requestWithRetry(url, MAX_RETRIES, DEFAULT_TIMEOUT);
+}
+
+async function fetchPage(path, page) {
+  const size = Math.min(page, MAX_PAGE_SIZE);
+  const url = `${API_BASE_URL}${path}?page=${page}&size=${size}`;
+  return requestWithRetry(url, MAX_RETRIES, DEFAULT_TIMEOUT);
+}
+
+async function paginateAll(path) {
+  const allItems = [];
+  let page = 1;
+
+  while (true) {
+    const result = await fetchPage(path, page);
+    if (!result.ok) return result;
+
+    allItems.push(...result.data.items);
+
+    if (result.data.items.length < PAGE_SIZE) break;
+    page++;
+  }
+
+  return { ok: true, data: allItems };
+}
+
+async function postData(path, body) {
+  const url = API_BASE_URL + path;
+  return postWithRetry(url, body, MAX_RETRIES);
+}
+
+async function requestWithRetry(url, retriesLeft, timeout) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const response = await fetch(url, {
+      headers: DEFAULT_HEADERS,
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    if (response.status >= 500 && retriesLeft > 0) {
+      await sleep(RETRY_DELAY);
+      return requestWithRetry(url, retriesLeft - 1, timeout);
+    }
+
+    if (!response.ok) return { ok: false, error: `HTTP ${response.status}` };
+
+    const data = await response.json();
+    return { ok: true, data };
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (retriesLeft > 0) {
+      await sleep(RETRY_DELAY);
+      return requestWithRetry(url, retriesLeft - 1, timeout);
+    }
+    return { ok: false, error: error.message };
+  }
+}
+
+async function postWithRetry(url, body, retriesLeft) {
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: DEFAULT_HEADERS,
+      body: JSON.stringify(body),
+    });
+
+    if ([200, 201].includes(response.status)) {
+      return { ok: true, data: await response.json() };
+    }
+
+    if (retriesLeft > 0) {
+      await sleep(RETRY_DELAY);
+      return postWithRetry(url, body, retriesLeft - 1);
+    }
+
+    return { ok: false, error: `HTTP ${response.status}` };
+  } catch (error) {
+    return { ok: false, error: error.message };
+  }
+}
+
+function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); }
+
+module.exports = { fetchData, fetchPage, paginateAll, postData };
diff --git a/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/good/config.rb b/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/good/config.rb
new file mode 100644
index 0000000..4d6fcf5
--- /dev/null
+++ b/priv/combined_metrics/samples/variable_naming/screaming_snake_for_constants/good/config.rb
@@ -0,0 +1,99 @@
+# Application config and HTTP client using correctly-cased module constants.
+# GOOD: module-level constants use SCREAMING_SNAKE_CASE to distinguish them from variables.
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+class ConfigGood
+  MAX_RETRIES = 3
+  DEFAULT_TIMEOUT = 5
+  API_BASE_URL = 'https://api.example.com/v1'
+  PAGE_SIZE = 25
+  RETRY_DELAY = 1
+  MAX_PAGE_SIZE = 100
+  CONNECT_TIMEOUT = 2
+  DEFAULT_HEADERS = { 'Content-Type' => 'application/json', 'Accept' => 'application/json' }.freeze
+
+  def fetch_data(path)
+    url = URI(API_BASE_URL + path)
+    request_with_retry(url, MAX_RETRIES, DEFAULT_TIMEOUT)
+  end
+
+  def fetch_page(path, page)
+    size = [page, MAX_PAGE_SIZE].min
+    url = URI("#{API_BASE_URL}#{path}?page=#{page}&size=#{size}")
+    request_with_retry(url, MAX_RETRIES, DEFAULT_TIMEOUT)
+  end
+
+  def paginate_all(path)
+    all_items = []
+    page = 1
+
+    loop do
+      result = fetch_page(path, page)
+      return { ok: false, error: result[:error] } unless result[:ok]
+
+      all_items.concat(result[:data][:items])
+      break if result[:data][:items].length < PAGE_SIZE
+
+      page += 1
+    end
+
+    { ok: true, data: all_items }
+  end
+
+  def post_data(path, body)
+    url = URI(API_BASE_URL + path)
+    post_with_retry(url, body, MAX_RETRIES)
+  end
+
+  private
+
+  def request_with_retry(url, retries_left, timeout)
+    http = Net::HTTP.new(url.host, url.port)
+    http.read_timeout = timeout
+    http.open_timeout = CONNECT_TIMEOUT
+
+    request = Net::HTTP::Get.new(url)
+    DEFAULT_HEADERS.each { |k, v| request[k] = v }
+
+    response = http.request(request)
+
+    if response.code.to_i >= 500 && retries_left > 0
+      sleep(RETRY_DELAY)
+      return request_with_retry(url, retries_left - 1, timeout)
+    end
+
+    return { ok: false, error: "HTTP #{response.code}" } unless response.is_a?(Net::HTTPSuccess)
+
+    { ok: true, data: JSON.parse(response.body, symbolize_names: true) }
+  rescue => error
+    if retries_left > 0
+      sleep(RETRY_DELAY)
+      request_with_retry(url, retries_left - 1, timeout)
+    else
+      { ok: false, error: error.message }
+    end
+  end
+
+  def post_with_retry(url, body, retries_left)
+    http = Net::HTTP.new(url.host, url.port)
+    request = Net::HTTP::Post.new(url)
+    DEFAULT_HEADERS.each { |k, v| request[k] = v }
+    request.body = body.to_json
+
+    response = http.request(request)
+
+    return { ok: true, data: JSON.parse(response.body, symbolize_names: true) } if %w[200 201].include?(response.code)
+
+    if retries_left > 0
+      sleep(RETRY_DELAY)
+      return post_with_retry(url, body, retries_left - 1)
+    end
+
+    { ok: false, error: "HTTP #{response.code}" }
+  rescue => error
+    { ok: false, error: error.message }
+  end
+end
diff --git a/priv/combined_metrics/scope_and_assignment.yml b/priv/combined_metrics/scope_and_assignment.yml
new file mode 100644
index 0000000..507e8ae
--- /dev/null
+++ b/priv/combined_metrics/scope_and_assignment.yml
@@ -0,0 +1,625 @@
+declared_close_to_use:
+  _doc: "Variables should be declared near their first use, not hoisted to the top of the function."
+  _fix_hint: "Move variable declarations closer to their first use to reduce cognitive scope"
+  _log_baseline: -59.6022
+  branching:
+    mean_branch_count: -0.4906
+    mean_branching_density: -0.2814
+    mean_non_blank_count: -0.2090
+  brevity:
+    mean_sample_size: -0.2189
+  casing_entropy:
+    mean_entropy: 0.1835
+    mean_pascal_case_count: -0.1139
+    mean_snake_case_count: -0.3839
+  comment_structure:
+    mean_comment_line_count: -2.0000
+    mean_comment_line_ratio: 1.9655
+  compression:
+    mean_raw_bytes: -0.2840
+    mean_redundancy: -0.0394
+    mean_unique_line_ratio: 0.0151
+    mean_zlib_bytes: -0.2275
+    mean_zlib_ratio: -0.0566
+  entropy:
+    mean_char_entropy: 0.0079
+    mean_char_max_entropy: -0.0093
+    mean_char_normalized: 0.0172
+    mean_token_entropy: -0.0463
+    mean_token_max_entropy: -0.0451
+    mean_total_tokens: -0.2436
+    mean_vocab_size: -0.2189
+  function_metrics:
+    mean_avg_function_lines: -0.2057
+    mean_max_function_lines: -0.1704
+  halstead:
+    mean_N1_total_operators: -0.1397
+    mean_N2_total_operands: -0.3563
+    mean_difficulty: -0.1896
+    mean_effort: -0.4785
+    mean_estimated_bugs: -0.2888
+    mean_length: -0.2354
+    mean_n1_unique_operators: -0.1361
+    mean_n2_unique_operands: -0.3028
+    mean_time_to_implement_seconds: -0.4785
+    mean_vocabulary: -0.2576
+    mean_volume: -0.2889
+  heaps:
+    mean_beta: -0.0330
+    mean_k: 0.0180
+    mean_r_squared: 0.0061
+  identifier_length_variance:
+    mean_mean: 0.0259
+    mean_std_dev: 0.0252
+    mean_variance: 0.0505
+  indentation:
+    mean_blank_line_ratio: 0.0720
+    mean_mean_depth: 0.0139
+    mean_variance: 0.0738
+  line_patterns:
+    mean_blank_line_ratio: 0.0720
+    mean_string_literal_ratio: 0.1456
+  magic_number_density:
+    mean_density: -0.2641
+    mean_magic_number_count: -0.5094
+    mean_string_literal_ratio: 0.1456
+  ngram:
+    mean_bigram_hapax_fraction: 0.0140
+    mean_bigram_repeated_unique: -0.3088
+    mean_bigram_repetition_rate: -0.0208
+    mean_bigram_total: -0.2442
+    mean_bigram_unique: -0.2456
+    mean_trigram_hapax_fraction: -0.0098
+    mean_trigram_repeated_unique: -0.1403
+    mean_trigram_repetition_rate: 0.1025
+    mean_trigram_total: -0.2447
+    mean_trigram_unique: -0.2541
+  punctuation_density:
+    mean_arrow_density: 0.2442
+    mean_bracket_nonalpha_prefix_count: -0.1827
+    mean_bracket_nonalpha_suffix_count: -0.1215
+    mean_colon_suffix_density: 0.2436
+    mean_dot_count: 0.0423
+    mean_id_nonalpha_suffix_density: 0.1478
+    mean_question_mark_density: 0.2031
+  readability:
+    mean_avg_line_length: 0.0309
+    mean_avg_sub_words_per_id: 0.0089
+    mean_avg_tokens_per_line: -0.1463
+    mean_fog_adapted: -0.0885
+    mean_total_lines: -0.0974
+  symbol_density:
+    mean_density: 0.1303
+    mean_distinct_symbol_types: -0.0387
+    mean_symbol_count: -0.1541
+  vocabulary:
+    mean_mattr: -0.0662
+    mean_raw_ttr: 0.0986
+    mean_total_identifiers: -0.3537
+    mean_unique_identifiers: -0.2551
+  vowel_density:
+    mean_total_chars: -0.3278
+  zipf:
+    mean_exponent: -0.0151
+    mean_total_tokens: -0.2436
+    mean_vocab_size: -0.2189
+
+mutated_after_initial_assignment:
+  _doc: "Variables should not be reassigned after their initial value — prefer introducing a new name."
+  _fix_hint: "Avoid reassigning variables — introduce a new name for each transformed value"
+  _log_baseline: 6.6347
+  branching:
+    mean_branch_count: 0.1519
+    mean_branching_density: 0.2073
+    mean_max_nesting_depth: 0.0856
+    mean_non_blank_count: -0.0553
+  brevity:
+    mean_sample_size: 0.0068
+  casing_entropy:
+    mean_entropy: -0.0957
+    mean_pascal_case_count: -0.2061
+    mean_snake_case_count: -0.0467
+  compression:
+    mean_raw_bytes: -0.0496
+    mean_redundancy: -0.0291
+    mean_unique_line_ratio: -0.0110
+    mean_zlib_bytes: 0.0022
+    mean_zlib_ratio: -0.0518
+  entropy:
+    mean_char_entropy: -0.0034
+    mean_char_max_entropy: 0.0039
+    mean_char_normalized: -0.0074
+    mean_token_entropy: 0.0082
+    mean_token_max_entropy: 0.0015
+    mean_token_normalized: 0.0067
+    mean_total_tokens: -0.0392
+    mean_vocab_size: 0.0068
+  function_metrics:
+    mean_avg_function_lines: -0.1001
+    mean_max_function_lines: -0.0511
+  halstead:
+    mean_N1_total_operators: -0.0218
+    mean_N2_total_operands: -0.0623
+    mean_difficulty: -0.0341
+    mean_effort: -0.0690
+    mean_estimated_bugs: -0.0348
+    mean_length: -0.0382
+    mean_n1_unique_operators: 0.0337
+    mean_n2_unique_operands: 0.0056
+    mean_time_to_implement_seconds: -0.0690
+    mean_vocabulary: 0.0149
+    mean_volume: -0.0348
+  heaps:
+    mean_beta: 0.0300
+    mean_k: -0.0775
+    mean_r_squared: 0.0063
+  identifier_length_variance:
+    mean_mean: -0.0225
+    mean_std_dev: 0.0262
+    mean_variance: 0.0525
+  indentation:
+    mean_blank_line_ratio: -0.1139
+    mean_max_depth: 0.2725
+    mean_mean_depth: 0.0979
+    mean_variance: 0.5878
+  line_patterns:
+    mean_blank_line_ratio: -0.1139
+    mean_max_nesting_depth: 0.0856
+    mean_string_literal_ratio: 0.0397
+    mean_unique_line_ratio: -0.0203
+  magic_number_density:
+    mean_density: -0.6790
+    mean_magic_number_count: -0.7131
+    mean_string_literal_ratio: 0.0397
+  near_duplicate_blocks_file:
+    mean_sub_block_count: -0.1967
+  ngram:
+    mean_bigram_hapax_fraction: 0.0087
+    mean_bigram_repeated_unique: -0.0100
+    mean_bigram_repetition_rate: -0.0293
+    mean_bigram_total: -0.0393
+    mean_bigram_unique: 0.0068
+    mean_trigram_hapax_fraction: 0.0021
+    mean_trigram_repeated_unique: -0.0086
+    mean_trigram_repetition_rate: -0.0546
+    mean_trigram_total: -0.0394
+  punctuation_density:
+    mean_arrow_density: -1.5022
+    mean_bracket_nonalpha_prefix_count: 0.0497
+    mean_bracket_nonalpha_suffix_count: 0.4473
+    mean_colon_suffix_density: 0.3529
+    mean_dot_count: -0.1332
+    mean_exclamation_density: -2.0000
+    mean_id_nonalpha_suffix_density: 0.0542
+  readability:
+    mean_avg_line_length: 0.0073
+    mean_avg_sub_words_per_id: -0.0018
+    mean_avg_tokens_per_line: 0.0161
+    mean_fog_adapted: 0.0169
+    mean_total_lines: -0.0553
+  symbol_density:
+    mean_density: 0.0095
+    mean_distinct_symbol_types: 0.0436
+    mean_symbol_count: -0.0402
+  vocabulary:
+    mean_mattr: 0.0742
+    mean_raw_ttr: 0.0464
+    mean_total_identifiers: -0.0634
+    mean_unique_identifiers: -0.0170
+  vowel_density:
+    mean_total_chars: -0.0859
+  zipf:
+    mean_exponent: -0.0305
+    mean_r_squared: 0.0040
+    mean_total_tokens: -0.0392
+    mean_vocab_size: 0.0068
+
+reassigned_multiple_times:
+  _doc: "A variable reassigned many times is a sign the name is too generic or the function does too much."
+  _fix_hint: "Refactor repeated reassignment into a pipeline or named intermediate values"
+  _log_baseline: -107.5659
+  branching:
+    mean_non_blank_count: -0.2287
+  brevity:
+    mean_sample_size: 0.0287
+  casing_entropy:
+    mean_entropy: 0.2150
+    mean_pascal_case_count: -0.3434
+    mean_snake_case_count: -0.9136
+  compression:
+    mean_raw_bytes: -0.4804
+    mean_redundancy: -0.2638
+    mean_unique_line_ratio: -0.0172
+    mean_zlib_bytes: 0.0205
+    mean_zlib_ratio: -0.5009
+  entropy:
+    mean_char_entropy: 0.0869
+    mean_char_max_entropy: 0.0234
+    mean_char_normalized: 0.0636
+    mean_token_entropy: 0.0534
+    mean_token_normalized: 0.0470
+    mean_total_tokens: -0.4852
+    mean_vocab_size: 0.0287
+  function_metrics:
+    mean_avg_function_lines: -0.1143
+  halstead:
+    mean_N1_total_operators: -0.2160
+    mean_N2_total_operands: -0.9103
+    mean_difficulty: -1.1372
+    mean_effort: -1.6318
+    mean_estimated_bugs: -0.4946
+    mean_length: -0.5017
+    mean_n1_unique_operators: -0.1489
+    mean_n2_unique_operands: 0.0780
+    mean_time_to_implement_seconds: -1.6318
+    mean_vocabulary: 0.0309
+    mean_volume: -0.4946
+  heaps:
+    mean_beta: 0.2282
+    mean_k: -0.3898
+    mean_r_squared: 0.0349
+  identifier_length_variance:
+    mean_max: 0.3280
+    mean_mean: 0.3212
+    mean_std_dev: 0.8224
+    mean_variance: 1.6450
+  indentation:
+    mean_blank_line_ratio: 1.1002
+    mean_mean_depth: -0.0484
+    mean_variance: 0.1417
+  line_patterns:
+    mean_blank_line_ratio: 1.1002
+    mean_string_literal_ratio: 0.4958
+    mean_unique_line_ratio: -0.0236
+  magic_number_density:
+    mean_density: 0.4930
+    mean_string_literal_ratio: 0.4958
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.3280
+  ngram:
+    mean_bigram_hapax_fraction: 0.4509
+    mean_bigram_repeated_unique: -1.1755
+    mean_bigram_repetition_rate: -0.4690
+    mean_bigram_total: -0.4861
+    mean_bigram_unique: 0.0798
+    mean_trigram_hapax_fraction: 0.4536
+    mean_trigram_repeated_unique: -2.0000
+    mean_trigram_repetition_rate: -0.7942
+    mean_trigram_total: -0.4871
+    mean_trigram_unique: -0.0423
+  punctuation_density:
+    mean_colon_suffix_density: 0.4930
+    mean_dot_count: -0.4849
+    mean_id_nonalpha_suffix_density: -0.3517
+  readability:
+    mean_avg_line_length: -0.2630
+    mean_avg_sub_words_per_id: 0.1974
+    mean_avg_tokens_per_line: -0.2565
+    mean_flesch_adapted: -0.1476
+    mean_fog_adapted: -0.2565
+    mean_total_lines: -0.2287
+  symbol_density:
+    mean_density: 0.2755
+    mean_symbol_count: -0.2056
+  vocabulary:
+    mean_mattr: 0.9538
+    mean_raw_ttr: 0.9009
+    mean_total_identifiers: -0.7749
+    mean_unique_identifiers: 0.1260
+  vowel_density:
+    mean_total_chars: -0.4538
+  zipf:
+    mean_exponent: -0.2377
+    mean_total_tokens: -0.4852
+    mean_vocab_size: 0.0287
+
+scope_is_minimal:
+  _doc: "Variables should be scoped as narrowly as possible — not declared at a wider scope than needed."
+  _fix_hint: "Narrow the scope of variables — declare them in the innermost block where they are used"
+  _log_baseline: -6.7522
+  branching:
+    mean_branch_count: -0.1072
+    mean_branching_density: -0.0452
+    mean_non_blank_count: -0.0619
+  brevity:
+    mean_sample_size: -0.0368
+  casing_entropy:
+    mean_entropy: -0.0721
+    mean_other_count: -0.1823
+    mean_snake_case_count: 0.0081
+  comment_structure:
+    mean_comment_line_count: -0.4075
+    mean_comment_line_ratio: 2.0000
+  compression:
+    mean_raw_bytes: -0.1109
+    mean_redundancy: -0.0367
+    mean_unique_line_ratio: -0.1005
+    mean_zlib_bytes: -0.0343
+    mean_zlib_ratio: -0.0767
+  entropy:
+    mean_char_entropy: 0.0481
+    mean_char_normalized: 0.0481
+    mean_token_entropy: 0.0037
+    mean_token_max_entropy: -0.0081
+    mean_token_normalized: 0.0118
+    mean_total_tokens: 0.0143
+    mean_vocab_size: -0.0368
+  function_metrics:
+    mean_avg_function_lines: -0.2553
+    mean_avg_param_count: -0.1037
+    mean_function_count: 0.1691
+    mean_max_function_lines: -0.8149
+    mean_max_param_count: -0.4075
+  halstead:
+    mean_N1_total_operators: 0.0334
+    mean_N2_total_operands: -0.0363
+    mean_difficulty: 0.1281
+    mean_effort: 0.1258
+    mean_length: 0.0079
+    mean_n1_unique_operators: 0.0751
+    mean_n2_unique_operands: -0.0892
+    mean_time_to_implement_seconds: 0.1258
+    mean_vocabulary: -0.0460
+  heaps:
+    mean_beta: -0.0099
+    mean_k: -0.0341
+    mean_r_squared: 0.0103
+  identifier_length_variance:
+    mean_mean: -0.0389
+    mean_std_dev: 0.0545
+    mean_variance: 0.1090
+  indentation:
+    mean_blank_line_ratio: -0.1076
+    mean_max_depth: -0.4694
+    mean_mean_depth: -0.4430
+    mean_variance: -1.1640
+  line_patterns:
+    mean_blank_line_ratio: -0.1076
+    mean_string_literal_ratio: -0.0144
+    mean_unique_line_ratio: -0.0307
+  magic_number_density:
+    mean_string_literal_ratio: -0.0144
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.0447
+  ngram:
+    mean_bigram_hapax_fraction: -0.0078
+    mean_bigram_repeated_unique: 0.0406
+    mean_bigram_total: 0.0144
+    mean_bigram_unique: 0.0265
+    mean_trigram_hapax_fraction: 0.0113
+    mean_trigram_repeated_unique: 0.0074
+    mean_trigram_repetition_rate: -0.0382
+    mean_trigram_total: 0.0144
+    mean_trigram_unique: 0.0419
+  punctuation_density:
+    mean_arrow_density: -0.2974
+    mean_bracket_nonalpha_prefix_count: 0.7364
+    mean_bracket_nonalpha_suffix_count: 0.1691
+    mean_colon_suffix_density: -0.1217
+    mean_dot_count: 0.3290
+    mean_id_nonalpha_suffix_density: 0.0100
+  readability:
+    mean_avg_line_length: -0.0336
+    mean_avg_sub_words_per_id: -0.0359
+    mean_avg_tokens_per_line: 0.0563
+    mean_flesch_adapted: 0.0319
+    mean_fog_adapted: 0.0564
+    mean_total_lines: -0.0420
+  symbol_density:
+    mean_density: 0.1427
+    mean_distinct_symbol_types: 0.0336
+    mean_symbol_count: 0.0316
+  vocabulary:
+    mean_mattr: -0.0277
+    mean_raw_ttr: -0.0643
+    mean_total_identifiers: -0.0071
+    mean_unique_identifiers: -0.0713
+  vowel_density:
+    mean_total_chars: -0.0460
+  zipf:
+    mean_exponent: 0.0070
+    mean_total_tokens: 0.0143
+    mean_vocab_size: -0.0368
+
+shadowed_by_inner_scope:
+  _doc: "Inner-scope names that shadow outer-scope names cause confusion about which value is in play."
+  _fix_hint: "Rename the inner variable to avoid shadowing the outer one"
+  _log_baseline: -33.9501
+  branching:
+    mean_branching_density: 2.0000
+    mean_max_nesting_depth: -0.1450
+    mean_non_blank_count: -0.1418
+  brevity:
+    mean_sample_size: -0.0786
+  casing_entropy:
+    mean_entropy: 0.1125
+    mean_pascal_case_count: -0.0306
+    mean_snake_case_count: -0.2319
+  comment_structure:
+    mean_comment_line_count: -1.1073
+    mean_comment_line_ratio: 0.8936
+  compression:
+    mean_raw_bytes: -0.1107
+    mean_unique_line_ratio: -0.0068
+    mean_zlib_bytes: -0.1099
+  entropy:
+    mean_char_entropy: 0.0202
+    mean_char_max_entropy: -0.0068
+    mean_char_normalized: 0.0270
+    mean_token_entropy: -0.0147
+    mean_token_max_entropy: -0.0178
+    mean_token_normalized: 0.0030
+    mean_total_tokens: -0.1540
+    mean_vocab_size: -0.0786
+  function_metrics:
+    mean_avg_function_lines: -0.1314
+    mean_max_function_lines: -0.2043
+  halstead:
+    mean_N1_total_operators: -0.0341
+    mean_N2_total_operands: -0.2093
+    mean_difficulty: -0.1558
+    mean_effort: -0.2907
+    mean_estimated_bugs: -0.1349
+    mean_length: -0.1141
+    mean_n1_unique_operators: -0.0504
+    mean_n2_unique_operands: -0.1040
+    mean_time_to_implement_seconds: -0.2907
+    mean_vocabulary: -0.0894
+    mean_volume: -0.1349
+  heaps:
+    mean_beta: 0.0296
+    mean_k: -0.0817
+    mean_r_squared: -0.0030
+  identifier_length_variance:
+    mean_mean: 0.1455
+    mean_std_dev: 0.2453
+    mean_variance: 0.4905
+  indentation:
+    mean_blank_line_ratio: 0.0798
+    mean_mean_depth: -0.0595
+    mean_variance: -0.0634
+  line_patterns:
+    mean_blank_line_ratio: 0.0798
+    mean_max_nesting_depth: -0.1450
+    mean_string_literal_ratio: 0.1539
+    mean_unique_line_ratio: -0.0187
+  magic_number_density:
+    mean_density: 0.1539
+    mean_string_literal_ratio: 0.1539
+  ngram:
+    mean_bigram_hapax_fraction: 0.0443
+    mean_bigram_repeated_unique: -0.2754
+    mean_bigram_repetition_rate: -0.0922
+    mean_bigram_total: -0.1545
+    mean_bigram_unique: -0.1141
+    mean_trigram_hapax_fraction: 0.0321
+    mean_trigram_repeated_unique: -0.4412
+    mean_trigram_repetition_rate: -0.2046
+    mean_trigram_total: -0.1550
+    mean_trigram_unique: -0.1252
+  punctuation_density:
+    mean_arrow_density: 0.1539
+    mean_colon_suffix_density: 0.1539
+    mean_dot_count: -0.0206
+    mean_id_nonalpha_suffix_density: 0.0780
+  readability:
+    mean_avg_line_length: 0.0827
+    mean_avg_sub_words_per_id: 0.0859
+    mean_avg_tokens_per_line: -0.1060
+    mean_flesch_adapted: -0.0728
+    mean_fog_adapted: -0.1060
+    mean_total_lines: -0.0480
+  symbol_density:
+    mean_density: -0.0169
+    mean_distinct_symbol_types: -0.0561
+    mean_symbol_count: -0.1275
+  vocabulary:
+    mean_mattr: 0.0829
+    mean_raw_ttr: 0.1254
+    mean_total_identifiers: -0.2059
+    mean_unique_identifiers: -0.0804
+  vowel_density:
+    mean_total_chars: -0.0604
+  zipf:
+    mean_exponent: -0.0364
+    mean_r_squared: 0.0058
+    mean_total_tokens: -0.1540
+    mean_vocab_size: -0.0786
+
+used_only_once:
+  _doc: "A variable used only once is a candidate for inlining — it rarely adds clarity over a direct expression."
+  _fix_hint: "Inline single-use variables directly into their only use site"
+  _log_baseline: -116.4649
+  branching:
+    mean_non_blank_count: -0.5385
+  brevity:
+    mean_sample_size: -0.4955
+  casing_entropy:
+    mean_entropy: 0.6972
+    mean_snake_case_count: -1.1633
+  compression:
+    mean_raw_bytes: -0.8394
+    mean_redundancy: -0.1990
+    mean_unique_line_ratio: -0.2165
+    mean_zlib_bytes: -0.5910
+    mean_zlib_ratio: -0.2484
+  entropy:
+    mean_char_entropy: 0.0526
+    mean_char_normalized: 0.0407
+    mean_token_entropy: -0.0985
+    mean_token_max_entropy: -0.1058
+    mean_total_tokens: -0.4565
+    mean_vocab_size: -0.4955
+  function_metrics:
+    mean_avg_function_lines: -0.5273
+    mean_max_function_lines: -0.3325
+  halstead:
+    mean_N1_total_operators: -0.1758
+    mean_N2_total_operands: -1.1769
+    mean_difficulty: -0.2689
+    mean_effort: -0.9377
+    mean_estimated_bugs: -0.6685
+    mean_length: -0.5258
+    mean_n2_unique_operands: -0.9080
+    mean_time_to_implement_seconds: -0.9377
+    mean_vocabulary: -0.6531
+    mean_volume: -0.6688
+  heaps:
+    mean_k: -0.1674
+  identifier_length_variance:
+    mean_mean: -0.2014
+    mean_std_dev: 0.1846
+    mean_variance: 0.3694
+  indentation:
+    mean_blank_line_ratio: 0.4750
+    mean_max_depth: 1.2798
+    mean_mean_depth: 0.0995
+    mean_variance: 2.0000
+  line_patterns:
+    mean_blank_line_ratio: 0.4750
+    mean_string_literal_ratio: 0.1850
+    mean_unique_line_ratio: -0.2353
+  magic_number_density:
+    mean_string_literal_ratio: 0.1850
+  near_duplicate_blocks_file:
+    mean_sub_block_count: -0.7316
+  ngram:
+    mean_bigram_hapax_fraction: -0.2461
+    mean_bigram_repeated_unique: 0.1035
+    mean_bigram_repetition_rate: 0.6322
+    mean_bigram_total: -0.4576
+    mean_bigram_unique: -0.7819
+    mean_trigram_hapax_fraction: -0.1328
+    mean_trigram_repeated_unique: 0.5273
+    mean_trigram_repetition_rate: 0.9124
+    mean_trigram_total: -0.4587
+    mean_trigram_unique: -0.6298
+  punctuation_density:
+    mean_bracket_nonalpha_prefix_count: -0.2526
+    mean_bracket_nonalpha_suffix_count: 0.1540
+    mean_colon_suffix_density: 0.4612
+    mean_id_nonalpha_suffix_density: 0.0216
+    mean_question_mark_density: 0.9080
+  readability:
+    mean_avg_line_length: -0.3152
+    mean_avg_sub_words_per_id: -0.0458
+    mean_avg_tokens_per_line: 0.0820
+    mean_flesch_adapted: 0.0341
+    mean_fog_adapted: 0.1538
+    mean_total_lines: -0.5385
+  symbol_density:
+    mean_density: 0.6227
+    mean_symbol_count: -0.2178
+  vocabulary:
+    mean_mattr: 0.2063
+    mean_raw_ttr: 0.2647
+    mean_total_identifiers: -0.9999
+    mean_unique_identifiers: -0.7352
+  vowel_density:
+    mean_total_chars: -1.2013
+  zipf:
+    mean_exponent: 0.1820
+    mean_r_squared: -0.0230
+    mean_total_tokens: -0.4565
+    mean_vocab_size: -0.4955
+
diff --git a/priv/combined_metrics/testing.yml b/priv/combined_metrics/testing.yml
new file mode 100644
index 0000000..ef74557
--- /dev/null
+++ b/priv/combined_metrics/testing.yml
@@ -0,0 +1,420 @@
+reasonable_test_to_code_ratio:
+  _doc: "There should be an adequate number of test cases relative to the code being tested."
+  _fix_hint: "Add more tests — aim for at least one test per public function"
+  _log_baseline: 8.2261
+  branching:
+    mean_branch_count: 0.1869
+    mean_branching_density: 0.0352
+    mean_non_blank_count: 0.1517
+  brevity:
+    mean_sample_size: 0.0290
+  casing_entropy:
+    mean_entropy: 0.0597
+    mean_pascal_case_count: 0.2097
+    mean_snake_case_count: 0.0671
+  comment_structure:
+    mean_comment_line_count: -0.5246
+    mean_comment_line_ratio: 0.5016
+  compression:
+    mean_raw_bytes: 0.1290
+    mean_redundancy: 0.0346
+    mean_unique_line_ratio: -0.0556
+    mean_zlib_bytes: 0.0559
+    mean_zlib_ratio: 0.0732
+  entropy:
+    mean_char_entropy: -0.0074
+    mean_char_normalized: -0.0064
+    mean_token_entropy: 0.0033
+    mean_token_max_entropy: 0.0063
+    mean_token_normalized: -0.0029
+    mean_total_tokens: 0.1093
+    mean_vocab_size: 0.0290
+  function_metrics:
+    mean_avg_function_lines: -0.0273
+    mean_function_count: -0.0257
+    mean_max_function_lines: -0.0776
+  halstead:
+    mean_N1_total_operators: 0.1006
+    mean_N2_total_operands: 0.1082
+    mean_difficulty: 0.0314
+    mean_effort: 0.1446
+    mean_estimated_bugs: 0.1132
+    mean_length: 0.1034
+    mean_n1_unique_operators: -0.0102
+    mean_n2_unique_operands: 0.0667
+    mean_time_to_implement_seconds: 0.1446
+    mean_vocabulary: 0.0443
+    mean_volume: 0.1132
+  heaps:
+    mean_beta: -0.0095
+    mean_k: 0.0107
+    mean_r_squared: 0.0171
+  identifier_length_variance:
+    mean_mean: 0.0231
+    mean_std_dev: 0.0069
+    mean_variance: 0.0139
+  indentation:
+    mean_blank_line_ratio: -0.0175
+    mean_max_depth: 0.1093
+    mean_mean_depth: 0.1424
+    mean_variance: 0.3988
+  line_patterns:
+    mean_blank_line_ratio: -0.0175
+    mean_string_literal_ratio: 0.2536
+    mean_unique_line_ratio: -0.0582
+  magic_number_density:
+    mean_density: 0.3159
+    mean_magic_number_count: 0.4248
+    mean_string_literal_ratio: 0.2536
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.0723
+  ngram:
+    mean_bigram_hapax_fraction: -0.0173
+    mean_bigram_repeated_unique: 0.0681
+    mean_bigram_repetition_rate: 0.0346
+    mean_bigram_total: 0.1095
+    mean_bigram_unique: 0.0370
+    mean_trigram_hapax_fraction: -0.0158
+    mean_trigram_repeated_unique: 0.1118
+    mean_trigram_repetition_rate: 0.0487
+    mean_trigram_total: 0.1097
+    mean_trigram_unique: 0.0623
+  punctuation_density:
+    mean_bracket_number_pair_count: 0.1869
+    mean_colon_suffix_density: -0.1100
+    mean_dot_count: 0.2776
+    mean_exclamation_density: 2.0000
+    mean_id_nonalpha_suffix_density: -0.0296
+  readability:
+    mean_avg_line_length: -0.0303
+    mean_avg_tokens_per_line: -0.0880
+    mean_flesch_adapted: 0.0106
+    mean_fog_adapted: -0.0829
+    mean_total_lines: 0.1973
+  symbol_density:
+    mean_density: -0.0353
+    mean_distinct_symbol_types: -0.0284
+    mean_symbol_count: 0.0960
+  vocabulary:
+    mean_mattr: -0.0209
+    mean_raw_ttr: -0.0657
+    mean_total_identifiers: 0.0853
+    mean_unique_identifiers: 0.0196
+  vowel_density:
+    mean_total_chars: 0.1084
+  zipf:
+    mean_exponent: 0.0408
+    mean_r_squared: -0.0086
+    mean_total_tokens: 0.1093
+    mean_vocab_size: 0.0290
+
+test_has_assertion:
+  _doc: "Every test body must contain at least one assertion — a test without assertions proves nothing."
+  _fix_hint: "Add at least one assert/refute to every test — a test without assertions proves nothing"
+  _log_baseline: -9.6007
+  branching:
+    mean_branch_count: 0.0918
+    mean_branching_density: 0.1642
+    mean_non_blank_count: -0.0727
+  brevity:
+    mean_sample_size: -0.0555
+  casing_entropy:
+    mean_entropy: -0.0130
+    mean_other_count: -0.1294
+    mean_pascal_case_count: -0.0450
+    mean_snake_case_count: -0.0338
+  comment_structure:
+    mean_comment_line_count: -0.6211
+    mean_comment_line_ratio: 0.6522
+  compression:
+    mean_raw_bytes: -0.0140
+    mean_redundancy: 0.0137
+    mean_unique_line_ratio: -0.0037
+    mean_zlib_bytes: -0.0369
+    mean_zlib_ratio: 0.0229
+  entropy:
+    mean_char_entropy: 0.0022
+    mean_char_max_entropy: -0.0025
+    mean_char_normalized: 0.0048
+    mean_token_entropy: -0.0124
+    mean_token_max_entropy: -0.0118
+    mean_vocab_size: -0.0555
+  halstead:
+    mean_N1_total_operators: 0.0184
+    mean_N2_total_operands: -0.0481
+    mean_difficulty: 0.0979
+    mean_effort: 0.0682
+    mean_estimated_bugs: -0.0297
+    mean_length: -0.0087
+    mean_n1_unique_operators: 0.0130
+    mean_n2_unique_operands: -0.1329
+    mean_time_to_implement_seconds: 0.0682
+    mean_vocabulary: -0.0965
+    mean_volume: -0.0297
+  heaps:
+    mean_beta: -0.0415
+    mean_k: 0.0917
+    mean_r_squared: -0.0091
+  identifier_length_variance:
+    mean_mean: 0.0104
+    mean_std_dev: 0.0277
+    mean_variance: 0.0553
+  indentation:
+    mean_blank_line_ratio: 0.0261
+    mean_max_depth: -0.1294
+    mean_mean_depth: -0.0289
+    mean_variance: -0.0253
+  line_patterns:
+    mean_blank_line_ratio: 0.0261
+    mean_string_literal_ratio: -0.0139
+    mean_unique_line_ratio: -0.0056
+  magic_number_density:
+    mean_string_literal_ratio: -0.0139
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.0228
+  ngram:
+    mean_bigram_hapax_fraction: -0.0509
+    mean_bigram_repeated_unique: 0.0678
+    mean_bigram_repetition_rate: 0.0505
+    mean_bigram_unique: -0.0434
+    mean_trigram_hapax_fraction: -0.0376
+    mean_trigram_repeated_unique: 0.1149
+    mean_trigram_repetition_rate: 0.0832
+    mean_trigram_unique: -0.0336
+  punctuation_density:
+    mean_arrow_density: 2.0000
+    mean_bracket_nonalpha_prefix_count: -0.0712
+    mean_bracket_nonalpha_suffix_count: -0.0492
+    mean_colon_suffix_density: -0.0460
+    mean_dot_count: 0.0108
+    mean_id_nonalpha_suffix_density: 0.0127
+  readability:
+    mean_avg_line_length: 0.0691
+    mean_avg_sub_words_per_id: 0.0042
+    mean_avg_tokens_per_line: 0.0284
+    mean_flesch_adapted: -0.0065
+    mean_fog_adapted: 0.0284
+    mean_total_lines: -0.0284
+  symbol_density:
+    mean_density: 0.0263
+    mean_distinct_symbol_types: -0.0194
+    mean_symbol_count: 0.0126
+  vocabulary:
+    mean_mattr: -0.0644
+    mean_raw_ttr: -0.0389
+    mean_total_identifiers: -0.0370
+    mean_unique_identifiers: -0.0760
+  vowel_density:
+    mean_total_chars: -0.0266
+  zipf:
+    mean_exponent: 0.0248
+    mean_r_squared: -0.0049
+    mean_vocab_size: -0.0555
+
+test_name_describes_behavior:
+  _doc: "Test names should describe the expected behaviour, not just the method under test."
+  _fix_hint: "Describe expected behavior in test names: 'returns {:error, :not_found} when user missing'"
+  _log_baseline: 56.4575
+  branching:
+    mean_branch_count: 2.0000
+    mean_branching_density: -1.5965
+    mean_non_blank_count: 0.2388
+  brevity:
+    mean_sample_size: 0.1814
+  casing_entropy:
+    mean_entropy: -0.1587
+    mean_pascal_case_count: 0.0729
+    mean_snake_case_count: 0.3604
+  compression:
+    mean_raw_bytes: 0.3524
+    mean_redundancy: 0.0412
+    mean_unique_line_ratio: -0.0357
+    mean_zlib_bytes: 0.2483
+    mean_zlib_ratio: 0.1041
+  entropy:
+    mean_char_entropy: -0.0171
+    mean_char_max_entropy: 0.0138
+    mean_char_normalized: -0.0308
+    mean_token_entropy: 0.0449
+    mean_token_max_entropy: 0.0420
+    mean_total_tokens: 0.2704
+    mean_vocab_size: 0.1814
+  halstead:
+    mean_N1_total_operators: 0.2985
+    mean_N2_total_operands: 0.1414
+    mean_difficulty: 0.2542
+    mean_effort: 0.5528
+    mean_estimated_bugs: 0.2986
+    mean_length: 0.2432
+    mean_n1_unique_operators: 0.3063
+    mean_n2_unique_operands: 0.1935
+    mean_time_to_implement_seconds: 0.5528
+    mean_vocabulary: 0.2268
+    mean_volume: 0.2986
+  heaps:
+    mean_beta: 0.0106
+    mean_k: -0.0084
+  identifier_length_variance:
+    mean_mean: 0.0465
+  indentation:
+    mean_blank_line_ratio: -0.1184
+    mean_max_depth: 0.3691
+    mean_mean_depth: 0.3712
+    mean_variance: 0.8827
+  line_patterns:
+    mean_blank_line_ratio: -0.1184
+    mean_string_literal_ratio: -0.1419
+    mean_unique_line_ratio: -0.0535
+  magic_number_density:
+    mean_string_literal_ratio: -0.1419
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.0868
+  ngram:
+    mean_bigram_hapax_fraction: 0.0841
+    mean_bigram_repeated_unique: 0.1923
+    mean_bigram_repetition_rate: -0.0199
+    mean_bigram_total: 0.2709
+    mean_bigram_unique: 0.2850
+    mean_trigram_hapax_fraction: 0.0812
+    mean_trigram_repeated_unique: 0.1582
+    mean_trigram_repetition_rate: -0.0339
+    mean_trigram_total: 0.2715
+    mean_trigram_unique: 0.2823
+  punctuation_density:
+    mean_colon_suffix_density: -0.2725
+    mean_dot_count: 0.0701
+    mean_id_nonalpha_suffix_density: -0.0527
+  readability:
+    mean_avg_line_length: 0.1184
+    mean_avg_tokens_per_line: 0.0316
+    mean_total_lines: 0.2388
+  symbol_density:
+    mean_density: -0.1391
+    mean_distinct_symbol_types: 0.0729
+    mean_symbol_count: 0.2136
+  vocabulary:
+    mean_mattr: 0.0068
+    mean_raw_ttr: -0.1629
+    mean_total_identifiers: 0.3034
+    mean_unique_identifiers: 0.1403
+  vowel_density:
+    mean_total_chars: 0.3498
+  zipf:
+    mean_r_squared: 0.0095
+    mean_total_tokens: 0.2704
+    mean_vocab_size: 0.1814
+
+test_single_concept:
+  _doc: "Each test should verify a single concept — tests covering multiple things are harder to diagnose when they fail."
+  _fix_hint: "Test one thing per test — split tests covering multiple behaviors into separate test cases"
+  _log_baseline: 35.9646
+  branching:
+    mean_branch_count: 0.3696
+    mean_branching_density: -2.0000
+    mean_max_nesting_depth: 0.1534
+    mean_non_blank_count: 0.2620
+  brevity:
+    mean_sample_size: 0.0495
+  casing_entropy:
+    mean_entropy: -0.0975
+    mean_other_count: 0.3696
+    mean_pascal_case_count: -0.0146
+    mean_snake_case_count: 0.2046
+  comment_structure:
+    mean_comment_line_count: -1.0376
+    mean_comment_line_ratio: 1.0694
+  compression:
+    mean_raw_bytes: 0.1970
+    mean_redundancy: 0.0534
+    mean_unique_line_ratio: -0.1814
+    mean_zlib_bytes: 0.0851
+    mean_zlib_ratio: 0.1119
+  entropy:
+    mean_char_entropy: -0.0169
+    mean_char_normalized: -0.0187
+    mean_token_entropy: 0.0065
+    mean_token_max_entropy: 0.0104
+    mean_token_normalized: -0.0039
+    mean_total_tokens: 0.1633
+    mean_vocab_size: 0.0495
+  function_metrics:
+    mean_avg_function_lines: 0.8129
+    mean_avg_param_count: -0.0628
+    mean_function_count: 0.0628
+    mean_max_function_lines: 1.3538
+  halstead:
+    mean_N1_total_operators: 0.1507
+    mean_N2_total_operands: 0.0958
+    mean_difficulty: 0.1387
+    mean_effort: 0.2736
+    mean_estimated_bugs: 0.1348
+    mean_length: 0.1284
+    mean_n1_unique_operators: 0.0628
+    mean_n2_unique_operands: 0.0199
+    mean_time_to_implement_seconds: 0.2736
+    mean_vocabulary: 0.0302
+    mean_volume: 0.1349
+  heaps:
+    mean_beta: -0.0648
+    mean_k: 0.1502
+    mean_r_squared: 0.0046
+  identifier_length_variance:
+    mean_mean: 0.0149
+    mean_std_dev: 0.0642
+    mean_variance: 0.1285
+  indentation:
+    mean_blank_line_ratio: -0.0702
+    mean_max_depth: 0.2162
+    mean_mean_depth: 0.1207
+    mean_variance: 0.3787
+  line_patterns:
+    mean_blank_line_ratio: -0.0702
+    mean_max_nesting_depth: 0.1534
+    mean_string_literal_ratio: 0.3581
+    mean_unique_line_ratio: -0.1894
+  magic_number_density:
+    mean_density: -0.0115
+    mean_magic_number_count: 0.1534
+    mean_string_literal_ratio: 0.3581
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.1857
+  ngram:
+    mean_bigram_hapax_fraction: -0.0471
+    mean_bigram_repeated_unique: 0.1345
+    mean_bigram_repetition_rate: 0.0547
+    mean_bigram_total: 0.1635
+    mean_bigram_unique: 0.0656
+    mean_trigram_hapax_fraction: -0.0703
+    mean_trigram_repeated_unique: 0.2632
+    mean_trigram_repetition_rate: 0.1415
+    mean_trigram_total: 0.1638
+    mean_trigram_unique: 0.0672
+  punctuation_density:
+    mean_arrow_density: -0.1592
+    mean_bracket_nonalpha_prefix_count: 0.0712
+    mean_colon_suffix_density: -0.0922
+    mean_dot_count: 0.0317
+    mean_id_nonalpha_suffix_density: -0.0343
+  readability:
+    mean_avg_line_length: -0.1064
+    mean_avg_sub_words_per_id: 0.0125
+    mean_avg_tokens_per_line: -0.1758
+    mean_flesch_adapted: 0.0098
+    mean_fog_adapted: -0.1758
+    mean_total_lines: 0.3391
+  symbol_density:
+    mean_density: -0.0634
+    mean_symbol_count: 0.1338
+  vocabulary:
+    mean_mattr: -0.0722
+    mean_raw_ttr: -0.1338
+    mean_total_identifiers: 0.1750
+    mean_unique_identifiers: 0.0410
+  vowel_density:
+    mean_total_chars: 0.1898
+  zipf:
+    mean_exponent: 0.0281
+    mean_r_squared: -0.0039
+    mean_total_tokens: 0.1633
+    mean_vocab_size: 0.0495
+
diff --git a/priv/combined_metrics/type_and_value.yml b/priv/combined_metrics/type_and_value.yml
new file mode 100644
index 0000000..dc85081
--- /dev/null
+++ b/priv/combined_metrics/type_and_value.yml
@@ -0,0 +1,528 @@
+boolean_assigned_from_comparison:
+  _doc: "Boolean variables should be assigned directly from comparisons or predicate calls, not set via conditionals."
+  _fix_hint: "Assign the comparison result directly — bool = x > 0 not if x > 0 do true else false end"
+  _log_baseline: 3.2119
+  branching:
+    mean_branch_count: -0.8402
+    mean_branching_density: 0.3349
+    mean_max_nesting_depth: 0.1944
+    mean_non_blank_count: -0.2723
+  brevity:
+    mean_sample_size: 0.0454
+  casing_entropy:
+    mean_entropy: -0.1192
+    mean_other_count: -0.1944
+    mean_pascal_case_count: 0.1137
+    mean_snake_case_count: 0.1080
+  compression:
+    mean_raw_bytes: -0.0537
+    mean_redundancy: -0.0549
+    mean_unique_line_ratio: 0.0903
+    mean_zlib_bytes: 0.0350
+    mean_zlib_ratio: -0.0887
+  entropy:
+    mean_char_entropy: 0.0469
+    mean_char_max_entropy: 0.0084
+    mean_char_normalized: 0.0385
+    mean_token_entropy: 0.0094
+    mean_token_max_entropy: 0.0103
+    mean_total_tokens: 0.0172
+    mean_vocab_size: 0.0454
+  function_metrics:
+    mean_avg_function_lines: -0.3955
+    mean_function_count: 0.1137
+    mean_max_function_lines: -0.4184
+  halstead:
+    mean_N1_total_operators: 0.0223
+    mean_N2_total_operands: 0.0441
+    mean_difficulty: -0.1054
+    mean_effort: -0.0588
+    mean_estimated_bugs: 0.0466
+    mean_length: 0.0317
+    mean_n1_unique_operators: -0.0359
+    mean_n2_unique_operands: 0.1137
+    mean_time_to_implement_seconds: -0.0588
+    mean_vocabulary: 0.0635
+    mean_volume: 0.0466
+  heaps:
+    mean_beta: 0.0212
+    mean_k: -0.0531
+    mean_r_squared: 0.0046
+  identifier_length_variance:
+    mean_max: 0.0208
+    mean_mean: 0.0195
+    mean_std_dev: -0.0085
+    mean_variance: -0.0171
+  indentation:
+    mean_blank_line_ratio: 0.1081
+    mean_max_depth: -0.2570
+    mean_mean_depth: -0.2106
+    mean_variance: -0.3879
+  line_patterns:
+    mean_blank_line_ratio: 0.1081
+    mean_max_nesting_depth: 0.1944
+    mean_string_literal_ratio: -0.0182
+    mean_unique_line_ratio: 0.1190
+  magic_number_density:
+    mean_density: 0.1772
+    mean_magic_number_count: 0.1944
+    mean_string_literal_ratio: -0.0182
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.2455
+  ngram:
+    mean_bigram_hapax_fraction: 0.0123
+    mean_bigram_repeated_unique: -0.0200
+    mean_bigram_repetition_rate: -0.0701
+    mean_bigram_total: 0.0173
+    mean_bigram_unique: 0.0466
+    mean_trigram_hapax_fraction: 0.0153
+    mean_trigram_repeated_unique: -0.1345
+    mean_trigram_repetition_rate: -0.1804
+    mean_trigram_total: 0.0174
+    mean_trigram_unique: 0.0434
+  punctuation_density:
+    mean_arrow_density: 0.9500
+    mean_bracket_nonalpha_prefix_count: 0.1137
+    mean_colon_suffix_density: 0.0338
+    mean_dot_count: 0.1570
+    mean_exclamation_density: -2.0000
+    mean_id_nonalpha_suffix_density: 0.1365
+  readability:
+    mean_avg_line_length: 0.2263
+    mean_avg_sub_words_per_id: 0.0384
+    mean_avg_tokens_per_line: 0.2895
+    mean_flesch_adapted: -0.0583
+    mean_fog_adapted: 0.2895
+    mean_total_lines: -0.2723
+  symbol_density:
+    mean_density: 0.1390
+    mean_distinct_symbol_types: 0.0351
+    mean_symbol_count: 0.0855
+  vocabulary:
+    mean_raw_ttr: -0.0051
+    mean_total_identifiers: 0.1004
+    mean_unique_identifiers: 0.0953
+  vowel_density:
+    mean_total_chars: 0.1199
+  zipf:
+    mean_exponent: -0.0211
+    mean_r_squared: 0.0120
+    mean_total_tokens: 0.0172
+    mean_vocab_size: 0.0454
+
+hardcoded_url_or_path:
+  _doc: "URLs, file paths, and host names should be configuration values, not inline string literals."
+  _fix_hint: "Move hardcoded URLs and file paths to configuration or module attributes"
+  _log_baseline: 119.8203
+  branching:
+    mean_max_nesting_depth: 0.9571
+  brevity:
+    mean_sample_size: 0.3152
+  casing_entropy:
+    mean_entropy: -0.1421
+    mean_other_count: -2.0000
+    mean_pascal_case_count: 0.9571
+    mean_snake_case_count: 0.1889
+  compression:
+    mean_raw_bytes: 0.6634
+    mean_redundancy: 0.1246
+    mean_unique_line_ratio: 0.1310
+    mean_zlib_bytes: 0.4741
+    mean_zlib_ratio: 0.1894
+  entropy:
+    mean_char_entropy: 0.0190
+    mean_char_normalized: 0.0281
+    mean_token_entropy: 0.0674
+    mean_token_max_entropy: 0.0678
+    mean_total_tokens: 0.4785
+    mean_vocab_size: 0.3152
+  function_metrics:
+    mean_avg_function_lines: -0.8947
+    mean_avg_param_count: 0.9571
+    mean_function_count: 0.7942
+    mean_max_param_count: 0.9571
+  halstead:
+    mean_N1_total_operators: 0.5692
+    mean_N2_total_operands: 0.7517
+    mean_difficulty: 0.1642
+    mean_effort: 0.9625
+    mean_estimated_bugs: 0.7982
+    mean_length: 0.6248
+    mean_n1_unique_operators: 0.3299
+    mean_n2_unique_operands: 0.9174
+    mean_time_to_implement_seconds: 0.9625
+    mean_vocabulary: 0.7373
+    mean_volume: 0.7983
+  heaps:
+    mean_beta: 0.0461
+    mean_k: -0.1568
+  identifier_length_variance:
+    mean_mean: 0.6914
+    mean_std_dev: 0.5873
+    mean_variance: 1.1745
+  indentation:
+    mean_blank_line_ratio: 0.3864
+    mean_mean_depth: -0.2779
+    mean_variance: -0.3554
+  line_patterns:
+    mean_blank_line_ratio: 0.3864
+    mean_max_nesting_depth: 0.9571
+    mean_string_literal_ratio: -0.0201
+    mean_unique_line_ratio: 0.1351
+  magic_number_density:
+    mean_density: -0.4116
+    mean_string_literal_ratio: -0.0201
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.8771
+  ngram:
+    mean_bigram_hapax_fraction: -0.1563
+    mean_bigram_repeated_unique: 0.8894
+    mean_bigram_repetition_rate: 0.0704
+    mean_bigram_total: 0.4796
+    mean_bigram_unique: 0.5223
+    mean_trigram_repeated_unique: 0.6908
+    mean_trigram_repetition_rate: -0.2750
+    mean_trigram_total: 0.4807
+    mean_trigram_unique: 0.7019
+  punctuation_density:
+    mean_bracket_nonalpha_prefix_count: 1.1094
+    mean_bracket_nonalpha_suffix_count: 2.0000
+    mean_colon_suffix_density: -0.4737
+    mean_dot_count: 0.1098
+    mean_exclamation_density: 0.2954
+    mean_id_nonalpha_suffix_density: -0.1516
+    mean_question_mark_density: -0.7321
+  readability:
+    mean_avg_line_length: 0.6849
+    mean_avg_sub_words_per_id: 0.4262
+    mean_avg_tokens_per_line: 0.4785
+    mean_flesch_adapted: -0.4974
+    mean_fog_adapted: 1.0160
+  symbol_density:
+    mean_density: -0.0213
+    mean_symbol_count: 0.6424
+  vocabulary:
+    mean_mattr: 0.3608
+    mean_raw_ttr: 0.1636
+    mean_total_identifiers: 0.1955
+    mean_unique_identifiers: 0.3588
+  vowel_density:
+    mean_total_chars: 0.8868
+  zipf:
+    mean_r_squared: 0.0346
+    mean_total_tokens: 0.4785
+    mean_vocab_size: 0.3152
+
+no_empty_string_initial:
+  _doc: "Initialising a variable to an empty string and reassigning later signals missing structure."
+  _fix_hint: "Replace initial empty string assignments with nil or a meaningful default value"
+  _log_baseline: -11.4915
+  branching:
+    mean_branch_count: -0.1786
+    mean_max_nesting_depth: -0.1294
+    mean_non_blank_count: -0.1786
+  brevity:
+    mean_sample_size: -0.0035
+  casing_entropy:
+    mean_entropy: -0.1033
+    mean_other_count: -0.6637
+    mean_pascal_case_count: 0.0802
+    mean_snake_case_count: -0.0041
+  compression:
+    mean_raw_bytes: -0.0782
+    mean_redundancy: -0.0287
+    mean_unique_line_ratio: 0.0310
+    mean_zlib_bytes: -0.0379
+    mean_zlib_ratio: -0.0404
+  entropy:
+    mean_char_entropy: 0.0283
+    mean_char_normalized: 0.0283
+    mean_token_entropy: 0.0161
+    mean_token_normalized: 0.0169
+    mean_total_tokens: -0.0149
+    mean_vocab_size: -0.0035
+  function_metrics:
+    mean_avg_function_lines: -0.3885
+    mean_function_count: 0.1786
+    mean_max_function_lines: -0.2468
+  halstead:
+    mean_N1_total_operators: 0.0444
+    mean_N2_total_operands: -0.0445
+    mean_difficulty: 0.0151
+    mean_effort: 0.0252
+    mean_estimated_bugs: 0.0101
+    mean_length: 0.0132
+    mean_n1_unique_operators: 0.0266
+    mean_n2_unique_operands: -0.0329
+    mean_time_to_implement_seconds: 0.0252
+    mean_vocabulary: -0.0132
+    mean_volume: 0.0101
+  heaps:
+    mean_beta: 0.0171
+    mean_k: -0.0214
+    mean_r_squared: -0.0034
+  identifier_length_variance:
+    mean_mean: -0.0210
+    mean_std_dev: -0.0040
+    mean_variance: -0.0080
+  indentation:
+    mean_blank_line_ratio: -0.0652
+    mean_mean_depth: -0.0937
+    mean_variance: -0.0350
+  line_patterns:
+    mean_blank_line_ratio: -0.0652
+    mean_max_nesting_depth: -0.1294
+    mean_string_literal_ratio: -0.2412
+    mean_unique_line_ratio: 0.0092
+  magic_number_density:
+    mean_string_literal_ratio: -0.2412
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.2212
+  ngram:
+    mean_bigram_hapax_fraction: -0.0336
+    mean_bigram_repeated_unique: 0.0542
+    mean_bigram_repetition_rate: 0.0363
+    mean_bigram_total: -0.0149
+    mean_bigram_unique: -0.0294
+    mean_trigram_hapax_fraction: -0.0403
+    mean_trigram_repeated_unique: 0.1410
+    mean_trigram_repetition_rate: 0.1489
+    mean_trigram_total: -0.0150
+    mean_trigram_unique: -0.0536
+  punctuation_density:
+    mean_bracket_nonalpha_prefix_count: -0.0918
+    mean_colon_suffix_density: 0.6122
+    mean_dot_count: 0.0246
+    mean_exclamation_density: 2.0000
+    mean_id_nonalpha_suffix_density: 0.1461
+  readability:
+    mean_avg_line_length: 0.1060
+    mean_avg_sub_words_per_id: 0.0097
+    mean_avg_tokens_per_line: 0.1637
+    mean_flesch_adapted: -0.0183
+    mean_fog_adapted: 0.1637
+    mean_total_lines: -0.1786
+  symbol_density:
+    mean_density: 0.0683
+    mean_distinct_symbol_types: 0.0164
+    mean_symbol_count: -0.0101
+  vocabulary:
+    mean_total_identifiers: -0.0164
+    mean_unique_identifiers: -0.0167
+  vowel_density:
+    mean_total_chars: -0.0374
+  zipf:
+    mean_exponent: -0.0054
+    mean_r_squared: -0.0034
+    mean_total_tokens: -0.0149
+    mean_vocab_size: -0.0035
+
+no_implicit_null_initial:
+  _doc: "Initialising a variable to `nil`/`null` and assigning it later in a branch signals missing structure."
+  _fix_hint: "Use nil explicitly when a variable starts null — or restructure to avoid nil initialization"
+  _log_baseline: -3.2196
+  branching:
+    mean_branch_count: 0.0293
+    mean_branching_density: 0.0871
+    mean_non_blank_count: -0.0578
+  brevity:
+    mean_sample_size: 0.0132
+  casing_entropy:
+    mean_entropy: 0.0619
+    mean_other_count: 0.1247
+    mean_screaming_snake_density: 0.0422
+    mean_snake_case_count: -0.0452
+  compression:
+    mean_raw_bytes: -0.0246
+    mean_redundancy: -0.0100
+    mean_unique_line_ratio: -0.0159
+    mean_zlib_bytes: -0.0071
+    mean_zlib_ratio: -0.0174
+  entropy:
+    mean_char_entropy: 0.0071
+    mean_char_max_entropy: 0.0063
+    mean_token_entropy: -0.0025
+    mean_token_max_entropy: 0.0029
+    mean_token_normalized: -0.0055
+    mean_vocab_size: 0.0132
+  function_metrics:
+    mean_avg_function_lines: -0.1325
+    mean_avg_param_count: -0.0029
+    mean_function_count: 0.0440
+    mean_max_function_lines: -0.1618
+  halstead:
+    mean_N1_total_operators: 0.0268
+    mean_N2_total_operands: -0.0416
+    mean_difficulty: 0.0085
+    mean_effort: 0.0109
+    mean_estimated_bugs: 0.0024
+    mean_n1_unique_operators: 0.0393
+    mean_n2_unique_operands: -0.0108
+    mean_time_to_implement_seconds: 0.0109
+    mean_vocabulary: 0.0038
+    mean_volume: 0.0024
+  heaps:
+    mean_beta: -0.0079
+    mean_k: 0.0418
+    mean_r_squared: -0.0034
+  identifier_length_variance:
+    mean_mean: 0.0130
+    mean_std_dev: 0.0211
+    mean_variance: 0.0423
+  indentation:
+    mean_blank_line_ratio: -0.1146
+    mean_mean_depth: 0.0089
+    mean_variance: 0.1759
+  line_patterns:
+    mean_blank_line_ratio: -0.1146
+    mean_string_literal_ratio: -0.0022
+    mean_unique_line_ratio: -0.0135
+  magic_number_density:
+    mean_density: -0.0066
+    mean_string_literal_ratio: -0.0022
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.0422
+  ngram:
+    mean_bigram_hapax_fraction: -0.0181
+    mean_bigram_repeated_unique: 0.0178
+    mean_bigram_repetition_rate: 0.0335
+    mean_bigram_unique: -0.0287
+    mean_trigram_hapax_fraction: -0.0209
+    mean_trigram_repeated_unique: 0.0959
+    mean_trigram_repetition_rate: 0.0860
+    mean_trigram_unique: -0.0245
+  punctuation_density:
+    mean_arrow_density: -1.4388
+    mean_bracket_nonalpha_prefix_count: 0.0807
+    mean_bracket_nonalpha_suffix_count: 0.1035
+    mean_colon_suffix_density: 0.1166
+    mean_exclamation_density: 2.0000
+    mean_id_nonalpha_suffix_density: 0.0685
+  readability:
+    mean_avg_line_length: 0.0358
+    mean_avg_sub_words_per_id: 0.0035
+    mean_avg_tokens_per_line: 0.0586
+    mean_flesch_adapted: -0.0082
+    mean_fog_adapted: 0.0549
+    mean_total_lines: -0.0578
+  symbol_density:
+    mean_density: 0.0549
+    mean_distinct_symbol_types: 0.0342
+    mean_symbol_count: 0.0303
+  vocabulary:
+    mean_mattr: 0.0148
+    mean_raw_ttr: 0.0350
+    mean_total_identifiers: -0.0402
+    mean_unique_identifiers: -0.0052
+  vowel_density:
+    mean_total_chars: -0.0272
+  zipf:
+    mean_exponent: -0.0074
+    mean_r_squared: 0.0047
+    mean_vocab_size: 0.0132
+
+no_magic_value_assigned:
+  _doc: "Literal strings and numbers assigned to variables should be named constants, not inline values."
+  _fix_hint: "Replace magic value assignments with named constants or module attributes"
+  _log_baseline: -6.5439
+  branching:
+    mean_branch_count: -0.2035
+    mean_branching_density: -0.1140
+    mean_non_blank_count: -0.0893
+  brevity:
+    mean_sample_size: -0.0122
+  casing_entropy:
+    mean_entropy: -0.0570
+    mean_other_count: -0.3211
+    mean_snake_case_count: -0.0248
+  compression:
+    mean_raw_bytes: -0.1800
+    mean_redundancy: -0.0342
+    mean_unique_line_ratio: 0.0140
+    mean_zlib_bytes: -0.1207
+    mean_zlib_ratio: -0.0593
+  entropy:
+    mean_char_max_entropy: -0.0144
+    mean_char_normalized: 0.0154
+    mean_token_entropy: 0.0837
+    mean_token_normalized: 0.0863
+    mean_total_tokens: -0.1270
+    mean_vocab_size: -0.0122
+  function_metrics:
+    mean_avg_function_lines: -1.1104
+    mean_avg_param_count: -0.3099
+    mean_function_count: 0.8801
+    mean_max_function_lines: -0.5872
+  halstead:
+    mean_N1_total_operators: 0.2796
+    mean_N2_total_operands: -0.0340
+    mean_difficulty: -0.1408
+    mean_effort: 0.0099
+    mean_estimated_bugs: 0.1506
+    mean_length: 0.1539
+    mean_n1_unique_operators: -0.0859
+    mean_n2_unique_operands: 0.0209
+    mean_time_to_implement_seconds: 0.0099
+    mean_vocabulary: -0.0140
+    mean_volume: 0.1507
+  heaps:
+    mean_beta: 0.0889
+    mean_k: -0.2042
+    mean_r_squared: 0.0230
+  identifier_length_variance:
+    mean_max: -0.0438
+    mean_mean: -0.1573
+    mean_std_dev: -0.2110
+    mean_variance: -0.4220
+  indentation:
+    mean_blank_line_ratio: -0.1918
+    mean_mean_depth: -0.2808
+    mean_variance: -0.1572
+  line_patterns:
+    mean_blank_line_ratio: -0.1918
+    mean_string_literal_ratio: -1.7484
+    mean_unique_line_ratio: 0.0086
+  magic_number_density:
+    mean_string_literal_ratio: -1.7484
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.2805
+  ngram:
+    mean_bigram_hapax_fraction: 0.0998
+    mean_bigram_repeated_unique: -0.1265
+    mean_bigram_repetition_rate: -0.2414
+    mean_bigram_total: -0.1274
+    mean_bigram_unique: 0.1208
+    mean_trigram_hapax_fraction: 0.1034
+    mean_trigram_repeated_unique: -0.9134
+    mean_trigram_repetition_rate: -0.8787
+    mean_trigram_total: -0.1278
+    mean_trigram_unique: 0.1009
+  punctuation_density:
+    mean_arrow_density: -0.3964
+    mean_bracket_nonalpha_prefix_count: -0.7737
+    mean_bracket_nonalpha_suffix_count: 2.0000
+    mean_colon_suffix_density: -0.2477
+    mean_id_nonalpha_suffix_density: -0.0427
+    mean_question_mark_density: 0.9772
+  readability:
+    mean_avg_line_length: -0.0927
+    mean_avg_sub_words_per_id: -0.1514
+    mean_avg_tokens_per_line: -0.0377
+    mean_flesch_adapted: 0.2297
+    mean_fog_adapted: -0.5835
+    mean_total_lines: -0.0893
+  symbol_density:
+    mean_density: -0.0945
+    mean_symbol_count: -0.2742
+  vocabulary:
+    mean_mattr: 0.0329
+    mean_raw_ttr: 0.0328
+    mean_total_identifiers: -0.0327
+  vowel_density:
+    mean_total_chars: -0.1899
+  zipf:
+    mean_exponent: -0.0525
+    mean_r_squared: 0.0208
+    mean_total_tokens: -0.1270
+    mean_vocab_size: -0.0122
+
diff --git a/priv/combined_metrics/variable_naming.yml b/priv/combined_metrics/variable_naming.yml
new file mode 100644
index 0000000..8b9a7dc
--- /dev/null
+++ b/priv/combined_metrics/variable_naming.yml
@@ -0,0 +1,1209 @@
+boolean_has_is_has_prefix:
+  _doc: "Boolean variables should be prefixed with `is_`, `has_`, or `can_`."
+  _fix_hint: "Prefix boolean variables with is_, has_, or can_ (e.g., is_valid, has_errors)"
+  _log_baseline: 15.9674
+  brevity:
+    mean_sample_size: 0.0752
+  casing_entropy:
+    mean_camel_case_count: 2.0000
+    mean_entropy: 0.5244
+    mean_snake_case_count: -0.2159
+  compression:
+    mean_raw_bytes: 0.1698
+    mean_redundancy: 0.0581
+    mean_zlib_bytes: 0.0387
+    mean_zlib_ratio: 0.1318
+  entropy:
+    mean_char_entropy: 0.0136
+    mean_token_entropy: 0.0198
+    mean_token_max_entropy: 0.0173
+    mean_vocab_size: 0.0752
+  halstead:
+    mean_difficulty: -0.0725
+    mean_effort: -0.0594
+    mean_estimated_bugs: 0.0109
+    mean_n2_unique_operands: 0.0694
+    mean_time_to_implement_seconds: -0.0594
+    mean_vocabulary: 0.0494
+    mean_volume: 0.0110
+  heaps:
+    mean_k: 0.1146
+  identifier_length_variance:
+    mean_max: 0.3229
+    mean_mean: 0.3020
+    mean_std_dev: 0.3453
+    mean_variance: 0.6908
+  ngram:
+    mean_bigram_hapax_fraction: 0.0164
+    mean_bigram_repeated_unique: -0.0209
+    mean_bigram_repetition_rate: -0.0199
+    mean_bigram_unique: 0.0182
+    mean_trigram_repeated_unique: -0.0226
+    mean_trigram_repetition_rate: -0.0134
+  punctuation_density:
+    mean_exclamation_density: -0.1826
+    mean_question_mark_density: -0.1720
+  readability:
+    mean_avg_line_length: 0.1754
+    mean_avg_sub_words_per_id: 0.3932
+    mean_flesch_adapted: -0.4857
+    mean_fog_adapted: 0.5482
+  symbol_density:
+    mean_density: -0.1660
+  vocabulary:
+    mean_mattr: 0.1133
+    mean_raw_ttr: 0.1095
+    mean_unique_identifiers: 0.1095
+  vowel_density:
+    mean_total_chars: 0.3030
+  zipf:
+    mean_exponent: -0.0403
+    mean_r_squared: 0.0110
+    mean_vocab_size: 0.0752
+
+collection_name_is_plural:
+  _doc: "Variables holding a collection should use a plural name."
+  _fix_hint: "Use plural names for collections (users, orders, ids not user, order, id)"
+  _log_baseline: 32.4645
+  brevity:
+    mean_sample_size: -0.6992
+  casing_entropy:
+    mean_camel_case_count: 0.6209
+    mean_entropy: 0.2223
+    mean_snake_case_count: -0.1349
+  compression:
+    mean_raw_bytes: 1.0908
+    mean_redundancy: 0.4215
+    mean_zlib_bytes: 0.1628
+    mean_zlib_ratio: 0.9437
+  entropy:
+    mean_token_entropy: -0.1350
+    mean_token_max_entropy: -0.1629
+    mean_vocab_size: -0.6992
+  halstead:
+    mean_N2_total_operands: -0.0666
+    mean_difficulty: 0.9299
+    mean_effort: 0.6844
+    mean_estimated_bugs: -0.2047
+    mean_n2_unique_operands: -1.0118
+    mean_time_to_implement_seconds: 0.6844
+    mean_vocabulary: -0.6902
+    mean_volume: -0.2049
+  heaps:
+    mean_k: -0.9514
+  identifier_length_variance:
+    mean_mean: 2.0000
+    mean_std_dev: -0.8154
+    mean_variance: -1.6626
+  ngram:
+    mean_bigram_hapax_fraction: -0.1830
+    mean_bigram_repetition_rate: 0.1958
+    mean_bigram_unique: -0.2431
+    mean_trigram_repeated_unique: -0.2204
+  punctuation_density:
+    mean_arrow_density: 0.0922
+    mean_colon_suffix_density: -1.0500
+    mean_question_mark_density: -0.7411
+  readability:
+    mean_avg_line_length: 1.1368
+    mean_avg_sub_words_per_id: 0.1688
+    mean_flesch_adapted: -0.1723
+    mean_fog_adapted: 1.0561
+  symbol_density:
+    mean_density: -1.1302
+  vocabulary:
+    mean_mattr: -0.8764
+    mean_raw_ttr: -1.0193
+    mean_total_identifiers: -0.0701
+    mean_unique_identifiers: -1.0655
+  vowel_density:
+    mean_total_chars: 1.9266
+  zipf:
+    mean_exponent: 0.2071
+    mean_r_squared: -0.1226
+    mean_vocab_size: -0.6992
+
+loop_var_is_single_letter:
+  _doc: "Loop index variables (`i`, `j`, `k`) are acceptable inside loop bodies."
+  _fix_hint: "Use descriptive loop variable names instead of single letters (user not u)"
+  _log_baseline: -28.4780
+  brevity:
+    mean_sample_size: -0.1049
+  casing_entropy:
+    mean_camel_case_count: -2.0000
+    mean_entropy: -0.3852
+    mean_snake_case_count: 0.2130
+  comment_structure:
+    mean_comment_line_ratio: 0.0080
+  compression:
+    mean_raw_bytes: -0.4302
+    mean_redundancy: -0.1176
+    mean_unique_line_ratio: -0.0195
+    mean_zlib_bytes: -0.1067
+    mean_zlib_ratio: -0.3218
+  entropy:
+    mean_char_normalized: -0.0122
+    mean_token_entropy: -0.0181
+    mean_token_max_entropy: -0.0244
+    mean_vocab_size: -0.1049
+  function_metrics:
+    mean_max_function_lines: -0.0254
+  halstead:
+    mean_N1_total_operators: 0.0117
+    mean_difficulty: 0.1678
+    mean_effort: 0.1521
+    mean_estimated_bugs: -0.0119
+    mean_n1_unique_operators: 0.0342
+    mean_n2_unique_operands: -0.1437
+    mean_time_to_implement_seconds: 0.1521
+    mean_vocabulary: -0.0770
+    mean_volume: -0.0118
+  heaps:
+    mean_beta: -0.0911
+    mean_k: 0.1233
+    mean_r_squared: -0.0216
+  identifier_length_variance:
+    mean_max: -0.5833
+    mean_mean: -0.8534
+    mean_std_dev: -0.9223
+    mean_variance: -1.8497
+  indentation:
+    mean_max_depth: -0.0956
+    mean_mean_depth: -0.0126
+    mean_variance: -0.0698
+  line_patterns:
+    mean_unique_line_ratio: -0.0229
+  ngram:
+    mean_bigram_repeated_unique: -0.0377
+    mean_bigram_repetition_rate: 0.0174
+    mean_bigram_unique: -0.0494
+    mean_trigram_hapax_fraction: -0.0166
+    mean_trigram_repetition_rate: 0.0370
+    mean_trigram_unique: -0.0433
+  punctuation_density:
+    mean_id_nonalpha_suffix_density: 0.0170
+  readability:
+    mean_avg_line_length: -0.4449
+    mean_avg_sub_words_per_id: -0.3465
+    mean_avg_tokens_per_line: 0.0100
+    mean_flesch_adapted: 0.4102
+    mean_fog_adapted: -1.3612
+  symbol_density:
+    mean_density: 0.4330
+    mean_distinct_symbol_types: 0.0533
+    mean_symbol_count: 0.0087
+  vocabulary:
+    mean_mattr: -0.1051
+    mean_raw_ttr: -0.1591
+    mean_unique_identifiers: -0.1594
+  vowel_density:
+    mean_total_chars: -0.8588
+  zipf:
+    mean_exponent: 0.0112
+    mean_r_squared: -0.0134
+    mean_vocab_size: -0.1049
+
+name_contains_and:
+  _doc: "Variable names containing `and` signal a variable that holds two concerns."
+  _fix_hint: "Split variables with 'and' into two focused variables (user_and_role → user + role)"
+  _log_baseline: -11.0411
+  branching:
+    mean_branch_count: -0.7789
+    mean_branching_density: -0.8340
+    mean_non_blank_count: 0.0514
+  brevity:
+    mean_sample_size: 0.0228
+  casing_entropy:
+    mean_camel_case_count: -0.4615
+    mean_entropy: 0.1436
+    mean_other_count: 1.3389
+    mean_pascal_case_count: 0.1900
+    mean_snake_case_count: 0.1975
+  comment_structure:
+    mean_comment_line_ratio: -0.0598
+  compression:
+    mean_raw_bytes: -0.1329
+    mean_redundancy: -0.0509
+    mean_unique_line_ratio: 0.1427
+    mean_zlib_bytes: -0.0335
+    mean_zlib_ratio: -0.1016
+  entropy:
+    mean_char_max_entropy: 0.0179
+    mean_char_normalized: -0.0146
+    mean_token_normalized: -0.0144
+    mean_total_tokens: 0.1238
+    mean_vocab_size: 0.0228
+  function_metrics:
+    mean_avg_function_lines: -0.6838
+    mean_avg_param_count: -0.1995
+    mean_function_count: 0.7156
+    mean_max_function_lines: 0.0491
+  halstead:
+    mean_N1_total_operators: 0.1087
+    mean_N2_total_operands: 0.1710
+    mean_difficulty: 0.1849
+    mean_effort: 0.3281
+    mean_estimated_bugs: 0.1413
+    mean_length: 0.1329
+    mean_n1_unique_operators: 0.0560
+    mean_n2_unique_operands: 0.0401
+    mean_time_to_implement_seconds: 0.3281
+    mean_vocabulary: 0.0436
+    mean_volume: 0.1414
+  heaps:
+    mean_beta: -0.1359
+    mean_k: 0.4287
+  identifier_length_variance:
+    mean_max: -0.7789
+    mean_mean: -0.4671
+    mean_std_dev: -0.9757
+    mean_variance: -1.9585
+  indentation:
+    mean_blank_line_ratio: -0.1265
+    mean_max_depth: -0.2572
+    mean_mean_depth: -0.2927
+    mean_variance: -0.5976
+  line_patterns:
+    mean_blank_line_ratio: -0.1265
+    mean_string_literal_ratio: -0.7394
+    mean_unique_line_ratio: 0.1718
+  magic_number_density:
+    mean_density: 0.8439
+    mean_magic_number_count: 0.9649
+    mean_string_literal_ratio: -0.1285
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.5838
+  ngram:
+    mean_bigram_hapax_fraction: 0.0227
+    mean_bigram_repeated_unique: 0.0307
+    mean_bigram_total: 0.1240
+    mean_bigram_unique: 0.0872
+    mean_trigram_hapax_fraction: -0.0343
+    mean_trigram_repeated_unique: 0.2280
+    mean_trigram_repetition_rate: 0.1771
+    mean_trigram_total: 0.1242
+    mean_trigram_unique: 0.0527
+  punctuation_density:
+    mean_arrow_density: -0.1900
+    mean_bracket_nonalpha_suffix_count: -0.2572
+    mean_colon_suffix_density: -1.0487
+    mean_dot_count: -0.5320
+    mean_exclamation_density: 1.5137
+    mean_id_nonalpha_suffix_density: -0.0594
+    mean_question_mark_density: 1.5137
+  readability:
+    mean_avg_line_length: -0.1965
+    mean_avg_sub_words_per_id: -0.5151
+    mean_avg_tokens_per_line: 0.0675
+    mean_flesch_adapted: 0.8109
+    mean_fog_adapted: -2.0000
+    mean_total_lines: 0.0519
+  symbol_density:
+    mean_density: 0.1769
+    mean_distinct_symbol_types: 0.1589
+    mean_symbol_count: 0.0451
+  vocabulary:
+    mean_mattr: -0.2049
+    mean_raw_ttr: -0.1504
+    mean_total_identifiers: 0.1499
+  vowel_density:
+    mean_total_chars: -0.3180
+  zipf:
+    mean_exponent: 0.0125
+    mean_total_tokens: 0.1238
+    mean_vocab_size: 0.0228
+
+name_contains_type_suffix:
+  _doc: "Type suffixes in names (`userString`, `nameList`) are redundant noise."
+  _fix_hint: "Remove type suffixes from names (userList → users, dataMap → data)"
+  _log_baseline: -26.2345
+  branching:
+    mean_branch_count: -0.4150
+    mean_branching_density: -0.4125
+  brevity:
+    mean_sample_size: -0.1936
+  casing_entropy:
+    mean_camel_case_count: -1.4300
+    mean_entropy: -0.3896
+    mean_other_count: -2.0000
+    mean_pascal_case_count: -0.1660
+    mean_snake_case_count: 0.1802
+  compression:
+    mean_raw_bytes: -0.2768
+    mean_redundancy: -0.1061
+    mean_zlib_bytes: -0.1005
+    mean_zlib_ratio: -0.1770
+  entropy:
+    mean_char_entropy: -0.0082
+    mean_token_entropy: -0.0294
+    mean_token_max_entropy: -0.0396
+    mean_token_normalized: 0.0102
+    mean_total_tokens: -0.0142
+    mean_vocab_size: -0.1936
+  halstead:
+    mean_N1_total_operators: -0.0138
+    mean_N2_total_operands: -0.0198
+    mean_difficulty: 0.2824
+    mean_effort: 0.2335
+    mean_estimated_bugs: -0.0503
+    mean_length: -0.0161
+    mean_n1_unique_operators: 0.0679
+    mean_n2_unique_operands: -0.2321
+    mean_time_to_implement_seconds: 0.2335
+    mean_vocabulary: -0.1655
+    mean_volume: -0.0503
+  heaps:
+    mean_beta: -0.1004
+    mean_k: 0.1792
+  identifier_length_variance:
+    mean_max: -0.3735
+    mean_mean: -0.4843
+    mean_std_dev: -0.6059
+    mean_variance: -1.2170
+  line_patterns:
+    mean_string_literal_ratio: 0.0109
+  ngram:
+    mean_bigram_hapax_fraction: -0.0337
+    mean_bigram_repeated_unique: 0.0355
+    mean_bigram_repetition_rate: 0.0884
+    mean_bigram_total: -0.0143
+    mean_bigram_unique: -0.0700
+    mean_trigram_hapax_fraction: -0.0406
+    mean_trigram_repeated_unique: 0.2397
+    mean_trigram_repetition_rate: 0.2387
+    mean_trigram_total: -0.0143
+    mean_trigram_unique: -0.0591
+  punctuation_density:
+    mean_colon_suffix_density: -0.1444
+    mean_id_nonalpha_suffix_density: -0.0281
+    mean_question_mark_density: 0.5850
+  readability:
+    mean_avg_line_length: -0.2896
+    mean_avg_sub_words_per_id: -0.3400
+    mean_avg_tokens_per_line: -0.0147
+    mean_flesch_adapted: 0.4136
+    mean_fog_adapted: -1.0490
+  symbol_density:
+    mean_density: 0.2546
+    mean_symbol_count: -0.0213
+  vocabulary:
+    mean_mattr: -0.2341
+    mean_raw_ttr: -0.2567
+    mean_total_identifiers: -0.0421
+    mean_unique_identifiers: -0.2988
+  vowel_density:
+    mean_total_chars: -0.5247
+  zipf:
+    mean_exponent: 0.0794
+    mean_r_squared: 0.0102
+    mean_total_tokens: -0.0142
+    mean_vocab_size: -0.1936
+
+name_is_abbreviation:
+  _doc: "Abbreviated names (`usr`, `cfg`, `mgr`) reduce readability."
+  _fix_hint: "Expand abbreviations to full words (usr → user, cnt → count, idx → index)"
+  _log_baseline: 23.1000
+  brevity:
+    mean_sample_size: -0.2397
+  casing_entropy:
+    mean_camel_case_count: 0.4951
+    mean_entropy: 0.1951
+    mean_snake_case_count: -0.2645
+  compression:
+    mean_raw_bytes: 0.8246
+    mean_redundancy: 0.3054
+    mean_unique_line_ratio: 0.1893
+    mean_zlib_bytes: 0.1088
+    mean_zlib_ratio: 0.7116
+  entropy:
+    mean_char_entropy: -0.0619
+    mean_char_normalized: -0.0892
+    mean_token_entropy: -0.0583
+    mean_token_max_entropy: -0.0514
+    mean_total_tokens: -0.1699
+    mean_vocab_size: -0.2397
+  halstead:
+    mean_N1_total_operators: -0.1681
+    mean_N2_total_operands: -0.1679
+    mean_difficulty: 0.3150
+    mean_effort: 0.0480
+    mean_estimated_bugs: -0.2403
+    mean_length: -0.1680
+    mean_n2_unique_operands: -0.4607
+    mean_time_to_implement_seconds: 0.0480
+    mean_vocabulary: -0.3410
+    mean_volume: -0.2405
+  heaps:
+    mean_beta: -0.1643
+    mean_k: 0.3581
+    mean_r_squared: -0.0412
+  identifier_length_variance:
+    mean_max: 2.0000
+    mean_mean: 1.8274
+    mean_std_dev: 0.3959
+    mean_variance: 0.7880
+  line_patterns:
+    mean_string_literal_ratio: -0.1475
+    mean_unique_line_ratio: 0.1981
+  magic_number_density:
+    mean_density: 0.5685
+    mean_string_literal_ratio: -0.3380
+  ngram:
+    mean_bigram_repeated_unique: -0.0944
+    mean_bigram_total: -0.1701
+    mean_bigram_unique: -0.0528
+    mean_trigram_hapax_fraction: 0.1423
+    mean_trigram_repeated_unique: -0.3139
+    mean_trigram_repetition_rate: -0.1310
+    mean_trigram_total: -0.1703
+    mean_trigram_unique: -0.0522
+  punctuation_density:
+    mean_arrow_density: 0.3569
+    mean_bracket_nonalpha_prefix_count: -0.4746
+    mean_bracket_nonalpha_suffix_count: -0.1763
+    mean_colon_suffix_density: -0.6554
+    mean_dot_count: -0.1834
+    mean_exclamation_density: -0.7311
+    mean_id_nonalpha_suffix_density: -0.0637
+    mean_question_mark_density: -0.9035
+  readability:
+    mean_avg_line_length: 0.8581
+    mean_avg_tokens_per_line: -0.1700
+    mean_fog_adapted: -0.1492
+  symbol_density:
+    mean_density: -1.0085
+    mean_symbol_count: -0.1894
+  vocabulary:
+    mean_mattr: -0.5807
+    mean_raw_ttr: -0.1377
+    mean_total_identifiers: -0.1967
+    mean_unique_identifiers: -0.3487
+  vowel_density:
+    mean_total_chars: 1.6488
+  zipf:
+    mean_exponent: 0.0937
+    mean_total_tokens: -0.1699
+    mean_vocab_size: -0.2397
+
+name_is_generic:
+  _doc: "Generic names (`data`, `result`, `tmp`, `val`, `obj`) convey no domain meaning."
+  _fix_hint: "Replace generic names (data, result, tmp, info) with domain-specific names"
+  _log_baseline: 37.2228
+  branching:
+    mean_branch_count: 0.5193
+    mean_branching_density: 0.3889
+    mean_max_nesting_depth: -0.0599
+    mean_non_blank_count: 0.0756
+  brevity:
+    mean_sample_size: 0.2053
+  casing_entropy:
+    mean_camel_case_count: 2.0000
+    mean_entropy: 0.3865
+    mean_snake_case_count: 0.0835
+  compression:
+    mean_raw_bytes: 0.3477
+    mean_redundancy: 0.0524
+    mean_zlib_bytes: 0.2391
+    mean_zlib_ratio: 0.1093
+  entropy:
+    mean_char_entropy: 0.0197
+    mean_char_max_entropy: 0.0088
+    mean_char_normalized: 0.0110
+    mean_token_entropy: 0.0372
+    mean_token_max_entropy: 0.0450
+    mean_token_normalized: -0.0077
+    mean_total_tokens: 0.0784
+    mean_vocab_size: 0.2053
+  function_metrics:
+    mean_avg_function_lines: -0.1306
+    mean_avg_param_count: -0.0443
+    mean_function_count: 0.2694
+    mean_max_function_lines: -0.2279
+  halstead:
+    mean_N1_total_operators: 0.0995
+    mean_N2_total_operands: 0.0454
+    mean_difficulty: -0.2194
+    mean_effort: -0.0846
+    mean_estimated_bugs: 0.1286
+    mean_length: 0.0789
+    mean_n1_unique_operators: 0.0328
+    mean_n2_unique_operands: 0.2960
+    mean_time_to_implement_seconds: -0.0846
+    mean_vocabulary: 0.2199
+    mean_volume: 0.1286
+  heaps:
+    mean_beta: 0.1174
+    mean_k: -0.2339
+    mean_r_squared: 0.0145
+  identifier_length_variance:
+    mean_max: 0.4477
+    mean_mean: 0.5561
+    mean_std_dev: 0.6865
+    mean_variance: 1.3793
+  indentation:
+    mean_blank_line_ratio: 0.0556
+    mean_max_depth: -0.1451
+    mean_mean_depth: -0.0760
+    mean_variance: -0.2765
+  line_patterns:
+    mean_blank_line_ratio: 0.0556
+    mean_max_nesting_depth: -0.0599
+    mean_string_literal_ratio: -0.0386
+    mean_unique_line_ratio: 0.0182
+  magic_number_density:
+    mean_density: -0.0624
+    mean_string_literal_ratio: -0.1451
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.2270
+  ngram:
+    mean_bigram_hapax_fraction: 0.1528
+    mean_bigram_repeated_unique: -0.1344
+    mean_bigram_repetition_rate: -0.1251
+    mean_bigram_total: 0.0786
+    mean_bigram_unique: 0.1718
+    mean_trigram_hapax_fraction: 0.1086
+    mean_trigram_repeated_unique: -0.2389
+    mean_trigram_repetition_rate: -0.2091
+    mean_trigram_total: 0.0787
+    mean_trigram_unique: 0.1550
+  punctuation_density:
+    mean_arrow_density: -0.1087
+    mean_bracket_nonalpha_prefix_count: 0.2766
+    mean_bracket_number_pair_count: 0.2499
+    mean_colon_suffix_density: -0.0752
+    mean_exclamation_density: -0.2923
+    mean_id_nonalpha_suffix_density: -0.0340
+    mean_question_mark_density: 0.1584
+  readability:
+    mean_avg_line_length: 0.2897
+    mean_avg_sub_words_per_id: 0.2590
+    mean_flesch_adapted: -0.2843
+    mean_fog_adapted: 0.5030
+    mean_total_lines: 0.0756
+  symbol_density:
+    mean_density: -0.2642
+    mean_distinct_symbol_types: 0.0252
+    mean_symbol_count: 0.0858
+  vocabulary:
+    mean_mattr: 0.1805
+    mean_raw_ttr: 0.1632
+    mean_total_identifiers: 0.2060
+    mean_unique_identifiers: 0.3675
+  vowel_density:
+    mean_total_chars: 0.7602
+  zipf:
+    mean_exponent: -0.0977
+    mean_r_squared: 0.0316
+    mean_total_tokens: 0.0784
+    mean_vocab_size: 0.2053
+
+name_is_number_like:
+  _doc: "Number-suffixed names (`var1`, `thing2`) signal a missing abstraction."
+  _fix_hint: "Replace number-like names (x1, y2) with descriptive names indicating purpose"
+  _log_baseline: 1.7668
+  brevity:
+    mean_sample_size: -0.0262
+  casing_entropy:
+    mean_camel_case_count: 0.6902
+    mean_entropy: -0.4709
+    mean_other_count: -2.0000
+    mean_snake_case_count: 0.1755
+  compression:
+    mean_raw_bytes: 0.1098
+    mean_redundancy: 0.0379
+    mean_zlib_bytes: 0.0415
+    mean_zlib_ratio: 0.0696
+  entropy:
+    mean_char_entropy: -0.0074
+    mean_char_max_entropy: -0.0070
+    mean_token_entropy: -0.0056
+    mean_token_max_entropy: -0.0054
+    mean_total_tokens: -0.0075
+    mean_vocab_size: -0.0262
+  halstead:
+    mean_N1_total_operators: -0.0036
+    mean_N2_total_operands: -0.0096
+    mean_difficulty: -0.0139
+    mean_effort: -0.0244
+    mean_estimated_bugs: -0.0103
+    mean_length: -0.0059
+    mean_n1_unique_operators: -0.0253
+    mean_n2_unique_operands: -0.0217
+    mean_time_to_implement_seconds: -0.0244
+    mean_vocabulary: -0.0224
+    mean_volume: -0.0102
+  heaps:
+    mean_beta: 0.0225
+    mean_k: -0.1085
+    mean_r_squared: 0.0046
+  identifier_length_variance:
+    mean_max: 0.0623
+    mean_mean: 0.2201
+    mean_std_dev: 0.2399
+    mean_variance: 0.4803
+  line_patterns:
+    mean_string_literal_ratio: 0.0201
+  ngram:
+    mean_bigram_repeated_unique: -0.0072
+    mean_bigram_repetition_rate: 0.0064
+    mean_bigram_total: -0.0075
+    mean_bigram_unique: -0.0124
+    mean_trigram_repeated_unique: -0.0135
+    mean_trigram_repetition_rate: 0.0035
+    mean_trigram_total: -0.0075
+    mean_trigram_unique: -0.0093
+  punctuation_density:
+    mean_colon_suffix_density: 0.0087
+    mean_question_mark_density: -0.1007
+  readability:
+    mean_avg_line_length: 0.1147
+    mean_avg_sub_words_per_id: 0.1104
+    mean_avg_tokens_per_line: -0.0075
+    mean_flesch_adapted: -0.1154
+    mean_fog_adapted: 0.0448
+  symbol_density:
+    mean_density: -0.1135
+    mean_distinct_symbol_types: -0.0272
+    mean_symbol_count: -0.0042
+  vocabulary:
+    mean_mattr: -0.0101
+    mean_raw_ttr: -0.0152
+    mean_total_identifiers: -0.0159
+    mean_unique_identifiers: -0.0307
+  vowel_density:
+    mean_total_chars: 0.2031
+  zipf:
+    mean_exponent: 0.0060
+    mean_total_tokens: -0.0075
+    mean_vocab_size: -0.0262
+
+name_is_single_letter:
+  _doc: "Single-letter names outside loop indices are too opaque."
+  _fix_hint: "Replace single-letter names with descriptive names (n → count, s → status)"
+  _log_baseline: 25.4977
+  branching:
+    mean_branching_density: -0.0458
+    mean_non_blank_count: 0.0439
+  brevity:
+    mean_sample_size: 0.2432
+  casing_entropy:
+    mean_camel_case_count: 2.0000
+    mean_entropy: 0.4023
+    mean_snake_case_count: -0.1981
+  comment_structure:
+    mean_comment_line_ratio: -0.0675
+  compression:
+    mean_raw_bytes: 0.6309
+    mean_redundancy: 0.1583
+    mean_unique_line_ratio: 0.0981
+    mean_zlib_bytes: 0.3475
+    mean_zlib_ratio: 0.2887
+  entropy:
+    mean_char_entropy: 0.0257
+    mean_char_max_entropy: 0.0109
+    mean_char_normalized: 0.0147
+    mean_token_entropy: 0.0833
+    mean_token_max_entropy: 0.0545
+    mean_token_normalized: 0.0285
+    mean_total_tokens: -0.0299
+    mean_vocab_size: 0.2432
+  function_metrics:
+    mean_avg_function_lines: 0.0375
+  halstead:
+    mean_N1_total_operators: -0.0309
+    mean_N2_total_operands: -0.0201
+    mean_difficulty: -0.5465
+    mean_effort: -0.5119
+    mean_estimated_bugs: 0.0320
+    mean_length: -0.0265
+    mean_n1_unique_operators: -0.0959
+    mean_n2_unique_operands: 0.4383
+    mean_time_to_implement_seconds: -0.5119
+    mean_vocabulary: 0.2605
+    mean_volume: 0.0321
+  heaps:
+    mean_beta: 0.2530
+    mean_k: -0.4973
+    mean_r_squared: 0.0625
+  identifier_length_variance:
+    mean_mean: 1.3809
+    mean_std_dev: 0.0433
+    mean_variance: 0.0855
+  indentation:
+    mean_blank_line_ratio: -0.0414
+    mean_mean_depth: 0.0281
+    mean_variance: 0.0340
+  line_patterns:
+    mean_blank_line_ratio: -0.0414
+    mean_unique_line_ratio: 0.1020
+  magic_number_density:
+    mean_density: 0.0305
+  ngram:
+    mean_bigram_hapax_fraction: 0.2477
+    mean_bigram_repeated_unique: -0.2477
+    mean_bigram_repetition_rate: -0.2739
+    mean_bigram_total: -0.0300
+    mean_bigram_unique: 0.2691
+    mean_trigram_hapax_fraction: 0.1285
+    mean_trigram_repeated_unique: -0.4299
+    mean_trigram_repetition_rate: -0.3303
+    mean_trigram_total: -0.0300
+    mean_trigram_unique: 0.1239
+  punctuation_density:
+    mean_colon_suffix_density: 0.0312
+    mean_id_nonalpha_suffix_density: -0.0325
+    mean_question_mark_density: -0.9170
+  readability:
+    mean_avg_line_length: 0.6245
+    mean_avg_sub_words_per_id: 0.2530
+    mean_avg_tokens_per_line: -0.0775
+    mean_flesch_adapted: -0.2420
+    mean_fog_adapted: -0.0686
+    mean_total_lines: 0.0444
+  symbol_density:
+    mean_density: -0.6602
+    mean_symbol_count: -0.0262
+  vocabulary:
+    mean_mattr: 0.5595
+    mean_raw_ttr: 0.5013
+    mean_total_identifiers: -0.0367
+    mean_unique_identifiers: 0.4625
+  vowel_density:
+    mean_total_chars: 1.3325
+  zipf:
+    mean_exponent: -0.2161
+    mean_r_squared: 0.1041
+    mean_total_tokens: -0.0299
+    mean_vocab_size: 0.2432
+
+name_is_too_long:
+  _doc: "Names longer than ~30 characters harm readability."
+  _fix_hint: "Shorten overly long names — aim for 2–3 descriptive words, drop redundant context"
+  _log_baseline: -7.5164
+  branching:
+    mean_branch_count: 0.0340
+    mean_branching_density: 0.0916
+    mean_max_nesting_depth: 0.0484
+    mean_non_blank_count: -0.0724
+  brevity:
+    mean_sample_size: -0.0167
+  casing_entropy:
+    mean_camel_case_count: -0.1082
+    mean_entropy: 0.0111
+    mean_other_count: 0.0922
+    mean_pascal_case_count: 0.0340
+    mean_snake_case_count: 0.1201
+  comment_structure:
+    mean_comment_line_ratio: 0.1321
+  compression:
+    mean_raw_bytes: -0.2235
+    mean_redundancy: -0.0299
+    mean_unique_line_ratio: -0.0154
+    mean_zlib_bytes: -0.1618
+    mean_zlib_ratio: -0.0643
+  entropy:
+    mean_token_entropy: -0.0111
+    mean_token_max_entropy: -0.0038
+    mean_token_normalized: -0.0072
+    mean_total_tokens: 0.0756
+    mean_vocab_size: -0.0167
+  function_metrics:
+    mean_avg_function_lines: -0.1811
+    mean_avg_param_count: -0.0267
+    mean_function_count: 0.1054
+    mean_max_function_lines: -0.1862
+  halstead:
+    mean_N1_total_operators: 0.0815
+    mean_N2_total_operands: 0.0706
+    mean_difficulty: 0.1104
+    mean_effort: 0.1960
+    mean_estimated_bugs: 0.0734
+    mean_length: 0.0774
+    mean_n1_unique_operators: 0.0062
+    mean_n2_unique_operands: -0.0320
+    mean_time_to_implement_seconds: 0.1960
+    mean_vocabulary: -0.0217
+    mean_volume: 0.0734
+  heaps:
+    mean_beta: -0.0480
+    mean_k: 0.1004
+    mean_r_squared: -0.0095
+  identifier_length_variance:
+    mean_max: -0.4664
+    mean_mean: -0.4075
+    mean_std_dev: -0.5860
+    mean_variance: -1.1740
+  indentation:
+    mean_blank_line_ratio: 0.0206
+    mean_max_depth: -0.2280
+    mean_mean_depth: -0.1355
+    mean_variance: -0.2997
+  line_patterns:
+    mean_blank_line_ratio: 0.0206
+    mean_max_nesting_depth: 0.0484
+    mean_string_literal_ratio: -0.0763
+    mean_unique_line_ratio: -0.0145
+  magic_number_density:
+    mean_density: -0.0708
+    mean_string_literal_ratio: -0.1025
+  near_duplicate_blocks_file:
+    mean_sub_block_count: 0.1015
+  ngram:
+    mean_bigram_hapax_fraction: -0.0613
+    mean_bigram_repeated_unique: 0.1532
+    mean_bigram_repetition_rate: 0.0826
+    mean_bigram_total: 0.0758
+    mean_bigram_unique: 0.0140
+    mean_trigram_hapax_fraction: -0.0412
+    mean_trigram_repeated_unique: 0.2154
+    mean_trigram_repetition_rate: 0.1235
+    mean_trigram_total: 0.0759
+    mean_trigram_unique: 0.0351
+  punctuation_density:
+    mean_arrow_density: 0.1321
+    mean_bracket_nonalpha_prefix_count: 0.0708
+    mean_bracket_nonalpha_suffix_count: 0.0511
+    mean_colon_suffix_density: -0.0806
+    mean_dot_count: 0.0613
+    mean_exclamation_density: 0.3183
+    mean_id_nonalpha_suffix_density: 0.0149
+    mean_question_mark_density: 0.1862
+  readability:
+    mean_avg_line_length: -0.1589
+    mean_avg_sub_words_per_id: -0.3392
+    mean_avg_tokens_per_line: 0.1430
+    mean_flesch_adapted: 2.0000
+    mean_fog_adapted: -0.3969
+    mean_total_lines: -0.0733
+  symbol_density:
+    mean_density: 0.2971
+    mean_distinct_symbol_types: 0.0446
+    mean_symbol_count: 0.0831
+  vocabulary:
+    mean_mattr: -0.0845
+    mean_raw_ttr: -0.1058
+    mean_total_identifiers: 0.0719
+    mean_unique_identifiers: -0.0383
+  vowel_density:
+    mean_total_chars: -0.3320
+  zipf:
+    mean_exponent: 0.0555
+    mean_total_tokens: 0.0756
+    mean_vocab_size: -0.0167
+
+name_is_too_short:
+  _doc: "Names shorter than 3 characters (outside loops) are too opaque."
+  _fix_hint: "Use at least 3 characters — replace very short names with full words"
+  _log_baseline: -0.4484
+  branching:
+    mean_branch_count: -0.2327
+    mean_branching_density: -0.2381
+  brevity:
+    mean_sample_size: -0.1256
+  casing_entropy:
+    mean_camel_case_count: -0.0450
+    mean_entropy: -0.4953
+    mean_other_count: -2.0000
+    mean_snake_case_count: 0.0286
+  comment_structure:
+    mean_comment_line_ratio: -0.0092
+  compression:
+    mean_raw_bytes: 0.2713
+    mean_redundancy: 0.1160
+    mean_zlib_bytes: 0.0526
+    mean_zlib_ratio: 0.2197
+  entropy:
+    mean_char_entropy: -0.0115
+    mean_char_max_entropy: 0.0191
+    mean_char_normalized: -0.0304
+    mean_token_entropy: -0.0467
+    mean_token_max_entropy: -0.0267
+    mean_token_normalized: -0.0201
+    mean_total_tokens: -0.0256
+    mean_vocab_size: -0.1256
+  halstead:
+    mean_N1_total_operators: -0.0225
+    mean_N2_total_operands: -0.0374
+    mean_difficulty: 0.0242
+    mean_effort: -0.0350
+    mean_estimated_bugs: -0.0584
+    mean_length: -0.0283
+    mean_n1_unique_operators: -0.0974
+    mean_n2_unique_operands: -0.1584
+    mean_time_to_implement_seconds: -0.0350
+    mean_vocabulary: -0.1401
+    mean_volume: -0.0584
+  heaps:
+    mean_k: -0.1166
+    mean_r_squared: 0.0306
+  identifier_length_variance:
+    mean_mean: 0.5797
+    mean_std_dev: -0.1344
+    mean_variance: -0.2709
+  indentation:
+    mean_variance: 0.0168
+  line_patterns:
+    mean_string_literal_ratio: 0.0229
+  ngram:
+    mean_bigram_hapax_fraction: 0.0137
+    mean_bigram_repeated_unique: -0.0944
+    mean_bigram_repetition_rate: 0.0110
+    mean_bigram_total: -0.0256
+    mean_bigram_unique: -0.0691
+    mean_trigram_repeated_unique: -0.0446
+    mean_trigram_total: -0.0256
+    mean_trigram_unique: -0.0318
+  punctuation_density:
+    mean_colon_suffix_density: -0.2391
+    mean_id_nonalpha_suffix_density: -0.0101
+    mean_question_mark_density: -0.2722
+  readability:
+    mean_avg_line_length: 0.2778
+    mean_avg_tokens_per_line: -0.0329
+    mean_fog_adapted: -0.0263
+  symbol_density:
+    mean_density: -0.2806
+    mean_distinct_symbol_types: 0.0241
+    mean_symbol_count: -0.0137
+  vocabulary:
+    mean_mattr: -0.2548
+    mean_raw_ttr: -0.1285
+    mean_total_identifiers: -0.0370
+    mean_unique_identifiers: -0.1640
+  vowel_density:
+    mean_total_chars: 0.5403
+  zipf:
+    mean_exponent: 0.0521
+    mean_total_tokens: -0.0256
+    mean_vocab_size: -0.1256
+
+negated_boolean_name:
+  _doc: "Negated boolean names (`isNotValid`, `notActive`) are harder to reason about."
+  _fix_hint: "Rename negated booleans positively (is_not_active → is_inactive, not_found → missing)"
+  _log_baseline: -15.6244
+  brevity:
+    mean_sample_size: -0.3765
+  casing_entropy:
+    mean_camel_case_count: -0.4213
+  compression:
+    mean_raw_bytes: -0.1561
+    mean_zlib_bytes: -0.2426
+    mean_zlib_ratio: 0.0872
+  entropy:
+    mean_token_max_entropy: -0.0741
+    mean_vocab_size: -0.3765
+  halstead:
+    mean_difficulty: 0.3608
+    mean_effort: 0.2913
+    mean_estimated_bugs: -0.0613
+    mean_n2_unique_operands: -0.4082
+    mean_time_to_implement_seconds: 0.2913
+    mean_vocabulary: -0.3088
+    mean_volume: -0.0612
+  heaps:
+    mean_beta: 0.1348
+    mean_k: -0.7753
+  identifier_length_variance:
+    mean_max: -0.1714
+    mean_mean: -0.4077
+    mean_std_dev: -0.9919
+    mean_variance: -2.0000
+  line_patterns:
+    mean_string_literal_ratio: 0.1212
+  magic_number_density:
+    mean_string_literal_ratio: 0.2446
+  near_duplicate_blocks_file:
+    mean_sub_block_count: -0.2060
+  ngram:
+    mean_bigram_hapax_fraction: -0.1145
+    mean_bigram_repeated_unique: 0.1809
+    mean_bigram_repetition_rate: 0.1382
+    mean_bigram_unique: -0.1039
+    mean_trigram_hapax_fraction: -0.0761
+    mean_trigram_repeated_unique: 0.1656
+    mean_trigram_repetition_rate: 0.2761
+    mean_trigram_unique: -0.1381
+  punctuation_density:
+    mean_bracket_nonalpha_prefix_count: -0.9075
+    mean_bracket_nonalpha_suffix_count: -0.1522
+    mean_colon_suffix_density: -0.4874
+    mean_exclamation_density: -1.5354
+    mean_id_nonalpha_suffix_density: -0.1055
+  readability:
+    mean_avg_line_length: -0.1581
+    mean_avg_sub_words_per_id: -0.4843
+    mean_flesch_adapted: 0.6639
+    mean_fog_adapted: -0.4551
+  symbol_density:
+    mean_density: 0.1413
+  vocabulary:
+    mean_mattr: -0.0722
+    mean_raw_ttr: -0.4365
+    mean_unique_identifiers: -0.4305
+  vowel_density:
+    mean_total_chars: -0.4070
+  zipf:
+    mean_exponent: 0.0569
+    mean_vocab_size: -0.3765
+
+no_hungarian_notation:
+  _doc: "Hungarian notation prefixes (`strName`, `bFlag`) add noise without type safety."
+  _fix_hint: "Remove type prefixes from names (strName → name, intCount → count)"
+  _log_baseline: -15.0940
+  brevity:
+    mean_sample_size: -0.0814
+  casing_entropy:
+    mean_camel_case_count: -2.0000
+    mean_entropy: -0.1319
+    mean_snake_case_count: 0.3573
+  compression:
+    mean_raw_bytes: -0.1982
+    mean_redundancy: -0.0699
+    mean_zlib_bytes: -0.0838
+    mean_zlib_ratio: -0.1165
+  entropy:
+    mean_char_entropy: -0.0328
+    mean_char_max_entropy: 0.0126
+    mean_char_normalized: -0.0451
+    mean_token_entropy: -0.0170
+    mean_token_max_entropy: -0.0171
+    mean_vocab_size: -0.0814
+  halstead:
+    mean_N1_total_operators: -0.0177
+    mean_difficulty: 0.0792
+    mean_effort: 0.0437
+    mean_estimated_bugs: -0.0349
+    mean_length: -0.0097
+    mean_n1_unique_operators: -0.0623
+    mean_n2_unique_operands: -0.1363
+    mean_time_to_implement_seconds: 0.0437
+    mean_vocabulary: -0.1173
+    mean_volume: -0.0349
+  heaps:
+    mean_beta: -0.0354
+    mean_k: 0.0692
+  identifier_length_variance:
+    mean_max: -0.1067
+    mean_mean: -0.3583
+    mean_std_dev: -0.0131
+    mean_variance: -0.0329
+  magic_number_density:
+    mean_density: 0.0312
+  ngram:
+    mean_bigram_hapax_fraction: -0.0158
+    mean_bigram_repeated_unique: 0.0179
+    mean_bigram_repetition_rate: 0.0262
+    mean_bigram_unique: -0.0230
+    mean_trigram_repetition_rate: -0.0101
+  punctuation_density:
+    mean_arrow_density: 0.0283
+    mean_colon_suffix_density: -0.1656
+    mean_id_nonalpha_suffix_density: -0.0231
+    mean_question_mark_density: 0.1563
+  readability:
+    mean_avg_line_length: -0.2142
+    mean_avg_sub_words_per_id: -0.4897
+    mean_flesch_adapted: 0.6818
+    mean_fog_adapted: -0.8542
+  symbol_density:
+    mean_density: 0.1919
+    mean_distinct_symbol_types: 0.0849
+  vocabulary:
+    mean_mattr: -0.1437
+    mean_raw_ttr: -0.1556
+    mean_unique_identifiers: -0.1488
+  vowel_density:
+    mean_total_chars: -0.3491
+  zipf:
+    mean_exponent: 0.0655
+    mean_vocab_size: -0.0814
+
+screaming_snake_for_constants:
+  _doc: "Module-level constants should use SCREAMING_SNAKE_CASE."
+  _fix_hint: "Use SCREAMING_SNAKE_CASE for module-level constants (@MAX_SIZE not @max_size)"
+  _log_baseline: -6.3000
+  branching:
+    mean_branching_density: 0.0176
+    mean_non_blank_count: -0.0180
+  brevity:
+    mean_sample_size: -0.0136
+  casing_entropy:
+    mean_camel_case_count: 0.0302
+    mean_entropy: 0.0224
+    mean_macro_case_count: 1.9927
+    mean_pascal_case_count: -0.1675
+    mean_screaming_snake_density: 2.0000
+  comment_structure:
+    mean_comment_line_ratio: 0.0267
+  compression:
+    mean_raw_bytes: -0.0086
+    mean_redundancy: -0.0090
+    mean_unique_line_ratio: -0.0048
+    mean_zlib_bytes: 0.0081
+    mean_zlib_ratio: -0.0168
+  entropy:
+    mean_char_entropy: 0.0306
+    mean_char_max_entropy: 0.0092
+    mean_char_normalized: 0.0214
+    mean_total_tokens: -0.0066
+    mean_vocab_size: -0.0136
+  halstead:
+    mean_N1_total_operators: -0.0036
+    mean_N2_total_operands: -0.0117
+    mean_difficulty: 0.0034
+    mean_effort: -0.0052
+    mean_estimated_bugs: -0.0088
+    mean_length: -0.0067
+    mean_n2_unique_operands: -0.0163
+    mean_time_to_implement_seconds: -0.0052
+    mean_vocabulary: -0.0115
+    mean_volume: -0.0088
+  identifier_length_variance:
+    mean_mean: 0.0041
+    mean_std_dev: 0.0225
+    mean_variance: 0.0446
+  indentation:
+    mean_blank_line_ratio: 0.0078
+    mean_mean_depth: 0.0069
+    mean_variance: 0.0048
+  line_patterns:
+    mean_blank_line_ratio: 0.0078
+    mean_string_literal_ratio: 0.0089
+    mean_unique_line_ratio: -0.0059
+  magic_number_density:
+    mean_density: 0.0057
+    mean_string_literal_ratio: 0.0090
+  ngram:
+    mean_bigram_hapax_fraction: -0.0085
+    mean_bigram_repetition_rate: 0.0069
+    mean_bigram_total: -0.0066
+    mean_bigram_unique: -0.0131
+    mean_trigram_hapax_fraction: -0.0045
+    mean_trigram_repetition_rate: 0.0072
+    mean_trigram_total: -0.0067
+    mean_trigram_unique: -0.0101
+  punctuation_density:
+    mean_arrow_density: 0.0071
+    mean_colon_suffix_density: 0.0103
+    mean_id_nonalpha_suffix_density: 0.0078
+  readability:
+    mean_avg_line_length: 0.0087
+    mean_avg_sub_words_per_id: -0.0090
+    mean_avg_tokens_per_line: 0.0103
+    mean_flesch_adapted: 0.0095
+    mean_fog_adapted: -0.0083
+    mean_total_lines: -0.0182
+  symbol_density:
+    mean_symbol_count: -0.0036
+  vocabulary:
+    mean_mattr: -0.0045
+    mean_raw_ttr: -0.0077
+    mean_total_identifiers: -0.0145
+    mean_unique_identifiers: -0.0226
+  vowel_density:
+    mean_total_chars: -0.0105
+  zipf:
+    mean_exponent: 0.0038
+    mean_total_tokens: -0.0066
+    mean_vocab_size: -0.0136
+
diff --git a/test/codeqa/combined_metrics/file_scorer_test.exs b/test/codeqa/combined_metrics/file_scorer_test.exs
new file mode 100644
index 0000000..b863693
--- /dev/null
+++ b/test/codeqa/combined_metrics/file_scorer_test.exs
@@ -0,0 +1,268 @@
+defmodule CodeQA.CombinedMetrics.FileScorerTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.CombinedMetrics.FileScorer
+
+  describe "file_to_aggregate/1" do
+    test "prefixes each key with mean_" do
+      input = %{"halstead" => %{"tokens" => 42.0, "effort" => 100.5}}
+
+      assert FileScorer.file_to_aggregate(input) == %{
+               "halstead" => %{"mean_tokens" => 42.0, "mean_effort" => 100.5}
+             }
+    end
+
+    test "handles multiple groups" do
+      input = %{
+        "halstead" => %{"tokens" => 10.0},
+        "branching" => %{"branching_density" => 0.5}
+      }
+
+      result = FileScorer.file_to_aggregate(input)
+
+      assert result == %{
+               "halstead" => %{"mean_tokens" => 10.0},
+               "branching" => %{"mean_branching_density" => 0.5}
+             }
+    end
+
+    test "returns empty map for empty input" do
+      assert FileScorer.file_to_aggregate(%{}) == %{}
+    end
+
+    test "preserves values unchanged" do
+      input = %{"entropy" => %{"normalized_entropy" => 0.87}}
+      result = FileScorer.file_to_aggregate(input)
+      assert get_in(result, ["entropy", "mean_normalized_entropy"]) == 0.87
+    end
+  end
+
+  describe "worst_files_per_behavior/2" do
+    test "returns a map with string keys in category.behavior format" do
+      files_map = build_files_map()
+      result = FileScorer.worst_files_per_behavior(files_map, combined_top: 2)
+
+      assert is_map(result)
+
+      for {key, entries} <- result do
+        assert is_binary(key)
+        assert String.contains?(key, ".")
+        assert is_list(entries)
+      end
+    end
+
+    test "each entry has file and cosine keys" do
+      files_map = build_files_map()
+      result = FileScorer.worst_files_per_behavior(files_map, combined_top: 2)
+
+      for {_key, entries} <- result do
+        for entry <- entries do
+          assert Map.has_key?(entry, :file)
+          assert Map.has_key?(entry, :cosine)
+          assert is_binary(entry.file)
+          assert is_float(entry.cosine)
+        end
+      end
+    end
+
+    test "respects combined_top limit" do
+      files_map = build_files_map()
+      result = FileScorer.worst_files_per_behavior(files_map, combined_top: 1)
+
+      for {_key, entries} <- result do
+        assert length(entries) <= 1
+      end
+    end
+
+    test "entries are sorted ascending by cosine (most negative first)" do
+      files_map = build_files_map()
+      result = FileScorer.worst_files_per_behavior(files_map, combined_top: 99)
+
+      for {_key, entries} <- result do
+        cosines = Enum.map(entries, & &1.cosine)
+        assert cosines == Enum.sort(cosines)
+      end
+    end
+
+    test "skips files with empty metrics" do
+      files_map = %{
+        "lib/empty.ex" => %{"metrics" => %{}, "lines" => 10},
+        "lib/nokey.ex" => %{"lines" => 5}
+      }
+
+      result = FileScorer.worst_files_per_behavior(files_map)
+
+      for {_key, entries} <- result do
+        file_paths = Enum.map(entries, & &1.file)
+        refute "lib/empty.ex" in file_paths
+        refute "lib/nokey.ex" in file_paths
+      end
+    end
+
+    test "uses default combined_top of 2" do
+      files_map = build_files_map()
+      result = FileScorer.worst_files_per_behavior(files_map)
+
+      for {_key, entries} <- result do
+        assert length(entries) <= 2
+      end
+    end
+
+    test "each entry has top_metrics key" do
+      files_map = build_files_map()
+      result = FileScorer.worst_files_per_behavior(files_map)
+
+      for {_key, entries} <- result, entry <- entries do
+        assert Map.has_key?(entry, :top_metrics), "missing :top_metrics in #{inspect(entry)}"
+      end
+    end
+
+    test "top_metrics is a list" do
+      files_map = build_files_map()
+      result = FileScorer.worst_files_per_behavior(files_map)
+
+      for {_key, entries} <- result, entry <- entries do
+        assert is_list(entry.top_metrics)
+      end
+    end
+
+    test "top_metrics is [] (not nil) when all contributions are zero" do
+      # Single file with no variation — cosines will be near 0
+      files_map = %{
+        "lib/zero.ex" => %{
+          "metrics" => %{
+            "halstead" => %{"tokens" => 0.0}
+          },
+          "lines" => 1,
+          "bytes" => 5
+        }
+      }
+
+      result = FileScorer.worst_files_per_behavior(files_map)
+
+      for {_key, entries} <- result, entry <- entries do
+        assert entry.top_metrics == []
+      end
+    end
+
+    test "each entry has top_nodes key" do
+      files_map = build_files_map()
+      result = FileScorer.worst_files_per_behavior(files_map)
+
+      for {_key, entries} <- result, entry <- entries do
+        assert Map.has_key?(entry, :top_nodes), "missing :top_nodes in #{inspect(entry)}"
+      end
+    end
+
+    test "top_nodes is [] when file_data has no nodes key" do
+      files_map = build_files_map()
+      result = FileScorer.worst_files_per_behavior(files_map)
+
+      for {_key, entries} <- result, entry <- entries do
+        assert entry.top_nodes == []
+      end
+    end
+
+    test "top_nodes is [] when file_data nodes is nil" do
+      files_map =
+        build_files_map()
+        |> Map.new(fn {path, data} -> {path, Map.put(data, "nodes", nil)} end)
+
+      result = FileScorer.worst_files_per_behavior(files_map)
+
+      for {_key, entries} <- result, entry <- entries do
+        assert entry.top_nodes == []
+      end
+    end
+
+    test "top_nodes is [] when file_data nodes is []" do
+      files_map =
+        build_files_map()
+        |> Map.new(fn {path, data} -> {path, Map.put(data, "nodes", [])} end)
+
+      result = FileScorer.worst_files_per_behavior(files_map)
+
+      for {_key, entries} <- result, entry <- entries do
+        assert entry.top_nodes == []
+      end
+    end
+  end
+
+  # Build a realistic files_map using a real project file so diagnose_aggregate
+  # has real metric values to work with. We use a small fixed map rather than
+  # running the full analyzer to keep tests fast.
+  defp build_files_map do
+    %{
+      "lib/example_a.ex" => %{
+        "metrics" => %{
+          "halstead" => %{
+            "tokens" => 80.0,
+            "vocabulary" => 30.0,
+            "volume" => 400.0,
+            "difficulty" => 12.0,
+            "effort" => 4800.0,
+            "bugs" => 0.1
+          },
+          "branching" => %{
+            "branching_density" => 0.3
+          },
+          "entropy" => %{
+            "normalized_entropy" => 0.75
+          },
+          "function_metrics" => %{
+            "avg_function_length" => 20.0,
+            "max_function_length" => 40.0,
+            "function_count" => 5.0,
+            "avg_params" => 2.0,
+            "max_params" => 4.0
+          },
+          "readability" => %{
+            "readability_score" => 0.6
+          },
+          "indentation" => %{
+            "avg_indent_level" => 2.0,
+            "max_indent_level" => 4.0,
+            "indent_variance" => 0.5
+          }
+        },
+        "lines" => 100,
+        "bytes" => 2048
+      },
+      "lib/example_b.ex" => %{
+        "metrics" => %{
+          "halstead" => %{
+            "tokens" => 200.0,
+            "vocabulary" => 60.0,
+            "volume" => 1200.0,
+            "difficulty" => 30.0,
+            "effort" => 36000.0,
+            "bugs" => 0.4
+          },
+          "branching" => %{
+            "branching_density" => 0.7
+          },
+          "entropy" => %{
+            "normalized_entropy" => 0.9
+          },
+          "function_metrics" => %{
+            "avg_function_length" => 50.0,
+            "max_function_length" => 120.0,
+            "function_count" => 15.0,
+            "avg_params" => 4.0,
+            "max_params" => 8.0
+          },
+          "readability" => %{
+            "readability_score" => 0.3
+          },
+          "indentation" => %{
+            "avg_indent_level" => 4.0,
+            "max_indent_level" => 8.0,
+            "indent_variance" => 2.0
+          }
+        },
+        "lines" => 300,
+        "bytes" => 8192
+      }
+    }
+  end
+end
diff --git a/test/codeqa/combined_metrics/sample_runner_test.exs b/test/codeqa/combined_metrics/sample_runner_test.exs
new file mode 100644
index 0000000..ea582d2
--- /dev/null
+++ b/test/codeqa/combined_metrics/sample_runner_test.exs
@@ -0,0 +1,34 @@
+defmodule CodeQA.CombinedMetrics.SampleRunnerTest do
+  use ExUnit.Case
+
+  alias CodeQA.CombinedMetrics.SampleRunner
+
+  setup_all do
+    results = SampleRunner.run(category: "variable_naming", verbose: true)
+    %{results: results}
+  end
+
+  describe "run/1" do
+    test "returns a list of results with required keys", %{results: results} do
+      assert is_list(results)
+      assert length(results) > 0
+      result = hd(results)
+      assert Map.has_key?(result, :bad_score)
+      assert Map.has_key?(result, :good_score)
+      assert Map.has_key?(result, :ratio)
+      assert Map.has_key?(result, :direction_ok)
+    end
+
+    test "name_is_generic result has good_score > bad_score", %{results: results} do
+      generic = Enum.find(results, &(&1.behavior == "name_is_generic"))
+      assert generic != nil
+      assert generic.good_score > generic.bad_score
+    end
+
+    test "verbose: true populates metric_detail", %{results: results} do
+      [result | _] = results
+      assert is_list(result.metric_detail)
+      # only populated when behavior has scalars configured
+    end
+  end
+end

From 5d67df721fb1db0b1ae9d8ff4144e2fbf2530841 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 19 Mar 2026 18:26:52 +0100
Subject: [PATCH 07/71] feat(near-duplicate-blocks): add near-duplicate block
 detection and impact analysis

Introduce winnowing-based near-duplicate block detection at file and codebase
level. BlockImpactAnalyzer computes refactoring potentials by identifying
duplicated code blocks across files. Includes LinePatterns helper and
CRC-based block matching for efficient similarity detection.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/block_impact/codebase_impact.ex    |  22 +
 lib/codeqa/block_impact/file_impact.ex        |  46 ++
 .../block_impact/refactoring_potentials.ex    |  87 ++++
 lib/codeqa/block_impact_analyzer.ex           | 192 ++++++++
 .../metrics/codebase/codebase_metric.ex       |  14 +
 .../near_duplicate_blocks_codebase.ex         |  44 ++
 lib/codeqa/metrics/file/line_patterns.ex      |  83 ++++
 .../metrics/file/near_duplicate_blocks.ex     | 442 ++++++++++++++++++
 .../file/near_duplicate_blocks_file.ex        |  37 ++
 .../block_impact/codebase_impact_test.exs     |  59 +++
 test/codeqa/block_impact/file_impact_test.exs |  64 +++
 .../refactoring_potentials_test.exs           | 108 +++++
 test/codeqa/block_impact_analyzer_test.exs    |  86 ++++
 test/codeqa/block_matcher_test.exs            |  37 ++
 .../near_duplicate_blocks_codebase_test.exs   |  98 ++++
 test/codeqa/metrics/file/bradford_test.exs    | 122 +++++
 test/codeqa/metrics/file/brevity_test.exs     |  44 ++
 .../file/near_duplicate_blocks_file_test.exs  |  52 +++
 .../file/near_duplicate_blocks_test.exs       | 227 +++++++++
 test/codeqa/metrics/file/rfc_test.exs         |  97 ++++
 20 files changed, 1961 insertions(+)
 create mode 100644 lib/codeqa/block_impact/codebase_impact.ex
 create mode 100644 lib/codeqa/block_impact/file_impact.ex
 create mode 100644 lib/codeqa/block_impact/refactoring_potentials.ex
 create mode 100644 lib/codeqa/block_impact_analyzer.ex
 create mode 100644 lib/codeqa/metrics/codebase/codebase_metric.ex
 create mode 100644 lib/codeqa/metrics/codebase/near_duplicate_blocks_codebase.ex
 create mode 100644 lib/codeqa/metrics/file/line_patterns.ex
 create mode 100644 lib/codeqa/metrics/file/near_duplicate_blocks.ex
 create mode 100644 lib/codeqa/metrics/file/near_duplicate_blocks_file.ex
 create mode 100644 test/codeqa/block_impact/codebase_impact_test.exs
 create mode 100644 test/codeqa/block_impact/file_impact_test.exs
 create mode 100644 test/codeqa/block_impact/refactoring_potentials_test.exs
 create mode 100644 test/codeqa/block_impact_analyzer_test.exs
 create mode 100644 test/codeqa/block_matcher_test.exs
 create mode 100644 test/codeqa/metrics/codebase/near_duplicate_blocks_codebase_test.exs
 create mode 100644 test/codeqa/metrics/file/bradford_test.exs
 create mode 100644 test/codeqa/metrics/file/brevity_test.exs
 create mode 100644 test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs
 create mode 100644 test/codeqa/metrics/file/near_duplicate_blocks_test.exs
 create mode 100644 test/codeqa/metrics/file/rfc_test.exs

diff --git a/lib/codeqa/block_impact/codebase_impact.ex b/lib/codeqa/block_impact/codebase_impact.ex
new file mode 100644
index 0000000..50fa5ba
--- /dev/null
+++ b/lib/codeqa/block_impact/codebase_impact.ex
@@ -0,0 +1,22 @@
+defmodule CodeQA.BlockImpact.CodebaseImpact do
+  @moduledoc """
+  Leave-one-out codebase aggregate: reconstruct file content without a target node,
+  replace the file in the files map, and re-run the codebase aggregate.
+  """
+
+  alias CodeQA.AST.Enrichment.Node
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.BlockImpact.FileImpact
+  alias CodeQA.Engine.Analyzer
+
+  @doc """
+  Returns the codebase aggregate after removing the target node from the given file.
+  """
+  @spec compute(String.t(), String.t(), Node.t(), map()) :: map()
+  def compute(path, content, node, files_map) do
+    root_tokens = TokenNormalizer.normalize_structural(content)
+    reconstructed = FileImpact.reconstruct_without(root_tokens, node)
+    updated_files = Map.put(files_map, path, reconstructed)
+    Analyzer.analyze_codebase_aggregate(updated_files)
+  end
+end
diff --git a/lib/codeqa/block_impact/file_impact.ex b/lib/codeqa/block_impact/file_impact.ex
new file mode 100644
index 0000000..10bd1f9
--- /dev/null
+++ b/lib/codeqa/block_impact/file_impact.ex
@@ -0,0 +1,46 @@
+defmodule CodeQA.BlockImpact.FileImpact do
+  @moduledoc """
+  Leave-one-out file metrics: reconstruct file content without a target node's tokens
+  and return the re-run file metrics map.
+  """
+
+  alias CodeQA.AST.Enrichment.Node
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.Engine.Analyzer
+
+  @min_tokens 10
+
+  @doc """
+  Computes file metrics for the content with the target node's tokens removed.
+
+  Returns `nil` if the node has fewer than `#{@min_tokens}` tokens.
+  Returns a raw `%{"group" => %{"key" => value}}` metrics map otherwise.
+  """
+  @spec compute(String.t(), Node.t()) :: map() | nil
+  def compute(_content, %Node{tokens: tokens}) when length(tokens) < @min_tokens, do: nil
+
+  def compute(content, node) do
+    root_tokens = TokenNormalizer.normalize_structural(content)
+    reconstructed = reconstruct_without(root_tokens, node)
+    Analyzer.analyze_file("", reconstructed)
+  end
+
+  @spec reconstruct_without([CodeQA.AST.Lexing.Token.t()], Node.t()) :: String.t()
+  def reconstruct_without(root_tokens, %Node{tokens: []}) do
+    Enum.map_join(root_tokens, "", & &1.content)
+  end
+
+  def reconstruct_without(root_tokens, node) do
+    first = List.first(node.tokens)
+
+    case Enum.find_index(root_tokens, fn t -> t.line == first.line and t.col == first.col end) do
+      nil ->
+        Enum.map_join(root_tokens, "", & &1.content)
+
+      start_idx ->
+        end_idx = start_idx + length(node.tokens)
+        remaining = Enum.take(root_tokens, start_idx) ++ Enum.drop(root_tokens, end_idx)
+        Enum.map_join(remaining, "", & &1.content)
+    end
+  end
+end
diff --git a/lib/codeqa/block_impact/refactoring_potentials.ex b/lib/codeqa/block_impact/refactoring_potentials.ex
new file mode 100644
index 0000000..34ca366
--- /dev/null
+++ b/lib/codeqa/block_impact/refactoring_potentials.ex
@@ -0,0 +1,87 @@
+defmodule CodeQA.BlockImpact.RefactoringPotentials do
+  @moduledoc """
+  Computes named refactoring potentials for a code block using leave-one-out cosine deltas.
+
+  Given baseline and without-node metrics at both file scope and codebase scope,
+  computes the cosine delta per behavior, merges the two scopes via max(), and
+  returns the top N behaviors sorted by delta descending.
+
+  Positive delta = removing the block improved that behavior's cosine → the block
+  is a contributor to that anti-pattern.
+  """
+
+  alias CodeQA.CombinedMetrics.FileScorer
+  alias CodeQA.CombinedMetrics.SampleRunner
+
+  @doc """
+  Returns top N refactoring potentials for a code block.
+
+  ## Parameters
+
+  - `baseline_file_cosines` — pre-computed cosines list from `SampleRunner.diagnose_aggregate/2` for the baseline file
+  - `without_file_metrics` — raw `%{"group" => %{"key" => val}}` with the node's tokens removed
+  - `baseline_codebase_cosines` — pre-computed cosines list for the full codebase baseline
+  - `without_codebase_agg` — `%{"group" => %{"mean_key" => val}}` with the node removed from the codebase
+
+  ## Options
+
+  - `:top` — number of potentials to return (default 3)
+
+  ## Result shape
+
+      [%{"category" => "function_design", "behavior" => "cyclomatic_complexity_under_10", "cosine_delta" => 0.41}]
+  """
+  @spec compute([map()], map(), [map()], map(), keyword()) :: [map()]
+  def compute(
+        baseline_file_cosines,
+        without_file_metrics,
+        baseline_codebase_cosines,
+        without_codebase_agg,
+        opts \\ []
+      ) do
+    top_n = Keyword.get(opts, :top, 3)
+
+    file_delta = compute_file_delta(baseline_file_cosines, without_file_metrics)
+    codebase_delta = compute_codebase_delta(baseline_codebase_cosines, without_codebase_agg)
+
+    all_keys = Enum.uniq(Map.keys(file_delta) ++ Map.keys(codebase_delta))
+
+    all_keys
+    |> Enum.map(fn {category, behavior} ->
+      file_d = Map.get(file_delta, {category, behavior}, 0.0)
+      codebase_d = Map.get(codebase_delta, {category, behavior}, 0.0)
+      merged = max(file_d, codebase_d)
+      {category, behavior, merged}
+    end)
+    |> Enum.sort_by(fn {_, _, delta} -> delta end, :desc)
+    |> Enum.take(top_n)
+    |> Enum.map(fn {category, behavior, delta} ->
+      %{
+        "category" => category,
+        "behavior" => behavior,
+        "cosine_delta" => Float.round(delta / 1.0, 4)
+      }
+    end)
+  end
+
+  defp compute_file_delta(baseline_cosines, without_metrics) do
+    without_agg = FileScorer.file_to_aggregate(without_metrics)
+    without_cosines = SampleRunner.diagnose_aggregate(without_agg, top: 99_999)
+    cosines_to_delta(baseline_cosines, without_cosines)
+  end
+
+  defp compute_codebase_delta(baseline_cosines, without_agg) do
+    without_cosines = SampleRunner.diagnose_aggregate(without_agg, top: 99_999)
+    cosines_to_delta(baseline_cosines, without_cosines)
+  end
+
+  defp cosines_to_delta(baseline_cosines, without_cosines) do
+    without_map =
+      Map.new(without_cosines, fn %{category: c, behavior: b, cosine: cos} -> {{c, b}, cos} end)
+
+    Map.new(baseline_cosines, fn %{category: c, behavior: b, cosine: cos} ->
+      without_cos = Map.get(without_map, {c, b}, 0.0)
+      {{c, b}, without_cos - cos}
+    end)
+  end
+end
diff --git a/lib/codeqa/block_impact_analyzer.ex b/lib/codeqa/block_impact_analyzer.ex
new file mode 100644
index 0000000..f4b17e4
--- /dev/null
+++ b/lib/codeqa/block_impact_analyzer.ex
@@ -0,0 +1,192 @@
+defmodule CodeQA.BlockImpactAnalyzer do
+  @moduledoc """
+  Orchestrates block impact analysis across all files in a pipeline result.
+
+  For each file, tokenizes its content, parses it into a node tree, and for each
+  node (recursively including children) computes refactoring potentials via
+  leave-one-out impact scoring at both file scope and codebase scope.
+
+  The pipeline result is returned with a `"nodes"` key added to each file entry.
+  All other keys in the result are preserved unchanged.
+  """
+
+  alias CodeQA.AST.Enrichment.Node
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.BlockImpact.{FileImpact, RefactoringPotentials}
+  alias CodeQA.CombinedMetrics.{FileScorer, SampleRunner}
+  alias CodeQA.Engine.Analyzer
+  alias CodeQA.Languages.Unknown
+
+  @min_tokens 10
+
+  @doc """
+  Analyzes all files in the pipeline result, adding `"nodes"` to each file entry.
+
+  ## Parameters
+
+  - `pipeline_result` — direct return value of `Engine.Analyzer.analyze_codebase/2`,
+    containing `"files"` and `"codebase"` keys
+  - `files_map` — raw `%{path => content}` map used for file-scope leave-one-out
+  - `opts` — keyword options
+
+  ## Options
+
+  - `:nodes_top` — number of refactoring potentials per node (default 3)
+  - `:workers` — parallelism for `Task.async_stream` (default `System.schedulers_online()`)
+  """
+  @spec analyze(map(), map(), keyword()) :: map()
+  def analyze(pipeline_result, files_map, opts \\ []) do
+    nodes_top = Keyword.get(opts, :nodes_top, 3)
+    workers = Keyword.get(opts, :workers, System.schedulers_online())
+
+    baseline_codebase_agg = Analyzer.analyze_codebase_aggregate(files_map)
+
+    baseline_codebase_cosines =
+      SampleRunner.diagnose_aggregate(baseline_codebase_agg, top: 99_999)
+
+    file_results = pipeline_result["files"]
+
+    updated_files =
+      file_results
+      |> Task.async_stream(
+        fn {path, file_data} ->
+          content = Map.get(files_map, path, "")
+          baseline_file_metrics = Map.get(file_data, "metrics", %{})
+
+          nodes =
+            compute_nodes(
+              path,
+              content,
+              baseline_file_metrics,
+              file_results,
+              baseline_codebase_cosines,
+              nodes_top
+            )
+
+          {path, Map.put(file_data, "nodes", nodes)}
+        end,
+        max_concurrency: workers,
+        ordered: false,
+        timeout: :infinity
+      )
+      |> Enum.reduce(%{}, fn {:ok, {path, data}}, acc -> Map.put(acc, path, data) end)
+
+    Map.put(pipeline_result, "files", updated_files)
+  end
+
+  defp compute_nodes(
+         path,
+         content,
+         baseline_file_metrics,
+         file_results,
+         baseline_codebase_cosines,
+         nodes_top
+       ) do
+    if content == "" do
+      []
+    else
+      root_tokens = TokenNormalizer.normalize_structural(content)
+      top_level_nodes = Parser.detect_blocks(root_tokens, Unknown)
+
+      baseline_file_agg = FileScorer.file_to_aggregate(baseline_file_metrics)
+      baseline_file_cosines = SampleRunner.diagnose_aggregate(baseline_file_agg, top: 99_999)
+
+      top_level_nodes
+      |> Enum.map(fn node ->
+        serialize_node(
+          node,
+          path,
+          content,
+          root_tokens,
+          baseline_file_cosines,
+          file_results,
+          baseline_codebase_cosines,
+          nodes_top
+        )
+      end)
+      |> Enum.sort_by(fn n -> {n["start_line"], n["column_start"]} end)
+    end
+  end
+
+  defp serialize_node(
+         node,
+         path,
+         content,
+         root_tokens,
+         baseline_file_cosines,
+         file_results,
+         baseline_codebase_cosines,
+         nodes_top
+       ) do
+    potentials =
+      if length(node.tokens) < @min_tokens do
+        []
+      else
+        compute_potentials(
+          node,
+          path,
+          root_tokens,
+          baseline_file_cosines,
+          file_results,
+          baseline_codebase_cosines,
+          nodes_top
+        )
+      end
+
+    children =
+      node.children
+      |> Enum.map(fn child ->
+        serialize_node(
+          child,
+          path,
+          content,
+          root_tokens,
+          baseline_file_cosines,
+          file_results,
+          baseline_codebase_cosines,
+          nodes_top
+        )
+      end)
+      |> Enum.sort_by(fn n -> {n["start_line"], n["column_start"]} end)
+
+    first_token = List.first(node.tokens)
+    char_length = Enum.reduce(node.tokens, 0, fn t, acc -> acc + byte_size(t.content) end)
+
+    %{
+      "start_line" => node.start_line,
+      "column_start" => (first_token && first_token.col) || 0,
+      "char_length" => char_length,
+      "type" => Atom.to_string(node.type),
+      "token_count" => length(node.tokens),
+      "refactoring_potentials" => potentials,
+      "children" => children
+    }
+  end
+
+  defp compute_potentials(
+         %Node{} = node,
+         path,
+         root_tokens,
+         baseline_file_cosines,
+         file_results,
+         baseline_codebase_cosines,
+         nodes_top
+       ) do
+    reconstructed = FileImpact.reconstruct_without(root_tokens, node)
+    without_file_metrics = Analyzer.analyze_file(path, reconstructed)
+
+    without_codebase_agg =
+      file_results
+      |> Map.put(path, %{"metrics" => without_file_metrics})
+      |> Analyzer.aggregate_file_metrics()
+
+    RefactoringPotentials.compute(
+      baseline_file_cosines,
+      without_file_metrics,
+      baseline_codebase_cosines,
+      without_codebase_agg,
+      top: nodes_top
+    )
+  end
+end
diff --git a/lib/codeqa/metrics/codebase/codebase_metric.ex b/lib/codeqa/metrics/codebase/codebase_metric.ex
new file mode 100644
index 0000000..8b275c8
--- /dev/null
+++ b/lib/codeqa/metrics/codebase/codebase_metric.ex
@@ -0,0 +1,14 @@
+defmodule CodeQA.Metrics.Codebase.CodebaseMetric do
+  @moduledoc """
+  Behaviour for metrics that operate across an entire codebase.
+
+  Unlike `FileMetric`, which analyzes a single file, codebase metrics receive
+  a map of all source files and can compute cross-file properties such as
+  duplication or structural similarity.
+
+  See [software metrics](https://en.wikipedia.org/wiki/Software_metric).
+  """
+
+  @callback name() :: String.t()
+  @callback analyze(%{String.t() => String.t()}, keyword()) :: map()
+end
diff --git a/lib/codeqa/metrics/codebase/near_duplicate_blocks_codebase.ex b/lib/codeqa/metrics/codebase/near_duplicate_blocks_codebase.ex
new file mode 100644
index 0000000..2e821e9
--- /dev/null
+++ b/lib/codeqa/metrics/codebase/near_duplicate_blocks_codebase.ex
@@ -0,0 +1,44 @@
+defmodule CodeQA.Metrics.Codebase.NearDuplicateBlocksCodebase do
+  @moduledoc """
+  Counts near-duplicate and exact-duplicate natural code blocks across the codebase.
+
+  Detects blocks per file, pools them, and finds pairs across all files.
+  Includes pair source lists (capped by max_pairs_per_bucket).
+
+  Configure in .codeqa.yml:
+      near_duplicate_blocks:
+        max_pairs_per_bucket: 50
+  """
+
+  @behaviour CodeQA.Metrics.Codebase.CodebaseMetric
+
+  alias CodeQA.Analysis.FileContextServer
+  alias CodeQA.Metrics.File.NearDuplicateBlocks
+
+  @impl true
+  def name, do: "near_duplicate_blocks_codebase"
+
+  @impl true
+  def analyze(files, opts \\ []) do
+    ndb_opts = Keyword.get(opts, :near_duplicate_blocks, [])
+    max_pairs = Keyword.get(ndb_opts, :max_pairs_per_bucket, nil)
+    workers = Keyword.get(opts, :workers, System.schedulers_online())
+
+    ndb_opts =
+      [include_pairs: true, max_pairs_per_bucket: max_pairs, workers: workers] ++
+        Keyword.take(opts, [:on_progress])
+
+    pid = Keyword.fetch!(opts, :file_context_pid)
+
+    all_blocks =
+      Enum.flat_map(files, fn {path, content} ->
+        ctx = FileContextServer.get(pid, content, path: path)
+        NearDuplicateBlocks.label_blocks(ctx.blocks, path)
+      end)
+
+    result = NearDuplicateBlocks.analyze_from_blocks(all_blocks, ndb_opts)
+
+    result
+    |> Map.reject(fn {k, _} -> k in ["block_count", "sub_block_count"] end)
+  end
+end
diff --git a/lib/codeqa/metrics/file/line_patterns.ex b/lib/codeqa/metrics/file/line_patterns.ex
new file mode 100644
index 0000000..e8b2b45
--- /dev/null
+++ b/lib/codeqa/metrics/file/line_patterns.ex
@@ -0,0 +1,83 @@
+defmodule CodeQA.Metrics.File.LinePatterns do
+  @moduledoc """
+  Structural line-level and nesting metrics.
+
+  ## Output keys
+
+  - `"blank_line_ratio"` — blank lines / total lines (spacing/organisation signal)
+  - `"unique_line_ratio"` — distinct non-blank trimmed lines / total non-blank lines
+    (low values indicate repetition or boilerplate)
+  - `"max_nesting_depth"` — maximum bracket nesting depth across `()`, `[]`, `{}`
+    (complexity proxy independent of branching keywords)
+  - `"string_literal_ratio"` — quoted string literal spans / total tokens
+    (high values may indicate magic strings or hardcoded data)
+  """
+
+  @behaviour CodeQA.Metrics.File.FileMetric
+
+  @impl true
+  def name, do: "line_patterns"
+
+  @impl true
+  def keys,
+    do: ["blank_line_ratio", "unique_line_ratio", "max_nesting_depth", "string_literal_ratio"]
+
+  @string_literal ~r/(?:"[^"]*"|'[^']*')/
+
+  @spec analyze(map()) :: map()
+  @impl true
+  def analyze(%{content: content, lines: lines, tokens: tokens}) do
+    total_lines = length(lines)
+    total_tokens = length(tokens)
+
+    if total_lines == 0 do
+      %{
+        "blank_line_ratio" => 0.0,
+        "unique_line_ratio" => 1.0,
+        "max_nesting_depth" => 0,
+        "string_literal_ratio" => 0.0
+      }
+    else
+      blank_count = Enum.count(lines, &(String.trim(&1) == ""))
+      blank_ratio = Float.round(blank_count / total_lines, 4)
+
+      non_blank = lines |> Enum.map(&String.trim/1) |> Enum.reject(&(&1 == ""))
+
+      unique_ratio =
+        if non_blank == [],
+          do: 1.0,
+          else: Float.round(length(Enum.uniq(non_blank)) / length(non_blank), 4)
+
+      string_count = @string_literal |> Regex.scan(content) |> length()
+
+      string_ratio =
+        if total_tokens == 0,
+          do: 0.0,
+          else: Float.round(string_count / total_tokens, 4)
+
+      %{
+        "blank_line_ratio" => blank_ratio,
+        "unique_line_ratio" => unique_ratio,
+        "max_nesting_depth" => max_nesting_depth(content),
+        "string_literal_ratio" => string_ratio
+      }
+    end
+  end
+
+  defp max_nesting_depth(content) do
+    content
+    |> String.graphemes()
+    |> Enum.reduce({0, 0}, fn
+      char, {depth, max_d} when char in ["(", "[", "{"] ->
+        new_depth = depth + 1
+        {new_depth, max(max_d, new_depth)}
+
+      char, {depth, max_d} when char in [")", "]", "}"] ->
+        {max(depth - 1, 0), max_d}
+
+      _, acc ->
+        acc
+    end)
+    |> elem(1)
+  end
+end
diff --git a/lib/codeqa/metrics/file/near_duplicate_blocks.ex b/lib/codeqa/metrics/file/near_duplicate_blocks.ex
new file mode 100644
index 0000000..c1cb707
--- /dev/null
+++ b/lib/codeqa/metrics/file/near_duplicate_blocks.ex
@@ -0,0 +1,442 @@
+defmodule CodeQA.Metrics.File.NearDuplicateBlocks do
+  @moduledoc """
+  Near-duplicate block detection using natural code blocks.
+
+  Detects blocks via blank-line boundaries and sub-blocks via bracket/indentation rules.
+  Compares structurally similar blocks by token-level edit distance, bucketed as a
+  percentage of the smaller block's token count.
+
+  Distance buckets:
+    d0 = exact (0%), d1 ≤ 5%, d2 ≤ 10%, d3 ≤ 15%, d4 ≤ 20%,
+    d5 ≤ 25%, d6 ≤ 30%, d7 ≤ 40%, d8 ≤ 50%
+  """
+
+  alias CodeQA.AST.Enrichment.Node
+  alias CodeQA.AST.Classification.NodeProtocol
+  alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Lexing.{NewlineToken, WhitespaceToken}
+  alias CodeQA.Language
+
+  @max_bucket 8
+  @bucket_thresholds [
+    {0, 0.0},
+    {1, 0.05},
+    {2, 0.10},
+    {3, 0.15},
+    {4, 0.20},
+    {5, 0.25},
+    {6, 0.30},
+    {7, 0.40},
+    {8, 0.50}
+  ]
+
+  # Pre-compute token kind strings to avoid repeated function calls in the hot path.
+  @nl_kind NewlineToken.kind()
+  @ws_kind WhitespaceToken.kind()
+
+  @doc "Standard Levenshtein distance between two token lists."
+  @spec token_edit_distance([String.t()], [String.t()]) :: non_neg_integer()
+  def token_edit_distance([], b), do: length(b)
+  def token_edit_distance(a, []), do: length(a)
+
+  def token_edit_distance(a, b) do
+    a_arr = List.to_tuple(a)
+    b_arr = List.to_tuple(b)
+    lb = tuple_size(b_arr)
+    init_row = List.to_tuple(Enum.to_list(0..lb))
+    result_row = levenshtein_rows(a_arr, b_arr, tuple_size(a_arr), lb, init_row, 1)
+    elem(result_row, lb)
+  end
+
+  defp levenshtein_rows(_a, _b, la, _lb, prev, i) when i > la, do: prev
+
+  defp levenshtein_rows(a, b, la, lb, prev, i) do
+    ai = elem(a, i - 1)
+    curr_reversed = levenshtein_cols(b, lb, prev, ai, [i], 1)
+    curr = List.to_tuple(:lists.reverse(curr_reversed))
+    levenshtein_rows(a, b, la, lb, curr, i + 1)
+  end
+
+  defp levenshtein_cols(_b, lb, _prev, _ai, acc, j) when j > lb, do: acc
+
+  defp levenshtein_cols(b, lb, prev, ai, [last_val | _] = acc, j) do
+    cost = if ai == elem(b, j - 1), do: 0, else: 1
+    val = min(elem(prev, j) + 1, min(last_val + 1, elem(prev, j - 1) + cost))
+    levenshtein_cols(b, lb, prev, ai, [val | acc], j + 1)
+  end
+
+  # Bounded Levenshtein: returns the edit distance, or max_distance + 1 if the
+  # distance would exceed max_distance. Bails after each row when the row minimum
+  # already exceeds max_distance — the final distance can only grow from there.
+  defp token_edit_distance_bounded([], b, _max), do: length(b)
+  defp token_edit_distance_bounded(a, [], _max), do: length(a)
+
+  defp token_edit_distance_bounded(a, b, max_distance) do
+    a_arr = List.to_tuple(a)
+    b_arr = List.to_tuple(b)
+    lb = tuple_size(b_arr)
+    init_row = List.to_tuple(Enum.to_list(0..lb))
+    levenshtein_rows_bounded(a_arr, b_arr, tuple_size(a_arr), lb, init_row, max_distance, 1)
+  end
+
+  defp levenshtein_rows_bounded(_a, _b, la, lb, prev, _max, i) when i > la, do: elem(prev, lb)
+
+  defp levenshtein_rows_bounded(a, b, la, lb, prev, max_distance, i) do
+    ai = elem(a, i - 1)
+    # levenshtein_cols_with_min tracks the row minimum as it builds, avoiding
+    # a separate O(lb) pass to find the min after the row is complete.
+    {curr_reversed, row_min} = levenshtein_cols_with_min(b, lb, prev, ai, {[i], i}, 1)
+    curr = List.to_tuple(:lists.reverse(curr_reversed))
+
+    if row_min > max_distance do
+      max_distance + 1
+    else
+      levenshtein_rows_bounded(a, b, la, lb, curr, max_distance, i + 1)
+    end
+  end
+
+  defp levenshtein_cols_with_min(_b, lb, _prev, _ai, acc_and_min, j) when j > lb, do: acc_and_min
+
+  defp levenshtein_cols_with_min(b, lb, prev, ai, {[last_val | _] = acc, min_val}, j) do
+    cost = if ai == elem(b, j - 1), do: 0, else: 1
+    val = min(elem(prev, j) + 1, min(last_val + 1, elem(prev, j - 1) + cost))
+    levenshtein_cols_with_min(b, lb, prev, ai, {[val | acc], min(min_val, val)}, j + 1)
+  end
+
+  @doc "Map an edit distance and min token count to a percentage bucket 0–8, or nil if > 50%."
+  @spec percent_bucket(non_neg_integer(), non_neg_integer()) :: 0..8 | nil
+  def percent_bucket(_ed, 0), do: nil
+  def percent_bucket(0, _min_count), do: 0
+
+  def percent_bucket(ed, min_count) do
+    pct = ed / min_count
+
+    @bucket_thresholds
+    |> Enum.find(fn {bucket, threshold} -> bucket > 0 and pct <= threshold end)
+    |> case do
+      {bucket, _} -> bucket
+      nil -> nil
+    end
+  end
+
+  @doc """
+  Analyze a list of `{path, content}` pairs for near-duplicate blocks.
+  Returns count keys `near_dup_block_d0..d8`, `block_count`, `sub_block_count`.
+  With `include_pairs: true` in opts, also returns `_pairs` keys.
+  """
+  @dialyzer {:nowarn_function, analyze: 2}
+  @spec analyze([{String.t(), String.t()}], keyword()) :: map()
+  def analyze(labeled_content, opts) do
+    all_blocks =
+      Enum.flat_map(labeled_content, fn {path, content} ->
+        lang_mod = Language.detect(path)
+        tokens = TokenNormalizer.normalize_structural(content)
+
+        Parser.detect_blocks(tokens, lang_mod)
+        |> label_blocks(path)
+      end)
+
+    analyze_from_blocks(all_blocks, opts)
+  end
+
+  @doc """
+  Analyze a pre-built list of labeled `Node.t()` structs for near-duplicate blocks.
+  Skips tokenization and block detection — use when blocks are already available.
+  Returns the same keys as `analyze/2`.
+  """
+  @dialyzer {:nowarn_function, analyze_from_blocks: 2}
+  @spec analyze_from_blocks([Node.t()], keyword()) :: map()
+  def analyze_from_blocks(all_blocks, opts) do
+    workers = Keyword.get(opts, :workers, System.schedulers_online())
+    max_pairs = Keyword.get(opts, :max_pairs_per_bucket, nil)
+    include_pairs = Keyword.get(opts, :include_pairs, false)
+
+    block_count = length(all_blocks)
+
+    find_pairs_opts =
+      [workers: workers, max_pairs_per_bucket: max_pairs] ++
+        Keyword.take(opts, [:on_progress, :idf_max_freq])
+
+    # do_find_pairs computes sub_block_count from the decorated list it already
+    # builds, eliminating the separate NodeProtocol.children pass.
+    {buckets, sub_block_count} = do_find_pairs(all_blocks, find_pairs_opts)
+
+    result =
+      for d <- 0..@max_bucket, into: %{} do
+        {"near_dup_block_d#{d}", Map.get(buckets, d, %{count: 0}).count}
+      end
+
+    result =
+      Map.merge(result, %{"block_count" => block_count, "sub_block_count" => sub_block_count})
+
+    case include_pairs do
+      true ->
+        pairs_result =
+          for d <- 0..@max_bucket, into: %{} do
+            {"near_dup_block_d#{d}_pairs",
+             Map.get(buckets, d, %{pairs: []}).pairs |> format_pairs()}
+          end
+
+        Map.merge(result, pairs_result)
+
+      false ->
+        result
+    end
+  end
+
+  @doc "Find near-duplicate pairs across a list of %Node{} structs."
+  @spec find_pairs([Node.t()], keyword()) :: map()
+  def find_pairs(blocks, opts) do
+    {buckets, _sub_block_count} = do_find_pairs(blocks, opts)
+    buckets
+  end
+
+  # Internal implementation returning {buckets, sub_block_count} so that
+  # analyze_from_blocks gets both without a redundant NodeProtocol.children pass.
+  defp do_find_pairs(blocks, opts) do
+    workers = Keyword.get(opts, :workers, System.schedulers_online())
+    max_pairs = Keyword.get(opts, :max_pairs_per_bucket, nil)
+    idf_max_freq = Keyword.get(opts, :idf_max_freq, 1.0)
+    has_progress = Keyword.has_key?(opts, :on_progress)
+
+    if length(blocks) < 2 do
+      {%{}, 0}
+    else
+      # Pre-compute canonical values and hashes once per block. Each decorated entry
+      # is {index, block, values, hash, len_values, children_count, newline_count, bigrams}
+      # so downstream functions never recompute them.
+      decorated =
+        blocks
+        |> Enum.with_index()
+        |> Enum.map(fn {block, i} ->
+          values = canonical_values(NodeProtocol.flat_tokens(block))
+          children_count = length(NodeProtocol.children(block))
+          newline_count = Enum.count(values, &(&1 == @nl_kind))
+          bigrams = Enum.chunk_every(values, 2, 1, :discard)
+
+          {i, block, values, :erlang.phash2(values), length(values), children_count,
+           newline_count, bigrams}
+        end)
+
+      # sub_block_count derived from the already-computed children_count in decorated.
+      sub_block_count =
+        Enum.reduce(decorated, 0, fn {_, _, _, _, _, cc, _, _}, acc -> acc + cc end)
+
+      # IDF: prune bigrams that appear in more than idf_max_freq fraction of blocks.
+      # These are structural noise (e.g. "end nil", "return false") that inflate the
+      # candidate set without helping identify true duplicates.
+      pruned = compute_frequent_bigrams(decorated, idf_max_freq)
+
+      decorated =
+        if MapSet.size(pruned) > 0 do
+          Enum.map(decorated, fn {i, b, v, h, l, c, n, bigrams} ->
+            {i, b, v, h, l, c, n,
+             Enum.reject(bigrams, &MapSet.member?(pruned, :erlang.phash2(&1)))}
+          end)
+        else
+          decorated
+        end
+
+      {exact_index, shingle_index} = build_indexes(decorated)
+
+      total = length(decorated)
+      # Convert to tuple for O(1) indexed lookup inside the hot comparison loop.
+      decorated_arr = List.to_tuple(decorated)
+
+      if has_progress,
+        do: IO.puts(:stderr, "  Comparing #{total} blocks for near-duplicates...")
+
+      raw_pairs =
+        decorated
+        |> Flow.from_enumerable(max_demand: 10, stages: workers)
+        |> Flow.flat_map(&find_pairs_for_block(&1, decorated_arr, exact_index, shingle_index))
+        |> Enum.to_list()
+
+      {bucket_pairs(raw_pairs, max_pairs), sub_block_count}
+    end
+  end
+
+  # Returns the set of bigram hashes that appear in more than max_freq fraction of blocks.
+  defp compute_frequent_bigrams(decorated, max_freq) do
+    total = length(decorated)
+    # Minimum threshold of 2 so a bigram must appear in 3+ blocks before being
+    # pruned — prevents over-pruning when the total block count is very small
+    # (e.g. with 2 blocks, any shared bigram would otherwise always be pruned).
+    threshold = max(2, round(total * max_freq))
+
+    decorated
+    |> Enum.reduce(%{}, fn {_, _, _, _, _, _, _, bigrams}, acc ->
+      bigrams
+      |> Enum.uniq_by(&:erlang.phash2/1)
+      |> Enum.reduce(acc, fn bigram, a ->
+        Map.update(a, :erlang.phash2(bigram), 1, &(&1 + 1))
+      end)
+    end)
+    |> Enum.filter(fn {_, count} -> count > threshold end)
+    |> Enum.map(&elem(&1, 0))
+    |> MapSet.new()
+  end
+
+  # Strip leading/trailing <NL> and <WS> tokens and extract kind values as strings.
+  # This ensures blocks split at blank-line boundaries compare as equal
+  # even if trailing newlines differ between first and last blocks.
+  # Returns [String.t()] (kinds only) so hashing, comparison, and edit distance
+  # are independent of token line/col metadata.
+  #
+  # Optimised to 3 passes: one reduce (skip leading NL/WS + collect reversed kinds),
+  # one drop_while (strip trailing from the reversed list), one :lists.reverse.
+  defp canonical_values(tokens) do
+    # Pass 1: skip leading NL/WS while building a reversed kinds list.
+    {reversed, _in_content} =
+      Enum.reduce(tokens, {[], false}, fn t, {acc, in_content} ->
+        kind = t.kind
+        is_skip = kind == @nl_kind or kind == @ws_kind
+
+        if in_content or not is_skip do
+          {[kind | acc], true}
+        else
+          {acc, false}
+        end
+      end)
+
+    # Pass 2: drop trailing NL/WS (which appear as leading in the reversed list).
+    # Pass 3: reverse back to source order via native BIF.
+    reversed
+    |> Enum.drop_while(&(&1 == @nl_kind or &1 == @ws_kind))
+    |> :lists.reverse()
+  end
+
+  # Build both exact (hash → [idx]) and shingle (bigram_hash → [idx]) indexes in one pass,
+  # using the pre-computed values from the decorated list.
+  defp build_indexes(decorated) do
+    Enum.reduce(decorated, {%{}, %{}}, fn {idx, _block, _values, hash, _len, _children, _newlines,
+                                           bigrams},
+                                          {exact_acc, shingle_acc} ->
+      exact_acc = Map.update(exact_acc, hash, [idx], &[idx | &1])
+
+      shingle_acc =
+        bigrams
+        |> Enum.reduce(shingle_acc, fn bigram, sh_acc ->
+          h = :erlang.phash2(bigram)
+          Map.update(sh_acc, h, [idx], &[idx | &1])
+        end)
+
+      {exact_acc, shingle_acc}
+    end)
+  end
+
+  defp find_pairs_for_block(
+         {i, block_a, values_a, hash_a, len_a, children_a, newlines_a, bigrams_a},
+         decorated_arr,
+         exact_index,
+         shingle_index
+       ) do
+    # For small exact-match lists (typically 0–3 entries) a plain list membership
+    # check avoids the overhead of constructing a MapSet.
+    exact_list = Map.get(exact_index, hash_a, [])
+
+    # For d0 (exact), find hash-matching blocks and confirm with value equality
+    # to guard against phash2 collisions.
+    exact_pairs =
+      exact_list
+      |> Enum.filter(&(&1 > i))
+      |> Enum.map(fn j ->
+        {_j, block_b, values_b, _hash_b, _len_b, children_b, newlines_b, _bigrams_b} =
+          elem(decorated_arr, j)
+
+        if values_b == values_a and
+             structure_compatible?(children_a, newlines_a, children_b, newlines_b) do
+          {0, {block_a.label, block_b.label}}
+        else
+          nil
+        end
+      end)
+      |> Enum.reject(&is_nil/1)
+
+    # For d1-d8 (near), use shingle index to find candidates.
+    min_shared = max(0, round(len_a * 0.5) - 1)
+
+    near_pairs =
+      bigrams_a
+      |> Enum.reduce(%{}, fn bigram, acc ->
+        h = :erlang.phash2(bigram)
+
+        Map.get(shingle_index, h, [])
+        |> Enum.reduce(acc, fn j, cnt ->
+          if j > i, do: Map.update(cnt, j, 1, &(&1 + 1)), else: cnt
+        end)
+      end)
+      |> Enum.filter(fn {_, count} -> count >= min_shared end)
+      |> Enum.map(&elem(&1, 0))
+      |> Enum.reject(fn j -> j in exact_list end)
+      |> Enum.flat_map(fn j ->
+        {_j, block_b, values_b, _hash_b, len_b, children_b, newlines_b, _bigrams_b} =
+          elem(decorated_arr, j)
+
+        min_count = min(len_a, len_b)
+        max_allowed = round(min_count * 0.5)
+
+        if structure_compatible?(children_a, newlines_a, children_b, newlines_b) and
+             abs(len_a - len_b) <= max_allowed do
+          ed = token_edit_distance_bounded(values_a, values_b, max_allowed)
+
+          case percent_bucket(ed, min_count) do
+            nil -> []
+            bucket when bucket > 0 -> [{bucket, {block_a.label, block_b.label}}]
+            # ed=0 handled by exact_pairs above
+            _ -> []
+          end
+        else
+          []
+        end
+      end)
+
+    exact_pairs ++ near_pairs
+  end
+
+  # Uses pre-computed children counts and newline counts from the decorated tuple
+  # so NodeProtocol.children/1 and Enum.count/2 are not called per candidate pair.
+  defp structure_compatible?(children_a, newlines_a, children_b, newlines_b) do
+    sub_diff = abs(children_a - children_b)
+    lines_a = newlines_a + 1
+    lines_b = newlines_b + 1
+    max_lines = max(lines_a, lines_b)
+    line_ratio = if max_lines > 0, do: abs(lines_a - lines_b) / max_lines, else: 0.0
+    sub_diff <= 1 and line_ratio <= 0.30
+  end
+
+  defp bucket_pairs(raw_pairs, max_pairs) do
+    Enum.reduce(raw_pairs, %{}, fn {bucket, pair}, acc ->
+      Map.update(
+        acc,
+        bucket,
+        %{count: 1, pairs: maybe_append([], pair, max_pairs, 0)},
+        fn existing ->
+          %{
+            count: existing.count + 1,
+            pairs: maybe_append(existing.pairs, pair, max_pairs, existing.count)
+          }
+        end
+      )
+    end)
+  end
+
+  # Uses the already-tracked count instead of length(list) to avoid an O(n) walk.
+  defp maybe_append(list, _pair, max, count) when is_integer(max) and count >= max, do: list
+  defp maybe_append(list, pair, _max, _count), do: [pair | list]
+
+  @doc false
+  def label_blocks(blocks, path) do
+    Enum.map(blocks, fn block ->
+      label = if block.start_line, do: "#{path}:#{block.start_line}", else: path
+      %{block | label: label}
+    end)
+  end
+
+  defp format_pairs(pairs) do
+    Enum.map(pairs, fn {label_a, label_b} ->
+      %{"source_a" => label_a, "source_b" => label_b}
+    end)
+  end
+end
diff --git a/lib/codeqa/metrics/file/near_duplicate_blocks_file.ex b/lib/codeqa/metrics/file/near_duplicate_blocks_file.ex
new file mode 100644
index 0000000..86f71e3
--- /dev/null
+++ b/lib/codeqa/metrics/file/near_duplicate_blocks_file.ex
@@ -0,0 +1,37 @@
+defmodule CodeQA.Metrics.File.NearDuplicateBlocksFile do
+  @moduledoc """
+  Counts near-duplicate and exact-duplicate natural code blocks within a single file.
+
+  Blocks are detected at blank-line boundaries with sub-block detection via bracket rules.
+  Distance is a percentage of the smaller block's token count, bucketed d0–d8.
+  Also reports block_count and sub_block_count as standalone metrics.
+  """
+
+  @behaviour CodeQA.Metrics.File.FileMetric
+
+  alias CodeQA.Metrics.File.NearDuplicateBlocks
+
+  @impl true
+  def name, do: "near_duplicate_blocks_file"
+
+  @impl true
+  def keys do
+    ["block_count", "sub_block_count"] ++ for(d <- 0..8, do: "near_dup_block_d#{d}")
+  end
+
+  @impl true
+  def analyze(%{path: path, blocks: blocks}) when is_list(blocks) do
+    NearDuplicateBlocks.analyze_from_blocks(
+      NearDuplicateBlocks.label_blocks(blocks, path || "unknown"),
+      []
+    )
+    |> Map.reject(fn {k, _} -> String.ends_with?(k, "_pairs") end)
+  end
+
+  def analyze(ctx) do
+    path = ctx.path || "unknown"
+
+    NearDuplicateBlocks.analyze([{path, ctx.content}], [])
+    |> Map.reject(fn {k, _} -> String.ends_with?(k, "_pairs") end)
+  end
+end
diff --git a/test/codeqa/block_impact/codebase_impact_test.exs b/test/codeqa/block_impact/codebase_impact_test.exs
new file mode 100644
index 0000000..0a0c264
--- /dev/null
+++ b/test/codeqa/block_impact/codebase_impact_test.exs
@@ -0,0 +1,59 @@
+defmodule CodeQA.BlockImpact.CodebaseImpactTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.BlockImpact.CodebaseImpact
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.Languages.Unknown
+
+  @content_a """
+  defmodule A do
+    def foo do
+      x = 1 + 2
+      y = x * 3
+      x + y
+    end
+
+    def bar do
+      :ok
+    end
+  end
+  """
+
+  @content_b """
+  defmodule B do
+    def baz, do: :baz
+  end
+  """
+
+  defp files_map, do: %{"lib/a.ex" => @content_a, "lib/b.ex" => @content_b}
+
+  defp first_block(content) do
+    tokens = TokenNormalizer.normalize_structural(content)
+    [first | _] = Parser.detect_blocks(tokens, Unknown)
+    first
+  end
+
+  describe "compute/4" do
+    test "returns a codebase aggregate map" do
+      node = first_block(@content_a)
+      result = CodebaseImpact.compute("lib/a.ex", @content_a, node, files_map())
+      assert is_map(result)
+      # Should have at least one group with mean_ keys
+      all_keys = result |> Map.values() |> Enum.flat_map(&Map.keys/1)
+      assert Enum.any?(all_keys, &String.starts_with?(&1, "mean_"))
+    end
+
+    test "produces a different aggregate than the baseline when a large node is removed" do
+      node = first_block(@content_a)
+
+      if length(node.tokens) >= 10 do
+        baseline = CodeQA.Engine.Analyzer.analyze_codebase_aggregate(files_map())
+        without = CodebaseImpact.compute("lib/a.ex", @content_a, node, files_map())
+        # Not necessarily different in all keys, but result is valid
+        assert is_map(without)
+        assert is_map(baseline)
+      end
+    end
+  end
+end
diff --git a/test/codeqa/block_impact/file_impact_test.exs b/test/codeqa/block_impact/file_impact_test.exs
new file mode 100644
index 0000000..3bffe8c
--- /dev/null
+++ b/test/codeqa/block_impact/file_impact_test.exs
@@ -0,0 +1,64 @@
+defmodule CodeQA.BlockImpact.FileImpactTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.BlockImpact.FileImpact
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.Languages.Unknown
+
+  @fixture_content """
+  defmodule MyModule do
+    def foo do
+      x = 1
+      y = 2
+      x + y
+    end
+
+    def bar do
+      :ok
+    end
+  end
+  """
+
+  defp get_first_block(content) do
+    tokens = TokenNormalizer.normalize_structural(content)
+    [first | _] = Parser.detect_blocks(tokens, Unknown)
+    first
+  end
+
+  describe "compute/2" do
+    test "returns a metrics map when node has >= 10 tokens" do
+      node = get_first_block(@fixture_content)
+
+      if length(node.tokens) >= 10 do
+        result = FileImpact.compute(@fixture_content, node)
+        assert is_map(result)
+        assert map_size(result) > 0
+      end
+    end
+
+    test "returns nil for a node with fewer than 10 tokens" do
+      # Create a tiny node by parsing very short content
+      tiny_content = "x = 1"
+      tokens = TokenNormalizer.normalize_structural(tiny_content)
+      nodes = Parser.detect_blocks(tokens, Unknown)
+      # Find or construct a node with < 10 tokens
+      small_nodes = Enum.filter(nodes, fn n -> length(n.tokens) < 10 end)
+
+      if small_nodes != [] do
+        node = List.first(small_nodes)
+        assert FileImpact.compute(tiny_content, node) == nil
+      end
+    end
+
+    test "reconstructed content does not contain the removed node's first token line" do
+      tokens = TokenNormalizer.normalize_structural(@fixture_content)
+      [node | _] = Parser.detect_blocks(tokens, Unknown)
+      # Only test if node is large enough
+      if length(node.tokens) >= 10 do
+        result = FileImpact.compute(@fixture_content, node)
+        assert is_map(result)
+      end
+    end
+  end
+end
diff --git a/test/codeqa/block_impact/refactoring_potentials_test.exs b/test/codeqa/block_impact/refactoring_potentials_test.exs
new file mode 100644
index 0000000..d5f2014
--- /dev/null
+++ b/test/codeqa/block_impact/refactoring_potentials_test.exs
@@ -0,0 +1,108 @@
+defmodule CodeQA.BlockImpact.RefactoringPotentialsTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.BlockImpact.RefactoringPotentials
+  alias CodeQA.CombinedMetrics.FileScorer
+  alias CodeQA.CombinedMetrics.SampleRunner
+
+  defp file_cosines(fm) do
+    fm
+    |> FileScorer.file_to_aggregate()
+    |> SampleRunner.diagnose_aggregate(top: 99_999)
+  end
+
+  describe "compute/5" do
+    test "returns a list of maps with category, behavior, cosine_delta" do
+      content = """
+      defmodule Foo do
+        def bar(a, b, c) do
+          if a do
+            if b do
+              if c do
+                :nested
+              end
+            end
+          end
+        end
+      end
+      """
+
+      baseline_fm = CodeQA.Engine.Analyzer.analyze_file("lib/foo.ex", content)
+      simple = "defmodule Foo do\n  def bar, do: :ok\nend\n"
+      without_fm = CodeQA.Engine.Analyzer.analyze_file("lib/foo.ex", simple)
+
+      files = %{"lib/foo.ex" => content}
+      baseline_agg = CodeQA.Engine.Analyzer.analyze_codebase_aggregate(files)
+      without_agg = CodeQA.Engine.Analyzer.analyze_codebase_aggregate(%{"lib/foo.ex" => simple})
+
+      baseline_file_cosines = file_cosines(baseline_fm)
+      baseline_codebase_cosines = SampleRunner.diagnose_aggregate(baseline_agg, top: 99_999)
+
+      result =
+        RefactoringPotentials.compute(
+          baseline_file_cosines,
+          without_fm,
+          baseline_codebase_cosines,
+          without_agg
+        )
+
+      assert is_list(result)
+
+      Enum.each(result, fn item ->
+        assert Map.has_key?(item, "category")
+        assert Map.has_key?(item, "behavior")
+        assert Map.has_key?(item, "cosine_delta")
+        assert is_binary(item["category"])
+        assert is_binary(item["behavior"])
+        assert is_float(item["cosine_delta"])
+      end)
+    end
+
+    test "returns at most top N results (default 3)" do
+      content = "defmodule A do\n  def foo, do: 1\nend\n"
+      fm = CodeQA.Engine.Analyzer.analyze_file("lib/a.ex", content)
+      agg = CodeQA.Engine.Analyzer.analyze_codebase_aggregate(%{"lib/a.ex" => content})
+
+      baseline_file_cosines = file_cosines(fm)
+      baseline_codebase_cosines = SampleRunner.diagnose_aggregate(agg, top: 99_999)
+
+      result =
+        RefactoringPotentials.compute(baseline_file_cosines, fm, baseline_codebase_cosines, agg)
+
+      assert length(result) <= 3
+    end
+
+    test "respects top: N option" do
+      content = "defmodule A do\n  def foo, do: 1\nend\n"
+      fm = CodeQA.Engine.Analyzer.analyze_file("lib/a.ex", content)
+      agg = CodeQA.Engine.Analyzer.analyze_codebase_aggregate(%{"lib/a.ex" => content})
+
+      baseline_file_cosines = file_cosines(fm)
+      baseline_codebase_cosines = SampleRunner.diagnose_aggregate(agg, top: 99_999)
+
+      result =
+        RefactoringPotentials.compute(baseline_file_cosines, fm, baseline_codebase_cosines, agg,
+          top: 5
+        )
+
+      assert length(result) <= 5
+    end
+
+    test "results are sorted descending by cosine_delta" do
+      content = "defmodule A do\n  def foo, do: 1\nend\n"
+      fm = CodeQA.Engine.Analyzer.analyze_file("lib/a.ex", content)
+      agg = CodeQA.Engine.Analyzer.analyze_codebase_aggregate(%{"lib/a.ex" => content})
+
+      baseline_file_cosines = file_cosines(fm)
+      baseline_codebase_cosines = SampleRunner.diagnose_aggregate(agg, top: 99_999)
+
+      result =
+        RefactoringPotentials.compute(baseline_file_cosines, fm, baseline_codebase_cosines, agg,
+          top: 99
+        )
+
+      deltas = Enum.map(result, & &1["cosine_delta"])
+      assert deltas == Enum.sort(deltas, :desc)
+    end
+  end
+end
diff --git a/test/codeqa/block_impact_analyzer_test.exs b/test/codeqa/block_impact_analyzer_test.exs
new file mode 100644
index 0000000..98aaecb
--- /dev/null
+++ b/test/codeqa/block_impact_analyzer_test.exs
@@ -0,0 +1,86 @@
+defmodule CodeQA.BlockImpactAnalyzerTest do
+  # async: false because the orchestrator uses Task.async_stream internally
+  use ExUnit.Case, async: false
+
+  alias CodeQA.BlockImpactAnalyzer
+
+  @fixture_content """
+  defmodule MyModule do
+    def foo do
+      x = 1
+      y = 2
+      x + y
+    end
+
+    def bar do
+      :ok
+    end
+  end
+  """
+
+  describe "analyze/3" do
+    test "adds 'nodes' key to each file entry in the pipeline result" do
+      files = %{"lib/my_module.ex" => @fixture_content}
+      pipeline_result = CodeQA.Engine.Analyzer.analyze_codebase(files)
+
+      result = BlockImpactAnalyzer.analyze(pipeline_result, files)
+
+      assert Map.has_key?(result, "files")
+      assert Map.has_key?(result["files"], "lib/my_module.ex")
+      file_data = result["files"]["lib/my_module.ex"]
+      assert Map.has_key?(file_data, "nodes")
+      assert is_list(file_data["nodes"])
+    end
+
+    test "each node has required fields" do
+      files = %{"lib/my_module.ex" => @fixture_content}
+      pipeline_result = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      result = BlockImpactAnalyzer.analyze(pipeline_result, files)
+
+      nodes = result["files"]["lib/my_module.ex"]["nodes"]
+
+      Enum.each(nodes, fn node ->
+        assert Map.has_key?(node, "start_line")
+        assert Map.has_key?(node, "column_start")
+        assert Map.has_key?(node, "char_length")
+        assert Map.has_key?(node, "type")
+        assert Map.has_key?(node, "token_count")
+        assert Map.has_key?(node, "refactoring_potentials")
+        assert Map.has_key?(node, "children")
+        assert is_list(node["refactoring_potentials"])
+        assert is_list(node["children"])
+      end)
+    end
+
+    test "nodes are sorted by start_line ascending" do
+      files = %{"lib/my_module.ex" => @fixture_content}
+      pipeline_result = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      result = BlockImpactAnalyzer.analyze(pipeline_result, files)
+
+      nodes = result["files"]["lib/my_module.ex"]["nodes"]
+      start_lines = Enum.map(nodes, & &1["start_line"])
+      assert start_lines == Enum.sort(start_lines)
+    end
+
+    test "preserves existing 'codebase' key in pipeline result" do
+      files = %{"lib/my_module.ex" => @fixture_content}
+      pipeline_result = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      result = BlockImpactAnalyzer.analyze(pipeline_result, files)
+
+      assert Map.has_key?(result, "codebase")
+      assert result["codebase"] == pipeline_result["codebase"]
+    end
+
+    test "nodes_top option limits refactoring_potentials per node" do
+      files = %{"lib/my_module.ex" => @fixture_content}
+      pipeline_result = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      result = BlockImpactAnalyzer.analyze(pipeline_result, files, nodes_top: 1)
+
+      nodes = result["files"]["lib/my_module.ex"]["nodes"]
+
+      Enum.each(nodes, fn node ->
+        assert length(node["refactoring_potentials"]) <= 1
+      end)
+    end
+  end
+end
diff --git a/test/codeqa/block_matcher_test.exs b/test/codeqa/block_matcher_test.exs
new file mode 100644
index 0000000..da55a09
--- /dev/null
+++ b/test/codeqa/block_matcher_test.exs
@@ -0,0 +1,37 @@
+defmodule Test.NodeMatcherTest do
+  use ExUnit.Case, async: true
+
+  alias Test.NodeMatcher
+
+  describe "exact/2" do
+    test "returns tagged tuple for :content field" do
+      assert {:exact, :content, "add"} = NodeMatcher.exact(:content, "add")
+    end
+
+    test "returns tagged tuple for :value field" do
+      assert {:exact, :value, "identifier"} = NodeMatcher.exact(:value, "identifier")
+    end
+
+    test "raises FunctionClauseError for unsupported field" do
+      assert_raise FunctionClauseError, fn ->
+        NodeMatcher.exact(:type, "something")
+      end
+    end
+  end
+
+  describe "partial/2" do
+    test "returns tagged tuple for :content field" do
+      assert {:partial, :content, "@doc"} = NodeMatcher.partial(:content, "@doc")
+    end
+
+    test "returns tagged tuple for :value field" do
+      assert {:partial, :value, "doc"} = NodeMatcher.partial(:value, "doc")
+    end
+
+    test "raises FunctionClauseError for unsupported field" do
+      assert_raise FunctionClauseError, fn ->
+        NodeMatcher.partial(:type, "something")
+      end
+    end
+  end
+end
diff --git a/test/codeqa/metrics/codebase/near_duplicate_blocks_codebase_test.exs b/test/codeqa/metrics/codebase/near_duplicate_blocks_codebase_test.exs
new file mode 100644
index 0000000..1c79776
--- /dev/null
+++ b/test/codeqa/metrics/codebase/near_duplicate_blocks_codebase_test.exs
@@ -0,0 +1,98 @@
+defmodule CodeQA.Metrics.Codebase.NearDuplicateBlocksCodebaseTest do
+  use ExUnit.Case, async: true
+  alias CodeQA.Analysis.FileContextServer
+  alias CodeQA.Metrics.Codebase.NearDuplicateBlocksCodebase
+
+  defp files(pairs), do: Map.new(pairs)
+
+  defp with_pid(fun) do
+    {:ok, pid} = FileContextServer.start_link()
+    fun.(pid)
+  end
+
+  describe "name/0" do
+    test "returns near_duplicate_blocks_codebase" do
+      assert NearDuplicateBlocksCodebase.name() == "near_duplicate_blocks_codebase"
+    end
+  end
+
+  describe "analyze/2" do
+    test "returns all count keys d0..d8" do
+      with_pid(fn pid ->
+        result =
+          NearDuplicateBlocksCodebase.analyze(files([{"a.ex", "x = 1\n"}]), file_context_pid: pid)
+
+        for d <- 0..8, do: assert(Map.has_key?(result, "near_dup_block_d#{d}"))
+      end)
+    end
+
+    test "returns all pairs keys d0..d8" do
+      with_pid(fn pid ->
+        result =
+          NearDuplicateBlocksCodebase.analyze(files([{"a.ex", "x = 1\n"}]), file_context_pid: pid)
+
+        for d <- 0..8, do: assert(Map.has_key?(result, "near_dup_block_d#{d}_pairs"))
+      end)
+    end
+
+    test "zero counts for a single trivial file" do
+      with_pid(fn pid ->
+        result =
+          NearDuplicateBlocksCodebase.analyze(files([{"a.ex", "x = 1\n"}]), file_context_pid: pid)
+
+        assert result["near_dup_block_d0"] == 0
+      end)
+    end
+
+    test "detects exact duplicate block across two files" do
+      block = "def foo\n  x = 1\nend\n"
+
+      with_pid(fn pid ->
+        result =
+          NearDuplicateBlocksCodebase.analyze(
+            files([{"a.ex", block}, {"b.ex", block}]),
+            file_context_pid: pid
+          )
+
+        assert result["near_dup_block_d0"] >= 1
+      end)
+    end
+
+    test "pair sources include file paths" do
+      block = "def foo\n  x = 1\nend\n"
+
+      with_pid(fn pid ->
+        result =
+          NearDuplicateBlocksCodebase.analyze(
+            files([{"a.ex", block}, {"b.ex", block}]),
+            file_context_pid: pid
+          )
+
+        all_pairs = result |> Map.values() |> Enum.filter(&is_list/1) |> List.flatten()
+
+        if all_pairs != [] do
+          pair = hd(all_pairs)
+          assert Map.has_key?(pair, "source_a")
+          assert Map.has_key?(pair, "source_b")
+        end
+      end)
+    end
+
+    test "pairs list is capped at max_pairs_per_bucket" do
+      block = "def foo\n  x = 1\nend\n"
+      many_files = for i <- 1..5, do: {"file#{i}.ex", block}
+
+      with_pid(fn pid ->
+        result =
+          NearDuplicateBlocksCodebase.analyze(
+            files(many_files),
+            file_context_pid: pid,
+            near_duplicate_blocks: [max_pairs_per_bucket: 2]
+          )
+
+        pairs_lists = result |> Map.values() |> Enum.filter(&is_list/1)
+        assert Enum.all?(pairs_lists, &(length(&1) <= 2))
+      end)
+    end
+  end
+end
diff --git a/test/codeqa/metrics/file/bradford_test.exs b/test/codeqa/metrics/file/bradford_test.exs
new file mode 100644
index 0000000..f323ca8
--- /dev/null
+++ b/test/codeqa/metrics/file/bradford_test.exs
@@ -0,0 +1,122 @@
+defmodule CodeQA.Metrics.File.BradfordTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.Metrics.File.Bradford
+  alias CodeQA.Engine.Pipeline
+
+  # Bradford zones are built by ranking lines densest-first, then walking down
+  # until each third of total tokens is accumulated:
+  #   zone 1 (core)   — fewest lines needed to reach 1/3 of all tokens
+  #   zone 2 (middle) — fewest additional lines to reach 2/3
+  #   zone 3 (tail)   — all remaining lines
+  #
+  # k1 = zone2_lines / zone1_lines  — how many more lines the middle needs vs the core
+  # k2 = zone3_lines / zone2_lines  — how many more lines the tail needs vs the middle
+  # k_ratio = k2 / k1               — > 1 means tail is more stretched; < 1 means core is extreme
+
+  defp ctx(code), do: Pipeline.build_file_context(code)
+  defp result(code), do: Bradford.analyze(ctx(code))
+
+  describe "analyze/1 - edge cases" do
+    test "returns zeros for empty content" do
+      # can't form three meaningful zones with nothing
+      assert result("") == %{"k1" => 0.0, "k2" => 0.0, "k_ratio" => 0.0}
+    end
+
+    test "returns zeros for a single line" do
+      # a single line cannot be split into three zones
+      assert result("a b c") == %{"k1" => 0.0, "k2" => 0.0, "k_ratio" => 0.0}
+    end
+
+    test "returns zeros for two lines" do
+      # two lines still can't fill three zones
+      assert result("a b c\nd e f") == %{"k1" => 0.0, "k2" => 0.0, "k_ratio" => 0.0}
+    end
+  end
+
+  describe "analyze/1 - uniform distribution" do
+    # 9 lines × 3 tokens = 27 total, third = 9
+    # sorted counts: [3, 3, 3, 3, 3, 3, 3, 3, 3]
+    # zone 1: 3 lines (3+3+3 = 9 ≥ 9)
+    # zone 2: 3 lines (3+3+3 = 9 ≥ 9)
+    # zone 3: 3 lines remaining
+    # k1 = 3/3 = 1.0  — middle needs the same number of lines as the core
+    # k2 = 3/3 = 1.0  — tail needs the same number of lines as the middle
+    # k_ratio = 1.0   — perfectly symmetric: no zone is more stretched than another
+    test "uniform file has k = 1" do
+      code = Enum.map_join(1..9, "\n", fn _ -> "a b c" end)
+      assert result(code) == %{"k1" => 1.0, "k2" => 1.0, "k_ratio" => 1.0}
+    end
+  end
+
+  describe "analyze/1 - Bradford concentration" do
+    # 1 line with 10 tokens  +  3 lines with 3 tokens  +  9 lines with 1 token
+    # total = 28, third ≈ 9.333
+    # sorted: [10, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1]  (13 lines)
+    # zone 1: 1 line  (10 ≥ 9.333)                        → n1 = 1
+    # zone 2: 4 lines (3+3+3 = 9 < 9.333; +1 → 10 ≥ 9.333) → n2 = 4
+    # zone 3: 8 lines remaining                            → n3 = 8
+    # k1 = 4/1 = 4.0  — the middle needs 4× more lines than the dense core
+    # k2 = 8/4 = 2.0  — the tail needs 2× more lines than the middle
+    # k_ratio = 0.5   — the core-to-middle jump (4×) is bigger than middle-to-tail (2×),
+    #                    meaning extreme concentration is at the very top, not spread across zones
+    test "concentrated file produces k1=4.0, k2=2.0, k_ratio=0.5" do
+      dense = "a b c d e f g h i j"
+      medium = Enum.map_join(1..3, "\n", fn _ -> "a b c" end)
+      sparse = Enum.map_join(1..9, "\n", fn _ -> "a" end)
+      code = Enum.join([dense, medium, sparse], "\n")
+
+      assert result(code) == %{
+               # 1 dense line does the work of 4 middle lines — extreme core
+               "k1" => 4.0,
+               # 4 middle lines do the work of 8 tail lines — moderate long tail
+               "k2" => 2.0,
+               # k2 < k1: the core is more concentrated than the tail is sparse
+               "k_ratio" => 0.5
+             }
+    end
+
+    test "concentrated file has higher k1 than uniform" do
+      # k1 is the primary concentration signal: how many times more lines the
+      # middle zone needs compared to the core. A uniform file scores 1.0 here.
+      uniform = Enum.map_join(1..9, "\n", fn _ -> "a b c" end)
+
+      dense = "a b c d e f g h i j"
+      medium = Enum.map_join(1..3, "\n", fn _ -> "a b c" end)
+      sparse = Enum.map_join(1..9, "\n", fn _ -> "a" end)
+      concentrated = Enum.join([dense, medium, sparse], "\n")
+
+      assert result(concentrated)["k1"] > result(uniform)["k1"]
+    end
+
+    test "k_ratio < 1 when the core is more extreme than the tail" do
+      # k_ratio = k2 / k1
+      # k_ratio < 1  →  k2 < k1  →  the core-to-middle multiplier exceeds the
+      #                               middle-to-tail multiplier: the spike is at
+      #                               the very top, not spread evenly down the rank list
+      # k_ratio > 1  →  k2 > k1  →  the tail is more stretched than the core jump,
+      #                               typical of many medium lines plus a huge sparse tail
+      code =
+        Enum.join(
+          [
+            "a b c d e f g h i j",
+            "a b c",
+            "a b c",
+            "a b c",
+            "a",
+            "a",
+            "a",
+            "a",
+            "a",
+            "a",
+            "a",
+            "a",
+            "a"
+          ],
+          "\n"
+        )
+
+      assert result(code)["k_ratio"] < 1.0
+    end
+  end
+end
diff --git a/test/codeqa/metrics/file/brevity_test.exs b/test/codeqa/metrics/file/brevity_test.exs
new file mode 100644
index 0000000..2f5662d
--- /dev/null
+++ b/test/codeqa/metrics/file/brevity_test.exs
@@ -0,0 +1,44 @@
+defmodule CodeQA.Metrics.File.BrevityTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.Metrics.File.Brevity
+  alias CodeQA.Engine.Pipeline
+
+  defp ctx(code), do: Pipeline.build_file_context(code)
+  defp result(code), do: Brevity.analyze(ctx(code))
+
+  describe "analyze/1 - edge cases" do
+    test "returns zeros for empty content" do
+      assert result("") == %{"correlation" => 0.0, "slope" => 0.0, "sample_size" => 0}
+    end
+
+    test "returns zeros for fewer than 3 unique tokens" do
+      assert result("a a b b")["correlation"] == 0.0
+      assert result("a a b b")["slope"] == 0.0
+    end
+  end
+
+  describe "analyze/1 - brevity law" do
+    test "negative correlation when shorter tokens are more frequent" do
+      # x(len=1): 10×, to(len=2): 3×, longname(len=8): 1×
+      code = String.duplicate("x ", 10) <> String.duplicate("to ", 3) <> "longname"
+      assert result(code)["correlation"] < 0.0
+    end
+
+    test "positive correlation when longer tokens are more frequent" do
+      # longword(len=8): 4×, a(len=1): 1×, b(len=1): 1×
+      code = String.duplicate("longword ", 4) <> "a b"
+      assert result(code)["correlation"] > 0.0
+    end
+
+    test "sample_size reflects unique token count" do
+      code = "alpha beta gamma alpha beta"
+      assert result(code)["sample_size"] == 3
+    end
+
+    test "slope is negative when brevity law holds" do
+      code = String.duplicate("x ", 10) <> String.duplicate("to ", 3) <> "longname"
+      assert result(code)["slope"] < 0.0
+    end
+  end
+end
diff --git a/test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs b/test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs
new file mode 100644
index 0000000..d52234f
--- /dev/null
+++ b/test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs
@@ -0,0 +1,52 @@
+defmodule CodeQA.Metrics.File.NearDuplicateBlocksFileTest do
+  use ExUnit.Case, async: true
+  alias CodeQA.Metrics.File.NearDuplicateBlocksFile
+  alias CodeQA.Engine.Pipeline
+
+  defp ctx(code, path \\ "test.ex") do
+    base = Pipeline.build_file_context(code)
+    Map.put(base, :path, path)
+  end
+
+  describe "name/0" do
+    test "returns near_duplicate_blocks_file" do
+      assert NearDuplicateBlocksFile.name() == "near_duplicate_blocks_file"
+    end
+  end
+
+  describe "keys/0" do
+    test "returns 11 keys: block_count, sub_block_count, and d0..d8" do
+      keys = NearDuplicateBlocksFile.keys()
+      assert length(keys) == 11
+      assert "block_count" in keys
+      assert "sub_block_count" in keys
+      assert "near_dup_block_d0" in keys
+      assert "near_dup_block_d8" in keys
+    end
+  end
+
+  describe "analyze/1" do
+    test "returns a map with all expected keys" do
+      result = NearDuplicateBlocksFile.analyze(ctx("x = 1\n"))
+      assert Map.has_key?(result, "block_count")
+      assert Map.has_key?(result, "sub_block_count")
+      for d <- 0..8, do: assert(Map.has_key?(result, "near_dup_block_d#{d}"))
+    end
+
+    test "no _pairs keys in output" do
+      result = NearDuplicateBlocksFile.analyze(ctx("x = 1\n"))
+      refute Enum.any?(Map.keys(result), &String.ends_with?(&1, "_pairs"))
+    end
+
+    test "detects exact duplicate blocks at d0" do
+      block = "def foo\n  x = 1\nend\n"
+      result = NearDuplicateBlocksFile.analyze(ctx(block <> "\n\n" <> block))
+      assert result["near_dup_block_d0"] >= 1
+    end
+
+    test "block_count is positive for non-trivial file" do
+      result = NearDuplicateBlocksFile.analyze(ctx("def foo\n  x\nend\n"))
+      assert result["block_count"] >= 1
+    end
+  end
+end
diff --git a/test/codeqa/metrics/file/near_duplicate_blocks_test.exs b/test/codeqa/metrics/file/near_duplicate_blocks_test.exs
new file mode 100644
index 0000000..a65e201
--- /dev/null
+++ b/test/codeqa/metrics/file/near_duplicate_blocks_test.exs
@@ -0,0 +1,227 @@
+defmodule CodeQA.Metrics.File.NearDuplicateBlocksTest do
+  use ExUnit.Case, async: true
+  alias CodeQA.Metrics.File.NearDuplicateBlocks, as: NDB
+
+  describe "token_edit_distance/2" do
+    test "identical sequences have distance 0" do
+      assert NDB.token_edit_distance(~w[a b c], ~w[a b c]) == 0
+    end
+
+    test "empty vs non-empty equals length of other" do
+      assert NDB.token_edit_distance([], ~w[a b c]) == 3
+      assert NDB.token_edit_distance(~w[a b c], []) == 3
+    end
+
+    test "single substitution" do
+      assert NDB.token_edit_distance(~w[a b c], ~w[a x c]) == 1
+    end
+  end
+
+  describe "find_pairs/2 idf_max_freq option" do
+    defp make_block(tokens, label) do
+      %CodeQA.AST.Enrichment.Node{
+        label: label,
+        tokens: Enum.map(tokens, &%{kind: &1}),
+        line_count: length(tokens),
+        children: []
+      }
+    end
+
+    test "exact duplicates are still detected when all bigrams are high-frequency" do
+      # 30 blocks all sharing bigram [end, nil] → pruned by IDF
+      # Two additional identical blocks → should still match via exact hash index (d0)
+      common = Enum.map(1..30, fn i -> make_block(~w[end nil common_#{i}], "file:#{i}") end)
+      dup = make_block(~w[end nil special unique_token], "dup:1")
+      dup2 = make_block(~w[end nil special unique_token], "dup:2")
+
+      result = NDB.find_pairs(common ++ [dup, dup2], idf_max_freq: 0.05)
+
+      assert result[0].count >= 1
+    end
+
+    test "near-duplicates are detected via non-pruned unique bigrams" do
+      # 50 blocks all sharing [end, nil] → pruned
+      # Two near-duplicates sharing unique bigrams [nil, special], [special, alpha] → not pruned
+      common = Enum.map(1..50, fn i -> make_block(~w[end nil common_#{i}], "common:#{i}") end)
+      near_a = make_block(~w[end nil special alpha beta gamma], "near:1")
+      near_b = make_block(~w[end nil special alpha beta delta], "near:2")
+
+      result = NDB.find_pairs(common ++ [near_a, near_b], idf_max_freq: 0.05)
+
+      total = Map.values(result) |> Enum.map(& &1.count) |> Enum.sum()
+      assert total >= 1
+    end
+  end
+
+  describe "analyze_from_blocks/2 sub_block_count" do
+    test "sub_block_count equals sum of children counts across all blocks" do
+      child = make_block(["x"], "child:1")
+
+      parent = %CodeQA.AST.Enrichment.Node{
+        label: "a:1",
+        tokens: Enum.map(["def", "<ID>", "end"], &%{kind: &1}),
+        line_count: 3,
+        children: [child, child]
+      }
+
+      solo = make_block(["y", "z", "w", "v", "u"], "b:1")
+      result = NDB.analyze_from_blocks([parent, solo], [])
+      assert result["sub_block_count"] == 2
+    end
+
+    test "sub_block_count is zero when no block has children" do
+      a = make_block(["x", "y", "z", "w", "v"], "a:1")
+      b = make_block(["x", "y", "z", "w", "Q"], "b:1")
+      result = NDB.analyze_from_blocks([a, b], [])
+      assert result["sub_block_count"] == 0
+    end
+  end
+
+  describe "canonical_values (via find_pairs)" do
+    test "blocks identical except for leading/trailing newline tokens are detected as d0 exact duplicates" do
+      core = ["def", "<ID>", "end"]
+      trimmed = make_block(core, "a:1")
+      with_nl = make_block(["<NL>"] ++ core ++ ["<NL>"], "b:1")
+      result = NDB.find_pairs([trimmed, with_nl], [])
+      assert Map.get(result, 0, %{count: 0}).count >= 1
+    end
+
+    test "blocks identical except for leading/trailing whitespace tokens are detected as d0 exact duplicates" do
+      core = ["def", "<ID>", "end"]
+      trimmed = make_block(core, "a:1")
+      with_ws = make_block(["<WS>"] ++ core ++ ["<WS>"], "b:1")
+      result = NDB.find_pairs([trimmed, with_ws], [])
+      assert Map.get(result, 0, %{count: 0}).count >= 1
+    end
+  end
+
+  describe "find_pairs/2 near-boundary behavior" do
+    test "pair at exactly d8 boundary (50% edit distance) is detected" do
+      # 10 tokens each, 5 substitutions = exactly 50% edit distance → d8
+      # First 5 tokens identical → 4 shared bigrams, passes shingle filter
+      a = ~w[a b c d e f g h i j]
+      b = ~w[a b c d e X Y Z W V]
+      result = NDB.find_pairs([make_block(a, "x:1"), make_block(b, "x:2")], [])
+      total = Map.values(result) |> Enum.map(& &1.count) |> Enum.sum()
+      assert total >= 1
+    end
+
+    test "pair just over d8 boundary (>50% edit distance) is not reported" do
+      # a: 10 tokens, b: 11 tokens — first 5 identical (4 shared bigrams, passes shingle),
+      # abs(10-11)=1 passes token-length guard, but edit distance = 6 (60%) → nil
+      a = ~w[a b c d e f g h i j]
+      b = ~w[a b c d e X Y Z W V U]
+      result = NDB.find_pairs([make_block(a, "x:1"), make_block(b, "x:2")], [])
+      total = Map.values(result) |> Enum.map(& &1.count) |> Enum.sum()
+      assert total == 0
+    end
+  end
+
+  describe "percent_bucket/2" do
+    test "returns 0 for edit distance 0" do
+      assert NDB.percent_bucket(0, 100) == 0
+    end
+
+    test "returns 1 for 1% difference (within 0–5%)" do
+      assert NDB.percent_bucket(1, 100) == 1
+    end
+
+    test "returns 1 for 5% difference (boundary)" do
+      assert NDB.percent_bucket(5, 100) == 1
+    end
+
+    test "returns 2 for 6% difference" do
+      assert NDB.percent_bucket(6, 100) == 2
+    end
+
+    test "returns 8 for 50% difference" do
+      assert NDB.percent_bucket(50, 100) == 8
+    end
+
+    test "returns nil for >50% difference" do
+      assert NDB.percent_bucket(51, 100) == nil
+    end
+
+    test "returns nil when min_token_count is 0" do
+      assert NDB.percent_bucket(0, 0) == nil
+    end
+
+    test "returns 7 for exactly 40% (d7 upper boundary)" do
+      assert NDB.percent_bucket(40, 100) == 7
+    end
+
+    test "returns 8 for 41% (just above d7 boundary, in d8)" do
+      assert NDB.percent_bucket(41, 100) == 8
+    end
+
+    test "returns 7 for mid-range d7 (35%)" do
+      assert NDB.percent_bucket(35, 100) == 7
+    end
+  end
+
+  describe "analyze/2" do
+    test "returns all expected count keys" do
+      result = NDB.analyze([{"a.ex", "x = 1\n"}], [])
+
+      for d <- 0..8 do
+        assert Map.has_key?(result, "near_dup_block_d#{d}")
+      end
+    end
+
+    test "returns block_count and sub_block_count" do
+      result = NDB.analyze([{"a.ex", "def foo\n  x\nend\n"}], [])
+      assert Map.has_key?(result, "block_count")
+      assert Map.has_key?(result, "sub_block_count")
+    end
+
+    test "block_count reflects detected blocks" do
+      code = "def foo\n  x\nend\n\n\ndef bar\n  y\nend\n"
+      result = NDB.analyze([{"a.ex", code}], [])
+      assert result["block_count"] >= 2
+    end
+
+    test "detects exact duplicate blocks at d0" do
+      # Two identical function-like blocks separated by blank lines
+      block = "def foo\n  x = 1\nend\n"
+      result = NDB.analyze([{"a.ex", block <> "\n\n" <> block}], [])
+      assert result["near_dup_block_d0"] >= 1
+    end
+
+    test "detects near-duplicate blocks (single token difference)" do
+      block_a = "def foo\n  x = 1\nend\n"
+      # one identifier differs
+      block_b = "def bar\n  x = 1\nend\n"
+      result = NDB.analyze([{"a.ex", block_a <> "\n\n" <> block_b}], [])
+      near_dup_total = Enum.sum(for d <- 0..8, do: result["near_dup_block_d#{d}"])
+      assert near_dup_total >= 1
+    end
+
+    test "cross-file detection: same block in two files" do
+      block = "def foo\n  x = 1\nend\n"
+      result = NDB.analyze([{"a.ex", block}, {"b.ex", block}], [])
+      assert result["near_dup_block_d0"] >= 1
+    end
+
+    test "returns only count keys (no pairs keys)" do
+      result = NDB.analyze([{"a.ex", "x = 1\n"}], [])
+      refute Enum.any?(Map.keys(result), &String.ends_with?(&1, "_pairs"))
+    end
+
+    test "find_pairs/2 with include_pairs option returns pair data" do
+      block = "def foo\n  x = 1\nend\n"
+      result = NDB.analyze([{"a.ex", block <> "\n\n" <> block}], include_pairs: true)
+      pairs_keys = Map.keys(result) |> Enum.filter(&String.ends_with?(&1, "_pairs"))
+      assert pairs_keys != []
+    end
+
+    test "pair sources include file:line format" do
+      block = "def foo\n  x = 1\nend\n"
+      result = NDB.analyze([{"a.ex", block <> "\n\n" <> block}], include_pairs: true)
+      pairs = result["near_dup_block_d0_pairs"]
+      assert pairs != []
+      [first | _] = pairs
+      assert first["source_a"] =~ ~r/a\.ex:\d+/
+      assert first["source_b"] =~ ~r/a\.ex:\d+/
+    end
+  end
+end
diff --git a/test/codeqa/metrics/file/rfc_test.exs b/test/codeqa/metrics/file/rfc_test.exs
new file mode 100644
index 0000000..3ac9fcd
--- /dev/null
+++ b/test/codeqa/metrics/file/rfc_test.exs
@@ -0,0 +1,97 @@
+defmodule CodeQA.Metrics.File.RFCTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.Metrics.File.RFC
+  alias CodeQA.Engine.Pipeline
+
+  defp ctx(code), do: Pipeline.build_file_context(code)
+  defp result(code), do: RFC.analyze(ctx(code))
+
+  describe "analyze/1" do
+    test "returns zero counts for empty content" do
+      r = result("")
+      assert r["rfc_count"] == 0
+      assert r["rfc_density"] == 0.0
+    end
+
+    test "counts function definitions with no calls" do
+      code = """
+      def foo do
+        1
+      end
+      """
+
+      r = result(code)
+      assert r["function_def_count"] == 1
+      assert r["distinct_call_count"] == 0
+      assert r["rfc_count"] == 1
+    end
+
+    test "counts distinct call targets" do
+      code = """
+      def foo do
+        bar()
+        baz()
+        bar()
+      end
+      """
+
+      r = result(code)
+      # bar and baz are distinct call targets (bar appears twice but counts once)
+      assert r["distinct_call_count"] == 2
+      assert r["function_def_count"] == 1
+      assert r["rfc_count"] == 3
+    end
+
+    test "rfc_density is rfc_count normalized by line count" do
+      code = """
+      def foo do
+        bar()
+        baz()
+      end
+      """
+
+      c = ctx(code)
+      r = RFC.analyze(c)
+      assert r["rfc_density"] == Float.round(r["rfc_count"] / c.line_count, 4)
+    end
+
+    test "file with no functions and no calls returns all zeros" do
+      r = result("x = 1\ny = 2")
+      assert r["rfc_count"] == 0
+      assert r["function_def_count"] == 0
+      assert r["distinct_call_count"] == 0
+    end
+
+    test "file with only calls and no function definitions" do
+      code = "foo()\nbar()\nbaz()"
+      r = result(code)
+      assert r["function_def_count"] == 0
+      assert r["distinct_call_count"] == 3
+      assert r["rfc_count"] == 3
+    end
+
+    test "duplicate calls are deduplicated" do
+      code = "foo()\nfoo()\nfoo()"
+      r = result(code)
+      assert r["distinct_call_count"] == 1
+    end
+
+    test "multiple function definitions are counted" do
+      code = """
+      def foo do
+        bar()
+      end
+
+      def baz do
+        qux()
+      end
+      """
+
+      r = result(code)
+      assert r["function_def_count"] == 2
+      assert r["distinct_call_count"] == 2
+      assert r["rfc_count"] == 4
+    end
+  end
+end

From ef91d6b7b3763fc30fd3a03e6756a0e868c84b6a Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 19 Mar 2026 18:27:03 +0100
Subject: [PATCH 08/71] feat(diagnostics): add config and diagnostics modules

Add Config module for loading and validating .codeqa.yml configuration,
and Diagnostics module for surfacing rule violations and code issues
with structured output.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/config.ex             |  99 +++++++++++++++++++++
 lib/codeqa/diagnostics.ex        | 147 +++++++++++++++++++++++++++++++
 test/codeqa/config_test.exs      | 104 ++++++++++++++++++++++
 test/codeqa/diagnostics_test.exs |  48 ++++++++++
 4 files changed, 398 insertions(+)
 create mode 100644 lib/codeqa/config.ex
 create mode 100644 lib/codeqa/diagnostics.ex
 create mode 100644 test/codeqa/config_test.exs
 create mode 100644 test/codeqa/diagnostics_test.exs

diff --git a/lib/codeqa/config.ex b/lib/codeqa/config.ex
new file mode 100644
index 0000000..5171eac
--- /dev/null
+++ b/lib/codeqa/config.ex
@@ -0,0 +1,99 @@
+defmodule CodeQA.Config do
+  @moduledoc "Loads and caches .codeqa.yml configuration via :persistent_term."
+
+  @key {__MODULE__, :config}
+
+  @default_impact %{
+    "complexity" => 5,
+    "file_structure" => 4,
+    "function_design" => 4,
+    "code_smells" => 3,
+    "naming_conventions" => 2,
+    "error_handling" => 2,
+    "consistency" => 2,
+    "documentation" => 1,
+    "testing" => 1
+  }
+
+  defstruct ignore_paths: [],
+            impact_map: @default_impact,
+            combined_top: 2,
+            cosine_significance_threshold: 0.15,
+            near_duplicate_blocks: []
+
+  @spec load(String.t()) :: :ok
+  def load(path) do
+    if :persistent_term.get(@key, nil) == nil do
+      config = parse(path)
+      :persistent_term.put(@key, config)
+    end
+
+    :ok
+  end
+
+  @spec reset() :: :ok
+  def reset do
+    :persistent_term.erase(@key)
+    :ok
+  end
+
+  @spec ignore_paths() :: [String.t()]
+  def ignore_paths, do: fetch().ignore_paths
+
+  @spec impact_map() :: %{String.t() => pos_integer()}
+  def impact_map, do: fetch().impact_map
+
+  @spec combined_top() :: pos_integer()
+  def combined_top, do: fetch().combined_top
+
+  @spec cosine_significance_threshold() :: float()
+  def cosine_significance_threshold, do: fetch().cosine_significance_threshold
+
+  @spec near_duplicate_blocks_opts() :: keyword()
+  def near_duplicate_blocks_opts, do: fetch().near_duplicate_blocks
+
+  defp fetch do
+    :persistent_term.get(@key, %__MODULE__{})
+  end
+
+  defp parse(path) do
+    config_file = Path.join(path, ".codeqa.yml")
+
+    case File.read(config_file) do
+      {:ok, contents} ->
+        case YamlElixir.read_from_string(contents) do
+          {:ok, yaml} -> from_yaml(yaml)
+          _ -> %__MODULE__{}
+        end
+
+      {:error, _} ->
+        %__MODULE__{}
+    end
+  end
+
+  defp from_yaml(yaml) do
+    %__MODULE__{
+      ignore_paths: parse_ignore_paths(yaml),
+      impact_map: parse_impact(yaml),
+      combined_top: Map.get(yaml, "combined_top", 2),
+      cosine_significance_threshold: Map.get(yaml, "cosine_significance_threshold", 0.15),
+      near_duplicate_blocks: parse_near_duplicate_blocks(yaml)
+    }
+  end
+
+  defp parse_ignore_paths(%{"ignore_paths" => patterns}) when is_list(patterns), do: patterns
+  defp parse_ignore_paths(_), do: []
+
+  defp parse_impact(%{"impact" => overrides}) when is_map(overrides) do
+    string_overrides = Map.new(overrides, fn {k, v} -> {to_string(k), v} end)
+    Map.merge(@default_impact, string_overrides)
+  end
+
+  defp parse_impact(_), do: @default_impact
+
+  defp parse_near_duplicate_blocks(%{"near_duplicate_blocks" => %{"max_pairs_per_bucket" => n}})
+       when is_integer(n),
+       do: [max_pairs_per_bucket: n]
+
+  defp parse_near_duplicate_blocks(_), do: []
+end
diff --git a/lib/codeqa/diagnostics.ex b/lib/codeqa/diagnostics.ex
new file mode 100644
index 0000000..6b3956e
--- /dev/null
+++ b/lib/codeqa/diagnostics.ex
@@ -0,0 +1,147 @@
+defmodule CodeQA.Diagnostics do
+  @moduledoc """
+  Diagnoses a codebase by identifying likely code quality issues using
+  cosine similarity against combined metric behavior profiles.
+  """
+
+  alias CodeQA.CombinedMetrics.{SampleRunner, FileScorer}
+  alias CodeQA.HealthReport.Grader
+
+  @doc """
+  Runs diagnostics on the given path and returns results as a string.
+
+  ## Options
+
+    * `:path` - file or directory path (required)
+    * `:mode` - `:aggregate` (default) or `:per_file`
+    * `:top` - number of top issues to display (default 15)
+    * `:format` - `:plain` or `:json` (default `:plain`)
+    * `:combined_top` - worst offender files per behavior (default 2)
+  """
+  @spec run(keyword()) :: String.t()
+  def run(opts) do
+    path = opts[:path]
+    mode = opts[:mode] || :aggregate
+    top = opts[:top] || 15
+    format = opts[:format] || :plain
+
+    files = CodeQA.Engine.Collector.collect_files(path)
+    result = CodeQA.Engine.Analyzer.analyze_codebase(files, [])
+
+    case mode do
+      :per_file -> run_per_file(result, top, format)
+      _ -> run_aggregate(result, top, format)
+    end
+  end
+
+  defp run_aggregate(result, top, format) do
+    aggregate = get_in(result, ["codebase", "aggregate"])
+    issues_task = Task.async(fn -> SampleRunner.diagnose_aggregate(aggregate, top: top) end)
+    categories_task = Task.async(fn -> SampleRunner.score_aggregate(aggregate) end)
+    issues = Task.await(issues_task)
+    categories = Task.await(categories_task)
+
+    case format do
+      :json ->
+        Jason.encode!(%{issues: issues, categories: categories}, pretty: true)
+
+      _ ->
+        "## Diagnose: aggregate\n\n" <>
+          issues_table(issues) <>
+          "\n" <>
+          categories_text(categories)
+    end
+  end
+
+  defp run_per_file(result, top, format) do
+    files = Map.get(result, "files", %{})
+
+    file_diagnoses =
+      Map.new(files, fn {file_path, file_data} ->
+        metrics = Map.get(file_data, "metrics", %{})
+        file_agg = FileScorer.file_to_aggregate(metrics)
+        diagnoses = SampleRunner.diagnose_aggregate(file_agg, top: top)
+        {file_path, diagnoses}
+      end)
+
+    case format do
+      :json ->
+        files_json =
+          Enum.map(file_diagnoses, fn {file_path, diagnoses} ->
+            behaviors =
+              Enum.map(diagnoses, fn d ->
+                %{
+                  behavior: "#{d.category}.#{d.behavior}",
+                  cosine: d.cosine,
+                  score: Grader.score_cosine(d.cosine)
+                }
+              end)
+
+            %{file: file_path, behaviors: behaviors}
+          end)
+
+        Jason.encode!(%{files: files_json}, pretty: true)
+
+      _ ->
+        file_rows =
+          Enum.flat_map(file_diagnoses, fn {file_path, diagnoses} ->
+            Enum.map(diagnoses, fn %{category: cat, behavior: beh, cosine: cosine, score: score} ->
+              {file_path, "#{cat}.#{beh}", cosine, score}
+            end)
+          end)
+
+        "## Diagnose: per-file\n\n" <> per_file_table(file_rows, top)
+    end
+  end
+
+  defp issues_table(issues) do
+    rows =
+      Enum.map(issues, fn %{category: cat, behavior: beh, cosine: cosine, score: score} ->
+        cosine_str = :erlang.float_to_binary(cosine / 1.0, decimals: 2)
+        score_str = :erlang.float_to_binary(score / 1.0, decimals: 2)
+        "| #{cat}.#{beh} | #{cosine_str} | #{score_str} |"
+      end)
+
+    Enum.join(
+      ["| Behavior | Cosine | Score |", "|----------|--------|-------|"] ++ rows ++ [""],
+      "\n"
+    )
+  end
+
+  defp categories_text(categories) do
+    Enum.map_join(categories, "\n", fn %{name: name, behaviors: behaviors} ->
+      rows =
+        Enum.map(behaviors, fn %{behavior: beh, score: score} ->
+          score_str = :erlang.float_to_binary(score / 1.0, decimals: 2)
+          "| #{beh} | #{score_str} |"
+        end)
+
+      Enum.join(
+        ["### #{name}", "| Behavior | Score |", "|----------|-------|"] ++ rows ++ [""],
+        "\n"
+      )
+    end)
+  end
+
+  defp per_file_table(rows, top) do
+    data_rows =
+      rows
+      |> Enum.group_by(fn {file_path, _, _, _} -> file_path end)
+      |> Enum.flat_map(fn {_file_path, file_rows} ->
+        file_rows
+        |> Enum.sort_by(fn {_, _, cosine, _} -> cosine end)
+        |> Enum.take(top)
+      end)
+      |> Enum.map(fn {file_path, behavior_key, cosine, _score} ->
+        cosine_str = :erlang.float_to_binary(cosine / 1.0, decimals: 2)
+        cosine_score = Grader.score_cosine(cosine)
+        "| #{file_path} | #{behavior_key} | #{cosine_str} | #{cosine_score} |"
+      end)
+
+    Enum.join(
+      ["| File | Behavior | Cosine | Score |", "|------|----------|--------|-------|"] ++
+        data_rows,
+      "\n"
+    )
+  end
+end
diff --git a/test/codeqa/config_test.exs b/test/codeqa/config_test.exs
new file mode 100644
index 0000000..fced903
--- /dev/null
+++ b/test/codeqa/config_test.exs
@@ -0,0 +1,104 @@
+defmodule CodeQA.ConfigTest do
+  use ExUnit.Case, async: false
+
+  alias CodeQA.Config
+
+  setup do
+    Config.reset()
+    on_exit(&Config.reset/0)
+  end
+
+  describe "load/1 and accessors" do
+    test "returns defaults when no .codeqa.yml exists" do
+      dir = System.tmp_dir!()
+      Config.load(dir)
+
+      assert Config.ignore_paths() == []
+      assert Config.combined_top() == 2
+      assert Config.cosine_significance_threshold() == 0.15
+      assert Config.near_duplicate_blocks_opts() == []
+      assert is_map(Config.impact_map())
+      assert Map.get(Config.impact_map(), "complexity") == 5
+    end
+
+    test "loads ignore_paths from .codeqa.yml" do
+      dir =
+        tmp_dir_with_config("""
+        ignore_paths:
+          - priv/**
+          - docs/**
+        """)
+
+      Config.load(dir)
+
+      assert Config.ignore_paths() == ["priv/**", "docs/**"]
+    end
+
+    test "loads impact overrides" do
+      dir =
+        tmp_dir_with_config("""
+        impact:
+          complexity: 10
+          documentation: 3
+        """)
+
+      Config.load(dir)
+
+      assert Config.impact_map()["complexity"] == 10
+      assert Config.impact_map()["documentation"] == 3
+      assert Config.impact_map()["function_design"] == 4
+    end
+
+    test "loads combined_top" do
+      dir = tmp_dir_with_config("combined_top: 5\n")
+      Config.load(dir)
+      assert Config.combined_top() == 5
+    end
+
+    test "loads cosine_significance_threshold" do
+      dir = tmp_dir_with_config("cosine_significance_threshold: 0.25\n")
+      Config.load(dir)
+      assert Config.cosine_significance_threshold() == 0.25
+    end
+
+    test "loads near_duplicate_blocks opts" do
+      dir =
+        tmp_dir_with_config("""
+        near_duplicate_blocks:
+          max_pairs_per_bucket: 25
+        """)
+
+      Config.load(dir)
+
+      assert Config.near_duplicate_blocks_opts() == [max_pairs_per_bucket: 25]
+    end
+
+    test "caches: second load/1 call is a no-op" do
+      dir1 = tmp_dir_with_config("combined_top: 7\n")
+      dir2 = tmp_dir_with_config("combined_top: 3\n")
+
+      Config.load(dir1)
+      Config.load(dir2)
+
+      assert Config.combined_top() == 7
+    end
+
+    test "reset/0 clears cache so load/1 works again" do
+      dir1 = tmp_dir_with_config("combined_top: 7\n")
+      dir2 = tmp_dir_with_config("combined_top: 3\n")
+
+      Config.load(dir1)
+      Config.reset()
+      Config.load(dir2)
+
+      assert Config.combined_top() == 3
+    end
+  end
+
+  defp tmp_dir_with_config(yaml) do
+    dir = Path.join(System.tmp_dir!(), "codeqa_config_test_#{System.unique_integer([:positive])}")
+    File.mkdir_p!(dir)
+    File.write!(Path.join(dir, ".codeqa.yml"), yaml)
+    dir
+  end
+end
diff --git a/test/codeqa/diagnostics_test.exs b/test/codeqa/diagnostics_test.exs
new file mode 100644
index 0000000..4e5db61
--- /dev/null
+++ b/test/codeqa/diagnostics_test.exs
@@ -0,0 +1,48 @@
+defmodule CodeQA.DiagnosticsTest do
+  use ExUnit.Case, async: true
+
+  @small_path Path.expand("../../lib/codeqa/health_report/formatter", __DIR__)
+
+  describe "run/1 aggregate mode" do
+    test "plain format output structure" do
+      output = CodeQA.Diagnostics.run(path: @small_path, mode: :aggregate, top: 5, format: :plain)
+
+      assert output =~ "## Diagnose: aggregate"
+      assert output =~ "| Behavior | Cosine | Score |"
+      assert output =~ "###"
+    end
+
+    test "json format returns valid JSON with issues and categories keys" do
+      output = CodeQA.Diagnostics.run(path: @small_path, mode: :aggregate, top: 5, format: :json)
+
+      decoded = Jason.decode!(output)
+      assert Map.has_key?(decoded, "issues")
+      assert Map.has_key?(decoded, "categories")
+    end
+  end
+
+  describe "run/1 per-file mode" do
+    @tag timeout: 120_000
+    test "runs without error on a small directory" do
+      output = CodeQA.Diagnostics.run(path: @small_path, mode: :per_file, top: 3, format: :plain)
+
+      assert output =~ "## Diagnose: per-file"
+    end
+
+    @tag timeout: 120_000
+    test "output contains per-file table header" do
+      output = CodeQA.Diagnostics.run(path: @small_path, mode: :per_file, top: 3, format: :plain)
+
+      assert output =~ "| File | Behavior | Cosine | Score |"
+    end
+
+    @tag timeout: 120_000
+    test "json format returns valid JSON with files key" do
+      output = CodeQA.Diagnostics.run(path: @small_path, mode: :per_file, top: 3, format: :json)
+
+      decoded = Jason.decode!(output)
+      assert Map.has_key?(decoded, "files")
+      assert is_list(decoded["files"])
+    end
+  end
+end

From 3a465c965a23dbfecacddc10da9ff72033e552d6 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 19 Mar 2026 18:27:17 +0100
Subject: [PATCH 09/71] feat(health-report): update health report with new
 categories and grading

Rework health report categories, grader, and formatters (GitHub and plain)
to integrate with combined metrics scoring. Config module now drives
category weighting.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/health_report.ex                   |  45 +-
 lib/codeqa/health_report/categories.ex        |  89 +-
 lib/codeqa/health_report/config.ex            |  33 +-
 lib/codeqa/health_report/formatter/github.ex  | 424 +++++++-
 lib/codeqa/health_report/formatter/plain.ex   | 192 +++-
 lib/codeqa/health_report/grader.ex            | 148 ++-
 test/codeqa/health_report/categories_test.exs |  71 ++
 test/codeqa/health_report/config_test.exs     | 111 +++
 test/codeqa/health_report/formatter_test.exs  | 919 +++++++++++++++++-
 test/codeqa/health_report/grader_test.exs     | 486 +++++++++
 10 files changed, 2402 insertions(+), 116 deletions(-)
 create mode 100644 test/codeqa/health_report/categories_test.exs
 create mode 100644 test/codeqa/health_report/config_test.exs
 create mode 100644 test/codeqa/health_report/grader_test.exs

diff --git a/lib/codeqa/health_report.ex b/lib/codeqa/health_report.ex
index 982b469..4a521e2 100644
--- a/lib/codeqa/health_report.ex
+++ b/lib/codeqa/health_report.ex
@@ -2,6 +2,7 @@ defmodule CodeQA.HealthReport do
   @moduledoc "Orchestrates health report generation from analysis results."
 
   alias CodeQA.HealthReport.{Config, Grader, Formatter}
+  alias CodeQA.CombinedMetrics.{FileScorer, SampleRunner}
 
   @spec generate(map(), keyword()) :: map()
   def generate(analysis_results, opts \\ []) do
@@ -9,17 +10,23 @@ defmodule CodeQA.HealthReport do
     detail = Keyword.get(opts, :detail, :default)
     top_n = Keyword.get(opts, :top, 5)
 
-    %{categories: categories, grade_scale: grade_scale} = Config.load(config_path)
+    %{
+      categories: categories,
+      grade_scale: grade_scale,
+      impact_map: impact_map,
+      combined_top: combined_top
+    } =
+      Config.load(config_path)
+
     aggregate = get_in(analysis_results, ["codebase", "aggregate"]) || %{}
     files = Map.get(analysis_results, "files", %{})
 
-    category_grades = Grader.grade_aggregate(categories, aggregate, grade_scale)
-
-    category_grades =
-      Enum.zip(categories, category_grades)
-      |> Enum.map(fn {cat_def, graded} ->
+    threshold_grades =
+      categories
+      |> Grader.grade_aggregate(aggregate, grade_scale)
+      |> Enum.zip(categories)
+      |> Enum.map(fn {graded, cat_def} ->
         summary = build_category_summary(graded)
-
         cat_top = Map.get(cat_def, :top, top_n)
 
         worst =
@@ -29,18 +36,34 @@ defmodule CodeQA.HealthReport do
             _default -> Grader.worst_offenders(cat_def, files, cat_top, grade_scale)
           end
 
-        Map.merge(graded, %{summary: summary, worst_offenders: worst})
+        graded
+        |> Map.put(:type, :threshold)
+        |> Map.merge(%{summary: summary, worst_offenders: worst})
+      end)
+
+    worst_files_map = FileScorer.worst_files_per_behavior(files, combined_top: combined_top)
+
+    cosine_grades = Grader.grade_cosine_categories(aggregate, worst_files_map, grade_scale)
+
+    # TODO(option-c): a unified flat issues list would replace the current per-category worst offenders loop; all category results would be flattened, deduplicated by file+line, and re-ranked by a cross-category severity score before rendering.
+    all_categories =
+      (threshold_grades ++ cosine_grades)
+      |> Enum.map(fn cat ->
+        Map.put(cat, :impact, Map.get(impact_map, to_string(cat.key), 1))
       end)
 
-    {overall_score, overall_grade} = Grader.overall_score(category_grades, grade_scale)
+    {overall_score, overall_grade} = Grader.overall_score(all_categories, grade_scale, impact_map)
 
     metadata = build_metadata(analysis_results)
 
+    top_issues = SampleRunner.diagnose_aggregate(aggregate, top: 10)
+
     %{
       metadata: metadata,
       overall_score: overall_score,
       overall_grade: overall_grade,
-      categories: category_grades
+      categories: all_categories,
+      top_issues: top_issues
     }
   end
 
@@ -59,6 +82,8 @@ defmodule CodeQA.HealthReport do
     }
   end
 
+  defp build_category_summary(%{type: :cosine}), do: ""
+
   defp build_category_summary(graded) do
     low_scorers =
       graded.metric_scores
diff --git a/lib/codeqa/health_report/categories.ex b/lib/codeqa/health_report/categories.ex
index 69970be..98b2e97 100644
--- a/lib/codeqa/health_report/categories.ex
+++ b/lib/codeqa/health_report/categories.ex
@@ -36,28 +36,36 @@ defmodule CodeQA.HealthReport.Categories do
             source: "readability",
             weight: 0.4,
             good: :high,
-            thresholds: %{a: 70, b: 50, c: 35, d: 20}
+            thresholds: %{a: 70, b: 50, c: 35, d: 20},
+            fix_hint:
+              "Low readability score — simplify sentences, prefer short identifiers, avoid deeply nested expressions"
           },
           %{
             name: "fog_adapted",
             source: "readability",
             weight: 0.3,
             good: :low,
-            thresholds: %{a: 6, b: 10, c: 15, d: 22}
+            thresholds: %{a: 6, b: 10, c: 15, d: 22},
+            fix_hint:
+              "High fog index — reduce complex multi-word identifiers and long compound expressions"
           },
           %{
             name: "avg_tokens_per_line",
             source: "readability",
             weight: 0.2,
             good: :low,
-            thresholds: %{a: 6, b: 10, c: 14, d: 20}
+            thresholds: %{a: 6, b: 10, c: 14, d: 20},
+            fix_hint:
+              "Too many tokens per line — break long lines into multiple shorter statements"
           },
           %{
             name: "avg_line_length",
             source: "readability",
             weight: 0.1,
             good: :low,
-            thresholds: %{a: 40, b: 60, c: 80, d: 100}
+            thresholds: %{a: 40, b: 60, c: 80, d: 100},
+            fix_hint:
+              "Lines too long — wrap at 80–120 characters and extract intermediate variables"
           }
         ]
       },
@@ -70,28 +78,35 @@ defmodule CodeQA.HealthReport.Categories do
             source: "halstead",
             weight: 0.35,
             good: :low,
-            thresholds: %{a: 10, b: 20, c: 35, d: 50}
+            thresholds: %{a: 10, b: 20, c: 35, d: 50},
+            fix_hint:
+              "High operator/operand ratio — extract repeated sub-expressions into named variables"
           },
           %{
             name: "effort",
             source: "halstead",
             weight: 0.30,
             good: :low,
-            thresholds: %{a: 5000, b: 20000, c: 50000, d: 100_000}
+            thresholds: %{a: 5000, b: 20_000, c: 50_000, d: 100_000},
+            fix_hint:
+              "High implementation effort — simplify logic by extracting helpers and reducing branching"
           },
           %{
             name: "volume",
             source: "halstead",
             weight: 0.20,
             good: :low,
-            thresholds: %{a: 300, b: 1000, c: 3000, d: 8000}
+            thresholds: %{a: 300, b: 1000, c: 3000, d: 8000},
+            fix_hint:
+              "High token volume — extract helper functions to reduce the total operation count"
           },
           %{
             name: "estimated_bugs",
             source: "halstead",
             weight: 0.15,
             good: :low,
-            thresholds: %{a: 0.1, b: 0.5, c: 1.0, d: 3.0}
+            thresholds: %{a: 0.1, b: 0.5, c: 1.0, d: 3.0},
+            fix_hint: "High defect estimate — reduce complexity; simpler code has fewer bugs"
           }
         ]
       },
@@ -104,56 +119,69 @@ defmodule CodeQA.HealthReport.Categories do
             source: "branching",
             weight: 0.25,
             good: :low,
-            thresholds: %{a: 0.08, b: 0.17, c: 0.30, d: 0.45}
+            thresholds: %{a: 0.08, b: 0.17, c: 0.30, d: 0.45},
+            fix_hint:
+              "Too many branches per line — flatten conditionals using guard clauses or early returns"
           },
           %{
             name: "mean_depth",
             source: "indentation",
             weight: 0.2,
             good: :low,
-            thresholds: %{a: 3.5, b: 7, c: 10, d: 15}
+            thresholds: %{a: 3.5, b: 7, c: 10, d: 15},
+            fix_hint: "High average nesting — extract inner blocks into helper functions"
           },
           %{
             name: "avg_function_lines",
             source: "function_metrics",
             weight: 0.2,
             good: :low,
-            thresholds: %{a: 8, b: 15, c: 30, d: 65}
+            thresholds: %{a: 8, b: 15, c: 30, d: 65},
+            fix_hint:
+              "Functions too long on average — split into smaller single-purpose functions"
           },
           %{
             name: "max_depth",
             source: "indentation",
             weight: 0.1,
             good: :low,
-            thresholds: %{a: 8, b: 16, c: 25, d: 35}
+            thresholds: %{a: 8, b: 16, c: 25, d: 35},
+            fix_hint: "Deep nesting — restructure using early returns or extract nested logic"
           },
           %{
             name: "max_function_lines",
             source: "function_metrics",
             weight: 0.1,
             good: :low,
-            thresholds: %{a: 20, b: 50, c: 100, d: 200}
+            thresholds: %{a: 20, b: 50, c: 100, d: 200},
+            fix_hint:
+              "Largest function too long — decompose the longest function into focused helpers"
           },
           %{
             name: "variance",
             source: "indentation",
             weight: 0.1,
             good: :low,
-            thresholds: %{a: 7, b: 20, c: 40, d: 65}
+            thresholds: %{a: 7, b: 20, c: 40, d: 65},
+            fix_hint:
+              "Inconsistent indentation depth — standardize nesting by flattening or restructuring"
           },
           %{
             name: "avg_param_count",
             source: "function_metrics",
             weight: 0.03,
             good: :low,
-            thresholds: %{a: 2, b: 3, c: 5, d: 7}
+            thresholds: %{a: 2, b: 3, c: 5, d: 7},
+            fix_hint: "Too many parameters on average — group related params into a struct or map"
           },
           %{
             name: "max_param_count",
             source: "function_metrics",
             weight: 0.02,
             good: :low,
-            thresholds: %{a: 3, b: 5, c: 7, d: 10}
+            thresholds: %{a: 3, b: 5, c: 7, d: 10},
+            fix_hint:
+              "Function has too many parameters — introduce a parameter object or options map"
           }
         ]
       },
@@ -166,21 +194,27 @@ defmodule CodeQA.HealthReport.Categories do
             source: "compression",
             weight: 0.5,
             good: :low,
-            thresholds: %{a: 0.3, b: 0.5, c: 0.65, d: 0.8}
+            thresholds: %{a: 0.3, b: 0.5, c: 0.65, d: 0.8},
+            fix_hint:
+              "High redundancy — extract repeated patterns into shared helpers or abstractions"
           },
           %{
             name: "bigram_repetition_rate",
             source: "ngram",
             weight: 0.3,
             good: :low,
-            thresholds: %{a: 0.15, b: 0.30, c: 0.45, d: 0.60}
+            thresholds: %{a: 0.15, b: 0.30, c: 0.45, d: 0.60},
+            fix_hint:
+              "Repeated two-token sequences — consolidate duplicated patterns into named functions"
           },
           %{
             name: "trigram_repetition_rate",
             source: "ngram",
             weight: 0.2,
             good: :low,
-            thresholds: %{a: 0.05, b: 0.15, c: 0.30, d: 0.45}
+            thresholds: %{a: 0.05, b: 0.15, c: 0.30, d: 0.45},
+            fix_hint:
+              "Repeated three-token sequences — extract duplicated logic into reusable abstractions"
           }
         ]
       },
@@ -193,28 +227,34 @@ defmodule CodeQA.HealthReport.Categories do
             source: "casing_entropy",
             weight: 0.3,
             good: :low,
-            thresholds: %{a: 1.0, b: 1.5, c: 2.0, d: 2.3}
+            thresholds: %{a: 1.0, b: 1.5, c: 2.0, d: 2.3},
+            fix_hint:
+              "Mixed casing styles — use a single consistent casing convention throughout the file"
           },
           %{
             name: "mean",
             source: "identifier_length_variance",
             weight: 0.25,
             good: :low,
-            thresholds: %{a: 12, b: 18, c: 25, d: 35}
+            thresholds: %{a: 12, b: 18, c: 25, d: 35},
+            fix_hint: "Identifiers too long on average — prefer concise, intent-revealing names"
           },
           %{
             name: "variance",
             source: "identifier_length_variance",
             weight: 0.25,
             good: :low,
-            thresholds: %{a: 15, b: 30, c: 50, d: 80}
+            thresholds: %{a: 15, b: 30, c: 50, d: 80},
+            fix_hint: "High identifier length variance — standardize name length conventions"
           },
           %{
             name: "avg_sub_words_per_id",
             source: "readability",
             weight: 0.2,
             good: :low,
-            thresholds: %{a: 3, b: 4, c: 5, d: 7}
+            thresholds: %{a: 3, b: 4, c: 5, d: 7},
+            fix_hint:
+              "Identifiers have too many sub-words — simplify to 2–3 word names where possible"
           }
         ]
       },
@@ -227,7 +267,8 @@ defmodule CodeQA.HealthReport.Categories do
             source: "magic_number_density",
             weight: 1.0,
             good: :low,
-            thresholds: %{a: 0.02, b: 0.05, c: 0.10, d: 0.20}
+            thresholds: %{a: 0.02, b: 0.05, c: 0.10, d: 0.20},
+            fix_hint: "Too many magic numbers — replace literal values with named constants"
           }
         ]
       }
diff --git a/lib/codeqa/health_report/config.ex b/lib/codeqa/health_report/config.ex
index 15bf125..0b06a1d 100644
--- a/lib/codeqa/health_report/config.ex
+++ b/lib/codeqa/health_report/config.ex
@@ -3,9 +3,20 @@ defmodule CodeQA.HealthReport.Config do
 
   alias CodeQA.HealthReport.Categories
 
-  @spec load(String.t() | nil) :: %{categories: [map()], grade_scale: [{number(), String.t()}]}
-  def load(nil),
-    do: %{categories: Categories.defaults(), grade_scale: Categories.default_grade_scale()}
+  @spec load(String.t() | nil) :: %{
+          categories: [map()],
+          grade_scale: [{number(), String.t()}],
+          impact_map: %{String.t() => pos_integer()},
+          combined_top: pos_integer()
+        }
+  def load(nil) do
+    %{
+      categories: Categories.defaults(),
+      grade_scale: Categories.default_grade_scale(),
+      impact_map: CodeQA.Config.impact_map(),
+      combined_top: CodeQA.Config.combined_top()
+    }
+  end
 
   def load(path) do
     yaml = YamlElixir.read_from_file!(path)
@@ -30,8 +41,22 @@ defmodule CodeQA.HealthReport.Config do
       end)
 
     grade_scale = parse_grade_scale(Map.get(yaml, "grade_scale"))
+    impact_map = parse_impact(Map.get(yaml, "impact"))
+    combined_top = Map.get(yaml, "combined_top", 2)
+
+    %{
+      categories: categories,
+      grade_scale: grade_scale,
+      impact_map: impact_map,
+      combined_top: combined_top
+    }
+  end
+
+  defp parse_impact(nil), do: CodeQA.Config.impact_map()
 
-    %{categories: categories, grade_scale: grade_scale}
+  defp parse_impact(overrides) when is_map(overrides) do
+    string_overrides = Map.new(overrides, fn {k, v} -> {to_string(k), v} end)
+    Map.merge(CodeQA.Config.impact_map(), string_overrides)
   end
 
   defp parse_grade_scale(nil), do: Categories.default_grade_scale()
diff --git a/lib/codeqa/health_report/formatter/github.ex b/lib/codeqa/health_report/formatter/github.ex
index 72bb9ee..90c7c18 100644
--- a/lib/codeqa/health_report/formatter/github.ex
+++ b/lib/codeqa/health_report/formatter/github.ex
@@ -8,18 +8,65 @@ defmodule CodeQA.HealthReport.Formatter.Github do
   @spec render(map(), atom(), keyword()) :: String.t()
   def render(report, detail, opts \\ []) do
     chart? = Keyword.get(opts, :chart, true)
+    display_categories = merge_cosine_categories(report.categories)
 
     [
       header(report),
-      if(chart?, do: mermaid_chart(report.categories), else: []),
-      progress_bars(report.categories),
-      category_sections(report.categories, detail),
+      cosine_legend(),
+      if(chart?, do: mermaid_chart(display_categories), else: []),
+      progress_bars(display_categories),
+      top_issues_section(Map.get(report, :top_issues, []), detail),
+      category_sections(display_categories, detail),
       footer()
     ]
     |> List.flatten()
     |> Enum.join("\n")
   end
 
+  defp merge_cosine_categories(categories) do
+    {cosine, threshold} = Enum.split_with(categories, &(&1.type == :cosine))
+
+    case cosine do
+      [] ->
+        threshold
+
+      _ ->
+        total_impact = Enum.sum(Enum.map(cosine, & &1.impact))
+
+        combined_score =
+          round(Enum.sum(Enum.map(cosine, &(&1.score * &1.impact))) / max(total_impact, 1))
+
+        combined = %{
+          type: :cosine_group,
+          key: "combined_metrics",
+          name: "Combined Metrics",
+          score: combined_score,
+          grade: grade_letter_from_score(combined_score),
+          categories: cosine
+        }
+
+        threshold ++ [combined]
+    end
+  end
+
+  defp grade_letter_from_score(score) do
+    cond do
+      score >= 97 -> "A+"
+      score >= 93 -> "A"
+      score >= 90 -> "A-"
+      score >= 87 -> "B+"
+      score >= 83 -> "B"
+      score >= 80 -> "B-"
+      score >= 77 -> "C+"
+      score >= 73 -> "C"
+      score >= 70 -> "C-"
+      score >= 67 -> "D+"
+      score >= 63 -> "D"
+      score >= 60 -> "D-"
+      true -> "F"
+    end
+  end
+
   defp header(report) do
     emoji = grade_emoji(report.overall_grade)
 
@@ -31,9 +78,16 @@ defmodule CodeQA.HealthReport.Formatter.Github do
     ]
   end
 
+  defp cosine_legend do
+    [
+      "> *Combined metric scores use cosine similarity: +1 = metric profile perfectly matches healthy pattern for this behavior, 0 = no signal, −1 = anti-pattern detected. Mapped to 0–100 using breakpoints (approx: ≥0.5→A, ≥0.2→B, ≥0.0→C, ≥−0.3→D, <−0.3→F); actual letter grades use the full 15-step scale.*",
+      ""
+    ]
+  end
+
   defp mermaid_chart(categories) do
-    names = Enum.map(categories, fn c -> ~s("#{c.name}") end) |> Enum.join(", ")
-    scores = Enum.map(categories, fn c -> to_string(c.score) end) |> Enum.join(", ")
+    names = Enum.map_join(categories, ", ", fn c -> ~s("#{c.name}") end)
+    scores = Enum.map_join(categories, ", ", fn c -> to_string(c.score) end)
 
     [
       "```mermaid",
@@ -77,32 +131,232 @@ defmodule CodeQA.HealthReport.Formatter.Github do
   defp category_sections(_categories, :summary), do: []
 
   defp category_sections(categories, detail) do
-    Enum.flat_map(categories, fn cat ->
-      emoji = grade_emoji(cat.grade)
-      summary_line = "#{emoji} #{cat.name} — #{cat.grade} (#{cat.score}/100)"
-
-      inner =
-        section_content(cat, detail)
-        |> List.flatten()
-        |> Enum.join("\n")
-
-      [
-        "<details>",
-        "<summary><strong>#{summary_line}</strong></summary>",
-        "",
-        inner,
-        "",
-        "</details>",
-        ""
-      ]
+    Enum.flat_map(categories, &render_category(&1, detail))
+  end
+
+  defp render_category(%{type: :cosine_group} = group, detail) do
+    emoji = grade_emoji(group.grade)
+    summary_line = "#{emoji} #{group.name} — #{group.grade} (#{group.score}/100)"
+
+    inner =
+      cosine_group_content(group, detail)
+      |> List.flatten()
+      |> Enum.join("\n")
+
+    [
+      "<details>",
+      "<summary><strong>#{summary_line}</strong></summary>",
+      "",
+      inner,
+      "",
+      "</details>",
+      ""
+    ]
+  end
+
+  defp render_category(%{type: :cosine} = cat, detail) do
+    emoji = grade_emoji(cat.grade)
+    summary_line = "#{emoji} #{cat.name} — #{cat.grade} (#{cat.score}/100)"
+
+    inner =
+      cosine_section_content(cat, detail)
+      |> List.flatten()
+      |> Enum.join("\n")
+
+    [
+      "<details>",
+      "<summary><strong>#{summary_line}</strong></summary>",
+      "",
+      inner,
+      "",
+      "</details>",
+      ""
+    ]
+  end
+
+  defp render_category(cat, detail) do
+    emoji = grade_emoji(cat.grade)
+    summary_line = "#{emoji} #{cat.name} — #{cat.grade} (#{cat.score}/100)"
+
+    inner =
+      section_content(cat, detail)
+      |> List.flatten()
+      |> Enum.join("\n")
+
+    [
+      "<details>",
+      "<summary><strong>#{summary_line}</strong></summary>",
+      "",
+      inner,
+      "",
+      "</details>",
+      ""
+    ]
+  end
+
+  defp cosine_group_content(group, detail) do
+    rows =
+      Enum.map(group.categories, fn cat ->
+        emoji = grade_emoji(cat.grade)
+        "| #{cat.name} | #{cat.score} | #{emoji} #{cat.grade} |"
+      end)
+
+    summary_table = [
+      "| Category | Score | Grade |",
+      "|----------|-------|-------|"
+      | rows
+    ]
+
+    sub_sections =
+      Enum.flat_map(group.categories, fn cat ->
+        emoji = grade_emoji(cat.grade)
+
+        inner =
+          cosine_section_content(cat, detail)
+          |> List.flatten()
+          |> Enum.join("\n")
+
+        [
+          "<details>",
+          "<summary><strong>#{emoji} #{cat.name} — #{cat.grade} (#{cat.score}/100)</strong></summary>",
+          "",
+          inner,
+          "",
+          "</details>",
+          ""
+        ]
+      end)
+
+    summary_table ++ [""] ++ sub_sections
+  end
+
+  defp cosine_section_content(cat, detail) do
+    n = length(cat.behaviors)
+
+    behaviors_rows =
+      Enum.map(cat.behaviors, fn b ->
+        "| #{b.behavior} | #{format_num(b.cosine)} | #{b.score} | #{b.grade} |"
+      end)
+
+    behaviors_table = [
+      "> Cosine similarity scores for #{n} behaviors.",
+      "",
+      "| Behavior | Cosine | Score | Grade |",
+      "|----------|--------|-------|-------|"
+      | behaviors_rows
+    ]
+
+    offenders_sections = cosine_worst_offenders(cat, detail)
+
+    behaviors_table ++ [""] ++ offenders_sections
+  end
+
+  defp cosine_worst_offenders(_cat, :summary), do: []
+
+  defp cosine_worst_offenders(cat, _detail) do
+    Enum.flat_map(cat.behaviors, fn b ->
+      offenders = Map.get(b, :worst_offenders, [])
+
+      if offenders == [] do
+        []
+      else
+        fix_hint = cosine_fix_hint(cat.key, b.behavior)
+
+        cards =
+          Enum.flat_map(offenders, fn f ->
+            score_str = format_cosine_score(f.cosine)
+            summary = "<code>#{f.file}</code> — #{score_str}"
+
+            why_line = format_why_line(Map.get(f, :top_metrics, []))
+            where_line = format_where_line(Map.get(f, :top_nodes, []))
+            fix_line = if fix_hint, do: "**Fix:** #{fix_hint}", else: nil
+
+            body_lines =
+              [why_line, where_line, fix_line]
+              |> Enum.reject(&is_nil/1)
+
+            if body_lines == [] do
+              [
+                "<details>",
+                "<summary>#{summary}</summary>",
+                "",
+                "</details>",
+                ""
+              ]
+            else
+              [
+                "<details>",
+                "<summary>#{summary}</summary>",
+                ""
+              ] ++
+                body_lines ++
+                [
+                  "",
+                  "</details>",
+                  ""
+                ]
+            end
+          end)
+
+        ["**Worst Offenders: #{b.behavior}**", "" | cards]
+      end
     end)
   end
 
+  defp cosine_fix_hint(category_key, behavior) do
+    yaml_path = "priv/combined_metrics/#{category_key}.yml"
+
+    case YamlElixir.read_from_file(yaml_path) do
+      {:ok, data} ->
+        get_in(data, [behavior, "_fix_hint"])
+
+      {:error, reason} ->
+        require Logger
+        Logger.debug("cosine_fix_hint: could not read #{yaml_path}: #{inspect(reason)}")
+        nil
+    end
+  end
+
+  defp format_cosine_score(cosine) when cosine < 0,
+    do: "−#{format_num(abs(cosine))}"
+
+  defp format_cosine_score(cosine), do: format_num(cosine)
+
+  defp format_why_line([]), do: nil
+
+  defp format_why_line(top_metrics) do
+    parts =
+      Enum.map(top_metrics, fn %{metric: metric, contribution: contribution} ->
+        sign = if contribution < 0, do: "↓", else: "↑"
+        abs_val = abs(contribution)
+
+        value_str =
+          if contribution < 0,
+            do: "−#{format_num(abs_val)}",
+            else: "+#{format_num(abs_val)}"
+
+        "#{sign} #{metric} (#{value_str})"
+      end)
+
+    "**Why:** #{Enum.join(parts, ", ")}"
+  end
+
+  defp format_where_line([]), do: nil
+
+  defp format_where_line(top_nodes) do
+    parts =
+      Enum.map(top_nodes, fn node ->
+        line = node["start_line"] || "?"
+        type = node["type"] || "unknown"
+        "line #{line} (#{type})"
+      end)
+
+    "**Where:** #{Enum.join(parts, ", ")}"
+  end
+
   defp section_content(cat, _detail) do
     metric_summary =
-      cat.metric_scores
-      |> Enum.map(fn m -> "#{m.name}=#{format_num(m.value)}" end)
-      |> Enum.join(", ")
+      Enum.map_join(cat.metric_scores, ", ", fn m -> "#{m.name}=#{format_num(m.value)}" end)
 
     metrics_table =
       if cat.metric_scores != [] do
@@ -128,6 +382,7 @@ defmodule CodeQA.HealthReport.Formatter.Github do
   end
 
   defp worst_offenders(cat) do
+    # TODO(option-c): the flat issues list alternative would replace the per-category worst offenders loop with a single table sorted by severity: each row is one specific issue at one location (file:line — behavior — fix), not one file with multiple behaviors collapsed into it.
     offenders = Map.get(cat, :worst_offenders, [])
 
     if offenders == [] do
@@ -135,30 +390,100 @@ defmodule CodeQA.HealthReport.Formatter.Github do
     else
       averages = Map.new(cat.metric_scores, &{&1.name, &1.value})
 
-      rows =
-        Enum.map(offenders, fn f ->
-          issues =
-            f.metric_scores
-            |> Enum.map(fn m ->
-              avg = Map.get(averages, m.name)
-              avg_str = if avg, do: " (avg: #{format_num(avg)})", else: ""
-              "#{direction(m.good)}#{m.name}=#{format_num(m.value)}#{avg_str}"
-            end)
-            |> Enum.join("<br>")
-
-          "| #{format_path(f.path)}<br>#{format_lines(f[:lines])} lines · #{format_size(f[:bytes])} | #{f.grade} (#{f.score}) | #{issues} |"
+      cards =
+        Enum.flat_map(offenders, fn f ->
+          size_str = "#{format_lines(f[:lines])} lines · #{format_size(f[:bytes])}"
+          summary = "<code>#{f.path}</code> — #{size_str} — #{f.grade} (#{f.score})"
+
+          why_str = format_threshold_why(f.metric_scores, averages)
+          why_line = if why_str != "", do: "**Why:** #{why_str}", else: nil
+
+          where_line = format_where_line(Map.get(f, :top_nodes, []))
+
+          fix_hint = threshold_fix_hint(f.metric_scores)
+          fix_line = if fix_hint, do: "**Fix:** #{fix_hint}", else: nil
+
+          body_lines =
+            [why_line, where_line, fix_line]
+            |> Enum.reject(&is_nil/1)
+
+          if body_lines == [] do
+            [
+              "<details>",
+              "<summary>#{summary}</summary>",
+              "",
+              "</details>",
+              ""
+            ]
+          else
+            [
+              "<details>",
+              "<summary>#{summary}</summary>",
+              ""
+            ] ++
+              body_lines ++
+              [
+                "",
+                "</details>",
+                ""
+              ]
+          end
         end)
 
-      [
-        "**Worst Offenders**",
-        "",
-        "| File | Grade | Issues |",
-        "|------|-------|--------|"
-        | rows
-      ]
+      ["**Worst Offenders**", "" | cards]
     end
   end
 
+  defp format_threshold_why(metric_scores, averages) do
+    Enum.map_join(metric_scores, " · ", fn m ->
+      avg = Map.get(averages, m.name)
+      avg_str = if avg, do: " (avg: #{format_num(avg)})", else: ""
+      "#{direction(m.good)}#{m.name}=#{format_num(m.value)}#{avg_str}"
+    end)
+  end
+
+  defp threshold_fix_hint(metric_scores) do
+    worst = Enum.min_by(metric_scores, & &1.score, fn -> nil end)
+
+    if worst do
+      categories = CodeQA.HealthReport.Categories.defaults()
+      all_metrics = Enum.flat_map(categories, & &1.metrics)
+
+      found =
+        Enum.find(all_metrics, fn m ->
+          m.name == worst.name and m.source == worst.source
+        end)
+
+      if found, do: Map.get(found, :fix_hint), else: nil
+    end
+  end
+
+  defp top_issues_section([], _detail), do: []
+  defp top_issues_section(_issues, :summary), do: []
+
+  defp top_issues_section(issues, _detail) do
+    rows =
+      issues
+      |> Enum.map(fn i ->
+        "| `#{i.category}.#{i.behavior}` | #{format_num(i.cosine)} | #{format_num(i.score)} |"
+      end)
+      |> Enum.join("\n")
+
+    table = "| Behavior | Cosine | Score |\n|----------|--------|-------|\n#{rows}"
+
+    [
+      "<details>",
+      "<summary><strong>🔍 Top Likely Issues (cosine similarity)</strong></summary>",
+      "",
+      "> Most negative cosine = file's metric profile best matches this anti-pattern.",
+      "",
+      table,
+      "",
+      "</details>",
+      ""
+    ]
+  end
+
   defp footer do
     ["<!-- Sticky Pull Request Commentcodeqa-health-report -->", ""]
   end
@@ -179,15 +504,6 @@ defmodule CodeQA.HealthReport.Formatter.Github do
 
   defp extract_project_name(_), do: "unknown"
 
-  defp format_path(path) when byte_size(path) < 80, do: "`#{path}`"
-
-  defp format_path(path) do
-    case String.split(path, "/") do
-      [file] -> "`#{file}`"
-      parts -> Enum.join(Enum.drop(parts, -1), "/") <> "/<br>`#{List.last(parts)}`"
-    end
-  end
-
   defp direction(:high), do: "↑ "
   defp direction(_), do: "↓ "
 
diff --git a/lib/codeqa/health_report/formatter/plain.ex b/lib/codeqa/health_report/formatter/plain.ex
index 8471aef..f0e0a8a 100644
--- a/lib/codeqa/health_report/formatter/plain.ex
+++ b/lib/codeqa/health_report/formatter/plain.ex
@@ -5,7 +5,9 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
   def render(report, detail) do
     [
       header(report),
+      cosine_legend(),
       overall_table(report),
+      top_issues_section(Map.get(report, :top_issues, []), detail),
       category_sections(report.categories, detail)
     ]
     |> List.flatten()
@@ -23,16 +25,24 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
     ]
   end
 
+  defp cosine_legend do
+    [
+      "> *Combined metric scores use cosine similarity: +1 = metric profile perfectly matches healthy pattern for this behavior, 0 = no signal, −1 = anti-pattern detected. Mapped to 0–100 using breakpoints (approx: ≥0.5→A, ≥0.2→B, ≥0.0→C, ≥−0.3→D, <−0.3→F); actual letter grades use the full 15-step scale.*",
+      ""
+    ]
+  end
+
   defp overall_table(report) do
     rows =
       Enum.map(report.categories, fn cat ->
         summary = Map.get(cat, :summary, "")
-        "| #{cat.name} | #{cat.grade} | #{cat.score} | #{summary} |"
+        impact = Map.get(cat, :impact, "")
+        "| #{cat.name} | #{cat.grade} | #{cat.score} | #{impact} | #{summary} |"
       end)
 
     [
-      "| Category | Grade | Score | Summary |",
-      "|----------|-------|-------|---------|"
+      "| Category | Grade | Score | Impact | Summary |",
+      "|----------|-------|-------|--------|---------|"
       | rows
     ] ++ [""]
   end
@@ -41,15 +51,130 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
 
   defp category_sections(categories, detail) do
     Enum.flat_map(categories, fn cat ->
-      section_header(cat) ++ metric_detail(cat) ++ worst_offenders_section(cat, detail)
+      render_category(cat, detail)
     end)
   end
 
+  defp render_category(%{type: :cosine} = cat, detail) do
+    cosine_section_header(cat) ++
+      cosine_behaviors_table(cat) ++ cosine_worst_offenders(cat, detail)
+  end
+
+  defp render_category(cat, detail) do
+    section_header(cat) ++ metric_detail(cat) ++ worst_offenders_section(cat, detail)
+  end
+
+  defp cosine_section_header(cat) do
+    n = length(cat.behaviors)
+
+    [
+      "## #{cat.name} — #{cat.grade}",
+      "",
+      "> Cosine similarity scores for #{n} behaviors.",
+      ""
+    ]
+  end
+
+  defp cosine_behaviors_table(cat) do
+    rows =
+      Enum.map(cat.behaviors, fn b ->
+        "| #{b.behavior} | #{format_num(b.cosine)} | #{b.score} | #{b.grade} |"
+      end)
+
+    [
+      "| Behavior | Cosine | Score | Grade |",
+      "|----------|--------|-------|-------|"
+      | rows
+    ] ++ [""]
+  end
+
+  defp cosine_worst_offenders(_cat, :summary), do: []
+
+  defp cosine_worst_offenders(cat, _detail) do
+    Enum.flat_map(cat.behaviors, fn b ->
+      offenders = Map.get(b, :worst_offenders, [])
+
+      if offenders == [] do
+        []
+      else
+        fix_hint = cosine_fix_hint(cat.key, b.behavior)
+
+        rows =
+          Enum.map(offenders, fn f ->
+            details = format_cosine_details(f, fix_hint)
+            "| #{format_path(f.file)} | #{format_num(f.cosine)} | #{details} |"
+          end)
+
+        [
+          "### Worst Offenders: #{b.behavior}",
+          "",
+          "| File | Cosine | Details |",
+          "|------|--------|---------|"
+          | rows
+        ] ++ [""]
+      end
+    end)
+  end
+
+  defp format_cosine_details(f, fix_hint) do
+    why_part = format_why_part(Map.get(f, :top_metrics, []))
+    where_part = format_where_part(Map.get(f, :top_nodes, []))
+    fix_part = if fix_hint, do: "**Fix:** #{fix_hint}", else: nil
+
+    [why_part, where_part, fix_part]
+    |> Enum.reject(&is_nil/1)
+    |> Enum.join("<br>")
+  end
+
+  defp format_why_part([]), do: nil
+
+  defp format_why_part(top_metrics) do
+    parts =
+      Enum.map(top_metrics, fn %{metric: metric, contribution: contribution} ->
+        sign = if contribution < 0, do: "↓", else: "↑"
+        abs_val = abs(contribution)
+
+        value_str =
+          if contribution < 0,
+            do: "−#{format_num(abs_val)}",
+            else: "+#{format_num(abs_val)}"
+
+        "#{sign} #{metric} (#{value_str})"
+      end)
+
+    "**Why:** #{Enum.join(parts, ", ")}"
+  end
+
+  defp format_where_part([]), do: nil
+
+  defp format_where_part(top_nodes) do
+    parts =
+      Enum.map(top_nodes, fn node ->
+        line = node["start_line"] || "?"
+        type = node["type"] || "unknown"
+        "line #{line} (#{type})"
+      end)
+
+    "**Where:** #{Enum.join(parts, ", ")}"
+  end
+
+  defp cosine_fix_hint(category_key, behavior) do
+    yaml_path = "priv/combined_metrics/#{category_key}.yml"
+
+    case YamlElixir.read_from_file(yaml_path) do
+      {:ok, data} ->
+        get_in(data, [behavior, "_fix_hint"])
+
+      {:error, reason} ->
+        require Logger
+        Logger.debug("cosine_fix_hint: could not read #{yaml_path}: #{inspect(reason)}")
+        nil
+    end
+  end
+
   defp section_header(cat) do
     metric_summary =
-      cat.metric_scores
-      |> Enum.map(fn m -> "#{m.name}=#{format_num(m.value)}" end)
-      |> Enum.join(", ")
+      Enum.map_join(cat.metric_scores, ", ", fn m -> "#{m.name}=#{format_num(m.value)}" end)
 
     [
       "## #{cat.name} — #{cat.grade}",
@@ -88,14 +213,23 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
 
       rows =
         Enum.map(offenders, fn f ->
-          issues =
-            f.metric_scores
-            |> Enum.map(fn m ->
+          metric_issues =
+            Enum.map_join(f.metric_scores, "<br>", fn m ->
               avg = Map.get(averages, m.name)
               avg_str = if avg, do: " (avg: #{format_num(avg)})", else: ""
               "#{direction(m.good)}#{m.name}=#{format_num(m.value)}#{avg_str}"
             end)
-            |> Enum.join("<br>")
+
+          where_part = format_where_part(Map.get(f, :top_nodes, []))
+          fix_hint = threshold_fix_hint(f.metric_scores)
+          fix_part = if fix_hint, do: "**Fix:** #{fix_hint}", else: nil
+
+          extra =
+            [where_part, fix_part]
+            |> Enum.reject(&is_nil/1)
+            |> Enum.map_join("", &"<br>#{&1}")
+
+          issues = metric_issues <> extra
 
           "| #{format_path(f.path)}<br>#{format_lines(f[:lines])} lines · #{format_size(f[:bytes])} | #{f.grade} | #{issues} |"
         end)
@@ -110,6 +244,22 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
     end
   end
 
+  defp threshold_fix_hint(metric_scores) do
+    worst = Enum.min_by(metric_scores, & &1.score, fn -> nil end)
+
+    if worst do
+      categories = CodeQA.HealthReport.Categories.defaults()
+      all_metrics = Enum.flat_map(categories, & &1.metrics)
+
+      found =
+        Enum.find(all_metrics, fn m ->
+          m.name == worst.name and m.source == worst.source
+        end)
+
+      if found, do: Map.get(found, :fix_hint), else: nil
+    end
+  end
+
   defp format_path(path) when byte_size(path) < 80, do: "`#{path}`"
 
   defp format_path(path) do
@@ -138,4 +288,24 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
   end
 
   defp format_date(_), do: "unknown"
+
+  defp top_issues_section([], _detail), do: []
+  defp top_issues_section(_issues, :summary), do: []
+
+  defp top_issues_section(issues, _detail) do
+    rows =
+      Enum.map(issues, fn i ->
+        "| #{i.category}.#{i.behavior} | #{format_num(i.cosine)} | #{format_num(i.score)} |"
+      end)
+
+    [
+      "## Top Likely Issues",
+      "",
+      "> Ranked by cosine similarity — most negative means the file's metric profile best matches this anti-pattern.",
+      "",
+      "| Behavior | Cosine | Score |",
+      "|----------|--------|-------|"
+      | rows
+    ] ++ [""]
+  end
 end
diff --git a/lib/codeqa/health_report/grader.ex b/lib/codeqa/health_report/grader.ex
index 864cad3..94259d6 100644
--- a/lib/codeqa/health_report/grader.ex
+++ b/lib/codeqa/health_report/grader.ex
@@ -1,6 +1,8 @@
 defmodule CodeQA.HealthReport.Grader do
   @moduledoc "Scores metrics and assigns letter grades."
 
+  alias CodeQA.CombinedMetrics.SampleRunner
+
   @doc """
   Score a single metric value (0-100) based on thresholds and direction.
 
@@ -16,6 +18,32 @@ defmodule CodeQA.HealthReport.Grader do
     value |> score_low_is_good(t) |> clamp(0, 100)
   end
 
+  @doc """
+  Maps cosine similarity [-1, +1] to a score [0, 100] with linear interpolation
+  within each band. Result is clamped to [0, 100] and rounded to an integer.
+
+  | Cosine range  | Score range |
+  |---------------|-------------|
+  | [0.5, 1.0]    | [90, 100]   |
+  | [0.2, 0.5)    | [70, 90)    |
+  | [0.0, 0.2)    | [50, 70)    |
+  | [-0.3, 0.0)   | [30, 50)    |
+  | [-1.0, -0.3)  | [0, 30)     |
+  """
+  @spec score_cosine(float()) :: integer()
+  def score_cosine(cosine) do
+    cosine
+    |> cosine_to_score()
+    |> clamp(0, 100)
+    |> round()
+  end
+
+  defp cosine_to_score(c) when c >= 0.5, do: interpolate_between(c, 0.5, 90, 1.0, 100)
+  defp cosine_to_score(c) when c >= 0.2, do: interpolate_between(c, 0.2, 70, 0.5, 90)
+  defp cosine_to_score(c) when c >= 0.0, do: interpolate_between(c, 0.0, 50, 0.2, 70)
+  defp cosine_to_score(c) when c >= -0.3, do: interpolate_between(c, -0.3, 30, 0.0, 50)
+  defp cosine_to_score(c), do: interpolate_between(c, -1.0, 0, -0.3, 30)
+
   # Lower values are better: below A = 100, A = 90, A-B = 70-90, etc.
   defp score_low_is_good(val, t) do
     cond do
@@ -161,23 +189,103 @@ defmodule CodeQA.HealthReport.Grader do
     Enum.map(categories, &grade_category(&1, file_like, scale))
   end
 
-  @doc "Compute overall score as average of category scores."
-  @spec overall_score(list(), [{number(), String.t()}]) :: {integer(), String.t()}
+  @doc """
+  Compute overall score as a weighted average of category scores.
+
+  Each category's weight is looked up from `impact_map` by converting
+  `category.key` (atom) to string. Defaults to `1` if the key is absent.
+
+  Backward compatible: calling with two arguments (empty `impact_map`) produces
+  the same arithmetic mean as the old `/2` signature.
+  """
+  @spec overall_score(
+          categories :: [map()],
+          grade_scale :: [{number(), String.t()}],
+          impact_map :: %{String.t() => pos_integer()}
+        ) :: {integer(), String.t()}
   def overall_score(
         category_grades,
-        scale \\ CodeQA.HealthReport.Categories.default_grade_scale()
+        scale \\ CodeQA.HealthReport.Categories.default_grade_scale(),
+        impact_map \\ %{}
       ) do
     if category_grades == [] do
       {0, "F"}
     else
-      avg =
-        Enum.reduce(category_grades, 0, fn g, acc -> acc + g.score end)
-        |> div(length(category_grades))
+      {weighted_sum, total_impact} =
+        Enum.reduce(category_grades, {0, 0}, fn g, {ws, ti} ->
+          impact = Map.get(impact_map, to_string(g.key), 1)
+          {ws + g.score * impact, ti + impact}
+        end)
 
+      avg = round(weighted_sum / total_impact)
       {avg, grade_letter(avg, scale)}
     end
   end
 
+  @doc """
+  Grade codebase aggregate metrics using cosine similarity.
+
+  Calls `SampleRunner.diagnose_aggregate/2` to get all behaviors with cosine
+  values, groups them by category, and returns a graded category list suitable
+  for use with `overall_score/3`.
+
+  Categories with zero behaviors are skipped.
+  """
+  @spec grade_cosine_categories(
+          aggregate :: map(),
+          worst_files :: %{String.t() => [map()]},
+          grade_scale :: [{number(), String.t()}]
+        ) :: [map()]
+  def grade_cosine_categories(
+        aggregate,
+        worst_files,
+        scale \\ CodeQA.HealthReport.Categories.default_grade_scale()
+      ) do
+    threshold = CodeQA.Config.cosine_significance_threshold()
+
+    aggregate
+    |> SampleRunner.diagnose_aggregate(top: 99_999)
+    |> Enum.group_by(& &1.category)
+    |> Enum.map(fn {category, behaviors} ->
+      behavior_entries =
+        behaviors
+        |> Enum.reject(fn b -> abs(b.cosine) < threshold end)
+        |> Enum.map(fn b ->
+          cosine_score = score_cosine(b.cosine)
+
+          %{
+            behavior: b.behavior,
+            cosine: b.cosine,
+            score: cosine_score,
+            grade: grade_letter(cosine_score, scale),
+            worst_offenders: Map.get(worst_files, "#{category}.#{b.behavior}", [])
+          }
+        end)
+
+      category_score =
+        if behavior_entries == [] do
+          50
+        else
+          round(Enum.sum(Enum.map(behavior_entries, & &1.score)) / length(behavior_entries))
+        end
+
+      %{
+        type: :cosine,
+        key: category,
+        name: humanize_category(category),
+        score: category_score,
+        grade: grade_letter(category_score, scale),
+        behaviors: behavior_entries
+      }
+    end)
+  end
+
+  defp humanize_category(slug) do
+    slug
+    |> String.split("_")
+    |> Enum.map_join(" ", &String.capitalize/1)
+  end
+
   @doc """
   Find worst offender files for a category. Returns top N files sorted by worst score.
   `all_file_metrics` is `%{"path" => %{"metrics" => %{...}}}` from analysis results.
@@ -189,21 +297,47 @@ defmodule CodeQA.HealthReport.Grader do
         top_n,
         scale \\ CodeQA.HealthReport.Categories.default_grade_scale()
       ) do
+    # TODO(option-c): threshold metric scores are file-level aggregates; line-level attribution would require each AST node to carry its own per-metric values so that the node with the highest contribution to the bad metric score could be identified and reported directly.
     all_file_metrics
     |> Enum.map(fn {path, file_data} ->
       metrics = Map.get(file_data, "metrics", %{})
       graded = grade_category(category, metrics, scale)
+
       %{
         path: path,
         score: graded.score,
         grade: graded.grade,
         metric_scores: graded.metric_scores,
         lines: file_data["lines"],
-        bytes: file_data["bytes"]
+        bytes: file_data["bytes"],
+        top_nodes: top_3_nodes(Map.get(file_data, "nodes"))
       }
     end)
     |> Enum.filter(fn f -> f.metric_scores != [] end)
     |> Enum.sort_by(& &1.score, :asc)
     |> Enum.take(top_n)
   end
+
+  @doc """
+  Returns the top 3 nodes by refactoring potential impact, ranked by cosine_delta sum.
+
+  Only considers top-level nodes; children are not traversed. Returns an empty list
+  if input is nil, empty, or nodes lack refactoring_potentials data.
+  """
+  @spec top_3_nodes(list() | nil) :: list()
+  def top_3_nodes(nil), do: []
+  def top_3_nodes([]), do: []
+
+  def top_3_nodes(nodes) when is_list(nodes) do
+    nodes
+    |> Enum.sort_by(&node_impact_score/1, :desc)
+    |> Enum.take(3)
+  end
+
+  defp node_impact_score(%{"refactoring_potentials" => potentials})
+       when is_list(potentials) and potentials != [] do
+    Enum.sum(Enum.map(potentials, & &1["cosine_delta"]))
+  end
+
+  defp node_impact_score(_), do: 0.0
 end
diff --git a/test/codeqa/health_report/categories_test.exs b/test/codeqa/health_report/categories_test.exs
new file mode 100644
index 0000000..0912d46
--- /dev/null
+++ b/test/codeqa/health_report/categories_test.exs
@@ -0,0 +1,71 @@
+defmodule CodeQA.HealthReport.CategoriesTest do
+  use ExUnit.Case
+
+  alias CodeQA.HealthReport.Categories
+
+  describe "defaults/0" do
+    test "all metrics have fix_hint field" do
+      categories = Categories.defaults()
+
+      metrics = Enum.flat_map(categories, & &1.metrics)
+
+      Enum.each(metrics, fn metric ->
+        assert Map.has_key?(metric, :fix_hint),
+               "Metric #{metric.name} missing :fix_hint field"
+
+        assert is_binary(metric.fix_hint),
+               "Metric #{metric.name} :fix_hint must be a string"
+
+        assert String.length(metric.fix_hint) > 0,
+               "Metric #{metric.name} :fix_hint cannot be empty"
+      end)
+    end
+
+    test "all categories have expected keys" do
+      categories = Categories.defaults()
+
+      Enum.each(categories, fn category ->
+        assert Map.has_key?(category, :key)
+        assert Map.has_key?(category, :name)
+        assert Map.has_key?(category, :metrics)
+      end)
+    end
+
+    test "all metrics have required threshold keys" do
+      categories = Categories.defaults()
+
+      metrics = Enum.flat_map(categories, & &1.metrics)
+
+      Enum.each(metrics, fn metric ->
+        assert Map.has_key?(metric, :name)
+        assert Map.has_key?(metric, :source)
+        assert Map.has_key?(metric, :weight)
+        assert Map.has_key?(metric, :good)
+        assert Map.has_key?(metric, :thresholds)
+        assert Map.has_key?(metric, :fix_hint)
+      end)
+    end
+
+    test "fix_hint is accessible via Map.get" do
+      categories = Categories.defaults()
+
+      metrics = Enum.flat_map(categories, & &1.metrics)
+
+      Enum.each(metrics, fn metric ->
+        hint = Map.get(metric, :fix_hint)
+        assert is_binary(hint)
+        assert String.length(hint) > 0
+      end)
+    end
+
+    test "has exactly 24 metrics across 6 categories" do
+      categories = Categories.defaults()
+
+      assert length(categories) == 6
+
+      metrics = Enum.flat_map(categories, & &1.metrics)
+
+      assert length(metrics) == 24
+    end
+  end
+end
diff --git a/test/codeqa/health_report/config_test.exs b/test/codeqa/health_report/config_test.exs
new file mode 100644
index 0000000..da4d6a1
--- /dev/null
+++ b/test/codeqa/health_report/config_test.exs
@@ -0,0 +1,111 @@
+defmodule CodeQA.HealthReport.ConfigTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.HealthReport.Config
+
+  @default_impact %{
+    "complexity" => 5,
+    "file_structure" => 4,
+    "function_design" => 4,
+    "code_smells" => 3,
+    "naming_conventions" => 2,
+    "error_handling" => 2,
+    "consistency" => 2,
+    "documentation" => 1,
+    "testing" => 1
+  }
+
+  describe "load/1 with nil" do
+    test "returns default impact map" do
+      result = Config.load(nil)
+      assert result.impact_map == @default_impact
+    end
+
+    test "returns combined_top of 2" do
+      result = Config.load(nil)
+      assert result.combined_top == 2
+    end
+
+    test "returns categories and grade_scale" do
+      result = Config.load(nil)
+      assert is_list(result.categories)
+      assert is_list(result.grade_scale)
+    end
+  end
+
+  describe "load/1 with YAML path" do
+    defp write_temp_yaml(content) do
+      path = Path.join(System.tmp_dir!(), "test_config_#{System.unique_integer()}.yml")
+      File.write!(path, content)
+      on_exit(fn -> File.rm(path) end)
+      path
+    end
+
+    test "user impact values override defaults, defaults fill gaps" do
+      path =
+        write_temp_yaml("""
+        impact:
+          complexity: 10
+          testing: 9
+        """)
+
+      result = Config.load(path)
+
+      assert result.impact_map["complexity"] == 10
+      assert result.impact_map["testing"] == 9
+      # Default values for keys not overridden
+      assert result.impact_map["file_structure"] == 4
+      assert result.impact_map["function_design"] == 4
+      assert result.impact_map["code_smells"] == 3
+      assert result.impact_map["naming_conventions"] == 2
+      assert result.impact_map["error_handling"] == 2
+      assert result.impact_map["consistency"] == 2
+      assert result.impact_map["documentation"] == 1
+    end
+
+    test "reads combined_top from YAML" do
+      path =
+        write_temp_yaml("""
+        combined_top: 5
+        """)
+
+      result = Config.load(path)
+      assert result.combined_top == 5
+    end
+
+    test "defaults to combined_top: 2 when absent from YAML" do
+      path =
+        write_temp_yaml("""
+        categories: {}
+        """)
+
+      result = Config.load(path)
+      assert result.combined_top == 2
+    end
+
+    test "defaults to full default impact map when impact absent from YAML" do
+      path =
+        write_temp_yaml("""
+        categories: {}
+        """)
+
+      result = Config.load(path)
+      assert result.impact_map == @default_impact
+    end
+
+    test "returns categories and grade_scale alongside impact fields" do
+      path =
+        write_temp_yaml("""
+        impact:
+          complexity: 5
+        combined_top: 3
+        """)
+
+      result = Config.load(path)
+      assert is_list(result.categories)
+      assert is_list(result.grade_scale)
+      assert is_map(result.impact_map)
+      assert is_integer(result.combined_top)
+    end
+  end
+end
diff --git a/test/codeqa/health_report/formatter_test.exs b/test/codeqa/health_report/formatter_test.exs
index 1fddec3..52c6e30 100644
--- a/test/codeqa/health_report/formatter_test.exs
+++ b/test/codeqa/health_report/formatter_test.exs
@@ -9,24 +9,49 @@ defmodule CodeQA.HealthReport.FormatterTest do
     overall_grade: "B+",
     categories: [
       %{
+        type: :threshold,
         name: "Readability",
         key: :readability,
         score: 100,
         grade: "A",
+        impact: 3,
         summary: "Excellent",
         metric_scores: [
-          %{name: "flesch_adapted", source: "readability", weight: 0.4, good: :high, value: 102.5, score: 100}
+          %{
+            name: "flesch_adapted",
+            source: "readability",
+            weight: 0.4,
+            good: :high,
+            value: 102.5,
+            score: 100
+          }
         ],
         worst_offenders: [
-          %{path: "lib/foo.ex", score: 75, grade: "B+", lines: 120, bytes: 3840,
-            metric_scores: [%{name: "flesch_adapted", source: "readability", good: :high, value: 65.0, score: 75}]}
+          %{
+            path: "lib/foo.ex",
+            score: 75,
+            grade: "B+",
+            lines: 120,
+            bytes: 3840,
+            metric_scores: [
+              %{
+                name: "flesch_adapted",
+                source: "readability",
+                good: :high,
+                value: 65.0,
+                score: 75
+              }
+            ]
+          }
         ]
       },
       %{
+        type: :threshold,
         name: "Complexity",
         key: :complexity,
         score: 35,
         grade: "D",
+        impact: 5,
         summary: "Critical — requires attention",
         metric_scores: [
           %{name: "difficulty", source: "halstead", weight: 0.35, value: 24.01, score: 65}
@@ -36,6 +61,98 @@ defmodule CodeQA.HealthReport.FormatterTest do
     ]
   }
 
+  @cosine_category %{
+    type: :cosine,
+    key: "function_design",
+    name: "Function Design",
+    score: 64,
+    grade: "C",
+    impact: 1,
+    behaviors: [
+      %{
+        behavior: "no_boolean_parameter",
+        cosine: 0.12,
+        score: 56,
+        grade: "C",
+        worst_offenders: [
+          %{file: "lib/foo/bar.ex", cosine: -0.71}
+        ]
+      },
+      %{
+        behavior: "single_responsibility",
+        cosine: 0.45,
+        score: 78,
+        grade: "B+",
+        worst_offenders: []
+      }
+    ]
+  }
+
+  @enriched_cosine_category %{
+    type: :cosine,
+    key: "function_design",
+    name: "Function Design",
+    score: 64,
+    grade: "C",
+    impact: 1,
+    behaviors: [
+      %{
+        behavior: "no_boolean_parameter",
+        cosine: -0.65,
+        score: 42,
+        grade: "D+",
+        worst_offenders: [
+          %{
+            file: "lib/codeqa/formatter.ex",
+            cosine: -0.65,
+            top_metrics: [
+              %{metric: "branching.mean_depth", contribution: -4.10},
+              %{metric: "halstead.effort", contribution: -3.22}
+            ],
+            top_nodes: [
+              %{"start_line" => 89, "type" => "block"},
+              %{"start_line" => 134, "type" => "block"}
+            ]
+          }
+        ]
+      }
+    ]
+  }
+
+  @enriched_threshold_category %{
+    type: :threshold,
+    name: "Complexity",
+    key: :complexity,
+    score: 32,
+    grade: "F",
+    impact: 5,
+    summary: "Critical",
+    metric_scores: [
+      %{name: "difficulty", source: "halstead", weight: 0.35, good: :low, value: 39.0, score: 32}
+    ],
+    worst_offenders: [
+      %{
+        path: "lib/foo.ex",
+        score: 32,
+        grade: "F",
+        lines: 491,
+        bytes: 15_872,
+        metric_scores: [
+          %{name: "difficulty", source: "halstead", good: :low, value: 99.0, score: 0}
+        ],
+        top_nodes: [
+          %{"start_line" => 201, "type" => "block"},
+          %{"start_line" => 312, "type" => "block"}
+        ]
+      }
+    ]
+  }
+
+  @report_with_cosine %{
+    @sample_report
+    | categories: @sample_report.categories ++ [@cosine_category]
+  }
+
   describe "format_markdown/3 with :plain format" do
     test "produces header with # Code Health Report" do
       result = Formatter.format_markdown(@sample_report, :default, :plain)
@@ -53,10 +170,17 @@ defmodule CodeQA.HealthReport.FormatterTest do
       assert result =~ "## Overall: B+"
     end
 
-    test "includes category table" do
+    test "includes cosine legend" do
+      result = Formatter.format_markdown(@sample_report, :default, :plain)
+      assert result =~ "cosine similarity"
+      assert result =~ "anti-pattern detected"
+    end
+
+    test "includes category table with Impact column" do
       result = Formatter.format_markdown(@sample_report, :default, :plain)
-      assert result =~ "| Readability | A | 100 | Excellent |"
-      assert result =~ "| Complexity | D | 35 |"
+      assert result =~ "| Category | Grade | Score | Impact | Summary |"
+      assert result =~ "| Readability | A | 100 | 3 | Excellent |"
+      assert result =~ "| Complexity | D | 35 | 5 |"
     end
 
     test "includes worst offenders section" do
@@ -76,6 +200,359 @@ defmodule CodeQA.HealthReport.FormatterTest do
     end
   end
 
+  describe "format_markdown/3 plain with cosine category" do
+    test "renders cosine category header" do
+      result = Formatter.format_markdown(@report_with_cosine, :default, :plain)
+      assert result =~ "## Function Design — C"
+    end
+
+    test "renders cosine behavior table" do
+      result = Formatter.format_markdown(@report_with_cosine, :default, :plain)
+      assert result =~ "| Behavior | Cosine | Score | Grade |"
+      assert result =~ "| no_boolean_parameter | 0.12 | 56 | C |"
+      assert result =~ "| single_responsibility | 0.45 | 78 | B+ |"
+    end
+
+    test "renders cosine worst offenders per behavior" do
+      result = Formatter.format_markdown(@report_with_cosine, :default, :plain)
+      assert result =~ "### Worst Offenders: no_boolean_parameter"
+      assert result =~ "| File | Cosine | Details |"
+      assert result =~ "| `lib/foo/bar.ex` | -0.71 |"
+    end
+
+    test "omits behaviors with no worst offenders" do
+      result = Formatter.format_markdown(@report_with_cosine, :default, :plain)
+      refute result =~ "### Worst Offenders: single_responsibility"
+    end
+
+    test "cosine category impact shown in overall table" do
+      result = Formatter.format_markdown(@report_with_cosine, :default, :plain)
+      assert result =~ "| Function Design | C | 64 | 1 |"
+    end
+
+    test "summary detail omits cosine worst offenders" do
+      result = Formatter.format_markdown(@report_with_cosine, :summary, :plain)
+      refute result =~ "### Worst Offenders: no_boolean_parameter"
+    end
+  end
+
+  describe "plain formatter: cosine offenders with enriched data" do
+    defp report_with_enriched_cosine_plain do
+      %{
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
+        overall_score: 64,
+        overall_grade: "C",
+        categories: [@enriched_cosine_category]
+      }
+    end
+
+    test "cosine offenders table has 3 columns (File | Cosine | Details)" do
+      result = Formatter.format_markdown(report_with_enriched_cosine_plain(), :default, :plain)
+      assert result =~ "| File | Cosine | Details |"
+      assert result =~ "|------|--------|---------|"
+    end
+
+    test "Details cell contains Why with direction indicators" do
+      result = Formatter.format_markdown(report_with_enriched_cosine_plain(), :default, :plain)
+      assert result =~ "**Why:** ↓ branching.mean_depth (−4.10), ↓ halstead.effort (−3.22)"
+    end
+
+    test "Details cell omits Why when top_metrics empty" do
+      category = %{
+        @enriched_cosine_category
+        | behaviors: [
+            %{
+              behavior: "no_boolean_parameter",
+              cosine: -0.5,
+              score: 42,
+              grade: "D+",
+              worst_offenders: [
+                %{
+                  file: "lib/foo.ex",
+                  cosine: -0.5,
+                  top_metrics: [],
+                  top_nodes: [%{"start_line" => 10, "type" => "block"}]
+                }
+              ]
+            }
+          ]
+      }
+
+      report = %{
+        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        overall_score: 42,
+        overall_grade: "D+",
+        categories: [category]
+      }
+
+      result = Formatter.format_markdown(report, :default, :plain)
+      refute result =~ "**Why:**"
+      assert result =~ "**Where:**"
+    end
+
+    test "Details cell contains Where" do
+      result = Formatter.format_markdown(report_with_enriched_cosine_plain(), :default, :plain)
+      assert result =~ "**Where:** line 89 (block), line 134 (block)"
+    end
+
+    test "Details cell omits Where when top_nodes empty" do
+      category = %{
+        @enriched_cosine_category
+        | behaviors: [
+            %{
+              behavior: "no_boolean_parameter",
+              cosine: -0.5,
+              score: 42,
+              grade: "D+",
+              worst_offenders: [
+                %{
+                  file: "lib/foo.ex",
+                  cosine: -0.5,
+                  top_metrics: [%{metric: "branching.mean_depth", contribution: -4.10}],
+                  top_nodes: []
+                }
+              ]
+            }
+          ]
+      }
+
+      report = %{
+        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        overall_score: 42,
+        overall_grade: "D+",
+        categories: [category]
+      }
+
+      result = Formatter.format_markdown(report, :default, :plain)
+      refute result =~ "**Where:**"
+      assert result =~ "**Why:**"
+    end
+
+    test "Details cell omits Where when top_nodes key absent" do
+      category = %{
+        @enriched_cosine_category
+        | behaviors: [
+            %{
+              behavior: "no_boolean_parameter",
+              cosine: -0.5,
+              score: 42,
+              grade: "D+",
+              worst_offenders: [%{file: "lib/foo.ex", cosine: -0.5}]
+            }
+          ]
+      }
+
+      report = %{
+        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        overall_score: 42,
+        overall_grade: "D+",
+        categories: [category]
+      }
+
+      result = Formatter.format_markdown(report, :default, :plain)
+      refute result =~ "**Where:**"
+    end
+
+    test "Fix in Details when hint present" do
+      category = %{
+        type: :cosine,
+        key: "variable_naming",
+        name: "Variable Naming",
+        score: 50,
+        grade: "C",
+        impact: 1,
+        behaviors: [
+          %{
+            behavior: "name_is_generic",
+            cosine: -0.5,
+            score: 42,
+            grade: "D+",
+            worst_offenders: [
+              %{
+                file: "lib/foo.ex",
+                cosine: -0.5,
+                top_metrics: [%{metric: "some.metric", contribution: -1.0}],
+                top_nodes: []
+              }
+            ]
+          }
+        ]
+      }
+
+      report = %{
+        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        overall_score: 42,
+        overall_grade: "D+",
+        categories: [category]
+      }
+
+      result = Formatter.format_markdown(report, :default, :plain)
+      assert result =~ "**Fix:**"
+    end
+
+    test "Fix omitted when hint absent" do
+      category = %{
+        type: :cosine,
+        key: "nonexistent",
+        name: "Nonexistent",
+        score: 50,
+        grade: "C",
+        impact: 1,
+        behaviors: [
+          %{
+            behavior: "nonexistent_behavior",
+            cosine: -0.5,
+            score: 42,
+            grade: "D+",
+            worst_offenders: [
+              %{
+                file: "lib/foo.ex",
+                cosine: -0.5,
+                top_metrics: [%{metric: "some.metric", contribution: -1.0}],
+                top_nodes: []
+              }
+            ]
+          }
+        ]
+      }
+
+      report = %{
+        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        overall_score: 42,
+        overall_grade: "D+",
+        categories: [category]
+      }
+
+      result = Formatter.format_markdown(report, :default, :plain)
+      refute result =~ "**Fix:**"
+    end
+  end
+
+  describe "plain formatter: threshold offenders with enriched data" do
+    defp report_with_enriched_threshold_plain do
+      %{
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
+        overall_score: 32,
+        overall_grade: "F",
+        categories: [@enriched_threshold_category]
+      }
+    end
+
+    test "threshold Issues cell contains Where when top_nodes present" do
+      result =
+        Formatter.format_markdown(report_with_enriched_threshold_plain(), :default, :plain)
+
+      assert result =~ "**Where:** line 201 (block), line 312 (block)"
+    end
+
+    test "threshold Issues cell omits Where when top_nodes empty" do
+      category = %{
+        @enriched_threshold_category
+        | worst_offenders: [
+            %{
+              path: "lib/bar.ex",
+              score: 32,
+              grade: "F",
+              lines: 100,
+              bytes: 3000,
+              metric_scores: [
+                %{name: "difficulty", source: "halstead", good: :low, value: 99.0, score: 0}
+              ],
+              top_nodes: []
+            }
+          ]
+      }
+
+      report = %{
+        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        overall_score: 32,
+        overall_grade: "F",
+        categories: [category]
+      }
+
+      result = Formatter.format_markdown(report, :default, :plain)
+      refute result =~ "**Where:**"
+    end
+
+    test "threshold Issues cell omits Where when top_nodes key absent" do
+      category = %{
+        @enriched_threshold_category
+        | worst_offenders: [
+            %{
+              path: "lib/bar.ex",
+              score: 32,
+              grade: "F",
+              lines: 100,
+              bytes: 3000,
+              metric_scores: [
+                %{name: "difficulty", source: "halstead", good: :low, value: 99.0, score: 0}
+              ]
+            }
+          ]
+      }
+
+      report = %{
+        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        overall_score: 32,
+        overall_grade: "F",
+        categories: [category]
+      }
+
+      result = Formatter.format_markdown(report, :default, :plain)
+      refute result =~ "**Where:**"
+    end
+
+    test "Fix in threshold Issues when hint present" do
+      result =
+        Formatter.format_markdown(report_with_enriched_threshold_plain(), :default, :plain)
+
+      assert result =~ "**Fix:** High operator/operand ratio"
+    end
+
+    test "Fix omitted from threshold Issues when hint absent" do
+      category = %{
+        @enriched_threshold_category
+        | worst_offenders: [
+            %{
+              path: "lib/bar.ex",
+              score: 10,
+              grade: "F",
+              lines: 200,
+              bytes: 6000,
+              metric_scores: [
+                %{
+                  name: "nonexistent_metric",
+                  source: "nonexistent_source",
+                  good: :low,
+                  value: 99.0,
+                  score: 10
+                }
+              ],
+              top_nodes: []
+            }
+          ]
+      }
+
+      report = %{
+        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        overall_score: 10,
+        overall_grade: "F",
+        categories: [category]
+      }
+
+      result = Formatter.format_markdown(report, :default, :plain)
+      refute result =~ "**Fix:**"
+    end
+  end
+
   describe "format_markdown/3 defaults to :plain" do
     test "two-arity call matches plain output" do
       plain = Formatter.format_markdown(@sample_report, :default, :plain)
@@ -91,6 +568,12 @@ defmodule CodeQA.HealthReport.FormatterTest do
       assert result =~ "(79/100)"
     end
 
+    test "includes cosine legend" do
+      result = Formatter.format_markdown(@sample_report, :default, :github)
+      assert result =~ "cosine similarity"
+      assert result =~ "anti-pattern detected"
+    end
+
     test "includes mermaid chart" do
       result = Formatter.format_markdown(@sample_report, :default, :github)
       assert result =~ "```mermaid"
@@ -130,6 +613,38 @@ defmodule CodeQA.HealthReport.FormatterTest do
     end
   end
 
+  describe "format_markdown/3 github with cosine category" do
+    test "wraps cosine category in details/summary block" do
+      result = Formatter.format_markdown(@report_with_cosine, :default, :github)
+      assert result =~ "<summary><strong>🟠 Function Design — C (64/100)</strong></summary>"
+    end
+
+    test "renders cosine behaviors table inside details" do
+      result = Formatter.format_markdown(@report_with_cosine, :default, :github)
+      assert result =~ "| Behavior | Cosine | Score | Grade |"
+      assert result =~ "| no_boolean_parameter | 0.12 | 56 | C |"
+    end
+
+    test "renders cosine worst offenders per behavior as details cards" do
+      result = Formatter.format_markdown(@report_with_cosine, :default, :github)
+      assert result =~ "**Worst Offenders: no_boolean_parameter**"
+      assert result =~ "<code>lib/foo/bar.ex</code>"
+      assert result =~ "−0.71"
+      refute result =~ "| File | Cosine |"
+      refute result =~ "| `lib/foo/bar.ex` |"
+    end
+
+    test "omits behaviors with no worst offenders" do
+      result = Formatter.format_markdown(@report_with_cosine, :default, :github)
+      refute result =~ "**Worst Offenders: single_responsibility**"
+    end
+
+    test "summary detail omits cosine worst offenders" do
+      result = Formatter.format_markdown(@report_with_cosine, :summary, :github)
+      refute result =~ "**Worst Offenders: no_boolean_parameter**"
+    end
+  end
+
   describe "format_markdown/4 with :github format and chart: false" do
     test "omits mermaid chart when chart option is false" do
       result = Formatter.format_markdown(@sample_report, :default, :github, chart: false)
@@ -137,4 +652,396 @@ defmodule CodeQA.HealthReport.FormatterTest do
       assert result =~ "████"
     end
   end
+
+  describe "github cosine worst offender <details> cards" do
+    defp report_with_enriched_cosine do
+      %{
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
+        overall_score: 64,
+        overall_grade: "C",
+        categories: [@enriched_cosine_category]
+      }
+    end
+
+    test "renders <details> card for each worst offender" do
+      result = Formatter.format_markdown(report_with_enriched_cosine(), :default, :github)
+      assert result =~ "<details>"
+      assert result =~ "<code>lib/codeqa/formatter.ex</code>"
+    end
+
+    test "renders score with Unicode minus for negative cosine in card summary" do
+      result = Formatter.format_markdown(report_with_enriched_cosine(), :default, :github)
+      assert result =~ "<summary><code>lib/codeqa/formatter.ex</code> — −0.65</summary>"
+    end
+
+    test "renders Why row with ↓ for negative contributions" do
+      result = Formatter.format_markdown(report_with_enriched_cosine(), :default, :github)
+      assert result =~ "**Why:** ↓ branching.mean_depth (−4.10), ↓ halstead.effort (−3.22)"
+    end
+
+    test "renders Why row with ↑ for positive contributions" do
+      category = %{
+        @enriched_cosine_category
+        | behaviors: [
+            %{
+              behavior: "no_boolean_parameter",
+              cosine: 0.5,
+              score: 90,
+              grade: "A",
+              worst_offenders: [
+                %{
+                  file: "lib/foo.ex",
+                  cosine: 0.5,
+                  top_metrics: [%{metric: "halstead.effort", contribution: 2.5}],
+                  top_nodes: []
+                }
+              ]
+            }
+          ]
+      }
+
+      report = %{
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
+        overall_score: 90,
+        overall_grade: "A",
+        categories: [category]
+      }
+
+      result = Formatter.format_markdown(report, :default, :github)
+      assert result =~ "↑ halstead.effort (+2.50)"
+    end
+
+    test "omits Why row when top_metrics is empty" do
+      category = %{
+        @enriched_cosine_category
+        | behaviors: [
+            %{
+              behavior: "no_boolean_parameter",
+              cosine: -0.5,
+              score: 42,
+              grade: "D+",
+              worst_offenders: [
+                %{
+                  file: "lib/foo.ex",
+                  cosine: -0.5,
+                  top_metrics: [],
+                  top_nodes: [%{"start_line" => 10, "type" => "block"}]
+                }
+              ]
+            }
+          ]
+      }
+
+      report = %{
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
+        overall_score: 42,
+        overall_grade: "D+",
+        categories: [category]
+      }
+
+      result = Formatter.format_markdown(report, :default, :github)
+      refute result =~ "**Why:**"
+      assert result =~ "**Where:**"
+    end
+
+    test "renders Where row as 'line N (type)'" do
+      result = Formatter.format_markdown(report_with_enriched_cosine(), :default, :github)
+      assert result =~ "**Where:** line 89 (block), line 134 (block)"
+    end
+
+    test "omits Where row when top_nodes is empty" do
+      category = %{
+        @enriched_cosine_category
+        | behaviors: [
+            %{
+              behavior: "no_boolean_parameter",
+              cosine: -0.5,
+              score: 42,
+              grade: "D+",
+              worst_offenders: [
+                %{
+                  file: "lib/foo.ex",
+                  cosine: -0.5,
+                  top_metrics: [%{metric: "branching.mean_depth", contribution: -4.10}],
+                  top_nodes: []
+                }
+              ]
+            }
+          ]
+      }
+
+      report = %{
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
+        overall_score: 42,
+        overall_grade: "D+",
+        categories: [category]
+      }
+
+      result = Formatter.format_markdown(report, :default, :github)
+      refute result =~ "**Where:**"
+      assert result =~ "**Why:**"
+    end
+
+    test "omits Where row when top_nodes key is absent" do
+      category = %{
+        @enriched_cosine_category
+        | behaviors: [
+            %{
+              behavior: "no_boolean_parameter",
+              cosine: -0.5,
+              score: 42,
+              grade: "D+",
+              worst_offenders: [
+                %{file: "lib/foo.ex", cosine: -0.5}
+              ]
+            }
+          ]
+      }
+
+      report = %{
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
+        overall_score: 42,
+        overall_grade: "D+",
+        categories: [category]
+      }
+
+      result = Formatter.format_markdown(report, :default, :github)
+      refute result =~ "**Where:**"
+    end
+
+    test "does not render old table format" do
+      result = Formatter.format_markdown(report_with_enriched_cosine(), :default, :github)
+      refute result =~ "| File | Cosine |"
+    end
+
+    test "omits Fix row when cosine fix_hint is nil" do
+      category = %{
+        type: :cosine,
+        key: "nonexistent",
+        name: "Nonexistent",
+        score: 50,
+        grade: "C",
+        impact: 1,
+        behaviors: [
+          %{
+            behavior: "nonexistent_behavior",
+            cosine: -0.5,
+            score: 42,
+            grade: "D+",
+            worst_offenders: [
+              %{
+                file: "lib/foo.ex",
+                cosine: -0.5,
+                top_metrics: [%{metric: "some.metric", contribution: -1.0}],
+                top_nodes: []
+              }
+            ]
+          }
+        ]
+      }
+
+      report = %{
+        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        overall_score: 42,
+        overall_grade: "D+",
+        categories: [category]
+      }
+
+      result = Formatter.format_markdown(report, :default, :github)
+      refute result =~ "**Fix:**"
+    end
+
+    test "renders Fix row for cosine when hint is present" do
+      category = %{
+        type: :cosine,
+        key: "variable_naming",
+        name: "Variable Naming",
+        score: 50,
+        grade: "C",
+        impact: 1,
+        behaviors: [
+          %{
+            behavior: "name_is_generic",
+            cosine: -0.5,
+            score: 42,
+            grade: "D+",
+            worst_offenders: [
+              %{
+                file: "lib/foo.ex",
+                cosine: -0.5,
+                top_metrics: [%{metric: "some.metric", contribution: -1.0}],
+                top_nodes: []
+              }
+            ]
+          }
+        ]
+      }
+
+      report = %{
+        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        overall_score: 42,
+        overall_grade: "D+",
+        categories: [category]
+      }
+
+      result = Formatter.format_markdown(report, :default, :github)
+      assert result =~ "**Fix:**"
+    end
+
+    test "snapshot: full enriched cosine offender card" do
+      result = Formatter.format_markdown(report_with_enriched_cosine(), :default, :github)
+      assert result =~ "<details>"
+      assert result =~ "<summary>"
+      assert result =~ "**Why:**"
+      assert result =~ "↓"
+      assert result =~ "**Where:**"
+      assert result =~ "line"
+      assert result =~ "("
+      assert result =~ "</details>"
+    end
+  end
+
+  describe "github threshold worst offender <details> cards" do
+    defp report_with_enriched_threshold do
+      %{
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
+        overall_score: 32,
+        overall_grade: "F",
+        categories: [@enriched_threshold_category]
+      }
+    end
+
+    test "renders <details> card for each threshold worst offender" do
+      result = Formatter.format_markdown(report_with_enriched_threshold(), :default, :github)
+      assert result =~ "<details>"
+      assert result =~ "<code>lib/foo.ex</code>"
+    end
+
+    test "summary line includes lines, size and grade" do
+      result = Formatter.format_markdown(report_with_enriched_threshold(), :default, :github)
+      assert result =~ "491 lines"
+      assert result =~ "F (32)"
+    end
+
+    test "renders Why row with · separator for threshold metrics" do
+      result = Formatter.format_markdown(report_with_enriched_threshold(), :default, :github)
+      assert result =~ "**Why:** ↓ difficulty=99.00 (avg: 39.00)"
+    end
+
+    test "renders Where row for threshold worst offenders" do
+      result = Formatter.format_markdown(report_with_enriched_threshold(), :default, :github)
+      assert result =~ "**Where:** line 201 (block), line 312 (block)"
+    end
+
+    test "renders Fix row from Categories.defaults when hint available" do
+      result = Formatter.format_markdown(report_with_enriched_threshold(), :default, :github)
+      assert result =~ "**Fix:** High operator/operand ratio"
+    end
+
+    test "omits Where row when top_nodes is empty" do
+      category = %{
+        @enriched_threshold_category
+        | worst_offenders: [
+            %{
+              path: "lib/bar.ex",
+              score: 32,
+              grade: "F",
+              lines: 100,
+              bytes: 3000,
+              metric_scores: [
+                %{name: "difficulty", source: "halstead", good: :low, value: 99.0, score: 0}
+              ],
+              top_nodes: []
+            }
+          ]
+      }
+
+      report = %{
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
+        overall_score: 32,
+        overall_grade: "F",
+        categories: [category]
+      }
+
+      result = Formatter.format_markdown(report, :default, :github)
+      refute result =~ "**Where:**"
+    end
+
+    test "does not render old table format" do
+      result = Formatter.format_markdown(report_with_enriched_threshold(), :default, :github)
+      refute result =~ "| File | Grade | Issues |"
+    end
+
+    test "omits Fix row when threshold fix_hint is nil" do
+      category = %{
+        @enriched_threshold_category
+        | worst_offenders: [
+            %{
+              path: "lib/bar.ex",
+              score: 10,
+              grade: "F",
+              lines: 200,
+              bytes: 6000,
+              metric_scores: [
+                %{
+                  name: "nonexistent_metric",
+                  source: "nonexistent_source",
+                  good: :low,
+                  value: 99.0,
+                  score: 10
+                }
+              ],
+              top_nodes: []
+            }
+          ]
+      }
+
+      report = %{
+        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        overall_score: 10,
+        overall_grade: "F",
+        categories: [category]
+      }
+
+      result = Formatter.format_markdown(report, :default, :github)
+      refute result =~ "**Fix:**"
+    end
+
+    test "snapshot: full enriched threshold offender card" do
+      result = Formatter.format_markdown(report_with_enriched_threshold(), :default, :github)
+      assert result =~ "<details>"
+      assert result =~ "<summary>"
+      assert result =~ "**Why:**"
+      assert result =~ "**Where:**"
+      assert result =~ "</details>"
+    end
+  end
 end
diff --git a/test/codeqa/health_report/grader_test.exs b/test/codeqa/health_report/grader_test.exs
new file mode 100644
index 0000000..21de94e
--- /dev/null
+++ b/test/codeqa/health_report/grader_test.exs
@@ -0,0 +1,486 @@
+defmodule CodeQA.HealthReport.GraderTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.HealthReport.Grader
+
+  @default_scale CodeQA.HealthReport.Categories.default_grade_scale()
+
+  # -----------------------------------------------------------------------
+  # score_cosine/1
+  # -----------------------------------------------------------------------
+
+  describe "score_cosine/1" do
+    test "cosine 1.0 maps to 100" do
+      assert Grader.score_cosine(1.0) == 100
+    end
+
+    test "cosine -1.0 maps to 0" do
+      assert Grader.score_cosine(-1.0) == 0
+    end
+
+    test "cosine 0.5 (lower bound of top band) maps to 90" do
+      assert Grader.score_cosine(0.5) == 90
+    end
+
+    test "cosine 0.2 (lower bound of second band) maps to 70" do
+      assert Grader.score_cosine(0.2) == 70
+    end
+
+    test "cosine 0.0 (lower bound of third band) maps to 50" do
+      assert Grader.score_cosine(0.0) == 50
+    end
+
+    test "cosine -0.3 (lower bound of fourth band) maps to 30" do
+      assert Grader.score_cosine(-0.3) == 30
+    end
+
+    test "interpolation in [0.0, 0.2) band: cosine 0.12 → 62" do
+      # ratio = 0.12 / 0.2 = 0.6, score = 50 + 0.6 * 20 = 62
+      assert Grader.score_cosine(0.12) == 62
+    end
+
+    test "interpolation in [0.2, 0.5) band: cosine 0.35 → 80" do
+      # ratio = (0.35 - 0.2) / (0.5 - 0.2) = 0.15/0.3 = 0.5, score = 70 + 0.5 * 20 = 80
+      assert Grader.score_cosine(0.35) == 80
+    end
+
+    test "interpolation in [0.5, 1.0] band: cosine 0.75 → 95" do
+      # ratio = (0.75 - 0.5) / (1.0 - 0.5) = 0.25/0.5 = 0.5, score = 90 + 0.5 * 10 = 95
+      assert Grader.score_cosine(0.75) == 95
+    end
+
+    test "interpolation in [-0.3, 0.0) band: cosine -0.15 → 40" do
+      # ratio = (-0.15 - (-0.3)) / (0.0 - (-0.3)) = 0.15/0.3 = 0.5, score = 30 + 0.5 * 20 = 40
+      assert Grader.score_cosine(-0.15) == 40
+    end
+
+    test "interpolation in [-1.0, -0.3) band: cosine -0.65 → 15" do
+      # ratio = (-0.65 - (-1.0)) / (-0.3 - (-1.0)) = 0.35/0.7 = 0.5, score = 0 + 0.5 * 30 = 15
+      assert Grader.score_cosine(-0.65) == 15
+    end
+
+    test "result is always an integer" do
+      for cosine <- [-1.0, -0.5, 0.0, 0.1, 0.3, 0.6, 1.0] do
+        assert is_integer(Grader.score_cosine(cosine)),
+               "expected integer for cosine #{cosine}"
+      end
+    end
+
+    test "result is always in [0, 100]" do
+      for cosine <- [-1.0, -0.9, -0.3, 0.0, 0.2, 0.5, 1.0] do
+        score = Grader.score_cosine(cosine)
+
+        assert score >= 0 and score <= 100,
+               "score #{score} out of range for cosine #{cosine}"
+      end
+    end
+  end
+
+  # -----------------------------------------------------------------------
+  # overall_score/3 (including backward compat as /2)
+  # -----------------------------------------------------------------------
+
+  describe "overall_score/3" do
+    test "empty list returns {0, 'F'}" do
+      assert Grader.overall_score([], @default_scale) == {0, "F"}
+    end
+
+    test "equal weights produces arithmetic mean (backward compat /2)" do
+      categories = [
+        %{key: :readability, score: 80},
+        %{key: :complexity, score: 60}
+      ]
+
+      {score, _grade} = Grader.overall_score(categories, @default_scale)
+      assert score == 70
+    end
+
+    test "weighted average applies impact_map correctly" do
+      categories = [
+        %{key: :readability, score: 80},
+        %{key: :complexity, score: 60}
+      ]
+
+      # readability has weight 3, complexity has weight 1
+      # weighted = (80*3 + 60*1) / 4 = 300/4 = 75
+      impact_map = %{"readability" => 3, "complexity" => 1}
+      {score, _grade} = Grader.overall_score(categories, @default_scale, impact_map)
+      assert score == 75
+    end
+
+    test "missing keys in impact_map default to 1" do
+      categories = [
+        %{key: :readability, score: 80},
+        %{key: :complexity, score: 60}
+      ]
+
+      # Only readability in map with weight 2; complexity defaults to 1
+      # weighted = (80*2 + 60*1) / 3 = 220/3 ≈ 73
+      impact_map = %{"readability" => 2}
+      {score, _grade} = Grader.overall_score(categories, @default_scale, impact_map)
+      assert score == round((80 * 2 + 60 * 1) / 3)
+    end
+
+    test "backward compat: /2 call with empty impact_map equals arithmetic mean" do
+      categories = [
+        %{key: :readability, score: 90},
+        %{key: :complexity, score: 70},
+        %{key: :naming, score: 50}
+      ]
+
+      {score_two, grade_two} = Grader.overall_score(categories, @default_scale)
+      {score_three, grade_three} = Grader.overall_score(categories, @default_scale, %{})
+
+      assert score_two == score_three
+      assert grade_two == grade_three
+    end
+
+    test "returns grade string along with integer score" do
+      categories = [%{key: :readability, score: 100}]
+      {score, grade} = Grader.overall_score(categories, @default_scale)
+      assert is_integer(score)
+      assert is_binary(grade)
+    end
+
+    test "atom keys are converted to strings for impact_map lookup" do
+      categories = [
+        %{key: :function_design, score: 60},
+        %{key: :variable_naming, score: 40}
+      ]
+
+      impact_map = %{"function_design" => 2, "variable_naming" => 1}
+      {score, _} = Grader.overall_score(categories, @default_scale, impact_map)
+      # (60*2 + 40*1) / 3 = 160/3 ≈ 53
+      assert score == round((60 * 2 + 40 * 1) / 3)
+    end
+  end
+
+  # Shared aggregate for grade_cosine_categories/3 tests — computed once for the module.
+  setup_all do
+    files = CodeQA.Engine.Collector.collect_files("lib", [])
+    result = CodeQA.Engine.Analyzer.analyze_codebase(files)
+    aggregate = get_in(result, ["codebase", "aggregate"])
+    {:ok, aggregate: aggregate}
+  end
+
+  # -----------------------------------------------------------------------
+  # grade_cosine_categories/3
+  # -----------------------------------------------------------------------
+
+  describe "grade_cosine_categories/3" do
+    test "returns a list", %{aggregate: aggregate} do
+      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+      assert is_list(result)
+    end
+
+    test "each entry has required top-level keys", %{aggregate: aggregate} do
+      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+
+      for cat <- result do
+        assert Map.has_key?(cat, :type), "missing :type in #{inspect(cat)}"
+        assert Map.has_key?(cat, :key), "missing :key"
+        assert Map.has_key?(cat, :name), "missing :name"
+        assert Map.has_key?(cat, :score), "missing :score"
+        assert Map.has_key?(cat, :grade), "missing :grade"
+        assert Map.has_key?(cat, :behaviors), "missing :behaviors"
+      end
+    end
+
+    test "type is :cosine for every entry", %{aggregate: aggregate} do
+      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+      for cat <- result, do: assert(cat.type == :cosine)
+    end
+
+    test "scores are integers in [0, 100]", %{aggregate: aggregate} do
+      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+
+      for cat <- result do
+        assert is_integer(cat.score), "score not integer in #{cat.key}"
+        assert cat.score >= 0 and cat.score <= 100
+      end
+    end
+
+    test "grade is a string", %{aggregate: aggregate} do
+      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+      for cat <- result, do: assert(is_binary(cat.grade))
+    end
+
+    test "impact key is absent (HealthReport.generate/2 is responsible for embedding impact)", %{
+      aggregate: aggregate
+    } do
+      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+      for cat <- result, do: refute(Map.has_key?(cat, :impact))
+    end
+
+    test "name is humanized from key", %{aggregate: aggregate} do
+      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+
+      for cat <- result do
+        # name must be a non-empty string, words capitalized
+        assert is_binary(cat.name)
+        assert String.length(cat.name) > 0
+        # key should be a string (category slug)
+        assert is_binary(cat.key)
+      end
+    end
+
+    test "each behavior entry has required keys", %{aggregate: aggregate} do
+      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+
+      for cat <- result, b <- cat.behaviors do
+        assert Map.has_key?(b, :behavior)
+        assert Map.has_key?(b, :cosine)
+        assert Map.has_key?(b, :score)
+        assert Map.has_key?(b, :grade)
+        assert Map.has_key?(b, :worst_offenders)
+      end
+    end
+
+    test "behavior scores are integers in [0, 100]", %{aggregate: aggregate} do
+      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+
+      for cat <- result, b <- cat.behaviors do
+        assert is_integer(b.score)
+        assert b.score >= 0 and b.score <= 100
+      end
+    end
+
+    test "worst_offenders uses worst_files lookup", %{aggregate: aggregate} do
+      sentinel = [%{file: "lib/sentinel.ex", cosine: -0.99}]
+      # Get one real behavior key to inject into worst_files
+      [first_cat | _] = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+      first_behavior = hd(first_cat.behaviors)
+      lookup_key = "#{first_cat.key}.#{first_behavior.behavior}"
+
+      worst_files = %{lookup_key => sentinel}
+      result = Grader.grade_cosine_categories(aggregate, worst_files, @default_scale)
+
+      found_cat = Enum.find(result, &(&1.key == first_cat.key))
+      found_behavior = Enum.find(found_cat.behaviors, &(&1.behavior == first_behavior.behavior))
+      assert found_behavior.worst_offenders == sentinel
+    end
+
+    test "top_metrics and top_nodes pass through unmodified", %{aggregate: aggregate} do
+      sentinel = [
+        %{
+          file: "lib/sentinel.ex",
+          cosine: -0.99,
+          top_metrics: [%{metric: "foo.bar", contribution: -1.5}],
+          top_nodes: [%{"start_line" => 42, "type" => "block"}]
+        }
+      ]
+
+      [first_cat | _] = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+      first_behavior = hd(first_cat.behaviors)
+      lookup_key = "#{first_cat.key}.#{first_behavior.behavior}"
+
+      worst_files = %{lookup_key => sentinel}
+      result = Grader.grade_cosine_categories(aggregate, worst_files, @default_scale)
+
+      found_cat = Enum.find(result, &(&1.key == first_cat.key))
+      found_behavior = Enum.find(found_cat.behaviors, &(&1.behavior == first_behavior.behavior))
+      assert found_behavior.worst_offenders == sentinel
+    end
+
+    test "worst_offenders defaults to [] when key absent", %{aggregate: aggregate} do
+      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+      for cat <- result, b <- cat.behaviors, do: assert(b.worst_offenders == [])
+    end
+  end
+
+  # -----------------------------------------------------------------------
+  # worst_offenders/4 — top_nodes
+  # -----------------------------------------------------------------------
+
+  describe "worst_offenders/4 top_nodes" do
+    @category %{
+      key: :function_design,
+      name: "Function Design",
+      metrics: [
+        %{
+          source: "halstead",
+          name: "tokens",
+          weight: 1.0,
+          good: :low,
+          thresholds: %{a: 10, b: 20, c: 30, d: 40}
+        }
+      ]
+    }
+
+    test "returns top_nodes: [] when file_data has no nodes key" do
+      files = %{
+        "lib/foo.ex" => %{
+          "metrics" => %{"halstead" => %{"tokens" => 50.0}},
+          "lines" => 10,
+          "bytes" => 100
+        }
+      }
+
+      result = Grader.worst_offenders(@category, files, 5)
+      [entry | _] = result
+      assert entry.top_nodes == []
+    end
+
+    test "returns top_nodes: [] when file_data nodes is nil" do
+      files = %{
+        "lib/foo.ex" => %{
+          "metrics" => %{"halstead" => %{"tokens" => 50.0}},
+          "nodes" => nil,
+          "lines" => 10,
+          "bytes" => 100
+        }
+      }
+
+      result = Grader.worst_offenders(@category, files, 5)
+      [entry | _] = result
+      assert entry.top_nodes == []
+    end
+
+    test "returns top_nodes: [] when file_data nodes is []" do
+      files = %{
+        "lib/foo.ex" => %{
+          "metrics" => %{"halstead" => %{"tokens" => 50.0}},
+          "nodes" => [],
+          "lines" => 10,
+          "bytes" => 100
+        }
+      }
+
+      result = Grader.worst_offenders(@category, files, 5)
+      [entry | _] = result
+      assert entry.top_nodes == []
+    end
+
+    test "returns top 3 nodes ranked by refactoring_potentials descending" do
+      nodes = [
+        %{
+          "start_line" => 1,
+          "column_start" => 0,
+          "char_length" => 50,
+          "type" => "function",
+          "token_count" => 20,
+          "refactoring_potentials" => [
+            %{"category" => "function_design", "behavior" => "x", "cosine_delta" => 0.5}
+          ],
+          "children" => []
+        },
+        %{
+          "start_line" => 10,
+          "column_start" => 0,
+          "char_length" => 100,
+          "type" => "function",
+          "token_count" => 40,
+          "refactoring_potentials" => [
+            %{"category" => "function_design", "behavior" => "x", "cosine_delta" => 0.9},
+            %{"category" => "naming", "behavior" => "y", "cosine_delta" => 0.4}
+          ],
+          "children" => []
+        },
+        %{
+          "start_line" => 20,
+          "column_start" => 0,
+          "char_length" => 30,
+          "type" => "function",
+          "token_count" => 10,
+          "refactoring_potentials" => [
+            %{"category" => "function_design", "behavior" => "z", "cosine_delta" => 0.2}
+          ],
+          "children" => []
+        },
+        %{
+          "start_line" => 30,
+          "column_start" => 0,
+          "char_length" => 10,
+          "type" => "function",
+          "token_count" => 5,
+          "refactoring_potentials" => [],
+          "children" => []
+        }
+      ]
+
+      files = %{
+        "lib/foo.ex" => %{
+          "metrics" => %{"halstead" => %{"tokens" => 50.0}},
+          "nodes" => nodes,
+          "lines" => 40,
+          "bytes" => 400
+        }
+      }
+
+      result = Grader.worst_offenders(@category, files, 5)
+      [entry | _] = result
+
+      assert length(entry.top_nodes) == 3
+      # The node with highest sum of cosine_delta comes first (0.9+0.4=1.3)
+      [first | _] = entry.top_nodes
+      assert first["start_line"] == 10
+    end
+
+    test "parent+child overlap: only parent is included when both rank top 3" do
+      child_node = %{
+        "start_line" => 11,
+        "column_start" => 2,
+        "char_length" => 30,
+        "type" => "function",
+        "token_count" => 10,
+        "refactoring_potentials" => [
+          %{"category" => "function_design", "behavior" => "x", "cosine_delta" => 0.8}
+        ],
+        "children" => []
+      }
+
+      nodes = [
+        %{
+          "start_line" => 10,
+          "column_start" => 0,
+          "char_length" => 100,
+          "type" => "function",
+          "token_count" => 40,
+          "refactoring_potentials" => [
+            %{"category" => "function_design", "behavior" => "x", "cosine_delta" => 0.9}
+          ],
+          "children" => [child_node]
+        },
+        %{
+          "start_line" => 20,
+          "column_start" => 0,
+          "char_length" => 50,
+          "type" => "function",
+          "token_count" => 20,
+          "refactoring_potentials" => [
+            %{"category" => "naming", "behavior" => "y", "cosine_delta" => 0.5}
+          ],
+          "children" => []
+        },
+        %{
+          "start_line" => 30,
+          "column_start" => 0,
+          "char_length" => 30,
+          "type" => "function",
+          "token_count" => 10,
+          "refactoring_potentials" => [
+            %{"category" => "naming", "behavior" => "z", "cosine_delta" => 0.3}
+          ],
+          "children" => []
+        }
+      ]
+
+      files = %{
+        "lib/foo.ex" => %{
+          "metrics" => %{"halstead" => %{"tokens" => 50.0}},
+          "nodes" => nodes,
+          "lines" => 40,
+          "bytes" => 400
+        }
+      }
+
+      result = Grader.worst_offenders(@category, files, 5)
+      [entry | _] = result
+
+      # child_node is not top-level, so only top-level nodes are considered
+      assert length(entry.top_nodes) == 3
+      start_lines = Enum.map(entry.top_nodes, & &1["start_line"])
+      refute 11 in start_lines
+    end
+  end
+end

From 13f8b3c7b70a109efab723c19b19cc2560aba313 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 19 Mar 2026 18:27:28 +0100
Subject: [PATCH 10/71] feat(cli): add diagnose command and update existing
 commands

Add diagnose CLI command for surfacing code quality issues. Update
analyze, compare, correlate, history, health_report, and options
commands to work with the new engine and config layers.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/cli.ex                | 19 ++++++---
 lib/codeqa/cli/analyze.ex        | 24 ++++++-----
 lib/codeqa/cli/command.ex        |  2 +-
 lib/codeqa/cli/compare.ex        | 35 +++++++---------
 lib/codeqa/cli/correlate.ex      | 19 ++++++---
 lib/codeqa/cli/diagnose.ex       | 71 ++++++++++++++++++++++++++++++++
 lib/codeqa/cli/health_report.ex  | 47 +++++++++++----------
 lib/codeqa/cli/history.ex        | 21 ++++++----
 lib/codeqa/cli/options.ex        | 28 ++-----------
 test/codeqa/cli_compare_test.exs | 46 ++++++++++++---------
 test/codeqa/cli_test.exs         | 45 ++++++++++----------
 11 files changed, 219 insertions(+), 138 deletions(-)
 create mode 100644 lib/codeqa/cli/diagnose.ex

diff --git a/lib/codeqa/cli.ex b/lib/codeqa/cli.ex
index 210654d..85daa5e 100644
--- a/lib/codeqa/cli.ex
+++ b/lib/codeqa/cli.ex
@@ -6,24 +6,31 @@ defmodule CodeQA.CLI do
     "compare" => CodeQA.CLI.Compare,
     "history" => CodeQA.CLI.History,
     "correlate" => CodeQA.CLI.Correlate,
-    "stopwords" => CodeQA.CLI.Stopwords,
-    "health-report" => CodeQA.CLI.HealthReport
+    "health-report" => CodeQA.CLI.HealthReport,
+    "diagnose" => CodeQA.CLI.Diagnose
   }
 
   def main(args) do
     case args do
-      [cmd | rest] when is_map_key(@commands, cmd) -> @commands[cmd].run(rest)
-      _ -> print_usage()
+      [cmd | rest] when is_map_key(@commands, cmd) ->
+        output = @commands[cmd].run(rest)
+        unless output == "", do: IO.puts(output)
+        output
+
+      _ ->
+        output = build_usage()
+        IO.puts(output)
+        output
     end
   end
 
-  defp print_usage do
+  defp build_usage do
     command_usages =
       @commands
       |> Enum.sort_by(fn {name, _} -> name end)
       |> Enum.map(fn {_name, mod} -> mod.usage() end)
       |> Enum.join("\n")
 
-    IO.puts("Usage: codeqa <command> [options]\n\n" <> command_usages)
+    "Usage: codeqa <command> [options]\n\n" <> command_usages
   end
 end
diff --git a/lib/codeqa/cli/analyze.ex b/lib/codeqa/cli/analyze.ex
index 4473011..81f4970 100644
--- a/lib/codeqa/cli/analyze.ex
+++ b/lib/codeqa/cli/analyze.ex
@@ -32,19 +32,18 @@ defmodule CodeQA.CLI.Analyze do
 
   @impl CodeQA.CLI.Command
   def run(args) when args in [["--help"], ["-h"]] do
-    IO.puts(usage())
+    usage()
   end
 
   def run(args) do
     {opts, [path], _} =
-      Options.parse(args, [output: :string], [o: :output])
-
-    if opts[:telemetry], do: CodeQA.Telemetry.setup()
+      Options.parse(args, [output: :string], o: :output)
 
     Options.validate_dir!(path)
+    CodeQA.Config.load(path)
 
-    ignore_patterns = Options.parse_ignore_paths(opts[:ignore_paths]) ++ Options.load_config_ignore_paths(path)
-    files = CodeQA.Collector.collect_files(path, ignore_patterns: ignore_patterns)
+    files =
+      CodeQA.Engine.Collector.collect_files(path, Options.parse_ignore_paths(opts[:ignore_paths]))
 
     if map_size(files) == 0 do
       IO.puts(:stderr, "Warning: no source files found in '#{path}'")
@@ -53,14 +52,18 @@ defmodule CodeQA.CLI.Analyze do
 
     print_progress(opts, files)
 
-    analyze_opts = Options.build_analyze_opts(opts)
+    analyze_opts =
+      Options.build_analyze_opts(opts) ++ CodeQA.Config.near_duplicate_blocks_opts()
 
     start_time = System.monotonic_time(:millisecond)
-    results = CodeQA.Analyzer.analyze_codebase(files, analyze_opts)
+    results = CodeQA.Engine.Analyzer.analyze_codebase(files, analyze_opts)
     end_time = System.monotonic_time(:millisecond)
 
     IO.puts(:stderr, "Analysis completed in #{end_time - start_time}ms")
 
+    nodes_top = opts[:nodes_top] || 3
+    results = CodeQA.BlockImpactAnalyzer.analyze(results, files, nodes_top: nodes_top)
+
     total_bytes = results["files"] |> Map.values() |> Enum.map(& &1["bytes"]) |> Enum.sum()
     results = filter_files_for_output(results, opts, "json")
 
@@ -80,14 +83,13 @@ defmodule CodeQA.CLI.Analyze do
 
     case opts[:output] do
       nil ->
-        IO.puts(json)
+        json
 
       file ->
         File.write!(file, json)
         IO.puts(:stderr, "Report written to #{file}")
+        ""
     end
-
-    if opts[:telemetry], do: CodeQA.Telemetry.print_report()
   end
 
   defp print_progress(opts, files) do
diff --git a/lib/codeqa/cli/command.ex b/lib/codeqa/cli/command.ex
index e2702a1..c6cd4a1 100644
--- a/lib/codeqa/cli/command.ex
+++ b/lib/codeqa/cli/command.ex
@@ -1,6 +1,6 @@
 defmodule CodeQA.CLI.Command do
   @moduledoc "Behaviour for CLI commands."
 
-  @callback run([String.t()]) :: :ok
+  @callback run([String.t()]) :: String.t()
   @callback usage() :: String.t()
 end
diff --git a/lib/codeqa/cli/compare.ex b/lib/codeqa/cli/compare.ex
index b86bc32..9adc0c9 100644
--- a/lib/codeqa/cli/compare.ex
+++ b/lib/codeqa/cli/compare.ex
@@ -37,12 +37,13 @@ defmodule CodeQA.CLI.Compare do
 
   @impl CodeQA.CLI.Command
   def run(args) when args in [["--help"], ["-h"]] do
-    IO.puts(usage())
+    usage()
   end
 
   def run(args) do
     {opts, [path], _} =
-      Options.parse(args,
+      Options.parse(
+        args,
         [
           base_ref: :string,
           head_ref: :string,
@@ -54,8 +55,6 @@ defmodule CodeQA.CLI.Compare do
         []
       )
 
-    if opts[:telemetry], do: CodeQA.Telemetry.setup()
-
     base_ref = opts[:base_ref] || raise "Missing --base-ref"
     head_ref = opts[:head_ref] || "HEAD"
     changes_only = if opts[:changes_only], do: true, else: false
@@ -63,8 +62,9 @@ defmodule CodeQA.CLI.Compare do
     output_mode = opts[:output] || "auto"
 
     Options.validate_dir!(path)
+    CodeQA.Config.load(path)
 
-    ignore_patterns = Options.parse_ignore_paths(opts[:ignore_paths]) ++ Options.load_config_ignore_paths(path)
+    ignore_patterns = Options.parse_ignore_paths(opts[:ignore_paths])
     opts = Keyword.put(opts, :ignore_patterns, ignore_patterns)
 
     {base_result, head_result, changes} =
@@ -76,14 +76,12 @@ defmodule CodeQA.CLI.Compare do
       |> filter_files_for_output(opts, format)
 
     output_comparison(comparison, format, output_mode)
-
-    if opts[:telemetry], do: CodeQA.Telemetry.print_report()
   end
 
   defp run_comparison(path, base_ref, head_ref, changes_only, opts) do
     ignore_patterns = opts[:ignore_patterns] || []
     changes = CodeQA.Git.changed_files(path, base_ref, head_ref)
-    changes = CodeQA.Collector.reject_ignored(changes, ignore_patterns, & &1.path)
+    changes = CodeQA.Engine.Collector.reject_ignored(changes, & &1.path, ignore_patterns)
 
     file_paths =
       if changes_only do
@@ -102,8 +100,8 @@ defmodule CodeQA.CLI.Compare do
     else
       base_files = CodeQA.Git.collect_files_at_ref(path, base_ref, file_paths)
       head_files = CodeQA.Git.collect_files_at_ref(path, head_ref, file_paths)
-      base_files = CodeQA.Collector.reject_ignored_map(base_files, ignore_patterns)
-      head_files = CodeQA.Collector.reject_ignored_map(head_files, ignore_patterns)
+      base_files = CodeQA.Engine.Collector.reject_ignored_map(base_files, ignore_patterns)
+      head_files = CodeQA.Engine.Collector.reject_ignored_map(head_files, ignore_patterns)
 
       if map_size(base_files) == 0 and map_size(head_files) == 0 do
         IO.puts(:stderr, "Warning: no source files found at either ref")
@@ -112,16 +110,17 @@ defmodule CodeQA.CLI.Compare do
 
       print_progress(opts, base_files, head_files)
 
-      analyze_opts = Options.build_analyze_opts(opts)
+      analyze_opts =
+        Options.build_analyze_opts(opts) ++ CodeQA.Config.near_duplicate_blocks_opts()
 
       base_result =
         if map_size(base_files) > 0,
-          do: CodeQA.Analyzer.analyze_codebase(base_files, analyze_opts),
+          do: CodeQA.Engine.Analyzer.analyze_codebase(base_files, analyze_opts),
           else: empty
 
       head_result =
         if map_size(head_files) > 0,
-          do: CodeQA.Analyzer.analyze_codebase(head_files, analyze_opts),
+          do: CodeQA.Engine.Analyzer.analyze_codebase(head_files, analyze_opts),
           else: empty
 
       changes = if changes_only, do: changes, else: synthesize_changes(base_files, head_files)
@@ -156,11 +155,11 @@ defmodule CodeQA.CLI.Compare do
   end
 
   defp output_comparison(comparison, "markdown", output_mode) do
-    IO.puts(CodeQA.Formatter.format_markdown(comparison, output_mode))
+    CodeQA.Formatter.format_markdown(comparison, output_mode)
   end
 
   defp output_comparison(comparison, "github", output_mode) do
-    IO.puts(CodeQA.Formatter.format_github(comparison, output_mode))
+    CodeQA.Formatter.format_github(comparison, output_mode)
   end
 
   defp output_comparison(comparison, _format, output_mode) do
@@ -171,10 +170,8 @@ defmodule CodeQA.CLI.Compare do
         {path, CodeQA.Summarizer.summarize_file(path, data)}
       end)
 
-    IO.puts(
-      Jason.encode!(build_json_output(comparison, codebase_summary, file_summaries, output_mode),
-        pretty: true
-      )
+    Jason.encode!(build_json_output(comparison, codebase_summary, file_summaries, output_mode),
+      pretty: true
     )
   end
 
diff --git a/lib/codeqa/cli/correlate.ex b/lib/codeqa/cli/correlate.ex
index a3fd2f7..5021842 100644
--- a/lib/codeqa/cli/correlate.ex
+++ b/lib/codeqa/cli/correlate.ex
@@ -25,7 +25,7 @@ defmodule CodeQA.CLI.Correlate do
 
   @impl CodeQA.CLI.Command
   def run(args) when args in [["--help"], ["-h"]] do
-    IO.puts(usage())
+    usage()
   end
 
   def run(args) do
@@ -82,7 +82,7 @@ defmodule CodeQA.CLI.Correlate do
     sorted = Enum.sort_by(correlations, &abs(&1["correlation"]), :desc)
     top = Enum.take(sorted, top_n)
 
-    IO.puts(Jason.encode!(top, pretty: true))
+    Jason.encode!(top, pretty: true)
   end
 
   defp extract_metric_series(path, files) do
@@ -204,7 +204,16 @@ defmodule CodeQA.CLI.Correlate do
 
     pairs_stream
     |> Task.async_stream(
-      &correlate_pair(&1, counter, total_pairs, update_interval, total_start, series, category_map, opts),
+      &correlate_pair(
+        &1,
+        counter,
+        total_pairs,
+        update_interval,
+        total_start,
+        series,
+        category_map,
+        opts
+      ),
       max_concurrency: System.schedulers_online(),
       timeout: :infinity
     )
@@ -257,9 +266,7 @@ defmodule CodeQA.CLI.Correlate do
       eta_ms = round((total_pairs - current) * avg_time)
 
       output =
-        CodeQA.CLI.UI.progress_bar(current, total_pairs,
-          eta: CodeQA.CLI.UI.format_eta(eta_ms)
-        )
+        CodeQA.CLI.UI.progress_bar(current, total_pairs, eta: CodeQA.CLI.UI.format_eta(eta_ms))
 
       IO.write(:stderr, "\r" <> output)
       if current == total_pairs, do: IO.puts(:stderr, "")
diff --git a/lib/codeqa/cli/diagnose.ex b/lib/codeqa/cli/diagnose.ex
new file mode 100644
index 0000000..93c2e8d
--- /dev/null
+++ b/lib/codeqa/cli/diagnose.ex
@@ -0,0 +1,71 @@
+defmodule CodeQA.CLI.Diagnose do
+  @moduledoc false
+
+  @behaviour CodeQA.CLI.Command
+
+  @impl CodeQA.CLI.Command
+  def usage do
+    """
+    Usage: codeqa diagnose [options]
+
+      Diagnose likely code quality issues using cosine similarity against behavior profiles.
+
+    Options:
+      --path PATH           File or directory path to analyze (required)
+      --mode MODE           Output mode: aggregate (default) or per-file
+      --top N               Number of top issues to display (default: 15)
+      --format FORMAT       Output format: plain (default) or json
+      --combined-top N      Number of worst offender files per behavior (default: 2)
+    """
+  end
+
+  @impl CodeQA.CLI.Command
+  def run(args) when args in [["--help"], ["-h"]] do
+    usage()
+  end
+
+  def run(args) do
+    {opts, _, _} =
+      OptionParser.parse(args,
+        strict: [
+          path: :string,
+          mode: :string,
+          top: :integer,
+          format: :string,
+          combined_top: :integer
+        ]
+      )
+
+    path = opts[:path]
+
+    unless path do
+      IO.puts(:stderr, "Error: --path required")
+      exit({:shutdown, 1})
+    end
+
+    unless File.exists?(path) do
+      IO.puts(:stderr, "Error: '#{path}' does not exist")
+      exit({:shutdown, 1})
+    end
+
+    mode =
+      case opts[:mode] do
+        "per-file" -> :per_file
+        _ -> :aggregate
+      end
+
+    format =
+      case opts[:format] do
+        "json" -> :json
+        _ -> :plain
+      end
+
+    CodeQA.Diagnostics.run(
+      path: path,
+      mode: mode,
+      top: opts[:top] || 15,
+      format: format,
+      combined_top: opts[:combined_top] || 2
+    )
+  end
+end
diff --git a/lib/codeqa/cli/health_report.ex b/lib/codeqa/cli/health_report.ex
index 8f39186..525e2e0 100644
--- a/lib/codeqa/cli/health_report.ex
+++ b/lib/codeqa/cli/health_report.ex
@@ -29,28 +29,28 @@ defmodule CodeQA.CLI.HealthReport do
 
   @impl CodeQA.CLI.Command
   def run(args) when args in [["--help"], ["-h"]] do
-    IO.puts(usage())
+    usage()
   end
 
-  def run(args) do
-    {opts, [path], _} =
-      Options.parse(args,
-        [
-          output: :string,
-          config: :string,
-          detail: :string,
-          top: :integer,
-          format: :string
-        ],
-        [o: :output]
-      )
-
-    if opts[:telemetry], do: CodeQA.Telemetry.setup()
+  @command_options [
+    output: :string,
+    config: :string,
+    detail: :string,
+    top: :integer,
+    format: :string,
+    ignore_paths: :string
+  ]
 
+  def run(args) do
+    {opts, [path], _} = Options.parse(args, @command_options, o: :output)
     Options.validate_dir!(path)
+    extra_ignore_patterns = Options.parse_ignore_paths(opts[:ignore_paths])
 
-    ignore_patterns = Options.parse_ignore_paths(opts[:ignore_paths]) ++ Options.load_config_ignore_paths(path)
-    files = CodeQA.Collector.collect_files(path, ignore_patterns: ignore_patterns)
+    files =
+      CodeQA.Engine.Collector.collect_files(path, extra_ignore_patterns)
+
+    # IO.inspect(files |> Map.keys(), label: "files", limit: :infinity)
+    # Process.exit(Process.get(:codeqa_config), :kill)
 
     if map_size(files) == 0 do
       IO.puts(:stderr, "Warning: no source files found in '#{path}'")
@@ -59,14 +59,18 @@ defmodule CodeQA.CLI.HealthReport do
 
     IO.puts(:stderr, "Analyzing #{map_size(files)} files for health report...")
 
-    analyze_opts = Options.build_analyze_opts(opts)
+    analyze_opts =
+      Options.build_analyze_opts(opts) ++ CodeQA.Config.near_duplicate_blocks_opts()
 
     start_time = System.monotonic_time(:millisecond)
-    results = CodeQA.Analyzer.analyze_codebase(files, analyze_opts)
+    results = CodeQA.Engine.Analyzer.analyze_codebase(files, analyze_opts)
     end_time = System.monotonic_time(:millisecond)
 
     IO.puts(:stderr, "Analysis completed in #{end_time - start_time}ms")
 
+    nodes_top = opts[:nodes_top] || 3
+    results = CodeQA.BlockImpactAnalyzer.analyze(results, files, nodes_top: nodes_top)
+
     total_bytes = results["files"] |> Map.values() |> Enum.map(& &1["bytes"]) |> Enum.sum()
 
     results =
@@ -92,14 +96,13 @@ defmodule CodeQA.CLI.HealthReport do
 
     case opts[:output] do
       nil ->
-        IO.puts(markdown)
+        markdown
 
       file ->
         File.write!(file, markdown)
         IO.puts(:stderr, "Health report written to #{file}")
+        ""
     end
-
-    if opts[:telemetry], do: CodeQA.Telemetry.print_report()
   end
 
   defp parse_detail(nil), do: :default
diff --git a/lib/codeqa/cli/history.ex b/lib/codeqa/cli/history.ex
index 4c73ace..b24ea4c 100644
--- a/lib/codeqa/cli/history.ex
+++ b/lib/codeqa/cli/history.ex
@@ -34,18 +34,20 @@ defmodule CodeQA.CLI.History do
 
   @impl CodeQA.CLI.Command
   def run(args) when args in [["--help"], ["-h"]] do
-    IO.puts(usage())
+    usage()
   end
 
   def run(args) do
     {opts, [path], _} =
-      Options.parse(args,
+      Options.parse(
+        args,
         [
           commits: :integer,
           commit_list: :string,
           output_dir: :string
         ],
-        [n: :commits, o: :output_dir]
+        n: :commits,
+        o: :output_dir
       )
 
     output_dir = opts[:output_dir] || raise "Missing --output-dir"
@@ -56,14 +58,19 @@ defmodule CodeQA.CLI.History do
     commits = resolve_commits(opts, path)
     IO.puts(:stderr, "Found #{length(commits)} commits to analyze.")
 
-    analyze_opts = Options.build_analyze_opts(opts)
-    ignore_patterns = Options.parse_ignore_paths(opts[:ignore_paths]) ++ Options.load_config_ignore_paths(path)
+    CodeQA.Config.load(path)
+
+    analyze_opts =
+      Options.build_analyze_opts(opts) ++ CodeQA.Config.near_duplicate_blocks_opts()
+
+    ignore_patterns = Options.parse_ignore_paths(opts[:ignore_paths])
 
     commits
     |> Enum.with_index(1)
     |> Enum.each(&analyze_commit(&1, path, output_dir, analyze_opts, ignore_patterns, opts))
 
     IO.puts(:stderr, "Done writing history to #{output_dir}")
+    ""
   end
 
   defp resolve_commits(opts, path) do
@@ -97,7 +104,7 @@ defmodule CodeQA.CLI.History do
         else: analyze_opts
 
     files = CodeQA.Git.collect_files_at_ref(path, commit)
-    files = CodeQA.Collector.reject_ignored_map(files, ignore_patterns)
+    files = CodeQA.Engine.Collector.reject_ignored_map(files, ignore_patterns)
 
     if map_size(files) == 0 do
       IO.puts(:stderr, "Warning: no source files found at commit #{commit}")
@@ -108,7 +115,7 @@ defmodule CodeQA.CLI.History do
 
   defp write_commit_result(commit, path, output_dir, files, analyze_opts) do
     start_time = System.monotonic_time(:millisecond)
-    results = CodeQA.Analyzer.analyze_codebase(files, analyze_opts)
+    results = CodeQA.Engine.Analyzer.analyze_codebase(files, analyze_opts)
     end_time = System.monotonic_time(:millisecond)
 
     IO.puts(:stderr, "  Analysis completed in #{end_time - start_time}ms")
diff --git a/lib/codeqa/cli/options.ex b/lib/codeqa/cli/options.ex
index c735d56..5003292 100644
--- a/lib/codeqa/cli/options.ex
+++ b/lib/codeqa/cli/options.ex
@@ -10,13 +10,11 @@ defmodule CodeQA.CLI.Options do
     ncd_top: :integer,
     ncd_paths: :string,
     combinations: :boolean,
-    telemetry: :boolean,
-    experimental_stopwords: :boolean,
-    stopwords_threshold: :float,
     show_files: :boolean,
     show_file_paths: :string,
     ignore_paths: :string,
-    progress: :boolean
+    progress: :boolean,
+    nodes_top: :integer
   ]
 
   @common_aliases [w: :workers, t: :timeout]
@@ -27,7 +25,7 @@ defmodule CodeQA.CLI.Options do
   @spec common_aliases() :: keyword()
   def common_aliases, do: @common_aliases
 
-  @spec parse(list(String.t()), keyword()) :: {keyword(), list(String.t()), list()}
+  @spec parse(list(String.t()), keyword(), keyword()) :: {keyword(), list(String.t()), list()}
   def parse(args, extra_strict \\ [], extra_aliases \\ []) do
     OptionParser.parse(args,
       strict: Keyword.merge(@common_strict, extra_strict),
@@ -54,22 +52,6 @@ defmodule CodeQA.CLI.Options do
     |> Enum.map(&String.trim/1)
   end
 
-  @spec load_config_ignore_paths(String.t()) :: [String.t()]
-  def load_config_ignore_paths(path) do
-    config_file = Path.join(path, ".codeqa.yml")
-
-    case File.read(config_file) do
-      {:ok, contents} ->
-        case YamlElixir.read_from_string(contents) do
-          {:ok, %{"ignore_paths" => patterns}} when is_list(patterns) -> patterns
-          _ -> []
-        end
-
-      {:error, _} ->
-        []
-    end
-  end
-
   @spec build_analyze_opts(keyword()) :: keyword()
   def build_analyze_opts(opts) do
     start_time_progress = System.monotonic_time(:millisecond)
@@ -79,9 +61,7 @@ defmodule CodeQA.CLI.Options do
       :show_ncd,
       :ncd_top,
       :combinations,
-      :telemetry,
-      :experimental_stopwords,
-      :stopwords_threshold
+      :nodes_top
     ]
 
     base =
diff --git a/test/codeqa/cli_compare_test.exs b/test/codeqa/cli_compare_test.exs
index f43578a..b39e2c2 100644
--- a/test/codeqa/cli_compare_test.exs
+++ b/test/codeqa/cli_compare_test.exs
@@ -29,12 +29,7 @@ defmodule CodeQA.CLI.CompareTest do
       System.cmd("git", ["add", "."], cd: repo)
       System.cmd("git", ["commit", "-m", "update app"], cd: repo)
 
-      stdout =
-        ExUnit.CaptureIO.capture_io(fn ->
-          ExUnit.CaptureIO.capture_io(:stderr, fn ->
-            CodeQA.CLI.main(["compare", repo, "--base-ref", "HEAD~1", "--format", "github"])
-          end)
-        end)
+      stdout = CodeQA.CLI.main(["compare", repo, "--base-ref", "HEAD~1", "--format", "github"])
 
       assert stdout =~ "File changes — 1 modified"
       refute stdout =~ "File changes — no changes"
@@ -44,7 +39,7 @@ defmodule CodeQA.CLI.CompareTest do
   describe "compare with no source file changes" do
     test "exits 0 when only non-source files changed", %{repo: repo} do
       # Create a branch, change only a .md file (not a source file)
-      File.write!(Path.join(repo, "README.md"), "# Hello")
+      File.write!(Path.join(repo, "README.txt"), "hello")
       System.cmd("git", ["add", "."], cd: repo)
       System.cmd("git", ["commit", "-m", "add readme"], cd: repo)
 
@@ -55,28 +50,39 @@ defmodule CodeQA.CLI.CompareTest do
       assert changes == [], "expected no source file changes, got: #{inspect(changes)}"
 
       # Verify the CLI handles this gracefully by calling main
-      # Capture stderr to verify the message
-      output =
-        ExUnit.CaptureIO.capture_io(:stderr, fn ->
-          CodeQA.CLI.main(["compare", repo, "--base-ref", base_ref, "--changes-only", "--format", "json"])
-        end)
+      stdout =
+        CodeQA.CLI.main([
+          "compare",
+          repo,
+          "--base-ref",
+          base_ref,
+          "--changes-only",
+          "--format",
+          "json"
+        ])
+
+      result = Jason.decode!(stdout)
 
-      assert output =~ "No source files changed"
+      assert result["metadata"]["total_files_compared"] == 0
     end
 
     test "outputs valid JSON with empty comparison", %{repo: repo} do
       # Change only a non-source file
-      File.write!(Path.join(repo, "README.md"), "# Hello")
+      File.write!(Path.join(repo, "README.txt"), "hello")
       System.cmd("git", ["add", "."], cd: repo)
       System.cmd("git", ["commit", "-m", "add readme"], cd: repo)
 
-      # Capture stdout (the JSON output) to verify it's valid
+      # Assert on JSON return value directly
       stdout =
-        ExUnit.CaptureIO.capture_io(fn ->
-          ExUnit.CaptureIO.capture_io(:stderr, fn ->
-            CodeQA.CLI.main(["compare", repo, "--base-ref", "HEAD~1", "--changes-only", "--format", "json"])
-          end)
-        end)
+        CodeQA.CLI.main([
+          "compare",
+          repo,
+          "--base-ref",
+          "HEAD~1",
+          "--changes-only",
+          "--format",
+          "json"
+        ])
 
       assert {:ok, result} = Jason.decode(stdout)
       assert result["metadata"]["total_files_compared"] == 0
diff --git a/test/codeqa/cli_test.exs b/test/codeqa/cli_test.exs
index 2f2b51f..9abd991 100644
--- a/test/codeqa/cli_test.exs
+++ b/test/codeqa/cli_test.exs
@@ -1,11 +1,17 @@
 defmodule CodeQA.CLITest do
-  use ExUnit.Case, async: true
+  use ExUnit.Case, async: false
 
-  @moduletag :tmp_dir
-
-  setup %{tmp_dir: tmp_dir} do
+  setup do
+    CodeQA.Config.reset()
+    tmp_dir = Path.join(System.tmp_dir!(), "codeqa_test_#{System.unique_integer([:positive])}")
     File.mkdir_p!(Path.join(tmp_dir, "lib"))
     File.write!(Path.join(tmp_dir, "lib/app.ex"), "defmodule App do\nend\n")
+
+    on_exit(fn ->
+      CodeQA.Config.reset()
+      File.rm_rf!(tmp_dir)
+    end)
+
     %{dir: tmp_dir}
   end
 
@@ -19,23 +25,20 @@ defmodule CodeQA.CLITest do
         - ignored/**
       """)
 
-      output =
-        ExUnit.CaptureIO.capture_io(:stderr, fn ->
-          CodeQA.CLI.main(["analyze", dir])
-        end)
+      json = CodeQA.CLI.main(["analyze", dir, "--show-files"])
+      report = Jason.decode!(json)
 
-      # The ignored file should not be counted
-      refute output =~ "secret.ex"
-      assert output =~ "Analyzing 1 files"
+      # total_files == 1 proves the ignored file was excluded (setup has exactly 2 files)
+      assert report["metadata"]["total_files"] == 1
+      # file paths confirm secret.ex is absent
+      refute Map.has_key?(report["files"], Path.join(dir, "ignored/secret.ex"))
     end
 
     test "works normally when .codeqa.yml is absent", %{dir: dir} do
-      output =
-        ExUnit.CaptureIO.capture_io(:stderr, fn ->
-          CodeQA.CLI.main(["analyze", dir])
-        end)
+      json = CodeQA.CLI.main(["analyze", dir])
+      report = Jason.decode!(json)
 
-      assert output =~ "Analyzing 1 files"
+      assert report["metadata"]["total_files"] == 1
     end
 
     test "config file and --ignore-paths are merged additively", %{dir: dir} do
@@ -49,13 +52,11 @@ defmodule CodeQA.CLITest do
         - ignored_by_config/**
       """)
 
-      output =
-        ExUnit.CaptureIO.capture_io(:stderr, fn ->
-          CodeQA.CLI.main(["analyze", dir, "--ignore-paths", "ignored_by_flag/**"])
-        end)
+      json = CodeQA.CLI.main(["analyze", dir, "--ignore-paths", "ignored_by_flag/**"])
+      report = Jason.decode!(json)
 
-      # Only lib/app.ex should be analyzed
-      assert output =~ "Analyzing 1 files"
+      # Only lib/app.ex should be analyzed — both ignore sources must apply
+      assert report["metadata"]["total_files"] == 1
     end
   end
 end

From 397fd8fa32cff9b3900910efeda24f8fbb005555 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 19 Mar 2026 18:27:38 +0100
Subject: [PATCH 11/71] feat(scalar-tuner): add scalar tuner UI tool

Add a React/Vite web app for interactively tuning scalar metric weights
and visualizing combined metric scores. Includes knob controls, behavior
cards, YAML export, and a bundled metric report for offline use.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 tools/scalar_tuner/README.md                  |     16 +
 tools/scalar_tuner/eslint.config.js           |     29 +
 tools/scalar_tuner/index.html                 |     13 +
 tools/scalar_tuner/package-lock.json          |   2610 +
 tools/scalar_tuner/package.json               |     27 +
 tools/scalar_tuner/public/favicon.svg         |      1 +
 tools/scalar_tuner/public/icons.svg           |     24 +
 tools/scalar_tuner/public/metric_report.json  | 283278 +++++++++++++++
 tools/scalar_tuner/src/App.css                |    328 +
 tools/scalar_tuner/src/App.jsx                |    252 +
 tools/scalar_tuner/src/assets/hero.png        |    Bin 0 -> 44919 bytes
 tools/scalar_tuner/src/assets/react.svg       |      1 +
 tools/scalar_tuner/src/assets/vite.svg        |      1 +
 .../src/components/BehaviorCard.jsx           |    160 +
 tools/scalar_tuner/src/components/Knob.jsx    |     68 +
 .../scalar_tuner/src/components/MetricRow.jsx |     59 +
 .../src/components/ScoreDisplay.jsx           |     52 +
 .../scalar_tuner/src/components/YamlModal.jsx |     64 +
 tools/scalar_tuner/src/index.css              |    106 +
 tools/scalar_tuner/src/main.jsx               |     10 +
 tools/scalar_tuner/vite.config.js             |      7 +
 21 files changed, 287106 insertions(+)
 create mode 100644 tools/scalar_tuner/README.md
 create mode 100644 tools/scalar_tuner/eslint.config.js
 create mode 100644 tools/scalar_tuner/index.html
 create mode 100644 tools/scalar_tuner/package-lock.json
 create mode 100644 tools/scalar_tuner/package.json
 create mode 100644 tools/scalar_tuner/public/favicon.svg
 create mode 100644 tools/scalar_tuner/public/icons.svg
 create mode 100644 tools/scalar_tuner/public/metric_report.json
 create mode 100644 tools/scalar_tuner/src/App.css
 create mode 100644 tools/scalar_tuner/src/App.jsx
 create mode 100644 tools/scalar_tuner/src/assets/hero.png
 create mode 100644 tools/scalar_tuner/src/assets/react.svg
 create mode 100644 tools/scalar_tuner/src/assets/vite.svg
 create mode 100644 tools/scalar_tuner/src/components/BehaviorCard.jsx
 create mode 100644 tools/scalar_tuner/src/components/Knob.jsx
 create mode 100644 tools/scalar_tuner/src/components/MetricRow.jsx
 create mode 100644 tools/scalar_tuner/src/components/ScoreDisplay.jsx
 create mode 100644 tools/scalar_tuner/src/components/YamlModal.jsx
 create mode 100644 tools/scalar_tuner/src/index.css
 create mode 100644 tools/scalar_tuner/src/main.jsx
 create mode 100644 tools/scalar_tuner/vite.config.js

diff --git a/tools/scalar_tuner/README.md b/tools/scalar_tuner/README.md
new file mode 100644
index 0000000..a36934d
--- /dev/null
+++ b/tools/scalar_tuner/README.md
@@ -0,0 +1,16 @@
+# React + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Oxc](https://oxc.rs)
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/)
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the [TS template](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts) for information on how to integrate TypeScript and [`typescript-eslint`](https://typescript-eslint.io) in your project.
diff --git a/tools/scalar_tuner/eslint.config.js b/tools/scalar_tuner/eslint.config.js
new file mode 100644
index 0000000..4fa125d
--- /dev/null
+++ b/tools/scalar_tuner/eslint.config.js
@@ -0,0 +1,29 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{js,jsx}'],
+    extends: [
+      js.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        ecmaFeatures: { jsx: true },
+        sourceType: 'module',
+      },
+    },
+    rules: {
+      'no-unused-vars': ['error', { varsIgnorePattern: '^[A-Z_]' }],
+    },
+  },
+])
diff --git a/tools/scalar_tuner/index.html b/tools/scalar_tuner/index.html
new file mode 100644
index 0000000..a4b3848
--- /dev/null
+++ b/tools/scalar_tuner/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>scalar-tuner</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>
diff --git a/tools/scalar_tuner/package-lock.json b/tools/scalar_tuner/package-lock.json
new file mode 100644
index 0000000..7007122
--- /dev/null
+++ b/tools/scalar_tuner/package-lock.json
@@ -0,0 +1,2610 @@
+{
+  "name": "scalar-tuner",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "scalar-tuner",
+      "version": "0.0.0",
+      "dependencies": {
+        "react": "^19.2.4",
+        "react-dom": "^19.2.4"
+      },
+      "devDependencies": {
+        "@eslint/js": "^9.39.4",
+        "@types/react": "^19.2.14",
+        "@types/react-dom": "^19.2.3",
+        "@vitejs/plugin-react": "^6.0.0",
+        "eslint": "^9.39.4",
+        "eslint-plugin-react-hooks": "^7.0.1",
+        "eslint-plugin-react-refresh": "^0.5.2",
+        "globals": "^17.4.0",
+        "vite": "^8.0.0"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
+      "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz",
+      "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz",
+      "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-module-transforms": "^7.28.6",
+        "@babel/helpers": "^7.28.6",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/traverse": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.29.1",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz",
+      "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
+      "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.28.6",
+        "@babel/helper-validator-option": "^7.27.1",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
+      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
+      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
+      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/traverse": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.6.tgz",
+      "integrity": "sha512-xOBvwq86HHdB7WUDTfKfT/Vuxh7gElQ+Sfti2Cy6yIWNW05P8iUslOVcZ4/sKbE+/jQaukQAdz/gf3724kYdqw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.0.tgz",
+      "integrity": "sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.0"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
+      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.28.6",
+        "@babel/parser": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz",
+      "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-globals": "^7.28.0",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
+      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@emnapi/core": {
+      "version": "1.9.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.9.0.tgz",
+      "integrity": "sha512-0DQ98G9ZQZOxfUcQn1waV2yS8aWdZ6kJMbYCJB3oUBecjWYO1fqJ+a1DRfPF3O5JEkwqwP1A9QEN/9mYm2Yd0w==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.2.0",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/runtime": {
+      "version": "1.9.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.9.0.tgz",
+      "integrity": "sha512-QN75eB0IH2ywSpRpNddCRfQIhmJYBCJ1x5Lb3IscKAL8bMnVAKnRg8dCoXbHzVLLH7P38N2Z3mtulB7W0J0FKw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/wasi-threads": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.0.tgz",
+      "integrity": "sha512-N10dEJNSsUx41Z6pZsXU8FjPjpBEplgH24sfkmITrBED1/U2Esum9F3lfLrMjKHHjmi557zQn7kR9R+XWXu5Rg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz",
+      "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "eslint-visitor-keys": "^3.4.3"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint-community/regexpp": {
+      "version": "4.12.2",
+      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz",
+      "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+      }
+    },
+    "node_modules/@eslint/config-array": {
+      "version": "0.21.2",
+      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.2.tgz",
+      "integrity": "sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/object-schema": "^2.1.7",
+        "debug": "^4.3.1",
+        "minimatch": "^3.1.5"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/config-helpers": {
+      "version": "0.4.2",
+      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz",
+      "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.17.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/core": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz",
+      "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@types/json-schema": "^7.0.15"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/eslintrc": {
+      "version": "3.3.5",
+      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.5.tgz",
+      "integrity": "sha512-4IlJx0X0qftVsN5E+/vGujTRIFtwuLbNsVUe7TO6zYPDR1O6nFwvwhIKEKSrl6dZchmYBITazxKoUYOjdtjlRg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ajv": "^6.14.0",
+        "debug": "^4.3.2",
+        "espree": "^10.0.1",
+        "globals": "^14.0.0",
+        "ignore": "^5.2.0",
+        "import-fresh": "^3.2.1",
+        "js-yaml": "^4.1.1",
+        "minimatch": "^3.1.5",
+        "strip-json-comments": "^3.1.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/globals": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
+      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@eslint/js": {
+      "version": "9.39.4",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.4.tgz",
+      "integrity": "sha512-nE7DEIchvtiFTwBw4Lfbu59PG+kCofhjsKaCWzxTpt4lfRjRMqG6uMBzKXuEcyXhOHoUp9riAm7/aWYGhXZ9cw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      }
+    },
+    "node_modules/@eslint/object-schema": {
+      "version": "2.1.7",
+      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz",
+      "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/plugin-kit": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz",
+      "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.17.0",
+        "levn": "^0.4.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@humanfs/core": {
+      "version": "0.19.1",
+      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
+      "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanfs/node": {
+      "version": "0.16.7",
+      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz",
+      "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@humanfs/core": "^0.19.1",
+        "@humanwhocodes/retry": "^0.4.0"
+      },
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanwhocodes/module-importer": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
+      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.22"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@humanwhocodes/retry": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz",
+      "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@napi-rs/wasm-runtime": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.1.tgz",
+      "integrity": "sha512-p64ah1M1ld8xjWv3qbvFwHiFVWrq1yFvV4f7w+mzaqiR4IlSgkqhcRdHwsGgomwzBH51sRY4NEowLxnaBjcW/A==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "^1.7.1",
+        "@emnapi/runtime": "^1.7.1",
+        "@tybys/wasm-util": "^0.10.1"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      }
+    },
+    "node_modules/@oxc-project/runtime": {
+      "version": "0.115.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/runtime/-/runtime-0.115.0.tgz",
+      "integrity": "sha512-Rg8Wlt5dCbXhQnsXPrkOjL1DTSvXLgb2R/KYfnf1/K+R0k6UMLEmbQXPM+kwrWqSmWA2t0B1EtHy2/3zikQpvQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@oxc-project/types": {
+      "version": "0.115.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.115.0.tgz",
+      "integrity": "sha512-4n91DKnebUS4yjUHl2g3/b2T+IUdCfmoZGhmwsovZCDaJSs+QkVAM+0AqqTxHSsHfeiMuueT75cZaZcT/m0pSw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/Boshen"
+      }
+    },
+    "node_modules/@rolldown/binding-android-arm64": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.0-rc.9.tgz",
+      "integrity": "sha512-lcJL0bN5hpgJfSIz/8PIf02irmyL43P+j1pTCfbD1DbLkmGRuFIA4DD3B3ZOvGqG0XiVvRznbKtN0COQVaKUTg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-darwin-arm64": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.0-rc.9.tgz",
+      "integrity": "sha512-J7Zk3kLYFsLtuH6U+F4pS2sYVzac0qkjcO5QxHS7OS7yZu2LRs+IXo+uvJ/mvpyUljDJ3LROZPoQfgBIpCMhdQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-darwin-x64": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.0-rc.9.tgz",
+      "integrity": "sha512-iwtmmghy8nhfRGeNAIltcNXzD0QMNaaA5U/NyZc1Ia4bxrzFByNMDoppoC+hl7cDiUq5/1CnFthpT9n+UtfFyg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-freebsd-x64": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.0-rc.9.tgz",
+      "integrity": "sha512-DLFYI78SCiZr5VvdEplsVC2Vx53lnA4/Ga5C65iyldMVaErr86aiqCoNBLl92PXPfDtUYjUh+xFFor40ueNs4Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.0-rc.9.tgz",
+      "integrity": "sha512-CsjTmTwd0Hri6iTw/DRMK7kOZ7FwAkrO4h8YWKoX/kcj833e4coqo2wzIFywtch/8Eb5enQ/lwLM7w6JX1W5RQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm64-gnu": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.0-rc.9.tgz",
+      "integrity": "sha512-2x9O2JbSPxpxMDhP9Z74mahAStibTlrBMW0520+epJH5sac7/LwZW5Bmg/E6CXuEF53JJFW509uP+lSedaUNxg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-arm64-musl": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.0-rc.9.tgz",
+      "integrity": "sha512-JA1QRW31ogheAIRhIg9tjMfsYbglXXYGNPLdPEYrwFxdbkQCAzvpSCSHCDWNl4hTtrol8WeboCSEpjdZK8qrCg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-ppc64-gnu": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.0.0-rc.9.tgz",
+      "integrity": "sha512-aOKU9dJheda8Kj8Y3w9gnt9QFOO+qKPAl8SWd7JPHP+Cu0EuDAE5wokQubLzIDQWg2myXq2XhTpOVS07qqvT+w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-s390x-gnu": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.0.0-rc.9.tgz",
+      "integrity": "sha512-OalO94fqj7IWRn3VdXWty75jC5dk4C197AWEuMhIpvVv2lw9fiPhud0+bW2ctCxb3YoBZor71QHbY+9/WToadA==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-x64-gnu": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.0-rc.9.tgz",
+      "integrity": "sha512-cVEl1vZtBsBZna3YMjGXNvnYYrOJ7RzuWvZU0ffvJUexWkukMaDuGhUXn0rjnV0ptzGVkvc+vW9Yqy6h8YX4pg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-x64-musl": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.0-rc.9.tgz",
+      "integrity": "sha512-UzYnKCIIc4heAKgI4PZ3dfBGUZefGCJ1TPDuLHoCzgrMYPb5Rv6TLFuYtyM4rWyHM7hymNdsg5ik2C+UD9VDbA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-openharmony-arm64": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.0-rc.9.tgz",
+      "integrity": "sha512-+6zoiF+RRyf5cdlFQP7nm58mq7+/2PFaY2DNQeD4B87N36JzfF/l9mdBkkmTvSYcYPE8tMh/o3cRlsx1ldLfog==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-wasm32-wasi": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.0-rc.9.tgz",
+      "integrity": "sha512-rgFN6sA/dyebil3YTlL2evvi/M+ivhfnyxec7AccTpRPccno/rPoNlqybEZQBkcbZu8Hy+eqNJCqfBR8P7Pg8g==",
+      "cpu": [
+        "wasm32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@napi-rs/wasm-runtime": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/@rolldown/binding-win32-arm64-msvc": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.0-rc.9.tgz",
+      "integrity": "sha512-lHVNUG/8nlF1IQk1C0Ci574qKYyty2goMiPlRqkC5R+3LkXDkL5Dhx8ytbxq35m+pkHVIvIxviD+TWLdfeuadA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-win32-x64-msvc": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.0-rc.9.tgz",
+      "integrity": "sha512-G0oA4+w1iY5AGi5HcDTxWsoxF509hrFIPB2rduV5aDqS9FtDg1CAfa7V34qImbjfhIcA8C+RekocJZA96EarwQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-rc.7",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.7.tgz",
+      "integrity": "sha512-qujRfC8sFVInYSPPMLQByRh7zhwkGFS4+tyMQ83srV1qrxL4g8E2tyxVVyxd0+8QeBM1mIk9KbWxkegRr76XzA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@tybys/wasm-util": {
+      "version": "0.10.1",
+      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.1.tgz",
+      "integrity": "sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/json-schema": {
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/react": {
+      "version": "19.2.14",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.14.tgz",
+      "integrity": "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/@types/react-dom": {
+      "version": "19.2.3",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz",
+      "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "^19.2.0"
+      }
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-6.0.1.tgz",
+      "integrity": "sha512-l9X/E3cDb+xY3SWzlG1MOGt2usfEHGMNIaegaUGFsLkb3RCn/k8/TOXBcab+OndDI4TBtktT8/9BwwW8Vi9KUQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@rolldown/pluginutils": "1.0.0-rc.7"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "peerDependencies": {
+        "@rolldown/plugin-babel": "^0.1.7 || ^0.2.0",
+        "babel-plugin-react-compiler": "^1.0.0",
+        "vite": "^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@rolldown/plugin-babel": {
+          "optional": true
+        },
+        "babel-plugin-react-compiler": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.16.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz",
+      "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-jsx": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "6.14.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz",
+      "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "dev": true,
+      "license": "Python-2.0"
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.8",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.8.tgz",
+      "integrity": "sha512-PCLz/LXGBsNTErbtB6i5u4eLpHeMfi93aUv5duMmj6caNu6IphS4q6UevDnL36sZQv9lrP11dbPKGMaXPwMKfQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.28.1",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz",
+      "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "baseline-browser-mapping": "^2.9.0",
+        "caniuse-lite": "^1.0.30001759",
+        "electron-to-chromium": "^1.5.263",
+        "node-releases": "^2.0.27",
+        "update-browserslist-db": "^1.2.0"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001779",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001779.tgz",
+      "integrity": "sha512-U5og2PN7V4DMgF50YPNtnZJGWVLFjjsN3zb6uMT5VGYIewieDj1upwfuVNXf4Kor+89c3iCRJnSzMD5LmTvsfA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/deep-is": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.313",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.313.tgz",
+      "integrity": "sha512-QBMrTWEf00GXZmJyx2lbYD45jpI3TUFnNIzJ5BBc8piGUDwMPa1GV6HJWTZVvY/eiN3fSopl7NRbgGp9sZ9LTA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint": {
+      "version": "9.39.4",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.4.tgz",
+      "integrity": "sha512-XoMjdBOwe/esVgEvLmNsD3IRHkm7fbKIUGvrleloJXUZgDHig2IPWNniv+GwjyJXzuNqVjlr5+4yVUZjycJwfQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.8.0",
+        "@eslint-community/regexpp": "^4.12.1",
+        "@eslint/config-array": "^0.21.2",
+        "@eslint/config-helpers": "^0.4.2",
+        "@eslint/core": "^0.17.0",
+        "@eslint/eslintrc": "^3.3.5",
+        "@eslint/js": "9.39.4",
+        "@eslint/plugin-kit": "^0.4.1",
+        "@humanfs/node": "^0.16.6",
+        "@humanwhocodes/module-importer": "^1.0.1",
+        "@humanwhocodes/retry": "^0.4.2",
+        "@types/estree": "^1.0.6",
+        "ajv": "^6.14.0",
+        "chalk": "^4.0.0",
+        "cross-spawn": "^7.0.6",
+        "debug": "^4.3.2",
+        "escape-string-regexp": "^4.0.0",
+        "eslint-scope": "^8.4.0",
+        "eslint-visitor-keys": "^4.2.1",
+        "espree": "^10.4.0",
+        "esquery": "^1.5.0",
+        "esutils": "^2.0.2",
+        "fast-deep-equal": "^3.1.3",
+        "file-entry-cache": "^8.0.0",
+        "find-up": "^5.0.0",
+        "glob-parent": "^6.0.2",
+        "ignore": "^5.2.0",
+        "imurmurhash": "^0.1.4",
+        "is-glob": "^4.0.0",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "lodash.merge": "^4.6.2",
+        "minimatch": "^3.1.5",
+        "natural-compare": "^1.4.0",
+        "optionator": "^0.9.3"
+      },
+      "bin": {
+        "eslint": "bin/eslint.js"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      },
+      "peerDependencies": {
+        "jiti": "*"
+      },
+      "peerDependenciesMeta": {
+        "jiti": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/eslint-plugin-react-hooks": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-7.0.1.tgz",
+      "integrity": "sha512-O0d0m04evaNzEPoSW+59Mezf8Qt0InfgGIBJnpC0h3NH/WjUAR7BIKUfysC6todmtiZ/A0oUVS8Gce0WhBrHsA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.24.4",
+        "@babel/parser": "^7.24.4",
+        "hermes-parser": "^0.25.1",
+        "zod": "^3.25.0 || ^4.0.0",
+        "zod-validation-error": "^3.5.0 || ^4.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0"
+      }
+    },
+    "node_modules/eslint-plugin-react-refresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.5.2.tgz",
+      "integrity": "sha512-hmgTH57GfzoTFjVN0yBwTggnsVUF2tcqi7RJZHqi9lIezSs4eFyAMktA68YD4r5kNw1mxyY4dmkyoFDb3FIqrA==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "eslint": "^9 || ^10"
+      }
+    },
+    "node_modules/eslint-scope": {
+      "version": "8.4.0",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz",
+      "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "esrecurse": "^4.3.0",
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-visitor-keys": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
+      "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/espree": {
+      "version": "10.4.0",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz",
+      "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "acorn": "^8.15.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^4.2.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/esquery": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz",
+      "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "estraverse": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/esrecurse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-levenshtein": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/file-entry-cache": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
+      "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flat-cache": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
+    "node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/flat-cache": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
+      "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flatted": "^3.2.9",
+        "keyv": "^4.5.4"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/flatted": {
+      "version": "3.4.1",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.1.tgz",
+      "integrity": "sha512-IxfVbRFVlV8V/yRaGzk0UVIcsKKHMSfYw66T/u4nTwlWteQePsxe//LjudR1AMX4tZW3WFCh3Zqa/sjlqpbURQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/globals": {
+      "version": "17.4.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-17.4.0.tgz",
+      "integrity": "sha512-hjrNztw/VajQwOLsMNT1cbJiH2muO3OROCHnbehc8eY5JyD2gqz4AcMHPqgaOR59DjgUjYAYLeH699g/eWi2jw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/hermes-estree": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/hermes-estree/-/hermes-estree-0.25.1.tgz",
+      "integrity": "sha512-0wUoCcLp+5Ev5pDW2OriHC2MJCbwLwuRx+gAqMTOkGKJJiBCLjtrvy4PWUGn6MIVefecRpzoOZ/UV6iGdOr+Cw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/hermes-parser": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/hermes-parser/-/hermes-parser-0.25.1.tgz",
+      "integrity": "sha512-6pEjquH3rqaI6cYAXYPcz9MS4rY6R4ngRgrgfDshRptUZIc3lw0MCIJIGDj9++mfySOuPTHB4nrSW99BCvOPIA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "hermes-estree": "0.25.1"
+      }
+    },
+    "node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/import-fresh": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.19"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json-buffer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json-stable-stringify-without-jsonify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/keyv": {
+      "version": "4.5.4",
+      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "json-buffer": "3.0.1"
+      }
+    },
+    "node_modules/levn": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "^1.2.1",
+        "type-check": "~0.4.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/lightningcss": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz",
+      "integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==",
+      "dev": true,
+      "license": "MPL-2.0",
+      "dependencies": {
+        "detect-libc": "^2.0.3"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      },
+      "optionalDependencies": {
+        "lightningcss-android-arm64": "1.32.0",
+        "lightningcss-darwin-arm64": "1.32.0",
+        "lightningcss-darwin-x64": "1.32.0",
+        "lightningcss-freebsd-x64": "1.32.0",
+        "lightningcss-linux-arm-gnueabihf": "1.32.0",
+        "lightningcss-linux-arm64-gnu": "1.32.0",
+        "lightningcss-linux-arm64-musl": "1.32.0",
+        "lightningcss-linux-x64-gnu": "1.32.0",
+        "lightningcss-linux-x64-musl": "1.32.0",
+        "lightningcss-win32-arm64-msvc": "1.32.0",
+        "lightningcss-win32-x64-msvc": "1.32.0"
+      }
+    },
+    "node_modules/lightningcss-android-arm64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.32.0.tgz",
+      "integrity": "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-arm64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.32.0.tgz",
+      "integrity": "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-x64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.32.0.tgz",
+      "integrity": "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-freebsd-x64": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.32.0.tgz",
+      "integrity": "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm-gnueabihf": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.32.0.tgz",
+      "integrity": "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.32.0.tgz",
+      "integrity": "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.32.0.tgz",
+      "integrity": "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.32.0.tgz",
+      "integrity": "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.32.0.tgz",
+      "integrity": "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-win32-arm64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.32.0.tgz",
+      "integrity": "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-win32-x64-msvc": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.32.0.tgz",
+      "integrity": "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/locate-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-locate": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/lodash.merge": {
+      "version": "4.6.2",
+      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
+      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/natural-compare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.36",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.36.tgz",
+      "integrity": "sha512-TdC8FSgHz8Mwtw9g5L4gR/Sh9XhSP/0DEkQxfEFXOpiul5IiHgHan2VhYYb6agDSfp4KuvltmGApc8HMgUrIkA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/optionator": {
+      "version": "0.9.4",
+      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
+      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "deep-is": "^0.1.3",
+        "fast-levenshtein": "^2.0.6",
+        "levn": "^0.4.1",
+        "prelude-ls": "^1.2.1",
+        "type-check": "^0.4.0",
+        "word-wrap": "^1.2.5"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-locate": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-limit": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "callsites": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.8",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.8.tgz",
+      "integrity": "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/prelude-ls": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/react": {
+      "version": "19.2.4",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.2.4.tgz",
+      "integrity": "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "19.2.4",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.4.tgz",
+      "integrity": "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ==",
+      "license": "MIT",
+      "dependencies": {
+        "scheduler": "^0.27.0"
+      },
+      "peerDependencies": {
+        "react": "^19.2.4"
+      }
+    },
+    "node_modules/resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/rolldown": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.0-rc.9.tgz",
+      "integrity": "sha512-9EbgWge7ZH+yqb4d2EnELAntgPTWbfL8ajiTW+SyhJEC4qhBbkCKbqFV4Ge4zmu5ziQuVbWxb/XwLZ+RIO7E8Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@oxc-project/types": "=0.115.0",
+        "@rolldown/pluginutils": "1.0.0-rc.9"
+      },
+      "bin": {
+        "rolldown": "bin/cli.mjs"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "optionalDependencies": {
+        "@rolldown/binding-android-arm64": "1.0.0-rc.9",
+        "@rolldown/binding-darwin-arm64": "1.0.0-rc.9",
+        "@rolldown/binding-darwin-x64": "1.0.0-rc.9",
+        "@rolldown/binding-freebsd-x64": "1.0.0-rc.9",
+        "@rolldown/binding-linux-arm-gnueabihf": "1.0.0-rc.9",
+        "@rolldown/binding-linux-arm64-gnu": "1.0.0-rc.9",
+        "@rolldown/binding-linux-arm64-musl": "1.0.0-rc.9",
+        "@rolldown/binding-linux-ppc64-gnu": "1.0.0-rc.9",
+        "@rolldown/binding-linux-s390x-gnu": "1.0.0-rc.9",
+        "@rolldown/binding-linux-x64-gnu": "1.0.0-rc.9",
+        "@rolldown/binding-linux-x64-musl": "1.0.0-rc.9",
+        "@rolldown/binding-openharmony-arm64": "1.0.0-rc.9",
+        "@rolldown/binding-wasm32-wasi": "1.0.0-rc.9",
+        "@rolldown/binding-win32-arm64-msvc": "1.0.0-rc.9",
+        "@rolldown/binding-win32-x64-msvc": "1.0.0-rc.9"
+      }
+    },
+    "node_modules/rolldown/node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-rc.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.9.tgz",
+      "integrity": "sha512-w6oiRWgEBl04QkFZgmW+jnU1EC9b57Oihi2ot3HNWIQRqgHp5PnYDia5iZ5FF7rpa4EQdiqMDXjlqKGXBhsoXw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/scheduler": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
+      "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==",
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD",
+      "optional": true
+    },
+    "node_modules/type-check": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "node_modules/vite": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-8.0.0.tgz",
+      "integrity": "sha512-fPGaRNj9Zytaf8LEiBhY7Z6ijnFKdzU/+mL8EFBaKr7Vw1/FWcTBAMW0wLPJAGMPX38ZPVCVgLceWiEqeoqL2Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@oxc-project/runtime": "0.115.0",
+        "lightningcss": "^1.32.0",
+        "picomatch": "^4.0.3",
+        "postcss": "^8.5.8",
+        "rolldown": "1.0.0-rc.9",
+        "tinyglobby": "^0.2.15"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "@vitejs/devtools": "^0.0.0-alpha.31",
+        "esbuild": "^0.27.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "@vitejs/devtools": {
+          "optional": true
+        },
+        "esbuild": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/word-wrap": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/yocto-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/zod": {
+      "version": "4.3.6",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz",
+      "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-validation-error": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/zod-validation-error/-/zod-validation-error-4.0.2.tgz",
+      "integrity": "sha512-Q6/nZLe6jxuU80qb/4uJ4t5v2VEZ44lzQjPDhYJNztRQ4wyWc6VF3D3Kb/fAuPetZQnhS3hnajCf9CsWesghLQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0"
+      },
+      "peerDependencies": {
+        "zod": "^3.25.0 || ^4.0.0"
+      }
+    }
+  }
+}
diff --git a/tools/scalar_tuner/package.json b/tools/scalar_tuner/package.json
new file mode 100644
index 0000000..67971ab
--- /dev/null
+++ b/tools/scalar_tuner/package.json
@@ -0,0 +1,27 @@
+{
+  "name": "scalar-tuner",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.4",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.0",
+    "eslint": "^9.39.4",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "globals": "^17.4.0",
+    "vite": "^8.0.0"
+  }
+}
diff --git a/tools/scalar_tuner/public/favicon.svg b/tools/scalar_tuner/public/favicon.svg
new file mode 100644
index 0000000..6893eb1
--- /dev/null
+++ b/tools/scalar_tuner/public/favicon.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="46" fill="none" viewBox="0 0 48 46"><path fill="#863bff" d="M25.946 44.938c-.664.845-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.287c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.497 0-3.578-1.842-3.578H1.237c-.92 0-1.456-1.04-.92-1.788L10.013.474c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.579 1.842 3.579h11.377c.943 0 1.473 1.088.89 1.83L25.947 44.94z" style="fill:#863bff;fill:color(display-p3 .5252 .23 1);fill-opacity:1"/><mask id="a" width="48" height="46" x="0" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M25.842 44.938c-.664.844-2.021.375-2.021-.698V33.937a2.26 2.26 0 0 0-2.262-2.262H10.183c-.92 0-1.456-1.04-.92-1.788l7.48-10.471c1.07-1.498 0-3.579-1.842-3.579H1.133c-.92 0-1.456-1.04-.92-1.787L9.91.473c.214-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.471c-1.07 1.498 0 3.578 1.842 3.578h11.377c.943 0 1.473 1.088.89 1.832L25.843 44.94z" style="fill:#000;fill-opacity:1"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#ede6ff" rx="5.508" ry="14.704" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -4.47 31.516)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#ede6ff" rx="10.399" ry="29.851" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -39.328 7.883)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#7e14ff" rx="5.508" ry="30.487" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -25.913 -14.639)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.814 -32.644 -3.334)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#7e14ff" rx="5.508" ry="30.599" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="matrix(.00324 1 1 -.00324 -34.34 30.47)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#ede6ff" rx="14.072" ry="22.078" style="fill:#ede6ff;fill:color(display-p3 .9275 .9033 1);fill-opacity:1" transform="rotate(93.35 24.506 48.493)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#7e14ff" rx="3.47" ry="21.501" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(89.009 28.708 47.59)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx=".387" cy="8.972" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(39.51 .387 8.972)"/></g><g filter="url(#k)"><ellipse cx="47.523" cy="-6.092" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 47.523 -6.092)"/></g><g filter="url(#l)"><ellipse cx="41.412" cy="6.333" fill="#47bfff" rx="5.971" ry="9.665" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 41.412 6.333)"/></g><g filter="url(#m)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#n)"><ellipse cx="-1.879" cy="38.332" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 -1.88 38.332)"/></g><g filter="url(#o)"><ellipse cx="35.651" cy="29.907" fill="#7e14ff" rx="4.407" ry="29.108" style="fill:#7e14ff;fill:color(display-p3 .4922 .0767 1);fill-opacity:1" transform="rotate(37.892 35.651 29.907)"/></g><g filter="url(#p)"><ellipse cx="38.418" cy="32.4" fill="#47bfff" rx="5.971" ry="15.297" style="fill:#47bfff;fill:color(display-p3 .2799 .748 1);fill-opacity:1" transform="rotate(37.892 38.418 32.4)"/></g></g><defs><filter id="b" width="60.045" height="41.654" x="-19.77" y="16.149" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-54.613" y="-7.533" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-49.64" y="2.03" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-45.045" y="20.029" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-43.513" y="21.178" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="15.756" y="-17.901" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="23.548" y="2.284" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-27.636" y="-22.853" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="20.116" y="-38.415" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="24.641" y="-11.323" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-29.286" y="6.009" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="8.244" y="-2.416" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="18.713" y="10.588" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17158" stdDeviation="4.596"/></filter></defs></svg>
\ No newline at end of file
diff --git a/tools/scalar_tuner/public/icons.svg b/tools/scalar_tuner/public/icons.svg
new file mode 100644
index 0000000..e952219
--- /dev/null
+++ b/tools/scalar_tuner/public/icons.svg
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+  <symbol id="bluesky-icon" viewBox="0 0 16 17">
+    <g clip-path="url(#bluesky-clip)"><path fill="#08060d" d="M7.75 7.735c-.693-1.348-2.58-3.86-4.334-5.097-1.68-1.187-2.32-.981-2.74-.79C.188 2.065.1 2.812.1 3.251s.241 3.602.398 4.13c.52 1.744 2.367 2.333 4.07 2.145-2.495.37-4.71 1.278-1.805 4.512 3.196 3.309 4.38-.71 4.987-2.746.608 2.036 1.307 5.91 4.93 2.746 2.72-2.746.747-4.143-1.747-4.512 1.702.189 3.55-.4 4.07-2.145.156-.528.397-3.691.397-4.13s-.088-1.186-.575-1.406c-.42-.19-1.06-.395-2.741.79-1.755 1.24-3.64 3.752-4.334 5.099"/></g>
+    <defs><clipPath id="bluesky-clip"><path fill="#fff" d="M.1.85h15.3v15.3H.1z"/></clipPath></defs>
+  </symbol>
+  <symbol id="discord-icon" viewBox="0 0 20 19">
+    <path fill="#08060d" d="M16.224 3.768a14.5 14.5 0 0 0-3.67-1.153c-.158.286-.343.67-.47.976a13.5 13.5 0 0 0-4.067 0c-.128-.306-.317-.69-.476-.976A14.4 14.4 0 0 0 3.868 3.77C1.546 7.28.916 10.703 1.231 14.077a14.7 14.7 0 0 0 4.5 2.306q.545-.748.965-1.587a9.5 9.5 0 0 1-1.518-.74q.191-.14.372-.293c2.927 1.369 6.107 1.369 8.999 0q.183.152.372.294-.723.437-1.52.74.418.838.963 1.588a14.6 14.6 0 0 0 4.504-2.308c.37-3.911-.63-7.302-2.644-10.309m-9.13 8.234c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.894 0 1.614.82 1.599 1.82.001 1-.705 1.82-1.6 1.82m5.91 0c-.878 0-1.599-.82-1.599-1.82 0-.998.705-1.82 1.6-1.82.893 0 1.614.82 1.599 1.82 0 1-.706 1.82-1.6 1.82"/>
+  </symbol>
+  <symbol id="documentation-icon" viewBox="0 0 21 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="m15.5 13.333 1.533 1.322c.645.555.967.833.967 1.178s-.322.623-.967 1.179L15.5 18.333m-3.333-5-1.534 1.322c-.644.555-.966.833-.966 1.178s.322.623.966 1.179l1.534 1.321"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M17.167 10.836v-4.32c0-1.41 0-2.117-.224-2.68-.359-.906-1.118-1.621-2.08-1.96-.599-.21-1.349-.21-2.848-.21-2.623 0-3.935 0-4.983.369-1.684.591-3.013 1.842-3.641 3.428C3 6.449 3 7.684 3 10.154v2.122c0 2.558 0 3.838.706 4.726q.306.383.713.671c.76.536 1.79.64 3.581.66"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M3 10a2.78 2.78 0 0 1 2.778-2.778c.555 0 1.209.097 1.748-.047.48-.129.854-.503.982-.982.145-.54.048-1.194.048-1.749a2.78 2.78 0 0 1 2.777-2.777"/>
+  </symbol>
+  <symbol id="github-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M9.356 1.85C5.05 1.85 1.57 5.356 1.57 9.694a7.84 7.84 0 0 0 5.324 7.44c.387.079.528-.168.528-.376 0-.182-.013-.805-.013-1.454-2.165.467-2.616-.935-2.616-.935-.349-.91-.864-1.143-.864-1.143-.71-.48.051-.48.051-.48.787.051 1.2.805 1.2.805.695 1.194 1.817.857 2.268.649.064-.507.27-.857.49-1.052-1.728-.182-3.545-.857-3.545-3.87 0-.857.31-1.558.8-2.104-.078-.195-.349-1 .077-2.078 0 0 .657-.208 2.14.805a7.5 7.5 0 0 1 1.946-.26c.657 0 1.328.092 1.946.26 1.483-1.013 2.14-.805 2.14-.805.426 1.078.155 1.883.078 2.078.502.546.799 1.247.799 2.104 0 3.013-1.818 3.675-3.558 3.87.284.247.528.714.528 1.454 0 1.052-.012 1.896-.012 2.156 0 .208.142.455.528.377a7.84 7.84 0 0 0 5.324-7.441c.013-4.338-3.48-7.844-7.773-7.844" clip-rule="evenodd"/>
+  </symbol>
+  <symbol id="social-icon" viewBox="0 0 20 20">
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M12.5 6.667a4.167 4.167 0 1 0-8.334 0 4.167 4.167 0 0 0 8.334 0"/>
+    <path fill="none" stroke="#aa3bff" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.35" d="M2.5 16.667a5.833 5.833 0 0 1 8.75-5.053m3.837.474.513 1.035c.07.144.257.282.414.309l.93.155c.596.1.736.536.307.965l-.723.73a.64.64 0 0 0-.152.531l.207.903c.164.715-.213.991-.84.618l-.872-.52a.63.63 0 0 0-.577 0l-.872.52c-.624.373-1.003.094-.84-.618l.207-.903a.64.64 0 0 0-.152-.532l-.723-.729c-.426-.43-.289-.864.306-.964l.93-.156a.64.64 0 0 0 .412-.31l.513-1.034c.28-.562.735-.562 1.012 0"/>
+  </symbol>
+  <symbol id="x-icon" viewBox="0 0 19 19">
+    <path fill="#08060d" fill-rule="evenodd" d="M1.893 1.98c.052.072 1.245 1.769 2.653 3.77l2.892 4.114c.183.261.333.48.333.486s-.068.089-.152.183l-.522.593-.765.867-3.597 4.087c-.375.426-.734.834-.798.905a1 1 0 0 0-.118.148c0 .01.236.017.664.017h.663l.729-.83c.4-.457.796-.906.879-.999a692 692 0 0 0 1.794-2.038c.034-.037.301-.34.594-.675l.551-.624.345-.392a7 7 0 0 1 .34-.374c.006 0 .93 1.306 2.052 2.903l2.084 2.965.045.063h2.275c1.87 0 2.273-.003 2.266-.021-.008-.02-1.098-1.572-3.894-5.547-2.013-2.862-2.28-3.246-2.273-3.266.008-.019.282-.332 2.085-2.38l2-2.274 1.567-1.782c.022-.028-.016-.03-.65-.03h-.674l-.3.342a871 871 0 0 1-1.782 2.025c-.067.075-.405.458-.75.852a100 100 0 0 1-.803.91c-.148.172-.299.344-.99 1.127-.304.343-.32.358-.345.327-.015-.019-.904-1.282-1.976-2.808L6.365 1.85H1.8zm1.782.91 8.078 11.294c.772 1.08 1.413 1.973 1.425 1.984.016.017.241.02 1.05.017l1.03-.004-2.694-3.766L7.796 5.75 5.722 2.852l-1.039-.004-1.039-.004z" clip-rule="evenodd"/>
+  </symbol>
+</svg>
diff --git a/tools/scalar_tuner/public/metric_report.json b/tools/scalar_tuner/public/metric_report.json
new file mode 100644
index 0000000..8a692d7
--- /dev/null
+++ b/tools/scalar_tuner/public/metric_report.json
@@ -0,0 +1,283278 @@
+{
+  "code_smells.no_magic_method_abuse": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.readonly_for_never_reassigned_fields": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0027,
+      "good": 0.0027,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.9145,
+      "log_good": -5.9145
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8462,
+      "good": 0.8462,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.167,
+      "log_good": -0.167
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0027,
+      "good": 0.0027,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.9145,
+      "log_good": -5.9145
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6853,
+      "good": 4.6887,
+      "ratio": 1.0007,
+      "suggested_scalar": 0.021,
+      "log_bad": 1.5444,
+      "log_good": 1.5452
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 68.0,
+      "good": 69.0,
+      "ratio": 1.0147,
+      "suggested_scalar": 0.4232,
+      "log_bad": 4.2195,
+      "log_good": 4.2341
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3253,
+      "good": 0.3253,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.123,
+      "log_good": -1.123
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5885,
+      "good": 0.5935,
+      "ratio": 1.0085,
+      "suggested_scalar": 0.2453,
+      "log_bad": -0.5302,
+      "log_good": -0.5217
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.8846,
+      "good": 2.8846,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0594,
+      "log_good": 1.0594
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 365.0,
+      "good": 369.0,
+      "ratio": 1.011,
+      "suggested_scalar": 0.316,
+      "log_bad": 5.8999,
+      "log_good": 5.9108
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0015,
+      "good": 0.0014,
+      "ratio": 0.9333,
+      "suggested_scalar": -2.0,
+      "log_bad": -6.5023,
+      "log_good": -6.5713
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0066,
+      "good": 0.0064,
+      "ratio": 0.9697,
+      "suggested_scalar": -0.892,
+      "log_bad": -5.0207,
+      "log_good": -5.0515
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1056,
+      "good": 1.0971,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.2237,
+      "log_bad": 0.1004,
+      "log_good": 0.0927
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 83.0,
+      "good": 83.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.4188,
+      "log_good": 4.4188
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.5355,
+      "good": 104.7286,
+      "ratio": 1.0018,
+      "suggested_scalar": 0.0535,
+      "log_bad": 4.6495,
+      "log_good": 4.6514
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5962,
+      "good": 0.6005,
+      "ratio": 1.0072,
+      "suggested_scalar": 0.2083,
+      "log_bad": -0.5172,
+      "log_good": -0.51
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 4.965,
+      "good": 4.965,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6024,
+      "log_good": 1.6024
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1371.0,
+      "good": 1407.0,
+      "ratio": 1.0263,
+      "suggested_scalar": 0.7514,
+      "log_bad": 7.2233,
+      "log_good": 7.2492
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0769,
+      "good": 0.0769,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.5652,
+      "log_good": -2.5652
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7885,
+      "good": 0.7885,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2376,
+      "log_good": -0.2376
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.0192,
+      "good": 7.0962,
+      "ratio": 1.011,
+      "suggested_scalar": 0.3163,
+      "log_bad": 1.9486,
+      "log_good": 1.9596
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.8328,
+      "good": 2.8328,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0413,
+      "log_good": 1.0413
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 55.0,
+      "good": 55.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0073,
+      "log_good": 4.0073
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.94,
+      "good": 0.9392,
+      "ratio": 0.9991,
+      "suggested_scalar": -0.0247,
+      "log_bad": -0.0619,
+      "log_good": -0.0627
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6163,
+      "good": 0.6198,
+      "ratio": 1.0057,
+      "suggested_scalar": 0.1642,
+      "log_bad": -0.484,
+      "log_good": -0.4784
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3416,
+      "good": 0.346,
+      "ratio": 1.0129,
+      "suggested_scalar": 0.371,
+      "log_bad": -1.0741,
+      "log_good": -1.0613
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6065,
+      "good": 2.6299,
+      "ratio": 1.009,
+      "suggested_scalar": 0.2591,
+      "log_bad": 0.958,
+      "log_good": 0.9669
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 363.0,
+      "good": 367.0,
+      "ratio": 1.011,
+      "suggested_scalar": 0.3177,
+      "log_bad": 5.8944,
+      "log_good": 5.9054
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0466,
+      "good": 0.0461,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.3127,
+      "log_bad": -3.0662,
+      "log_good": -3.0769
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8074,
+      "good": 5.8074,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7591,
+      "log_good": 1.7591
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2483,
+      "good": 1.2483,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2218,
+      "log_good": 0.2218
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.2071,
+      "good": 5.237,
+      "ratio": 1.0057,
+      "suggested_scalar": 0.166,
+      "log_bad": 1.65,
+      "log_good": 1.6557
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8068,
+      "good": 0.8074,
+      "ratio": 1.0007,
+      "suggested_scalar": 0.0216,
+      "log_bad": -0.2147,
+      "log_good": -0.2139
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1475,
+      "good": 0.1475,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.9139,
+      "log_good": -1.9139
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.2282,
+      "good": 2.2282,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.8012,
+      "log_good": 0.8012
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 281.0,
+      "good": 283.0,
+      "ratio": 1.0071,
+      "suggested_scalar": 0.2056,
+      "log_bad": 5.6384,
+      "log_good": 5.6454
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7082,
+      "good": 0.7188,
+      "ratio": 1.015,
+      "suggested_scalar": 0.4307,
+      "log_bad": -0.345,
+      "log_good": -0.3302
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 70.0,
+      "good": 71.0,
+      "ratio": 1.0143,
+      "suggested_scalar": 0.4112,
+      "log_bad": 4.2485,
+      "log_good": 4.2627
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 480.0,
+      "good": 480.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.1738,
+      "log_good": 6.1738
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 135.0,
+      "good": 139.0,
+      "ratio": 1.0296,
+      "suggested_scalar": 0.8464,
+      "log_bad": 4.9053,
+      "log_good": 4.9345
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2877,
+      "good": 0.2846,
+      "ratio": 0.9892,
+      "suggested_scalar": -0.314,
+      "log_bad": -1.2458,
+      "log_good": -1.2567
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 59.0,
+      "good": 60.0,
+      "ratio": 1.0169,
+      "suggested_scalar": 0.4872,
+      "log_bad": 4.0775,
+      "log_good": 4.0943
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 70.0,
+      "good": 71.0,
+      "ratio": 1.0143,
+      "suggested_scalar": 0.4112,
+      "log_bad": 4.2485,
+      "log_good": 4.2627
+    },
+    "brevity.mean_sample_size": {
+      "bad": 70.0,
+      "good": 71.0,
+      "ratio": 1.0143,
+      "suggested_scalar": 0.4112,
+      "log_bad": 4.2485,
+      "log_good": 4.2627
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 365.0,
+      "good": 369.0,
+      "ratio": 1.011,
+      "suggested_scalar": 0.316,
+      "log_bad": 5.8999,
+      "log_good": 5.9108
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 209.0,
+      "good": 209.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.3423,
+      "log_good": 5.3423
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 206.0,
+      "good": 207.0,
+      "ratio": 1.0049,
+      "suggested_scalar": 0.1404,
+      "log_bad": 5.3279,
+      "log_good": 5.3327
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.011,
+      "good": 0.0108,
+      "ratio": 0.9818,
+      "suggested_scalar": -0.5319,
+      "log_bad": -4.5099,
+      "log_good": -4.5282
+    },
+    "heaps.mean_k": {
+      "bad": 2.3067,
+      "good": 2.2651,
+      "ratio": 0.982,
+      "suggested_scalar": -0.5276,
+      "log_bad": 0.8358,
+      "log_good": 0.8176
+    },
+    "halstead.mean_effort": {
+      "bad": 78221.1305,
+      "good": 79927.1919,
+      "ratio": 1.0218,
+      "suggested_scalar": 0.6255,
+      "log_bad": 11.2673,
+      "log_good": 11.2889
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8495,
+      "good": 0.8516,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0716,
+      "log_bad": -0.1631,
+      "log_good": -0.1606
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 44.0,
+      "good": 45.0,
+      "ratio": 1.0227,
+      "suggested_scalar": 0.6515,
+      "log_bad": 3.7842,
+      "log_good": 3.8067
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 214.0,
+      "good": 214.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.366,
+      "log_good": 5.366
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3253,
+      "good": 0.3253,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.123,
+      "log_good": -1.123
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.7831,
+      "good": 5.7831,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7549,
+      "log_good": 1.7549
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1475,
+      "good": 0.1475,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.9139,
+      "log_good": -1.9139
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.8077,
+      "good": 2.8385,
+      "ratio": 1.011,
+      "suggested_scalar": 0.3163,
+      "log_bad": 1.0324,
+      "log_good": 1.0433
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 364.0,
+      "good": 368.0,
+      "ratio": 1.011,
+      "suggested_scalar": 0.3168,
+      "log_bad": 5.8972,
+      "log_good": 5.9081
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 42.0,
+      "good": 43.0,
+      "ratio": 1.0238,
+      "suggested_scalar": 0.6821,
+      "log_bad": 3.7377,
+      "log_good": 3.7612
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4345.6184,
+      "good": 4440.3995,
+      "ratio": 1.0218,
+      "suggested_scalar": 0.6255,
+      "log_bad": 8.3769,
+      "log_good": 8.3985
+    },
+    "readability.mean_total_lines": {
+      "bad": 52.0,
+      "good": 52.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9512,
+      "log_good": 3.9512
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2124.5245,
+      "good": 2156.3091,
+      "ratio": 1.015,
+      "suggested_scalar": 0.4305,
+      "log_bad": 7.6613,
+      "log_good": 7.6762
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 526.0,
+      "good": 535.0,
+      "ratio": 1.0171,
+      "suggested_scalar": 0.4918,
+      "log_bad": 6.2653,
+      "log_good": 6.2823
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 25.1923,
+      "good": 25.8846,
+      "ratio": 1.0275,
+      "suggested_scalar": 0.7859,
+      "log_bad": 3.2265,
+      "log_good": 3.2536
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.125,
+      "good": 1.1218,
+      "ratio": 0.9972,
+      "suggested_scalar": -0.0826,
+      "log_bad": 0.1178,
+      "log_good": 0.1149
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 35.0,
+      "good": 35.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5553,
+      "log_good": 3.5553
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8505,
+      "good": 0.8481,
+      "ratio": 0.9972,
+      "suggested_scalar": -0.0819,
+      "log_bad": -0.1619,
+      "log_good": -0.1648
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9903,
+      "good": 0.9903,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0097,
+      "log_good": -0.0097
+    },
+    "halstead.mean_length": {
+      "bad": 349.0,
+      "good": 353.0,
+      "ratio": 1.0115,
+      "suggested_scalar": 0.3304,
+      "log_bad": 5.8551,
+      "log_good": 5.8665
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.1293,
+      "good": 6.1497,
+      "ratio": 1.0033,
+      "suggested_scalar": 0.0963,
+      "log_bad": 1.8131,
+      "log_good": 1.8164
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1524,
+      "good": 0.1485,
+      "ratio": 0.9744,
+      "suggested_scalar": -0.7515,
+      "log_bad": -1.8812,
+      "log_good": -1.9072
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 36.8182,
+      "good": 37.0667,
+      "ratio": 1.0067,
+      "suggested_scalar": 0.195,
+      "log_bad": 3.606,
+      "log_good": 3.6127
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7136,
+      "good": 0.7101,
+      "ratio": 0.9951,
+      "suggested_scalar": -0.1425,
+      "log_bad": -0.3374,
+      "log_good": -0.3423
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 52.0,
+      "good": 52.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9512,
+      "log_good": 3.9512
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.move_constructors_are_noexcept": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0017,
+      "good": 0.0018,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.3974,
+      "log_bad": -6.3771,
+      "log_good": -6.32
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8219,
+      "good": 0.8286,
+      "ratio": 1.0082,
+      "suggested_scalar": 0.0564,
+      "log_bad": -0.1961,
+      "log_good": -0.188
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0017,
+      "good": 0.0018,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.3974,
+      "log_bad": -6.3771,
+      "log_good": -6.32
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6033,
+      "good": 4.5959,
+      "ratio": 0.9984,
+      "suggested_scalar": -0.0112,
+      "log_bad": 1.5268,
+      "log_good": 1.5252
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 100.0,
+      "good": 96.0,
+      "ratio": 0.96,
+      "suggested_scalar": -0.2838,
+      "log_bad": 4.6052,
+      "log_good": 4.5643
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.2647,
+      "good": 0.2469,
+      "ratio": 0.9328,
+      "suggested_scalar": -0.484,
+      "log_bad": -1.3292,
+      "log_good": -1.3988
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6034,
+      "good": 0.5963,
+      "ratio": 0.9882,
+      "suggested_scalar": -0.0823,
+      "log_bad": -0.5052,
+      "log_good": -0.517
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.6986,
+      "good": 5.7714,
+      "ratio": 1.0128,
+      "suggested_scalar": 0.0883,
+      "log_bad": 1.7402,
+      "log_good": 1.7529
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 582.0,
+      "good": 555.0,
+      "ratio": 0.9536,
+      "suggested_scalar": -0.3302,
+      "log_bad": 6.3665,
+      "log_good": 6.319
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0008,
+      "good": 0.0009,
+      "ratio": 1.125,
+      "suggested_scalar": 0.8188,
+      "log_bad": -7.1309,
+      "log_good": -7.0131
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1507,
+      "good": 0.1286,
+      "ratio": 0.8534,
+      "suggested_scalar": -1.1025,
+      "log_bad": -1.8925,
+      "log_good": -2.051
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1614,
+      "good": 1.1704,
+      "ratio": 1.0077,
+      "suggested_scalar": 0.0537,
+      "log_bad": 0.1496,
+      "log_good": 0.1573
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 202.0,
+      "good": 186.0,
+      "ratio": 0.9208,
+      "suggested_scalar": -0.5737,
+      "log_bad": 5.3083,
+      "log_good": 5.2257
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 106.3058,
+      "good": 105.8135,
+      "ratio": 0.9954,
+      "suggested_scalar": -0.0323,
+      "log_bad": 4.6663,
+      "log_good": 4.6617
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7194,
+      "good": 0.7365,
+      "ratio": 1.0238,
+      "suggested_scalar": 0.1633,
+      "log_bad": -0.3293,
+      "log_good": -0.3058
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 6.8714,
+      "good": 6.7516,
+      "ratio": 0.9826,
+      "suggested_scalar": -0.1223,
+      "log_bad": 1.9274,
+      "log_good": 1.9098
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2493.0,
+      "good": 2354.0,
+      "ratio": 0.9442,
+      "suggested_scalar": -0.3988,
+      "log_bad": 7.8212,
+      "log_good": 7.7639
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0685,
+      "good": 0.0857,
+      "ratio": 1.2511,
+      "suggested_scalar": 1.5574,
+      "log_bad": -2.6809,
+      "log_good": -2.4569
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7671,
+      "good": 0.7714,
+      "ratio": 1.0056,
+      "suggested_scalar": 0.0389,
+      "log_bad": -0.2651,
+      "log_good": -0.2595
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.5588,
+      "good": 8.5385,
+      "ratio": 0.9976,
+      "suggested_scalar": -0.0165,
+      "log_bad": 2.147,
+      "log_good": 2.1446
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 51.0,
+      "good": 51.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9318,
+      "log_good": 3.9318
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 14.4297,
+      "good": 14.9192,
+      "ratio": 1.0339,
+      "suggested_scalar": 0.2319,
+      "log_bad": 2.6693,
+      "log_good": 2.7026
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 131.0,
+      "good": 116.0,
+      "ratio": 0.8855,
+      "suggested_scalar": -0.8454,
+      "log_bad": 4.8752,
+      "log_good": 4.7536
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9315,
+      "good": 0.929,
+      "ratio": 0.9973,
+      "suggested_scalar": -0.0187,
+      "log_bad": -0.071,
+      "log_good": -0.0736
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 28.0,
+      "ratio": 0.9655,
+      "suggested_scalar": -0.244,
+      "log_bad": 3.3673,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6807,
+      "good": 0.6801,
+      "ratio": 0.9991,
+      "suggested_scalar": -0.0061,
+      "log_bad": -0.3846,
+      "log_good": -0.3855
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5672,
+      "good": 0.5877,
+      "ratio": 1.0361,
+      "suggested_scalar": 0.2468,
+      "log_bad": -0.567,
+      "log_good": -0.5315
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.1319,
+      "good": 3.1262,
+      "ratio": 0.9982,
+      "suggested_scalar": -0.0127,
+      "log_bad": 1.1416,
+      "log_good": 1.1398
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 580.0,
+      "good": 553.0,
+      "ratio": 0.9534,
+      "suggested_scalar": -0.3314,
+      "log_bad": 6.363,
+      "log_good": 6.3154
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0395,
+      "good": 0.0396,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0176,
+      "log_bad": -3.2315,
+      "log_good": -3.2289
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.9307,
+      "ratio": 0.9961,
+      "suggested_scalar": -0.0275,
+      "log_bad": 1.7841,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 16.0,
+      "good": 15.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.4487,
+      "log_bad": 2.7726,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3083,
+      "good": 1.3487,
+      "ratio": 1.0309,
+      "suggested_scalar": 0.2114,
+      "log_bad": 0.2687,
+      "log_good": 0.2991
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6043,
+      "good": 5.5391,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0814,
+      "log_bad": 1.7235,
+      "log_good": 1.7118
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7731,
+      "good": 0.7749,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0162,
+      "log_bad": -0.2573,
+      "log_good": -0.255
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1098,
+      "good": 0.1139,
+      "ratio": 1.0373,
+      "suggested_scalar": 0.2549,
+      "log_bad": -2.2091,
+      "log_good": -2.1724
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.6213,
+      "good": 2.5984,
+      "ratio": 0.9913,
+      "suggested_scalar": -0.061,
+      "log_bad": 0.9637,
+      "log_good": 0.9549
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 363.0,
+      "good": 339.0,
+      "ratio": 0.9339,
+      "suggested_scalar": -0.4755,
+      "log_bad": 5.8944,
+      "log_good": 5.826
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.2601,
+      "good": 1.1875,
+      "ratio": 0.9424,
+      "suggested_scalar": -0.4125,
+      "log_bad": 0.2312,
+      "log_good": 0.1719
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 102.0,
+      "good": 98.0,
+      "ratio": 0.9608,
+      "suggested_scalar": -0.2781,
+      "log_bad": 4.625,
+      "log_good": 4.585
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1232.0,
+      "good": 1131.0,
+      "ratio": 0.918,
+      "suggested_scalar": -0.5947,
+      "log_bad": 7.1164,
+      "log_good": 7.0309
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 239.0,
+      "good": 224.0,
+      "ratio": 0.9372,
+      "suggested_scalar": -0.4506,
+      "log_bad": 5.4765,
+      "log_good": 5.4116
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2577,
+      "good": 0.2667,
+      "ratio": 1.0349,
+      "suggested_scalar": 0.2387,
+      "log_bad": -1.356,
+      "log_good": -1.3216
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 105.0,
+      "good": 104.0,
+      "ratio": 0.9905,
+      "suggested_scalar": -0.0665,
+      "log_bad": 4.654,
+      "log_good": 4.6444
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 102.0,
+      "good": 98.0,
+      "ratio": 0.9608,
+      "suggested_scalar": -0.2781,
+      "log_bad": 4.625,
+      "log_good": 4.585
+    },
+    "brevity.mean_sample_size": {
+      "bad": 102.0,
+      "good": 98.0,
+      "ratio": 0.9608,
+      "suggested_scalar": -0.2781,
+      "log_bad": 4.625,
+      "log_good": 4.585
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 582.0,
+      "good": 555.0,
+      "ratio": 0.9536,
+      "suggested_scalar": -0.3302,
+      "log_bad": 6.3665,
+      "log_good": 6.319
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 316.0,
+      "good": 306.0,
+      "ratio": 0.9684,
+      "suggested_scalar": -0.2236,
+      "log_bad": 5.7557,
+      "log_good": 5.7236
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 268.0,
+      "good": 250.0,
+      "ratio": 0.9328,
+      "suggested_scalar": -0.4834,
+      "log_bad": 5.591,
+      "log_good": 5.5215
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0052,
+      "good": 0.0054,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.2624,
+      "log_bad": -5.2591,
+      "log_good": -5.2214
+    },
+    "heaps.mean_k": {
+      "bad": 2.2305,
+      "good": 2.223,
+      "ratio": 0.9966,
+      "suggested_scalar": -0.0234,
+      "log_bad": 0.8022,
+      "log_good": 0.7989
+    },
+    "halstead.mean_effort": {
+      "bad": 184518.5547,
+      "good": 164292.4903,
+      "ratio": 0.8904,
+      "suggested_scalar": -0.8072,
+      "log_bad": 12.1255,
+      "log_good": 12.0094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8399,
+      "good": 0.8374,
+      "ratio": 0.997,
+      "suggested_scalar": -0.0207,
+      "log_bad": -0.1745,
+      "log_good": -0.1775
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 71.0,
+      "good": 68.0,
+      "ratio": 0.9577,
+      "suggested_scalar": -0.3001,
+      "log_bad": 4.2627,
+      "log_good": 4.2195
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 330.0,
+      "good": 317.0,
+      "ratio": 0.9606,
+      "suggested_scalar": -0.2794,
+      "log_bad": 5.7991,
+      "log_good": 5.7589
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.2772,
+      "good": 0.2849,
+      "ratio": 1.0278,
+      "suggested_scalar": 0.1905,
+      "log_bad": -1.283,
+      "log_good": -1.2556
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.099,
+      "good": 6.0806,
+      "ratio": 0.997,
+      "suggested_scalar": -0.021,
+      "log_bad": 1.8081,
+      "log_good": 1.8051
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1098,
+      "good": 0.1139,
+      "ratio": 1.0373,
+      "suggested_scalar": 0.2549,
+      "log_bad": -2.2091,
+      "log_good": -2.1724
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.5792,
+      "good": 3.5821,
+      "ratio": 1.0008,
+      "suggested_scalar": 0.0056,
+      "log_bad": 1.2751,
+      "log_good": 1.2759
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 581.0,
+      "good": 554.0,
+      "ratio": 0.9535,
+      "suggested_scalar": -0.3308,
+      "log_bad": 6.3648,
+      "log_good": 6.3172
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 112.0,
+      "good": 111.0,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.0624,
+      "log_bad": 4.7185,
+      "log_good": 4.7095
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 10251.0308,
+      "good": 9127.3606,
+      "ratio": 0.8904,
+      "suggested_scalar": -0.8072,
+      "log_bad": 9.2351,
+      "log_good": 9.119
+    },
+    "readability.mean_total_lines": {
+      "bad": 68.0,
+      "good": 65.0,
+      "ratio": 0.9559,
+      "suggested_scalar": -0.3137,
+      "log_bad": 4.2195,
+      "log_good": 4.1744
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 3780.3542,
+      "good": 3562.4647,
+      "ratio": 0.9424,
+      "suggested_scalar": -0.4127,
+      "log_bad": 8.2376,
+      "log_good": 8.1782
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 796.0,
+      "good": 753.0,
+      "ratio": 0.946,
+      "suggested_scalar": -0.3861,
+      "log_bad": 6.6796,
+      "log_good": 6.6241
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 34.1029,
+      "good": 33.5538,
+      "ratio": 0.9839,
+      "suggested_scalar": -0.1128,
+      "log_bad": 3.5294,
+      "log_good": 3.5132
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0856,
+      "good": 1.0917,
+      "ratio": 1.0056,
+      "suggested_scalar": 0.039,
+      "log_bad": 0.0821,
+      "log_good": 0.0877
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 11.0,
+      "good": 9.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -1.3951,
+      "log_bad": 2.3979,
+      "log_good": 2.1972
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6915,
+      "good": 0.6726,
+      "ratio": 0.9727,
+      "suggested_scalar": -0.1927,
+      "log_bad": -0.3689,
+      "log_good": -0.3966
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9026,
+      "good": 0.9096,
+      "ratio": 1.0078,
+      "suggested_scalar": 0.0537,
+      "log_bad": -0.1025,
+      "log_good": -0.0948
+    },
+    "halstead.mean_length": {
+      "bad": 569.0,
+      "good": 541.0,
+      "ratio": 0.9508,
+      "suggested_scalar": -0.3508,
+      "log_bad": 6.3439,
+      "log_good": 6.2934
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6724,
+      "good": 6.6147,
+      "ratio": 0.9914,
+      "suggested_scalar": -0.0604,
+      "log_bad": 1.898,
+      "log_good": 1.8893
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1269,
+      "good": 0.1302,
+      "ratio": 1.026,
+      "suggested_scalar": 0.1785,
+      "log_bad": -2.0644,
+      "log_good": -2.0387
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 48.8099,
+      "good": 46.1176,
+      "ratio": 0.9448,
+      "suggested_scalar": -0.3945,
+      "log_bad": 3.8879,
+      "log_good": 3.8312
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 1.2675,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 56.0,
+      "good": 53.0,
+      "ratio": 0.9464,
+      "suggested_scalar": -0.3828,
+      "log_bad": 4.0254,
+      "log_good": 3.9703
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6082,
+      "good": 0.584,
+      "ratio": 0.9602,
+      "suggested_scalar": -0.2823,
+      "log_bad": -0.4973,
+      "log_good": -0.5379
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 73.0,
+      "good": 70.0,
+      "ratio": 0.9589,
+      "suggested_scalar": -0.2917,
+      "log_bad": 4.2905,
+      "log_good": 4.2485
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.uses_checked_arithmetic": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 4.0,
+      "good": 8.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2035,
+      "log_bad": 1.3863,
+      "log_good": 2.0794
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 0.0076,
+      "ratio": 0.0076,
+      "suggested_scalar": -1.4326,
+      "log_bad": 0.0,
+      "log_good": -4.8796
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 1.3333,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0346,
+      "log_bad": 0.4055,
+      "log_good": 0.2877
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8235,
+      "good": 0.8361,
+      "ratio": 1.0153,
+      "suggested_scalar": 0.0045,
+      "log_bad": -0.1942,
+      "log_good": -0.179
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 0.0076,
+      "ratio": 0.0076,
+      "suggested_scalar": -1.4326,
+      "log_bad": 0.0,
+      "log_good": -4.8796
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6798,
+      "good": 4.5822,
+      "ratio": 0.9791,
+      "suggested_scalar": -0.0062,
+      "log_bad": 1.5433,
+      "log_good": 1.5222
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 91.0,
+      "good": 86.0,
+      "ratio": 0.9451,
+      "suggested_scalar": -0.0166,
+      "log_bad": 4.5109,
+      "log_good": 4.4543
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6452,
+      "good": 0.4743,
+      "ratio": 0.7351,
+      "suggested_scalar": -0.0903,
+      "log_bad": -0.4382,
+      "log_good": -0.7459
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 23.0,
+      "ratio": 1.2105,
+      "suggested_scalar": 0.0561,
+      "log_bad": 2.9444,
+      "log_good": 3.1355
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7547,
+      "good": 0.5928,
+      "ratio": 0.7855,
+      "suggested_scalar": -0.0709,
+      "log_bad": -0.2814,
+      "log_good": -0.5229
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.4706,
+      "good": 7.0164,
+      "ratio": 1.5695,
+      "suggested_scalar": 0.1323,
+      "log_bad": 1.4975,
+      "log_good": 1.9483
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 258.0,
+      "good": 394.0,
+      "ratio": 1.5271,
+      "suggested_scalar": 0.1243,
+      "log_bad": 5.553,
+      "log_good": 5.9764
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.119,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 0.0016,
+      "ratio": 0.0016,
+      "suggested_scalar": -1.89,
+      "log_bad": 0.0,
+      "log_good": -6.4378
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1765,
+      "good": 0.0492,
+      "ratio": 0.2788,
+      "suggested_scalar": -0.375,
+      "log_bad": -1.7344,
+      "log_good": -3.0119
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 0.0011,
+      "ratio": 0.0011,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.8124
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8354,
+      "good": 0.948,
+      "ratio": 1.1348,
+      "suggested_scalar": 0.0371,
+      "log_bad": -0.1798,
+      "log_good": -0.0534
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 93.0,
+      "good": 120.0,
+      "ratio": 1.2903,
+      "suggested_scalar": 0.0748,
+      "log_bad": 4.5326,
+      "log_good": 4.7875
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 99.2668,
+      "good": 87.9489,
+      "ratio": 0.886,
+      "suggested_scalar": -0.0355,
+      "log_bad": 4.5978,
+      "log_good": 4.4768
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4553,
+      "good": 0.5369,
+      "ratio": 1.1792,
+      "suggested_scalar": 0.0484,
+      "log_bad": -0.7868,
+      "log_good": -0.6219
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 12.702,
+      "good": 19.6364,
+      "ratio": 1.5459,
+      "suggested_scalar": 0.1279,
+      "log_bad": 2.5418,
+      "log_good": 2.9774
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1216.0,
+      "good": 1892.0,
+      "ratio": 1.5559,
+      "suggested_scalar": 0.1298,
+      "log_bad": 7.1033,
+      "log_good": 7.5454
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0294,
+      "good": 0.0656,
+      "ratio": 2.2313,
+      "suggested_scalar": 0.2356,
+      "log_bad": -3.5268,
+      "log_good": -2.7242
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7941,
+      "good": 0.7705,
+      "ratio": 0.9703,
+      "suggested_scalar": -0.0089,
+      "log_bad": -0.2305,
+      "log_good": -0.2607
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.5882,
+      "good": 6.678,
+      "ratio": 0.8801,
+      "suggested_scalar": -0.0375,
+      "log_bad": 2.0266,
+      "log_good": 1.8988
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 13.0,
+      "good": 10.0,
+      "ratio": 0.7692,
+      "suggested_scalar": -0.077,
+      "log_bad": 2.5649,
+      "log_good": 2.3026
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 9.1903,
+      "good": 31.8194,
+      "ratio": 3.4623,
+      "suggested_scalar": 0.3646,
+      "log_bad": 2.2181,
+      "log_good": 3.4601
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 67.0,
+      "good": 72.0,
+      "ratio": 1.0746,
+      "suggested_scalar": 0.0211,
+      "log_bad": 4.2047,
+      "log_good": 4.2767
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9265,
+      "good": 0.9509,
+      "ratio": 1.0263,
+      "suggested_scalar": 0.0076,
+      "log_bad": -0.0763,
+      "log_good": -0.0503
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 30.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0535,
+      "log_bad": 3.2189,
+      "log_good": 3.4012
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5609,
+      "good": 0.649,
+      "ratio": 1.1571,
+      "suggested_scalar": 0.0428,
+      "log_bad": -0.5782,
+      "log_good": -0.4323
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2461,
+      "good": 0.3214,
+      "ratio": 1.306,
+      "suggested_scalar": 0.0784,
+      "log_bad": -1.402,
+      "log_good": -1.1351
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2772,
+      "good": 2.8494,
+      "ratio": 1.2513,
+      "suggested_scalar": 0.0658,
+      "log_bad": 0.8229,
+      "log_good": 1.0471
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 256.0,
+      "good": 392.0,
+      "ratio": 1.5313,
+      "suggested_scalar": 0.1251,
+      "log_bad": 5.5452,
+      "log_good": 5.9713
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 13.0,
+      "good": 21.0,
+      "ratio": 1.6154,
+      "suggested_scalar": 0.1408,
+      "log_bad": 2.5649,
+      "log_good": 3.0445
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.031,
+      "good": 0.0508,
+      "ratio": 1.6387,
+      "suggested_scalar": 0.145,
+      "log_bad": -3.4738,
+      "log_good": -2.9799
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 6.0444,
+      "ratio": 1.0151,
+      "suggested_scalar": 0.0044,
+      "log_bad": 1.7841,
+      "log_good": 1.7991
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 13.0,
+      "good": 38.0,
+      "ratio": 2.9231,
+      "suggested_scalar": 0.3149,
+      "log_bad": 2.5649,
+      "log_good": 3.6376
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1344,
+      "good": 1.2663,
+      "ratio": 1.1163,
+      "suggested_scalar": 0.0323,
+      "log_bad": 0.1261,
+      "log_good": 0.2361
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9092,
+      "good": 5.7313,
+      "ratio": 0.9699,
+      "suggested_scalar": -0.009,
+      "log_bad": 1.7765,
+      "log_good": 1.7459
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.786,
+      "good": 0.7581,
+      "ratio": 0.9645,
+      "suggested_scalar": -0.0106,
+      "log_bad": -0.2408,
+      "log_good": -0.2769
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1707,
+      "good": 0.1159,
+      "ratio": 0.679,
+      "suggested_scalar": -0.1137,
+      "log_bad": -1.7678,
+      "log_good": -2.155
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.564,
+      "good": 4.4313,
+      "ratio": 1.2434,
+      "suggested_scalar": 0.0639,
+      "log_bad": 1.2709,
+      "log_good": 1.4887
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2035,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 220.0,
+      "good": 320.0,
+      "ratio": 1.4545,
+      "suggested_scalar": 0.11,
+      "log_bad": 5.3936,
+      "log_good": 5.7683
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 8.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2035,
+      "log_bad": 1.3863,
+      "log_good": 2.0794
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5293,
+      "good": 0.7712,
+      "ratio": 1.457,
+      "suggested_scalar": 0.1105,
+      "log_bad": -0.6362,
+      "log_good": -0.2598
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 93.0,
+      "good": 95.0,
+      "ratio": 1.0215,
+      "suggested_scalar": 0.0062,
+      "log_bad": 4.5326,
+      "log_good": 4.5539
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 618.0,
+      "good": 886.0,
+      "ratio": 1.4337,
+      "suggested_scalar": 0.1058,
+      "log_bad": 6.4265,
+      "log_good": 6.7867
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 112.0,
+      "good": 129.0,
+      "ratio": 1.1518,
+      "suggested_scalar": 0.0415,
+      "log_bad": 4.7185,
+      "log_good": 4.8598
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0155,
+      "good": 0.0152,
+      "ratio": 0.9806,
+      "suggested_scalar": -0.0057,
+      "log_bad": -4.1669,
+      "log_good": -4.1865
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1705,
+      "good": 0.2411,
+      "ratio": 1.4141,
+      "suggested_scalar": 0.1017,
+      "log_bad": -1.769,
+      "log_good": -1.4225
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 40.0,
+      "good": 75.0,
+      "ratio": 1.875,
+      "suggested_scalar": 0.1845,
+      "log_bad": 3.6889,
+      "log_good": 4.3175
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0845,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 93.0,
+      "good": 95.0,
+      "ratio": 1.0215,
+      "suggested_scalar": 0.0062,
+      "log_bad": 4.5326,
+      "log_good": 4.5539
+    },
+    "brevity.mean_sample_size": {
+      "bad": 93.0,
+      "good": 95.0,
+      "ratio": 1.0215,
+      "suggested_scalar": 0.0062,
+      "log_bad": 4.5326,
+      "log_good": 4.5539
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 258.0,
+      "good": 394.0,
+      "ratio": 1.5271,
+      "suggested_scalar": 0.1243,
+      "log_bad": 5.553,
+      "log_good": 5.9764
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 115.0,
+      "good": 220.0,
+      "ratio": 1.913,
+      "suggested_scalar": 0.1904,
+      "log_bad": 4.7449,
+      "log_good": 5.3936
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 180.0,
+      "good": 257.0,
+      "ratio": 1.4278,
+      "suggested_scalar": 0.1045,
+      "log_bad": 5.193,
+      "log_good": 5.5491
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0039,
+      "good": 0.0051,
+      "ratio": 1.3077,
+      "suggested_scalar": 0.0788,
+      "log_bad": -5.5468,
+      "log_good": -5.2785
+    },
+    "heaps.mean_k": {
+      "bad": 1.4976,
+      "good": 2.8818,
+      "ratio": 1.9243,
+      "suggested_scalar": 0.1922,
+      "log_bad": 0.4039,
+      "log_good": 1.0584
+    },
+    "halstead.mean_effort": {
+      "bad": 33682.7674,
+      "good": 79938.1434,
+      "ratio": 2.3733,
+      "suggested_scalar": 0.2537,
+      "log_bad": 10.4247,
+      "log_good": 11.289
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.9037,
+      "good": 0.8724,
+      "ratio": 0.9654,
+      "suggested_scalar": -0.0103,
+      "log_bad": -0.1013,
+      "log_good": -0.1365
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 66.0,
+      "good": 56.0,
+      "ratio": 0.8485,
+      "suggested_scalar": -0.0482,
+      "log_bad": 4.1897,
+      "log_good": 4.0254
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 132.0,
+      "good": 231.0,
+      "ratio": 1.75,
+      "suggested_scalar": 0.1643,
+      "log_bad": 4.8828,
+      "log_good": 5.4424
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.6452,
+      "good": 0.4333,
+      "ratio": 0.6716,
+      "suggested_scalar": -0.1169,
+      "log_bad": -0.4382,
+      "log_good": -0.8363
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.6452,
+      "good": 7.3833,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0309,
+      "log_bad": 1.8939,
+      "log_good": 1.9992
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1707,
+      "good": 0.1159,
+      "ratio": 0.679,
+      "suggested_scalar": -0.1137,
+      "log_bad": -1.7678,
+      "log_good": -2.155
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.2383,
+      "good": 4.8798,
+      "ratio": 1.1514,
+      "suggested_scalar": 0.0414,
+      "log_bad": 1.4442,
+      "log_good": 1.5851
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 257.0,
+      "good": 393.0,
+      "ratio": 1.5292,
+      "suggested_scalar": 0.1247,
+      "log_bad": 5.5491,
+      "log_good": 5.9738
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 0.4725,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 27.0,
+      "good": 54.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2035,
+      "log_bad": 3.2958,
+      "log_good": 3.989
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1871.2649,
+      "good": 4441.008,
+      "ratio": 2.3733,
+      "suggested_scalar": 0.2537,
+      "log_bad": 7.5344,
+      "log_good": 8.3986
+    },
+    "readability.mean_total_lines": {
+      "bad": 34.0,
+      "good": 59.0,
+      "ratio": 1.7353,
+      "suggested_scalar": 0.1618,
+      "log_bad": 3.5264,
+      "log_good": 4.0775
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 20.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.269,
+      "log_bad": 2.0794,
+      "log_good": 2.9957
+    },
+    "halstead.mean_volume": {
+      "bad": 1587.9019,
+      "good": 2313.4553,
+      "ratio": 1.4569,
+      "suggested_scalar": 0.1105,
+      "log_bad": 7.3702,
+      "log_good": 7.7465
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 534.0,
+      "good": 664.0,
+      "ratio": 1.2434,
+      "suggested_scalar": 0.064,
+      "log_bad": 6.2804,
+      "log_good": 6.4983
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 34.4412,
+      "good": 30.3559,
+      "ratio": 0.8814,
+      "suggested_scalar": -0.0371,
+      "log_bad": 3.5393,
+      "log_good": 3.413
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1805,
+      "good": 1.3252,
+      "ratio": 1.1226,
+      "suggested_scalar": 0.0339,
+      "log_bad": 0.1659,
+      "log_good": 0.2816
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.119,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 11.0,
+      "good": 19.0,
+      "ratio": 1.7273,
+      "suggested_scalar": 0.1605,
+      "log_bad": 2.3979,
+      "log_good": 2.9444
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 3.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2035,
+      "log_bad": 1.7918,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8773,
+      "good": 0.8313,
+      "ratio": 0.9476,
+      "suggested_scalar": -0.0158,
+      "log_bad": -0.1309,
+      "log_good": -0.1848
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9839,
+      "good": 0.981,
+      "ratio": 0.9971,
+      "suggested_scalar": -0.0009,
+      "log_bad": -0.0162,
+      "log_good": -0.0192
+    },
+    "halstead.mean_length": {
+      "bad": 244.0,
+      "good": 360.0,
+      "ratio": 1.4754,
+      "suggested_scalar": 0.1142,
+      "log_bad": 5.4972,
+      "log_good": 5.8861
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 8.5,
+      "good": 19.6667,
+      "ratio": 2.3137,
+      "suggested_scalar": 0.2463,
+      "log_bad": 2.1401,
+      "log_good": 2.9789
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5392,
+      "good": 6.5699,
+      "ratio": 1.0047,
+      "suggested_scalar": 0.0014,
+      "log_bad": 1.8778,
+      "log_good": 1.8825
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0949,
+      "good": 0.1163,
+      "ratio": 1.2255,
+      "suggested_scalar": 0.0597,
+      "log_bad": -2.3549,
+      "log_good": -2.1516
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 21.2121,
+      "good": 34.5536,
+      "ratio": 1.629,
+      "suggested_scalar": 0.1432,
+      "log_bad": 3.0546,
+      "log_good": 3.5425
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 0.407,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 60.0,
+      "good": 52.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.042,
+      "log_bad": 4.0943,
+      "log_good": 3.9512
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7778,
+      "good": 0.7082,
+      "ratio": 0.9105,
+      "suggested_scalar": -0.0275,
+      "log_bad": -0.2513,
+      "log_good": -0.345
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 34.0,
+      "good": 61.0,
+      "ratio": 1.7941,
+      "suggested_scalar": 0.1716,
+      "log_bad": 3.5264,
+      "log_good": 4.1109
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 18.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0346,
+      "log_bad": 2.7726,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_dead_code_after_return": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 54.0,
+      "good": 38.0,
+      "ratio": 0.7037,
+      "suggested_scalar": -0.3612,
+      "log_bad": 3.989,
+      "log_good": 3.6376
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0056,
+      "good": 0.0025,
+      "ratio": 0.4464,
+      "suggested_scalar": -0.8289,
+      "log_bad": -5.185,
+      "log_good": -5.9915
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1053,
+      "good": 1.2353,
+      "ratio": 1.1176,
+      "suggested_scalar": 0.1143,
+      "log_bad": 0.1001,
+      "log_good": 0.2113
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8519,
+      "good": 0.8478,
+      "ratio": 0.9952,
+      "suggested_scalar": -0.005,
+      "log_bad": -0.1603,
+      "log_good": -0.1651
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0056,
+      "good": 0.0025,
+      "ratio": 0.4464,
+      "suggested_scalar": -0.8289,
+      "log_bad": -5.185,
+      "log_good": -5.9915
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4528,
+      "good": 4.5626,
+      "ratio": 1.0247,
+      "suggested_scalar": 0.025,
+      "log_bad": 1.4935,
+      "log_good": 1.5179
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 101.0,
+      "good": 79.0,
+      "ratio": 0.7822,
+      "suggested_scalar": -0.2525,
+      "log_bad": 4.6151,
+      "log_good": 4.3694
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.532,
+      "good": 0.4888,
+      "ratio": 0.9188,
+      "suggested_scalar": -0.087,
+      "log_bad": -0.6311,
+      "log_good": -0.7158
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5536,
+      "good": 0.5511,
+      "ratio": 0.9955,
+      "suggested_scalar": -0.0047,
+      "log_bad": -0.5913,
+      "log_good": -0.5958
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.6914,
+      "good": 3.0435,
+      "ratio": 0.6487,
+      "suggested_scalar": -0.4448,
+      "log_bad": 1.5457,
+      "log_good": 1.113
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 531.0,
+      "good": 393.0,
+      "ratio": 0.7401,
+      "suggested_scalar": -0.3093,
+      "log_bad": 6.2748,
+      "log_good": 5.9738
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1144,
+      "good": 1.1072,
+      "ratio": 0.9935,
+      "suggested_scalar": -0.0067,
+      "log_bad": 0.1083,
+      "log_good": 0.1018
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 174.0,
+      "good": 115.0,
+      "ratio": 0.6609,
+      "suggested_scalar": -0.4256,
+      "log_bad": 5.1591,
+      "log_good": 4.7449
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 92.8173,
+      "good": 95.0415,
+      "ratio": 1.024,
+      "suggested_scalar": 0.0243,
+      "log_bad": 4.5306,
+      "log_good": 4.5543
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6604,
+      "good": 0.6531,
+      "ratio": 0.9889,
+      "suggested_scalar": -0.0114,
+      "log_bad": -0.4149,
+      "log_good": -0.426
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 30.29,
+      "good": 18.7006,
+      "ratio": 0.6174,
+      "suggested_scalar": -0.4957,
+      "log_bad": 3.4108,
+      "log_good": 2.9286
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2485.0,
+      "good": 1599.0,
+      "ratio": 0.6435,
+      "suggested_scalar": -0.4531,
+      "log_bad": 7.818,
+      "log_good": 7.3771
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0864,
+      "good": 0.0217,
+      "ratio": 0.2512,
+      "suggested_scalar": -1.4201,
+      "log_bad": -2.4488,
+      "log_good": -3.8304
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8272,
+      "good": 0.8043,
+      "ratio": 0.9723,
+      "suggested_scalar": -0.0289,
+      "log_bad": -0.1897,
+      "log_good": -0.2178
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.5556,
+      "good": 8.5435,
+      "ratio": 1.3032,
+      "suggested_scalar": 0.2722,
+      "log_bad": 1.8803,
+      "log_good": 2.1452
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 14.0,
+      "good": 6.0,
+      "ratio": 0.4286,
+      "suggested_scalar": -0.8708,
+      "log_bad": 2.6391,
+      "log_good": 1.7918
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.9418,
+      "good": 3.259,
+      "ratio": 0.5485,
+      "suggested_scalar": -0.6173,
+      "log_bad": 1.782,
+      "log_good": 1.1814
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 153.0,
+      "good": 105.0,
+      "ratio": 0.6863,
+      "suggested_scalar": -0.3869,
+      "log_bad": 5.0304,
+      "log_good": 4.654
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9569,
+      "good": 0.9596,
+      "ratio": 1.0028,
+      "suggested_scalar": 0.0029,
+      "log_bad": -0.0441,
+      "log_good": -0.0412
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 23.0,
+      "ratio": 0.92,
+      "suggested_scalar": -0.0857,
+      "log_bad": 3.2189,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6905,
+      "good": 0.6598,
+      "ratio": 0.9555,
+      "suggested_scalar": -0.0467,
+      "log_bad": -0.3703,
+      "log_good": -0.4158
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.448,
+      "good": 0.4885,
+      "ratio": 1.0904,
+      "suggested_scalar": 0.089,
+      "log_bad": -0.803,
+      "log_good": -0.7164
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.2315,
+      "good": 2.9393,
+      "ratio": 0.9096,
+      "suggested_scalar": -0.0974,
+      "log_bad": 1.1729,
+      "log_good": 1.0782
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 529.0,
+      "good": 391.0,
+      "ratio": 0.7391,
+      "suggested_scalar": -0.3107,
+      "log_bad": 6.271,
+      "log_good": 5.9687
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 18.0,
+      "good": 11.0,
+      "ratio": 0.6111,
+      "suggested_scalar": -0.5062,
+      "log_bad": 2.8904,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0395,
+      "good": 0.056,
+      "ratio": 1.4177,
+      "suggested_scalar": 0.3588,
+      "log_bad": -3.2315,
+      "log_good": -2.8824
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7279,
+      "good": 5.6147,
+      "ratio": 0.9802,
+      "suggested_scalar": -0.0205,
+      "log_bad": 1.7453,
+      "log_good": 1.7254
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 7.0,
+      "good": 4.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -0.5752,
+      "log_bad": 1.9459,
+      "log_good": 1.3863
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6422,
+      "good": 0.5107,
+      "ratio": 0.7952,
+      "suggested_scalar": -0.2355,
+      "log_bad": -0.4429,
+      "log_good": -0.672
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4201,
+      "good": 5.1751,
+      "ratio": 0.9548,
+      "suggested_scalar": -0.0475,
+      "log_bad": 1.6901,
+      "log_good": 1.6439
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7774,
+      "good": 0.8126,
+      "ratio": 1.0453,
+      "suggested_scalar": 0.0455,
+      "log_bad": -0.2518,
+      "log_good": -0.2075
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1563,
+      "good": 0.2069,
+      "ratio": 1.3237,
+      "suggested_scalar": 0.2883,
+      "log_bad": -1.856,
+      "log_good": -1.5755
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 5.5036,
+      "good": 4.3244,
+      "ratio": 0.7857,
+      "suggested_scalar": -0.2478,
+      "log_bad": 1.7054,
+      "log_good": 1.4643
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 352.0,
+      "good": 255.0,
+      "ratio": 0.7244,
+      "suggested_scalar": -0.3313,
+      "log_bad": 5.8636,
+      "log_good": 5.5413
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 14.0,
+      "good": 9.0,
+      "ratio": 0.6429,
+      "suggested_scalar": -0.4541,
+      "log_bad": 2.6391,
+      "log_good": 2.1972
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.1186,
+      "good": 0.8069,
+      "ratio": 0.7213,
+      "suggested_scalar": -0.3357,
+      "log_bad": 0.1121,
+      "log_good": -0.2146
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 83.0,
+      "ratio": 0.7757,
+      "suggested_scalar": -0.261,
+      "log_bad": 4.6728,
+      "log_good": 4.4188
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1371.0,
+      "good": 913.0,
+      "ratio": 0.6659,
+      "suggested_scalar": -0.4179,
+      "log_bad": 7.2233,
+      "log_good": 6.8167
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 175.0,
+      "good": 118.0,
+      "ratio": 0.6743,
+      "suggested_scalar": -0.4051,
+      "log_bad": 5.1648,
+      "log_good": 4.7707
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0151,
+      "good": 0.0051,
+      "ratio": 0.3377,
+      "suggested_scalar": -1.1156,
+      "log_bad": -4.1931,
+      "log_good": -5.2785
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2844,
+      "good": 0.2875,
+      "ratio": 1.0109,
+      "suggested_scalar": 0.0111,
+      "log_bad": -1.2574,
+      "log_good": -1.2465
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 83.0,
+      "good": 60.0,
+      "ratio": 0.7229,
+      "suggested_scalar": -0.3335,
+      "log_bad": 4.4188,
+      "log_good": 4.0943
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 19.0,
+      "good": 17.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.1143,
+      "log_bad": 2.9444,
+      "log_good": 2.8332
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 83.0,
+      "ratio": 0.7757,
+      "suggested_scalar": -0.261,
+      "log_bad": 4.6728,
+      "log_good": 4.4188
+    },
+    "brevity.mean_sample_size": {
+      "bad": 107.0,
+      "good": 83.0,
+      "ratio": 0.7757,
+      "suggested_scalar": -0.261,
+      "log_bad": 4.6728,
+      "log_good": 4.4188
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 531.0,
+      "good": 393.0,
+      "ratio": 0.7401,
+      "suggested_scalar": -0.3093,
+      "log_bad": 6.2748,
+      "log_good": 5.9738
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 280.0,
+      "good": 222.0,
+      "ratio": 0.7929,
+      "suggested_scalar": -0.2386,
+      "log_bad": 5.6348,
+      "log_good": 5.4027
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 263.0,
+      "good": 196.0,
+      "ratio": 0.7452,
+      "suggested_scalar": -0.3022,
+      "log_bad": 5.5722,
+      "log_good": 5.2781
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0019,
+      "good": 0.0025,
+      "ratio": 1.3158,
+      "suggested_scalar": 0.2821,
+      "log_bad": -6.2659,
+      "log_good": -5.9915
+    },
+    "heaps.mean_k": {
+      "bad": 3.5673,
+      "good": 3.1838,
+      "ratio": 0.8925,
+      "suggested_scalar": -0.1169,
+      "log_bad": 1.2718,
+      "log_good": 1.1581
+    },
+    "halstead.mean_effort": {
+      "bad": 96587.8705,
+      "good": 58657.5804,
+      "ratio": 0.6073,
+      "suggested_scalar": -0.5126,
+      "log_bad": 11.4782,
+      "log_good": 10.9795
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.804,
+      "good": 0.8118,
+      "ratio": 1.0097,
+      "suggested_scalar": 0.0099,
+      "log_bad": -0.2182,
+      "log_good": -0.2085
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 76.0,
+      "good": 56.0,
+      "ratio": 0.7368,
+      "suggested_scalar": -0.3139,
+      "log_bad": 4.3307,
+      "log_good": 4.0254
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 329.0,
+      "good": 266.0,
+      "ratio": 0.8085,
+      "suggested_scalar": -0.2185,
+      "log_bad": 5.7961,
+      "log_good": 5.5835
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4483,
+      "good": 0.487,
+      "ratio": 1.0863,
+      "suggested_scalar": 0.0851,
+      "log_bad": -0.8023,
+      "log_good": -0.7195
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.8793,
+      "good": 7.9391,
+      "ratio": 1.0076,
+      "suggested_scalar": 0.0078,
+      "log_bad": 2.0642,
+      "log_good": 2.0718
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1563,
+      "good": 0.2069,
+      "ratio": 1.3237,
+      "suggested_scalar": 0.2883,
+      "log_bad": -1.856,
+      "log_good": -1.5755
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.7106,
+      "good": 3.4174,
+      "ratio": 0.7255,
+      "suggested_scalar": -0.3299,
+      "log_bad": 1.5498,
+      "log_good": 1.2289
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 530.0,
+      "good": 392.0,
+      "ratio": 0.7396,
+      "suggested_scalar": -0.31,
+      "log_bad": 6.2729,
+      "log_good": 5.9713
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 4.0,
+      "good": 11.0,
+      "ratio": 2.75,
+      "suggested_scalar": 1.0397,
+      "log_bad": 1.3863,
+      "log_good": 2.3979
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 60.0,
+      "good": 55.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0894,
+      "log_bad": 4.0943,
+      "log_good": 4.0073
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5365.9928,
+      "good": 3258.7545,
+      "ratio": 0.6073,
+      "suggested_scalar": -0.5126,
+      "log_bad": 8.5878,
+      "log_good": 8.0891
+    },
+    "readability.mean_total_lines": {
+      "bad": 81.0,
+      "good": 46.0,
+      "ratio": 0.5679,
+      "suggested_scalar": -0.5815,
+      "log_bad": 4.3944,
+      "log_good": 3.8286
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 3355.7386,
+      "good": 2420.6518,
+      "ratio": 0.7213,
+      "suggested_scalar": -0.3357,
+      "log_bad": 8.1184,
+      "log_good": 7.7918
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 769.0,
+      "good": 544.0,
+      "ratio": 0.7074,
+      "suggested_scalar": -0.3558,
+      "log_bad": 6.6451,
+      "log_good": 6.2989
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 29.4938,
+      "good": 33.5,
+      "ratio": 1.1358,
+      "suggested_scalar": 0.1309,
+      "log_bad": 3.3842,
+      "log_good": 3.5115
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2691,
+      "good": 1.2189,
+      "ratio": 0.9604,
+      "suggested_scalar": -0.0415,
+      "log_bad": 0.2383,
+      "log_good": 0.1979
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 16.0,
+      "good": 6.0,
+      "ratio": 0.375,
+      "suggested_scalar": -1.0081,
+      "log_bad": 2.7726,
+      "log_good": 1.7918
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8295,
+      "good": 0.7843,
+      "ratio": 0.9455,
+      "suggested_scalar": -0.0576,
+      "log_bad": -0.1869,
+      "log_good": -0.243
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9892,
+      "good": 0.9891,
+      "ratio": 0.9999,
+      "suggested_scalar": -0.0001,
+      "log_bad": -0.0109,
+      "log_good": -0.011
+    },
+    "halstead.mean_length": {
+      "bad": 504.0,
+      "good": 384.0,
+      "ratio": 0.7619,
+      "suggested_scalar": -0.2795,
+      "log_bad": 6.2226,
+      "log_good": 5.9506
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.8947,
+      "good": 3.2353,
+      "ratio": 0.661,
+      "suggested_scalar": -0.4255,
+      "log_bad": 1.5882,
+      "log_good": 1.1741
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7415,
+      "good": 6.375,
+      "ratio": 0.9456,
+      "suggested_scalar": -0.0575,
+      "log_bad": 1.9083,
+      "log_good": 1.8524
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1127,
+      "good": 0.1388,
+      "ratio": 1.2316,
+      "suggested_scalar": 0.2141,
+      "log_bad": -2.183,
+      "log_good": -1.9747
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 28.7829,
+      "good": 24.2321,
+      "ratio": 0.8419,
+      "suggested_scalar": -0.1769,
+      "log_bad": 3.3598,
+      "log_good": 3.1877
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 1.0,
+      "ratio": 0.1429,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.9459,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 78.0,
+      "good": 56.0,
+      "ratio": 0.7179,
+      "suggested_scalar": -0.3406,
+      "log_bad": 4.3567,
+      "log_good": 4.0254
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6844,
+      "good": 0.6939,
+      "ratio": 1.0139,
+      "suggested_scalar": 0.0142,
+      "log_bad": -0.3792,
+      "log_good": -0.3654
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 81.0,
+      "good": 46.0,
+      "ratio": 0.5679,
+      "suggested_scalar": -0.5815,
+      "log_bad": 4.3944,
+      "log_good": 3.8286
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 26.0,
+      "good": 17.0,
+      "ratio": 0.6538,
+      "suggested_scalar": -0.4367,
+      "log_bad": 3.2581,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.no_default_arguments_on_virtual_functions": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 4.0,
+      "good": 2.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2522,
+      "log_bad": 1.3863,
+      "log_good": 0.6931
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0061,
+      "good": 0.0088,
+      "ratio": 1.4426,
+      "suggested_scalar": 0.1333,
+      "log_bad": -5.0995,
+      "log_good": -4.733
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8958,
+      "good": 0.8837,
+      "ratio": 0.9865,
+      "suggested_scalar": -0.0049,
+      "log_bad": -0.11,
+      "log_good": -0.1236
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0102,
+      "good": 0.0088,
+      "ratio": 0.8627,
+      "suggested_scalar": -0.0537,
+      "log_bad": -4.5854,
+      "log_good": -4.733
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7555,
+      "good": 4.6161,
+      "ratio": 0.9707,
+      "suggested_scalar": -0.0108,
+      "log_bad": 1.5593,
+      "log_good": 1.5296
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 131.0,
+      "good": 90.0,
+      "ratio": 0.687,
+      "suggested_scalar": -0.1366,
+      "log_bad": 4.8752,
+      "log_good": 4.4998
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5308,
+      "good": 0.5025,
+      "ratio": 0.9467,
+      "suggested_scalar": -0.0199,
+      "log_bad": -0.6334,
+      "log_good": -0.6882
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 19.0,
+      "ratio": 0.95,
+      "suggested_scalar": -0.0187,
+      "log_bad": 2.9957,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6512,
+      "good": 0.6609,
+      "ratio": 1.0149,
+      "suggested_scalar": 0.0054,
+      "log_bad": -0.4289,
+      "log_good": -0.4142
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.25,
+      "good": 3.5349,
+      "ratio": 1.0877,
+      "suggested_scalar": 0.0306,
+      "log_bad": 1.1787,
+      "log_good": 1.2627
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 490.0,
+      "good": 341.0,
+      "ratio": 0.6959,
+      "suggested_scalar": -0.1319,
+      "log_bad": 6.1944,
+      "log_good": 5.8319
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1047,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2708,
+      "good": 0.2326,
+      "ratio": 0.8589,
+      "suggested_scalar": -0.0553,
+      "log_bad": -1.3064,
+      "log_good": -1.4584
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9231,
+      "good": 0.9033,
+      "ratio": 0.9786,
+      "suggested_scalar": -0.0079,
+      "log_bad": -0.08,
+      "log_good": -0.1017
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 171.0,
+      "good": 115.0,
+      "ratio": 0.6725,
+      "suggested_scalar": -0.1444,
+      "log_bad": 5.1417,
+      "log_good": 4.7449
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 108.1566,
+      "good": 111.376,
+      "ratio": 1.0298,
+      "suggested_scalar": 0.0107,
+      "log_bad": 4.6836,
+      "log_good": 4.7129
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5378,
+      "good": 0.5706,
+      "ratio": 1.061,
+      "suggested_scalar": 0.0215,
+      "log_bad": -0.6203,
+      "log_good": -0.5611
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.0148,
+      "good": 7.043,
+      "ratio": 0.8787,
+      "suggested_scalar": -0.047,
+      "log_bad": 2.0813,
+      "log_good": 1.952
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2153.0,
+      "good": 1596.0,
+      "ratio": 0.7413,
+      "suggested_scalar": -0.1089,
+      "log_bad": 7.6746,
+      "log_good": 7.3753
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1667,
+      "good": 0.0465,
+      "ratio": 0.2789,
+      "suggested_scalar": -0.4645,
+      "log_bad": -1.7916,
+      "log_good": -3.0683
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.875,
+      "good": 0.8837,
+      "ratio": 1.0099,
+      "suggested_scalar": 0.0036,
+      "log_bad": -0.1335,
+      "log_good": -0.1236
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.6522,
+      "good": 8.3171,
+      "ratio": 0.7808,
+      "suggested_scalar": -0.09,
+      "log_bad": 2.3658,
+      "log_good": 2.1183
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.7708,
+      "good": 6.1092,
+      "ratio": 1.0586,
+      "suggested_scalar": 0.0207,
+      "log_bad": 1.7528,
+      "log_good": 1.8098
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 123.0,
+      "good": 85.0,
+      "ratio": 0.6911,
+      "suggested_scalar": -0.1345,
+      "log_bad": 4.8122,
+      "log_good": 4.4427
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.944,
+      "good": 0.9356,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.0033,
+      "log_bad": -0.0576,
+      "log_good": -0.0666
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 22.0,
+      "ratio": 0.7333,
+      "suggested_scalar": -0.1128,
+      "log_bad": 3.4012,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6033,
+      "good": 0.6216,
+      "ratio": 1.0303,
+      "suggested_scalar": 0.0109,
+      "log_bad": -0.5053,
+      "log_good": -0.4755
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3299,
+      "good": 0.3422,
+      "ratio": 1.0373,
+      "suggested_scalar": 0.0133,
+      "log_bad": -1.109,
+      "log_good": -1.0724
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5211,
+      "good": 2.6424,
+      "ratio": 1.0481,
+      "suggested_scalar": 0.0171,
+      "log_bad": 0.9247,
+      "log_good": 0.9717
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 488.0,
+      "good": 339.0,
+      "ratio": 0.6947,
+      "suggested_scalar": -0.1326,
+      "log_bad": 6.1903,
+      "log_good": 5.826
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0367,
+      "good": 0.0293,
+      "ratio": 0.7984,
+      "suggested_scalar": -0.0819,
+      "log_bad": -3.305,
+      "log_good": -3.5302
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0875,
+      "good": 5.8329,
+      "ratio": 0.9582,
+      "suggested_scalar": -0.0155,
+      "log_bad": 1.8062,
+      "log_good": 1.7635
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 39.0,
+      "good": 21.0,
+      "ratio": 0.5385,
+      "suggested_scalar": -0.2252,
+      "log_bad": 3.6636,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0518,
+      "good": 1.058,
+      "ratio": 1.0059,
+      "suggested_scalar": 0.0021,
+      "log_bad": 0.0505,
+      "log_good": 0.0564
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.1707,
+      "good": 5.811,
+      "ratio": 0.9417,
+      "suggested_scalar": -0.0219,
+      "log_bad": 1.8198,
+      "log_good": 1.7598
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7812,
+      "good": 0.7914,
+      "ratio": 1.0131,
+      "suggested_scalar": 0.0047,
+      "log_bad": -0.2469,
+      "log_good": -0.234
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2381,
+      "good": 0.2321,
+      "ratio": 0.9748,
+      "suggested_scalar": -0.0093,
+      "log_bad": -1.4351,
+      "log_good": -1.4606
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.831,
+      "good": 2.6539,
+      "ratio": 0.9374,
+      "suggested_scalar": -0.0235,
+      "log_bad": 1.0406,
+      "log_good": 0.976
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 5.0,
+      "good": 1.0,
+      "ratio": 0.2,
+      "suggested_scalar": -0.5856,
+      "log_bad": 1.6094,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 396.0,
+      "good": 270.0,
+      "ratio": 0.6818,
+      "suggested_scalar": -0.1394,
+      "log_bad": 5.9814,
+      "log_good": 5.5984
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 8.0,
+      "good": 6.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1047,
+      "log_bad": 2.0794,
+      "log_good": 1.7918
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0785,
+      "good": 0.7163,
+      "ratio": 0.6642,
+      "suggested_scalar": -0.1489,
+      "log_bad": 0.0756,
+      "log_good": -0.3337
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 130.0,
+      "good": 91.0,
+      "ratio": 0.7,
+      "suggested_scalar": -0.1298,
+      "log_bad": 4.8675,
+      "log_good": 4.5109
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 978.0,
+      "good": 724.0,
+      "ratio": 0.7403,
+      "suggested_scalar": -0.1094,
+      "log_bad": 6.8855,
+      "log_good": 6.5848
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 237.0,
+      "good": 174.0,
+      "ratio": 0.7342,
+      "suggested_scalar": -0.1124,
+      "log_bad": 5.4681,
+      "log_good": 5.1591
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0041,
+      "good": 1.0,
+      "ratio": 243.9024,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.4968,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1653,
+      "good": 0.1877,
+      "ratio": 1.1355,
+      "suggested_scalar": 0.0462,
+      "log_bad": -1.8,
+      "log_good": -1.6729
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 91.0,
+      "good": 64.0,
+      "ratio": 0.7033,
+      "suggested_scalar": -0.1281,
+      "log_bad": 4.5109,
+      "log_good": 4.1589
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 130.0,
+      "good": 91.0,
+      "ratio": 0.7,
+      "suggested_scalar": -0.1298,
+      "log_bad": 4.8675,
+      "log_good": 4.5109
+    },
+    "brevity.mean_sample_size": {
+      "bad": 130.0,
+      "good": 91.0,
+      "ratio": 0.7,
+      "suggested_scalar": -0.1298,
+      "log_bad": 4.8675,
+      "log_good": 4.5109
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 490.0,
+      "good": 341.0,
+      "ratio": 0.6959,
+      "suggested_scalar": -0.1319,
+      "log_bad": 6.1944,
+      "log_good": 5.8319
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 220.0,
+      "good": 160.0,
+      "ratio": 0.7273,
+      "suggested_scalar": -0.1159,
+      "log_bad": 5.3936,
+      "log_good": 5.0752
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 317.0,
+      "good": 210.0,
+      "ratio": 0.6625,
+      "suggested_scalar": -0.1498,
+      "log_bad": 5.7589,
+      "log_good": 5.3471
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0102,
+      "good": 1.0,
+      "ratio": 98.0392,
+      "suggested_scalar": 1.6684,
+      "log_bad": -4.5854,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.5567,
+      "good": 2.2437,
+      "ratio": 0.8776,
+      "suggested_scalar": -0.0475,
+      "log_bad": 0.9387,
+      "log_good": 0.8081
+    },
+    "halstead.mean_effort": {
+      "bad": 113878.7786,
+      "good": 60482.495,
+      "ratio": 0.5311,
+      "suggested_scalar": -0.2302,
+      "log_bad": 11.6429,
+      "log_good": 11.0101
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8787,
+      "good": 0.8929,
+      "ratio": 1.0162,
+      "suggested_scalar": 0.0058,
+      "log_bad": -0.1293,
+      "log_good": -0.1133
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 101.0,
+      "good": 68.0,
+      "ratio": 0.6733,
+      "suggested_scalar": -0.1439,
+      "log_bad": 4.6151,
+      "log_good": 4.2195
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 223.0,
+      "good": 157.0,
+      "ratio": 0.704,
+      "suggested_scalar": -0.1277,
+      "log_bad": 5.4072,
+      "log_good": 5.0562
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.462,
+      "good": 0.4783,
+      "ratio": 1.0353,
+      "suggested_scalar": 0.0126,
+      "log_bad": -0.7722,
+      "log_good": -0.7375
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.7193,
+      "good": 6.2957,
+      "ratio": 1.1008,
+      "suggested_scalar": 0.0349,
+      "log_bad": 1.7438,
+      "log_good": 1.8399
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2381,
+      "good": 0.2321,
+      "ratio": 0.9748,
+      "suggested_scalar": -0.0093,
+      "log_bad": -1.4351,
+      "log_good": -1.4606
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.2609,
+      "good": 3.3268,
+      "ratio": 0.7808,
+      "suggested_scalar": -0.09,
+      "log_bad": 1.4495,
+      "log_good": 1.202
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 489.0,
+      "good": 340.0,
+      "ratio": 0.6953,
+      "suggested_scalar": -0.1322,
+      "log_bad": 6.1924,
+      "log_good": 5.8289
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 69.0,
+      "good": 47.0,
+      "ratio": 0.6812,
+      "suggested_scalar": -0.1397,
+      "log_bad": 4.2341,
+      "log_good": 3.8501
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6326.5988,
+      "good": 3360.1386,
+      "ratio": 0.5311,
+      "suggested_scalar": -0.2302,
+      "log_bad": 8.7525,
+      "log_good": 8.1197
+    },
+    "readability.mean_total_lines": {
+      "bad": 46.0,
+      "good": 41.0,
+      "ratio": 0.8913,
+      "suggested_scalar": -0.0419,
+      "log_bad": 3.8286,
+      "log_good": 3.7136
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 3235.3746,
+      "good": 2148.8034,
+      "ratio": 0.6642,
+      "suggested_scalar": -0.1489,
+      "log_bad": 8.0819,
+      "log_good": 7.6727
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 854.0,
+      "good": 604.0,
+      "ratio": 0.7073,
+      "suggested_scalar": -0.126,
+      "log_bad": 6.7499,
+      "log_good": 6.4036
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 44.3913,
+      "good": 36.5854,
+      "ratio": 0.8242,
+      "suggested_scalar": -0.0704,
+      "log_bad": 3.793,
+      "log_good": 3.5996
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0386,
+      "good": 1.0286,
+      "ratio": 0.9904,
+      "suggested_scalar": -0.0035,
+      "log_bad": 0.0379,
+      "log_good": 0.0282
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1047,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 13.0,
+      "good": 10.0,
+      "ratio": 0.7692,
+      "suggested_scalar": -0.0955,
+      "log_bad": 2.5649,
+      "log_good": 2.3026
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8258,
+      "good": 0.8259,
+      "ratio": 1.0001,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1914,
+      "log_good": -0.1913
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9483,
+      "good": 0.9509,
+      "ratio": 1.0027,
+      "suggested_scalar": 0.001,
+      "log_bad": -0.0531,
+      "log_good": -0.0503
+    },
+    "halstead.mean_length": {
+      "bad": 460.0,
+      "good": 331.0,
+      "ratio": 0.7196,
+      "suggested_scalar": -0.1197,
+      "log_bad": 6.1312,
+      "log_good": 5.8021
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.0224,
+      "good": 6.5078,
+      "ratio": 0.9267,
+      "suggested_scalar": -0.0277,
+      "log_bad": 1.9491,
+      "log_good": 1.873
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1029,
+      "good": 0.1006,
+      "ratio": 0.9776,
+      "suggested_scalar": -0.0082,
+      "log_bad": -2.274,
+      "log_good": -2.2966
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 35.198,
+      "good": 28.1471,
+      "ratio": 0.7997,
+      "suggested_scalar": -0.0813,
+      "log_bad": 3.561,
+      "log_good": 3.3374
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 2.0,
+      "ratio": 0.25,
+      "suggested_scalar": -0.5044,
+      "log_bad": 2.0794,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 79.0,
+      "good": 55.0,
+      "ratio": 0.6962,
+      "suggested_scalar": -0.1318,
+      "log_bad": 4.3694,
+      "log_good": 4.0073
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7129,
+      "good": 0.6952,
+      "ratio": 0.9752,
+      "suggested_scalar": -0.0091,
+      "log_bad": -0.3384,
+      "log_good": -0.3636
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 48.0,
+      "good": 43.0,
+      "ratio": 0.8958,
+      "suggested_scalar": -0.04,
+      "log_bad": 3.8712,
+      "log_good": 3.7612
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.no_mutable_default_argument": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 20.0,
+      "good": 32.0,
+      "ratio": 1.6,
+      "suggested_scalar": 0.9583,
+      "log_bad": 2.9957,
+      "log_good": 3.4657
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -1.4133,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.067,
+      "good": 0.06,
+      "ratio": 0.8955,
+      "suggested_scalar": -0.225,
+      "log_bad": -2.7031,
+      "log_good": -2.8134
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.6667,
+      "good": 0.25,
+      "ratio": 0.375,
+      "suggested_scalar": -2.0,
+      "log_bad": -0.4054,
+      "log_good": -1.3863
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9375,
+      "good": 0.931,
+      "ratio": 0.9931,
+      "suggested_scalar": -0.0142,
+      "log_bad": -0.0645,
+      "log_good": -0.0715
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.067,
+      "good": 0.06,
+      "ratio": 0.8955,
+      "suggested_scalar": -0.225,
+      "log_bad": -2.7031,
+      "log_good": -2.8134
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.424,
+      "good": 4.409,
+      "ratio": 0.9966,
+      "suggested_scalar": -0.0069,
+      "log_bad": 1.487,
+      "log_good": 1.4836
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 83.0,
+      "good": 80.0,
+      "ratio": 0.9639,
+      "suggested_scalar": -0.0751,
+      "log_bad": 4.4188,
+      "log_good": 4.382
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5457,
+      "good": 0.4975,
+      "ratio": 0.9117,
+      "suggested_scalar": -0.1886,
+      "log_bad": -0.6057,
+      "log_good": -0.6982
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 18.0,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.1102,
+      "log_bad": 2.9444,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6725,
+      "good": 0.6637,
+      "ratio": 0.9869,
+      "suggested_scalar": -0.0269,
+      "log_bad": -0.3968,
+      "log_good": -0.4099
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.4167,
+      "good": 4.4828,
+      "ratio": 1.015,
+      "suggested_scalar": 0.0303,
+      "log_bad": 1.4854,
+      "log_good": 1.5002
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 418.0,
+      "good": 450.0,
+      "ratio": 1.0766,
+      "suggested_scalar": 0.1504,
+      "log_bad": 6.0355,
+      "log_good": 6.1092
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0208,
+      "good": 0.0172,
+      "ratio": 0.8269,
+      "suggested_scalar": -0.3875,
+      "log_bad": -3.8728,
+      "log_good": -4.0628
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9302,
+      "good": 0.9946,
+      "ratio": 1.0692,
+      "suggested_scalar": 0.1365,
+      "log_bad": -0.0724,
+      "log_good": -0.0054
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 173.0,
+      "good": 171.0,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0237,
+      "log_bad": 5.1533,
+      "log_good": 5.1417
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 106.6755,
+      "good": 106.6357,
+      "ratio": 0.9996,
+      "suggested_scalar": -0.0008,
+      "log_bad": 4.6698,
+      "log_good": 4.6694
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4892,
+      "good": 0.5212,
+      "ratio": 1.0654,
+      "suggested_scalar": 0.1292,
+      "log_bad": -0.715,
+      "log_good": -0.6516
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.6744,
+      "good": 10.3637,
+      "ratio": 1.1947,
+      "suggested_scalar": 0.3628,
+      "log_bad": 2.1604,
+      "log_good": 2.3383
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1921.0,
+      "good": 2037.0,
+      "ratio": 1.0604,
+      "suggested_scalar": 0.1196,
+      "log_bad": 7.5606,
+      "log_good": 7.6192
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0833,
+      "good": 0.1379,
+      "ratio": 1.6555,
+      "suggested_scalar": 1.0278,
+      "log_bad": -2.4853,
+      "log_good": -1.9812
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9375,
+      "good": 0.931,
+      "ratio": 0.9931,
+      "suggested_scalar": -0.0142,
+      "log_bad": -0.0645,
+      "log_good": -0.0715
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.7083,
+      "good": 7.7586,
+      "ratio": 0.8909,
+      "suggested_scalar": -0.2355,
+      "log_bad": 2.1643,
+      "log_good": 2.0488
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 10.8264,
+      "good": 9.9738,
+      "ratio": 0.9212,
+      "suggested_scalar": -0.1672,
+      "log_bad": 2.382,
+      "log_good": 2.3
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 162.0,
+      "good": 157.0,
+      "ratio": 0.9691,
+      "suggested_scalar": -0.0639,
+      "log_bad": 5.0876,
+      "log_good": 5.0562
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9475,
+      "good": 0.9437,
+      "ratio": 0.996,
+      "suggested_scalar": -0.0082,
+      "log_bad": -0.0539,
+      "log_good": -0.0579
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 31.0,
+      "ratio": 1.24,
+      "suggested_scalar": 0.4386,
+      "log_bad": 3.2189,
+      "log_good": 3.434
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5929,
+      "good": 0.6073,
+      "ratio": 1.0243,
+      "suggested_scalar": 0.0489,
+      "log_bad": -0.5227,
+      "log_good": -0.4987
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3221,
+      "good": 0.3304,
+      "ratio": 1.0258,
+      "suggested_scalar": 0.0519,
+      "log_bad": -1.1329,
+      "log_good": -1.1075
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4565,
+      "good": 2.5463,
+      "ratio": 1.0366,
+      "suggested_scalar": 0.0732,
+      "log_bad": 0.8987,
+      "log_good": 0.9346
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 416.0,
+      "good": 448.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.1511,
+      "log_bad": 6.0307,
+      "log_good": 6.1048
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 22.0,
+      "good": 23.0,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.0906,
+      "log_bad": 3.091,
+      "log_good": 3.1355
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0478,
+      "good": 0.0422,
+      "ratio": 0.8828,
+      "suggested_scalar": -0.2541,
+      "log_bad": -3.0407,
+      "log_good": -3.1653
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.858,
+      "good": 5.7279,
+      "ratio": 0.9778,
+      "suggested_scalar": -0.0458,
+      "log_bad": 1.7678,
+      "log_good": 1.7453
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 10.0,
+      "good": 13.0,
+      "ratio": 1.3,
+      "suggested_scalar": 0.535,
+      "log_bad": 2.3026,
+      "log_good": 2.5649
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.3695,
+      "good": 0.4391,
+      "ratio": 1.1884,
+      "suggested_scalar": 0.3519,
+      "log_bad": -0.9956,
+      "log_good": -0.823
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8647,
+      "good": 5.8224,
+      "ratio": 0.9928,
+      "suggested_scalar": -0.0148,
+      "log_bad": 1.769,
+      "log_good": 1.7617
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7552,
+      "good": 0.7697,
+      "ratio": 1.0192,
+      "suggested_scalar": 0.0388,
+      "log_bad": -0.2808,
+      "log_good": -0.2618
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -1.4133,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2,
+      "good": 0.1944,
+      "ratio": 0.972,
+      "suggested_scalar": -0.0579,
+      "log_bad": -1.6094,
+      "log_good": -1.6378
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.9452,
+      "good": 3.2193,
+      "ratio": 1.0931,
+      "suggested_scalar": 0.1814,
+      "log_bad": 1.0802,
+      "log_good": 1.1692
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 336.0,
+      "good": 361.0,
+      "ratio": 1.0744,
+      "suggested_scalar": 0.1463,
+      "log_bad": 5.8171,
+      "log_good": 5.8889
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 8.0,
+      "good": 6.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.5866,
+      "log_bad": 2.0794,
+      "log_good": 1.7918
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6396,
+      "good": 0.7017,
+      "ratio": 1.0971,
+      "suggested_scalar": 0.1889,
+      "log_bad": -0.4469,
+      "log_good": -0.3542
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 116.0,
+      "good": 117.0,
+      "ratio": 1.0086,
+      "suggested_scalar": 0.0175,
+      "log_bad": 4.7536,
+      "log_good": 4.7622
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1062.0,
+      "good": 1078.0,
+      "ratio": 1.0151,
+      "suggested_scalar": 0.0305,
+      "log_bad": 6.9679,
+      "log_good": 6.9829
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 141.0,
+      "good": 137.0,
+      "ratio": 0.9716,
+      "suggested_scalar": -0.0587,
+      "log_bad": 4.9488,
+      "log_good": 4.92
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0072,
+      "good": 0.0067,
+      "ratio": 0.9306,
+      "suggested_scalar": -0.1468,
+      "log_bad": -4.9337,
+      "log_good": -5.0056
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1986,
+      "good": 0.2356,
+      "ratio": 1.1863,
+      "suggested_scalar": 0.3483,
+      "log_bad": -1.6165,
+      "log_good": -1.4456
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 68.0,
+      "good": 79.0,
+      "ratio": 1.1618,
+      "suggested_scalar": 0.3057,
+      "log_bad": 4.2195,
+      "log_good": 4.3694
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.5866,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 116.0,
+      "good": 117.0,
+      "ratio": 1.0086,
+      "suggested_scalar": 0.0175,
+      "log_bad": 4.7536,
+      "log_good": 4.7622
+    },
+    "brevity.mean_sample_size": {
+      "bad": 116.0,
+      "good": 117.0,
+      "ratio": 1.0086,
+      "suggested_scalar": 0.0175,
+      "log_bad": 4.7536,
+      "log_good": 4.7622
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 418.0,
+      "good": 450.0,
+      "ratio": 1.0766,
+      "suggested_scalar": 0.1504,
+      "log_bad": 6.0355,
+      "log_good": 6.1092
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 201.0,
+      "good": 217.0,
+      "ratio": 1.0796,
+      "suggested_scalar": 0.1562,
+      "log_bad": 5.3033,
+      "log_good": 5.3799
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 281.0,
+      "good": 294.0,
+      "ratio": 1.0463,
+      "suggested_scalar": 0.0922,
+      "log_bad": 5.6384,
+      "log_good": 5.6836
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.2435,
+      "good": 2.1822,
+      "ratio": 0.9727,
+      "suggested_scalar": -0.0565,
+      "log_bad": 0.808,
+      "log_good": 0.7803
+    },
+    "halstead.mean_effort": {
+      "bad": 58311.0018,
+      "good": 91232.583,
+      "ratio": 1.5646,
+      "suggested_scalar": 0.9127,
+      "log_bad": 10.9735,
+      "log_good": 11.4212
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8552,
+      "good": 0.8475,
+      "ratio": 0.991,
+      "suggested_scalar": -0.0184,
+      "log_bad": -0.1564,
+      "log_good": -0.1655
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 58.0,
+      "good": 49.0,
+      "ratio": 0.8448,
+      "suggested_scalar": -0.3438,
+      "log_bad": 4.0604,
+      "log_good": 3.8918
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 160.0,
+      "good": 196.0,
+      "ratio": 1.225,
+      "suggested_scalar": 0.4138,
+      "log_bad": 5.0752,
+      "log_good": 5.2781
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4509,
+      "good": 0.4269,
+      "ratio": 0.9468,
+      "suggested_scalar": -0.1115,
+      "log_bad": -0.7965,
+      "log_good": -0.8512
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.1387,
+      "good": 6.3041,
+      "ratio": 1.0269,
+      "suggested_scalar": 0.0542,
+      "log_bad": 1.8146,
+      "log_good": 1.8412
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2,
+      "good": 0.1944,
+      "ratio": 0.972,
+      "suggested_scalar": -0.0579,
+      "log_bad": -1.6094,
+      "log_good": -1.6378
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.4833,
+      "good": 3.1034,
+      "ratio": 0.8909,
+      "suggested_scalar": -0.2355,
+      "log_bad": 1.248,
+      "log_good": 1.1325
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 417.0,
+      "good": 449.0,
+      "ratio": 1.0767,
+      "suggested_scalar": 0.1508,
+      "log_bad": 6.0331,
+      "log_good": 6.107
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 54.0,
+      "good": 61.0,
+      "ratio": 1.1296,
+      "suggested_scalar": 0.2485,
+      "log_bad": 3.989,
+      "log_good": 4.1109
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3239.5001,
+      "good": 5068.4768,
+      "ratio": 1.5646,
+      "suggested_scalar": 0.9127,
+      "log_bad": 8.0832,
+      "log_good": 8.5308
+    },
+    "readability.mean_total_lines": {
+      "bad": 48.0,
+      "good": 58.0,
+      "ratio": 1.2083,
+      "suggested_scalar": 0.3859,
+      "log_bad": 3.8712,
+      "log_good": 4.0604
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 1918.8869,
+      "good": 2105.2021,
+      "ratio": 1.0971,
+      "suggested_scalar": 0.1889,
+      "log_bad": 7.5595,
+      "log_good": 7.6522
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 782.0,
+      "good": 800.0,
+      "ratio": 1.023,
+      "suggested_scalar": 0.0464,
+      "log_bad": 6.6619,
+      "log_good": 6.6846
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 38.6875,
+      "good": 33.8793,
+      "ratio": 0.8757,
+      "suggested_scalar": -0.2706,
+      "log_bad": 3.6555,
+      "log_good": 3.5228
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0794,
+      "good": 1.0913,
+      "ratio": 1.011,
+      "suggested_scalar": 0.0224,
+      "log_bad": 0.0764,
+      "log_good": 0.0874
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8393,
+      "good": 0.831,
+      "ratio": 0.9901,
+      "suggested_scalar": -0.0203,
+      "log_bad": -0.1752,
+      "log_good": -0.1851
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9629,
+      "good": 0.9835,
+      "ratio": 1.0214,
+      "suggested_scalar": 0.0432,
+      "log_bad": -0.0378,
+      "log_good": -0.0166
+    },
+    "halstead.mean_length": {
+      "bad": 301.0,
+      "good": 333.0,
+      "ratio": 1.1063,
+      "suggested_scalar": 0.206,
+      "log_bad": 5.7071,
+      "log_good": 5.8081
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 15.3333,
+      "good": 14.25,
+      "ratio": 0.9293,
+      "suggested_scalar": -0.1494,
+      "log_bad": 2.73,
+      "log_good": 2.6568
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.858,
+      "good": 6.8704,
+      "ratio": 1.0018,
+      "suggested_scalar": 0.0037,
+      "log_bad": 1.9254,
+      "log_good": 1.9272
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1049,
+      "good": 0.1065,
+      "ratio": 1.0153,
+      "suggested_scalar": 0.0309,
+      "log_bad": -2.2547,
+      "log_good": -2.2396
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.3879,
+      "good": 43.3367,
+      "ratio": 1.4261,
+      "suggested_scalar": 0.7237,
+      "log_bad": 3.414,
+      "log_good": 3.769
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 8.0,
+      "ratio": 2.0,
+      "suggested_scalar": 1.4133,
+      "log_bad": 1.3863,
+      "log_good": 2.0794
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 78.0,
+      "good": 73.0,
+      "ratio": 0.9359,
+      "suggested_scalar": -0.1351,
+      "log_bad": 4.3567,
+      "log_good": 4.2905
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.758,
+      "good": 0.7313,
+      "ratio": 0.9648,
+      "suggested_scalar": -0.0731,
+      "log_bad": -0.2771,
+      "log_good": -0.3129
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 48.0,
+      "good": 58.0,
+      "ratio": 1.2083,
+      "suggested_scalar": 0.3859,
+      "log_bad": 3.8712,
+      "log_good": 4.0604
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 15.0,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.1407,
+      "log_bad": 2.6391,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "testing.reasonable_test_to_code_ratio": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 39.0,
+      "good": 51.0,
+      "ratio": 1.3077,
+      "suggested_scalar": 0.0723,
+      "log_bad": 3.6636,
+      "log_good": 3.9318
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0114,
+      "good": 0.0292,
+      "ratio": 2.5614,
+      "suggested_scalar": 0.2536,
+      "log_bad": -4.4741,
+      "log_good": -3.5336
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.9091,
+      "good": 1.9,
+      "ratio": 0.9952,
+      "suggested_scalar": -0.0013,
+      "log_bad": 0.6466,
+      "log_good": 0.6419
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9333,
+      "good": 0.7595,
+      "ratio": 0.8138,
+      "suggested_scalar": -0.0556,
+      "log_bad": -0.069,
+      "log_good": -0.2751
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0114,
+      "good": 0.0292,
+      "ratio": 2.5614,
+      "suggested_scalar": 0.2536,
+      "log_bad": -4.4741,
+      "log_good": -3.5336
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8806,
+      "good": 4.7486,
+      "ratio": 0.973,
+      "suggested_scalar": -0.0074,
+      "log_bad": 1.5853,
+      "log_good": 1.5578
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 84.0,
+      "good": 99.0,
+      "ratio": 1.1786,
+      "suggested_scalar": 0.0443,
+      "log_bad": 4.4308,
+      "log_good": 4.5951
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3452,
+      "good": 0.3194,
+      "ratio": 0.9253,
+      "suggested_scalar": -0.0209,
+      "log_bad": -1.0636,
+      "log_good": -1.1413
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 18.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0284,
+      "log_bad": 2.9957,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.4753,
+      "good": 0.4588,
+      "ratio": 0.9653,
+      "suggested_scalar": -0.0095,
+      "log_bad": -0.7438,
+      "log_good": -0.7791
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.9556,
+      "good": 3.3165,
+      "ratio": 1.6959,
+      "suggested_scalar": 0.1424,
+      "log_bad": 0.6707,
+      "log_good": 1.1989
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 526.0,
+      "good": 789.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1093,
+      "log_bad": 6.2653,
+      "log_good": 6.6708
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0006,
+      "good": 1.0,
+      "ratio": 1666.6667,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.4186,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1556,
+      "good": 1.0,
+      "ratio": 6.4267,
+      "suggested_scalar": 0.5016,
+      "log_bad": -1.8605,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.061,
+      "good": 1.2345,
+      "ratio": 1.1635,
+      "suggested_scalar": 0.0408,
+      "log_bad": 0.0592,
+      "log_good": 0.2107
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 164.0,
+      "good": 225.0,
+      "ratio": 1.372,
+      "suggested_scalar": 0.0853,
+      "log_bad": 5.0999,
+      "log_good": 5.4161
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.4253,
+      "good": 108.6245,
+      "ratio": 1.0402,
+      "suggested_scalar": 0.0106,
+      "log_bad": 4.6485,
+      "log_good": 4.6879
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6743,
+      "good": 0.7665,
+      "ratio": 1.1367,
+      "suggested_scalar": 0.0346,
+      "log_bad": -0.3941,
+      "log_good": -0.2659
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.4951,
+      "good": 9.9972,
+      "ratio": 1.0529,
+      "suggested_scalar": 0.0139,
+      "log_bad": 2.2508,
+      "log_good": 2.3023
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1735.0,
+      "good": 2.8e3,
+      "ratio": 1.6138,
+      "suggested_scalar": 0.129,
+      "log_bad": 7.4588,
+      "log_good": 7.9374
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1333,
+      "good": 0.1519,
+      "ratio": 1.1395,
+      "suggested_scalar": 0.0352,
+      "log_bad": -2.0152,
+      "log_good": -1.8845
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9111,
+      "good": 0.7342,
+      "ratio": 0.8058,
+      "suggested_scalar": -0.0582,
+      "log_bad": -0.0931,
+      "log_good": -0.309
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 13.8421,
+      "good": 9.9873,
+      "ratio": 0.7215,
+      "suggested_scalar": -0.088,
+      "log_bad": 2.6277,
+      "log_good": 2.3013
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.6202,
+      "good": 2.7226,
+      "ratio": 4.3899,
+      "suggested_scalar": 0.3988,
+      "log_bad": -0.4777,
+      "log_good": 1.0016
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 145.0,
+      "good": 186.0,
+      "ratio": 1.2828,
+      "suggested_scalar": 0.0671,
+      "log_bad": 4.9767,
+      "log_good": 5.2257
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9447,
+      "good": 0.915,
+      "ratio": 0.9686,
+      "suggested_scalar": -0.0086,
+      "log_bad": -0.0569,
+      "log_good": -0.0888
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 26.0,
+      "ratio": 0.963,
+      "suggested_scalar": -0.0102,
+      "log_bad": 3.2958,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6346,
+      "good": 0.7214,
+      "ratio": 1.1368,
+      "suggested_scalar": 0.0346,
+      "log_bad": -0.4548,
+      "log_good": -0.3266
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5134,
+      "good": 0.615,
+      "ratio": 1.1979,
+      "suggested_scalar": 0.0487,
+      "log_bad": -0.6667,
+      "log_good": -0.4861
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7366,
+      "good": 3.5897,
+      "ratio": 1.3117,
+      "suggested_scalar": 0.0732,
+      "log_bad": 1.0067,
+      "log_good": 1.2781
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 524.0,
+      "good": 787.0,
+      "ratio": 1.5019,
+      "suggested_scalar": 0.1097,
+      "log_bad": 6.2615,
+      "log_good": 6.6682
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0776,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0209,
+      "good": 0.0139,
+      "ratio": 0.6651,
+      "suggested_scalar": -0.11,
+      "log_bad": -3.868,
+      "log_good": -4.2759
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0444,
+      "good": 6.0224,
+      "ratio": 0.9964,
+      "suggested_scalar": -0.001,
+      "log_bad": 1.7991,
+      "log_good": 1.7955
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 17.0,
+      "good": 37.0,
+      "ratio": 2.1765,
+      "suggested_scalar": 0.2097,
+      "log_bad": 2.8332,
+      "log_good": 3.6109
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.5736,
+      "good": 0.7159,
+      "ratio": 1.2481,
+      "suggested_scalar": 0.0597,
+      "log_bad": -0.5558,
+      "log_good": -0.3342
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5253,
+      "good": 5.5934,
+      "ratio": 1.0123,
+      "suggested_scalar": 0.0033,
+      "log_bad": 1.7093,
+      "log_good": 1.7216
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8075,
+      "good": 0.7885,
+      "ratio": 0.9765,
+      "suggested_scalar": -0.0064,
+      "log_bad": -0.2138,
+      "log_good": -0.2376
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2241,
+      "good": 0.21,
+      "ratio": 0.9371,
+      "suggested_scalar": -0.0175,
+      "log_bad": -1.4957,
+      "log_good": -1.5606
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.0814,
+      "good": 3.1618,
+      "ratio": 1.0261,
+      "suggested_scalar": 0.0069,
+      "log_bad": 1.1254,
+      "log_good": 1.1511
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 6.0,
+      "good": 29.0,
+      "ratio": 4.8333,
+      "suggested_scalar": 0.4248,
+      "log_bad": 1.7918,
+      "log_good": 3.3673
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 327.0,
+      "good": 412.0,
+      "ratio": 1.2599,
+      "suggested_scalar": 0.0623,
+      "log_bad": 5.79,
+      "log_good": 6.021
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9802,
+      "good": 1.4916,
+      "ratio": 1.5217,
+      "suggested_scalar": 0.1132,
+      "log_bad": -0.02,
+      "log_good": 0.3998
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 97.0,
+      "good": 108.0,
+      "ratio": 1.1134,
+      "suggested_scalar": 0.029,
+      "log_bad": 4.5747,
+      "log_good": 4.6821
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 845.0,
+      "good": 1263.0,
+      "ratio": 1.4947,
+      "suggested_scalar": 0.1084,
+      "log_bad": 6.7393,
+      "log_good": 7.1412
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 168.0,
+      "good": 251.0,
+      "ratio": 1.494,
+      "suggested_scalar": 0.1082,
+      "log_bad": 5.124,
+      "log_good": 5.5255
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2376,
+      "good": 0.2129,
+      "ratio": 0.896,
+      "suggested_scalar": -0.0296,
+      "log_bad": -1.4372,
+      "log_good": -1.5469
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 87.0,
+      "good": 112.0,
+      "ratio": 1.2874,
+      "suggested_scalar": 0.0681,
+      "log_bad": 4.4659,
+      "log_good": 4.7185
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 11.0,
+      "good": 10.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0257,
+      "log_bad": 2.3979,
+      "log_good": 2.3026
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 97.0,
+      "good": 108.0,
+      "ratio": 1.1134,
+      "suggested_scalar": 0.029,
+      "log_bad": 4.5747,
+      "log_good": 4.6821
+    },
+    "brevity.mean_sample_size": {
+      "bad": 97.0,
+      "good": 108.0,
+      "ratio": 1.1134,
+      "suggested_scalar": 0.029,
+      "log_bad": 4.5747,
+      "log_good": 4.6821
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 526.0,
+      "good": 789.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1093,
+      "log_bad": 6.2653,
+      "log_good": 6.6708
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 283.0,
+      "good": 404.0,
+      "ratio": 1.4276,
+      "suggested_scalar": 0.096,
+      "log_bad": 5.6454,
+      "log_good": 6.0014
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 258.0,
+      "good": 296.0,
+      "ratio": 1.1473,
+      "suggested_scalar": 0.037,
+      "log_bad": 5.553,
+      "log_good": 5.6904
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0114,
+      "good": 0.0368,
+      "ratio": 3.2281,
+      "suggested_scalar": 0.3159,
+      "log_bad": -4.4741,
+      "log_good": -3.3023
+    },
+    "heaps.mean_k": {
+      "bad": 5.2931,
+      "good": 5.5074,
+      "ratio": 1.0405,
+      "suggested_scalar": 0.0107,
+      "log_bad": 1.6664,
+      "log_good": 1.7061
+    },
+    "halstead.mean_effort": {
+      "bad": 116999.5951,
+      "good": 200018.1327,
+      "ratio": 1.7096,
+      "suggested_scalar": 0.1446,
+      "log_bad": 11.6699,
+      "log_good": 12.2062
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8372,
+      "good": 0.8281,
+      "ratio": 0.9891,
+      "suggested_scalar": -0.0029,
+      "log_bad": -0.1777,
+      "log_good": -0.1886
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 57.0,
+      "good": 73.0,
+      "ratio": 1.2807,
+      "suggested_scalar": 0.0667,
+      "log_bad": 4.0431,
+      "log_good": 4.2905
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 292.0,
+      "good": 424.0,
+      "ratio": 1.4521,
+      "suggested_scalar": 0.1006,
+      "log_bad": 5.6768,
+      "log_good": 6.0497
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3232,
+      "good": 0.2533,
+      "ratio": 0.7837,
+      "suggested_scalar": -0.0657,
+      "log_bad": -1.1295,
+      "log_good": -1.3732
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.1524,
+      "good": 5.6133,
+      "ratio": 1.0895,
+      "suggested_scalar": 0.0231,
+      "log_bad": 1.6395,
+      "log_good": 1.7251
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2241,
+      "good": 0.21,
+      "ratio": 0.9371,
+      "suggested_scalar": -0.0175,
+      "log_bad": -1.4957,
+      "log_good": -1.5606
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.0702,
+      "good": 4.4641,
+      "ratio": 0.7354,
+      "suggested_scalar": -0.0829,
+      "log_bad": 1.8034,
+      "log_good": 1.4961
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 525.0,
+      "good": 788.0,
+      "ratio": 1.501,
+      "suggested_scalar": 0.1095,
+      "log_bad": 6.2634,
+      "log_good": 6.6695
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 72.0,
+      "good": 109.0,
+      "ratio": 1.5139,
+      "suggested_scalar": 0.1118,
+      "log_bad": 4.2767,
+      "log_good": 4.6913
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6499.9775,
+      "good": 11112.1185,
+      "ratio": 1.7096,
+      "suggested_scalar": 0.1446,
+      "log_bad": 8.7796,
+      "log_good": 9.3158
+    },
+    "readability.mean_total_lines": {
+      "bad": 38.0,
+      "good": 79.0,
+      "ratio": 2.0789,
+      "suggested_scalar": 0.1973,
+      "log_bad": 3.6376,
+      "log_good": 4.3694
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1093,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2940.466,
+      "good": 4474.8157,
+      "ratio": 1.5218,
+      "suggested_scalar": 0.1132,
+      "log_bad": 7.9863,
+      "log_good": 8.4062
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 634.0,
+      "good": 780.0,
+      "ratio": 1.2303,
+      "suggested_scalar": 0.0559,
+      "log_bad": 6.452,
+      "log_good": 6.6593
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 38.2105,
+      "good": 34.1519,
+      "ratio": 0.8938,
+      "suggested_scalar": -0.0303,
+      "log_bad": 3.6431,
+      "log_good": 3.5308
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0444,
+      "good": 1.0411,
+      "ratio": 0.9968,
+      "suggested_scalar": -0.0009,
+      "log_bad": 0.0434,
+      "log_good": 0.0403
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 15.0,
+      "good": 42.0,
+      "ratio": 2.8,
+      "suggested_scalar": 0.2776,
+      "log_bad": 2.7081,
+      "log_good": 3.7377
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 1.0,
+      "ratio": 0.1429,
+      "suggested_scalar": -0.5246,
+      "log_bad": 1.9459,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7798,
+      "good": 0.7354,
+      "ratio": 0.9431,
+      "suggested_scalar": -0.0158,
+      "log_bad": -0.2487,
+      "log_good": -0.3073
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9047,
+      "good": 0.964,
+      "ratio": 1.0655,
+      "suggested_scalar": 0.0171,
+      "log_bad": -0.1002,
+      "log_good": -0.0367
+    },
+    "halstead.mean_length": {
+      "bad": 460.0,
+      "good": 675.0,
+      "ratio": 1.4674,
+      "suggested_scalar": 0.1034,
+      "log_bad": 6.1312,
+      "log_good": 6.5147
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 2.5455,
+      "good": 2.3,
+      "ratio": 0.9036,
+      "suggested_scalar": -0.0273,
+      "log_bad": 0.9343,
+      "log_good": 0.8329
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5999,
+      "good": 6.7549,
+      "ratio": 1.0235,
+      "suggested_scalar": 0.0063,
+      "log_bad": 1.8871,
+      "log_good": 1.9103
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1646,
+      "good": 0.1444,
+      "ratio": 0.8773,
+      "suggested_scalar": -0.0353,
+      "log_bad": -1.8042,
+      "log_good": -1.9352
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 39.7895,
+      "good": 44.6986,
+      "ratio": 1.1234,
+      "suggested_scalar": 0.0314,
+      "log_bad": 3.6836,
+      "log_good": 3.7999
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 12.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1869,
+      "log_bad": 1.7918,
+      "log_good": 2.4849
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 53.0,
+      "good": 57.0,
+      "ratio": 1.0755,
+      "suggested_scalar": 0.0196,
+      "log_bad": 3.9703,
+      "log_good": 4.0431
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6628,
+      "good": 0.6216,
+      "ratio": 0.9378,
+      "suggested_scalar": -0.0173,
+      "log_bad": -0.4113,
+      "log_good": -0.4755
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 45.0,
+      "good": 79.0,
+      "ratio": 1.7556,
+      "suggested_scalar": 0.1517,
+      "log_bad": 3.8067,
+      "log_good": 4.3694
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1869,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.getter_has_no_prefix": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.3355,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0034,
+      "good": 0.0071,
+      "ratio": 2.0882,
+      "suggested_scalar": 0.4836,
+      "log_bad": -5.684,
+      "log_good": -4.9477
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.75,
+      "good": 1.75,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.5596,
+      "log_good": 0.5596
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7838,
+      "good": 0.7857,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.0016,
+      "log_bad": -0.2436,
+      "log_good": -0.2412
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0034,
+      "good": 0.0071,
+      "ratio": 2.0882,
+      "suggested_scalar": 0.4836,
+      "log_bad": -5.684,
+      "log_good": -4.9477
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5488,
+      "good": 4.5357,
+      "ratio": 0.9971,
+      "suggested_scalar": -0.0019,
+      "log_bad": 1.5149,
+      "log_good": 1.512
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 73.0,
+      "good": 67.0,
+      "ratio": 0.9178,
+      "suggested_scalar": -0.0563,
+      "log_bad": 4.2905,
+      "log_good": 4.2047
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4737,
+      "good": 0.4382,
+      "ratio": 0.9251,
+      "suggested_scalar": -0.0512,
+      "log_bad": -0.7472,
+      "log_good": -0.8251
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 19.0,
+      "ratio": 0.95,
+      "suggested_scalar": -0.0337,
+      "log_bad": 2.9957,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5996,
+      "good": 0.5809,
+      "ratio": 0.9688,
+      "suggested_scalar": -0.0208,
+      "log_bad": -0.5115,
+      "log_good": -0.5432
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.3243,
+      "good": 4.0,
+      "ratio": 0.925,
+      "suggested_scalar": -0.0512,
+      "log_bad": 1.4643,
+      "log_good": 1.3863
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 298.0,
+      "good": 283.0,
+      "ratio": 0.9497,
+      "suggested_scalar": -0.0339,
+      "log_bad": 5.6971,
+      "log_good": 5.6454
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1081,
+      "good": 0.0952,
+      "ratio": 0.8807,
+      "suggested_scalar": -0.0835,
+      "log_bad": -2.2247,
+      "log_good": -2.3518
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0186,
+      "good": 0.9913,
+      "ratio": 0.9732,
+      "suggested_scalar": -0.0178,
+      "log_bad": 0.0184,
+      "log_good": -0.0087
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 95.0,
+      "good": 89.0,
+      "ratio": 0.9368,
+      "suggested_scalar": -0.0429,
+      "log_bad": 4.5539,
+      "log_good": 4.4886
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 109.0669,
+      "good": 113.1739,
+      "ratio": 1.0377,
+      "suggested_scalar": 0.0243,
+      "log_bad": 4.692,
+      "log_good": 4.7289
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6667,
+      "good": 0.6773,
+      "ratio": 1.0159,
+      "suggested_scalar": 0.0104,
+      "log_bad": -0.4054,
+      "log_good": -0.3896
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 4.6752,
+      "good": 3.4445,
+      "ratio": 0.7368,
+      "suggested_scalar": -0.2007,
+      "log_bad": 1.5423,
+      "log_good": 1.2368
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1095.0,
+      "good": 1056.0,
+      "ratio": 0.9644,
+      "suggested_scalar": -0.0238,
+      "log_bad": 6.9985,
+      "log_good": 6.9622
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 0.0476,
+      "ratio": 0.0476,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -3.0449
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7568,
+      "good": 0.7619,
+      "ratio": 1.0067,
+      "suggested_scalar": 0.0044,
+      "log_bad": -0.2787,
+      "log_good": -0.2719
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.2778,
+      "good": 7.075,
+      "ratio": 0.8547,
+      "suggested_scalar": -0.1031,
+      "log_bad": 2.1136,
+      "log_good": 1.9566
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.5164,
+      "good": 6.0952,
+      "ratio": 1.1049,
+      "suggested_scalar": 0.0655,
+      "log_bad": 1.7077,
+      "log_good": 1.8075
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 65.0,
+      "good": 54.0,
+      "ratio": 0.8308,
+      "suggested_scalar": -0.1218,
+      "log_bad": 4.1744,
+      "log_good": 3.989
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.8832,
+      "good": 0.9009,
+      "ratio": 1.02,
+      "suggested_scalar": 0.013,
+      "log_bad": -0.1242,
+      "log_good": -0.1044
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 23.0,
+      "ratio": 0.9583,
+      "suggested_scalar": -0.028,
+      "log_bad": 3.1781,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6128,
+      "good": 0.5928,
+      "ratio": 0.9674,
+      "suggested_scalar": -0.0218,
+      "log_bad": -0.4897,
+      "log_good": -0.5229
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4764,
+      "good": 0.4555,
+      "ratio": 0.9561,
+      "suggested_scalar": -0.0295,
+      "log_bad": -0.7415,
+      "log_good": -0.7864
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5825,
+      "good": 2.4558,
+      "ratio": 0.9509,
+      "suggested_scalar": -0.033,
+      "log_bad": 0.9488,
+      "log_good": 0.8985
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 296.0,
+      "good": 281.0,
+      "ratio": 0.9493,
+      "suggested_scalar": -0.0342,
+      "log_bad": 5.6904,
+      "log_good": 5.6384
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1198,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.057,
+      "good": 0.053,
+      "ratio": 0.9298,
+      "suggested_scalar": -0.0478,
+      "log_bad": -2.8647,
+      "log_good": -2.9375
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8826,
+      "good": 5.9307,
+      "ratio": 1.0082,
+      "suggested_scalar": 0.0053,
+      "log_bad": 1.772,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 22.0,
+      "good": 27.0,
+      "ratio": 1.2273,
+      "suggested_scalar": 0.1345,
+      "log_bad": 3.091,
+      "log_good": 3.2958
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1639,
+      "good": 1.2718,
+      "ratio": 1.0927,
+      "suggested_scalar": 0.0582,
+      "log_bad": 0.1518,
+      "log_good": 0.2404
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4867,
+      "good": 5.4411,
+      "ratio": 0.9917,
+      "suggested_scalar": -0.0055,
+      "log_bad": 1.7023,
+      "log_good": 1.694
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7733,
+      "good": 0.7648,
+      "ratio": 0.989,
+      "suggested_scalar": -0.0073,
+      "log_bad": -0.2571,
+      "log_good": -0.2681
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1778,
+      "good": 0.1765,
+      "ratio": 0.9927,
+      "suggested_scalar": -0.0048,
+      "log_bad": -1.7271,
+      "log_good": -1.7344
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.1622,
+      "good": 1.8559,
+      "ratio": 0.8583,
+      "suggested_scalar": -0.1003,
+      "log_bad": 0.7711,
+      "log_good": 0.6184
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 201.0,
+      "good": 201.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.3033,
+      "log_good": 5.3033
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.189,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5942,
+      "good": 0.5439,
+      "ratio": 0.9153,
+      "suggested_scalar": -0.0581,
+      "log_bad": -0.5205,
+      "log_good": -0.609
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 76.0,
+      "good": 70.0,
+      "ratio": 0.9211,
+      "suggested_scalar": -0.054,
+      "log_bad": 4.3307,
+      "log_good": 4.2485
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 466.0,
+      "good": 423.0,
+      "ratio": 0.9077,
+      "suggested_scalar": -0.0636,
+      "log_bad": 6.1442,
+      "log_good": 6.0474
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 114.0,
+      "good": 109.0,
+      "ratio": 0.9561,
+      "suggested_scalar": -0.0295,
+      "log_bad": 4.7362,
+      "log_good": 4.6913
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0201,
+      "good": 0.0212,
+      "ratio": 1.0547,
+      "suggested_scalar": 0.035,
+      "log_bad": -3.907,
+      "log_good": -3.8538
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2651,
+      "good": 0.2615,
+      "ratio": 0.9864,
+      "suggested_scalar": -0.009,
+      "log_bad": -1.3276,
+      "log_good": -1.3413
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 57.0,
+      "good": 66.0,
+      "ratio": 1.1579,
+      "suggested_scalar": 0.0963,
+      "log_bad": 4.0431,
+      "log_good": 4.1897
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 76.0,
+      "good": 70.0,
+      "ratio": 0.9211,
+      "suggested_scalar": -0.054,
+      "log_bad": 4.3307,
+      "log_good": 4.2485
+    },
+    "brevity.mean_sample_size": {
+      "bad": 76.0,
+      "good": 70.0,
+      "ratio": 0.9211,
+      "suggested_scalar": -0.054,
+      "log_bad": 4.3307,
+      "log_good": 4.2485
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 298.0,
+      "good": 283.0,
+      "ratio": 0.9497,
+      "suggested_scalar": -0.0339,
+      "log_bad": 5.6971,
+      "log_good": 5.6454
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 156.0,
+      "good": 148.0,
+      "ratio": 0.9487,
+      "suggested_scalar": -0.0346,
+      "log_bad": 5.0499,
+      "log_good": 4.9972
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 156.0,
+      "good": 157.0,
+      "ratio": 1.0064,
+      "suggested_scalar": 0.0042,
+      "log_bad": 5.0499,
+      "log_good": 5.0562
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.4821,
+      "good": 2.7316,
+      "ratio": 1.1005,
+      "suggested_scalar": 0.0629,
+      "log_bad": 0.9091,
+      "log_good": 1.0049
+    },
+    "halstead.mean_effort": {
+      "bad": 49769.2212,
+      "good": 46487.1298,
+      "ratio": 0.9341,
+      "suggested_scalar": -0.0448,
+      "log_bad": 10.8152,
+      "log_good": 10.7469
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8782,
+      "good": 0.8877,
+      "ratio": 1.0108,
+      "suggested_scalar": 0.0071,
+      "log_bad": -0.1299,
+      "log_good": -0.1191
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 49.0,
+      "good": 44.0,
+      "ratio": 0.898,
+      "suggested_scalar": -0.0707,
+      "log_bad": 3.8918,
+      "log_good": 3.7842
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 174.0,
+      "good": 160.0,
+      "ratio": 0.9195,
+      "suggested_scalar": -0.0551,
+      "log_bad": 5.1591,
+      "log_good": 5.0752
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4737,
+      "good": 0.4382,
+      "ratio": 0.9251,
+      "suggested_scalar": -0.0512,
+      "log_bad": -0.7472,
+      "log_good": -0.8251
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.9053,
+      "good": 4.7528,
+      "ratio": 0.9689,
+      "suggested_scalar": -0.0207,
+      "log_bad": 1.5903,
+      "log_good": 1.5587
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1778,
+      "good": 0.1765,
+      "ratio": 0.9927,
+      "suggested_scalar": -0.0048,
+      "log_bad": -1.7271,
+      "log_good": -1.7344
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.3111,
+      "good": 2.83,
+      "ratio": 0.8547,
+      "suggested_scalar": -0.1031,
+      "log_bad": 1.1973,
+      "log_good": 1.0403
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 297.0,
+      "good": 282.0,
+      "ratio": 0.9495,
+      "suggested_scalar": -0.034,
+      "log_bad": 5.6937,
+      "log_good": 5.6419
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.4553,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 46.0,
+      "good": 48.0,
+      "ratio": 1.0435,
+      "suggested_scalar": 0.028,
+      "log_bad": 3.8286,
+      "log_good": 3.8712
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2764.9567,
+      "good": 2582.6183,
+      "ratio": 0.9341,
+      "suggested_scalar": -0.0448,
+      "log_bad": 7.9248,
+      "log_good": 7.8566
+    },
+    "readability.mean_total_lines": {
+      "bad": 36.0,
+      "good": 40.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0692,
+      "log_bad": 3.5835,
+      "log_good": 3.6889
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 1782.6695,
+      "good": 1631.778,
+      "ratio": 0.9154,
+      "suggested_scalar": -0.0581,
+      "log_bad": 7.4859,
+      "log_good": 7.3974
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 424.0,
+      "good": 430.0,
+      "ratio": 1.0142,
+      "suggested_scalar": 0.0092,
+      "log_bad": 6.0497,
+      "log_good": 6.0638
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 28.4722,
+      "good": 23.6,
+      "ratio": 0.8289,
+      "suggested_scalar": -0.1233,
+      "log_bad": 3.3489,
+      "log_good": 3.1612
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0563,
+      "good": 1.0222,
+      "ratio": 0.9677,
+      "suggested_scalar": -0.0216,
+      "log_bad": 0.0548,
+      "log_good": 0.022
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 14.0,
+      "good": 10.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.221,
+      "log_bad": 2.6391,
+      "log_good": 2.3026
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7711,
+      "good": 0.7612,
+      "ratio": 0.9872,
+      "suggested_scalar": -0.0085,
+      "log_bad": -0.2599,
+      "log_good": -0.2729
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9704,
+      "good": 0.9778,
+      "ratio": 1.0076,
+      "suggested_scalar": 0.005,
+      "log_bad": -0.03,
+      "log_good": -0.0225
+    },
+    "halstead.mean_length": {
+      "bad": 288.0,
+      "good": 269.0,
+      "ratio": 0.934,
+      "suggested_scalar": -0.0448,
+      "log_bad": 5.663,
+      "log_good": 5.5947
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.375,
+      "good": 4.25,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.019,
+      "log_bad": 1.4759,
+      "log_good": 1.4469
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2479,
+      "good": 6.1293,
+      "ratio": 0.981,
+      "suggested_scalar": -0.0126,
+      "log_bad": 1.8322,
+      "log_good": 1.8131
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1427,
+      "good": 0.1407,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0093,
+      "log_bad": -1.947,
+      "log_good": -1.9611
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.9184,
+      "good": 28.4886,
+      "ratio": 1.0204,
+      "suggested_scalar": 0.0133,
+      "log_bad": 3.3293,
+      "log_good": 3.3495
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.4553,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 45.0,
+      "good": 39.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.094,
+      "log_bad": 3.8067,
+      "log_good": 3.6636
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6346,
+      "good": 0.5796,
+      "ratio": 0.9133,
+      "suggested_scalar": -0.0595,
+      "log_bad": -0.4548,
+      "log_good": -0.5454
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 37.0,
+      "good": 42.0,
+      "ratio": 1.1351,
+      "suggested_scalar": 0.0833,
+      "log_bad": 3.6109,
+      "log_good": 3.7377
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 12.0,
+      "good": 10.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1198,
+      "log_bad": 2.4849,
+      "log_good": 2.3026
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.uses_raise_from": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 56.0,
+      "good": 54.0,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.0498,
+      "log_bad": 4.0254,
+      "log_good": 3.989
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0582,
+      "good": 0.0597,
+      "ratio": 1.0258,
+      "suggested_scalar": 0.0348,
+      "log_bad": -2.8439,
+      "log_good": -2.8184
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6,
+      "good": 1.6,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.47,
+      "log_good": 0.47
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9412,
+      "good": 0.8909,
+      "ratio": 0.9466,
+      "suggested_scalar": -0.0752,
+      "log_bad": -0.0606,
+      "log_good": -0.1155
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0603,
+      "good": 0.0597,
+      "ratio": 0.99,
+      "suggested_scalar": -0.0137,
+      "log_bad": -2.8084,
+      "log_good": -2.8184
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7457,
+      "good": 4.6716,
+      "ratio": 0.9844,
+      "suggested_scalar": -0.0216,
+      "log_bad": 1.5572,
+      "log_good": 1.5415
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 109.0,
+      "good": 93.0,
+      "ratio": 0.8532,
+      "suggested_scalar": -0.2174,
+      "log_bad": 4.6913,
+      "log_good": 4.5326
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5307,
+      "good": 0.4811,
+      "ratio": 0.9065,
+      "suggested_scalar": -0.1344,
+      "log_bad": -0.6336,
+      "log_good": -0.7317
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 16.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.1613,
+      "log_bad": 2.8904,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6691,
+      "good": 0.6291,
+      "ratio": 0.9402,
+      "suggested_scalar": -0.0844,
+      "log_bad": -0.4018,
+      "log_good": -0.4635
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.549,
+      "good": 5.0909,
+      "ratio": 1.1191,
+      "suggested_scalar": 0.1541,
+      "log_bad": 1.5149,
+      "log_good": 1.6275
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 481.0,
+      "good": 486.0,
+      "ratio": 1.0104,
+      "suggested_scalar": 0.0142,
+      "log_bad": 6.1759,
+      "log_good": 6.1862
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0009,
+      "good": 0.0009,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.0131,
+      "log_good": -7.0131
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0784,
+      "good": 0.0182,
+      "ratio": 0.2321,
+      "suggested_scalar": -2.0,
+      "log_bad": -2.5459,
+      "log_good": -4.0063
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9302,
+      "good": 0.9968,
+      "ratio": 1.0716,
+      "suggested_scalar": 0.0947,
+      "log_bad": -0.0724,
+      "log_good": -0.0032
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 202.0,
+      "good": 197.0,
+      "ratio": 0.9752,
+      "suggested_scalar": -0.0343,
+      "log_bad": 5.3083,
+      "log_good": 5.2832
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 97.2051,
+      "good": 99.8611,
+      "ratio": 1.0273,
+      "suggested_scalar": 0.0369,
+      "log_bad": 4.5768,
+      "log_good": 4.6038
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4813,
+      "good": 0.5361,
+      "ratio": 1.1139,
+      "suggested_scalar": 0.1477,
+      "log_bad": -0.7313,
+      "log_good": -0.6234
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 14.4254,
+      "good": 14.4226,
+      "ratio": 0.9998,
+      "suggested_scalar": -0.0003,
+      "log_bad": 2.669,
+      "log_good": 2.6688
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2166.0,
+      "good": 2153.0,
+      "ratio": 0.994,
+      "suggested_scalar": -0.0082,
+      "log_bad": 7.6806,
+      "log_good": 7.6746
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2353,
+      "good": 0.2182,
+      "ratio": 0.9273,
+      "suggested_scalar": -0.1033,
+      "log_bad": -1.4469,
+      "log_good": -1.5223
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9412,
+      "good": 0.8909,
+      "ratio": 0.9466,
+      "suggested_scalar": -0.0752,
+      "log_bad": -0.0606,
+      "log_good": -0.1155
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.234,
+      "good": 9.0,
+      "ratio": 0.8794,
+      "suggested_scalar": -0.176,
+      "log_bad": 2.3257,
+      "log_good": 2.1972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 10.0515,
+      "good": 13.0645,
+      "ratio": 1.2998,
+      "suggested_scalar": 0.359,
+      "log_bad": 2.3077,
+      "log_good": 2.5699
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 158.0,
+      "good": 154.0,
+      "ratio": 0.9747,
+      "suggested_scalar": -0.0351,
+      "log_bad": 5.0626,
+      "log_good": 5.037
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9549,
+      "good": 0.953,
+      "ratio": 0.998,
+      "suggested_scalar": -0.0027,
+      "log_bad": -0.0461,
+      "log_good": -0.0481
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 30.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4012,
+      "log_good": 3.4012
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6048,
+      "good": 0.6349,
+      "ratio": 1.0498,
+      "suggested_scalar": 0.0665,
+      "log_bad": -0.5029,
+      "log_good": -0.4543
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2923,
+      "good": 0.345,
+      "ratio": 1.1803,
+      "suggested_scalar": 0.227,
+      "log_bad": -1.23,
+      "log_good": -1.0642
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5304,
+      "good": 2.7392,
+      "ratio": 1.0825,
+      "suggested_scalar": 0.1086,
+      "log_bad": 0.9284,
+      "log_good": 1.0077
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 479.0,
+      "good": 484.0,
+      "ratio": 1.0104,
+      "suggested_scalar": 0.0142,
+      "log_bad": 6.1717,
+      "log_good": 6.1821
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0457,
+      "good": 0.0453,
+      "ratio": 0.9912,
+      "suggested_scalar": -0.012,
+      "log_bad": -3.0857,
+      "log_good": -3.0944
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0224,
+      "good": 5.9307,
+      "ratio": 0.9848,
+      "suggested_scalar": -0.021,
+      "log_bad": 1.7955,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 36.0,
+      "good": 35.0,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.0386,
+      "log_bad": 3.5835,
+      "log_good": 3.5553
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9052,
+      "good": 0.9083,
+      "ratio": 1.0034,
+      "suggested_scalar": 0.0047,
+      "log_bad": -0.0996,
+      "log_good": -0.0962
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.0454,
+      "good": 5.8727,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.0397,
+      "log_bad": 1.7993,
+      "log_good": 1.7703
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.788,
+      "good": 0.7877,
+      "ratio": 0.9996,
+      "suggested_scalar": -0.0005,
+      "log_bad": -0.2383,
+      "log_good": -0.2386
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.25,
+      "good": 0.2361,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.0783,
+      "log_bad": -1.3863,
+      "log_good": -1.4435
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.7981,
+      "good": 3.7977,
+      "ratio": 0.9999,
+      "suggested_scalar": -0.0001,
+      "log_bad": 1.3345,
+      "log_good": 1.3344
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 385.0,
+      "good": 371.0,
+      "ratio": 0.9636,
+      "suggested_scalar": -0.0507,
+      "log_bad": 5.9532,
+      "log_good": 5.9162
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.2288,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8167,
+      "good": 0.7978,
+      "ratio": 0.9769,
+      "suggested_scalar": -0.0321,
+      "log_bad": -0.2025,
+      "log_good": -0.2259
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 133.0,
+      "good": 119.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.1523,
+      "log_bad": 4.8903,
+      "log_good": 4.7791
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1216.0,
+      "good": 1136.0,
+      "ratio": 0.9342,
+      "suggested_scalar": -0.0932,
+      "log_bad": 7.1033,
+      "log_good": 7.0353
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 160.0,
+      "good": 148.0,
+      "ratio": 0.925,
+      "suggested_scalar": -0.1068,
+      "log_bad": 5.0752,
+      "log_good": 4.9972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0104,
+      "good": 0.0103,
+      "ratio": 0.9904,
+      "suggested_scalar": -0.0132,
+      "log_bad": -4.5659,
+      "log_good": -4.5756
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2516,
+      "good": 0.2551,
+      "ratio": 1.0139,
+      "suggested_scalar": 0.0189,
+      "log_bad": -1.3799,
+      "log_good": -1.3661
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 67.0,
+      "good": 74.0,
+      "ratio": 1.1045,
+      "suggested_scalar": 0.1361,
+      "log_bad": 4.2047,
+      "log_good": 4.3041
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 133.0,
+      "good": 119.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.1523,
+      "log_bad": 4.8903,
+      "log_good": 4.7791
+    },
+    "brevity.mean_sample_size": {
+      "bad": 133.0,
+      "good": 119.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.1523,
+      "log_bad": 4.8903,
+      "log_good": 4.7791
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 481.0,
+      "good": 486.0,
+      "ratio": 1.0104,
+      "suggested_scalar": 0.0142,
+      "log_bad": 6.1759,
+      "log_good": 6.1862
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 220.0,
+      "good": 223.0,
+      "ratio": 1.0136,
+      "suggested_scalar": 0.0185,
+      "log_bad": 5.3936,
+      "log_good": 5.4072
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 316.0,
+      "good": 299.0,
+      "ratio": 0.9462,
+      "suggested_scalar": -0.0757,
+      "log_bad": 5.7557,
+      "log_good": 5.7004
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0021,
+      "good": 0.0021,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.1658,
+      "log_good": -6.1658
+    },
+    "heaps.mean_k": {
+      "bad": 2.388,
+      "good": 2.7552,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.1959,
+      "log_bad": 0.8705,
+      "log_good": 1.0135
+    },
+    "halstead.mean_effort": {
+      "bad": 74432.8929,
+      "good": 84336.4654,
+      "ratio": 1.1331,
+      "suggested_scalar": 0.1711,
+      "log_bad": 11.2177,
+      "log_good": 11.3426
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8569,
+      "good": 0.8517,
+      "ratio": 0.9939,
+      "suggested_scalar": -0.0083,
+      "log_bad": -0.1544,
+      "log_good": -0.1605
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 79.0,
+      "good": 63.0,
+      "ratio": 0.7975,
+      "suggested_scalar": -0.3099,
+      "log_bad": 4.3694,
+      "log_good": 4.1431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 202.0,
+      "good": 218.0,
+      "ratio": 1.0792,
+      "suggested_scalar": 0.1044,
+      "log_bad": 5.3083,
+      "log_good": 5.3845
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4604,
+      "good": 0.4112,
+      "ratio": 0.8931,
+      "suggested_scalar": -0.1548,
+      "log_bad": -0.7757,
+      "log_good": -0.8887
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0198,
+      "good": 5.7665,
+      "ratio": 0.9579,
+      "suggested_scalar": -0.0589,
+      "log_bad": 1.7951,
+      "log_good": 1.7521
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.25,
+      "good": 0.2361,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.0783,
+      "log_bad": -1.3863,
+      "log_good": -1.4435
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.8628,
+      "good": 4.2107,
+      "ratio": 0.8659,
+      "suggested_scalar": -0.1972,
+      "log_bad": 1.5816,
+      "log_good": 1.4376
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 480.0,
+      "good": 485.0,
+      "ratio": 1.0104,
+      "suggested_scalar": 0.0142,
+      "log_bad": 6.1738,
+      "log_good": 6.1841
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.9493,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 46.0,
+      "good": 54.0,
+      "ratio": 1.1739,
+      "suggested_scalar": 0.2196,
+      "log_bad": 3.8286,
+      "log_good": 3.989
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4135.1607,
+      "good": 4685.3592,
+      "ratio": 1.1331,
+      "suggested_scalar": 0.1711,
+      "log_bad": 8.3273,
+      "log_good": 8.4522
+    },
+    "readability.mean_total_lines": {
+      "bad": 47.0,
+      "good": 54.0,
+      "ratio": 1.1489,
+      "suggested_scalar": 0.1901,
+      "log_bad": 3.8501,
+      "log_good": 3.989
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2450.0827,
+      "good": 2393.3321,
+      "ratio": 0.9768,
+      "suggested_scalar": -0.0321,
+      "log_bad": 7.8039,
+      "log_good": 7.7804
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 856.0,
+      "good": 786.0,
+      "ratio": 0.9182,
+      "suggested_scalar": -0.1168,
+      "log_bad": 6.7523,
+      "log_good": 6.667
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 38.383,
+      "good": 37.1667,
+      "ratio": 0.9683,
+      "suggested_scalar": -0.0441,
+      "log_bad": 3.6476,
+      "log_good": 3.6154
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1731,
+      "good": 1.1565,
+      "ratio": 0.9858,
+      "suggested_scalar": -0.0195,
+      "log_bad": 0.1596,
+      "log_good": 0.1454
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 11.0,
+      "good": 14.0,
+      "ratio": 1.2727,
+      "suggested_scalar": 0.3303,
+      "log_bad": 2.3979,
+      "log_good": 2.6391
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 1.0,
+      "ratio": 0.25,
+      "suggested_scalar": -1.8985,
+      "log_bad": 1.3863,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8805,
+      "good": 0.8544,
+      "ratio": 0.9704,
+      "suggested_scalar": -0.0412,
+      "log_bad": -0.1273,
+      "log_good": -0.1574
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9708,
+      "good": 0.9638,
+      "ratio": 0.9928,
+      "suggested_scalar": -0.0099,
+      "log_bad": -0.0296,
+      "log_good": -0.0369
+    },
+    "halstead.mean_length": {
+      "bad": 362.0,
+      "good": 366.0,
+      "ratio": 1.011,
+      "suggested_scalar": 0.015,
+      "log_bad": 5.8916,
+      "log_good": 5.9026
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.4,
+      "good": 11.2,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.1015,
+      "log_bad": 2.3418,
+      "log_good": 2.4159
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.0553,
+      "good": 6.8948,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.0315,
+      "log_bad": 1.9538,
+      "log_good": 1.9308
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1019,
+      "good": 0.1036,
+      "ratio": 1.0167,
+      "suggested_scalar": 0.0227,
+      "log_bad": -2.2838,
+      "log_good": -2.2672
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.3797,
+      "good": 35.2381,
+      "ratio": 1.1599,
+      "suggested_scalar": 0.2032,
+      "log_bad": 3.4138,
+      "log_good": 3.5621
+    },
+    "branching.mean_branch_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 93.0,
+      "good": 81.0,
+      "ratio": 0.871,
+      "suggested_scalar": -0.1892,
+      "log_bad": 4.5326,
+      "log_good": 4.3944
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.788,
+      "good": 0.7525,
+      "ratio": 0.9549,
+      "suggested_scalar": -0.0631,
+      "log_bad": -0.2383,
+      "log_good": -0.2844
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 51.0,
+      "good": 55.0,
+      "ratio": 1.0784,
+      "suggested_scalar": 0.1034,
+      "log_bad": 3.9318,
+      "log_good": 4.0073
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.promise_returning_functions_are_async": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 23.0,
+      "good": 29.0,
+      "ratio": 1.2609,
+      "suggested_scalar": 0.1745,
+      "log_bad": 3.1355,
+      "log_good": 3.3673
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 13.0,
+      "good": 15.0,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.1077,
+      "log_bad": 2.5649,
+      "log_good": 2.7081
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.5219,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.011,
+      "good": 0.0113,
+      "ratio": 1.0273,
+      "suggested_scalar": 0.0203,
+      "log_bad": -4.5099,
+      "log_good": -4.483
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.2,
+      "ratio": 1.2,
+      "suggested_scalar": 0.1373,
+      "log_bad": 0.0,
+      "log_good": 0.1823
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8421,
+      "good": 0.8654,
+      "ratio": 1.0277,
+      "suggested_scalar": 0.0205,
+      "log_bad": -0.1719,
+      "log_good": -0.1446
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.011,
+      "good": 0.0113,
+      "ratio": 1.0273,
+      "suggested_scalar": 0.0203,
+      "log_bad": -4.5099,
+      "log_good": -4.483
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7224,
+      "good": 4.7532,
+      "ratio": 1.0065,
+      "suggested_scalar": 0.0049,
+      "log_bad": 1.5523,
+      "log_good": 1.5588
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 86.0,
+      "good": 88.0,
+      "ratio": 1.0233,
+      "suggested_scalar": 0.0173,
+      "log_bad": 4.4543,
+      "log_good": 4.4773
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4281,
+      "good": 0.4433,
+      "ratio": 1.0355,
+      "suggested_scalar": 0.0263,
+      "log_bad": -0.8484,
+      "log_good": -0.8135
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.621,
+      "good": 0.6331,
+      "ratio": 1.0195,
+      "suggested_scalar": 0.0145,
+      "log_bad": -0.4764,
+      "log_good": -0.4571
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.5263,
+      "good": 1.9231,
+      "ratio": 0.7612,
+      "suggested_scalar": -0.2054,
+      "log_bad": 0.9268,
+      "log_good": 0.6539
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 455.0,
+      "good": 442.0,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.0218,
+      "log_bad": 6.1203,
+      "log_good": 6.0913
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1373,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.001,
+      "good": 0.001,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.9078,
+      "log_good": -6.9078
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0702,
+      "good": 1.0,
+      "ratio": 14.245,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.6564,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.001,
+      "good": 0.001,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.9078,
+      "log_good": -6.9078
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0362,
+      "good": 1.0318,
+      "ratio": 0.9958,
+      "suggested_scalar": -0.0032,
+      "log_bad": 0.0356,
+      "log_good": 0.0313
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 135.0,
+      "good": 129.0,
+      "ratio": 0.9556,
+      "suggested_scalar": -0.0342,
+      "log_bad": 4.9053,
+      "log_good": 4.8598
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 100.6836,
+      "good": 97.1328,
+      "ratio": 0.9647,
+      "suggested_scalar": -0.027,
+      "log_bad": 4.612,
+      "log_good": 4.5761
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6652,
+      "good": 0.6122,
+      "ratio": 0.9203,
+      "suggested_scalar": -0.0625,
+      "log_bad": -0.4077,
+      "log_good": -0.4907
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 16.7076,
+      "good": 18.4688,
+      "ratio": 1.1054,
+      "suggested_scalar": 0.0755,
+      "log_bad": 2.8159,
+      "log_good": 2.9161
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1920.0,
+      "good": 1941.0,
+      "ratio": 1.0109,
+      "suggested_scalar": 0.0082,
+      "log_bad": 7.5601,
+      "log_good": 7.571
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1228,
+      "good": 0.0577,
+      "ratio": 0.4699,
+      "suggested_scalar": -0.5687,
+      "log_bad": -2.0972,
+      "log_good": -2.8525
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.807,
+      "good": 0.8462,
+      "ratio": 1.0486,
+      "suggested_scalar": 0.0357,
+      "log_bad": -0.2144,
+      "log_good": -0.167
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.9825,
+      "good": 8.5,
+      "ratio": 1.0648,
+      "suggested_scalar": 0.0473,
+      "log_bad": 2.0773,
+      "log_good": 2.1401
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.4072,
+      "good": 2.7633,
+      "ratio": 0.511,
+      "suggested_scalar": -0.5054,
+      "log_bad": 1.6877,
+      "log_good": 1.0164
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 79.0,
+      "good": 72.0,
+      "ratio": 0.9114,
+      "suggested_scalar": -0.0699,
+      "log_bad": 4.3694,
+      "log_good": 4.2767
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9316,
+      "good": 0.9386,
+      "ratio": 1.0075,
+      "suggested_scalar": 0.0056,
+      "log_bad": -0.0709,
+      "log_good": -0.0634
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 29.0,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0255,
+      "log_bad": 3.4012,
+      "log_good": 3.3673
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6609,
+      "good": 0.6491,
+      "ratio": 0.9821,
+      "suggested_scalar": -0.0136,
+      "log_bad": -0.4142,
+      "log_good": -0.4322
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4547,
+      "good": 0.3773,
+      "ratio": 0.8298,
+      "suggested_scalar": -0.1405,
+      "log_bad": -0.7881,
+      "log_good": -0.9747
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9493,
+      "good": 2.8502,
+      "ratio": 0.9664,
+      "suggested_scalar": -0.0257,
+      "log_bad": 1.0816,
+      "log_good": 1.0474
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 453.0,
+      "good": 440.0,
+      "ratio": 0.9713,
+      "suggested_scalar": -0.0219,
+      "log_bad": 6.1159,
+      "log_good": 6.0868
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 17.0,
+      "good": 15.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.0942,
+      "log_bad": 2.8332,
+      "log_good": 2.7081
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0549,
+      "good": 0.0611,
+      "ratio": 1.1129,
+      "suggested_scalar": 0.0806,
+      "log_bad": -2.9022,
+      "log_good": -2.7952
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.9307,
+      "ratio": 1.004,
+      "suggested_scalar": 0.003,
+      "log_bad": 1.7761,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 33.0,
+      "good": 28.0,
+      "ratio": 0.8485,
+      "suggested_scalar": -0.1237,
+      "log_bad": 3.4965,
+      "log_good": 3.3322
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3842,
+      "good": 1.432,
+      "ratio": 1.0345,
+      "suggested_scalar": 0.0256,
+      "log_bad": 0.3251,
+      "log_good": 0.3591
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6557,
+      "good": 5.6653,
+      "ratio": 1.0017,
+      "suggested_scalar": 0.0013,
+      "log_bad": 1.7327,
+      "log_good": 1.7344
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7995,
+      "good": 0.8015,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0019,
+      "log_bad": -0.2238,
+      "log_good": -0.2213
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.0952,
+      "good": 0.1613,
+      "ratio": 1.6943,
+      "suggested_scalar": 0.397,
+      "log_bad": -2.3518,
+      "log_good": -1.8245
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.0875,
+      "good": 4.2975,
+      "ratio": 1.0514,
+      "suggested_scalar": 0.0377,
+      "log_bad": 1.4079,
+      "log_good": 1.458
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 321.0,
+      "good": 341.0,
+      "ratio": 1.0623,
+      "suggested_scalar": 0.0455,
+      "log_bad": 5.7714,
+      "log_good": 5.8319
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 25.0,
+      "good": 27.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.0579,
+      "log_bad": 3.2189,
+      "log_good": 3.2958
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.919,
+      "good": 0.8957,
+      "ratio": 0.9746,
+      "suggested_scalar": -0.0193,
+      "log_bad": -0.0845,
+      "log_good": -0.1101
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 90.0,
+      "good": 92.0,
+      "ratio": 1.0222,
+      "suggested_scalar": 0.0165,
+      "log_bad": 4.4998,
+      "log_good": 4.5218
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1007.0,
+      "good": 1061.0,
+      "ratio": 1.0536,
+      "suggested_scalar": 0.0393,
+      "log_bad": 6.9147,
+      "log_good": 6.967
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 152.0,
+      "good": 152.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.0239,
+      "log_good": 5.0239
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0132,
+      "good": 0.0068,
+      "ratio": 0.5152,
+      "suggested_scalar": -0.4994,
+      "log_bad": -4.3275,
+      "log_good": -4.9908
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2725,
+      "good": 0.2986,
+      "ratio": 1.0958,
+      "suggested_scalar": 0.0689,
+      "log_bad": -1.3001,
+      "log_good": -1.2087
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 92.0,
+      "good": 88.0,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.0335,
+      "log_bad": 4.5218,
+      "log_good": 4.4773
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.168,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 90.0,
+      "good": 92.0,
+      "ratio": 1.0222,
+      "suggested_scalar": 0.0165,
+      "log_bad": 4.4998,
+      "log_good": 4.5218
+    },
+    "brevity.mean_sample_size": {
+      "bad": 90.0,
+      "good": 92.0,
+      "ratio": 1.0222,
+      "suggested_scalar": 0.0165,
+      "log_bad": 4.4998,
+      "log_good": 4.5218
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 455.0,
+      "good": 442.0,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.0218,
+      "log_bad": 6.1203,
+      "log_good": 6.0913
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 260.0,
+      "good": 252.0,
+      "ratio": 0.9692,
+      "suggested_scalar": -0.0235,
+      "log_bad": 5.5607,
+      "log_good": 5.5294
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 244.0,
+      "good": 259.0,
+      "ratio": 1.0615,
+      "suggested_scalar": 0.0449,
+      "log_bad": 5.4972,
+      "log_good": 5.5568
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.2671,
+      "good": 2.1526,
+      "ratio": 0.9495,
+      "suggested_scalar": -0.039,
+      "log_bad": 0.8185,
+      "log_good": 0.7667
+    },
+    "halstead.mean_effort": {
+      "bad": 112243.8943,
+      "good": 100380.0053,
+      "ratio": 0.8943,
+      "suggested_scalar": -0.0841,
+      "log_bad": 11.6284,
+      "log_good": 11.5167
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8712,
+      "good": 0.8684,
+      "ratio": 0.9968,
+      "suggested_scalar": -0.0024,
+      "log_bad": -0.1379,
+      "log_good": -0.1411
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 56.0,
+      "good": 59.0,
+      "ratio": 1.0536,
+      "suggested_scalar": 0.0393,
+      "log_bad": 4.0254,
+      "log_good": 4.0775
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 277.0,
+      "good": 264.0,
+      "ratio": 0.9531,
+      "suggested_scalar": -0.0362,
+      "log_bad": 5.624,
+      "log_good": 5.5759
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.363,
+      "good": 0.3876,
+      "ratio": 1.0678,
+      "suggested_scalar": 0.0494,
+      "log_bad": -1.0134,
+      "log_good": -0.9478
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.4593,
+      "good": 8.2248,
+      "ratio": 1.1026,
+      "suggested_scalar": 0.0736,
+      "log_bad": 2.0095,
+      "log_good": 2.1072
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.0952,
+      "good": 0.1613,
+      "ratio": 1.6943,
+      "suggested_scalar": 0.397,
+      "log_bad": -2.3518,
+      "log_good": -1.8245
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.8084,
+      "good": 4.0316,
+      "ratio": 1.0586,
+      "suggested_scalar": 0.0429,
+      "log_bad": 1.3372,
+      "log_good": 1.3942
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 454.0,
+      "good": 441.0,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.0219,
+      "log_bad": 6.1181,
+      "log_good": 6.089
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.2166,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 74.0,
+      "good": 67.0,
+      "ratio": 0.9054,
+      "suggested_scalar": -0.0748,
+      "log_bad": 4.3041,
+      "log_good": 4.2047
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6235.7719,
+      "good": 5576.667,
+      "ratio": 0.8943,
+      "suggested_scalar": -0.0841,
+      "log_bad": 8.7381,
+      "log_good": 8.6263
+    },
+    "readability.mean_total_lines": {
+      "bad": 57.0,
+      "good": 52.0,
+      "ratio": 0.9123,
+      "suggested_scalar": -0.0691,
+      "log_bad": 4.0431,
+      "log_good": 3.9512
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 6.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.2166,
+      "log_bad": 2.0794,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2756.8676,
+      "good": 2687.1236,
+      "ratio": 0.9747,
+      "suggested_scalar": -0.0193,
+      "log_bad": 7.9219,
+      "log_good": 7.8962
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 651.0,
+      "good": 681.0,
+      "ratio": 1.0461,
+      "suggested_scalar": 0.0339,
+      "log_bad": 6.4785,
+      "log_good": 6.5236
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.5789,
+      "good": 36.1346,
+      "ratio": 1.1091,
+      "suggested_scalar": 0.078,
+      "log_bad": 3.4837,
+      "log_good": 3.5873
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.159,
+      "good": 1.1947,
+      "ratio": 1.0308,
+      "suggested_scalar": 0.0228,
+      "log_bad": 0.1476,
+      "log_good": 0.1779
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1373,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 21.0,
+      "good": 17.0,
+      "ratio": 0.8095,
+      "suggested_scalar": -0.1591,
+      "log_bad": 3.0445,
+      "log_good": 2.8332
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 1.0,
+      "ratio": 0.25,
+      "suggested_scalar": -1.0437,
+      "log_bad": 1.3863,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7695,
+      "good": 0.8035,
+      "ratio": 1.0442,
+      "suggested_scalar": 0.0326,
+      "log_bad": -0.262,
+      "log_good": -0.2188
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9489,
+      "good": 0.9636,
+      "ratio": 1.0155,
+      "suggested_scalar": 0.0116,
+      "log_bad": -0.0525,
+      "log_good": -0.0371
+    },
+    "halstead.mean_length": {
+      "bad": 429.0,
+      "good": 416.0,
+      "ratio": 0.9697,
+      "suggested_scalar": -0.0232,
+      "log_bad": 6.0615,
+      "log_good": 6.0307
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.75,
+      "good": 9.4,
+      "ratio": 0.8,
+      "suggested_scalar": -0.168,
+      "log_bad": 2.4639,
+      "log_good": 2.2407
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4919,
+      "good": 6.5236,
+      "ratio": 1.0049,
+      "suggested_scalar": 0.0037,
+      "log_bad": 1.8706,
+      "log_good": 1.8754
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1354,
+      "good": 0.1298,
+      "ratio": 0.9586,
+      "suggested_scalar": -0.0318,
+      "log_bad": -1.9995,
+      "log_good": -2.0418
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 40.7143,
+      "good": 37.3559,
+      "ratio": 0.9175,
+      "suggested_scalar": -0.0648,
+      "log_bad": 3.7066,
+      "log_good": 3.6205
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 3.0,
+      "ratio": 0.4286,
+      "suggested_scalar": -0.6379,
+      "log_bad": 1.9459,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 49.0,
+      "good": 50.0,
+      "ratio": 1.0204,
+      "suggested_scalar": 0.0152,
+      "log_bad": 3.8918,
+      "log_good": 3.912
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.623,
+      "good": 0.6602,
+      "ratio": 1.0597,
+      "suggested_scalar": 0.0437,
+      "log_bad": -0.4732,
+      "log_good": -0.4152
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 57.0,
+      "good": 52.0,
+      "ratio": 0.9123,
+      "suggested_scalar": -0.0691,
+      "log_bad": 4.0431,
+      "log_good": 3.9512
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 20.0,
+      "ratio": 1.1765,
+      "suggested_scalar": 0.1224,
+      "log_bad": 2.8332,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "documentation.every_declaration_has_doc_comment": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 24.0,
+      "good": 27.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.1606,
+      "log_bad": 3.1781,
+      "log_good": 3.2958
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0088,
+      "good": 0.0028,
+      "ratio": 0.3182,
+      "suggested_scalar": -1.5619,
+      "log_bad": -4.733,
+      "log_good": -5.8781
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.25,
+      "good": 1.25,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2231,
+      "log_good": 0.2231
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.86,
+      "good": 0.859,
+      "ratio": 0.9988,
+      "suggested_scalar": -0.0016,
+      "log_bad": -0.1508,
+      "log_good": -0.152
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0088,
+      "good": 0.0028,
+      "ratio": 0.3182,
+      "suggested_scalar": -1.5619,
+      "log_bad": -4.733,
+      "log_good": -5.8781
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.481,
+      "good": 4.4846,
+      "ratio": 1.0008,
+      "suggested_scalar": 0.0011,
+      "log_bad": 1.4998,
+      "log_good": 1.5006
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 97.0,
+      "good": 178.0,
+      "ratio": 1.8351,
+      "suggested_scalar": 0.828,
+      "log_bad": 4.5747,
+      "log_good": 5.1818
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.439,
+      "good": 0.5659,
+      "ratio": 1.2891,
+      "suggested_scalar": 0.3463,
+      "log_bad": -0.8233,
+      "log_good": -0.5693
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 21.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0665,
+      "log_bad": 2.9957,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7372,
+      "good": 0.6579,
+      "ratio": 0.8924,
+      "suggested_scalar": -0.1552,
+      "log_bad": -0.3049,
+      "log_good": -0.4187
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.8,
+      "good": 4.359,
+      "ratio": 0.9081,
+      "suggested_scalar": -0.1314,
+      "log_bad": 1.5686,
+      "log_good": 1.4722
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 342.0,
+      "good": 716.0,
+      "ratio": 2.0936,
+      "suggested_scalar": 1.0078,
+      "log_bad": 5.8348,
+      "log_good": 6.5737
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0005,
+      "good": 0.0003,
+      "ratio": 0.6,
+      "suggested_scalar": -0.6967,
+      "log_bad": -7.6009,
+      "log_good": -8.1117
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.18,
+      "good": 0.4744,
+      "ratio": 2.6356,
+      "suggested_scalar": 1.3218,
+      "log_bad": -1.7148,
+      "log_good": -0.7457
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0026,
+      "good": 0.0006,
+      "ratio": 0.2308,
+      "suggested_scalar": -2.0,
+      "log_bad": -5.9522,
+      "log_good": -7.4186
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9008,
+      "good": 0.9627,
+      "ratio": 1.0687,
+      "suggested_scalar": 0.0906,
+      "log_bad": -0.1045,
+      "log_good": -0.038
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 138.0,
+      "good": 325.0,
+      "ratio": 2.3551,
+      "suggested_scalar": 1.1683,
+      "log_bad": 4.9273,
+      "log_good": 5.7838
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.9118,
+      "good": 105.6426,
+      "ratio": 1.0366,
+      "suggested_scalar": 0.049,
+      "log_bad": 4.6241,
+      "log_good": 4.6601
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5073,
+      "good": 0.5091,
+      "ratio": 1.0035,
+      "suggested_scalar": 0.0048,
+      "log_bad": -0.6787,
+      "log_good": -0.6751
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 21.6848,
+      "good": 14.6037,
+      "ratio": 0.6735,
+      "suggested_scalar": -0.5392,
+      "log_bad": 3.0766,
+      "log_good": 2.6813
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1910.0,
+      "good": 3596.0,
+      "ratio": 1.8827,
+      "suggested_scalar": 0.863,
+      "log_bad": 7.5549,
+      "log_good": 8.1876
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.28,
+      "good": 0.3077,
+      "ratio": 1.0989,
+      "suggested_scalar": 0.1287,
+      "log_bad": -1.273,
+      "log_good": -1.1786
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.82,
+      "good": 0.8205,
+      "ratio": 1.0006,
+      "suggested_scalar": 0.0008,
+      "log_bad": -0.1985,
+      "log_good": -0.1978
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.84,
+      "good": 9.1795,
+      "ratio": 1.342,
+      "suggested_scalar": 0.4013,
+      "log_bad": 1.9228,
+      "log_good": 2.217
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 14.72,
+      "good": 10.3327,
+      "ratio": 0.7019,
+      "suggested_scalar": -0.4827,
+      "log_bad": 2.6892,
+      "log_good": 2.3353
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 78.0,
+      "good": 232.0,
+      "ratio": 2.9744,
+      "suggested_scalar": 1.4867,
+      "log_bad": 4.3567,
+      "log_good": 5.4467
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.8892,
+      "good": 0.9499,
+      "ratio": 1.0683,
+      "suggested_scalar": 0.0901,
+      "log_bad": -0.1174,
+      "log_good": -0.0514
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 35.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.2103,
+      "log_bad": 3.4012,
+      "log_good": 3.5553
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6539,
+      "good": 0.6532,
+      "ratio": 0.9989,
+      "suggested_scalar": -0.0015,
+      "log_bad": -0.4248,
+      "log_good": -0.4259
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3588,
+      "good": 0.3067,
+      "ratio": 0.8548,
+      "suggested_scalar": -0.214,
+      "log_bad": -1.025,
+      "log_good": -1.1819
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.8896,
+      "good": 2.8837,
+      "ratio": 0.998,
+      "suggested_scalar": -0.0028,
+      "log_bad": 1.0611,
+      "log_good": 1.0591
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 340.0,
+      "good": 714.0,
+      "ratio": 2.1,
+      "suggested_scalar": 1.012,
+      "log_bad": 5.8289,
+      "log_good": 6.5709
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 9.0,
+      "good": 13.0,
+      "ratio": 1.4444,
+      "suggested_scalar": 0.5016,
+      "log_bad": 2.1972,
+      "log_good": 2.5649
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0468,
+      "good": 0.0363,
+      "ratio": 0.7756,
+      "suggested_scalar": -0.3465,
+      "log_bad": -3.0619,
+      "log_good": -3.3159
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8826,
+      "good": 6.0,
+      "ratio": 1.02,
+      "suggested_scalar": 0.027,
+      "log_bad": 1.772,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 35.0,
+      "good": 65.0,
+      "ratio": 1.8571,
+      "suggested_scalar": 0.8443,
+      "log_bad": 3.5553,
+      "log_good": 4.1744
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4576,
+      "good": 1.1354,
+      "ratio": 0.779,
+      "suggested_scalar": -0.3407,
+      "log_bad": 0.3768,
+      "log_good": 0.127
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.0443,
+      "good": 6.2328,
+      "ratio": 1.0312,
+      "suggested_scalar": 0.0419,
+      "log_bad": 1.7991,
+      "log_good": 1.8298
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7617,
+      "good": 0.7474,
+      "ratio": 0.9812,
+      "suggested_scalar": -0.0258,
+      "log_bad": -0.2722,
+      "log_good": -0.2912
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1228,
+      "good": 0.0824,
+      "ratio": 0.671,
+      "suggested_scalar": -0.5442,
+      "log_bad": -2.0972,
+      "log_good": -2.4962
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.6567,
+      "good": 3.8215,
+      "ratio": 0.8206,
+      "suggested_scalar": -0.2696,
+      "log_bad": 1.5383,
+      "log_good": 1.3406
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 260.0,
+      "good": 559.0,
+      "ratio": 2.15,
+      "suggested_scalar": 1.0441,
+      "log_bad": 5.5607,
+      "log_good": 6.3261
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.9454,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6974,
+      "good": 1.7095,
+      "ratio": 2.4512,
+      "suggested_scalar": 1.2229,
+      "log_bad": -0.3604,
+      "log_good": 0.5362
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 102.0,
+      "good": 182.0,
+      "ratio": 1.7843,
+      "suggested_scalar": 0.7898,
+      "log_bad": 4.625,
+      "log_good": 5.204
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1035.0,
+      "good": 2153.0,
+      "ratio": 2.0802,
+      "suggested_scalar": 0.999,
+      "log_bad": 6.9422,
+      "log_good": 7.6746
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 160.0,
+      "good": 350.0,
+      "ratio": 2.1875,
+      "suggested_scalar": 1.0676,
+      "log_bad": 5.0752,
+      "log_good": 5.8579
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0117,
+      "good": 0.0056,
+      "ratio": 0.4786,
+      "suggested_scalar": -1.005,
+      "log_bad": -4.4482,
+      "log_good": -5.185
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1667,
+      "good": 0.1536,
+      "ratio": 0.9214,
+      "suggested_scalar": -0.1116,
+      "log_bad": -1.7916,
+      "log_good": -1.8734
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 53.0,
+      "good": 97.0,
+      "ratio": 1.8302,
+      "suggested_scalar": 0.8244,
+      "log_bad": 3.9703,
+      "log_good": 4.5747
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 102.0,
+      "good": 182.0,
+      "ratio": 1.7843,
+      "suggested_scalar": 0.7898,
+      "log_bad": 4.625,
+      "log_good": 5.204
+    },
+    "brevity.mean_sample_size": {
+      "bad": 102.0,
+      "good": 182.0,
+      "ratio": 1.7843,
+      "suggested_scalar": 0.7898,
+      "log_bad": 4.625,
+      "log_good": 5.204
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 342.0,
+      "good": 716.0,
+      "ratio": 2.0936,
+      "suggested_scalar": 1.0078,
+      "log_bad": 5.8348,
+      "log_good": 6.5737
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 144.0,
+      "good": 307.0,
+      "ratio": 2.1319,
+      "suggested_scalar": 1.0326,
+      "log_bad": 4.9698,
+      "log_good": 5.7268
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 221.0,
+      "good": 448.0,
+      "ratio": 2.0271,
+      "suggested_scalar": 0.9638,
+      "log_bad": 5.3982,
+      "log_good": 6.1048
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0058,
+      "good": 0.0028,
+      "ratio": 0.4828,
+      "suggested_scalar": -0.9933,
+      "log_bad": -5.1499,
+      "log_good": -5.8781
+    },
+    "heaps.mean_k": {
+      "bad": 1.4745,
+      "good": 2.6016,
+      "ratio": 1.7644,
+      "suggested_scalar": 0.7745,
+      "log_bad": 0.3883,
+      "log_good": 0.9561
+    },
+    "halstead.mean_effort": {
+      "bad": 74943.4879,
+      "good": 219658.4821,
+      "ratio": 2.931,
+      "suggested_scalar": 1.4667,
+      "log_bad": 11.2245,
+      "log_good": 12.2998
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.9059,
+      "good": 0.8302,
+      "ratio": 0.9164,
+      "suggested_scalar": -0.119,
+      "log_bad": -0.0988,
+      "log_good": -0.1861
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 67.0,
+      "good": 143.0,
+      "ratio": 2.1343,
+      "suggested_scalar": 1.0341,
+      "log_bad": 4.2047,
+      "log_good": 4.9628
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 157.0,
+      "good": 336.0,
+      "ratio": 2.1401,
+      "suggested_scalar": 1.0378,
+      "log_bad": 5.0562,
+      "log_good": 5.8171
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3986,
+      "good": 0.4031,
+      "ratio": 1.0113,
+      "suggested_scalar": 0.0153,
+      "log_bad": -0.9198,
+      "log_good": -0.9086
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.5,
+      "good": 6.6246,
+      "ratio": 0.8833,
+      "suggested_scalar": -0.1693,
+      "log_bad": 2.0149,
+      "log_good": 1.8908
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1228,
+      "good": 0.0824,
+      "ratio": 0.671,
+      "suggested_scalar": -0.5442,
+      "log_bad": -2.0972,
+      "log_good": -2.4962
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.5523,
+      "good": 4.0649,
+      "ratio": 1.1443,
+      "suggested_scalar": 0.1839,
+      "log_bad": 1.2676,
+      "log_good": 1.4024
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 341.0,
+      "good": 715.0,
+      "ratio": 2.0968,
+      "suggested_scalar": 1.0099,
+      "log_bad": 5.8319,
+      "log_good": 6.5723
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 42.0,
+      "good": 64.0,
+      "ratio": 1.5238,
+      "suggested_scalar": 0.5745,
+      "log_bad": 3.7377,
+      "log_good": 4.1589
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4163.5271,
+      "good": 12203.249,
+      "ratio": 2.931,
+      "suggested_scalar": 1.4667,
+      "log_bad": 8.3341,
+      "log_good": 9.4095
+    },
+    "readability.mean_total_lines": {
+      "bad": 50.0,
+      "good": 78.0,
+      "ratio": 1.56,
+      "suggested_scalar": 0.6065,
+      "log_bad": 3.912,
+      "log_good": 4.3567
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2092.1724,
+      "good": 5128.3531,
+      "ratio": 2.4512,
+      "suggested_scalar": 1.2229,
+      "log_bad": 7.646,
+      "log_good": 8.5425
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 661.0,
+      "good": 1247.0,
+      "ratio": 1.8865,
+      "suggested_scalar": 0.8658,
+      "log_bad": 6.4938,
+      "log_good": 7.1285
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 36.9,
+      "good": 45.0128,
+      "ratio": 1.2199,
+      "suggested_scalar": 0.2711,
+      "log_bad": 3.6082,
+      "log_good": 3.8069
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1582,
+      "good": 1.086,
+      "ratio": 0.9377,
+      "suggested_scalar": -0.0878,
+      "log_bad": 0.1469,
+      "log_good": 0.0825
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 11.0,
+      "good": 44.0,
+      "ratio": 4.0,
+      "suggested_scalar": 1.8908,
+      "log_bad": 2.3979,
+      "log_good": 3.7842
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 9.0,
+      "good": 37.0,
+      "ratio": 4.1111,
+      "suggested_scalar": 1.9282,
+      "log_bad": 2.1972,
+      "log_good": 3.6109
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8385,
+      "good": 0.8855,
+      "ratio": 1.0561,
+      "suggested_scalar": 0.0744,
+      "log_bad": -0.1761,
+      "log_good": -0.1216
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9885,
+      "good": 0.9851,
+      "ratio": 0.9966,
+      "suggested_scalar": -0.0047,
+      "log_bad": -0.0116,
+      "log_good": -0.015
+    },
+    "halstead.mean_length": {
+      "bad": 317.0,
+      "good": 686.0,
+      "ratio": 2.164,
+      "suggested_scalar": 1.0529,
+      "log_bad": 5.7589,
+      "log_good": 6.5309
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.25,
+      "good": 10.75,
+      "ratio": 1.4828,
+      "suggested_scalar": 0.5373,
+      "log_bad": 1.981,
+      "log_good": 2.3749
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6724,
+      "good": 7.5078,
+      "ratio": 1.1252,
+      "suggested_scalar": 0.1609,
+      "log_bad": 1.898,
+      "log_good": 2.0159
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0757,
+      "good": 0.0854,
+      "ratio": 1.1281,
+      "suggested_scalar": 0.1644,
+      "log_bad": -2.581,
+      "log_good": -2.4604
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 35.8209,
+      "good": 42.8322,
+      "ratio": 1.1957,
+      "suggested_scalar": 0.2438,
+      "log_bad": 3.5785,
+      "log_good": 3.7573
+    },
+    "branching.mean_branch_count": {
+      "bad": 14.0,
+      "good": 24.0,
+      "ratio": 1.7143,
+      "suggested_scalar": 0.7352,
+      "log_bad": 2.6391,
+      "log_good": 3.1781
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 55.0,
+      "good": 131.0,
+      "ratio": 2.3818,
+      "suggested_scalar": 1.1837,
+      "log_bad": 4.0073,
+      "log_good": 4.8752
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7602,
+      "good": 0.7835,
+      "ratio": 1.0306,
+      "suggested_scalar": 0.0412,
+      "log_bad": -0.2742,
+      "log_good": -0.244
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 50.0,
+      "good": 78.0,
+      "ratio": 1.56,
+      "suggested_scalar": 0.6065,
+      "log_bad": 3.912,
+      "log_good": 4.3567
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.uses_short_circuit_operators": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0055,
+      "good": 0.006,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0369,
+      "log_bad": -5.203,
+      "log_good": -5.116
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 1.5,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.4055,
+      "log_good": 0.4055
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7959,
+      "good": 0.7872,
+      "ratio": 0.9891,
+      "suggested_scalar": -0.0047,
+      "log_bad": -0.2283,
+      "log_good": -0.2393
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0055,
+      "good": 0.006,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0369,
+      "log_bad": -5.203,
+      "log_good": -5.116
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.3806,
+      "good": 4.3813,
+      "ratio": 1.0002,
+      "suggested_scalar": 0.0001,
+      "log_bad": 1.4772,
+      "log_good": 1.4773
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 102.0,
+      "good": 96.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0257,
+      "log_bad": 4.625,
+      "log_good": 4.5643
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5164,
+      "good": 0.5386,
+      "ratio": 1.043,
+      "suggested_scalar": 0.0179,
+      "log_bad": -0.6609,
+      "log_good": -0.6188
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 18.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0447,
+      "log_bad": 2.9957,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.603,
+      "good": 0.6049,
+      "ratio": 1.0032,
+      "suggested_scalar": 0.0013,
+      "log_bad": -0.5058,
+      "log_good": -0.5027
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 9.9592,
+      "good": 9.8723,
+      "ratio": 0.9913,
+      "suggested_scalar": -0.0037,
+      "log_bad": 2.2985,
+      "log_good": 2.2897
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 361.0,
+      "good": 335.0,
+      "ratio": 0.928,
+      "suggested_scalar": -0.0317,
+      "log_bad": 5.8889,
+      "log_good": 5.8141
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0043,
+      "good": 0.0048,
+      "ratio": 1.1163,
+      "suggested_scalar": 0.0467,
+      "log_bad": -5.4491,
+      "log_good": -5.3391
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1224,
+      "good": 0.0851,
+      "ratio": 0.6953,
+      "suggested_scalar": -0.1543,
+      "log_bad": -2.1005,
+      "log_good": -2.4639
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.001,
+      "good": 0.0011,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0405,
+      "log_bad": -6.9078,
+      "log_good": -6.8124
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9564,
+      "good": 0.9707,
+      "ratio": 1.015,
+      "suggested_scalar": 0.0063,
+      "log_bad": -0.0446,
+      "log_good": -0.0297
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 121.0,
+      "good": 106.0,
+      "ratio": 0.876,
+      "suggested_scalar": -0.0562,
+      "log_bad": 4.7958,
+      "log_good": 4.6634
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 91.9802,
+      "good": 91.7769,
+      "ratio": 0.9978,
+      "suggested_scalar": -0.0009,
+      "log_bad": 4.5216,
+      "log_good": 4.5194
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5333,
+      "good": 0.5359,
+      "ratio": 1.0049,
+      "suggested_scalar": 0.0021,
+      "log_bad": -0.6287,
+      "log_good": -0.6238
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 14.0951,
+      "good": 11.15,
+      "ratio": 0.7911,
+      "suggested_scalar": -0.0995,
+      "log_bad": 2.6458,
+      "log_good": 2.4114
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2078.0,
+      "good": 1869.0,
+      "ratio": 0.8994,
+      "suggested_scalar": -0.045,
+      "log_bad": 7.6392,
+      "log_good": 7.5332
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1633,
+      "good": 0.0851,
+      "ratio": 0.5211,
+      "suggested_scalar": -0.2767,
+      "log_bad": -1.8122,
+      "log_good": -2.4639
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7143,
+      "good": 0.7021,
+      "ratio": 0.9829,
+      "suggested_scalar": -0.0073,
+      "log_bad": -0.3365,
+      "log_good": -0.3537
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.3673,
+      "good": 7.1277,
+      "ratio": 0.9675,
+      "suggested_scalar": -0.014,
+      "log_bad": 1.9971,
+      "log_good": 1.964
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 20.9779,
+      "good": 21.6858,
+      "ratio": 1.0337,
+      "suggested_scalar": 0.0141,
+      "log_bad": 3.0435,
+      "log_good": 3.0767
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 70.0,
+      "good": 59.0,
+      "ratio": 0.8429,
+      "suggested_scalar": -0.0726,
+      "log_bad": 4.2485,
+      "log_good": 4.0775
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9087,
+      "good": 0.9175,
+      "ratio": 1.0097,
+      "suggested_scalar": 0.0041,
+      "log_bad": -0.0957,
+      "log_good": -0.0861
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 26.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.0608,
+      "log_bad": 3.4012,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6429,
+      "good": 0.6346,
+      "ratio": 0.9871,
+      "suggested_scalar": -0.0055,
+      "log_bad": -0.4418,
+      "log_good": -0.4548
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3538,
+      "good": 0.3694,
+      "ratio": 1.0441,
+      "suggested_scalar": 0.0183,
+      "log_bad": -1.039,
+      "log_good": -0.9959
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.8005,
+      "good": 2.7365,
+      "ratio": 0.9771,
+      "suggested_scalar": -0.0098,
+      "log_bad": 1.0298,
+      "log_good": 1.0067
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 359.0,
+      "good": 333.0,
+      "ratio": 0.9276,
+      "suggested_scalar": -0.0319,
+      "log_bad": 5.8833,
+      "log_good": 5.8081
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 0.009,
+      "ratio": 0.009,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -4.7105
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.2668,
+      "good": 6.1898,
+      "ratio": 0.9877,
+      "suggested_scalar": -0.0052,
+      "log_bad": 1.8353,
+      "log_good": 1.8229
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 51.0,
+      "good": 47.0,
+      "ratio": 0.9216,
+      "suggested_scalar": -0.0347,
+      "log_bad": 3.9318,
+      "log_good": 3.8501
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9821,
+      "good": 0.9907,
+      "ratio": 1.0088,
+      "suggested_scalar": 0.0037,
+      "log_bad": -0.0181,
+      "log_good": -0.0093
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9261,
+      "good": 5.7576,
+      "ratio": 0.9716,
+      "suggested_scalar": -0.0122,
+      "log_bad": 1.7794,
+      "log_good": 1.7505
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.699,
+      "good": 0.7078,
+      "ratio": 1.0126,
+      "suggested_scalar": 0.0053,
+      "log_bad": -0.3581,
+      "log_good": -0.3456
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.125,
+      "good": 0.1296,
+      "ratio": 1.0368,
+      "suggested_scalar": 0.0153,
+      "log_bad": -2.0794,
+      "log_good": -2.0433
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.7543,
+      "good": 3.3392,
+      "ratio": 0.8894,
+      "suggested_scalar": -0.0497,
+      "log_bad": 1.3229,
+      "log_good": 1.2057
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 278.0,
+      "good": 256.0,
+      "ratio": 0.9209,
+      "suggested_scalar": -0.035,
+      "log_bad": 5.6276,
+      "log_good": 5.5452
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7562,
+      "good": 0.6936,
+      "ratio": 0.9172,
+      "suggested_scalar": -0.0367,
+      "log_bad": -0.2794,
+      "log_good": -0.3659
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 105.0,
+      "good": 97.0,
+      "ratio": 0.9238,
+      "suggested_scalar": -0.0336,
+      "log_bad": 4.654,
+      "log_good": 4.5747
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 898.0,
+      "good": 803.0,
+      "ratio": 0.8942,
+      "suggested_scalar": -0.0475,
+      "log_bad": 6.8002,
+      "log_good": 6.6884
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 162.0,
+      "good": 141.0,
+      "ratio": 0.8704,
+      "suggested_scalar": -0.0589,
+      "log_bad": 5.0876,
+      "log_good": 4.9488
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1773,
+      "good": 0.1821,
+      "ratio": 1.0271,
+      "suggested_scalar": 0.0113,
+      "log_bad": -1.7299,
+      "log_good": -1.7032
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 59.0,
+      "good": 54.0,
+      "ratio": 0.9153,
+      "suggested_scalar": -0.0376,
+      "log_bad": 4.0775,
+      "log_good": 3.989
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 105.0,
+      "good": 97.0,
+      "ratio": 0.9238,
+      "suggested_scalar": -0.0336,
+      "log_bad": 4.654,
+      "log_good": 4.5747
+    },
+    "brevity.mean_sample_size": {
+      "bad": 105.0,
+      "good": 97.0,
+      "ratio": 0.9238,
+      "suggested_scalar": -0.0336,
+      "log_bad": 4.654,
+      "log_good": 4.5747
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 361.0,
+      "good": 335.0,
+      "ratio": 0.928,
+      "suggested_scalar": -0.0317,
+      "log_bad": 5.8889,
+      "log_good": 5.8141
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 173.0,
+      "good": 176.0,
+      "ratio": 1.0173,
+      "suggested_scalar": 0.0073,
+      "log_bad": 5.1533,
+      "log_good": 5.1705
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 227.0,
+      "good": 209.0,
+      "ratio": 0.9207,
+      "suggested_scalar": -0.0351,
+      "log_bad": 5.425,
+      "log_good": 5.3423
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0166,
+      "good": 0.0179,
+      "ratio": 1.0783,
+      "suggested_scalar": 0.032,
+      "log_bad": -4.0984,
+      "log_good": -4.023
+    },
+    "heaps.mean_k": {
+      "bad": 2.936,
+      "good": 2.7871,
+      "ratio": 0.9493,
+      "suggested_scalar": -0.0221,
+      "log_bad": 1.077,
+      "log_good": 1.025
+    },
+    "halstead.mean_effort": {
+      "bad": 76566.0808,
+      "good": 54488.4951,
+      "ratio": 0.7117,
+      "suggested_scalar": -0.1444,
+      "log_bad": 11.2459,
+      "log_good": 10.9057
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8826,
+      "good": 0.8724,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0049,
+      "log_bad": -0.1249,
+      "log_good": -0.1365
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 72.0,
+      "good": 70.0,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.012,
+      "log_bad": 4.2767,
+      "log_good": 4.2485
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 178.0,
+      "good": 175.0,
+      "ratio": 0.9831,
+      "suggested_scalar": -0.0072,
+      "log_bad": 5.1818,
+      "log_good": 5.1648
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4876,
+      "good": 0.5377,
+      "ratio": 1.1027,
+      "suggested_scalar": 0.0415,
+      "log_bad": -0.7183,
+      "log_good": -0.6205
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.4215,
+      "good": 7.5755,
+      "ratio": 1.0208,
+      "suggested_scalar": 0.0087,
+      "log_bad": 2.0044,
+      "log_good": 2.0249
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.125,
+      "good": 0.1296,
+      "ratio": 1.0368,
+      "suggested_scalar": 0.0153,
+      "log_bad": -2.0794,
+      "log_good": -2.0433
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.1447,
+      "good": 4.9426,
+      "ratio": 0.9607,
+      "suggested_scalar": -0.017,
+      "log_bad": 1.638,
+      "log_good": 1.5979
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 360.0,
+      "good": 334.0,
+      "ratio": 0.9278,
+      "suggested_scalar": -0.0318,
+      "log_bad": 5.8861,
+      "log_good": 5.8111
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 46.0,
+      "good": 46.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8286,
+      "log_good": 3.8286
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4253.6712,
+      "good": 3027.1386,
+      "ratio": 0.7117,
+      "suggested_scalar": -0.1444,
+      "log_bad": 8.3555,
+      "log_good": 8.0154
+    },
+    "readability.mean_total_lines": {
+      "bad": 49.0,
+      "good": 47.0,
+      "ratio": 0.9592,
+      "suggested_scalar": -0.0177,
+      "log_bad": 3.8918,
+      "log_good": 3.8501
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2268.6246,
+      "good": 2080.8482,
+      "ratio": 0.9172,
+      "suggested_scalar": -0.0367,
+      "log_bad": 7.7269,
+      "log_good": 7.6405
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 742.0,
+      "good": 683.0,
+      "ratio": 0.9205,
+      "suggested_scalar": -0.0352,
+      "log_bad": 6.6093,
+      "log_good": 6.5265
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 41.2245,
+      "good": 38.617,
+      "ratio": 0.9367,
+      "suggested_scalar": -0.0277,
+      "log_bad": 3.719,
+      "log_good": 3.6537
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2692,
+      "good": 1.2745,
+      "ratio": 1.0042,
+      "suggested_scalar": 0.0018,
+      "log_bad": 0.2384,
+      "log_good": 0.2426
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 4.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1722,
+      "log_bad": 1.7918,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8345,
+      "good": 0.8203,
+      "ratio": 0.983,
+      "suggested_scalar": -0.0073,
+      "log_bad": -0.1809,
+      "log_good": -0.1981
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9742,
+      "good": 0.9739,
+      "ratio": 0.9997,
+      "suggested_scalar": -0.0001,
+      "log_bad": -0.0261,
+      "log_good": -0.0264
+    },
+    "halstead.mean_length": {
+      "bad": 340.0,
+      "good": 316.0,
+      "ratio": 0.9294,
+      "suggested_scalar": -0.0311,
+      "log_bad": 5.8289,
+      "log_good": 5.7557
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 8.3333,
+      "good": 8.0,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0173,
+      "log_bad": 2.1203,
+      "log_good": 2.0794
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7142,
+      "good": 6.5999,
+      "ratio": 0.983,
+      "suggested_scalar": -0.0073,
+      "log_bad": 1.9042,
+      "log_good": 1.8871
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0833,
+      "good": 0.0942,
+      "ratio": 1.1309,
+      "suggested_scalar": 0.0522,
+      "log_bad": -2.4853,
+      "log_good": -2.3623
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 33.75,
+      "good": 26.1857,
+      "ratio": 0.7759,
+      "suggested_scalar": -0.1077,
+      "log_bad": 3.519,
+      "log_good": 3.2652
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 4.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2943,
+      "log_bad": 2.0794,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 59.0,
+      "good": 57.0,
+      "ratio": 0.9661,
+      "suggested_scalar": -0.0146,
+      "log_bad": 4.0775,
+      "log_good": 4.0431
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7401,
+      "good": 0.7416,
+      "ratio": 1.002,
+      "suggested_scalar": 0.0009,
+      "log_bad": -0.301,
+      "log_good": -0.2989
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 49.0,
+      "good": 47.0,
+      "ratio": 0.9592,
+      "suggested_scalar": -0.0177,
+      "log_bad": 3.8918,
+      "log_good": 3.8501
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 22.0,
+      "good": 18.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.0852,
+      "log_bad": 3.091,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "documentation.file_has_module_docstring": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 56.0,
+      "good": 57.0,
+      "ratio": 1.0179,
+      "suggested_scalar": 0.0098,
+      "log_bad": 4.0254,
+      "log_good": 4.0431
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0089,
+      "good": 0.0115,
+      "ratio": 1.2921,
+      "suggested_scalar": 0.1425,
+      "log_bad": -4.7217,
+      "log_good": -4.4654
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.25,
+      "good": 1.25,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2231,
+      "log_good": 0.2231
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.871,
+      "good": 0.8904,
+      "ratio": 1.0223,
+      "suggested_scalar": 0.0122,
+      "log_bad": -0.1381,
+      "log_good": -0.1161
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0089,
+      "good": 0.0115,
+      "ratio": 1.2921,
+      "suggested_scalar": 0.1425,
+      "log_bad": -4.7217,
+      "log_good": -4.4654
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.845,
+      "good": 4.849,
+      "ratio": 1.0008,
+      "suggested_scalar": 0.0005,
+      "log_bad": 1.5779,
+      "log_good": 1.5788
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 105.0,
+      "good": 117.0,
+      "ratio": 1.1143,
+      "suggested_scalar": 0.0602,
+      "log_bad": 4.654,
+      "log_good": 4.7622
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4024,
+      "good": 0.4424,
+      "ratio": 1.0994,
+      "suggested_scalar": 0.0527,
+      "log_bad": -0.9103,
+      "log_good": -0.8155
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 19.0,
+      "ratio": 1.1176,
+      "suggested_scalar": 0.0618,
+      "log_bad": 2.8332,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5877,
+      "good": 0.4976,
+      "ratio": 0.8467,
+      "suggested_scalar": -0.0925,
+      "log_bad": -0.5315,
+      "log_good": -0.698
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.0323,
+      "good": 2.9041,
+      "ratio": 0.9577,
+      "suggested_scalar": -0.024,
+      "log_bad": 1.1093,
+      "log_good": 1.0661
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 671.0,
+      "good": 780.0,
+      "ratio": 1.1624,
+      "suggested_scalar": 0.0837,
+      "log_bad": 6.5088,
+      "log_good": 6.6593
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0012,
+      "good": 0.001,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1014,
+      "log_bad": -6.7254,
+      "log_good": -6.9078
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.155,
+      "good": 1.062,
+      "ratio": 0.9195,
+      "suggested_scalar": -0.0467,
+      "log_bad": 0.1441,
+      "log_good": 0.0602
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 211.0,
+      "good": 267.0,
+      "ratio": 1.2654,
+      "suggested_scalar": 0.1309,
+      "log_bad": 5.3519,
+      "log_good": 5.5872
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 92.2773,
+      "good": 95.7412,
+      "ratio": 1.0375,
+      "suggested_scalar": 0.0205,
+      "log_bad": 4.5248,
+      "log_good": 4.5616
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7299,
+      "good": 0.6675,
+      "ratio": 0.9145,
+      "suggested_scalar": -0.0497,
+      "log_bad": -0.3148,
+      "log_good": -0.4042
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 22.4313,
+      "good": 18.9972,
+      "ratio": 0.8469,
+      "suggested_scalar": -0.0924,
+      "log_bad": 3.1105,
+      "log_good": 2.9443
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2458.0,
+      "good": 3029.0,
+      "ratio": 1.2323,
+      "suggested_scalar": 0.1161,
+      "log_bad": 7.8071,
+      "log_good": 8.016
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 0.0274,
+      "ratio": 0.0274,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -3.5972
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8548,
+      "good": 0.8767,
+      "ratio": 1.0256,
+      "suggested_scalar": 0.0141,
+      "log_bad": -0.1569,
+      "log_good": -0.1316
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.8226,
+      "good": 10.6849,
+      "ratio": 0.9873,
+      "suggested_scalar": -0.0071,
+      "log_bad": 2.3816,
+      "log_good": 2.3688
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.3215,
+      "good": 2.9634,
+      "ratio": 0.8922,
+      "suggested_scalar": -0.0634,
+      "log_bad": 1.2004,
+      "log_good": 1.0863
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 143.0,
+      "good": 187.0,
+      "ratio": 1.3077,
+      "suggested_scalar": 0.1492,
+      "log_bad": 4.9628,
+      "log_good": 5.2311
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9667,
+      "good": 0.9679,
+      "ratio": 1.0012,
+      "suggested_scalar": 0.0007,
+      "log_bad": -0.0339,
+      "log_good": -0.0326
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 33.0,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.1116,
+      "log_bad": 3.2958,
+      "log_good": 3.4965
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6831,
+      "good": 0.6524,
+      "ratio": 0.9551,
+      "suggested_scalar": -0.0256,
+      "log_bad": -0.3811,
+      "log_good": -0.4271
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5381,
+      "good": 0.4781,
+      "ratio": 0.8885,
+      "suggested_scalar": -0.0657,
+      "log_bad": -0.6197,
+      "log_good": -0.7379
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.1553,
+      "good": 2.8765,
+      "ratio": 0.9116,
+      "suggested_scalar": -0.0514,
+      "log_bad": 1.1491,
+      "log_good": 1.0566
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 669.0,
+      "good": 778.0,
+      "ratio": 1.1629,
+      "suggested_scalar": 0.0839,
+      "log_bad": 6.5058,
+      "log_good": 6.6567
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 10.0,
+      "good": 12.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.1014,
+      "log_bad": 2.3026,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0253,
+      "good": 0.0269,
+      "ratio": 1.0632,
+      "suggested_scalar": 0.0341,
+      "log_bad": -3.677,
+      "log_good": -3.6156
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 6.0661,
+      "ratio": 1.0228,
+      "suggested_scalar": 0.0126,
+      "log_bad": 1.7801,
+      "log_good": 1.8027
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 66.0,
+      "good": 78.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0929,
+      "log_bad": 4.1897,
+      "log_good": 4.3567
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9685,
+      "good": 0.9314,
+      "ratio": 0.9617,
+      "suggested_scalar": -0.0217,
+      "log_bad": -0.032,
+      "log_good": -0.0711
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4058,
+      "good": 5.8519,
+      "ratio": 1.0825,
+      "suggested_scalar": 0.0441,
+      "log_bad": 1.6875,
+      "log_good": 1.7668
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8169,
+      "good": 0.7994,
+      "ratio": 0.9786,
+      "suggested_scalar": -0.012,
+      "log_bad": -0.2022,
+      "log_good": -0.2239
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1507,
+      "good": 0.1705,
+      "ratio": 1.1314,
+      "suggested_scalar": 0.0686,
+      "log_bad": -1.8925,
+      "log_good": -1.769
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.7362,
+      "good": 4.3586,
+      "ratio": 0.9203,
+      "suggested_scalar": -0.0462,
+      "log_bad": 1.5552,
+      "log_good": 1.4722
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 6.0,
+      "good": 8.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1599,
+      "log_bad": 1.7918,
+      "log_good": 2.0794
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 406.0,
+      "good": 507.0,
+      "ratio": 1.2488,
+      "suggested_scalar": 0.1235,
+      "log_bad": 6.0064,
+      "log_good": 6.2285
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.4592,
+      "good": 1.6008,
+      "ratio": 1.097,
+      "suggested_scalar": 0.0515,
+      "log_bad": 0.3779,
+      "log_good": 0.4705
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 106.0,
+      "good": 158.0,
+      "ratio": 1.4906,
+      "suggested_scalar": 0.2219,
+      "log_bad": 4.6634,
+      "log_good": 5.0626
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1448.0,
+      "good": 1813.0,
+      "ratio": 1.2521,
+      "suggested_scalar": 0.125,
+      "log_bad": 7.2779,
+      "log_good": 7.5027
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 223.0,
+      "good": 234.0,
+      "ratio": 1.0493,
+      "suggested_scalar": 0.0268,
+      "log_bad": 5.4072,
+      "log_good": 5.4553
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.3025,
+      "good": 0.2846,
+      "ratio": 0.9408,
+      "suggested_scalar": -0.0339,
+      "log_bad": -1.1957,
+      "log_good": -1.2567
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 108.0,
+      "good": 119.0,
+      "ratio": 1.1019,
+      "suggested_scalar": 0.0539,
+      "log_bad": 4.6821,
+      "log_good": 4.7791
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 106.0,
+      "good": 158.0,
+      "ratio": 1.4906,
+      "suggested_scalar": 0.2219,
+      "log_bad": 4.6634,
+      "log_good": 5.0626
+    },
+    "brevity.mean_sample_size": {
+      "bad": 106.0,
+      "good": 158.0,
+      "ratio": 1.4906,
+      "suggested_scalar": 0.2219,
+      "log_bad": 4.6634,
+      "log_good": 5.0626
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 671.0,
+      "good": 780.0,
+      "ratio": 1.1624,
+      "suggested_scalar": 0.0837,
+      "log_bad": 6.5088,
+      "log_good": 6.6593
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 395.0,
+      "good": 427.0,
+      "ratio": 1.081,
+      "suggested_scalar": 0.0433,
+      "log_bad": 5.9789,
+      "log_good": 6.0568
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 289.0,
+      "good": 378.0,
+      "ratio": 1.308,
+      "suggested_scalar": 0.1493,
+      "log_bad": 5.6664,
+      "log_good": 5.9349
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0089,
+      "good": 0.0103,
+      "ratio": 1.1573,
+      "suggested_scalar": 0.0812,
+      "log_bad": -4.7217,
+      "log_good": -4.5756
+    },
+    "heaps.mean_k": {
+      "bad": 2.037,
+      "good": 5.7397,
+      "ratio": 2.8177,
+      "suggested_scalar": 0.576,
+      "log_bad": 0.7115,
+      "log_good": 1.7474
+    },
+    "halstead.mean_effort": {
+      "bad": 168961.9225,
+      "good": 220738.1934,
+      "ratio": 1.3064,
+      "suggested_scalar": 0.1486,
+      "log_bad": 12.0374,
+      "log_good": 12.3047
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8035,
+      "good": 0.8012,
+      "ratio": 0.9971,
+      "suggested_scalar": -0.0016,
+      "log_bad": -0.2188,
+      "log_good": -0.2216
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 78.0,
+      "good": 84.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0412,
+      "log_bad": 4.3567,
+      "log_good": 4.4308
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 429.0,
+      "good": 465.0,
+      "ratio": 1.0839,
+      "suggested_scalar": 0.0448,
+      "log_bad": 6.0615,
+      "log_good": 6.142
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3223,
+      "good": 0.412,
+      "ratio": 1.2783,
+      "suggested_scalar": 0.1365,
+      "log_bad": -1.1323,
+      "log_good": -0.8867
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.8626,
+      "good": 6.7903,
+      "ratio": 0.9895,
+      "suggested_scalar": -0.0059,
+      "log_bad": 1.9261,
+      "log_good": 1.9155
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1507,
+      "good": 0.1705,
+      "ratio": 1.1314,
+      "suggested_scalar": 0.0686,
+      "log_bad": -1.8925,
+      "log_good": -1.769
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.2114,
+      "good": 4.9676,
+      "ratio": 0.9532,
+      "suggested_scalar": -0.0266,
+      "log_bad": 1.6508,
+      "log_good": 1.6029
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 670.0,
+      "good": 779.0,
+      "ratio": 1.1627,
+      "suggested_scalar": 0.0838,
+      "log_bad": 6.5073,
+      "log_good": 6.658
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 97.0,
+      "good": 101.0,
+      "ratio": 1.0412,
+      "suggested_scalar": 0.0225,
+      "log_bad": 4.5747,
+      "log_good": 4.6151
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 9386.7735,
+      "good": 12263.233,
+      "ratio": 1.3064,
+      "suggested_scalar": 0.1486,
+      "log_bad": 9.1471,
+      "log_good": 9.4144
+    },
+    "readability.mean_total_lines": {
+      "bad": 62.0,
+      "good": 73.0,
+      "ratio": 1.1774,
+      "suggested_scalar": 0.0908,
+      "log_bad": 4.1271,
+      "log_good": 4.2905
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 4377.6881,
+      "good": 4802.3849,
+      "ratio": 1.097,
+      "suggested_scalar": 0.0515,
+      "log_bad": 8.3843,
+      "log_good": 8.4769
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 779.0,
+      "good": 1053.0,
+      "ratio": 1.3517,
+      "suggested_scalar": 0.1676,
+      "log_bad": 6.658,
+      "log_good": 6.9594
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 38.4677,
+      "good": 40.2877,
+      "ratio": 1.0473,
+      "suggested_scalar": 0.0257,
+      "log_bad": 3.6498,
+      "log_good": 3.696
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2243,
+      "good": 1.185,
+      "ratio": 0.9679,
+      "suggested_scalar": -0.0181,
+      "log_bad": 0.2024,
+      "log_good": 0.1697
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 60.0,
+      "good": 69.0,
+      "ratio": 1.15,
+      "suggested_scalar": 0.0777,
+      "log_bad": 4.0943,
+      "log_good": 4.2341
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7611,
+      "good": 0.8008,
+      "ratio": 1.0522,
+      "suggested_scalar": 0.0283,
+      "log_bad": -0.273,
+      "log_good": -0.2221
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3854,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9368,
+      "good": 0.9285,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.0049,
+      "log_bad": -0.0653,
+      "log_good": -0.0742
+    },
+    "halstead.mean_length": {
+      "bad": 652.0,
+      "good": 699.0,
+      "ratio": 1.0721,
+      "suggested_scalar": 0.0387,
+      "log_bad": 6.48,
+      "log_good": 6.5497
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.125,
+      "good": 4.25,
+      "ratio": 1.0303,
+      "suggested_scalar": 0.0166,
+      "log_bad": 1.4171,
+      "log_good": 1.4469
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7279,
+      "good": 7.3038,
+      "ratio": 1.0856,
+      "suggested_scalar": 0.0457,
+      "log_bad": 1.9063,
+      "log_good": 1.9884
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1607,
+      "good": 0.141,
+      "ratio": 0.8774,
+      "suggested_scalar": -0.0727,
+      "log_bad": -1.8282,
+      "log_good": -1.959
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 38.5962,
+      "good": 45.9643,
+      "ratio": 1.1909,
+      "suggested_scalar": 0.0971,
+      "log_bad": 3.6532,
+      "log_good": 3.8279
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3854,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 68.0,
+      "good": 110.0,
+      "ratio": 1.6176,
+      "suggested_scalar": 0.2674,
+      "log_bad": 4.2195,
+      "log_good": 4.7005
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6263,
+      "good": 0.6852,
+      "ratio": 1.094,
+      "suggested_scalar": 0.05,
+      "log_bad": -0.4679,
+      "log_good": -0.378
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 62.0,
+      "good": 73.0,
+      "ratio": 1.1774,
+      "suggested_scalar": 0.0908,
+      "log_bad": 4.1271,
+      "log_good": 4.2905
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "variable_naming.name_contains_and": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 84.0,
+      "good": 68.0,
+      "ratio": 0.8095,
+      "suggested_scalar": -0.4615,
+      "log_bad": 4.4308,
+      "log_good": 4.2195
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 41.3333,
+      "good": 54.0,
+      "ratio": 1.3065,
+      "suggested_scalar": 0.5838,
+      "log_bad": 3.7217,
+      "log_good": 3.989
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0035,
+      "good": 0.0033,
+      "ratio": 0.9429,
+      "suggested_scalar": -0.1285,
+      "log_bad": -5.655,
+      "log_good": -5.7138
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1869,
+      "good": 1.0833,
+      "ratio": 0.9127,
+      "suggested_scalar": -0.1995,
+      "log_bad": 0.1713,
+      "log_good": 0.08
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.859,
+      "good": 0.917,
+      "ratio": 1.0675,
+      "suggested_scalar": 0.1427,
+      "log_bad": -0.152,
+      "log_good": -0.0866
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0094,
+      "good": 0.0067,
+      "ratio": 0.7128,
+      "suggested_scalar": -0.7394,
+      "log_bad": -4.667,
+      "log_good": -5.0056
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6913,
+      "good": 4.6984,
+      "ratio": 1.0015,
+      "suggested_scalar": 0.0033,
+      "log_bad": 1.5457,
+      "log_good": 1.5472
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 115.6667,
+      "good": 118.0,
+      "ratio": 1.0202,
+      "suggested_scalar": 0.0436,
+      "log_bad": 4.7507,
+      "log_good": 4.7707
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5672,
+      "good": 0.5164,
+      "ratio": 0.9104,
+      "suggested_scalar": -0.2049,
+      "log_bad": -0.567,
+      "log_good": -0.6609
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.6667,
+      "good": 19.0,
+      "ratio": 1.0755,
+      "suggested_scalar": 0.1589,
+      "log_bad": 2.8717,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6084,
+      "good": 0.5717,
+      "ratio": 0.9397,
+      "suggested_scalar": -0.1359,
+      "log_bad": -0.4969,
+      "log_good": -0.5591
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.9654,
+      "good": 2.5934,
+      "ratio": 0.8746,
+      "suggested_scalar": -0.2927,
+      "log_bad": 1.087,
+      "log_good": 0.953
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 565.6667,
+      "good": 598.6667,
+      "ratio": 1.0583,
+      "suggested_scalar": 0.1238,
+      "log_bad": 6.338,
+      "log_good": 6.3947
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.6667,
+      "good": 2.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9808,
+      "log_good": 0.9808
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0001,
+      "good": 0.0002,
+      "ratio": 2.0,
+      "suggested_scalar": 1.5137,
+      "log_bad": -9.2103,
+      "log_good": -8.5172
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0185,
+      "good": 0.018,
+      "ratio": 0.973,
+      "suggested_scalar": -0.0598,
+      "log_bad": -3.99,
+      "log_good": -4.0174
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0005,
+      "good": 0.001,
+      "ratio": 2.0,
+      "suggested_scalar": 1.5137,
+      "log_bad": -7.6009,
+      "log_good": -6.9078
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0243,
+      "good": 1.0302,
+      "ratio": 1.0058,
+      "suggested_scalar": 0.0125,
+      "log_bad": 0.024,
+      "log_good": 0.0298
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 201.6667,
+      "good": 216.0,
+      "ratio": 1.0711,
+      "suggested_scalar": 0.1499,
+      "log_bad": 5.3066,
+      "log_good": 5.3753
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 62.8362,
+      "good": 91.0927,
+      "ratio": 1.4497,
+      "suggested_scalar": 0.8109,
+      "log_bad": 4.1405,
+      "log_good": 4.5119
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5725,
+      "good": 0.5737,
+      "ratio": 1.0021,
+      "suggested_scalar": 0.0046,
+      "log_bad": -0.5577,
+      "log_good": -0.5556
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 39.104,
+      "good": 15.9489,
+      "ratio": 0.4079,
+      "suggested_scalar": -1.9585,
+      "log_bad": 3.6662,
+      "log_good": 2.7694
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2912.6667,
+      "good": 2740.6667,
+      "ratio": 0.9409,
+      "suggested_scalar": -0.1329,
+      "log_bad": 7.9768,
+      "log_good": 7.916
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0482,
+      "good": 0.0329,
+      "ratio": 0.6826,
+      "suggested_scalar": -0.834,
+      "log_bad": -3.0324,
+      "log_good": -3.4143
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.826,
+      "good": 0.8936,
+      "ratio": 1.0818,
+      "suggested_scalar": 0.1718,
+      "log_bad": -0.1912,
+      "log_good": -0.1125
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.1913,
+      "good": 8.4483,
+      "ratio": 1.0314,
+      "suggested_scalar": 0.0675,
+      "log_bad": 2.1031,
+      "log_good": 2.134
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 6.5,
+      "good": 12.0,
+      "ratio": 1.8462,
+      "suggested_scalar": 1.3389,
+      "log_bad": 1.8718,
+      "log_good": 2.4849
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.0046,
+      "good": 2.2853,
+      "ratio": 0.7606,
+      "suggested_scalar": -0.5976,
+      "log_bad": 1.1001,
+      "log_good": 0.8265
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 162.0,
+      "good": 177.3333,
+      "ratio": 1.0947,
+      "suggested_scalar": 0.1975,
+      "log_bad": 5.0876,
+      "log_good": 5.178
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9557,
+      "good": 0.9548,
+      "ratio": 0.9991,
+      "suggested_scalar": -0.0021,
+      "log_bad": -0.0453,
+      "log_good": -0.0463
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.6667,
+      "good": 26.3333,
+      "ratio": 1.026,
+      "suggested_scalar": 0.056,
+      "log_bad": 3.2452,
+      "log_good": 3.2708
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.677,
+      "good": 0.6614,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0509,
+      "log_bad": -0.3901,
+      "log_good": -0.4134
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.348,
+      "good": 0.3774,
+      "ratio": 1.0845,
+      "suggested_scalar": 0.1771,
+      "log_bad": -1.0556,
+      "log_good": -0.9744
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0967,
+      "good": 2.9559,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.1016,
+      "log_bad": 1.1303,
+      "log_good": 1.0838
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 563.6667,
+      "good": 596.6667,
+      "ratio": 1.0585,
+      "suggested_scalar": 0.1242,
+      "log_bad": 6.3345,
+      "log_good": 6.3914
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 14.6667,
+      "good": 15.0,
+      "ratio": 1.0227,
+      "suggested_scalar": 0.0491,
+      "log_bad": 2.6856,
+      "log_good": 2.7081
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.059,
+      "good": 0.0365,
+      "ratio": 0.6186,
+      "suggested_scalar": -1.0487,
+      "log_bad": -2.8302,
+      "log_good": -3.3104
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.879,
+      "good": 5.9274,
+      "ratio": 1.0082,
+      "suggested_scalar": 0.0179,
+      "log_bad": 1.7714,
+      "log_good": 1.7796
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 7.3333,
+      "good": 8.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.19,
+      "log_bad": 1.9924,
+      "log_good": 2.0794
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6783,
+      "good": 0.7244,
+      "ratio": 1.068,
+      "suggested_scalar": 0.1436,
+      "log_bad": -0.3882,
+      "log_good": -0.3224
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.755,
+      "good": 5.7292,
+      "ratio": 0.9955,
+      "suggested_scalar": -0.0098,
+      "log_bad": 1.7501,
+      "log_good": 1.7456
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.798,
+      "good": 0.7927,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0146,
+      "log_bad": -0.2256,
+      "log_good": -0.2323
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1688,
+      "good": 0.1593,
+      "ratio": 0.9437,
+      "suggested_scalar": -0.1265,
+      "log_bad": -1.779,
+      "log_good": -1.837
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 6.2349,
+      "good": 3.9883,
+      "ratio": 0.6397,
+      "suggested_scalar": -0.9757,
+      "log_bad": 1.8302,
+      "log_good": 1.3834
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.0,
+      "good": 4.6667,
+      "ratio": 1.5556,
+      "suggested_scalar": 0.9649,
+      "log_bad": 1.0986,
+      "log_good": 1.5405
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 437.0,
+      "good": 447.6667,
+      "ratio": 1.0244,
+      "suggested_scalar": 0.0527,
+      "log_bad": 6.0799,
+      "log_good": 6.104
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 18.0,
+      "good": 16.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.2572,
+      "log_bad": 2.8904,
+      "log_good": 2.7726
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.2372,
+      "good": 1.3199,
+      "ratio": 1.0668,
+      "suggested_scalar": 0.1413,
+      "log_bad": 0.2129,
+      "log_good": 0.2776
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 127.0,
+      "good": 128.3333,
+      "ratio": 1.0105,
+      "suggested_scalar": 0.0228,
+      "log_bad": 4.8442,
+      "log_good": 4.8546
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1884.0,
+      "good": 1628.6667,
+      "ratio": 0.8645,
+      "suggested_scalar": -0.318,
+      "log_bad": 7.5412,
+      "log_good": 7.3955
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 208.6667,
+      "good": 225.6667,
+      "ratio": 1.0815,
+      "suggested_scalar": 0.171,
+      "log_bad": 5.3407,
+      "log_good": 5.4191
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0012,
+      "good": 0.0011,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.19,
+      "log_bad": -6.7254,
+      "log_good": -6.8124
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2979,
+      "good": 0.2899,
+      "ratio": 0.9731,
+      "suggested_scalar": -0.0594,
+      "log_bad": -1.211,
+      "log_good": -1.2382
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 94.3333,
+      "good": 95.6667,
+      "ratio": 1.0141,
+      "suggested_scalar": 0.0307,
+      "log_bad": 4.5468,
+      "log_good": 4.5609
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 16.3333,
+      "good": 22.6667,
+      "ratio": 1.3878,
+      "suggested_scalar": 0.7156,
+      "log_bad": 2.7932,
+      "log_good": 3.1209
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 127.0,
+      "good": 128.3333,
+      "ratio": 1.0105,
+      "suggested_scalar": 0.0228,
+      "log_bad": 4.8442,
+      "log_good": 4.8546
+    },
+    "brevity.mean_sample_size": {
+      "bad": 127.0,
+      "good": 128.3333,
+      "ratio": 1.0105,
+      "suggested_scalar": 0.0228,
+      "log_bad": 4.8442,
+      "log_good": 4.8546
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 565.6667,
+      "good": 598.6667,
+      "ratio": 1.0583,
+      "suggested_scalar": 0.1238,
+      "log_bad": 6.338,
+      "log_good": 6.3947
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 303.3333,
+      "good": 309.6667,
+      "ratio": 1.0209,
+      "suggested_scalar": 0.0451,
+      "log_bad": 5.7148,
+      "log_good": 5.7355
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 335.6667,
+      "good": 349.3333,
+      "ratio": 1.0407,
+      "suggested_scalar": 0.0872,
+      "log_bad": 5.8161,
+      "log_good": 5.856
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0053,
+      "good": 0.0078,
+      "ratio": 1.4717,
+      "suggested_scalar": 0.8439,
+      "log_bad": -5.24,
+      "log_good": -4.8536
+    },
+    "heaps.mean_k": {
+      "bad": 2.9015,
+      "good": 3.5308,
+      "ratio": 1.2169,
+      "suggested_scalar": 0.4287,
+      "log_bad": 1.0652,
+      "log_good": 1.2615
+    },
+    "halstead.mean_effort": {
+      "bad": 111346.5438,
+      "good": 129399.2913,
+      "ratio": 1.1621,
+      "suggested_scalar": 0.3281,
+      "log_bad": 11.6204,
+      "log_good": 11.7707
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8235,
+      "good": 0.8181,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0144,
+      "log_bad": -0.1942,
+      "log_good": -0.2008
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 90.0,
+      "good": 91.6667,
+      "ratio": 1.0185,
+      "suggested_scalar": 0.0401,
+      "log_bad": 4.4998,
+      "log_good": 4.5182
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 333.0,
+      "good": 350.0,
+      "ratio": 1.0511,
+      "suggested_scalar": 0.1087,
+      "log_bad": 5.8081,
+      "log_good": 5.8579
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4462,
+      "good": 0.4165,
+      "ratio": 0.9334,
+      "suggested_scalar": -0.1504,
+      "log_bad": -0.807,
+      "log_good": -0.8759
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 9.3402,
+      "good": 7.5415,
+      "ratio": 0.8074,
+      "suggested_scalar": -0.4671,
+      "log_bad": 2.2343,
+      "log_good": 2.0204
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1688,
+      "good": 0.1593,
+      "ratio": 0.9437,
+      "suggested_scalar": -0.1265,
+      "log_bad": -1.779,
+      "log_good": -1.837
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 11.7154,
+      "good": 4.6883,
+      "ratio": 0.4002,
+      "suggested_scalar": -2.0,
+      "log_bad": 2.4609,
+      "log_good": 1.5451
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 564.6667,
+      "good": 597.6667,
+      "ratio": 1.0584,
+      "suggested_scalar": 0.124,
+      "log_bad": 6.3362,
+      "log_good": 6.393
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 69.6667,
+      "good": 77.3333,
+      "ratio": 1.11,
+      "suggested_scalar": 0.228,
+      "log_bad": 4.2437,
+      "log_good": 4.3481
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6185.9191,
+      "good": 7188.8495,
+      "ratio": 1.1621,
+      "suggested_scalar": 0.3281,
+      "log_bad": 8.73,
+      "log_good": 8.8803
+    },
+    "readability.mean_total_lines": {
+      "bad": 69.3333,
+      "good": 71.0,
+      "ratio": 1.024,
+      "suggested_scalar": 0.0519,
+      "log_bad": 4.2389,
+      "log_good": 4.2627
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 5.3333,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.2572,
+      "log_bad": 1.7918,
+      "log_good": 1.674
+    },
+    "halstead.mean_volume": {
+      "bad": 3711.5709,
+      "good": 3959.7706,
+      "ratio": 1.0669,
+      "suggested_scalar": 0.1414,
+      "log_bad": 8.2192,
+      "log_good": 8.2839
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 941.0,
+      "good": 926.6667,
+      "ratio": 0.9848,
+      "suggested_scalar": -0.0335,
+      "log_bad": 6.8469,
+      "log_good": 6.8316
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 40.1901,
+      "good": 36.7312,
+      "ratio": 0.9139,
+      "suggested_scalar": -0.1965,
+      "log_bad": 3.6936,
+      "log_good": 3.6036
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.6038,
+      "good": 1.2668,
+      "ratio": 0.7899,
+      "suggested_scalar": -0.5151,
+      "log_bad": 0.4724,
+      "log_good": 0.2365
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.6667,
+      "good": 2.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9808,
+      "log_good": 0.9808
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 24.6667,
+      "good": 19.3333,
+      "ratio": 0.7838,
+      "suggested_scalar": -0.532,
+      "log_bad": 3.2055,
+      "log_good": 2.9618
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8404,
+      "good": 0.8273,
+      "ratio": 0.9844,
+      "suggested_scalar": -0.0343,
+      "log_bad": -0.1739,
+      "log_good": -0.1896
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9854,
+      "good": 0.9821,
+      "ratio": 0.9967,
+      "suggested_scalar": -0.0073,
+      "log_bad": -0.0147,
+      "log_good": -0.0181
+    },
+    "halstead.mean_length": {
+      "bad": 541.6667,
+      "good": 575.6667,
+      "ratio": 1.0628,
+      "suggested_scalar": 0.1329,
+      "log_bad": 6.2947,
+      "log_good": 6.3555
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.8667,
+      "good": 3.5583,
+      "ratio": 0.7312,
+      "suggested_scalar": -0.6838,
+      "log_bad": 1.5824,
+      "log_good": 1.2693
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9883,
+      "good": 7.003,
+      "ratio": 1.0021,
+      "suggested_scalar": 0.0046,
+      "log_bad": 1.9442,
+      "log_good": 1.9463
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1043,
+      "good": 0.1131,
+      "ratio": 1.0844,
+      "suggested_scalar": 0.1769,
+      "log_bad": -2.2605,
+      "log_good": -2.1795
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.9299,
+      "good": 32.5739,
+      "ratio": 1.0883,
+      "suggested_scalar": 0.1849,
+      "log_bad": 3.3989,
+      "log_good": 3.4835
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.3333,
+      "good": 2.3333,
+      "ratio": 0.7,
+      "suggested_scalar": -0.7789,
+      "log_bad": 1.204,
+      "log_good": 0.8473
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 90.0,
+      "good": 90.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.4998,
+      "log_good": 4.4998
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7188,
+      "good": 0.7263,
+      "ratio": 1.0104,
+      "suggested_scalar": 0.0227,
+      "log_bad": -0.3302,
+      "log_good": -0.3198
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 70.0,
+      "good": 71.6667,
+      "ratio": 1.0238,
+      "suggested_scalar": 0.0514,
+      "log_bad": 4.2485,
+      "log_good": 4.272
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 30.0,
+      "good": 21.0,
+      "ratio": 0.7,
+      "suggested_scalar": -0.7789,
+      "log_bad": 3.4012,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "variable_naming.name_is_too_short": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 41.0,
+      "good": 40.0,
+      "ratio": 0.9756,
+      "suggested_scalar": -0.045,
+      "log_bad": 3.7136,
+      "log_good": 3.6889
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 44.0,
+      "good": 44.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7842,
+      "log_good": 3.7842
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0042,
+      "good": 0.0042,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.4727,
+      "log_good": -5.4727
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 1.5,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.4055,
+      "log_good": 0.4055
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8147,
+      "good": 0.8155,
+      "ratio": 1.001,
+      "suggested_scalar": 0.0018,
+      "log_bad": -0.2049,
+      "log_good": -0.204
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0079,
+      "good": 0.008,
+      "ratio": 1.0127,
+      "suggested_scalar": 0.0229,
+      "log_bad": -4.8409,
+      "log_good": -4.8283
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7338,
+      "good": 4.7041,
+      "ratio": 0.9937,
+      "suggested_scalar": -0.0115,
+      "log_bad": 1.5547,
+      "log_good": 1.5484
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 108.0,
+      "good": 100.0,
+      "ratio": 0.9259,
+      "suggested_scalar": -0.1401,
+      "log_bad": 4.6821,
+      "log_good": 4.6052
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3338,
+      "good": 0.2902,
+      "ratio": 0.8694,
+      "suggested_scalar": -0.2548,
+      "log_bad": -1.0972,
+      "log_good": -1.2372
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 25.0,
+      "good": 25.3333,
+      "ratio": 1.0133,
+      "suggested_scalar": 0.0241,
+      "log_bad": 3.2189,
+      "log_good": 3.2321
+    },
+    "heaps.mean_beta": {
+      "bad": 0.4464,
+      "good": 0.4443,
+      "ratio": 0.9953,
+      "suggested_scalar": -0.0086,
+      "log_bad": -0.8065,
+      "log_good": -0.8113
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.6982,
+      "good": 2.7096,
+      "ratio": 1.0042,
+      "suggested_scalar": 0.0077,
+      "log_bad": 0.9926,
+      "log_good": 0.9968
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 717.0,
+      "good": 707.0,
+      "ratio": 0.9861,
+      "suggested_scalar": -0.0256,
+      "log_bad": 6.5751,
+      "log_good": 6.561
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.3333,
+      "good": 3.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.204,
+      "log_good": 1.204
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0198,
+      "good": 0.0197,
+      "ratio": 0.9949,
+      "suggested_scalar": -0.0092,
+      "log_bad": -3.9221,
+      "log_good": -3.9271
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0036,
+      "good": 0.0031,
+      "ratio": 0.8611,
+      "suggested_scalar": -0.2722,
+      "log_bad": -5.6268,
+      "log_good": -5.7764
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.2016,
+      "good": 1.2365,
+      "ratio": 1.029,
+      "suggested_scalar": 0.0521,
+      "log_bad": 0.1837,
+      "log_good": 0.2123
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 248.6667,
+      "good": 243.6667,
+      "ratio": 0.9799,
+      "suggested_scalar": -0.037,
+      "log_bad": 5.5161,
+      "log_good": 5.4958
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.886,
+      "good": 102.3933,
+      "ratio": 1.005,
+      "suggested_scalar": 0.009,
+      "log_bad": 4.6239,
+      "log_good": 4.6288
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7112,
+      "good": 0.7155,
+      "ratio": 1.006,
+      "suggested_scalar": 0.011,
+      "log_bad": -0.3408,
+      "log_good": -0.3348
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.7363,
+      "good": 7.5285,
+      "ratio": 0.8617,
+      "suggested_scalar": -0.2709,
+      "log_bad": 2.1675,
+      "log_good": 2.0187
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2267.0,
+      "good": 2631.3333,
+      "ratio": 1.1607,
+      "suggested_scalar": 0.2713,
+      "log_bad": 7.7262,
+      "log_good": 7.8752
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1256,
+      "good": 0.1102,
+      "ratio": 0.8774,
+      "suggested_scalar": -0.2381,
+      "log_bad": -2.0747,
+      "log_good": -2.2055
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7846,
+      "good": 0.7855,
+      "ratio": 1.0011,
+      "suggested_scalar": 0.0021,
+      "log_bad": -0.2426,
+      "log_good": -0.2414
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.8554,
+      "good": 10.6612,
+      "ratio": 0.9821,
+      "suggested_scalar": -0.0329,
+      "log_bad": 2.3847,
+      "log_good": 2.3666
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 9.0,
+      "good": 3.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -2.0,
+      "log_bad": 2.1972,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.1499,
+      "good": 2.1698,
+      "ratio": 1.0093,
+      "suggested_scalar": 0.0168,
+      "log_bad": 0.7654,
+      "log_good": 0.7746
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 210.3333,
+      "good": 213.6667,
+      "ratio": 1.0158,
+      "suggested_scalar": 0.0286,
+      "log_bad": 5.3487,
+      "log_good": 5.3644
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9339,
+      "good": 0.9336,
+      "ratio": 0.9997,
+      "suggested_scalar": -0.0006,
+      "log_bad": -0.0684,
+      "log_good": -0.0687
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 32.0,
+      "good": 30.3333,
+      "ratio": 0.9479,
+      "suggested_scalar": -0.0974,
+      "log_bad": 3.4657,
+      "log_good": 3.4122
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6336,
+      "good": 0.6753,
+      "ratio": 1.0658,
+      "suggested_scalar": 0.116,
+      "log_bad": -0.4563,
+      "log_good": -0.3926
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5552,
+      "good": 0.5552,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.5884,
+      "log_good": -0.5884
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7299,
+      "good": 3.0801,
+      "ratio": 1.1283,
+      "suggested_scalar": 0.2197,
+      "log_bad": 1.0043,
+      "log_good": 1.125
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 715.0,
+      "good": 705.0,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0256,
+      "log_bad": 6.5723,
+      "log_good": 6.5582
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 15.3333,
+      "good": 15.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.73,
+      "log_good": 2.73
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.039,
+      "good": 0.0342,
+      "ratio": 0.8769,
+      "suggested_scalar": -0.2391,
+      "log_bad": -3.2442,
+      "log_good": -3.3755
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0369,
+      "good": 6.1006,
+      "ratio": 1.0106,
+      "suggested_scalar": 0.0191,
+      "log_bad": 1.7979,
+      "log_good": 1.8084
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 15.6667,
+      "good": 15.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7515,
+      "log_good": 2.7515
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7339,
+      "good": 0.5591,
+      "ratio": 0.7618,
+      "suggested_scalar": -0.4953,
+      "log_bad": -0.3094,
+      "log_good": -0.5814
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6211,
+      "good": 5.4788,
+      "ratio": 0.9747,
+      "suggested_scalar": -0.0467,
+      "log_bad": 1.7265,
+      "log_good": 1.7009
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7841,
+      "good": 0.7711,
+      "ratio": 0.9834,
+      "suggested_scalar": -0.0304,
+      "log_bad": -0.2432,
+      "log_good": -0.2599
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1898,
+      "good": 0.1891,
+      "ratio": 0.9963,
+      "suggested_scalar": -0.0067,
+      "log_bad": -1.6618,
+      "log_good": -1.6655
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.9537,
+      "good": 2.7435,
+      "ratio": 0.9288,
+      "suggested_scalar": -0.1344,
+      "log_bad": 1.0831,
+      "log_good": 1.0092
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.6667,
+      "good": 2.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9808,
+      "log_good": 0.9808
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 442.3333,
+      "good": 434.6667,
+      "ratio": 0.9827,
+      "suggested_scalar": -0.0318,
+      "log_bad": 6.0921,
+      "log_good": 6.0746
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.5074,
+      "good": 1.4598,
+      "ratio": 0.9684,
+      "suggested_scalar": -0.0584,
+      "log_bad": 0.4104,
+      "log_good": 0.3783
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 115.0,
+      "good": 107.3333,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.1256,
+      "log_bad": 4.7449,
+      "log_good": 4.6759
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1094.0,
+      "good": 1472.0,
+      "ratio": 1.3455,
+      "suggested_scalar": 0.5403,
+      "log_bad": 6.9976,
+      "log_good": 7.2944
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 262.3333,
+      "good": 257.0,
+      "ratio": 0.9797,
+      "suggested_scalar": -0.0374,
+      "log_bad": 5.5696,
+      "log_good": 5.5491
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0032,
+      "good": 0.0032,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.7446,
+      "log_good": -5.7446
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2883,
+      "good": 0.2867,
+      "ratio": 0.9945,
+      "suggested_scalar": -0.0101,
+      "log_bad": -1.2438,
+      "log_good": -1.2493
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 125.3333,
+      "good": 119.0,
+      "ratio": 0.9495,
+      "suggested_scalar": -0.0944,
+      "log_bad": 4.831,
+      "log_good": 4.7791
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 10.6667,
+      "good": 10.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3671,
+      "log_good": 2.3671
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 115.0,
+      "good": 107.3333,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.1256,
+      "log_bad": 4.7449,
+      "log_good": 4.6759
+    },
+    "brevity.mean_sample_size": {
+      "bad": 115.0,
+      "good": 107.3333,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.1256,
+      "log_bad": 4.7449,
+      "log_good": 4.6759
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 717.0,
+      "good": 707.0,
+      "ratio": 0.9861,
+      "suggested_scalar": -0.0256,
+      "log_bad": 6.5751,
+      "log_good": 6.561
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 401.3333,
+      "good": 398.3333,
+      "ratio": 0.9925,
+      "suggested_scalar": -0.0137,
+      "log_bad": 5.9948,
+      "log_good": 5.9873
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 331.3333,
+      "good": 319.0,
+      "ratio": 0.9628,
+      "suggested_scalar": -0.0691,
+      "log_bad": 5.8031,
+      "log_good": 5.7652
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0038,
+      "good": 0.0038,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.5728,
+      "log_good": -5.5728
+    },
+    "heaps.mean_k": {
+      "bad": 5.6743,
+      "good": 5.3223,
+      "ratio": 0.938,
+      "suggested_scalar": -0.1166,
+      "log_bad": 1.7359,
+      "log_good": 1.6719
+    },
+    "halstead.mean_effort": {
+      "bad": 252351.0234,
+      "good": 247546.2694,
+      "ratio": 0.981,
+      "suggested_scalar": -0.035,
+      "log_bad": 12.4386,
+      "log_good": 12.4194
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8212,
+      "good": 0.8122,
+      "ratio": 0.989,
+      "suggested_scalar": -0.0201,
+      "log_bad": -0.197,
+      "log_good": -0.208
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 76.0,
+      "good": 69.6667,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.1584,
+      "log_bad": 4.3307,
+      "log_good": 4.2437
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 407.3333,
+      "good": 402.3333,
+      "ratio": 0.9877,
+      "suggested_scalar": -0.0225,
+      "log_bad": 6.0096,
+      "log_good": 5.9973
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.2803,
+      "good": 0.2612,
+      "ratio": 0.9319,
+      "suggested_scalar": -0.1285,
+      "log_bad": -1.2719,
+      "log_good": -1.3425
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.3968,
+      "good": 6.0456,
+      "ratio": 1.375,
+      "suggested_scalar": 0.5797,
+      "log_bad": 1.4809,
+      "log_good": 1.7993
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1898,
+      "good": 0.1891,
+      "ratio": 0.9963,
+      "suggested_scalar": -0.0067,
+      "log_bad": -1.6618,
+      "log_good": -1.6655
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.6719,
+      "good": 4.6048,
+      "ratio": 0.9856,
+      "suggested_scalar": -0.0263,
+      "log_bad": 1.5416,
+      "log_good": 1.5271
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 716.0,
+      "good": 706.0,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0256,
+      "log_bad": 6.5737,
+      "log_good": 6.5596
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 9.6667,
+      "good": 9.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.2687,
+      "log_good": 2.2687
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 124.0,
+      "good": 121.0,
+      "ratio": 0.9758,
+      "suggested_scalar": -0.0446,
+      "log_bad": 4.8203,
+      "log_good": 4.7958
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 14019.5013,
+      "good": 13752.5705,
+      "ratio": 0.981,
+      "suggested_scalar": -0.035,
+      "log_bad": 9.5482,
+      "log_good": 9.529
+    },
+    "readability.mean_total_lines": {
+      "bad": 66.0,
+      "good": 66.3333,
+      "ratio": 1.005,
+      "suggested_scalar": 0.0092,
+      "log_bad": 4.1897,
+      "log_good": 4.1947
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.3333,
+      "good": 6.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8458,
+      "log_good": 1.8458
+    },
+    "halstead.mean_volume": {
+      "bad": 4522.1971,
+      "good": 4379.4278,
+      "ratio": 0.9684,
+      "suggested_scalar": -0.0584,
+      "log_bad": 8.4168,
+      "log_good": 8.3847
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 830.3333,
+      "good": 854.6667,
+      "ratio": 1.0293,
+      "suggested_scalar": 0.0526,
+      "log_bad": 6.7218,
+      "log_good": 6.7507
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.2774,
+      "good": 37.5979,
+      "ratio": 1.1648,
+      "suggested_scalar": 0.2778,
+      "log_bad": 3.4744,
+      "log_good": 3.6269
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1103,
+      "good": 1.1066,
+      "ratio": 0.9967,
+      "suggested_scalar": -0.0061,
+      "log_bad": 0.1046,
+      "log_good": 0.1013
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.3333,
+      "good": 3.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.204,
+      "log_good": 1.204
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 36.3333,
+      "good": 36.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5927,
+      "log_good": 3.5927
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.719,
+      "good": 0.7204,
+      "ratio": 1.0019,
+      "suggested_scalar": 0.0035,
+      "log_bad": -0.3299,
+      "log_good": -0.3279
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9323,
+      "good": 0.9481,
+      "ratio": 1.0169,
+      "suggested_scalar": 0.0306,
+      "log_bad": -0.0701,
+      "log_good": -0.0533
+    },
+    "halstead.mean_length": {
+      "bad": 669.6667,
+      "good": 659.3333,
+      "ratio": 0.9846,
+      "suggested_scalar": -0.0283,
+      "log_bad": 6.5068,
+      "log_good": 6.4912
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.2758,
+      "good": 7.3061,
+      "ratio": 1.0042,
+      "suggested_scalar": 0.0076,
+      "log_bad": 1.9846,
+      "log_good": 1.9887
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8451,
+      "good": 6.7456,
+      "ratio": 0.9855,
+      "suggested_scalar": -0.0267,
+      "log_bad": 1.9235,
+      "log_good": 1.9089
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1771,
+      "good": 0.1518,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.2806,
+      "log_bad": -1.731,
+      "log_good": -1.8852
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 55.5475,
+      "good": 56.2915,
+      "ratio": 1.0134,
+      "suggested_scalar": 0.0242,
+      "log_bad": 4.0172,
+      "log_good": 4.0305
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.3333,
+      "good": 7.3333,
+      "ratio": 0.88,
+      "suggested_scalar": -0.2327,
+      "log_bad": 2.1203,
+      "log_good": 1.9924
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 69.6667,
+      "good": 63.6667,
+      "ratio": 0.9139,
+      "suggested_scalar": -0.164,
+      "log_bad": 4.2437,
+      "log_good": 4.1537
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6201,
+      "good": 0.6248,
+      "ratio": 1.0076,
+      "suggested_scalar": 0.0137,
+      "log_bad": -0.4779,
+      "log_good": -0.4703
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 66.6667,
+      "good": 67.0,
+      "ratio": 1.005,
+      "suggested_scalar": 0.0091,
+      "log_bad": 4.1997,
+      "log_good": 4.2047
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.6667,
+      "good": 14.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6856,
+      "log_good": 2.6856
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "file_structure.uses_standard_indentation_width": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 26.0,
+      "good": 26.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2581,
+      "log_good": 3.2581
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0295,
+      "good": 0.0295,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.5234,
+      "log_good": -3.5234
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6,
+      "good": 1.6,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.47,
+      "log_good": 0.47
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7467,
+      "good": 0.7467,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2921,
+      "log_good": -0.2921
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0295,
+      "good": 0.0295,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.5234,
+      "log_good": -3.5234
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.0284,
+      "good": 4.4729,
+      "ratio": 1.1103,
+      "suggested_scalar": 0.151,
+      "log_bad": 1.3934,
+      "log_good": 1.498
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 67.0,
+      "good": 67.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2047,
+      "log_good": 4.2047
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4309,
+      "good": 0.4309,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.8419,
+      "log_good": -0.8419
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6124,
+      "good": 0.6124,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.4904,
+      "log_good": -0.4904
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 9.12,
+      "good": 4.56,
+      "ratio": 0.5,
+      "suggested_scalar": -1.0,
+      "log_bad": 2.2105,
+      "log_good": 1.5173
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 407.0,
+      "good": 407.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.0088,
+      "log_good": 6.0088
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0005,
+      "good": 0.0006,
+      "ratio": 1.2,
+      "suggested_scalar": 0.263,
+      "log_bad": -7.6009,
+      "log_good": -7.4186
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0005,
+      "good": 0.0006,
+      "ratio": 1.2,
+      "suggested_scalar": 0.263,
+      "log_bad": -7.6009,
+      "log_good": -7.4186
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0994,
+      "good": 1.0994,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0948,
+      "log_good": 0.0948
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 142.0,
+      "good": 142.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.9558,
+      "log_good": 4.9558
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 105.5365,
+      "good": 105.5365,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.6591,
+      "log_good": 4.6591
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6921,
+      "good": 0.6921,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.368,
+      "log_good": -0.368
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.0732,
+      "good": 13.0732,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5706,
+      "log_good": 2.5706
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2128.0,
+      "good": 1788.0,
+      "ratio": 0.8402,
+      "suggested_scalar": -0.2512,
+      "log_bad": 7.6629,
+      "log_good": 7.4889
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.04,
+      "good": 0.04,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.2189,
+      "log_good": -3.2189
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6,
+      "good": 0.6,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.5108,
+      "log_good": -0.5108
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.4267,
+      "good": 5.4267,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6913,
+      "log_good": 1.6913
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 25.8389,
+      "good": 6.4597,
+      "ratio": 0.25,
+      "suggested_scalar": -2.0,
+      "log_bad": 3.2519,
+      "log_good": 1.8656
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 131.0,
+      "good": 131.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.8752,
+      "log_good": 4.8752
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9292,
+      "good": 0.9292,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0734,
+      "log_good": -0.0734
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.726,
+      "good": 0.6818,
+      "ratio": 0.9391,
+      "suggested_scalar": -0.0906,
+      "log_bad": -0.3202,
+      "log_good": -0.383
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5235,
+      "good": 0.5235,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.6472,
+      "log_good": -0.6472
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.6501,
+      "good": 3.1424,
+      "ratio": 0.8609,
+      "suggested_scalar": -0.2161,
+      "log_bad": 1.2948,
+      "log_good": 1.145
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 405.0,
+      "good": 405.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.0039,
+      "log_good": 6.0039
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0541,
+      "good": 0.0541,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.9169,
+      "log_good": -2.9169
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7814,
+      "good": 5.7814,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7546,
+      "log_good": 1.7546
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.3932,
+      "good": 0.3932,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.9334,
+      "log_good": -0.9334
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4715,
+      "good": 5.4715,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6996,
+      "log_good": 1.6996
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.6968,
+      "good": 0.7737,
+      "ratio": 1.1104,
+      "suggested_scalar": 0.151,
+      "log_bad": -0.3613,
+      "log_good": -0.2566
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1279,
+      "good": 0.1477,
+      "ratio": 1.1548,
+      "suggested_scalar": 0.2077,
+      "log_bad": -2.0565,
+      "log_good": -1.9126
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6157,
+      "good": 3.6157,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.2853,
+      "log_good": 1.2853
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 263.0,
+      "good": 263.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.5722,
+      "log_good": 5.5722
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6693,
+      "good": 0.6693,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.4015,
+      "log_good": -0.4015
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 85.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.4427,
+      "log_good": 4.4427
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 902.0,
+      "good": 902.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.8046,
+      "log_good": 6.8046
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 113.0,
+      "good": 113.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.7274,
+      "log_good": 4.7274
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0074,
+      "good": 0.0074,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.9063,
+      "log_good": -4.9063
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2948,
+      "good": 0.2948,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.2215,
+      "log_good": -1.2215
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 79.0,
+      "good": 79.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3694,
+      "log_good": 4.3694
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 85.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.4427,
+      "log_good": 4.4427
+    },
+    "brevity.mean_sample_size": {
+      "bad": 85.0,
+      "good": 85.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.4427,
+      "log_good": 4.4427
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 407.0,
+      "good": 407.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.0088,
+      "log_good": 6.0088
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 217.0,
+      "good": 217.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.3799,
+      "log_good": 5.3799
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 204.0,
+      "good": 204.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.3181,
+      "log_good": 5.3181
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.3351,
+      "good": 2.3351,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.8481,
+      "log_good": 0.8481
+    },
+    "halstead.mean_effort": {
+      "bad": 59300.7782,
+      "good": 59300.7782,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 10.9904,
+      "log_good": 10.9904
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8537,
+      "good": 0.8537,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1582,
+      "log_good": -0.1582
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 44.0,
+      "good": 44.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7842,
+      "log_good": 3.7842
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 218.0,
+      "good": 218.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.3845,
+      "log_good": 5.3845
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3944,
+      "good": 0.3944,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.9304,
+      "log_good": -0.9304
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.3521,
+      "good": 6.3521,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8488,
+      "log_good": 1.8488
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1279,
+      "good": 0.1477,
+      "ratio": 1.1548,
+      "suggested_scalar": 0.2077,
+      "log_bad": -2.0565,
+      "log_good": -1.9126
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.2289,
+      "good": 3.2289,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.1721,
+      "log_good": 1.1721
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 406.0,
+      "good": 406.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.0064,
+      "log_good": 6.0064
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 70.0,
+      "good": 70.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2485,
+      "log_good": 4.2485
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3294.4877,
+      "good": 3294.4877,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 8.1,
+      "log_good": 8.1
+    },
+    "readability.mean_total_lines": {
+      "bad": 75.0,
+      "good": 75.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3175,
+      "log_good": 4.3175
+    },
+    "indentation.mean_max_depth": {
+      "bad": 20.0,
+      "good": 10.0,
+      "ratio": 0.5,
+      "suggested_scalar": -1.0,
+      "log_bad": 2.9957,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 2007.8755,
+      "good": 2007.8755,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 7.6048,
+      "log_good": 7.6048
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 583.0,
+      "good": 569.0,
+      "ratio": 0.976,
+      "suggested_scalar": -0.0351,
+      "log_bad": 6.3682,
+      "log_good": 6.3439
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 27.2267,
+      "good": 22.6667,
+      "ratio": 0.8325,
+      "suggested_scalar": -0.2644,
+      "log_bad": 3.3042,
+      "log_good": 3.1209
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1323,
+      "good": 1.1323,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1243,
+      "log_good": 0.1243
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7338,
+      "good": 0.7338,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3095,
+      "log_good": -0.3095
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9715,
+      "good": 0.9715,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0289,
+      "log_good": -0.0289
+    },
+    "halstead.mean_length": {
+      "bad": 331.0,
+      "good": 331.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.8021,
+      "log_good": 5.8021
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.9,
+      "good": 8.1,
+      "ratio": 1.0253,
+      "suggested_scalar": 0.0361,
+      "log_bad": 2.0669,
+      "log_good": 2.0919
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4094,
+      "good": 6.4094,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8578,
+      "log_good": 1.8578
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.102,
+      "good": 0.1214,
+      "ratio": 1.1902,
+      "suggested_scalar": 0.2512,
+      "log_bad": -2.2828,
+      "log_good": -2.1087
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.5341,
+      "good": 29.5341,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3855,
+      "log_good": 3.3855
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 56.0,
+      "good": 56.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0254,
+      "log_good": 4.0254
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6127,
+      "good": 0.6127,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.4899,
+      "log_good": -0.4899
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 75.0,
+      "good": 75.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3175,
+      "log_good": 4.3175
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.uses_snake_case_for_methods": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 41.0,
+      "good": 1.0,
+      "ratio": 0.0244,
+      "suggested_scalar": -1.9869,
+      "log_bad": 3.7136,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.8889,
+      "good": 0.8889,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1178,
+      "log_good": -0.1178
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7619,
+      "good": 0.7561,
+      "ratio": 0.9924,
+      "suggested_scalar": -0.0041,
+      "log_bad": -0.2719,
+      "log_good": -0.2796
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5663,
+      "good": 4.4752,
+      "ratio": 0.98,
+      "suggested_scalar": -0.0108,
+      "log_bad": 1.5187,
+      "log_good": 1.4986
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 60.0,
+      "good": 53.0,
+      "ratio": 0.8833,
+      "suggested_scalar": -0.0664,
+      "log_bad": 4.0943,
+      "log_good": 3.9703
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4789,
+      "good": 0.4154,
+      "ratio": 0.8674,
+      "suggested_scalar": -0.0761,
+      "log_bad": -0.7363,
+      "log_good": -0.8785
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 17.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.0306,
+      "log_bad": 2.8904,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7178,
+      "good": 0.6833,
+      "ratio": 0.9519,
+      "suggested_scalar": -0.0264,
+      "log_bad": -0.3316,
+      "log_good": -0.3808
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.9048,
+      "good": 2.9268,
+      "ratio": 1.0076,
+      "suggested_scalar": 0.004,
+      "log_bad": 1.0664,
+      "log_good": 1.0739
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 182.0,
+      "good": 176.0,
+      "ratio": 0.967,
+      "suggested_scalar": -0.0179,
+      "log_bad": 5.204,
+      "log_good": 5.1705
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.001,
+      "good": 0.001,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.9078,
+      "log_good": -6.9078
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0238,
+      "good": 1.0,
+      "ratio": 42.0168,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.7381,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.001,
+      "good": 0.002,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3709,
+      "log_bad": -6.9078,
+      "log_good": -6.2146
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8912,
+      "good": 0.9083,
+      "ratio": 1.0192,
+      "suggested_scalar": 0.0102,
+      "log_bad": -0.1152,
+      "log_good": -0.0962
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 71.0,
+      "good": 65.0,
+      "ratio": 0.9155,
+      "suggested_scalar": -0.0472,
+      "log_bad": 4.2627,
+      "log_good": 4.1744
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 77.1214,
+      "good": 76.4779,
+      "ratio": 0.9917,
+      "suggested_scalar": -0.0045,
+      "log_bad": 4.3454,
+      "log_good": 4.337
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4475,
+      "good": 0.4914,
+      "ratio": 1.0981,
+      "suggested_scalar": 0.0501,
+      "log_bad": -0.8041,
+      "log_good": -0.7105
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.5997,
+      "good": 12.7778,
+      "ratio": 1.3311,
+      "suggested_scalar": 0.153,
+      "log_bad": 2.2617,
+      "log_good": 2.5477
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1016.0,
+      "good": 1006.0,
+      "ratio": 0.9902,
+      "suggested_scalar": -0.0053,
+      "log_bad": 6.9236,
+      "log_good": 6.9137
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0476,
+      "good": 0.0488,
+      "ratio": 1.0252,
+      "suggested_scalar": 0.0133,
+      "log_bad": -3.0449,
+      "log_good": -3.02
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7143,
+      "good": 0.7073,
+      "ratio": 0.9902,
+      "suggested_scalar": -0.0053,
+      "log_bad": -0.3365,
+      "log_good": -0.3463
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 4.439,
+      "good": 4.2927,
+      "ratio": 0.967,
+      "suggested_scalar": -0.0179,
+      "log_bad": 1.4904,
+      "log_good": 1.4569
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.7528,
+      "good": 1.7751,
+      "ratio": 1.0127,
+      "suggested_scalar": 0.0068,
+      "log_bad": 0.5612,
+      "log_good": 0.5739
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 27.0,
+      "good": 63.0,
+      "ratio": 2.3333,
+      "suggested_scalar": 0.4533,
+      "log_bad": 3.2958,
+      "log_good": 4.1431
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.8867,
+      "good": 0.8867,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1202,
+      "log_good": -0.1202
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5945,
+      "good": 0.6292,
+      "ratio": 1.0584,
+      "suggested_scalar": 0.0304,
+      "log_bad": -0.52,
+      "log_good": -0.4633
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2333,
+      "good": 0.2529,
+      "ratio": 1.084,
+      "suggested_scalar": 0.0432,
+      "log_bad": -1.4554,
+      "log_good": -1.3748
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.466,
+      "good": 2.6971,
+      "ratio": 1.0937,
+      "suggested_scalar": 0.0479,
+      "log_bad": 0.9026,
+      "log_good": 0.9922
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 180.0,
+      "good": 174.0,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0181,
+      "log_bad": 5.193,
+      "log_good": 5.1591
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0275,
+      "good": 0.0341,
+      "ratio": 1.24,
+      "suggested_scalar": 0.1151,
+      "log_bad": -3.5936,
+      "log_good": -3.3785
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8074,
+      "good": 5.6439,
+      "ratio": 0.9718,
+      "suggested_scalar": -0.0153,
+      "log_bad": 1.7591,
+      "log_good": 1.7306
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.2169,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1808,
+      "good": 0.1982,
+      "ratio": 0.1679,
+      "suggested_scalar": -0.9549,
+      "log_bad": 0.1662,
+      "log_good": -1.6185
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.3181,
+      "good": 5.1715,
+      "ratio": 0.9724,
+      "suggested_scalar": -0.015,
+      "log_bad": 1.6711,
+      "log_good": 1.6432
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7863,
+      "good": 0.7929,
+      "ratio": 1.0084,
+      "suggested_scalar": 0.0045,
+      "log_bad": -0.2404,
+      "log_good": -0.2321
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2222,
+      "good": 0.2264,
+      "ratio": 1.0189,
+      "suggested_scalar": 0.01,
+      "log_bad": -1.5042,
+      "log_good": -1.4855
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.0983,
+      "good": 3.5746,
+      "ratio": 1.1537,
+      "suggested_scalar": 0.0765,
+      "log_bad": 1.1309,
+      "log_good": 1.2739
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 158.0,
+      "good": 151.0,
+      "ratio": 0.9557,
+      "suggested_scalar": -0.0242,
+      "log_bad": 5.0626,
+      "log_good": 5.0173
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.3387,
+      "good": 0.3169,
+      "ratio": 0.9356,
+      "suggested_scalar": -0.0356,
+      "log_bad": -1.0826,
+      "log_good": -1.1492
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 62.0,
+      "good": 54.0,
+      "ratio": 0.871,
+      "suggested_scalar": -0.0739,
+      "log_bad": 4.1271,
+      "log_good": 3.989
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 607.0,
+      "good": 607.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.4085,
+      "log_good": 6.4085
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 77.0,
+      "good": 71.0,
+      "ratio": 0.9221,
+      "suggested_scalar": -0.0434,
+      "log_bad": 4.3438,
+      "log_good": 4.2627
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2363,
+      "good": 0.2557,
+      "ratio": 1.0821,
+      "suggested_scalar": 0.0422,
+      "log_bad": -1.4427,
+      "log_good": -1.3638
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 32.0,
+      "good": 34.0,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.0324,
+      "log_bad": 3.4657,
+      "log_good": 3.5264
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 62.0,
+      "good": 54.0,
+      "ratio": 0.871,
+      "suggested_scalar": -0.0739,
+      "log_bad": 4.1271,
+      "log_good": 3.989
+    },
+    "brevity.mean_sample_size": {
+      "bad": 62.0,
+      "good": 54.0,
+      "ratio": 0.871,
+      "suggested_scalar": -0.0739,
+      "log_bad": 4.1271,
+      "log_good": 3.989
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 182.0,
+      "good": 176.0,
+      "ratio": 0.967,
+      "suggested_scalar": -0.0179,
+      "log_bad": 5.204,
+      "log_good": 5.1705
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 81.0,
+      "good": 81.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3944,
+      "log_good": 4.3944
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 132.0,
+      "good": 123.0,
+      "ratio": 0.9318,
+      "suggested_scalar": -0.0378,
+      "log_bad": 4.8828,
+      "log_good": 4.8122
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.6357,
+      "good": 1.7042,
+      "ratio": 1.0419,
+      "suggested_scalar": 0.0219,
+      "log_bad": 0.4921,
+      "log_good": 0.5331
+    },
+    "halstead.mean_effort": {
+      "bad": 22645.775,
+      "good": 23954.9024,
+      "ratio": 1.0578,
+      "suggested_scalar": 0.0301,
+      "log_bad": 10.0277,
+      "log_good": 10.0839
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8932,
+      "good": 0.8986,
+      "ratio": 1.006,
+      "suggested_scalar": 0.0032,
+      "log_bad": -0.1129,
+      "log_good": -0.1069
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 38.0,
+      "good": 31.0,
+      "ratio": 0.8158,
+      "suggested_scalar": -0.1089,
+      "log_bad": 3.6376,
+      "log_good": 3.434
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 95.0,
+      "good": 95.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.5539,
+      "log_good": 4.5539
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4789,
+      "good": 0.4154,
+      "ratio": 0.8674,
+      "suggested_scalar": -0.0761,
+      "log_bad": -0.7363,
+      "log_good": -0.8785
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.5493,
+      "good": 9.3385,
+      "ratio": 1.0923,
+      "suggested_scalar": 0.0472,
+      "log_bad": 2.1458,
+      "log_good": 2.2341
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2222,
+      "good": 0.2264,
+      "ratio": 1.0189,
+      "suggested_scalar": 0.01,
+      "log_bad": -1.5042,
+      "log_good": -1.4855
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.3756,
+      "good": 3.4192,
+      "ratio": 1.0129,
+      "suggested_scalar": 0.0069,
+      "log_bad": 1.2166,
+      "log_good": 1.2294
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 181.0,
+      "good": 175.0,
+      "ratio": 0.9669,
+      "suggested_scalar": -0.018,
+      "log_bad": 5.1985,
+      "log_good": 5.1648
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 20.0,
+      "good": 21.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0261,
+      "log_bad": 2.9957,
+      "log_good": 3.0445
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1258.0986,
+      "good": 1330.8279,
+      "ratio": 1.0578,
+      "suggested_scalar": 0.0301,
+      "log_bad": 7.1374,
+      "log_good": 7.1936
+    },
+    "readability.mean_total_lines": {
+      "bad": 41.0,
+      "good": 41.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7136,
+      "log_good": 3.7136
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 1015.9852,
+      "good": 950.8348,
+      "ratio": 0.9359,
+      "suggested_scalar": -0.0355,
+      "log_bad": 6.9236,
+      "log_good": 6.8573
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 412.0,
+      "good": 373.0,
+      "ratio": 0.9053,
+      "suggested_scalar": -0.0532,
+      "log_bad": 6.021,
+      "log_good": 5.9216
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 22.2439,
+      "good": 23.2439,
+      "ratio": 1.045,
+      "suggested_scalar": 0.0235,
+      "log_bad": 3.1021,
+      "log_good": 3.146
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.48,
+      "good": 1.4894,
+      "ratio": 1.0064,
+      "suggested_scalar": 0.0034,
+      "log_bad": 0.392,
+      "log_good": 0.3984
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8734,
+      "good": 0.8609,
+      "ratio": 0.9857,
+      "suggested_scalar": -0.0077,
+      "log_bad": -0.1354,
+      "log_good": -0.1498
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9878,
+      "good": 0.9942,
+      "ratio": 1.0065,
+      "suggested_scalar": 0.0035,
+      "log_bad": -0.0123,
+      "log_good": -0.0058
+    },
+    "halstead.mean_length": {
+      "bad": 172.0,
+      "good": 166.0,
+      "ratio": 0.9651,
+      "suggested_scalar": -0.019,
+      "log_bad": 5.1475,
+      "log_good": 5.112
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.6667,
+      "good": 5.5556,
+      "ratio": 0.9804,
+      "suggested_scalar": -0.0106,
+      "log_bad": 1.7346,
+      "log_good": 1.7148
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.7549,
+      "ratio": 0.9665,
+      "suggested_scalar": -0.0182,
+      "log_bad": 1.7841,
+      "log_good": 1.7501
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0797,
+      "good": 0.0805,
+      "ratio": 1.01,
+      "suggested_scalar": 0.0053,
+      "log_bad": -2.5295,
+      "log_good": -2.5195
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 22.2895,
+      "good": 25.1935,
+      "ratio": 1.1303,
+      "suggested_scalar": 0.0655,
+      "log_bad": 3.1041,
+      "log_good": 3.2266
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 34.0,
+      "good": 27.0,
+      "ratio": 0.7941,
+      "suggested_scalar": -0.1233,
+      "log_bad": 3.5264,
+      "log_good": 3.2958
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7576,
+      "good": 0.7236,
+      "ratio": 0.9551,
+      "suggested_scalar": -0.0246,
+      "log_bad": -0.2776,
+      "log_good": -0.3235
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 42.0,
+      "good": 41.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0129,
+      "log_bad": 3.7377,
+      "log_good": 3.7136
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 18.0,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.0306,
+      "log_bad": 2.8332,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.does_not_use_generic_package_names": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.022,
+      "good": 0.025,
+      "ratio": 1.1364,
+      "suggested_scalar": 0.7168,
+      "log_bad": -3.8167,
+      "log_good": -3.6889
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.6667,
+      "good": 0.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.4054,
+      "log_good": -0.4054
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8772,
+      "good": 0.8704,
+      "ratio": 0.9922,
+      "suggested_scalar": -0.0436,
+      "log_bad": -0.131,
+      "log_good": -0.1388
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.022,
+      "good": 0.025,
+      "ratio": 1.1364,
+      "suggested_scalar": 0.7168,
+      "log_bad": -3.8167,
+      "log_good": -3.6889
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8229,
+      "good": 4.8339,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0128,
+      "log_bad": 1.5734,
+      "log_good": 1.5757
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 129.0,
+      "good": 104.0,
+      "ratio": 0.8062,
+      "suggested_scalar": -1.2079,
+      "log_bad": 4.8598,
+      "log_good": 4.6444
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6037,
+      "good": 0.5445,
+      "ratio": 0.9019,
+      "suggested_scalar": -0.5787,
+      "log_bad": -0.5047,
+      "log_good": -0.6079
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7415,
+      "good": 0.7389,
+      "ratio": 0.9965,
+      "suggested_scalar": -0.0197,
+      "log_bad": -0.2991,
+      "log_good": -0.3026
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.6316,
+      "good": 0.6667,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.3033,
+      "log_bad": -0.4595,
+      "log_good": -0.4054
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 363.0,
+      "good": 320.0,
+      "ratio": 0.8815,
+      "suggested_scalar": -0.707,
+      "log_bad": 5.8944,
+      "log_good": 5.7683
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0006,
+      "good": 0.0007,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.8644,
+      "log_bad": -7.4186,
+      "log_good": -7.2644
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1754,
+      "good": 0.1296,
+      "ratio": 0.7389,
+      "suggested_scalar": -1.6969,
+      "log_bad": -1.7407,
+      "log_good": -2.0433
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8405,
+      "good": 0.8641,
+      "ratio": 1.0281,
+      "suggested_scalar": 0.1553,
+      "log_bad": -0.1738,
+      "log_good": -0.1461
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 167.0,
+      "good": 143.0,
+      "ratio": 0.8563,
+      "suggested_scalar": -0.87,
+      "log_bad": 5.118,
+      "log_good": 4.9628
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 100.722,
+      "good": 106.3502,
+      "ratio": 1.0559,
+      "suggested_scalar": 0.3049,
+      "log_bad": 4.6124,
+      "log_good": 4.6667
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.2983,
+      "good": 0.3386,
+      "ratio": 1.1351,
+      "suggested_scalar": 0.7106,
+      "log_bad": -1.2097,
+      "log_good": -1.0829
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.9374,
+      "good": 10.435,
+      "ratio": 0.7487,
+      "suggested_scalar": -1.6228,
+      "log_bad": 2.6346,
+      "log_good": 2.3452
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1711.0,
+      "good": 1437.0,
+      "ratio": 0.8399,
+      "suggested_scalar": -0.9786,
+      "log_bad": 7.4448,
+      "log_good": 7.2703
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1053,
+      "good": 0.0926,
+      "ratio": 0.8794,
+      "suggested_scalar": -0.7207,
+      "log_bad": -2.2509,
+      "log_good": -2.3795
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8596,
+      "good": 0.8519,
+      "ratio": 0.991,
+      "suggested_scalar": -0.0505,
+      "log_bad": -0.1513,
+      "log_good": -0.1603
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.3684,
+      "good": 5.9259,
+      "ratio": 0.9305,
+      "suggested_scalar": -0.4038,
+      "log_bad": 1.8513,
+      "log_good": 1.7793
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.4783,
+      "good": 0.4815,
+      "ratio": 1.0067,
+      "suggested_scalar": 0.0374,
+      "log_bad": -0.7375,
+      "log_good": -0.7308
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 105.0,
+      "good": 83.0,
+      "ratio": 0.7905,
+      "suggested_scalar": -1.3184,
+      "log_bad": 4.654,
+      "log_good": 4.4188
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9431,
+      "good": 0.9305,
+      "ratio": 0.9866,
+      "suggested_scalar": -0.0754,
+      "log_bad": -0.0586,
+      "log_good": -0.072
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 28.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3322,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5517,
+      "good": 0.5421,
+      "ratio": 0.9826,
+      "suggested_scalar": -0.0984,
+      "log_bad": -0.5948,
+      "log_good": -0.6123
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.1247,
+      "good": 0.1415,
+      "ratio": 1.1347,
+      "suggested_scalar": 0.7087,
+      "log_bad": -2.0818,
+      "log_good": -1.9555
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2308,
+      "good": 2.1839,
+      "ratio": 0.979,
+      "suggested_scalar": -0.1191,
+      "log_bad": 0.8024,
+      "log_good": 0.7811
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 361.0,
+      "good": 318.0,
+      "ratio": 0.8809,
+      "suggested_scalar": -0.7112,
+      "log_bad": 5.8889,
+      "log_good": 5.7621
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0165,
+      "good": 0.0187,
+      "ratio": 1.1333,
+      "suggested_scalar": 0.7018,
+      "log_bad": -4.1044,
+      "log_good": -3.9792
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.9307,
+      "ratio": 0.9961,
+      "suggested_scalar": -0.0222,
+      "log_bad": 1.7841,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 55.0,
+      "good": 53.0,
+      "ratio": 0.9636,
+      "suggested_scalar": -0.2077,
+      "log_bad": 4.0073,
+      "log_good": 3.9703
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1766,
+      "good": 1.2416,
+      "ratio": 1.0552,
+      "suggested_scalar": 0.3015,
+      "log_bad": 0.1626,
+      "log_good": 0.2164
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.2423,
+      "good": 6.0256,
+      "ratio": 0.9653,
+      "suggested_scalar": -0.1981,
+      "log_bad": 1.8313,
+      "log_good": 1.796
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.81,
+      "good": 0.8151,
+      "ratio": 1.0063,
+      "suggested_scalar": 0.0352,
+      "log_bad": -0.2107,
+      "log_good": -0.2044
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1493,
+      "good": 0.1563,
+      "ratio": 1.0469,
+      "suggested_scalar": 0.2569,
+      "log_bad": -1.9018,
+      "log_good": -1.856
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.7333,
+      "good": 3.2303,
+      "ratio": 0.8653,
+      "suggested_scalar": -0.8115,
+      "log_bad": 1.3173,
+      "log_good": 1.1726
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 334.0,
+      "good": 291.0,
+      "ratio": 0.8713,
+      "suggested_scalar": -0.7728,
+      "log_bad": 5.8111,
+      "log_good": 5.6733
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7923,
+      "good": 0.6611,
+      "ratio": 0.8344,
+      "suggested_scalar": -1.0151,
+      "log_bad": -0.2328,
+      "log_good": -0.4139
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 128.0,
+      "good": 103.0,
+      "ratio": 0.8047,
+      "suggested_scalar": -1.2185,
+      "log_bad": 4.852,
+      "log_good": 4.6347
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1059.0,
+      "good": 842.0,
+      "ratio": 0.7951,
+      "suggested_scalar": -1.2858,
+      "log_bad": 6.9651,
+      "log_good": 6.7358
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 184.0,
+      "good": 159.0,
+      "ratio": 0.8641,
+      "suggested_scalar": -0.8188,
+      "log_bad": 5.2149,
+      "log_good": 5.0689
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2039,
+      "good": 0.2031,
+      "ratio": 0.9961,
+      "suggested_scalar": -0.022,
+      "log_bad": -1.5901,
+      "log_good": -1.5941
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 41.0,
+      "good": 42.0,
+      "ratio": 1.0244,
+      "suggested_scalar": 0.1351,
+      "log_bad": 3.7136,
+      "log_good": 3.7377
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 128.0,
+      "good": 103.0,
+      "ratio": 0.8047,
+      "suggested_scalar": -1.2185,
+      "log_bad": 4.852,
+      "log_good": 4.6347
+    },
+    "brevity.mean_sample_size": {
+      "bad": 128.0,
+      "good": 103.0,
+      "ratio": 0.8047,
+      "suggested_scalar": -1.2185,
+      "log_bad": 4.852,
+      "log_good": 4.6347
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 363.0,
+      "good": 320.0,
+      "ratio": 0.8815,
+      "suggested_scalar": -0.707,
+      "log_bad": 5.8944,
+      "log_good": 5.7683
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 154.0,
+      "good": 139.0,
+      "ratio": 0.9026,
+      "suggested_scalar": -0.5746,
+      "log_bad": 5.037,
+      "log_good": 4.9345
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 295.0,
+      "good": 253.0,
+      "ratio": 0.8576,
+      "suggested_scalar": -0.8612,
+      "log_bad": 5.687,
+      "log_good": 5.5334
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.8815,
+      "good": 1.6894,
+      "ratio": 0.8979,
+      "suggested_scalar": -0.6039,
+      "log_bad": 0.6321,
+      "log_good": 0.5244
+    },
+    "halstead.mean_effort": {
+      "bad": 60620.3204,
+      "good": 58090.6964,
+      "ratio": 0.9583,
+      "suggested_scalar": -0.239,
+      "log_bad": 11.0124,
+      "log_good": 10.9698
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8918,
+      "good": 0.9012,
+      "ratio": 1.0105,
+      "suggested_scalar": 0.0588,
+      "log_bad": -0.1145,
+      "log_good": -0.104
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 101.0,
+      "good": 76.0,
+      "ratio": 0.7525,
+      "suggested_scalar": -1.5947,
+      "log_bad": 4.6151,
+      "log_good": 4.3307
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 155.0,
+      "good": 137.0,
+      "ratio": 0.8839,
+      "suggested_scalar": -0.6922,
+      "log_bad": 5.0434,
+      "log_good": 4.92
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5449,
+      "good": 0.4685,
+      "ratio": 0.8598,
+      "suggested_scalar": -0.8471,
+      "log_bad": -0.6072,
+      "log_good": -0.7582
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.3413,
+      "good": 5.8881,
+      "ratio": 0.9285,
+      "suggested_scalar": -0.4158,
+      "log_bad": 1.8471,
+      "log_good": 1.7729
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1493,
+      "good": 0.1563,
+      "ratio": 1.0469,
+      "suggested_scalar": 0.2569,
+      "log_bad": -1.9018,
+      "log_good": -1.856
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.7012,
+      "good": 3.2593,
+      "ratio": 0.8806,
+      "suggested_scalar": -0.7129,
+      "log_bad": 1.3087,
+      "log_good": 1.1815
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 362.0,
+      "good": 319.0,
+      "ratio": 0.8812,
+      "suggested_scalar": -0.7091,
+      "log_bad": 5.8916,
+      "log_good": 5.7652
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3367.7956,
+      "good": 3227.2609,
+      "ratio": 0.9583,
+      "suggested_scalar": -0.239,
+      "log_bad": 8.122,
+      "log_good": 8.0794
+    },
+    "readability.mean_total_lines": {
+      "bad": 57.0,
+      "good": 54.0,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.3032,
+      "log_bad": 4.0431,
+      "log_good": 3.989
+    },
+    "indentation.mean_max_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_volume": {
+      "bad": 2376.806,
+      "good": 1983.3302,
+      "ratio": 0.8345,
+      "suggested_scalar": -1.0148,
+      "log_bad": 7.7735,
+      "log_good": 7.5925
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 767.0,
+      "good": 658.0,
+      "ratio": 0.8579,
+      "suggested_scalar": -0.8595,
+      "log_bad": 6.6425,
+      "log_good": 6.4892
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 28.8421,
+      "good": 25.4259,
+      "ratio": 0.8816,
+      "suggested_scalar": -0.7069,
+      "log_bad": 3.3618,
+      "log_good": 3.2358
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1779,
+      "good": 1.1167,
+      "ratio": 0.948,
+      "suggested_scalar": -0.2992,
+      "log_bad": 0.1637,
+      "log_good": 0.1104
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 18.0,
+      "good": 16.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.6605,
+      "log_bad": 2.8904,
+      "log_good": 2.7726
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 10.0,
+      "good": 7.0,
+      "ratio": 0.7,
+      "suggested_scalar": -2.0,
+      "log_bad": 2.3026,
+      "log_good": 1.9459
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9461,
+      "good": 0.9381,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0476,
+      "log_bad": -0.0554,
+      "log_good": -0.0639
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9872,
+      "good": 0.9823,
+      "ratio": 0.995,
+      "suggested_scalar": -0.0279,
+      "log_bad": -0.0129,
+      "log_good": -0.0179
+    },
+    "halstead.mean_length": {
+      "bad": 339.0,
+      "good": 296.0,
+      "ratio": 0.8732,
+      "suggested_scalar": -0.7606,
+      "log_bad": 5.826,
+      "log_good": 5.6904
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.6667,
+      "good": 7.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0369,
+      "log_good": 2.0369
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.0,
+      "good": 6.6865,
+      "ratio": 0.9552,
+      "suggested_scalar": -0.2569,
+      "log_bad": 1.9459,
+      "log_good": 1.9001
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.09,
+      "good": 0.0967,
+      "ratio": 1.0744,
+      "suggested_scalar": 0.4026,
+      "log_bad": -2.4079,
+      "log_good": -2.3361
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.505,
+      "good": 29.2895,
+      "ratio": 1.1484,
+      "suggested_scalar": 0.7758,
+      "log_bad": 3.2389,
+      "log_good": 3.3772
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -1.0223,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 91.0,
+      "good": 67.0,
+      "ratio": 0.7363,
+      "suggested_scalar": -1.7168,
+      "log_bad": 4.5109,
+      "log_good": 4.2047
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.861,
+      "good": 0.834,
+      "ratio": 0.9686,
+      "suggested_scalar": -0.1787,
+      "log_bad": -0.1497,
+      "log_good": -0.1815
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 57.0,
+      "good": 54.0,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.3032,
+      "log_bad": 4.0431,
+      "log_good": 3.989
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "scope_and_assignment.shadowed_by_inner_scope": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0084,
+      "good": 0.0114,
+      "ratio": 1.3571,
+      "suggested_scalar": 0.1539,
+      "log_bad": -4.7795,
+      "log_good": -4.4741
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8868,
+      "good": 0.875,
+      "ratio": 0.9867,
+      "suggested_scalar": -0.0068,
+      "log_bad": -0.1201,
+      "log_good": -0.1335
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0084,
+      "good": 0.0114,
+      "ratio": 1.3571,
+      "suggested_scalar": 0.1539,
+      "log_bad": -4.7795,
+      "log_good": -4.4741
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.3004,
+      "good": 4.4766,
+      "ratio": 1.041,
+      "suggested_scalar": 0.0202,
+      "log_bad": 1.4587,
+      "log_good": 1.4989
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 80.0,
+      "good": 67.0,
+      "ratio": 0.8375,
+      "suggested_scalar": -0.0894,
+      "log_bad": 4.382,
+      "log_good": 4.2047
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4256,
+      "good": 0.5017,
+      "ratio": 1.1788,
+      "suggested_scalar": 0.0829,
+      "log_bad": -0.8543,
+      "log_good": -0.6898
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 17.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.0561,
+      "log_bad": 2.9444,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.609,
+      "good": 0.6458,
+      "ratio": 1.0604,
+      "suggested_scalar": 0.0296,
+      "log_bad": -0.4959,
+      "log_good": -0.4373
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.1887,
+      "good": 5.5,
+      "ratio": 0.8887,
+      "suggested_scalar": -0.0595,
+      "log_bad": 1.8227,
+      "log_good": 1.7047
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 357.0,
+      "good": 263.0,
+      "ratio": 0.7367,
+      "suggested_scalar": -0.154,
+      "log_bad": 5.8777,
+      "log_good": 5.5722
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.145,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1698,
+      "good": 1.0,
+      "ratio": 5.8893,
+      "suggested_scalar": 0.8936,
+      "log_bad": -1.7731,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9948,
+      "good": 0.9255,
+      "ratio": 0.9303,
+      "suggested_scalar": -0.0364,
+      "log_bad": -0.0052,
+      "log_good": -0.0774
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 158.0,
+      "good": 105.0,
+      "ratio": 0.6646,
+      "suggested_scalar": -0.2059,
+      "log_bad": 5.0626,
+      "log_good": 4.654
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 110.3804,
+      "good": 95.5415,
+      "ratio": 0.8656,
+      "suggested_scalar": -0.0728,
+      "log_bad": 4.7039,
+      "log_good": 4.5596
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5225,
+      "good": 0.4351,
+      "ratio": 0.8327,
+      "suggested_scalar": -0.0922,
+      "log_bad": -0.6491,
+      "log_good": -0.8322
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 5.7602,
+      "good": 15.2454,
+      "ratio": 2.6467,
+      "suggested_scalar": 0.4905,
+      "log_bad": 1.751,
+      "log_good": 2.7243
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1603.0,
+      "good": 1287.0,
+      "ratio": 0.8029,
+      "suggested_scalar": -0.1107,
+      "log_bad": 7.3796,
+      "log_good": 7.1601
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0189,
+      "good": 1.0,
+      "ratio": 52.9101,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.9686,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8302,
+      "good": 0.8,
+      "ratio": 0.9636,
+      "suggested_scalar": -0.0187,
+      "log_bad": -0.1861,
+      "log_good": -0.2231
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.1136,
+      "good": 6.575,
+      "ratio": 0.8104,
+      "suggested_scalar": -0.106,
+      "log_bad": 2.0935,
+      "log_good": 1.8833
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 11.9644,
+      "good": 10.55,
+      "ratio": 0.8818,
+      "suggested_scalar": -0.0634,
+      "log_bad": 2.4819,
+      "log_good": 2.3561
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 141.0,
+      "good": 89.0,
+      "ratio": 0.6312,
+      "suggested_scalar": -0.2319,
+      "log_bad": 4.9488,
+      "log_good": 4.4886
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9332,
+      "good": 0.944,
+      "ratio": 1.0116,
+      "suggested_scalar": 0.0058,
+      "log_bad": -0.0691,
+      "log_good": -0.0576
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 19.0,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.0504,
+      "log_bad": 3.0445,
+      "log_good": 2.9444
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6082,
+      "good": 0.6076,
+      "ratio": 0.999,
+      "suggested_scalar": -0.0005,
+      "log_bad": -0.4973,
+      "log_good": -0.4982
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2817,
+      "good": 0.1877,
+      "ratio": 0.6663,
+      "suggested_scalar": -0.2046,
+      "log_bad": -1.2669,
+      "log_good": -1.6729
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5525,
+      "good": 2.5485,
+      "ratio": 0.9984,
+      "suggested_scalar": -0.0008,
+      "log_bad": 0.9371,
+      "log_good": 0.9355
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 355.0,
+      "good": 261.0,
+      "ratio": 0.7352,
+      "suggested_scalar": -0.155,
+      "log_bad": 5.8721,
+      "log_good": 5.5645
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 24.0,
+      "good": 16.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.2043,
+      "log_bad": 3.1781,
+      "log_good": 2.7726
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0168,
+      "good": 0.0228,
+      "ratio": 1.3571,
+      "suggested_scalar": 0.1539,
+      "log_bad": -4.0864,
+      "log_good": -3.781
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.7549,
+      "ratio": 0.9866,
+      "suggested_scalar": -0.0068,
+      "log_bad": 1.7635,
+      "log_good": 1.7501
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 17.0,
+      "good": 16.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0306,
+      "log_bad": 2.8332,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.4926,
+      "good": 0.6158,
+      "ratio": 1.2501,
+      "suggested_scalar": 0.1125,
+      "log_bad": -0.7081,
+      "log_good": -0.4848
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6854,
+      "good": 5.5215,
+      "ratio": 0.9712,
+      "suggested_scalar": -0.0147,
+      "log_bad": 1.7379,
+      "log_good": 1.7086
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7373,
+      "good": 0.7779,
+      "ratio": 1.0551,
+      "suggested_scalar": 0.027,
+      "log_bad": -0.3048,
+      "log_good": -0.2512
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.197,
+      "good": 0.2308,
+      "ratio": 1.1716,
+      "suggested_scalar": 0.0798,
+      "log_bad": -1.6246,
+      "log_good": -1.4662
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.4,
+      "good": 3.9045,
+      "ratio": 1.6269,
+      "suggested_scalar": 0.2453,
+      "log_bad": 0.8755,
+      "log_good": 1.3621
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 291.0,
+      "good": 227.0,
+      "ratio": 0.7801,
+      "suggested_scalar": -0.1252,
+      "log_bad": 5.6733,
+      "log_good": 5.425
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6448,
+      "good": 0.4934,
+      "ratio": 0.7652,
+      "suggested_scalar": -0.1349,
+      "log_bad": -0.4388,
+      "log_good": -0.7064
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 90.0,
+      "good": 77.0,
+      "ratio": 0.8556,
+      "suggested_scalar": -0.0786,
+      "log_bad": 4.4998,
+      "log_good": 4.3438
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 823.0,
+      "good": 730.0,
+      "ratio": 0.887,
+      "suggested_scalar": -0.0604,
+      "log_bad": 6.713,
+      "log_good": 6.593
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 153.0,
+      "good": 101.0,
+      "ratio": 0.6601,
+      "suggested_scalar": -0.2093,
+      "log_bad": 5.0304,
+      "log_good": 4.6151
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0168,
+      "good": 0.0228,
+      "ratio": 1.3571,
+      "suggested_scalar": 0.1539,
+      "log_bad": -4.0864,
+      "log_good": -3.781
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2801,
+      "good": 0.327,
+      "ratio": 1.1674,
+      "suggested_scalar": 0.078,
+      "log_bad": -1.2726,
+      "log_good": -1.1178
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 57.0,
+      "good": 33.0,
+      "ratio": 0.5789,
+      "suggested_scalar": -0.2754,
+      "log_bad": 4.0431,
+      "log_good": 3.4965
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 90.0,
+      "good": 77.0,
+      "ratio": 0.8556,
+      "suggested_scalar": -0.0786,
+      "log_bad": 4.4998,
+      "log_good": 4.3438
+    },
+    "brevity.mean_sample_size": {
+      "bad": 90.0,
+      "good": 77.0,
+      "ratio": 0.8556,
+      "suggested_scalar": -0.0786,
+      "log_bad": 4.4998,
+      "log_good": 4.3438
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 357.0,
+      "good": 263.0,
+      "ratio": 0.7367,
+      "suggested_scalar": -0.154,
+      "log_bad": 5.8777,
+      "log_good": 5.5722
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 170.0,
+      "good": 132.0,
+      "ratio": 0.7765,
+      "suggested_scalar": -0.1275,
+      "log_bad": 5.1358,
+      "log_good": 4.8828
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 227.0,
+      "good": 181.0,
+      "ratio": 0.7974,
+      "suggested_scalar": -0.1141,
+      "log_bad": 5.425,
+      "log_good": 5.1985
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0028,
+      "good": 0.0038,
+      "ratio": 1.3571,
+      "suggested_scalar": 0.1539,
+      "log_bad": -5.8781,
+      "log_good": -5.5728
+    },
+    "heaps.mean_k": {
+      "bad": 2.7568,
+      "good": 2.3443,
+      "ratio": 0.8504,
+      "suggested_scalar": -0.0817,
+      "log_bad": 1.0141,
+      "log_good": 0.852
+    },
+    "halstead.mean_effort": {
+      "bad": 52674.412,
+      "good": 29587.0973,
+      "ratio": 0.5617,
+      "suggested_scalar": -0.2907,
+      "log_bad": 10.8719,
+      "log_good": 10.2951
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8758,
+      "good": 0.8811,
+      "ratio": 1.0061,
+      "suggested_scalar": 0.003,
+      "log_bad": -0.1326,
+      "log_good": -0.1266
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 59.0,
+      "good": 48.0,
+      "ratio": 0.8136,
+      "suggested_scalar": -0.104,
+      "log_bad": 4.0775,
+      "log_good": 3.8712
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 153.0,
+      "good": 143.0,
+      "ratio": 0.9346,
+      "suggested_scalar": -0.0341,
+      "log_bad": 5.0304,
+      "log_good": 4.9628
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3861,
+      "good": 0.4952,
+      "ratio": 1.2826,
+      "suggested_scalar": 0.1254,
+      "log_bad": -0.9517,
+      "log_good": -0.7028
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.2089,
+      "good": 6.9524,
+      "ratio": 1.3347,
+      "suggested_scalar": 0.1455,
+      "log_bad": 1.6504,
+      "log_good": 1.9391
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.197,
+      "good": 0.2308,
+      "ratio": 1.1716,
+      "suggested_scalar": 0.0798,
+      "log_bad": -1.6246,
+      "log_good": -1.4662
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.2455,
+      "good": 2.63,
+      "ratio": 0.8104,
+      "suggested_scalar": -0.106,
+      "log_bad": 1.1773,
+      "log_good": 0.967
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 356.0,
+      "good": 262.0,
+      "ratio": 0.736,
+      "suggested_scalar": -0.1545,
+      "log_bad": 5.8749,
+      "log_good": 5.5683
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 36.0,
+      "good": 15.0,
+      "ratio": 0.4167,
+      "suggested_scalar": -0.4412,
+      "log_bad": 3.5835,
+      "log_good": 2.7081
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2926.3562,
+      "good": 1643.7276,
+      "ratio": 0.5617,
+      "suggested_scalar": -0.2907,
+      "log_bad": 7.9815,
+      "log_good": 7.4047
+    },
+    "readability.mean_total_lines": {
+      "bad": 44.0,
+      "good": 40.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.048,
+      "log_bad": 3.7842,
+      "log_good": 3.6889
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 1934.51,
+      "good": 1480.1258,
+      "ratio": 0.7651,
+      "suggested_scalar": -0.1349,
+      "log_bad": 7.5676,
+      "log_good": 7.2999
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 628.0,
+      "good": 505.0,
+      "ratio": 0.8041,
+      "suggested_scalar": -0.1099,
+      "log_bad": 6.4425,
+      "log_good": 6.2246
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 26.1591,
+      "good": 30.825,
+      "ratio": 1.1784,
+      "suggested_scalar": 0.0827,
+      "log_bad": 3.2642,
+      "log_good": 3.4283
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0428,
+      "good": 1.2366,
+      "ratio": 1.1858,
+      "suggested_scalar": 0.0859,
+      "log_bad": 0.0419,
+      "log_good": 0.2124
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.145,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 25.0,
+      "good": 24.0,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0206,
+      "log_bad": 3.2189,
+      "log_good": 3.1781
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 9.0,
+      "good": 1.0,
+      "ratio": 0.1111,
+      "suggested_scalar": -1.1073,
+      "log_bad": 2.1972,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8763,
+      "good": 0.9339,
+      "ratio": 1.0657,
+      "suggested_scalar": 0.0321,
+      "log_bad": -0.132,
+      "log_good": -0.0684
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.983,
+      "good": 0.9771,
+      "ratio": 0.994,
+      "suggested_scalar": -0.003,
+      "log_bad": -0.0171,
+      "log_good": -0.0232
+    },
+    "halstead.mean_length": {
+      "bad": 306.0,
+      "good": 244.0,
+      "ratio": 0.7974,
+      "suggested_scalar": -0.1141,
+      "log_bad": 5.7236,
+      "log_good": 5.4972
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 20.3333,
+      "good": 15.6667,
+      "ratio": 0.7705,
+      "suggested_scalar": -0.1314,
+      "log_bad": 3.0123,
+      "log_good": 2.7515
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4919,
+      "good": 6.2668,
+      "ratio": 0.9653,
+      "suggested_scalar": -0.0178,
+      "log_bad": 1.8706,
+      "log_good": 1.8353
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1062,
+      "good": 0.1027,
+      "ratio": 0.967,
+      "suggested_scalar": -0.0169,
+      "log_bad": -2.2424,
+      "log_good": -2.2759
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.2288,
+      "good": 19.9896,
+      "ratio": 0.7341,
+      "suggested_scalar": -0.1558,
+      "log_bad": 3.3043,
+      "log_good": 2.9952
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 61.0,
+      "good": 52.0,
+      "ratio": 0.8525,
+      "suggested_scalar": -0.0804,
+      "log_bad": 4.1109,
+      "log_good": 3.9512
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7489,
+      "good": 0.8177,
+      "ratio": 1.0919,
+      "suggested_scalar": 0.0443,
+      "log_bad": -0.2891,
+      "log_good": -0.2013
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 53.0,
+      "good": 40.0,
+      "ratio": 0.7547,
+      "suggested_scalar": -0.1418,
+      "log_bad": 3.9703,
+      "log_good": 3.6889
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.copyability_is_explicitly_declared": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.2891,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.92,
+      "good": 0.8209,
+      "ratio": 0.8923,
+      "suggested_scalar": -0.03,
+      "log_bad": -0.0834,
+      "log_good": -0.1974
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.722,
+      "good": 4.5492,
+      "ratio": 0.9634,
+      "suggested_scalar": -0.0098,
+      "log_bad": 1.5522,
+      "log_good": 1.515
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 126.0,
+      "good": 91.0,
+      "ratio": 0.7222,
+      "suggested_scalar": -0.0856,
+      "log_bad": 4.8363,
+      "log_good": 4.5109
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4593,
+      "good": 0.2867,
+      "ratio": 0.6242,
+      "suggested_scalar": -0.124,
+      "log_bad": -0.7781,
+      "log_good": -1.2493
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 23.0,
+      "good": 22.0,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.0117,
+      "log_bad": 3.1355,
+      "log_good": 3.091
+    },
+    "heaps.mean_beta": {
+      "bad": 0.633,
+      "good": 0.6121,
+      "ratio": 0.967,
+      "suggested_scalar": -0.0088,
+      "log_bad": -0.4573,
+      "log_good": -0.4909
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.76,
+      "good": 5.6716,
+      "ratio": 1.5084,
+      "suggested_scalar": 0.1082,
+      "log_bad": 1.3244,
+      "log_good": 1.7355
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 535.0,
+      "good": 541.0,
+      "ratio": 1.0112,
+      "suggested_scalar": 0.0029,
+      "log_bad": 6.2823,
+      "log_good": 6.2934
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0757,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 0.0005,
+      "ratio": 0.0005,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -7.6009
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.38,
+      "good": 0.1493,
+      "ratio": 0.3929,
+      "suggested_scalar": -0.2458,
+      "log_bad": -0.9676,
+      "log_good": -1.9018
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9997,
+      "good": 1.1818,
+      "ratio": 1.1822,
+      "suggested_scalar": 0.044,
+      "log_bad": -0.0003,
+      "log_good": 0.167
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 226.0,
+      "good": 194.0,
+      "ratio": 0.8584,
+      "suggested_scalar": -0.0402,
+      "log_bad": 5.4205,
+      "log_good": 5.2679
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 106.7718,
+      "good": 108.9743,
+      "ratio": 1.0206,
+      "suggested_scalar": 0.0054,
+      "log_bad": 4.6707,
+      "log_good": 4.6911
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5375,
+      "good": 0.7593,
+      "ratio": 1.4127,
+      "suggested_scalar": 0.0909,
+      "log_bad": -0.6208,
+      "log_good": -0.2754
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.0525,
+      "good": 3.8473,
+      "ratio": 0.5455,
+      "suggested_scalar": -0.1595,
+      "log_bad": 1.9534,
+      "log_good": 1.3474
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2038.0,
+      "good": 2153.0,
+      "ratio": 1.0564,
+      "suggested_scalar": 0.0144,
+      "log_bad": 7.6197,
+      "log_good": 7.6746
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.04,
+      "good": 0.0299,
+      "ratio": 0.7475,
+      "suggested_scalar": -0.0766,
+      "log_bad": -3.2189,
+      "log_good": -3.5099
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9,
+      "good": 0.7761,
+      "ratio": 0.8623,
+      "suggested_scalar": -0.039,
+      "log_bad": -0.1054,
+      "log_good": -0.2535
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 11.1458,
+      "good": 8.5873,
+      "ratio": 0.7705,
+      "suggested_scalar": -0.0686,
+      "log_bad": 2.4111,
+      "log_good": 2.1503
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 21.0,
+      "good": 48.0,
+      "ratio": 2.2857,
+      "suggested_scalar": 0.2175,
+      "log_bad": 3.0445,
+      "log_good": 3.8712
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 6.6624,
+      "good": 15.2355,
+      "ratio": 2.2868,
+      "suggested_scalar": 0.2176,
+      "log_bad": 1.8965,
+      "log_good": 2.7236
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 176.0,
+      "good": 125.0,
+      "ratio": 0.7102,
+      "suggested_scalar": -0.09,
+      "log_bad": 5.1705,
+      "log_good": 4.8283
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.936,
+      "good": 0.9097,
+      "ratio": 0.9719,
+      "suggested_scalar": -0.0075,
+      "log_bad": -0.0661,
+      "log_good": -0.0946
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 33.0,
+      "good": 27.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.0528,
+      "log_bad": 3.4965,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5849,
+      "good": 0.6772,
+      "ratio": 1.1578,
+      "suggested_scalar": 0.0386,
+      "log_bad": -0.5363,
+      "log_good": -0.3898
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.364,
+      "good": 0.5807,
+      "ratio": 1.5953,
+      "suggested_scalar": 0.1229,
+      "log_bad": -1.0106,
+      "log_good": -0.5435
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.409,
+      "good": 3.0978,
+      "ratio": 1.2859,
+      "suggested_scalar": 0.0662,
+      "log_bad": 0.8792,
+      "log_good": 1.1307
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 533.0,
+      "good": 539.0,
+      "ratio": 1.0113,
+      "suggested_scalar": 0.0029,
+      "log_bad": 6.2785,
+      "log_good": 6.2897
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0355,
+      "good": 0.0425,
+      "ratio": 1.1972,
+      "suggested_scalar": 0.0474,
+      "log_bad": -3.3382,
+      "log_good": -3.1583
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.1085,
+      "good": 5.9069,
+      "ratio": 0.967,
+      "suggested_scalar": -0.0088,
+      "log_bad": 1.8097,
+      "log_good": 1.7761
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 28.0,
+      "good": 21.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0757,
+      "log_bad": 3.3322,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0073,
+      "good": 1.2543,
+      "ratio": 1.2452,
+      "suggested_scalar": 0.0577,
+      "log_bad": 0.0073,
+      "log_good": 0.2266
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.0831,
+      "good": 5.5142,
+      "ratio": 0.9065,
+      "suggested_scalar": -0.0258,
+      "log_bad": 1.8055,
+      "log_good": 1.7073
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.773,
+      "good": 0.7702,
+      "ratio": 0.9964,
+      "suggested_scalar": -0.001,
+      "log_bad": -0.2575,
+      "log_good": -0.2611
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2188,
+      "good": 0.1519,
+      "ratio": 0.6942,
+      "suggested_scalar": -0.096,
+      "log_bad": -1.5196,
+      "log_good": -1.8845
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.6557,
+      "good": 1.9615,
+      "ratio": 0.7386,
+      "suggested_scalar": -0.0797,
+      "log_bad": 0.9767,
+      "log_good": 0.6737
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 10.0,
+      "good": 1.0,
+      "ratio": 0.1,
+      "suggested_scalar": -0.6059,
+      "log_bad": 2.3026,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 412.0,
+      "good": 332.0,
+      "ratio": 0.8058,
+      "suggested_scalar": -0.0568,
+      "log_bad": 6.021,
+      "log_good": 5.8051
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 9.0,
+      "good": 19.0,
+      "ratio": 2.1111,
+      "suggested_scalar": 0.1966,
+      "log_bad": 2.1972,
+      "log_good": 2.9444
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.221,
+      "good": 1.1562,
+      "ratio": 0.9469,
+      "suggested_scalar": -0.0143,
+      "log_bad": 0.1997,
+      "log_good": 0.1451
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 129.0,
+      "good": 93.0,
+      "ratio": 0.7209,
+      "suggested_scalar": -0.0861,
+      "log_bad": 4.8598,
+      "log_good": 4.5326
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1029.0,
+      "good": 981.0,
+      "ratio": 0.9534,
+      "suggested_scalar": -0.0126,
+      "log_bad": 6.9363,
+      "log_good": 6.8886
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 260.0,
+      "good": 230.0,
+      "ratio": 0.8846,
+      "suggested_scalar": -0.0323,
+      "log_bad": 5.5607,
+      "log_good": 5.4381
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1907,
+      "good": 0.2773,
+      "ratio": 1.4541,
+      "suggested_scalar": 0.0985,
+      "log_bad": -1.6571,
+      "log_good": -1.2827
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 89.0,
+      "good": 105.0,
+      "ratio": 1.1798,
+      "suggested_scalar": 0.0435,
+      "log_bad": 4.4886,
+      "log_good": 4.654
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 129.0,
+      "good": 93.0,
+      "ratio": 0.7209,
+      "suggested_scalar": -0.0861,
+      "log_bad": 4.8598,
+      "log_good": 4.5326
+    },
+    "brevity.mean_sample_size": {
+      "bad": 129.0,
+      "good": 93.0,
+      "ratio": 0.7209,
+      "suggested_scalar": -0.0861,
+      "log_bad": 4.8598,
+      "log_good": 4.5326
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 535.0,
+      "good": 541.0,
+      "ratio": 1.0112,
+      "suggested_scalar": 0.0029,
+      "log_bad": 6.2823,
+      "log_good": 6.2934
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 255.0,
+      "good": 295.0,
+      "ratio": 1.1569,
+      "suggested_scalar": 0.0383,
+      "log_bad": 5.5413,
+      "log_good": 5.687
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 336.0,
+      "good": 235.0,
+      "ratio": 0.6994,
+      "suggested_scalar": -0.0941,
+      "log_bad": 5.8171,
+      "log_good": 5.4596
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0187,
+      "good": 1.0,
+      "ratio": 53.4759,
+      "suggested_scalar": 1.047,
+      "log_bad": -3.9792,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.6841,
+      "good": 2.401,
+      "ratio": 0.8945,
+      "suggested_scalar": -0.0293,
+      "log_bad": 0.9873,
+      "log_good": 0.8759
+    },
+    "halstead.mean_effort": {
+      "bad": 168973.9646,
+      "good": 168283.9431,
+      "ratio": 0.9959,
+      "suggested_scalar": -0.0011,
+      "log_bad": 12.0375,
+      "log_good": 12.0334
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8676,
+      "good": 0.8433,
+      "ratio": 0.972,
+      "suggested_scalar": -0.0075,
+      "log_bad": -0.142,
+      "log_good": -0.1704
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 93.0,
+      "good": 64.0,
+      "ratio": 0.6882,
+      "suggested_scalar": -0.0983,
+      "log_bad": 4.5326,
+      "log_good": 4.1589
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 265.0,
+      "good": 303.0,
+      "ratio": 1.1434,
+      "suggested_scalar": 0.0353,
+      "log_bad": 5.5797,
+      "log_good": 5.7137
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3496,
+      "good": 0.2629,
+      "ratio": 0.752,
+      "suggested_scalar": -0.075,
+      "log_bad": -1.051,
+      "log_good": -1.336
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.5531,
+      "good": 5.0567,
+      "ratio": 1.1106,
+      "suggested_scalar": 0.0276,
+      "log_bad": 1.5158,
+      "log_good": 1.6207
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2188,
+      "good": 0.1519,
+      "ratio": 0.6942,
+      "suggested_scalar": -0.096,
+      "log_bad": -1.5196,
+      "log_good": -1.8845
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.4583,
+      "good": 3.4349,
+      "ratio": 0.7705,
+      "suggested_scalar": -0.0686,
+      "log_bad": 1.4948,
+      "log_good": 1.234
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 534.0,
+      "good": 540.0,
+      "ratio": 1.0112,
+      "suggested_scalar": 0.0029,
+      "log_bad": 6.2804,
+      "log_good": 6.2916
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 0.3648,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 73.0,
+      "good": 106.0,
+      "ratio": 1.4521,
+      "suggested_scalar": 0.0981,
+      "log_bad": 4.2905,
+      "log_good": 4.6634
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 9387.4425,
+      "good": 9349.1079,
+      "ratio": 0.9959,
+      "suggested_scalar": -0.0011,
+      "log_bad": 9.1471,
+      "log_good": 9.143
+    },
+    "readability.mean_total_lines": {
+      "bad": 48.0,
+      "good": 63.0,
+      "ratio": 1.3125,
+      "suggested_scalar": 0.0716,
+      "log_bad": 3.8712,
+      "log_good": 4.1431
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 18.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1067,
+      "log_bad": 2.4849,
+      "log_good": 2.8904
+    },
+    "halstead.mean_volume": {
+      "bad": 3663.072,
+      "good": 3468.6545,
+      "ratio": 0.9469,
+      "suggested_scalar": -0.0143,
+      "log_bad": 8.2061,
+      "log_good": 8.1515
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 846.0,
+      "good": 695.0,
+      "ratio": 0.8215,
+      "suggested_scalar": -0.0517,
+      "log_bad": 6.7405,
+      "log_good": 6.5439
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 39.9583,
+      "good": 31.6032,
+      "ratio": 0.7909,
+      "suggested_scalar": -0.0617,
+      "log_bad": 3.6878,
+      "log_good": 3.4533
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0491,
+      "good": 1.0537,
+      "ratio": 1.0044,
+      "suggested_scalar": 0.0012,
+      "log_bad": 0.0479,
+      "log_good": 0.0523
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0757,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 13.0,
+      "good": 27.0,
+      "ratio": 2.0769,
+      "suggested_scalar": 0.1923,
+      "log_bad": 2.5649,
+      "log_good": 3.2958
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 19.0,
+      "good": 10.0,
+      "ratio": 0.5263,
+      "suggested_scalar": -0.1689,
+      "log_bad": 2.9444,
+      "log_good": 2.3026
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8228,
+      "good": 0.6807,
+      "ratio": 0.8273,
+      "suggested_scalar": -0.0499,
+      "log_bad": -0.195,
+      "log_good": -0.3846
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9474,
+      "good": 0.9143,
+      "ratio": 0.9651,
+      "suggested_scalar": -0.0094,
+      "log_bad": -0.054,
+      "log_good": -0.0896
+    },
+    "halstead.mean_length": {
+      "bad": 525.0,
+      "good": 533.0,
+      "ratio": 1.0152,
+      "suggested_scalar": 0.004,
+      "log_bad": 6.2634,
+      "log_good": 6.2785
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.0112,
+      "good": 6.5392,
+      "ratio": 0.9327,
+      "suggested_scalar": -0.0183,
+      "log_bad": 1.9475,
+      "log_good": 1.8778
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1262,
+      "good": 0.1375,
+      "ratio": 1.0895,
+      "suggested_scalar": 0.0226,
+      "log_bad": -2.0699,
+      "log_good": -1.9841
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 46.129,
+      "good": 48.5156,
+      "ratio": 1.0517,
+      "suggested_scalar": 0.0133,
+      "log_bad": 3.8314,
+      "log_good": 3.8819
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 79.0,
+      "good": 51.0,
+      "ratio": 0.6456,
+      "suggested_scalar": -0.1152,
+      "log_bad": 4.3694,
+      "log_good": 3.9318
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7351,
+      "good": 0.5532,
+      "ratio": 0.7526,
+      "suggested_scalar": -0.0748,
+      "log_bad": -0.3077,
+      "log_good": -0.592
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 50.0,
+      "good": 67.0,
+      "ratio": 1.34,
+      "suggested_scalar": 0.077,
+      "log_bad": 3.912,
+      "log_good": 4.2047
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 11.0,
+      "ratio": 0.7857,
+      "suggested_scalar": -0.0635,
+      "log_bad": 2.6391,
+      "log_good": 2.3979
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "consistency.switch_fallthrough_has_comment": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.uses_mb_string_functions_for_unicode": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.uses_safe_call_over_null_check": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 20.0,
+      "good": 30.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1542,
+      "log_bad": 2.9957,
+      "log_good": 3.4012
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0028,
+      "good": 0.0057,
+      "ratio": 2.0357,
+      "suggested_scalar": 0.2703,
+      "log_bad": -5.8781,
+      "log_good": -5.1673
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.25,
+      "good": 1.2,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0155,
+      "log_bad": 0.2231,
+      "log_good": 0.1823
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.5741,
+      "good": 0.875,
+      "ratio": 1.5241,
+      "suggested_scalar": 0.1603,
+      "log_bad": -0.555,
+      "log_good": -0.1335
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0028,
+      "good": 0.0057,
+      "ratio": 2.0357,
+      "suggested_scalar": 0.2703,
+      "log_bad": -5.8781,
+      "log_good": -5.1673
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.1148,
+      "good": 4.6445,
+      "ratio": 1.1287,
+      "suggested_scalar": 0.0461,
+      "log_bad": 1.4146,
+      "log_good": 1.5357
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 62.0,
+      "good": 87.0,
+      "ratio": 1.4032,
+      "suggested_scalar": 0.1288,
+      "log_bad": 4.1271,
+      "log_good": 4.4659
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3467,
+      "good": 0.4782,
+      "ratio": 1.3793,
+      "suggested_scalar": 0.1223,
+      "log_bad": -1.0593,
+      "log_good": -0.7377
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 13.0,
+      "good": 14.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0282,
+      "log_bad": 2.5649,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5426,
+      "good": 0.6627,
+      "ratio": 1.2213,
+      "suggested_scalar": 0.076,
+      "log_bad": -0.6114,
+      "log_good": -0.4114
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 8.963,
+      "good": 5.125,
+      "ratio": 0.5718,
+      "suggested_scalar": -0.2126,
+      "log_bad": 2.1931,
+      "log_good": 1.6341
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 356.0,
+      "good": 353.0,
+      "ratio": 0.9916,
+      "suggested_scalar": -0.0032,
+      "log_bad": 5.8749,
+      "log_good": 5.8665
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 3.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2636,
+      "log_bad": 1.7918,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0052,
+      "good": 1.0,
+      "ratio": 192.3077,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.2591,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0185,
+      "good": 0.1563,
+      "ratio": 8.4486,
+      "suggested_scalar": 0.8115,
+      "log_bad": -3.99,
+      "log_good": -1.856
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0026,
+      "good": 0.016,
+      "ratio": 6.1538,
+      "suggested_scalar": 0.691,
+      "log_bad": -5.9522,
+      "log_good": -4.1352
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1698,
+      "good": 1.0179,
+      "ratio": 0.8701,
+      "suggested_scalar": -0.0529,
+      "log_bad": 0.1568,
+      "log_good": 0.0177
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 114.0,
+      "good": 132.0,
+      "ratio": 1.1579,
+      "suggested_scalar": 0.0558,
+      "log_bad": 4.7362,
+      "log_good": 4.8828
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.054,
+      "good": 91.4802,
+      "ratio": 0.9053,
+      "suggested_scalar": -0.0379,
+      "log_bad": 4.6157,
+      "log_good": 4.5161
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7155,
+      "good": 0.5767,
+      "ratio": 0.806,
+      "suggested_scalar": -0.082,
+      "log_bad": -0.3348,
+      "log_good": -0.5504
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.2091,
+      "good": 12.0883,
+      "ratio": 1.0784,
+      "suggested_scalar": 0.0287,
+      "log_bad": 2.4167,
+      "log_good": 2.4922
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1938.0,
+      "good": 1691.0,
+      "ratio": 0.8725,
+      "suggested_scalar": -0.0518,
+      "log_bad": 7.5694,
+      "log_good": 7.4331
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1852,
+      "good": 0.125,
+      "ratio": 0.6749,
+      "suggested_scalar": -0.1495,
+      "log_bad": -1.6863,
+      "log_good": -2.0794
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.5,
+      "good": 0.8438,
+      "ratio": 1.6876,
+      "suggested_scalar": 0.199,
+      "log_bad": -0.6931,
+      "log_good": -0.1698
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.5926,
+      "good": 11.0313,
+      "ratio": 1.6733,
+      "suggested_scalar": 0.1958,
+      "log_bad": 1.8859,
+      "log_good": 2.4007
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 27.2209,
+      "good": 9.2344,
+      "ratio": 0.3392,
+      "suggested_scalar": -0.4111,
+      "log_bad": 3.304,
+      "log_good": 2.2229
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 69.0,
+      "good": 68.0,
+      "ratio": 0.9855,
+      "suggested_scalar": -0.0056,
+      "log_bad": 4.2341,
+      "log_good": 4.2195
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.8741,
+      "good": 0.939,
+      "ratio": 1.0742,
+      "suggested_scalar": 0.0272,
+      "log_bad": -0.1346,
+      "log_good": -0.0629
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 15.0,
+      "good": 18.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0693,
+      "log_bad": 2.7081,
+      "log_good": 2.8904
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.7441,
+      "good": 0.6464,
+      "ratio": 0.8687,
+      "suggested_scalar": -0.0535,
+      "log_bad": -0.2956,
+      "log_good": -0.4363
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5791,
+      "good": 0.4188,
+      "ratio": 0.7232,
+      "suggested_scalar": -0.1232,
+      "log_bad": -0.5463,
+      "log_good": -0.8704
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.9073,
+      "good": 2.8278,
+      "ratio": 0.7237,
+      "suggested_scalar": -0.123,
+      "log_bad": 1.3628,
+      "log_good": 1.0395
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 354.0,
+      "good": 351.0,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0032,
+      "log_bad": 5.8693,
+      "log_good": 5.8608
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 15.0,
+      "good": 9.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.1943,
+      "log_bad": 2.7081,
+      "log_good": 2.1972
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0421,
+      "good": 0.0453,
+      "ratio": 1.076,
+      "suggested_scalar": 0.0279,
+      "log_bad": -3.1677,
+      "log_good": -3.0944
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.6147,
+      "good": 5.7814,
+      "ratio": 1.0297,
+      "suggested_scalar": 0.0111,
+      "log_bad": 1.7254,
+      "log_good": 1.7546
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 25.0,
+      "good": 34.0,
+      "ratio": 1.36,
+      "suggested_scalar": 0.1169,
+      "log_bad": 3.2189,
+      "log_good": 3.5264
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.359,
+      "good": 1.4828,
+      "ratio": 1.0911,
+      "suggested_scalar": 0.0332,
+      "log_bad": 0.3067,
+      "log_good": 0.3939
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.1447,
+      "good": 5.5633,
+      "ratio": 1.0814,
+      "suggested_scalar": 0.0297,
+      "log_bad": 1.638,
+      "log_good": 1.7162
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7329,
+      "good": 0.8034,
+      "ratio": 1.0962,
+      "suggested_scalar": 0.0349,
+      "log_bad": -0.3107,
+      "log_good": -0.2189
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1148,
+      "good": 0.2,
+      "ratio": 1.7422,
+      "suggested_scalar": 0.2111,
+      "log_bad": -2.1646,
+      "log_good": -1.6094
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.348,
+      "good": 3.4768,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0144,
+      "log_bad": 1.2084,
+      "log_good": 1.2461
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 209.0,
+      "good": 246.0,
+      "ratio": 1.177,
+      "suggested_scalar": 0.062,
+      "log_bad": 5.3423,
+      "log_good": 5.5053
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 6.0,
+      "good": 10.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.1943,
+      "log_bad": 1.7918,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6569,
+      "good": 0.6744,
+      "ratio": 1.0266,
+      "suggested_scalar": 0.01,
+      "log_bad": -0.4202,
+      "log_good": -0.3939
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 64.0,
+      "good": 90.0,
+      "ratio": 1.4063,
+      "suggested_scalar": 0.1297,
+      "log_bad": 4.1589,
+      "log_good": 4.4998
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 817.0,
+      "good": 945.0,
+      "ratio": 1.1567,
+      "suggested_scalar": 0.0554,
+      "log_bad": 6.7056,
+      "log_good": 6.8512
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 150.0,
+      "good": 161.0,
+      "ratio": 1.0733,
+      "suggested_scalar": 0.0269,
+      "log_bad": 5.0106,
+      "log_good": 5.0814
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.236,
+      "good": 0.2465,
+      "ratio": 1.0445,
+      "suggested_scalar": 0.0166,
+      "log_bad": -1.4439,
+      "log_good": -1.4004
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 62.0,
+      "good": 49.0,
+      "ratio": 0.7903,
+      "suggested_scalar": -0.0895,
+      "log_bad": 4.1271,
+      "log_good": 3.8918
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0849,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 64.0,
+      "good": 90.0,
+      "ratio": 1.4063,
+      "suggested_scalar": 0.1297,
+      "log_bad": 4.1589,
+      "log_good": 4.4998
+    },
+    "brevity.mean_sample_size": {
+      "bad": 64.0,
+      "good": 90.0,
+      "ratio": 1.4063,
+      "suggested_scalar": 0.1297,
+      "log_bad": 4.1589,
+      "log_good": 4.4998
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 356.0,
+      "good": 353.0,
+      "ratio": 0.9916,
+      "suggested_scalar": -0.0032,
+      "log_bad": 5.8749,
+      "log_good": 5.8665
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 174.0,
+      "good": 166.0,
+      "ratio": 0.954,
+      "suggested_scalar": -0.0179,
+      "log_bad": 5.1591,
+      "log_good": 5.112
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 163.0,
+      "good": 198.0,
+      "ratio": 1.2147,
+      "suggested_scalar": 0.074,
+      "log_bad": 5.0938,
+      "log_good": 5.2883
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.917,
+      "good": 1.883,
+      "ratio": 0.6455,
+      "suggested_scalar": -0.1665,
+      "log_bad": 1.0706,
+      "log_good": 0.6329
+    },
+    "halstead.mean_effort": {
+      "bad": 47174.3373,
+      "good": 42484.7694,
+      "ratio": 0.9006,
+      "suggested_scalar": -0.0398,
+      "log_bad": 10.7616,
+      "log_good": 10.6569
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8574,
+      "good": 0.857,
+      "ratio": 0.9995,
+      "suggested_scalar": -0.0002,
+      "log_bad": -0.1539,
+      "log_good": -0.1543
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 47.0,
+      "good": 69.0,
+      "ratio": 1.4681,
+      "suggested_scalar": 0.146,
+      "log_bad": 3.8501,
+      "log_good": 4.2341
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 181.0,
+      "good": 153.0,
+      "ratio": 0.8453,
+      "suggested_scalar": -0.0639,
+      "log_bad": 5.1985,
+      "log_good": 5.0304
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3509,
+      "good": 0.4621,
+      "ratio": 1.3169,
+      "suggested_scalar": 0.1047,
+      "log_bad": -1.0473,
+      "log_good": -0.772
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.1667,
+      "good": 7.1591,
+      "ratio": 0.9989,
+      "suggested_scalar": -0.0004,
+      "log_bad": 1.9694,
+      "log_good": 1.9684
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1148,
+      "good": 0.2,
+      "ratio": 1.7422,
+      "suggested_scalar": 0.2111,
+      "log_bad": -2.1646,
+      "log_good": -1.6094
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.184,
+      "good": 6.348,
+      "ratio": 1.5172,
+      "suggested_scalar": 0.1585,
+      "log_bad": 1.4313,
+      "log_good": 1.8481
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 355.0,
+      "good": 352.0,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0032,
+      "log_bad": 5.8721,
+      "log_good": 5.8636
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.4178,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 60.0,
+      "good": 42.0,
+      "ratio": 0.7,
+      "suggested_scalar": -0.1356,
+      "log_bad": 4.0943,
+      "log_good": 3.7377
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2620.7965,
+      "good": 2360.265,
+      "ratio": 0.9006,
+      "suggested_scalar": -0.0398,
+      "log_bad": 7.8712,
+      "log_good": 7.7665
+    },
+    "readability.mean_total_lines": {
+      "bad": 54.0,
+      "good": 32.0,
+      "ratio": 0.5926,
+      "suggested_scalar": -0.199,
+      "log_bad": 3.989,
+      "log_good": 3.4657
+    },
+    "indentation.mean_max_depth": {
+      "bad": 20.0,
+      "good": 8.0,
+      "ratio": 0.4,
+      "suggested_scalar": -0.3485,
+      "log_bad": 2.9957,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 1970.839,
+      "good": 2023.0843,
+      "ratio": 1.0265,
+      "suggested_scalar": 0.0099,
+      "log_bad": 7.5862,
+      "log_good": 7.6124
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 496.0,
+      "good": 598.0,
+      "ratio": 1.2056,
+      "suggested_scalar": 0.0711,
+      "log_bad": 6.2066,
+      "log_good": 6.3936
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 34.7593,
+      "good": 51.4063,
+      "ratio": 1.4789,
+      "suggested_scalar": 0.1488,
+      "log_bad": 3.5484,
+      "log_good": 3.9398
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1713,
+      "good": 1.2312,
+      "ratio": 1.0511,
+      "suggested_scalar": 0.019,
+      "log_bad": 0.1581,
+      "log_good": 0.208
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 3.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2636,
+      "log_bad": 1.7918,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 19.0,
+      "good": 26.0,
+      "ratio": 1.3684,
+      "suggested_scalar": 0.1193,
+      "log_bad": 2.9444,
+      "log_good": 3.2581
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 0.6121,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7129,
+      "good": 0.8293,
+      "ratio": 1.1633,
+      "suggested_scalar": 0.0575,
+      "log_bad": -0.3384,
+      "log_good": -0.1872
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9497,
+      "good": 0.9828,
+      "ratio": 1.0349,
+      "suggested_scalar": 0.013,
+      "log_bad": -0.0516,
+      "log_good": -0.0173
+    },
+    "halstead.mean_length": {
+      "bad": 331.0,
+      "good": 314.0,
+      "ratio": 0.9486,
+      "suggested_scalar": -0.0201,
+      "log_bad": 5.8021,
+      "log_good": 5.7494
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 13.25,
+      "good": 6.4,
+      "ratio": 0.483,
+      "suggested_scalar": -0.2767,
+      "log_bad": 2.584,
+      "log_good": 1.8563
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.0,
+      "good": 6.4919,
+      "ratio": 1.082,
+      "suggested_scalar": 0.03,
+      "log_bad": 1.7918,
+      "log_good": 1.8706
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0898,
+      "good": 0.0985,
+      "ratio": 1.0969,
+      "suggested_scalar": 0.0352,
+      "log_bad": -2.4102,
+      "log_good": -2.3177
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 23.9362,
+      "good": 21.0,
+      "ratio": 0.8773,
+      "suggested_scalar": -0.0498,
+      "log_bad": 3.1754,
+      "log_good": 3.0445
+    },
+    "branching.mean_branch_count": {
+      "bad": 10.0,
+      "good": 4.0,
+      "ratio": 0.4,
+      "suggested_scalar": -0.3485,
+      "log_bad": 2.3026,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 40.0,
+      "good": 61.0,
+      "ratio": 1.525,
+      "suggested_scalar": 0.1605,
+      "log_bad": 3.6889,
+      "log_good": 4.1109
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6196,
+      "good": 0.7525,
+      "ratio": 1.2145,
+      "suggested_scalar": 0.0739,
+      "log_bad": -0.4787,
+      "log_good": -0.2844
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 54.0,
+      "good": 32.0,
+      "ratio": 0.5926,
+      "suggested_scalar": -0.199,
+      "log_bad": 3.989,
+      "log_good": 3.4657
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.uses_elvis_for_nullable_default": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 13.0,
+      "good": 14.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0261,
+      "log_bad": 2.5649,
+      "log_good": 2.6391
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0095,
+      "good": 0.0411,
+      "ratio": 4.3263,
+      "suggested_scalar": 0.5154,
+      "log_bad": -4.6565,
+      "log_good": -3.1917
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.5,
+      "good": 1.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2439,
+      "log_bad": -0.6931,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8833,
+      "good": 0.9375,
+      "ratio": 1.0614,
+      "suggested_scalar": 0.021,
+      "log_bad": -0.1241,
+      "log_good": -0.0645
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0095,
+      "good": 0.0411,
+      "ratio": 4.3263,
+      "suggested_scalar": 0.5154,
+      "log_bad": -4.6565,
+      "log_good": -3.1917
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.2577,
+      "good": 4.4737,
+      "ratio": 1.0507,
+      "suggested_scalar": 0.0174,
+      "log_bad": 1.4487,
+      "log_good": 1.4982
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 77.0,
+      "good": 69.0,
+      "ratio": 0.8961,
+      "suggested_scalar": -0.0386,
+      "log_bad": 4.3438,
+      "log_good": 4.2341
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.406,
+      "good": 0.4222,
+      "ratio": 1.0399,
+      "suggested_scalar": 0.0138,
+      "log_bad": -0.9014,
+      "log_good": -0.8623
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 17.0,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.0213,
+      "log_bad": 2.7726,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6013,
+      "good": 0.6157,
+      "ratio": 1.0239,
+      "suggested_scalar": 0.0083,
+      "log_bad": -0.5087,
+      "log_good": -0.485
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 7.2,
+      "good": 6.5833,
+      "ratio": 0.9143,
+      "suggested_scalar": -0.0315,
+      "log_bad": 1.9741,
+      "log_good": 1.8845
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 315.0,
+      "good": 292.0,
+      "ratio": 0.927,
+      "suggested_scalar": -0.0267,
+      "log_bad": 5.7526,
+      "log_good": 5.6768
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0034,
+      "good": 1.0,
+      "ratio": 294.1176,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.684,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.05,
+      "good": 1.0,
+      "ratio": 20.0,
+      "suggested_scalar": 1.0541,
+      "log_bad": -2.9957,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0039,
+      "good": 0.012,
+      "ratio": 3.0769,
+      "suggested_scalar": 0.3955,
+      "log_bad": -5.5468,
+      "log_good": -4.4228
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9738,
+      "good": 1.0225,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0172,
+      "log_bad": -0.0265,
+      "log_good": 0.0223
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 104.0,
+      "good": 90.0,
+      "ratio": 0.8654,
+      "suggested_scalar": -0.0509,
+      "log_bad": 4.6444,
+      "log_good": 4.4998
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.2163,
+      "good": 100.1979,
+      "ratio": 0.9614,
+      "suggested_scalar": -0.0138,
+      "log_bad": 4.6465,
+      "log_good": 4.6071
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5,
+      "good": 0.488,
+      "ratio": 0.976,
+      "suggested_scalar": -0.0085,
+      "log_bad": -0.6931,
+      "log_good": -0.7174
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.0243,
+      "good": 10.4451,
+      "ratio": 1.042,
+      "suggested_scalar": 0.0145,
+      "log_bad": 2.305,
+      "log_good": 2.3461
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1784.0,
+      "good": 1505.0,
+      "ratio": 0.8436,
+      "suggested_scalar": -0.0598,
+      "log_bad": 7.4866,
+      "log_good": 7.3165
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.15,
+      "good": 0.0833,
+      "ratio": 0.5553,
+      "suggested_scalar": -0.207,
+      "log_bad": -1.8971,
+      "log_good": -2.4853
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8167,
+      "good": 0.875,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.0243,
+      "log_bad": -0.2025,
+      "log_good": -0.1335
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.25,
+      "good": 6.0833,
+      "ratio": 1.1587,
+      "suggested_scalar": 0.0518,
+      "log_bad": 1.6582,
+      "log_good": 1.8055
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 15.36,
+      "good": 16.3264,
+      "ratio": 1.0629,
+      "suggested_scalar": 0.0215,
+      "log_bad": 2.7318,
+      "log_good": 2.7928
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 64.0,
+      "good": 49.0,
+      "ratio": 0.7656,
+      "suggested_scalar": -0.094,
+      "log_bad": 4.1589,
+      "log_good": 3.8918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9118,
+      "good": 0.9217,
+      "ratio": 1.0109,
+      "suggested_scalar": 0.0038,
+      "log_bad": -0.0923,
+      "log_good": -0.0815
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 20.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0785,
+      "log_bad": 3.2189,
+      "log_good": 2.9957
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6693,
+      "good": 0.6292,
+      "ratio": 0.9401,
+      "suggested_scalar": -0.0217,
+      "log_bad": -0.4015,
+      "log_good": -0.4633
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2939,
+      "good": 0.2759,
+      "ratio": 0.9388,
+      "suggested_scalar": -0.0222,
+      "log_bad": -1.2245,
+      "log_good": -1.2877
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0237,
+      "good": 2.6971,
+      "ratio": 0.892,
+      "suggested_scalar": -0.0402,
+      "log_bad": 1.1065,
+      "log_good": 0.9922
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 313.0,
+      "good": 290.0,
+      "ratio": 0.9265,
+      "suggested_scalar": -0.0269,
+      "log_bad": 5.7462,
+      "log_good": 5.6699
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 26.0,
+      "good": 18.0,
+      "ratio": 0.6923,
+      "suggested_scalar": -0.1294,
+      "log_bad": 3.2581,
+      "log_good": 2.8904
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0286,
+      "good": 0.0411,
+      "ratio": 1.4371,
+      "suggested_scalar": 0.1276,
+      "log_bad": -3.5543,
+      "log_good": -3.1917
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.858,
+      "good": 5.9307,
+      "ratio": 1.0124,
+      "suggested_scalar": 0.0043,
+      "log_bad": 1.7678,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3111,
+      "good": 1.4162,
+      "ratio": 1.0802,
+      "suggested_scalar": 0.0271,
+      "log_bad": 0.2709,
+      "log_good": 0.348
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6117,
+      "good": 5.3829,
+      "ratio": 0.9592,
+      "suggested_scalar": -0.0146,
+      "log_bad": 1.7249,
+      "log_good": 1.6832
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7268,
+      "good": 0.7543,
+      "ratio": 1.0378,
+      "suggested_scalar": 0.0131,
+      "log_bad": -0.3191,
+      "log_good": -0.282
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1304,
+      "good": 0.1579,
+      "ratio": 1.2109,
+      "suggested_scalar": 0.0673,
+      "log_bad": -2.0371,
+      "log_good": -1.8458
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1661,
+      "good": 3.2319,
+      "ratio": 1.0208,
+      "suggested_scalar": 0.0072,
+      "log_bad": 1.1525,
+      "log_good": 1.1731
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 258.0,
+      "good": 241.0,
+      "ratio": 0.9341,
+      "suggested_scalar": -0.024,
+      "log_bad": 5.553,
+      "log_good": 5.4848
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0785,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6121,
+      "good": 0.4887,
+      "ratio": 0.7984,
+      "suggested_scalar": -0.0792,
+      "log_bad": -0.4909,
+      "log_good": -0.716
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 79.0,
+      "good": 72.0,
+      "ratio": 0.9114,
+      "suggested_scalar": -0.0326,
+      "log_bad": 4.3694,
+      "log_good": 4.2767
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 761.0,
+      "good": 695.0,
+      "ratio": 0.9133,
+      "suggested_scalar": -0.0319,
+      "log_bad": 6.6346,
+      "log_good": 6.5439
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 134.0,
+      "good": 116.0,
+      "ratio": 0.8657,
+      "suggested_scalar": -0.0508,
+      "log_bad": 4.8978,
+      "log_good": 4.7536
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 0.0137,
+      "ratio": 0.0137,
+      "suggested_scalar": -1.5096,
+      "log_bad": 0.0,
+      "log_good": -4.2904
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1873,
+      "good": 0.2192,
+      "ratio": 1.1703,
+      "suggested_scalar": 0.0553,
+      "log_bad": -1.675,
+      "log_good": -1.5178
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 53.0,
+      "good": 49.0,
+      "ratio": 0.9245,
+      "suggested_scalar": -0.0276,
+      "log_bad": 3.9703,
+      "log_good": 3.8918
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1012,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 79.0,
+      "good": 72.0,
+      "ratio": 0.9114,
+      "suggested_scalar": -0.0326,
+      "log_bad": 4.3694,
+      "log_good": 4.2767
+    },
+    "brevity.mean_sample_size": {
+      "bad": 79.0,
+      "good": 72.0,
+      "ratio": 0.9114,
+      "suggested_scalar": -0.0326,
+      "log_bad": 4.3694,
+      "log_good": 4.2767
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 315.0,
+      "good": 292.0,
+      "ratio": 0.927,
+      "suggested_scalar": -0.0267,
+      "log_bad": 5.7526,
+      "log_good": 5.6768
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 152.0,
+      "good": 161.0,
+      "ratio": 1.0592,
+      "suggested_scalar": 0.0202,
+      "log_bad": 5.0239,
+      "log_good": 5.0814
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 210.0,
+      "good": 198.0,
+      "ratio": 0.9429,
+      "suggested_scalar": -0.0207,
+      "log_bad": 5.3471,
+      "log_good": 5.2883
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0063,
+      "good": 0.0068,
+      "ratio": 1.0794,
+      "suggested_scalar": 0.0269,
+      "log_bad": -5.0672,
+      "log_good": -4.9908
+    },
+    "heaps.mean_k": {
+      "bad": 2.5711,
+      "good": 2.2225,
+      "ratio": 0.8644,
+      "suggested_scalar": -0.0513,
+      "log_bad": 0.9443,
+      "log_good": 0.7986
+    },
+    "halstead.mean_effort": {
+      "bad": 59145.8109,
+      "good": 34706.392,
+      "ratio": 0.5868,
+      "suggested_scalar": -0.1876,
+      "log_bad": 10.9878,
+      "log_good": 10.4547
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8902,
+      "good": 0.8724,
+      "ratio": 0.98,
+      "suggested_scalar": -0.0071,
+      "log_bad": -0.1163,
+      "log_good": -0.1365
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 52.0,
+      "good": 49.0,
+      "ratio": 0.9423,
+      "suggested_scalar": -0.0209,
+      "log_bad": 3.9512,
+      "log_good": 3.8918
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 159.0,
+      "good": 124.0,
+      "ratio": 0.7799,
+      "suggested_scalar": -0.0875,
+      "log_bad": 5.0689,
+      "log_good": 4.8203
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4231,
+      "good": 0.4222,
+      "ratio": 0.9979,
+      "suggested_scalar": -0.0007,
+      "log_bad": -0.8601,
+      "log_good": -0.8623
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.3173,
+      "good": 7.7222,
+      "ratio": 1.0553,
+      "suggested_scalar": 0.019,
+      "log_bad": 1.9902,
+      "log_good": 2.0441
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1304,
+      "good": 0.1579,
+      "ratio": 1.2109,
+      "suggested_scalar": 0.0673,
+      "log_bad": -2.0371,
+      "log_good": -1.8458
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.6,
+      "good": 2.4333,
+      "ratio": 0.9359,
+      "suggested_scalar": -0.0233,
+      "log_bad": 0.9555,
+      "log_good": 0.8892
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 314.0,
+      "good": 291.0,
+      "ratio": 0.9268,
+      "suggested_scalar": -0.0268,
+      "log_bad": 5.7494,
+      "log_good": 5.6733
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 37.0,
+      "good": 31.0,
+      "ratio": 0.8378,
+      "suggested_scalar": -0.0623,
+      "log_bad": 3.6109,
+      "log_good": 3.434
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3285.8784,
+      "good": 1928.1329,
+      "ratio": 0.5868,
+      "suggested_scalar": -0.1876,
+      "log_bad": 8.0974,
+      "log_good": 7.5643
+    },
+    "readability.mean_total_lines": {
+      "bad": 60.0,
+      "good": 48.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0785,
+      "log_bad": 4.0943,
+      "log_good": 3.8712
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 12.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1012,
+      "log_bad": 2.7726,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 1836.1685,
+      "good": 1466.0459,
+      "ratio": 0.7984,
+      "suggested_scalar": -0.0792,
+      "log_bad": 7.5154,
+      "log_good": 7.2903
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 590.0,
+      "good": 558.0,
+      "ratio": 0.9458,
+      "suggested_scalar": -0.0196,
+      "log_bad": 6.3801,
+      "log_good": 6.3244
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 28.5833,
+      "good": 30.1042,
+      "ratio": 1.0532,
+      "suggested_scalar": 0.0182,
+      "log_bad": 3.3528,
+      "log_good": 3.4047
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.15,
+      "good": 1.1875,
+      "ratio": 1.0326,
+      "suggested_scalar": 0.0113,
+      "log_bad": 0.1398,
+      "log_good": 0.1719
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 15.0,
+      "good": 13.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.0504,
+      "log_bad": 2.7081,
+      "log_good": 2.5649
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.3866,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8566,
+      "good": 0.8714,
+      "ratio": 1.0173,
+      "suggested_scalar": 0.006,
+      "log_bad": -0.1548,
+      "log_good": -0.1377
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9658,
+      "good": 0.9725,
+      "ratio": 1.0069,
+      "suggested_scalar": 0.0024,
+      "log_bad": -0.0348,
+      "log_good": -0.0279
+    },
+    "halstead.mean_length": {
+      "bad": 293.0,
+      "good": 240.0,
+      "ratio": 0.8191,
+      "suggested_scalar": -0.0702,
+      "log_bad": 5.6802,
+      "log_good": 5.4806
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 13.25,
+      "good": 10.6667,
+      "ratio": 0.805,
+      "suggested_scalar": -0.0763,
+      "log_bad": 2.584,
+      "log_good": 2.3671
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.3038,
+      "good": 6.1699,
+      "ratio": 0.9788,
+      "suggested_scalar": -0.0076,
+      "log_bad": 1.8412,
+      "log_good": 1.8197
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0852,
+      "good": 0.1072,
+      "ratio": 1.2582,
+      "suggested_scalar": 0.0808,
+      "log_bad": -2.4628,
+      "log_good": -2.2331
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 32.2115,
+      "good": 23.6735,
+      "ratio": 0.7349,
+      "suggested_scalar": -0.1084,
+      "log_bad": 3.4723,
+      "log_good": 3.1644
+    },
+    "branching.mean_branch_count": {
+      "bad": 9.0,
+      "good": 4.0,
+      "ratio": 0.4444,
+      "suggested_scalar": -0.2853,
+      "log_bad": 2.1972,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 44.0,
+      "good": 38.0,
+      "ratio": 0.8636,
+      "suggested_scalar": -0.0516,
+      "log_bad": 3.7842,
+      "log_good": 3.6376
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7476,
+      "good": 0.7525,
+      "ratio": 1.0066,
+      "suggested_scalar": 0.0023,
+      "log_bad": -0.2909,
+      "log_good": -0.2844
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 60.0,
+      "good": 48.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0785,
+      "log_bad": 4.0943,
+      "log_good": 3.8712
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.does_not_use_abbreviated_names": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 24.0,
+      "good": 28.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.1005,
+      "log_bad": 3.1781,
+      "log_good": 3.3322
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0466,
+      "good": 1.0,
+      "ratio": 21.4592,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.0662,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6667,
+      "good": 1.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.5108,
+      "log_good": 0.5108
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8182,
+      "good": 0.7949,
+      "ratio": 0.9715,
+      "suggested_scalar": -0.0188,
+      "log_bad": -0.2006,
+      "log_good": -0.2295
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0466,
+      "good": 1.0,
+      "ratio": 21.4592,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.0662,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4981,
+      "good": 4.4633,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.0051,
+      "log_bad": 1.5037,
+      "log_good": 1.4959
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 117.0,
+      "good": 70.0,
+      "ratio": 0.5983,
+      "suggested_scalar": -0.3351,
+      "log_bad": 4.7622,
+      "log_good": 4.2485
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4484,
+      "good": 0.3733,
+      "ratio": 0.8325,
+      "suggested_scalar": -0.1196,
+      "log_bad": -0.8021,
+      "log_good": -0.9854
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 15.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1189,
+      "log_bad": 2.8904,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.651,
+      "good": 0.5695,
+      "ratio": 0.8748,
+      "suggested_scalar": -0.0872,
+      "log_bad": -0.4292,
+      "log_good": -0.563
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.4545,
+      "good": 4.5128,
+      "ratio": 1.0131,
+      "suggested_scalar": 0.0085,
+      "log_bad": 1.4939,
+      "log_good": 1.5069
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 429.0,
+      "good": 289.0,
+      "ratio": 0.6737,
+      "suggested_scalar": -0.2577,
+      "log_bad": 6.0615,
+      "log_good": 5.6664
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1136,
+      "good": 1.0,
+      "ratio": 8.8028,
+      "suggested_scalar": 1.4188,
+      "log_bad": -2.1751,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0022,
+      "good": 0.0012,
+      "ratio": 0.5455,
+      "suggested_scalar": -0.3954,
+      "log_bad": -6.1193,
+      "log_good": -6.7254
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0079,
+      "good": 1.0026,
+      "ratio": 0.9947,
+      "suggested_scalar": -0.0034,
+      "log_bad": 0.0079,
+      "log_good": 0.0026
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 155.0,
+      "good": 102.0,
+      "ratio": 0.6581,
+      "suggested_scalar": -0.2729,
+      "log_bad": 5.0434,
+      "log_good": 4.625
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.6148,
+      "good": 96.1711,
+      "ratio": 0.9464,
+      "suggested_scalar": -0.0359,
+      "log_bad": 4.6212,
+      "log_good": 4.5661
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4766,
+      "good": 0.5174,
+      "ratio": 1.0856,
+      "suggested_scalar": 0.0536,
+      "log_bad": -0.7411,
+      "log_good": -0.6589
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.4686,
+      "good": 20.2672,
+      "ratio": 1.5048,
+      "suggested_scalar": 0.2666,
+      "log_bad": 2.6004,
+      "log_good": 3.009
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1837.0,
+      "good": 1663.0,
+      "ratio": 0.9053,
+      "suggested_scalar": -0.0649,
+      "log_bad": 7.5159,
+      "log_good": 7.4164
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.3182,
+      "good": 0.2821,
+      "ratio": 0.8865,
+      "suggested_scalar": -0.0785,
+      "log_bad": -1.1451,
+      "log_good": -1.2655
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7955,
+      "good": 0.7692,
+      "ratio": 0.9669,
+      "suggested_scalar": -0.0219,
+      "log_bad": -0.2288,
+      "log_good": -0.2624
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.75,
+      "good": 7.4103,
+      "ratio": 0.76,
+      "suggested_scalar": -0.179,
+      "log_bad": 2.2773,
+      "log_good": 2.0029
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 6.7025,
+      "good": 7.5319,
+      "ratio": 1.1237,
+      "suggested_scalar": 0.0761,
+      "log_bad": 1.9025,
+      "log_good": 2.0191
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 97.0,
+      "good": 42.0,
+      "ratio": 0.433,
+      "suggested_scalar": -0.546,
+      "log_bad": 4.5747,
+      "log_good": 3.7377
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9205,
+      "good": 0.8589,
+      "ratio": 0.9331,
+      "suggested_scalar": -0.0452,
+      "log_bad": -0.0828,
+      "log_good": -0.1521
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 22.0,
+      "ratio": 0.7586,
+      "suggested_scalar": -0.1802,
+      "log_bad": 3.3673,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6135,
+      "good": 0.6873,
+      "ratio": 1.1203,
+      "suggested_scalar": 0.0741,
+      "log_bad": -0.4886,
+      "log_good": -0.375
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3162,
+      "good": 0.3484,
+      "ratio": 1.1018,
+      "suggested_scalar": 0.0633,
+      "log_bad": -1.1514,
+      "log_good": -1.0544
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5873,
+      "good": 3.1981,
+      "ratio": 1.2361,
+      "suggested_scalar": 0.1382,
+      "log_bad": 0.9506,
+      "log_good": 1.1626
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 427.0,
+      "good": 287.0,
+      "ratio": 0.6721,
+      "suggested_scalar": -0.2592,
+      "log_bad": 6.0568,
+      "log_good": 5.6595
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 8.0,
+      "good": 7.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0871,
+      "log_bad": 2.0794,
+      "log_good": 1.9459
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.049,
+      "good": 0.0692,
+      "ratio": 1.4122,
+      "suggested_scalar": 0.2252,
+      "log_bad": -3.0159,
+      "log_good": -2.6708
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8074,
+      "good": 5.6724,
+      "ratio": 0.9768,
+      "suggested_scalar": -0.0153,
+      "log_bad": 1.7591,
+      "log_good": 1.7356
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 33.0,
+      "good": 31.0,
+      "ratio": 0.9394,
+      "suggested_scalar": -0.0408,
+      "log_bad": 3.4965,
+      "log_good": 3.434
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.362,
+      "good": 1.6267,
+      "ratio": 1.1943,
+      "suggested_scalar": 0.1158,
+      "log_bad": 0.309,
+      "log_good": 0.4866
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8677,
+      "good": 5.4836,
+      "ratio": 0.9345,
+      "suggested_scalar": -0.0442,
+      "log_bad": 1.7695,
+      "log_good": 1.7018
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7745,
+      "good": 0.7868,
+      "ratio": 1.0159,
+      "suggested_scalar": 0.0103,
+      "log_bad": -0.2555,
+      "log_good": -0.2398
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1698,
+      "good": 0.1875,
+      "ratio": 1.1042,
+      "suggested_scalar": 0.0647,
+      "log_bad": -1.7731,
+      "log_good": -1.674
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.67,
+      "good": 4.5019,
+      "ratio": 1.2267,
+      "suggested_scalar": 0.1333,
+      "log_bad": 1.3002,
+      "log_good": 1.5045
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 339.0,
+      "good": 222.0,
+      "ratio": 0.6549,
+      "suggested_scalar": -0.2761,
+      "log_bad": 5.826,
+      "log_good": 5.4027
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8634,
+      "good": 0.57,
+      "ratio": 0.6602,
+      "suggested_scalar": -0.2709,
+      "log_bad": -0.1469,
+      "log_good": -0.5621
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 106.0,
+      "good": 71.0,
+      "ratio": 0.6698,
+      "suggested_scalar": -0.2614,
+      "log_bad": 4.6634,
+      "log_good": 4.2627
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 904.0,
+      "good": 974.0,
+      "ratio": 1.0774,
+      "suggested_scalar": 0.0486,
+      "log_bad": 6.8068,
+      "log_good": 6.8814
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 174.0,
+      "good": 121.0,
+      "ratio": 0.6954,
+      "suggested_scalar": -0.237,
+      "log_bad": 5.1591,
+      "log_good": 4.7958
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0117,
+      "good": 0.0173,
+      "ratio": 1.4786,
+      "suggested_scalar": 0.2551,
+      "log_bad": -4.4482,
+      "log_good": -4.057
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2214,
+      "good": 0.2388,
+      "ratio": 1.0786,
+      "suggested_scalar": 0.0493,
+      "log_bad": -1.5078,
+      "log_good": -1.4321
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 64.0,
+      "good": 48.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1877,
+      "log_bad": 4.1589,
+      "log_good": 3.8712
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 106.0,
+      "good": 71.0,
+      "ratio": 0.6698,
+      "suggested_scalar": -0.2614,
+      "log_bad": 4.6634,
+      "log_good": 4.2627
+    },
+    "brevity.mean_sample_size": {
+      "bad": 106.0,
+      "good": 71.0,
+      "ratio": 0.6698,
+      "suggested_scalar": -0.2614,
+      "log_bad": 4.6634,
+      "log_good": 4.2627
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 429.0,
+      "good": 289.0,
+      "ratio": 0.6737,
+      "suggested_scalar": -0.2577,
+      "log_bad": 6.0615,
+      "log_good": 5.6664
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 213.0,
+      "good": 140.0,
+      "ratio": 0.6573,
+      "suggested_scalar": -0.2737,
+      "log_bad": 5.3613,
+      "log_good": 4.9416
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 288.0,
+      "good": 187.0,
+      "ratio": 0.6493,
+      "suggested_scalar": -0.2817,
+      "log_bad": 5.663,
+      "log_good": 5.2311
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0023,
+      "good": 0.0035,
+      "ratio": 1.5217,
+      "suggested_scalar": 0.2739,
+      "log_bad": -6.0748,
+      "log_good": -5.655
+    },
+    "heaps.mean_k": {
+      "bad": 2.259,
+      "good": 3.043,
+      "ratio": 1.3471,
+      "suggested_scalar": 0.1943,
+      "log_bad": 0.8149,
+      "log_good": 1.1128
+    },
+    "halstead.mean_effort": {
+      "bad": 74260.1327,
+      "good": 47418.815,
+      "ratio": 0.6386,
+      "suggested_scalar": -0.2926,
+      "log_bad": 11.2153,
+      "log_good": 10.7668
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8721,
+      "good": 0.8917,
+      "ratio": 1.0225,
+      "suggested_scalar": 0.0145,
+      "log_bad": -0.1369,
+      "log_good": -0.1146
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 88.0,
+      "good": 48.0,
+      "ratio": 0.5455,
+      "suggested_scalar": -0.3954,
+      "log_bad": 4.4773,
+      "log_good": 3.8712
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 203.0,
+      "good": 158.0,
+      "ratio": 0.7783,
+      "suggested_scalar": -0.1635,
+      "log_bad": 5.3132,
+      "log_good": 5.0626
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4258,
+      "good": 0.3725,
+      "ratio": 0.8748,
+      "suggested_scalar": -0.0872,
+      "log_bad": -0.8538,
+      "log_good": -0.9875
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.8323,
+      "good": 9.549,
+      "ratio": 1.6373,
+      "suggested_scalar": 0.3216,
+      "log_bad": 1.7634,
+      "log_good": 2.2564
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1698,
+      "good": 0.1875,
+      "ratio": 1.1042,
+      "suggested_scalar": 0.0647,
+      "log_bad": -1.7731,
+      "log_good": -1.674
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.9,
+      "good": 3.2381,
+      "ratio": 0.8303,
+      "suggested_scalar": -0.1213,
+      "log_bad": 1.361,
+      "log_good": 1.175
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 428.0,
+      "good": 288.0,
+      "ratio": 0.6729,
+      "suggested_scalar": -0.2584,
+      "log_bad": 6.0591,
+      "log_good": 5.663
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 47.0,
+      "good": 35.0,
+      "ratio": 0.7447,
+      "suggested_scalar": -0.1923,
+      "log_bad": 3.8501,
+      "log_good": 3.5553
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4125.5629,
+      "good": 2634.3786,
+      "ratio": 0.6386,
+      "suggested_scalar": -0.2926,
+      "log_bad": 8.325,
+      "log_good": 7.8764
+    },
+    "readability.mean_total_lines": {
+      "bad": 44.0,
+      "good": 39.0,
+      "ratio": 0.8864,
+      "suggested_scalar": -0.0787,
+      "log_bad": 3.7842,
+      "log_good": 3.6636
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2590.1275,
+      "good": 1710.07,
+      "ratio": 0.6602,
+      "suggested_scalar": -0.2708,
+      "log_bad": 7.8595,
+      "log_good": 7.4443
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 710.0,
+      "good": 520.0,
+      "ratio": 0.7324,
+      "suggested_scalar": -0.2031,
+      "log_bad": 6.5653,
+      "log_good": 6.2538
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 40.5,
+      "good": 41.4103,
+      "ratio": 1.0225,
+      "suggested_scalar": 0.0145,
+      "log_bad": 3.7013,
+      "log_good": 3.7235
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1268,
+      "good": 1.2192,
+      "ratio": 1.082,
+      "suggested_scalar": 0.0514,
+      "log_bad": 0.1194,
+      "log_good": 0.1982
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 1.0,
+      "ratio": 0.2,
+      "suggested_scalar": -1.0498,
+      "log_bad": 1.6094,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8614,
+      "good": 0.8423,
+      "ratio": 0.9778,
+      "suggested_scalar": -0.0146,
+      "log_bad": -0.1492,
+      "log_good": -0.1716
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9795,
+      "good": 0.96,
+      "ratio": 0.9801,
+      "suggested_scalar": -0.0131,
+      "log_bad": -0.0207,
+      "log_good": -0.0408
+    },
+    "halstead.mean_length": {
+      "bad": 377.0,
+      "good": 279.0,
+      "ratio": 0.7401,
+      "suggested_scalar": -0.1964,
+      "log_bad": 5.9322,
+      "log_good": 5.6312
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.5,
+      "good": 5.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0622,
+      "log_bad": 1.7047,
+      "log_good": 1.6094
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7279,
+      "good": 6.1497,
+      "ratio": 0.9141,
+      "suggested_scalar": -0.0586,
+      "log_bad": 1.9063,
+      "log_good": 1.8164
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1161,
+      "good": 0.0842,
+      "ratio": 0.7252,
+      "suggested_scalar": -0.2096,
+      "log_bad": -2.1533,
+      "log_good": -2.4746
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 28.6705,
+      "good": 27.7292,
+      "ratio": 0.9672,
+      "suggested_scalar": -0.0218,
+      "log_bad": 3.3559,
+      "log_good": 3.3225
+    },
+    "branching.mean_branch_count": {
+      "bad": 14.0,
+      "good": 11.0,
+      "ratio": 0.7857,
+      "suggested_scalar": -0.1573,
+      "log_bad": 2.6391,
+      "log_good": 2.3979
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 66.0,
+      "good": 38.0,
+      "ratio": 0.5758,
+      "suggested_scalar": -0.3601,
+      "log_bad": 4.1897,
+      "log_good": 3.6376
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7778,
+      "good": 0.7433,
+      "ratio": 0.9556,
+      "suggested_scalar": -0.0296,
+      "log_bad": -0.2513,
+      "log_good": -0.2967
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 44.0,
+      "good": 39.0,
+      "ratio": 0.8864,
+      "suggested_scalar": -0.0787,
+      "log_bad": 3.7842,
+      "log_good": 3.6636
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.uses_assertive_pattern_matching": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2358,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0084,
+      "good": 0.0244,
+      "ratio": 2.9048,
+      "suggested_scalar": 0.3628,
+      "log_bad": -4.7795,
+      "log_good": -3.7132
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 2.3333,
+      "ratio": 1.5555,
+      "suggested_scalar": 0.1503,
+      "log_bad": 0.4055,
+      "log_good": 0.8473
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8868,
+      "good": 0.8571,
+      "ratio": 0.9665,
+      "suggested_scalar": -0.0116,
+      "log_bad": -0.1201,
+      "log_good": -0.1542
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0084,
+      "good": 0.0265,
+      "ratio": 3.1548,
+      "suggested_scalar": 0.3909,
+      "log_bad": -4.7795,
+      "log_good": -3.6306
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.2686,
+      "good": 4.7972,
+      "ratio": 1.1238,
+      "suggested_scalar": 0.0397,
+      "log_bad": 1.4513,
+      "log_good": 1.568
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 84.0,
+      "good": 92.0,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.031,
+      "log_bad": 4.4308,
+      "log_good": 4.5218
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5385,
+      "good": 0.5719,
+      "ratio": 1.062,
+      "suggested_scalar": 0.0205,
+      "log_bad": -0.619,
+      "log_good": -0.5588
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 22.0,
+      "ratio": 1.375,
+      "suggested_scalar": 0.1084,
+      "log_bad": 2.7726,
+      "log_good": 3.091
+    },
+    "heaps.mean_beta": {
+      "bad": 0.65,
+      "good": 0.6449,
+      "ratio": 0.9922,
+      "suggested_scalar": -0.0027,
+      "log_bad": -0.4308,
+      "log_good": -0.4387
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 7.9623,
+      "good": 3.1429,
+      "ratio": 0.3947,
+      "suggested_scalar": -0.3163,
+      "log_bad": 2.0747,
+      "log_good": 1.1451
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 356.0,
+      "good": 491.0,
+      "ratio": 1.3792,
+      "suggested_scalar": 0.1094,
+      "log_bad": 5.8749,
+      "log_good": 6.1964
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 0.0028,
+      "ratio": 0.0028,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.8781
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0566,
+      "good": 0.0536,
+      "ratio": 0.947,
+      "suggested_scalar": -0.0185,
+      "log_bad": -2.8717,
+      "log_good": -2.9262
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0312,
+      "good": 0.9164,
+      "ratio": 0.8887,
+      "suggested_scalar": -0.0402,
+      "log_bad": 0.0307,
+      "log_good": -0.0873
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 112.0,
+      "good": 202.0,
+      "ratio": 1.8036,
+      "suggested_scalar": 0.2007,
+      "log_bad": 4.7185,
+      "log_good": 5.3083
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 102.1119,
+      "good": 99.5119,
+      "ratio": 0.9745,
+      "suggested_scalar": -0.0088,
+      "log_bad": 4.6261,
+      "log_good": 4.6003
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6704,
+      "good": 0.6041,
+      "ratio": 0.9011,
+      "suggested_scalar": -0.0354,
+      "log_bad": -0.3999,
+      "log_good": -0.504
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 16.5605,
+      "good": 14.0168,
+      "ratio": 0.8464,
+      "suggested_scalar": -0.0567,
+      "log_bad": 2.807,
+      "log_good": 2.6403
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1738.0,
+      "good": 2183.0,
+      "ratio": 1.256,
+      "suggested_scalar": 0.0776,
+      "log_bad": 7.4605,
+      "log_good": 7.6885
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2264,
+      "good": 0.125,
+      "ratio": 0.5521,
+      "suggested_scalar": -0.2021,
+      "log_bad": -1.4855,
+      "log_good": -2.0794
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7358,
+      "good": 0.7857,
+      "ratio": 1.0678,
+      "suggested_scalar": 0.0223,
+      "log_bad": -0.3068,
+      "log_good": -0.2412
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.12,
+      "good": 9.2642,
+      "ratio": 1.3012,
+      "suggested_scalar": 0.0896,
+      "log_bad": 1.9629,
+      "log_good": 2.2262
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 27.6967,
+      "good": 2.2653,
+      "ratio": 0.0818,
+      "suggested_scalar": -0.8518,
+      "log_bad": 3.3213,
+      "log_good": 0.8177
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 89.0,
+      "good": 163.0,
+      "ratio": 1.8315,
+      "suggested_scalar": 0.2059,
+      "log_bad": 4.4886,
+      "log_good": 5.0938
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9398,
+      "good": 0.9542,
+      "ratio": 1.0153,
+      "suggested_scalar": 0.0052,
+      "log_bad": -0.0621,
+      "log_good": -0.0469
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 30.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0759,
+      "log_bad": 3.1781,
+      "log_good": 3.4012
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6605,
+      "good": 0.6175,
+      "ratio": 0.9349,
+      "suggested_scalar": -0.0229,
+      "log_bad": -0.4148,
+      "log_good": -0.4821
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4944,
+      "good": 0.411,
+      "ratio": 0.8313,
+      "suggested_scalar": -0.0629,
+      "log_bad": -0.7044,
+      "log_good": -0.8892
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9458,
+      "good": 2.6144,
+      "ratio": 0.8875,
+      "suggested_scalar": -0.0406,
+      "log_bad": 1.0804,
+      "log_good": 0.961
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 354.0,
+      "good": 489.0,
+      "ratio": 1.3814,
+      "suggested_scalar": 0.1099,
+      "log_bad": 5.8693,
+      "log_good": 6.1924
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 26.0,
+      "good": 21.0,
+      "ratio": 0.8077,
+      "suggested_scalar": -0.0727,
+      "log_bad": 3.2581,
+      "log_good": 3.0445
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0112,
+      "good": 0.0224,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2358,
+      "log_bad": -4.4918,
+      "log_good": -3.7987
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7004,
+      "good": 5.9773,
+      "ratio": 1.0486,
+      "suggested_scalar": 0.0161,
+      "log_bad": 1.7405,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 23.0,
+      "good": 39.0,
+      "ratio": 1.6957,
+      "suggested_scalar": 0.1797,
+      "log_bad": 3.1355,
+      "log_good": 3.6636
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7325,
+      "good": 0.7078,
+      "ratio": 0.9663,
+      "suggested_scalar": -0.0117,
+      "log_bad": -0.3113,
+      "log_good": -0.3456
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5224,
+      "good": 6.1235,
+      "ratio": 1.1088,
+      "suggested_scalar": 0.0352,
+      "log_bad": 1.7088,
+      "log_good": 1.8121
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7488,
+      "good": 0.8026,
+      "ratio": 1.0718,
+      "suggested_scalar": 0.0236,
+      "log_bad": -0.2893,
+      "log_good": -0.2199
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1452,
+      "good": 0.1642,
+      "ratio": 1.1309,
+      "suggested_scalar": 0.0418,
+      "log_bad": -1.9296,
+      "log_good": -1.8067
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.0695,
+      "good": 3.7439,
+      "ratio": 0.92,
+      "suggested_scalar": -0.0284,
+      "log_bad": 1.4035,
+      "log_good": 1.3201
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 241.0,
+      "good": 367.0,
+      "ratio": 1.5228,
+      "suggested_scalar": 0.1431,
+      "log_bad": 5.4848,
+      "log_good": 5.9054
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 0.5476,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7074,
+      "good": 0.8481,
+      "ratio": 1.1989,
+      "suggested_scalar": 0.0617,
+      "log_bad": -0.3462,
+      "log_good": -0.1648
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 133.0,
+      "ratio": 1.5647,
+      "suggested_scalar": 0.1523,
+      "log_bad": 4.4427,
+      "log_good": 4.8903
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 779.0,
+      "good": 1387.0,
+      "ratio": 1.7805,
+      "suggested_scalar": 0.1963,
+      "log_bad": 6.658,
+      "log_good": 7.2349
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 126.0,
+      "good": 149.0,
+      "ratio": 1.1825,
+      "suggested_scalar": 0.057,
+      "log_bad": 4.8363,
+      "log_good": 5.0039
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0337,
+      "good": 1.0,
+      "ratio": 29.6736,
+      "suggested_scalar": 1.1535,
+      "log_bad": -3.3903,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2247,
+      "good": 0.2281,
+      "ratio": 1.0151,
+      "suggested_scalar": 0.0051,
+      "log_bad": -1.493,
+      "log_good": -1.478
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 70.0,
+      "good": 99.0,
+      "ratio": 1.4143,
+      "suggested_scalar": 0.1179,
+      "log_bad": 4.2485,
+      "log_good": 4.5951
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.138,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 133.0,
+      "ratio": 1.5647,
+      "suggested_scalar": 0.1523,
+      "log_bad": 4.4427,
+      "log_good": 4.8903
+    },
+    "brevity.mean_sample_size": {
+      "bad": 85.0,
+      "good": 133.0,
+      "ratio": 1.5647,
+      "suggested_scalar": 0.1523,
+      "log_bad": 4.4427,
+      "log_good": 4.8903
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 356.0,
+      "good": 491.0,
+      "ratio": 1.3792,
+      "suggested_scalar": 0.1094,
+      "log_bad": 5.8749,
+      "log_good": 6.1964
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 192.0,
+      "good": 254.0,
+      "ratio": 1.3229,
+      "suggested_scalar": 0.0952,
+      "log_bad": 5.2575,
+      "log_good": 5.5373
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 187.0,
+      "good": 293.0,
+      "ratio": 1.5668,
+      "suggested_scalar": 0.1528,
+      "log_bad": 5.2311,
+      "log_good": 5.6802
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.2111,
+      "good": 2.8089,
+      "ratio": 1.2704,
+      "suggested_scalar": 0.0814,
+      "log_bad": 0.7935,
+      "log_good": 1.0328
+    },
+    "halstead.mean_effort": {
+      "bad": 53480.6845,
+      "good": 91713.9158,
+      "ratio": 1.7149,
+      "suggested_scalar": 0.1835,
+      "log_bad": 10.8871,
+      "log_good": 11.4264
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8616,
+      "good": 0.8679,
+      "ratio": 1.0073,
+      "suggested_scalar": 0.0025,
+      "log_bad": -0.149,
+      "log_good": -0.1417
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 60.0,
+      "good": 62.0,
+      "ratio": 1.0333,
+      "suggested_scalar": 0.0112,
+      "log_bad": 4.0943,
+      "log_good": 4.1271
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 206.0,
+      "good": 241.0,
+      "ratio": 1.1699,
+      "suggested_scalar": 0.0534,
+      "log_bad": 5.3279,
+      "log_good": 5.4848
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5,
+      "good": 0.4653,
+      "ratio": 0.9306,
+      "suggested_scalar": -0.0245,
+      "log_bad": -0.6931,
+      "log_good": -0.7651
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.9554,
+      "good": 6.8663,
+      "ratio": 0.9872,
+      "suggested_scalar": -0.0044,
+      "log_bad": 1.9395,
+      "log_good": 1.9266
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1452,
+      "good": 0.1642,
+      "ratio": 1.1309,
+      "suggested_scalar": 0.0418,
+      "log_bad": -1.9296,
+      "log_good": -1.8067
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.5797,
+      "good": 4.0461,
+      "ratio": 1.1303,
+      "suggested_scalar": 0.0417,
+      "log_bad": 1.2753,
+      "log_good": 1.3978
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 355.0,
+      "good": 490.0,
+      "ratio": 1.3803,
+      "suggested_scalar": 0.1097,
+      "log_bad": 5.8721,
+      "log_good": 6.1944
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 12.0,
+      "ratio": 4.0,
+      "suggested_scalar": 0.4717,
+      "log_bad": 1.0986,
+      "log_good": 2.4849
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 62.0,
+      "good": 79.0,
+      "ratio": 1.2742,
+      "suggested_scalar": 0.0824,
+      "log_bad": 4.1271,
+      "log_good": 4.3694
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2971.1491,
+      "good": 5095.2175,
+      "ratio": 1.7149,
+      "suggested_scalar": 0.1835,
+      "log_bad": 7.9967,
+      "log_good": 8.5361
+    },
+    "readability.mean_total_lines": {
+      "bad": 50.0,
+      "good": 53.0,
+      "ratio": 1.06,
+      "suggested_scalar": 0.0198,
+      "log_bad": 3.912,
+      "log_good": 3.9703
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 6.0,
+      "ratio": 0.375,
+      "suggested_scalar": -0.3337,
+      "log_bad": 2.7726,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2122.2494,
+      "good": 2544.1892,
+      "ratio": 1.1988,
+      "suggested_scalar": 0.0617,
+      "log_bad": 7.6602,
+      "log_good": 7.8416
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 590.0,
+      "good": 835.0,
+      "ratio": 1.4153,
+      "suggested_scalar": 0.1182,
+      "log_bad": 6.3801,
+      "log_good": 6.7274
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 29.54,
+      "good": 35.7358,
+      "ratio": 1.2097,
+      "suggested_scalar": 0.0648,
+      "log_bad": 3.3857,
+      "log_good": 3.5762
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1524,
+      "good": 1.1574,
+      "ratio": 1.0043,
+      "suggested_scalar": 0.0015,
+      "log_bad": 0.1418,
+      "log_good": 0.1462
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 16.0,
+      "good": 28.0,
+      "ratio": 1.75,
+      "suggested_scalar": 0.1904,
+      "log_bad": 2.7726,
+      "log_good": 3.3322
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7427,
+      "good": 0.7847,
+      "ratio": 1.0566,
+      "suggested_scalar": 0.0187,
+      "log_bad": -0.2975,
+      "log_good": -0.2425
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 5.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.3118,
+      "log_bad": 0.6931,
+      "log_good": 1.6094
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9421,
+      "good": 0.9705,
+      "ratio": 1.0301,
+      "suggested_scalar": 0.0101,
+      "log_bad": -0.0596,
+      "log_good": -0.0299
+    },
+    "halstead.mean_length": {
+      "bad": 332.0,
+      "good": 390.0,
+      "ratio": 1.1747,
+      "suggested_scalar": 0.0548,
+      "log_bad": 5.8051,
+      "log_good": 5.9661
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 25.5,
+      "good": 17.3333,
+      "ratio": 0.6797,
+      "suggested_scalar": -0.1314,
+      "log_bad": 3.2387,
+      "log_good": 2.8526
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4094,
+      "good": 7.0553,
+      "ratio": 1.1008,
+      "suggested_scalar": 0.0327,
+      "log_bad": 1.8578,
+      "log_good": 1.9538
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1105,
+      "good": 0.1167,
+      "ratio": 1.0561,
+      "suggested_scalar": 0.0186,
+      "log_bad": -2.2027,
+      "log_good": -2.1481
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.2,
+      "good": 36.0484,
+      "ratio": 1.4305,
+      "suggested_scalar": 0.1218,
+      "log_bad": 3.2268,
+      "log_good": 3.5849
+    },
+    "branching.mean_branch_count": {
+      "bad": 12.0,
+      "good": 7.0,
+      "ratio": 0.5833,
+      "suggested_scalar": -0.1834,
+      "log_bad": 2.4849,
+      "log_good": 1.9459
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 56.0,
+      "good": 94.0,
+      "ratio": 1.6786,
+      "suggested_scalar": 0.1762,
+      "log_bad": 4.0254,
+      "log_good": 4.5433
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6257,
+      "good": 0.6621,
+      "ratio": 1.0582,
+      "suggested_scalar": 0.0192,
+      "log_bad": -0.4689,
+      "log_good": -0.4123
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 53.0,
+      "good": 56.0,
+      "ratio": 1.0566,
+      "suggested_scalar": 0.0187,
+      "log_bad": 3.9703,
+      "log_good": 4.0254
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.class_name_is_noun": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0043,
+      "good": 0.0043,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.4491,
+      "log_good": -5.4491
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5714,
+      "good": 1.5714,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.452,
+      "log_good": 0.452
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.6923,
+      "good": 0.6923,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3677,
+      "log_good": -0.3677
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0043,
+      "good": 0.0043,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.4491,
+      "log_good": -5.4491
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5995,
+      "good": 4.5798,
+      "ratio": 0.9957,
+      "suggested_scalar": -0.032,
+      "log_bad": 1.5259,
+      "log_good": 1.5217
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 57.0,
+      "good": 63.0,
+      "ratio": 1.1053,
+      "suggested_scalar": 0.7462,
+      "log_bad": 4.0431,
+      "log_good": 4.1431
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5075,
+      "good": 0.597,
+      "ratio": 1.1764,
+      "suggested_scalar": 1.2109,
+      "log_bad": -0.6783,
+      "log_good": -0.5158
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5804,
+      "good": 0.6131,
+      "ratio": 1.0563,
+      "suggested_scalar": 0.4086,
+      "log_bad": -0.544,
+      "log_good": -0.4892
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.9487,
+      "good": 1.9487,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6672,
+      "log_good": 0.6672
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 230.0,
+      "good": 230.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.4381,
+      "log_good": 5.4381
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0023,
+      "good": 0.0022,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.3314,
+      "log_bad": -6.0748,
+      "log_good": -6.1193
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.02,
+      "good": 0.9906,
+      "ratio": 0.9712,
+      "suggested_scalar": -0.218,
+      "log_bad": 0.0198,
+      "log_good": -0.0094
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 67.0,
+      "good": 67.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2047,
+      "log_good": 4.2047
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 107.6457,
+      "good": 107.6457,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.6788,
+      "log_good": 4.6788
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5066,
+      "good": 0.4454,
+      "ratio": 0.8792,
+      "suggested_scalar": -0.9599,
+      "log_bad": -0.68,
+      "log_good": -0.8088
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.8213,
+      "good": 12.0561,
+      "ratio": 0.8723,
+      "suggested_scalar": -1.0187,
+      "log_bad": 2.6262,
+      "log_good": 2.4896
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 878.0,
+      "good": 894.0,
+      "ratio": 1.0182,
+      "suggested_scalar": 0.1346,
+      "log_bad": 6.7776,
+      "log_good": 6.7957
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0513,
+      "good": 0.0513,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.9701,
+      "log_good": -2.9701
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.641,
+      "good": 0.641,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.4447,
+      "log_good": -0.4447
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.8974,
+      "good": 5.8974,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7745,
+      "log_good": 1.7745
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.1769,
+      "good": 3.1769,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.1559,
+      "log_good": 1.1559
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 56.0,
+      "good": 56.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0254,
+      "log_good": 4.0254
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9317,
+      "good": 0.9343,
+      "ratio": 1.0028,
+      "suggested_scalar": 0.0208,
+      "log_bad": -0.0707,
+      "log_good": -0.068
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5695,
+      "good": 0.5649,
+      "ratio": 0.9919,
+      "suggested_scalar": -0.0605,
+      "log_bad": -0.563,
+      "log_good": -0.5711
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3421,
+      "good": 0.2632,
+      "ratio": 0.7694,
+      "suggested_scalar": -1.9547,
+      "log_bad": -1.0727,
+      "log_good": -1.3348
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3228,
+      "good": 2.2982,
+      "ratio": 0.9894,
+      "suggested_scalar": -0.0794,
+      "log_bad": 0.8428,
+      "log_good": 0.8321
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 228.0,
+      "good": 228.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.4293,
+      "log_good": 5.4293
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0522,
+      "good": 0.0522,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.9527,
+      "log_good": -2.9527
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.858,
+      "good": 5.858,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7678,
+      "log_good": 1.7678
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7164,
+      "good": 0.7164,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3335,
+      "log_good": -0.3335
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.1086,
+      "good": 5.194,
+      "ratio": 1.0167,
+      "suggested_scalar": 0.1236,
+      "log_bad": 1.6309,
+      "log_good": 1.6475
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7852,
+      "good": 0.7818,
+      "ratio": 0.9957,
+      "suggested_scalar": -0.0324,
+      "log_bad": -0.2418,
+      "log_good": -0.2462
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1333,
+      "good": 0.1333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.0152,
+      "log_good": -2.0152
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.7177,
+      "good": 3.4722,
+      "ratio": 0.934,
+      "suggested_scalar": -0.5093,
+      "log_bad": 1.3131,
+      "log_good": 1.2448
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 167.0,
+      "good": 181.0,
+      "ratio": 1.0838,
+      "suggested_scalar": 0.6002,
+      "log_bad": 5.118,
+      "log_good": 5.1985
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.4375,
+      "good": 0.4483,
+      "ratio": 1.0247,
+      "suggested_scalar": 0.1818,
+      "log_bad": -0.8267,
+      "log_good": -0.8023
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 60.0,
+      "good": 66.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.7106,
+      "log_bad": 4.0943,
+      "log_good": 4.1897
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 382.0,
+      "good": 398.0,
+      "ratio": 1.0419,
+      "suggested_scalar": 0.3059,
+      "log_bad": 5.9454,
+      "log_good": 5.9865
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 73.0,
+      "good": 73.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2905,
+      "log_good": 4.2905
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2522,
+      "good": 0.2522,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.3775,
+      "log_good": -1.3775
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 26.0,
+      "good": 24.0,
+      "ratio": 0.9231,
+      "suggested_scalar": -0.5967,
+      "log_bad": 3.2581,
+      "log_good": 3.1781
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 60.0,
+      "good": 66.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.7106,
+      "log_bad": 4.0943,
+      "log_good": 4.1897
+    },
+    "brevity.mean_sample_size": {
+      "bad": 60.0,
+      "good": 66.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.7106,
+      "log_bad": 4.0943,
+      "log_good": 4.1897
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 230.0,
+      "good": 230.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.4381,
+      "log_good": 5.4381
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 110.0,
+      "good": 110.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.7005,
+      "log_good": 4.7005
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 139.0,
+      "good": 151.0,
+      "ratio": 1.0863,
+      "suggested_scalar": 0.6173,
+      "log_bad": 4.9345,
+      "log_good": 5.0173
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.5605,
+      "good": 2.3541,
+      "ratio": 0.9194,
+      "suggested_scalar": -0.6266,
+      "log_bad": 0.9402,
+      "log_good": 0.8562
+    },
+    "halstead.mean_effort": {
+      "bad": 27943.1887,
+      "good": 24544.2057,
+      "ratio": 0.8784,
+      "suggested_scalar": -0.9669,
+      "log_bad": 10.2379,
+      "log_good": 10.1082
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8649,
+      "good": 0.8593,
+      "ratio": 0.9935,
+      "suggested_scalar": -0.0484,
+      "log_bad": -0.1451,
+      "log_good": -0.1516
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 36.0,
+      "good": 42.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 1.1492,
+      "log_bad": 3.5835,
+      "log_good": 3.7377
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 152.0,
+      "good": 152.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.0239,
+      "log_good": 5.0239
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5075,
+      "good": 0.597,
+      "ratio": 1.1764,
+      "suggested_scalar": 1.2109,
+      "log_bad": -0.6783,
+      "log_good": -0.5158
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.7015,
+      "good": 5.9403,
+      "ratio": 1.0419,
+      "suggested_scalar": 0.3059,
+      "log_bad": 1.7407,
+      "log_good": 1.7818
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1333,
+      "good": 0.1333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.0152,
+      "log_good": -2.0152
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.359,
+      "good": 2.359,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.8582,
+      "log_good": 0.8582
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 229.0,
+      "good": 229.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.4337,
+      "log_good": 5.4337
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 17.0,
+      "good": 13.0,
+      "ratio": 0.7647,
+      "suggested_scalar": -2.0,
+      "log_bad": 2.8332,
+      "log_good": 2.5649
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1552.3994,
+      "good": 1363.567,
+      "ratio": 0.8784,
+      "suggested_scalar": -0.9669,
+      "log_bad": 7.3476,
+      "log_good": 7.2179
+    },
+    "readability.mean_total_lines": {
+      "bad": 39.0,
+      "good": 39.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6636,
+      "log_good": 3.6636
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 1312.4003,
+      "good": 1344.888,
+      "ratio": 1.0248,
+      "suggested_scalar": 0.1823,
+      "log_bad": 7.1796,
+      "log_good": 7.2041
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 378.0,
+      "good": 389.0,
+      "ratio": 1.0291,
+      "suggested_scalar": 0.2139,
+      "log_bad": 5.9349,
+      "log_good": 5.9636
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 21.359,
+      "good": 21.7692,
+      "ratio": 1.0192,
+      "suggested_scalar": 0.1418,
+      "log_bad": 3.0615,
+      "log_good": 3.0805
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1017,
+      "good": 1.1017,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0969,
+      "log_good": 0.0969
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8982,
+      "good": 0.9282,
+      "ratio": 1.0334,
+      "suggested_scalar": 0.2449,
+      "log_bad": -0.1074,
+      "log_good": -0.0745
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9805,
+      "good": 0.9853,
+      "ratio": 1.0049,
+      "suggested_scalar": 0.0364,
+      "log_bad": -0.0197,
+      "log_good": -0.0148
+    },
+    "halstead.mean_length": {
+      "bad": 225.0,
+      "good": 225.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.4161,
+      "log_good": 5.4161
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.2857,
+      "good": 6.2857,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8383,
+      "log_good": 1.8383
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.9069,
+      "good": 6.0444,
+      "ratio": 1.0233,
+      "suggested_scalar": 0.1716,
+      "log_bad": 1.7761,
+      "log_good": 1.7991
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1253,
+      "good": 0.123,
+      "ratio": 0.9816,
+      "suggested_scalar": -0.1381,
+      "log_bad": -2.077,
+      "log_good": -2.0956
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 21.2917,
+      "good": 18.25,
+      "ratio": 0.8571,
+      "suggested_scalar": -1.1493,
+      "log_bad": 3.0583,
+      "log_good": 2.9042
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 34.0,
+      "good": 40.0,
+      "ratio": 1.1765,
+      "suggested_scalar": 1.2116,
+      "log_bad": 3.5264,
+      "log_good": 3.6889
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8129,
+      "good": 0.8411,
+      "ratio": 1.0347,
+      "suggested_scalar": 0.2542,
+      "log_bad": -0.2071,
+      "log_good": -0.173
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 39.0,
+      "good": 39.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6636,
+      "log_good": 3.6636
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 18.0,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.4031,
+      "log_bad": 2.9444,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "scope_and_assignment.scope_is_minimal": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 38.0,
+      "good": 41.0,
+      "ratio": 1.0789,
+      "suggested_scalar": 0.0447,
+      "log_bad": 3.6376,
+      "log_good": 3.7136
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 6.0,
+      "good": 3.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.4075,
+      "log_bad": 1.7918,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0206,
+      "good": 0.0201,
+      "ratio": 0.9757,
+      "suggested_scalar": -0.0144,
+      "log_bad": -3.8825,
+      "log_good": -3.907
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.8333,
+      "good": 2.375,
+      "ratio": 0.8382,
+      "suggested_scalar": -0.1037,
+      "log_bad": 1.0414,
+      "log_good": 0.865
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9667,
+      "good": 0.8148,
+      "ratio": 0.8429,
+      "suggested_scalar": -0.1005,
+      "log_bad": -0.0339,
+      "log_good": -0.2048
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0206,
+      "good": 0.0201,
+      "ratio": 0.9757,
+      "suggested_scalar": -0.0144,
+      "log_bad": -3.8825,
+      "log_good": -3.907
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.2141,
+      "good": 4.5735,
+      "ratio": 1.0853,
+      "suggested_scalar": 0.0481,
+      "log_bad": 1.4384,
+      "log_good": 1.5203
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 93.0,
+      "good": 86.0,
+      "ratio": 0.9247,
+      "suggested_scalar": -0.046,
+      "log_bad": 4.5326,
+      "log_good": 4.4543
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4067,
+      "good": 0.388,
+      "ratio": 0.954,
+      "suggested_scalar": -0.0277,
+      "log_bad": -0.8997,
+      "log_good": -0.9467
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 18.0,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.0336,
+      "log_bad": 2.8332,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5161,
+      "good": 0.5075,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0099,
+      "log_bad": -0.6615,
+      "log_good": -0.6783
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 9.1667,
+      "good": 4.3148,
+      "ratio": 0.4707,
+      "suggested_scalar": -0.443,
+      "log_bad": 2.2156,
+      "log_good": 1.4621
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 486.0,
+      "good": 498.0,
+      "ratio": 1.0247,
+      "suggested_scalar": 0.0143,
+      "log_bad": 6.1862,
+      "log_good": 6.2106
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0333,
+      "good": 1.0,
+      "ratio": 30.03,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.4022,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0994,
+      "good": 1.1126,
+      "ratio": 1.012,
+      "suggested_scalar": 0.007,
+      "log_bad": 0.0948,
+      "log_good": 0.1067
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 166.0,
+      "good": 164.0,
+      "ratio": 0.988,
+      "suggested_scalar": -0.0071,
+      "log_bad": 5.112,
+      "log_good": 5.0999
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 94.7543,
+      "good": 100.0441,
+      "ratio": 1.0558,
+      "suggested_scalar": 0.0319,
+      "log_bad": 4.5513,
+      "log_good": 4.6056
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6804,
+      "good": 0.6781,
+      "ratio": 0.9966,
+      "suggested_scalar": -0.002,
+      "log_bad": -0.3851,
+      "log_good": -0.3885
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.8662,
+      "good": 11.8769,
+      "ratio": 1.2038,
+      "suggested_scalar": 0.109,
+      "log_bad": 2.2891,
+      "log_good": 2.4746
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2390.0,
+      "good": 1979.0,
+      "ratio": 0.828,
+      "suggested_scalar": -0.1109,
+      "log_bad": 7.779,
+      "log_good": 7.5903
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1,
+      "good": 0.0926,
+      "ratio": 0.926,
+      "suggested_scalar": -0.0452,
+      "log_bad": -2.3026,
+      "log_good": -2.3795
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8,
+      "good": 0.7593,
+      "ratio": 0.9491,
+      "suggested_scalar": -0.0307,
+      "log_bad": -0.2231,
+      "log_good": -0.2754
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.3793,
+      "good": 9.2222,
+      "ratio": 1.1006,
+      "suggested_scalar": 0.0563,
+      "log_bad": 2.1258,
+      "log_good": 2.2216
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 15.0,
+      "good": 11.0,
+      "ratio": 0.7333,
+      "suggested_scalar": -0.1823,
+      "log_bad": 2.7081,
+      "log_good": 2.3979
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 36.7056,
+      "good": 5.0676,
+      "ratio": 0.1381,
+      "suggested_scalar": -1.164,
+      "log_bad": 3.6029,
+      "log_good": 1.6229
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 144.0,
+      "good": 146.0,
+      "ratio": 1.0139,
+      "suggested_scalar": 0.0081,
+      "log_bad": 4.9698,
+      "log_good": 4.9836
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9494,
+      "good": 0.9488,
+      "ratio": 0.9994,
+      "suggested_scalar": -0.0004,
+      "log_bad": -0.0519,
+      "log_good": -0.0526
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 25.0,
+      "ratio": 1.1364,
+      "suggested_scalar": 0.0751,
+      "log_bad": 3.091,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6971,
+      "good": 0.6549,
+      "ratio": 0.9395,
+      "suggested_scalar": -0.0367,
+      "log_bad": -0.3608,
+      "log_good": -0.4233
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5207,
+      "good": 0.4879,
+      "ratio": 0.937,
+      "suggested_scalar": -0.0382,
+      "log_bad": -0.6526,
+      "log_good": -0.7176
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.3011,
+      "good": 2.8975,
+      "ratio": 0.8777,
+      "suggested_scalar": -0.0767,
+      "log_bad": 1.1943,
+      "log_good": 1.0638
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 484.0,
+      "good": 496.0,
+      "ratio": 1.0248,
+      "suggested_scalar": 0.0144,
+      "log_bad": 6.1821,
+      "log_good": 6.2066
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 60.0,
+      "good": 15.0,
+      "ratio": 0.25,
+      "suggested_scalar": -0.8149,
+      "log_bad": 4.0943,
+      "log_good": 2.7081
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0123,
+      "good": 0.01,
+      "ratio": 0.813,
+      "suggested_scalar": -0.1217,
+      "log_bad": -4.3982,
+      "log_good": -4.6052
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7814,
+      "good": 5.7814,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7546,
+      "log_good": 1.7546
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6839,
+      "good": 0.605,
+      "ratio": 0.8846,
+      "suggested_scalar": -0.0721,
+      "log_bad": -0.3799,
+      "log_good": -0.5025
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4654,
+      "good": 5.5003,
+      "ratio": 1.0064,
+      "suggested_scalar": 0.0037,
+      "log_bad": 1.6984,
+      "log_good": 1.7048
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7289,
+      "good": 0.7911,
+      "ratio": 1.0853,
+      "suggested_scalar": 0.0481,
+      "log_bad": -0.3162,
+      "log_good": -0.2343
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1549,
+      "good": 0.129,
+      "ratio": 0.8328,
+      "suggested_scalar": -0.1076,
+      "log_bad": -1.865,
+      "log_good": -2.0479
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.141,
+      "good": 3.4463,
+      "ratio": 1.0972,
+      "suggested_scalar": 0.0545,
+      "log_bad": 1.1445,
+      "log_good": 1.2373
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 311.0,
+      "good": 334.0,
+      "ratio": 1.074,
+      "suggested_scalar": 0.0419,
+      "log_bad": 5.7398,
+      "log_good": 5.8111
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 6.0,
+      "good": 8.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1691,
+      "log_bad": 1.7918,
+      "log_good": 2.0794
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9613,
+      "good": 0.9575,
+      "ratio": 0.996,
+      "suggested_scalar": -0.0023,
+      "log_bad": -0.0395,
+      "log_good": -0.0434
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 99.0,
+      "good": 93.0,
+      "ratio": 0.9394,
+      "suggested_scalar": -0.0368,
+      "log_bad": 4.5951,
+      "log_good": 4.5326
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1168.0,
+      "good": 1080.0,
+      "ratio": 0.9247,
+      "suggested_scalar": -0.046,
+      "log_bad": 7.063,
+      "log_good": 6.9847
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 167.0,
+      "good": 157.0,
+      "ratio": 0.9401,
+      "suggested_scalar": -0.0363,
+      "log_bad": 5.118,
+      "log_good": 5.0562
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0267,
+      "good": 0.0161,
+      "ratio": 0.603,
+      "suggested_scalar": -0.2974,
+      "log_bad": -3.6231,
+      "log_good": -4.1289
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2922,
+      "good": 0.2972,
+      "ratio": 1.0171,
+      "suggested_scalar": 0.01,
+      "log_bad": -1.2303,
+      "log_good": -1.2133
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 84.0,
+      "good": 90.0,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.0406,
+      "log_bad": 4.4308,
+      "log_good": 4.4998
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 8.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1691,
+      "log_bad": 1.7918,
+      "log_good": 2.0794
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 99.0,
+      "good": 93.0,
+      "ratio": 0.9394,
+      "suggested_scalar": -0.0368,
+      "log_bad": 4.5951,
+      "log_good": 4.5326
+    },
+    "brevity.mean_sample_size": {
+      "bad": 99.0,
+      "good": 93.0,
+      "ratio": 0.9394,
+      "suggested_scalar": -0.0368,
+      "log_bad": 4.5951,
+      "log_good": 4.5326
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 486.0,
+      "good": 498.0,
+      "ratio": 1.0247,
+      "suggested_scalar": 0.0143,
+      "log_bad": 6.1862,
+      "log_good": 6.2106
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 272.0,
+      "good": 287.0,
+      "ratio": 1.0551,
+      "suggested_scalar": 0.0316,
+      "log_bad": 5.6058,
+      "log_good": 5.6595
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 239.0,
+      "good": 250.0,
+      "ratio": 1.046,
+      "suggested_scalar": 0.0265,
+      "log_bad": 5.4765,
+      "log_good": 5.5215
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 4.4829,
+      "good": 4.2302,
+      "ratio": 0.9436,
+      "suggested_scalar": -0.0341,
+      "log_bad": 1.5003,
+      "log_good": 1.4422
+    },
+    "halstead.mean_effort": {
+      "bad": 74612.4467,
+      "good": 92415.7447,
+      "ratio": 1.2386,
+      "suggested_scalar": 0.1258,
+      "log_bad": 11.2201,
+      "log_good": 11.4341
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8244,
+      "good": 0.8411,
+      "ratio": 1.0203,
+      "suggested_scalar": 0.0118,
+      "log_bad": -0.1931,
+      "log_good": -0.173
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 71.0,
+      "good": 61.0,
+      "ratio": 0.8592,
+      "suggested_scalar": -0.0892,
+      "log_bad": 4.2627,
+      "log_good": 4.1109
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 274.0,
+      "good": 290.0,
+      "ratio": 1.0584,
+      "suggested_scalar": 0.0334,
+      "log_bad": 5.6131,
+      "log_good": 5.6699
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4217,
+      "good": 0.378,
+      "ratio": 0.8964,
+      "suggested_scalar": -0.0643,
+      "log_bad": -0.8635,
+      "log_good": -0.9729
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.0361,
+      "good": 6.5854,
+      "ratio": 0.9359,
+      "suggested_scalar": -0.0389,
+      "log_bad": 1.9511,
+      "log_good": 1.8849
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1549,
+      "good": 0.129,
+      "ratio": 0.8328,
+      "suggested_scalar": -0.1076,
+      "log_bad": -1.865,
+      "log_good": -2.0479
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.3517,
+      "good": 3.6889,
+      "ratio": 1.1006,
+      "suggested_scalar": 0.0564,
+      "log_bad": 1.2095,
+      "log_good": 1.3053
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 485.0,
+      "good": 497.0,
+      "ratio": 1.0247,
+      "suggested_scalar": 0.0144,
+      "log_bad": 6.1841,
+      "log_good": 6.2086
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 7.0,
+      "ratio": 3.5,
+      "suggested_scalar": 0.7364,
+      "log_bad": 0.6931,
+      "log_good": 1.9459
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 79.0,
+      "good": 80.0,
+      "ratio": 1.0127,
+      "suggested_scalar": 0.0074,
+      "log_bad": 4.3694,
+      "log_good": 4.382
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4145.1359,
+      "good": 5134.208,
+      "ratio": 1.2386,
+      "suggested_scalar": 0.1258,
+      "log_bad": 8.3297,
+      "log_good": 8.5437
+    },
+    "readability.mean_total_lines": {
+      "bad": 58.0,
+      "good": 54.0,
+      "ratio": 0.931,
+      "suggested_scalar": -0.042,
+      "log_bad": 4.0604,
+      "log_good": 3.989
+    },
+    "indentation.mean_max_depth": {
+      "bad": 20.0,
+      "good": 9.0,
+      "ratio": 0.45,
+      "suggested_scalar": -0.4694,
+      "log_bad": 2.9957,
+      "log_good": 2.1972
+    },
+    "halstead.mean_volume": {
+      "bad": 2883.769,
+      "good": 2872.5403,
+      "ratio": 0.9961,
+      "suggested_scalar": -0.0023,
+      "log_bad": 7.9669,
+      "log_good": 7.963
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 724.0,
+      "good": 683.0,
+      "ratio": 0.9434,
+      "suggested_scalar": -0.0343,
+      "log_bad": 6.5848,
+      "log_good": 6.5265
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 37.5517,
+      "good": 35.463,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.0336,
+      "log_bad": 3.6257,
+      "log_good": 3.5685
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2243,
+      "good": 1.1517,
+      "ratio": 0.9407,
+      "suggested_scalar": -0.0359,
+      "log_bad": 0.2024,
+      "log_good": 0.1412
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 12.0,
+      "good": 21.0,
+      "ratio": 1.75,
+      "suggested_scalar": 0.329,
+      "log_bad": 2.4849,
+      "log_good": 3.0445
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.4075,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.746,
+      "good": 0.7605,
+      "ratio": 1.0194,
+      "suggested_scalar": 0.0113,
+      "log_bad": -0.293,
+      "log_good": -0.2738
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9363,
+      "good": 0.9528,
+      "ratio": 1.0176,
+      "suggested_scalar": 0.0103,
+      "log_bad": -0.0658,
+      "log_good": -0.0484
+    },
+    "halstead.mean_length": {
+      "bad": 441.0,
+      "good": 447.0,
+      "ratio": 1.0136,
+      "suggested_scalar": 0.0079,
+      "log_bad": 6.089,
+      "log_good": 6.1026
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.0,
+      "good": 7.125,
+      "ratio": 0.6477,
+      "suggested_scalar": -0.2553,
+      "log_bad": 2.3979,
+      "log_good": 1.9636
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6294,
+      "good": 6.5392,
+      "ratio": 0.9864,
+      "suggested_scalar": -0.0081,
+      "log_bad": 1.8915,
+      "log_good": 1.8778
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1139,
+      "good": 0.1452,
+      "ratio": 1.2748,
+      "suggested_scalar": 0.1427,
+      "log_bad": -2.1724,
+      "log_good": -1.9296
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.8732,
+      "good": 32.1721,
+      "ratio": 1.2435,
+      "suggested_scalar": 0.1281,
+      "log_bad": 3.2532,
+      "log_good": 3.4711
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1072,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 70.0,
+      "good": 62.0,
+      "ratio": 0.8857,
+      "suggested_scalar": -0.0713,
+      "log_bad": 4.2485,
+      "log_good": 4.1271
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6485,
+      "good": 0.64,
+      "ratio": 0.9869,
+      "suggested_scalar": -0.0078,
+      "log_bad": -0.4331,
+      "log_good": -0.4463
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 60.0,
+      "good": 54.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0619,
+      "log_bad": 4.0943,
+      "log_good": 3.989
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.no_misused_promises": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 34.0,
+      "good": 31.0,
+      "ratio": 0.9118,
+      "suggested_scalar": -0.0249,
+      "log_bad": 3.5264,
+      "log_good": 3.434
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0045,
+      "good": 0.007,
+      "ratio": 1.5556,
+      "suggested_scalar": 0.1191,
+      "log_bad": -5.4037,
+      "log_good": -4.9618
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8462,
+      "good": 0.8696,
+      "ratio": 1.0277,
+      "suggested_scalar": 0.0074,
+      "log_bad": -0.167,
+      "log_good": -0.1397
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0045,
+      "good": 0.007,
+      "ratio": 1.5556,
+      "suggested_scalar": 0.1191,
+      "log_bad": -5.4037,
+      "log_good": -4.9618
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8751,
+      "good": 4.8769,
+      "ratio": 1.0004,
+      "suggested_scalar": 0.0001,
+      "log_bad": 1.5841,
+      "log_good": 1.5845
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 97.0,
+      "good": 84.0,
+      "ratio": 0.866,
+      "suggested_scalar": -0.0388,
+      "log_bad": 4.5747,
+      "log_good": 4.4308
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5054,
+      "good": 0.4324,
+      "ratio": 0.8556,
+      "suggested_scalar": -0.0421,
+      "log_bad": -0.6824,
+      "log_good": -0.8384
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6117,
+      "good": 0.5762,
+      "ratio": 0.942,
+      "suggested_scalar": -0.0161,
+      "log_bad": -0.4915,
+      "log_good": -0.5513
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.8462,
+      "good": 1.8261,
+      "ratio": 0.9891,
+      "suggested_scalar": -0.003,
+      "log_bad": 0.6131,
+      "log_good": 0.6022
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 447.0,
+      "good": 426.0,
+      "ratio": 0.953,
+      "suggested_scalar": -0.013,
+      "log_bad": 6.1026,
+      "log_good": 6.0544
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0492,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0016,
+      "good": 0.0018,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0318,
+      "log_bad": -6.4378,
+      "log_good": -6.32
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0769,
+      "good": 1.0,
+      "ratio": 13.0039,
+      "suggested_scalar": 0.6916,
+      "log_bad": -2.5652,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 0.0006,
+      "ratio": 0.0006,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -7.4186
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0513,
+      "good": 1.0424,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0023,
+      "log_bad": 0.05,
+      "log_good": 0.0415
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 123.0,
+      "good": 116.0,
+      "ratio": 0.9431,
+      "suggested_scalar": -0.0158,
+      "log_bad": 4.8122,
+      "log_good": 4.7536
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 91.0909,
+      "good": 88.3952,
+      "ratio": 0.9704,
+      "suggested_scalar": -0.0081,
+      "log_bad": 4.5119,
+      "log_good": 4.4818
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6009,
+      "good": 0.6071,
+      "ratio": 1.0103,
+      "suggested_scalar": 0.0028,
+      "log_bad": -0.5093,
+      "log_good": -0.4991
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 21.9561,
+      "good": 28.5113,
+      "ratio": 1.2986,
+      "suggested_scalar": 0.0704,
+      "log_bad": 3.089,
+      "log_good": 3.3503
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1894.0,
+      "good": 1704.0,
+      "ratio": 0.8997,
+      "suggested_scalar": -0.0285,
+      "log_bad": 7.5464,
+      "log_good": 7.4407
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1538,
+      "good": 0.1087,
+      "ratio": 0.7068,
+      "suggested_scalar": -0.0936,
+      "log_bad": -1.8721,
+      "log_good": -2.2192
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7885,
+      "good": 0.8261,
+      "ratio": 1.0477,
+      "suggested_scalar": 0.0126,
+      "log_bad": -0.2376,
+      "log_good": -0.191
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.5962,
+      "good": 9.2609,
+      "ratio": 1.0773,
+      "suggested_scalar": 0.0201,
+      "log_bad": 2.1513,
+      "log_good": 2.2258
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.284,
+      "good": 2.9263,
+      "ratio": 1.2812,
+      "suggested_scalar": 0.0668,
+      "log_bad": 0.8259,
+      "log_good": 1.0737
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 69.0,
+      "good": 67.0,
+      "ratio": 0.971,
+      "suggested_scalar": -0.0079,
+      "log_bad": 4.2341,
+      "log_good": 4.2047
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.918,
+      "good": 0.939,
+      "ratio": 1.0229,
+      "suggested_scalar": 0.0061,
+      "log_bad": -0.0856,
+      "log_good": -0.0629
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 32.0,
+      "good": 29.0,
+      "ratio": 0.9063,
+      "suggested_scalar": -0.0265,
+      "log_bad": 3.4657,
+      "log_good": 3.3673
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6199,
+      "good": 0.6262,
+      "ratio": 1.0102,
+      "suggested_scalar": 0.0027,
+      "log_bad": -0.4782,
+      "log_good": -0.4681
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4292,
+      "good": 0.4057,
+      "ratio": 0.9452,
+      "suggested_scalar": -0.0152,
+      "log_bad": -0.8458,
+      "log_good": -0.9021
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6306,
+      "good": 2.675,
+      "ratio": 1.0169,
+      "suggested_scalar": 0.0045,
+      "log_bad": 0.9672,
+      "log_good": 0.9839
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 445.0,
+      "good": 424.0,
+      "ratio": 0.9528,
+      "suggested_scalar": -0.013,
+      "log_bad": 6.0981,
+      "log_good": 6.0497
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 14.0,
+      "good": 12.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0416,
+      "log_bad": 2.6391,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0358,
+      "good": 0.0235,
+      "ratio": 0.6564,
+      "suggested_scalar": -0.1135,
+      "log_bad": -3.3298,
+      "log_good": -3.7508
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.8329,
+      "ratio": 0.9875,
+      "suggested_scalar": -0.0034,
+      "log_bad": 1.7761,
+      "log_good": 1.7635
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 20.0,
+      "good": 18.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0284,
+      "log_bad": 2.9957,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4067,
+      "good": 1.3833,
+      "ratio": 0.9834,
+      "suggested_scalar": -0.0045,
+      "log_bad": 0.3412,
+      "log_good": 0.3245
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7706,
+      "good": 5.5836,
+      "ratio": 0.9676,
+      "suggested_scalar": -0.0089,
+      "log_bad": 1.7528,
+      "log_good": 1.7198
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8253,
+      "good": 0.8361,
+      "ratio": 1.0131,
+      "suggested_scalar": 0.0035,
+      "log_bad": -0.192,
+      "log_good": -0.179
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1875,
+      "good": 0.1636,
+      "ratio": 0.8725,
+      "suggested_scalar": -0.0368,
+      "log_bad": -1.674,
+      "log_good": -1.8103
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.6857,
+      "good": 5.3396,
+      "ratio": 1.1396,
+      "suggested_scalar": 0.0352,
+      "log_bad": 1.5445,
+      "log_good": 1.6752
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 324.0,
+      "good": 314.0,
+      "ratio": 0.9691,
+      "suggested_scalar": -0.0085,
+      "log_bad": 5.7807,
+      "log_good": 5.7494
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 29.0,
+      "good": 31.0,
+      "ratio": 1.069,
+      "suggested_scalar": 0.018,
+      "log_bad": 3.3673,
+      "log_good": 3.434
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.935,
+      "good": 0.8502,
+      "ratio": 0.9093,
+      "suggested_scalar": -0.0256,
+      "log_bad": -0.0672,
+      "log_good": -0.1623
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 100.0,
+      "good": 87.0,
+      "ratio": 0.87,
+      "suggested_scalar": -0.0375,
+      "log_bad": 4.6052,
+      "log_good": 4.4659
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 950.0,
+      "good": 856.0,
+      "ratio": 0.9011,
+      "suggested_scalar": -0.0281,
+      "log_bad": 6.8565,
+      "log_good": 6.7523
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 151.0,
+      "good": 140.0,
+      "ratio": 0.9272,
+      "suggested_scalar": -0.0204,
+      "log_bad": 5.0173,
+      "log_good": 4.9416
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0067,
+      "good": 0.0141,
+      "ratio": 2.1045,
+      "suggested_scalar": 0.2006,
+      "log_bad": -5.0056,
+      "log_good": -4.2616
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2438,
+      "good": 0.2559,
+      "ratio": 1.0496,
+      "suggested_scalar": 0.0131,
+      "log_bad": -1.4114,
+      "log_good": -1.363
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 78.0,
+      "good": 73.0,
+      "ratio": 0.9359,
+      "suggested_scalar": -0.0179,
+      "log_bad": 4.3567,
+      "log_good": 4.2905
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 100.0,
+      "good": 87.0,
+      "ratio": 0.87,
+      "suggested_scalar": -0.0375,
+      "log_bad": 4.6052,
+      "log_good": 4.4659
+    },
+    "brevity.mean_sample_size": {
+      "bad": 100.0,
+      "good": 87.0,
+      "ratio": 0.87,
+      "suggested_scalar": -0.0375,
+      "log_bad": 4.6052,
+      "log_good": 4.4659
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 447.0,
+      "good": 426.0,
+      "ratio": 0.953,
+      "suggested_scalar": -0.013,
+      "log_bad": 6.1026,
+      "log_good": 6.0544
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 247.0,
+      "good": 246.0,
+      "ratio": 0.996,
+      "suggested_scalar": -0.0011,
+      "log_bad": 5.5094,
+      "log_good": 5.5053
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 256.0,
+      "good": 240.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0174,
+      "log_bad": 5.5452,
+      "log_good": 5.4806
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.4845,
+      "good": 2.8468,
+      "ratio": 1.1458,
+      "suggested_scalar": 0.0367,
+      "log_bad": 0.9101,
+      "log_good": 1.0462
+    },
+    "halstead.mean_effort": {
+      "bad": 104258.3155,
+      "good": 94137.9153,
+      "ratio": 0.9029,
+      "suggested_scalar": -0.0275,
+      "log_bad": 11.5546,
+      "log_good": 11.4525
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8686,
+      "good": 0.8666,
+      "ratio": 0.9977,
+      "suggested_scalar": -0.0006,
+      "log_bad": -0.1409,
+      "log_good": -0.1432
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 65.0,
+      "good": 55.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.045,
+      "log_bad": 4.1744,
+      "log_good": 4.0073
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 274.0,
+      "good": 259.0,
+      "ratio": 0.9453,
+      "suggested_scalar": -0.0152,
+      "log_bad": 5.6131,
+      "log_good": 5.5568
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4472,
+      "good": 0.3879,
+      "ratio": 0.8674,
+      "suggested_scalar": -0.0384,
+      "log_bad": -0.8047,
+      "log_good": -0.947
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.7236,
+      "good": 7.3793,
+      "ratio": 0.9554,
+      "suggested_scalar": -0.0123,
+      "log_bad": 2.0443,
+      "log_good": 1.9987
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1875,
+      "good": 0.1636,
+      "ratio": 0.8725,
+      "suggested_scalar": -0.0368,
+      "log_bad": -1.674,
+      "log_good": -1.8103
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.0385,
+      "good": 6.8155,
+      "ratio": 1.1287,
+      "suggested_scalar": 0.0326,
+      "log_bad": 1.7982,
+      "log_good": 1.9192
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 446.0,
+      "good": 425.0,
+      "ratio": 0.9529,
+      "suggested_scalar": -0.013,
+      "log_bad": 6.1003,
+      "log_good": 6.0521
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 70.0,
+      "good": 62.0,
+      "ratio": 0.8857,
+      "suggested_scalar": -0.0327,
+      "log_bad": 4.2485,
+      "log_good": 4.1271
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5792.1286,
+      "good": 5229.8842,
+      "ratio": 0.9029,
+      "suggested_scalar": -0.0275,
+      "log_bad": 8.6643,
+      "log_good": 8.5621
+    },
+    "readability.mean_total_lines": {
+      "bad": 52.0,
+      "good": 46.0,
+      "ratio": 0.8846,
+      "suggested_scalar": -0.0331,
+      "log_bad": 3.9512,
+      "log_good": 3.8286
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2804.963,
+      "good": 2550.5347,
+      "ratio": 0.9093,
+      "suggested_scalar": -0.0256,
+      "log_bad": 7.9391,
+      "log_good": 7.8441
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 720.0,
+      "good": 637.0,
+      "ratio": 0.8847,
+      "suggested_scalar": -0.033,
+      "log_bad": 6.5793,
+      "log_good": 6.4568
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.1538,
+      "good": 35.8478,
+      "ratio": 1.0197,
+      "suggested_scalar": 0.0053,
+      "log_bad": 3.5597,
+      "log_good": 3.5793
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.265,
+      "good": 1.2889,
+      "ratio": 1.0189,
+      "suggested_scalar": 0.005,
+      "log_bad": 0.2351,
+      "log_good": 0.2538
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0492,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 12.0,
+      "good": 16.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0776,
+      "log_bad": 2.4849,
+      "log_good": 2.7726
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 1.0,
+      "ratio": 0.25,
+      "suggested_scalar": -0.3737,
+      "log_bad": 1.3863,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.784,
+      "good": 0.8025,
+      "ratio": 1.0236,
+      "suggested_scalar": 0.0063,
+      "log_bad": -0.2433,
+      "log_good": -0.22
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9877,
+      "good": 0.9814,
+      "ratio": 0.9936,
+      "suggested_scalar": -0.0017,
+      "log_bad": -0.0124,
+      "log_good": -0.0188
+    },
+    "halstead.mean_length": {
+      "bad": 425.0,
+      "good": 399.0,
+      "ratio": 0.9388,
+      "suggested_scalar": -0.017,
+      "log_bad": 6.0521,
+      "log_good": 5.989
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.6667,
+      "good": 8.1667,
+      "ratio": 0.8448,
+      "suggested_scalar": -0.0455,
+      "log_bad": 2.2687,
+      "log_good": 2.1001
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6439,
+      "good": 6.4429,
+      "ratio": 0.9697,
+      "suggested_scalar": -0.0083,
+      "log_bad": 1.8937,
+      "log_good": 1.863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1305,
+      "good": 0.1444,
+      "ratio": 1.1065,
+      "suggested_scalar": 0.0273,
+      "log_bad": -2.0364,
+      "log_good": -1.9352
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 37.1692,
+      "good": 36.9091,
+      "ratio": 0.993,
+      "suggested_scalar": -0.0019,
+      "log_bad": 3.6155,
+      "log_good": 3.6085
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 5.0,
+      "ratio": 0.625,
+      "suggested_scalar": -0.1267,
+      "log_bad": 2.0794,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 55.0,
+      "good": 45.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.0541,
+      "log_bad": 4.0073,
+      "log_good": 3.8067
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6953,
+      "good": 0.6958,
+      "ratio": 1.0007,
+      "suggested_scalar": 0.0002,
+      "log_bad": -0.3634,
+      "log_good": -0.3627
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 52.0,
+      "good": 46.0,
+      "ratio": 0.8846,
+      "suggested_scalar": -0.0331,
+      "log_bad": 3.9512,
+      "log_good": 3.8286
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 26.0,
+      "good": 26.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2581,
+      "log_good": 3.2581
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.returns_typed_error": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 39.0,
+      "good": 80.0,
+      "ratio": 2.0513,
+      "suggested_scalar": 1.2007,
+      "log_bad": 3.6636,
+      "log_good": 4.382
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0081,
+      "good": 0.0042,
+      "ratio": 0.5185,
+      "suggested_scalar": -1.0976,
+      "log_bad": -4.8159,
+      "log_good": -5.4727
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1053,
+      "good": 1.1111,
+      "ratio": 1.0052,
+      "suggested_scalar": 0.0087,
+      "log_bad": 0.1001,
+      "log_good": 0.1054
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7073,
+      "good": 0.8161,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.2391,
+      "log_bad": -0.3463,
+      "log_good": -0.2032
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0081,
+      "good": 0.0042,
+      "ratio": 0.5185,
+      "suggested_scalar": -1.0976,
+      "log_bad": -4.8159,
+      "log_good": -5.4727
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.0795,
+      "good": 4.4328,
+      "ratio": 1.0866,
+      "suggested_scalar": 0.1388,
+      "log_bad": 1.406,
+      "log_good": 1.489
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 62.0,
+      "good": 81.0,
+      "ratio": 1.3065,
+      "suggested_scalar": 0.4467,
+      "log_bad": 4.1271,
+      "log_good": 4.3944
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4184,
+      "good": 0.3166,
+      "ratio": 0.7567,
+      "suggested_scalar": -0.4659,
+      "log_bad": -0.8713,
+      "log_good": -1.1501
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 13.0,
+      "good": 16.0,
+      "ratio": 1.2308,
+      "suggested_scalar": 0.347,
+      "log_bad": 2.5649,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.54,
+      "good": 0.4304,
+      "ratio": 0.797,
+      "suggested_scalar": -0.3791,
+      "log_bad": -0.6162,
+      "log_good": -0.843
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.2195,
+      "good": 4.1034,
+      "ratio": 0.9725,
+      "suggested_scalar": -0.0466,
+      "log_bad": 1.4397,
+      "log_good": 1.4118
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 369.0,
+      "good": 710.0,
+      "ratio": 1.9241,
+      "suggested_scalar": 1.0937,
+      "log_bad": 5.9108,
+      "log_good": 6.5653
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 1.836,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0036,
+      "good": 0.0019,
+      "ratio": 0.5278,
+      "suggested_scalar": -1.068,
+      "log_bad": -5.6268,
+      "log_good": -6.2659
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1423,
+      "good": 1.2648,
+      "ratio": 1.1072,
+      "suggested_scalar": 0.1702,
+      "log_bad": 0.133,
+      "log_good": 0.2349
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 98.0,
+      "good": 191.0,
+      "ratio": 1.949,
+      "suggested_scalar": 1.1152,
+      "log_bad": 4.585,
+      "log_good": 5.2523
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 109.2075,
+      "good": 96.4992,
+      "ratio": 0.8836,
+      "suggested_scalar": -0.2067,
+      "log_bad": 4.6932,
+      "log_good": 4.5695
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7418,
+      "good": 0.842,
+      "ratio": 1.1351,
+      "suggested_scalar": 0.2117,
+      "log_bad": -0.2987,
+      "log_good": -0.172
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.5214,
+      "good": 13.5117,
+      "ratio": 1.5856,
+      "suggested_scalar": 0.7704,
+      "log_bad": 2.1426,
+      "log_good": 2.6036
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1679.0,
+      "good": 2570.0,
+      "ratio": 1.5307,
+      "suggested_scalar": 0.7114,
+      "log_bad": 7.426,
+      "log_good": 7.8517
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2073,
+      "good": 0.1724,
+      "ratio": 0.8316,
+      "suggested_scalar": -0.3081,
+      "log_bad": -1.5736,
+      "log_good": -1.7579
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6585,
+      "good": 0.7586,
+      "ratio": 1.152,
+      "suggested_scalar": 0.2365,
+      "log_bad": -0.4178,
+      "log_good": -0.2763
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 4.5,
+      "good": 8.1609,
+      "ratio": 1.8135,
+      "suggested_scalar": 0.9948,
+      "log_bad": 1.5041,
+      "log_good": 2.0994
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 13.0,
+      "good": 10.0,
+      "ratio": 0.7692,
+      "suggested_scalar": -0.4385,
+      "log_bad": 2.5649,
+      "log_good": 2.3026
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.8543,
+      "good": 6.0698,
+      "ratio": 1.0368,
+      "suggested_scalar": 0.0604,
+      "log_bad": 1.7672,
+      "log_good": 1.8033
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 83.0,
+      "good": 177.0,
+      "ratio": 2.1325,
+      "suggested_scalar": 1.2656,
+      "log_bad": 4.4188,
+      "log_good": 5.1761
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.939,
+      "good": 0.9624,
+      "ratio": 1.0249,
+      "suggested_scalar": 0.0411,
+      "log_bad": -0.0629,
+      "log_good": -0.0383
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 27.0,
+      "ratio": 1.2273,
+      "suggested_scalar": 0.3422,
+      "log_bad": 3.091,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.7153,
+      "good": 0.7389,
+      "ratio": 1.033,
+      "suggested_scalar": 0.0542,
+      "log_bad": -0.3351,
+      "log_good": -0.3026
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5395,
+      "good": 0.6794,
+      "ratio": 1.2593,
+      "suggested_scalar": 0.3853,
+      "log_bad": -0.6171,
+      "log_good": -0.3865
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.5126,
+      "good": 3.8301,
+      "ratio": 1.0904,
+      "suggested_scalar": 0.1446,
+      "log_bad": 1.2564,
+      "log_good": 1.3429
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 367.0,
+      "good": 708.0,
+      "ratio": 1.9292,
+      "suggested_scalar": 1.0981,
+      "log_bad": 5.9054,
+      "log_good": 6.5624
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 13.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.1338,
+      "log_bad": 2.4849,
+      "log_good": 2.5649
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0325,
+      "good": 0.0141,
+      "ratio": 0.4338,
+      "suggested_scalar": -1.3955,
+      "log_bad": -3.4265,
+      "log_good": -4.2616
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.3576,
+      "good": 5.585,
+      "ratio": 1.0424,
+      "suggested_scalar": 0.0695,
+      "log_bad": 1.6785,
+      "log_good": 1.7201
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 1.1584,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7042,
+      "good": 0.4414,
+      "ratio": 0.6268,
+      "suggested_scalar": -0.7806,
+      "log_bad": -0.3507,
+      "log_good": -0.8178
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.1602,
+      "good": 5.1003,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0195,
+      "log_bad": 1.641,
+      "log_good": 1.6293
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7615,
+      "good": 0.7937,
+      "ratio": 1.0423,
+      "suggested_scalar": 0.0692,
+      "log_bad": -0.2725,
+      "log_good": -0.231
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1087,
+      "good": 0.0938,
+      "ratio": 0.8629,
+      "suggested_scalar": -0.2464,
+      "log_bad": -2.2192,
+      "log_good": -2.3666
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.9192,
+      "good": 3.6758,
+      "ratio": 1.2592,
+      "suggested_scalar": 0.3851,
+      "log_bad": 1.0713,
+      "log_good": 1.3018
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 228.0,
+      "good": 323.0,
+      "ratio": 1.4167,
+      "suggested_scalar": 0.5821,
+      "log_bad": 5.4293,
+      "log_good": 5.7777
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6649,
+      "good": 1.418,
+      "ratio": 2.1327,
+      "suggested_scalar": 1.2657,
+      "log_bad": -0.4081,
+      "log_good": 0.3492
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 71.0,
+      "good": 89.0,
+      "ratio": 1.2535,
+      "suggested_scalar": 0.3776,
+      "log_bad": 4.2627,
+      "log_good": 4.4886
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 614.0,
+      "good": 1.2e3,
+      "ratio": 1.9544,
+      "suggested_scalar": 1.1198,
+      "log_bad": 6.42,
+      "log_good": 7.0901
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 116.0,
+      "good": 198.0,
+      "ratio": 1.7069,
+      "suggested_scalar": 0.8935,
+      "log_bad": 4.7536,
+      "log_good": 5.2883
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0461,
+      "good": 0.0211,
+      "ratio": 0.4577,
+      "suggested_scalar": -1.3061,
+      "log_bad": -3.0769,
+      "log_good": -3.8585
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2304,
+      "good": 0.2493,
+      "ratio": 1.082,
+      "suggested_scalar": 0.1318,
+      "log_bad": -1.4679,
+      "log_good": -1.3891
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 64.0,
+      "good": 103.0,
+      "ratio": 1.6094,
+      "suggested_scalar": 0.7952,
+      "log_bad": 4.1589,
+      "log_good": 4.6347
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 19.0,
+      "good": 18.0,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.0904,
+      "log_bad": 2.9444,
+      "log_good": 2.8904
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 71.0,
+      "good": 89.0,
+      "ratio": 1.2535,
+      "suggested_scalar": 0.3776,
+      "log_bad": 4.2627,
+      "log_good": 4.4886
+    },
+    "brevity.mean_sample_size": {
+      "bad": 71.0,
+      "good": 89.0,
+      "ratio": 1.2535,
+      "suggested_scalar": 0.3776,
+      "log_bad": 4.2627,
+      "log_good": 4.4886
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 369.0,
+      "good": 710.0,
+      "ratio": 1.9241,
+      "suggested_scalar": 1.0937,
+      "log_bad": 5.9108,
+      "log_good": 6.5653
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 157.0,
+      "good": 423.0,
+      "ratio": 2.6943,
+      "suggested_scalar": 1.6563,
+      "log_bad": 5.0562,
+      "log_good": 6.0474
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 159.0,
+      "good": 215.0,
+      "ratio": 1.3522,
+      "suggested_scalar": 0.5042,
+      "log_bad": 5.0689,
+      "log_good": 5.3706
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 3.3256,
+      "good": 5.3165,
+      "ratio": 1.5987,
+      "suggested_scalar": 0.7841,
+      "log_bad": 1.2017,
+      "log_good": 1.6708
+    },
+    "halstead.mean_effort": {
+      "bad": 63629.5189,
+      "good": 210574.9479,
+      "ratio": 3.3094,
+      "suggested_scalar": 2.0,
+      "log_bad": 11.0608,
+      "log_good": 12.2576
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8391,
+      "good": 0.7876,
+      "ratio": 0.9386,
+      "suggested_scalar": -0.1059,
+      "log_bad": -0.1754,
+      "log_good": -0.2388
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 40.0,
+      "good": 54.0,
+      "ratio": 1.35,
+      "suggested_scalar": 0.5015,
+      "log_bad": 3.6889,
+      "log_good": 3.989
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 219.0,
+      "good": 473.0,
+      "ratio": 2.1598,
+      "suggested_scalar": 1.2868,
+      "log_bad": 5.3891,
+      "log_good": 6.1591
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4184,
+      "good": 0.2827,
+      "ratio": 0.6757,
+      "suggested_scalar": -0.6552,
+      "log_bad": -0.8713,
+      "log_good": -1.2634
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.2653,
+      "good": 6.2827,
+      "ratio": 1.0028,
+      "suggested_scalar": 0.0046,
+      "log_bad": 1.835,
+      "log_good": 1.8378
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1087,
+      "good": 0.0938,
+      "ratio": 0.8629,
+      "suggested_scalar": -0.2464,
+      "log_bad": -2.2192,
+      "log_good": -2.3666
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.3714,
+      "good": 4.5231,
+      "ratio": 1.9074,
+      "suggested_scalar": 1.0791,
+      "log_bad": 0.8635,
+      "log_good": 1.5092
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 368.0,
+      "good": 709.0,
+      "ratio": 1.9266,
+      "suggested_scalar": 1.0959,
+      "log_bad": 5.9081,
+      "log_good": 6.5639
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.3047,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 59.0,
+      "good": 96.0,
+      "ratio": 1.6271,
+      "suggested_scalar": 0.8135,
+      "log_bad": 4.0775,
+      "log_good": 4.5643
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3534.9733,
+      "good": 11698.6082,
+      "ratio": 3.3094,
+      "suggested_scalar": 2.0,
+      "log_bad": 8.1705,
+      "log_good": 9.3672
+    },
+    "readability.mean_total_lines": {
+      "bad": 82.0,
+      "good": 87.0,
+      "ratio": 1.061,
+      "suggested_scalar": 0.0989,
+      "log_bad": 4.4067,
+      "log_good": 4.4659
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 1994.6558,
+      "good": 4254.0394,
+      "ratio": 2.1327,
+      "suggested_scalar": 1.2657,
+      "log_bad": 7.5982,
+      "log_good": 8.3556
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 478.0,
+      "good": 671.0,
+      "ratio": 1.4038,
+      "suggested_scalar": 0.5668,
+      "log_bad": 6.1696,
+      "log_good": 6.5088
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 19.3537,
+      "good": 28.4368,
+      "ratio": 1.4693,
+      "suggested_scalar": 0.6431,
+      "log_bad": 2.9629,
+      "log_good": 3.3477
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1,
+      "good": 1.2063,
+      "ratio": 1.0966,
+      "suggested_scalar": 0.1542,
+      "log_bad": 0.0953,
+      "log_good": 0.1876
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 1.836,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 1.836,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7412,
+      "good": 0.7028,
+      "ratio": 0.9482,
+      "suggested_scalar": -0.0889,
+      "log_bad": -0.2995,
+      "log_good": -0.3527
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9611,
+      "good": 0.9714,
+      "ratio": 1.0107,
+      "suggested_scalar": 0.0178,
+      "log_bad": -0.0397,
+      "log_good": -0.029
+    },
+    "halstead.mean_length": {
+      "bad": 335.0,
+      "good": 671.0,
+      "ratio": 2.003,
+      "suggested_scalar": 1.1609,
+      "log_bad": 5.8141,
+      "log_good": 6.5088
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.5789,
+      "good": 5.0,
+      "ratio": 1.092,
+      "suggested_scalar": 0.147,
+      "log_bad": 1.5215,
+      "log_good": 1.6094
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.1497,
+      "good": 6.4757,
+      "ratio": 1.053,
+      "suggested_scalar": 0.0863,
+      "log_bad": 1.8164,
+      "log_good": 1.8681
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0935,
+      "good": 0.1646,
+      "ratio": 1.7604,
+      "suggested_scalar": 0.9451,
+      "log_bad": -2.3698,
+      "log_good": -1.8042
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 31.9,
+      "good": 49.5,
+      "ratio": 1.5517,
+      "suggested_scalar": 0.7343,
+      "log_bad": 3.4626,
+      "log_good": 3.902
+    },
+    "branching.mean_branch_count": {
+      "bad": 17.0,
+      "good": 15.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.2092,
+      "log_bad": 2.8332,
+      "log_good": 2.7081
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 41.0,
+      "good": 54.0,
+      "ratio": 1.3171,
+      "suggested_scalar": 0.4603,
+      "log_bad": 3.7136,
+      "log_good": 3.989
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5975,
+      "good": 0.5209,
+      "ratio": 0.8718,
+      "suggested_scalar": -0.2293,
+      "log_bad": -0.515,
+      "log_good": -0.6522
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 82.0,
+      "good": 87.0,
+      "ratio": 1.061,
+      "suggested_scalar": 0.0989,
+      "log_bad": 4.4067,
+      "log_good": 4.4659
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 17.0,
+      "ratio": 1.2143,
+      "suggested_scalar": 0.3245,
+      "log_bad": 2.6391,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.uses_exceptions_not_error_codes": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "documentation.file_has_license_header": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 54.0,
+      "good": 55.0,
+      "ratio": 1.0185,
+      "suggested_scalar": 0.0089,
+      "log_bad": 3.989,
+      "log_good": 4.0073
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0189,
+      "good": 0.0185,
+      "ratio": 0.9788,
+      "suggested_scalar": -0.0104,
+      "log_bad": -3.9686,
+      "log_good": -3.99
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.2353,
+      "good": 1.2353,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2113,
+      "log_good": 0.2113
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9333,
+      "good": 0.9344,
+      "ratio": 1.0012,
+      "suggested_scalar": 0.0006,
+      "log_bad": -0.069,
+      "log_good": -0.0679
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0189,
+      "good": 0.0185,
+      "ratio": 0.9788,
+      "suggested_scalar": -0.0104,
+      "log_bad": -3.9686,
+      "log_good": -3.99
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8309,
+      "good": 4.8591,
+      "ratio": 1.0058,
+      "suggested_scalar": 0.0028,
+      "log_bad": 1.575,
+      "log_good": 1.5809
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 108.0,
+      "good": 115.0,
+      "ratio": 1.0648,
+      "suggested_scalar": 0.0306,
+      "log_bad": 4.6821,
+      "log_good": 4.7449
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4554,
+      "good": 0.4669,
+      "ratio": 1.0253,
+      "suggested_scalar": 0.0121,
+      "log_bad": -0.7866,
+      "log_good": -0.7616
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5554,
+      "good": 0.5427,
+      "ratio": 0.9771,
+      "suggested_scalar": -0.0113,
+      "log_bad": -0.5881,
+      "log_good": -0.6112
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.0667,
+      "good": 3.0164,
+      "ratio": 0.9836,
+      "suggested_scalar": -0.008,
+      "log_bad": 1.1206,
+      "log_good": 1.1041
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 636.0,
+      "good": 648.0,
+      "ratio": 1.0189,
+      "suggested_scalar": 0.0091,
+      "log_bad": 6.4552,
+      "log_good": 6.4739
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0014,
+      "good": 0.0014,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.5713,
+      "log_good": -6.5713
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 0.0164,
+      "ratio": 0.0164,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -4.1105
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0042,
+      "good": 0.0042,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.4727,
+      "log_good": -5.4727
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1012,
+      "good": 1.0889,
+      "ratio": 0.9888,
+      "suggested_scalar": -0.0055,
+      "log_bad": 0.0964,
+      "log_good": 0.0852
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 164.0,
+      "good": 170.0,
+      "ratio": 1.0366,
+      "suggested_scalar": 0.0175,
+      "log_bad": 5.0999,
+      "log_good": 5.1358
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 99.9993,
+      "good": 100.0571,
+      "ratio": 1.0006,
+      "suggested_scalar": 0.0003,
+      "log_bad": 4.6052,
+      "log_good": 4.6057
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6677,
+      "good": 0.6553,
+      "ratio": 0.9814,
+      "suggested_scalar": -0.0091,
+      "log_bad": -0.4039,
+      "log_good": -0.4227
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.2821,
+      "good": 10.2169,
+      "ratio": 0.9937,
+      "suggested_scalar": -0.0031,
+      "log_bad": 2.3304,
+      "log_good": 2.324
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2121.0,
+      "good": 2167.0,
+      "ratio": 1.0217,
+      "suggested_scalar": 0.0104,
+      "log_bad": 7.6596,
+      "log_good": 7.6811
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1333,
+      "good": 0.1311,
+      "ratio": 0.9835,
+      "suggested_scalar": -0.0081,
+      "log_bad": -2.0152,
+      "log_good": -2.0318
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8833,
+      "good": 0.8852,
+      "ratio": 1.0022,
+      "suggested_scalar": 0.001,
+      "log_bad": -0.1241,
+      "log_good": -0.1219
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.6,
+      "good": 10.8,
+      "ratio": 1.0189,
+      "suggested_scalar": 0.0091,
+      "log_bad": 2.3609,
+      "log_good": 2.3795
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.1289,
+      "good": 3.2292,
+      "ratio": 1.0321,
+      "suggested_scalar": 0.0154,
+      "log_bad": 1.1407,
+      "log_good": 1.1722
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 135.0,
+      "good": 136.0,
+      "ratio": 1.0074,
+      "suggested_scalar": 0.0036,
+      "log_bad": 4.9053,
+      "log_good": 4.9127
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9639,
+      "good": 0.9617,
+      "ratio": 0.9977,
+      "suggested_scalar": -0.0011,
+      "log_bad": -0.0368,
+      "log_good": -0.0391
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 37.0,
+      "good": 37.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6109,
+      "log_good": 3.6109
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6176,
+      "good": 0.6101,
+      "ratio": 0.9879,
+      "suggested_scalar": -0.0059,
+      "log_bad": -0.4819,
+      "log_good": -0.4941
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4479,
+      "good": 0.4396,
+      "ratio": 0.9815,
+      "suggested_scalar": -0.0091,
+      "log_bad": -0.8032,
+      "log_good": -0.8219
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6153,
+      "good": 2.5645,
+      "ratio": 0.9806,
+      "suggested_scalar": -0.0095,
+      "log_bad": 0.9614,
+      "log_good": 0.9418
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 634.0,
+      "good": 646.0,
+      "ratio": 1.0189,
+      "suggested_scalar": 0.0091,
+      "log_bad": 6.452,
+      "log_good": 6.4708
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0189,
+      "good": 0.0185,
+      "ratio": 0.9788,
+      "suggested_scalar": -0.0104,
+      "log_bad": -3.9686,
+      "log_good": -3.99
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0224,
+      "good": 6.0875,
+      "ratio": 1.0108,
+      "suggested_scalar": 0.0052,
+      "log_bad": 1.7955,
+      "log_good": 1.8062
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 23.0,
+      "good": 28.0,
+      "ratio": 1.2174,
+      "suggested_scalar": 0.0957,
+      "log_bad": 3.1355,
+      "log_good": 3.3322
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8032,
+      "good": 0.8564,
+      "ratio": 1.0662,
+      "suggested_scalar": 0.0312,
+      "log_bad": -0.2192,
+      "log_good": -0.155
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6326,
+      "good": 5.6812,
+      "ratio": 1.0086,
+      "suggested_scalar": 0.0042,
+      "log_bad": 1.7286,
+      "log_good": 1.7372
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8022,
+      "good": 0.7982,
+      "ratio": 0.995,
+      "suggested_scalar": -0.0024,
+      "log_bad": -0.2204,
+      "log_good": -0.2254
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1892,
+      "good": 0.1974,
+      "ratio": 1.0433,
+      "suggested_scalar": 0.0206,
+      "log_bad": -1.665,
+      "log_good": -1.6225
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.2066,
+      "good": 3.1964,
+      "ratio": 0.9968,
+      "suggested_scalar": -0.0016,
+      "log_bad": 1.1652,
+      "log_good": 1.162
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1973,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 433.0,
+      "good": 445.0,
+      "ratio": 1.0277,
+      "suggested_scalar": 0.0133,
+      "log_bad": 6.0707,
+      "log_good": 6.0981
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.2587,
+      "good": 1.3006,
+      "ratio": 1.0333,
+      "suggested_scalar": 0.0159,
+      "log_bad": 0.2301,
+      "log_good": 0.2628
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 126.0,
+      "good": 133.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.0263,
+      "log_bad": 4.8363,
+      "log_good": 4.8903
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 973.0,
+      "good": 1001.0,
+      "ratio": 1.0288,
+      "suggested_scalar": 0.0138,
+      "log_bad": 6.8804,
+      "log_good": 6.9088
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 181.0,
+      "good": 188.0,
+      "ratio": 1.0387,
+      "suggested_scalar": 0.0185,
+      "log_bad": 5.1985,
+      "log_good": 5.2364
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0047,
+      "good": 0.0046,
+      "ratio": 0.9787,
+      "suggested_scalar": -0.0105,
+      "log_bad": -5.3602,
+      "log_good": -5.3817
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2531,
+      "good": 0.2531,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.374,
+      "log_good": -1.374
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 103.0,
+      "good": 103.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.6347,
+      "log_good": 4.6347
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 126.0,
+      "good": 133.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.0263,
+      "log_bad": 4.8363,
+      "log_good": 4.8903
+    },
+    "brevity.mean_sample_size": {
+      "bad": 126.0,
+      "good": 133.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.0263,
+      "log_bad": 4.8363,
+      "log_good": 4.8903
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 636.0,
+      "good": 648.0,
+      "ratio": 1.0189,
+      "suggested_scalar": 0.0091,
+      "log_bad": 6.4552,
+      "log_good": 6.4739
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 373.0,
+      "good": 378.0,
+      "ratio": 1.0134,
+      "suggested_scalar": 0.0065,
+      "log_bad": 5.9216,
+      "log_good": 5.9349
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 314.0,
+      "good": 326.0,
+      "ratio": 1.0382,
+      "suggested_scalar": 0.0182,
+      "log_bad": 5.7494,
+      "log_good": 5.7869
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0031,
+      "good": 0.0046,
+      "ratio": 1.4839,
+      "suggested_scalar": 0.192,
+      "log_bad": -5.7764,
+      "log_good": -5.3817
+    },
+    "heaps.mean_k": {
+      "bad": 3.7797,
+      "good": 4.2877,
+      "ratio": 1.1344,
+      "suggested_scalar": 0.0614,
+      "log_bad": 1.3296,
+      "log_good": 1.4558
+    },
+    "halstead.mean_effort": {
+      "bad": 178082.7621,
+      "good": 173986.0283,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0113,
+      "log_bad": 12.09,
+      "log_good": 12.0667
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8073,
+      "good": 0.8052,
+      "ratio": 0.9974,
+      "suggested_scalar": -0.0013,
+      "log_bad": -0.2141,
+      "log_good": -0.2167
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 71.0,
+      "good": 78.0,
+      "ratio": 1.0986,
+      "suggested_scalar": 0.0458,
+      "log_bad": 4.2627,
+      "log_good": 4.3567
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 378.0,
+      "good": 382.0,
+      "ratio": 1.0106,
+      "suggested_scalar": 0.0051,
+      "log_bad": 5.9349,
+      "log_good": 5.9454
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4573,
+      "good": 0.4765,
+      "ratio": 1.042,
+      "suggested_scalar": 0.02,
+      "log_bad": -0.7824,
+      "log_good": -0.7413
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.9329,
+      "good": 5.8882,
+      "ratio": 0.9925,
+      "suggested_scalar": -0.0037,
+      "log_bad": 1.7805,
+      "log_good": 1.773
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1892,
+      "good": 0.1974,
+      "ratio": 1.0433,
+      "suggested_scalar": 0.0206,
+      "log_bad": -1.665,
+      "log_good": -1.6225
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.0152,
+      "good": 5.0776,
+      "ratio": 1.0124,
+      "suggested_scalar": 0.006,
+      "log_bad": 1.6125,
+      "log_good": 1.6248
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 635.0,
+      "good": 647.0,
+      "ratio": 1.0189,
+      "suggested_scalar": 0.0091,
+      "log_bad": 6.4536,
+      "log_good": 6.4723
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 83.0,
+      "good": 83.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.4188,
+      "log_good": 4.4188
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 9893.4868,
+      "good": 9665.8905,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0113,
+      "log_bad": 9.1996,
+      "log_good": 9.1764
+    },
+    "readability.mean_total_lines": {
+      "bad": 60.0,
+      "good": 60.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0943,
+      "log_good": 4.0943
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 3775.9821,
+      "good": 3901.9293,
+      "ratio": 1.0334,
+      "suggested_scalar": 0.016,
+      "log_bad": 8.2364,
+      "log_good": 8.2692
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 811.0,
+      "good": 845.0,
+      "ratio": 1.0419,
+      "suggested_scalar": 0.02,
+      "log_bad": 6.6983,
+      "log_good": 6.7393
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 34.1167,
+      "good": 34.1167,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5298,
+      "log_good": 3.5298
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1357,
+      "good": 1.1326,
+      "ratio": 0.9973,
+      "suggested_scalar": -0.0013,
+      "log_bad": 0.1272,
+      "log_good": 0.1245
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 22.0,
+      "good": 24.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0423,
+      "log_bad": 3.091,
+      "log_good": 3.1781
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8083,
+      "good": 0.8135,
+      "ratio": 1.0064,
+      "suggested_scalar": 0.0031,
+      "log_bad": -0.2128,
+      "log_good": -0.2064
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9659,
+      "good": 0.9678,
+      "ratio": 1.002,
+      "suggested_scalar": 0.001,
+      "log_bad": -0.0347,
+      "log_good": -0.0327
+    },
+    "halstead.mean_length": {
+      "bad": 559.0,
+      "good": 570.0,
+      "ratio": 1.0197,
+      "suggested_scalar": 0.0095,
+      "log_bad": 6.3261,
+      "log_good": 6.3456
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 3.8235,
+      "good": 3.8235,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3412,
+      "log_good": 1.3412
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9773,
+      "good": 7.0553,
+      "ratio": 1.0112,
+      "suggested_scalar": 0.0054,
+      "log_bad": 1.9427,
+      "log_good": 1.9538
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1759,
+      "good": 0.1744,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0042,
+      "log_bad": -1.7378,
+      "log_good": -1.7464
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 47.162,
+      "good": 44.5897,
+      "ratio": 0.9455,
+      "suggested_scalar": -0.0273,
+      "log_bad": 3.8536,
+      "log_good": 3.7975
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 75.0,
+      "good": 81.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.0374,
+      "log_bad": 4.3175,
+      "log_good": 4.3944
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.672,
+      "good": 0.684,
+      "ratio": 1.0179,
+      "suggested_scalar": 0.0086,
+      "log_bad": -0.3975,
+      "log_good": -0.3798
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 60.0,
+      "good": 61.0,
+      "ratio": 1.0167,
+      "suggested_scalar": 0.008,
+      "log_bad": 4.0943,
+      "log_good": 4.1109
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.uses_smart_pointers_for_ownership": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0021,
+      "good": 0.0023,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.1656,
+      "log_bad": -6.1658,
+      "log_good": -6.0748
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8308,
+      "good": 0.8704,
+      "ratio": 1.0477,
+      "suggested_scalar": 0.0848,
+      "log_bad": -0.1854,
+      "log_good": -0.1388
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0021,
+      "good": 0.0023,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.1656,
+      "log_bad": -6.1658,
+      "log_good": -6.0748
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6658,
+      "good": 4.7012,
+      "ratio": 1.0076,
+      "suggested_scalar": 0.0138,
+      "log_bad": 1.5403,
+      "log_good": 1.5478
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 114.0,
+      "good": 79.0,
+      "ratio": 0.693,
+      "suggested_scalar": -0.6677,
+      "log_bad": 4.7362,
+      "log_good": 4.3694
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4574,
+      "good": 0.3422,
+      "ratio": 0.7481,
+      "suggested_scalar": -0.5282,
+      "log_bad": -0.7822,
+      "log_good": -1.0724
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 22.0,
+      "good": 19.0,
+      "ratio": 0.8636,
+      "suggested_scalar": -0.2669,
+      "log_bad": 3.091,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7402,
+      "good": 0.6665,
+      "ratio": 0.9004,
+      "suggested_scalar": -0.1909,
+      "log_bad": -0.3008,
+      "log_good": -0.4057
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.9231,
+      "good": 4.7407,
+      "ratio": 0.963,
+      "suggested_scalar": -0.0687,
+      "log_bad": 1.5939,
+      "log_good": 1.5562
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 476.0,
+      "good": 438.0,
+      "ratio": 0.9202,
+      "suggested_scalar": -0.1515,
+      "log_bad": 6.1654,
+      "log_good": 6.0822
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1077,
+      "good": 0.0926,
+      "ratio": 0.8598,
+      "suggested_scalar": -0.275,
+      "log_bad": -2.2284,
+      "log_good": -2.3795
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9847,
+      "good": 1.0695,
+      "ratio": 1.0861,
+      "suggested_scalar": 0.1504,
+      "log_bad": -0.0154,
+      "log_good": 0.0672
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 183.0,
+      "good": 148.0,
+      "ratio": 0.8087,
+      "suggested_scalar": -0.3864,
+      "log_bad": 5.2095,
+      "log_good": 4.9972
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 100.6467,
+      "good": 93.4984,
+      "ratio": 0.929,
+      "suggested_scalar": -0.1341,
+      "log_bad": 4.6116,
+      "log_good": 4.5379
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5221,
+      "good": 0.6499,
+      "ratio": 1.2448,
+      "suggested_scalar": 0.3986,
+      "log_bad": -0.6499,
+      "log_good": -0.4309
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 5.9995,
+      "good": 7.1272,
+      "ratio": 1.188,
+      "suggested_scalar": 0.3136,
+      "log_bad": 1.7917,
+      "log_good": 1.9639
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2125.0,
+      "good": 1762.0,
+      "ratio": 0.8292,
+      "suggested_scalar": -0.341,
+      "log_bad": 7.6615,
+      "log_good": 7.4742
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0923,
+      "good": 0.0556,
+      "ratio": 0.6024,
+      "suggested_scalar": -0.9227,
+      "log_bad": -2.3827,
+      "log_good": -2.8896
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8308,
+      "good": 0.8704,
+      "ratio": 1.0477,
+      "suggested_scalar": 0.0848,
+      "log_bad": -0.1854,
+      "log_good": -0.1388
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.9333,
+      "good": 8.9388,
+      "ratio": 1.1267,
+      "suggested_scalar": 0.2172,
+      "log_bad": 2.0711,
+      "log_good": 2.1904
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 30.0,
+      "good": 30.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4012,
+      "log_good": 3.4012
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 11.2095,
+      "good": 11.8957,
+      "ratio": 1.0612,
+      "suggested_scalar": 0.1082,
+      "log_bad": 2.4168,
+      "log_good": 2.4762
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 123.0,
+      "good": 98.0,
+      "ratio": 0.7967,
+      "suggested_scalar": -0.4136,
+      "log_bad": 4.8122,
+      "log_good": 4.585
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9594,
+      "good": 0.9621,
+      "ratio": 1.0028,
+      "suggested_scalar": 0.0051,
+      "log_bad": -0.0414,
+      "log_good": -0.0386
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 26.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.2605,
+      "log_bad": 3.4012,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6268,
+      "good": 0.6549,
+      "ratio": 1.0448,
+      "suggested_scalar": 0.0798,
+      "log_bad": -0.4671,
+      "log_good": -0.4233
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.289,
+      "good": 0.4427,
+      "ratio": 1.5318,
+      "suggested_scalar": 0.7764,
+      "log_bad": -1.2413,
+      "log_good": -0.8149
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6797,
+      "good": 2.898,
+      "ratio": 1.0815,
+      "suggested_scalar": 0.1426,
+      "log_bad": 0.9857,
+      "log_good": 1.064
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 474.0,
+      "good": 436.0,
+      "ratio": 0.9198,
+      "suggested_scalar": -0.1521,
+      "log_bad": 6.1612,
+      "log_good": 6.0776
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0441,
+      "good": 0.0708,
+      "ratio": 1.6054,
+      "suggested_scalar": 0.8618,
+      "log_bad": -3.1213,
+      "log_good": -2.6479
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.7549,
+      "ratio": 0.9665,
+      "suggested_scalar": -0.062,
+      "log_bad": 1.7841,
+      "log_good": 1.7501
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 20.0,
+      "good": 10.0,
+      "ratio": 0.5,
+      "suggested_scalar": -1.2619,
+      "log_bad": 2.9957,
+      "log_good": 2.3026
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3911,
+      "good": 1.3859,
+      "ratio": 0.9963,
+      "suggested_scalar": -0.0068,
+      "log_bad": 0.3301,
+      "log_good": 0.3263
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8775,
+      "good": 5.2796,
+      "ratio": 0.8983,
+      "suggested_scalar": -0.1953,
+      "log_bad": 1.7711,
+      "log_good": 1.6639
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7836,
+      "good": 0.8169,
+      "ratio": 1.0425,
+      "suggested_scalar": 0.0758,
+      "log_bad": -0.2439,
+      "log_good": -0.2022
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1558,
+      "good": 0.1429,
+      "ratio": 0.9172,
+      "suggested_scalar": -0.1573,
+      "log_bad": -1.8592,
+      "log_good": -1.9456
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.4494,
+      "good": 2.6697,
+      "ratio": 1.0899,
+      "suggested_scalar": 0.1568,
+      "log_bad": 0.8958,
+      "log_good": 0.982
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 385.0,
+      "good": 306.0,
+      "ratio": 0.7948,
+      "suggested_scalar": -0.4181,
+      "log_bad": 5.9532,
+      "log_good": 5.7236
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 13.0,
+      "good": 15.0,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.2605,
+      "log_bad": 2.5649,
+      "log_good": 2.7081
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.05,
+      "good": 0.8972,
+      "ratio": 0.8545,
+      "suggested_scalar": -0.2863,
+      "log_bad": 0.0488,
+      "log_good": -0.1085
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 115.0,
+      "good": 80.0,
+      "ratio": 0.6957,
+      "suggested_scalar": -0.6607,
+      "log_bad": 4.7449,
+      "log_good": 4.382
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1094.0,
+      "good": 893.0,
+      "ratio": 0.8163,
+      "suggested_scalar": -0.3696,
+      "log_bad": 6.9976,
+      "log_good": 6.7946
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 203.0,
+      "good": 171.0,
+      "ratio": 0.8424,
+      "suggested_scalar": -0.3123,
+      "log_bad": 5.3132,
+      "log_good": 5.1417
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0021,
+      "good": 0.0023,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.1656,
+      "log_bad": -6.1658,
+      "log_good": -6.0748
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2458,
+      "good": 0.2854,
+      "ratio": 1.1611,
+      "suggested_scalar": 0.2719,
+      "log_bad": -1.4032,
+      "log_good": -1.2539
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 73.0,
+      "good": 75.0,
+      "ratio": 1.0274,
+      "suggested_scalar": 0.0492,
+      "log_bad": 4.2905,
+      "log_good": 4.3175
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 115.0,
+      "good": 80.0,
+      "ratio": 0.6957,
+      "suggested_scalar": -0.6607,
+      "log_bad": 4.7449,
+      "log_good": 4.382
+    },
+    "brevity.mean_sample_size": {
+      "bad": 115.0,
+      "good": 80.0,
+      "ratio": 0.6957,
+      "suggested_scalar": -0.6607,
+      "log_bad": 4.7449,
+      "log_good": 4.382
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 476.0,
+      "good": 438.0,
+      "ratio": 0.9202,
+      "suggested_scalar": -0.1515,
+      "log_bad": 6.1654,
+      "log_good": 6.0822
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 248.0,
+      "good": 250.0,
+      "ratio": 1.0081,
+      "suggested_scalar": 0.0146,
+      "log_bad": 5.5134,
+      "log_good": 5.5215
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 300.0,
+      "good": 228.0,
+      "ratio": 0.76,
+      "suggested_scalar": -0.4996,
+      "log_bad": 5.7038,
+      "log_good": 5.4293
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.4235,
+      "good": 1.5871,
+      "ratio": 1.1149,
+      "suggested_scalar": 0.198,
+      "log_bad": 0.3531,
+      "log_good": 0.4619
+    },
+    "halstead.mean_effort": {
+      "bad": 114186.1332,
+      "good": 112899.6427,
+      "ratio": 0.9887,
+      "suggested_scalar": -0.0206,
+      "log_bad": 11.6456,
+      "log_good": 11.6343
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8586,
+      "good": 0.8351,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.0505,
+      "log_bad": -0.1525,
+      "log_good": -0.1802
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 84.0,
+      "good": 53.0,
+      "ratio": 0.631,
+      "suggested_scalar": -0.8384,
+      "log_bad": 4.4308,
+      "log_good": 3.9703
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 258.0,
+      "good": 256.0,
+      "ratio": 0.9922,
+      "suggested_scalar": -0.0142,
+      "log_bad": 5.553,
+      "log_good": 5.5452
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3989,
+      "good": 0.2905,
+      "ratio": 0.7283,
+      "suggested_scalar": -0.5773,
+      "log_bad": -0.919,
+      "log_good": -1.2362
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.9781,
+      "good": 6.0338,
+      "ratio": 1.0093,
+      "suggested_scalar": 0.0169,
+      "log_bad": 1.7881,
+      "log_good": 1.7974
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1558,
+      "good": 0.1429,
+      "ratio": 0.9172,
+      "suggested_scalar": -0.1573,
+      "log_bad": -1.8592,
+      "log_good": -1.9456
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.1733,
+      "good": 3.5755,
+      "ratio": 1.1267,
+      "suggested_scalar": 0.2172,
+      "log_bad": 1.1548,
+      "log_good": 1.2741
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 475.0,
+      "good": 437.0,
+      "ratio": 0.92,
+      "suggested_scalar": -0.1518,
+      "log_bad": 6.1633,
+      "log_good": 6.0799
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 48.0,
+      "good": 63.0,
+      "ratio": 1.3125,
+      "suggested_scalar": 0.495,
+      "log_bad": 3.8712,
+      "log_good": 4.1431
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6343.6741,
+      "good": 6272.2024,
+      "ratio": 0.9887,
+      "suggested_scalar": -0.0206,
+      "log_bad": 8.7552,
+      "log_good": 8.7439
+    },
+    "readability.mean_total_lines": {
+      "bad": 60.0,
+      "good": 49.0,
+      "ratio": 0.8167,
+      "suggested_scalar": -0.3687,
+      "log_bad": 4.0943,
+      "log_good": 3.8918
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 3149.9623,
+      "good": 2691.7144,
+      "ratio": 0.8545,
+      "suggested_scalar": -0.2862,
+      "log_bad": 8.0551,
+      "log_good": 7.8979
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 793.0,
+      "good": 608.0,
+      "ratio": 0.7667,
+      "suggested_scalar": -0.4836,
+      "log_bad": 6.6758,
+      "log_good": 6.4102
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.5,
+      "good": 32.8571,
+      "ratio": 1.011,
+      "suggested_scalar": 0.0199,
+      "log_bad": 3.4812,
+      "log_good": 3.4922
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.16,
+      "good": 1.2324,
+      "ratio": 1.0624,
+      "suggested_scalar": 0.1102,
+      "log_bad": 0.1484,
+      "log_good": 0.209
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 5.0,
+      "good": 8.0,
+      "ratio": 1.6,
+      "suggested_scalar": 0.8556,
+      "log_bad": 1.6094,
+      "log_good": 2.0794
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.6125,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8753,
+      "good": 0.7941,
+      "ratio": 0.9072,
+      "suggested_scalar": -0.1772,
+      "log_bad": -0.1332,
+      "log_good": -0.2305
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9371,
+      "good": 0.9575,
+      "ratio": 1.0218,
+      "suggested_scalar": 0.0392,
+      "log_bad": -0.065,
+      "log_good": -0.0434
+    },
+    "halstead.mean_length": {
+      "bad": 461.0,
+      "good": 427.0,
+      "ratio": 0.9262,
+      "suggested_scalar": -0.1395,
+      "log_bad": 6.1334,
+      "log_good": 6.0568
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8455,
+      "good": 6.3219,
+      "ratio": 0.9235,
+      "suggested_scalar": -0.1449,
+      "log_bad": 1.9236,
+      "log_good": 1.844
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1171,
+      "good": 0.1419,
+      "ratio": 1.2118,
+      "suggested_scalar": 0.3497,
+      "log_bad": -2.1447,
+      "log_good": -1.9526
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 36.25,
+      "good": 41.9434,
+      "ratio": 1.1571,
+      "suggested_scalar": 0.2656,
+      "log_bad": 3.5904,
+      "log_good": 3.7363
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 3.0,
+      "ratio": 0.5,
+      "suggested_scalar": -1.2619,
+      "log_bad": 1.7918,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 73.0,
+      "good": 43.0,
+      "ratio": 0.589,
+      "suggested_scalar": -0.9635,
+      "log_bad": 4.2905,
+      "log_good": 3.7612
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7567,
+      "good": 0.6711,
+      "ratio": 0.8869,
+      "suggested_scalar": -0.2185,
+      "log_bad": -0.2788,
+      "log_good": -0.3988
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 65.0,
+      "good": 54.0,
+      "ratio": 0.8308,
+      "suggested_scalar": -0.3375,
+      "log_bad": 4.1744,
+      "log_good": 3.989
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.function_does_not_change_return_type_via_options": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 26.0,
+      "good": 20.0,
+      "ratio": 0.7692,
+      "suggested_scalar": -0.1117,
+      "log_bad": 3.2581,
+      "log_good": 2.9957
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1726,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0109,
+      "good": 0.0372,
+      "ratio": 3.4128,
+      "suggested_scalar": 0.5224,
+      "log_bad": -4.519,
+      "log_good": -3.2914
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 3.0,
+      "good": 1.5,
+      "ratio": 0.5,
+      "suggested_scalar": -0.295,
+      "log_bad": 1.0986,
+      "log_good": 0.4055
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8519,
+      "good": 0.8065,
+      "ratio": 0.9467,
+      "suggested_scalar": -0.0233,
+      "log_bad": -0.1603,
+      "log_good": -0.2151
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0109,
+      "good": 0.0372,
+      "ratio": 3.4128,
+      "suggested_scalar": 0.5224,
+      "log_bad": -4.519,
+      "log_good": -3.2914
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7089,
+      "good": 4.7364,
+      "ratio": 1.0058,
+      "suggested_scalar": 0.0025,
+      "log_bad": 1.5495,
+      "log_good": 1.5553
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 92.0,
+      "good": 78.0,
+      "ratio": 0.8478,
+      "suggested_scalar": -0.0703,
+      "log_bad": 4.5218,
+      "log_good": 4.3567
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3967,
+      "good": 0.3988,
+      "ratio": 1.0053,
+      "suggested_scalar": 0.0022,
+      "log_bad": -0.9246,
+      "log_good": -0.9193
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.0,
+      "good": 19.0,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.0426,
+      "log_bad": 3.0445,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5475,
+      "good": 0.5375,
+      "ratio": 0.9817,
+      "suggested_scalar": -0.0078,
+      "log_bad": -0.6024,
+      "log_good": -0.6208
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.7037,
+      "good": 3.2258,
+      "ratio": 0.6858,
+      "suggested_scalar": -0.1605,
+      "log_bad": 1.5483,
+      "log_good": 1.1712
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 549.0,
+      "good": 484.0,
+      "ratio": 0.8816,
+      "suggested_scalar": -0.0536,
+      "log_bad": 6.3081,
+      "log_good": 6.1821
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1296,
+      "good": 1.0,
+      "ratio": 7.716,
+      "suggested_scalar": 0.8696,
+      "log_bad": -2.0433,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0337,
+      "good": 1.0372,
+      "ratio": 1.0034,
+      "suggested_scalar": 0.0014,
+      "log_bad": 0.0331,
+      "log_good": 0.0365
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 185.0,
+      "good": 184.0,
+      "ratio": 0.9946,
+      "suggested_scalar": -0.0023,
+      "log_bad": 5.2204,
+      "log_good": 5.2149
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.5664,
+      "good": 97.2397,
+      "ratio": 0.9574,
+      "suggested_scalar": -0.0185,
+      "log_bad": 4.6207,
+      "log_good": 4.5772
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7135,
+      "good": 0.6398,
+      "ratio": 0.8967,
+      "suggested_scalar": -0.0464,
+      "log_bad": -0.3376,
+      "log_good": -0.4466
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.1014,
+      "good": 17.0193,
+      "ratio": 1.5331,
+      "suggested_scalar": 0.1818,
+      "log_bad": 2.4071,
+      "log_good": 2.8343
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1958.0,
+      "good": 1957.0,
+      "ratio": 0.9995,
+      "suggested_scalar": -0.0002,
+      "log_bad": 7.5797,
+      "log_good": 7.5792
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1481,
+      "good": 0.0484,
+      "ratio": 0.3268,
+      "suggested_scalar": -0.476,
+      "log_bad": -1.9099,
+      "log_good": -3.0283
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8148,
+      "good": 0.7903,
+      "ratio": 0.9699,
+      "suggested_scalar": -0.013,
+      "log_bad": -0.2048,
+      "log_good": -0.2353
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 11.6809,
+      "good": 7.8065,
+      "ratio": 0.6683,
+      "suggested_scalar": -0.1715,
+      "log_bad": 2.458,
+      "log_good": 2.055
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 7.8752,
+      "good": 3.0135,
+      "ratio": 0.3827,
+      "suggested_scalar": -0.4088,
+      "log_bad": 2.0637,
+      "log_good": 1.1031
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 145.0,
+      "good": 140.0,
+      "ratio": 0.9655,
+      "suggested_scalar": -0.0149,
+      "log_bad": 4.9767,
+      "log_good": 4.9416
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9295,
+      "good": 0.9389,
+      "ratio": 1.0101,
+      "suggested_scalar": 0.0043,
+      "log_bad": -0.0731,
+      "log_good": -0.063
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 24.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0656,
+      "log_bad": 3.3322,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6359,
+      "good": 0.626,
+      "ratio": 0.9844,
+      "suggested_scalar": -0.0067,
+      "log_bad": -0.4527,
+      "log_good": -0.4684
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5283,
+      "good": 0.4087,
+      "ratio": 0.7736,
+      "suggested_scalar": -0.1092,
+      "log_bad": -0.6381,
+      "log_good": -0.8948
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7461,
+      "good": 2.6735,
+      "ratio": 0.9736,
+      "suggested_scalar": -0.0114,
+      "log_bad": 1.0102,
+      "log_good": 0.9834
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 547.0,
+      "good": 482.0,
+      "ratio": 0.8812,
+      "suggested_scalar": -0.0538,
+      "log_bad": 6.3044,
+      "log_good": 6.1779
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 30.0,
+      "good": 18.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.2174,
+      "log_bad": 3.4012,
+      "log_good": 2.8904
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.031,
+      "good": 0.0351,
+      "ratio": 1.1323,
+      "suggested_scalar": 0.0529,
+      "log_bad": -3.4738,
+      "log_good": -3.3496
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8826,
+      "good": 5.9542,
+      "ratio": 1.0122,
+      "suggested_scalar": 0.0051,
+      "log_bad": 1.772,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 40.0,
+      "good": 44.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0406,
+      "log_bad": 3.6889,
+      "log_good": 3.7842
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7532,
+      "good": 0.7936,
+      "ratio": 1.0536,
+      "suggested_scalar": 0.0222,
+      "log_bad": -0.2834,
+      "log_good": -0.2312
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6811,
+      "good": 5.704,
+      "ratio": 1.004,
+      "suggested_scalar": 0.0017,
+      "log_bad": 1.7371,
+      "log_good": 1.7412
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8005,
+      "good": 0.7955,
+      "ratio": 0.9938,
+      "suggested_scalar": -0.0027,
+      "log_bad": -0.2225,
+      "log_good": -0.2288
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1563,
+      "good": 0.1014,
+      "ratio": 0.6488,
+      "suggested_scalar": -0.1841,
+      "log_bad": -1.856,
+      "log_good": -2.2887
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.3319,
+      "good": 4.1255,
+      "ratio": 1.2382,
+      "suggested_scalar": 0.0909,
+      "log_bad": 1.2035,
+      "log_good": 1.4172
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 8.0,
+      "good": 5.0,
+      "ratio": 0.625,
+      "suggested_scalar": -0.2,
+      "log_bad": 2.0794,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 355.0,
+      "good": 356.0,
+      "ratio": 1.0028,
+      "suggested_scalar": 0.0012,
+      "log_bad": 5.8721,
+      "log_good": 5.8749
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 12.0,
+      "good": 7.0,
+      "ratio": 0.5833,
+      "suggested_scalar": -0.2294,
+      "log_bad": 2.4849,
+      "log_good": 1.9459
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0894,
+      "good": 0.7899,
+      "ratio": 0.7251,
+      "suggested_scalar": -0.1368,
+      "log_bad": 0.0856,
+      "log_good": -0.2358
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 95.0,
+      "good": 102.0,
+      "ratio": 1.0737,
+      "suggested_scalar": 0.0303,
+      "log_bad": 4.5539,
+      "log_good": 4.625
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 953.0,
+      "good": 1141.0,
+      "ratio": 1.1973,
+      "suggested_scalar": 0.0766,
+      "log_bad": 6.8596,
+      "log_good": 7.0397
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 198.0,
+      "good": 145.0,
+      "ratio": 0.7323,
+      "suggested_scalar": -0.1326,
+      "log_bad": 5.2883,
+      "log_good": 4.9767
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0091,
+      "good": 1.0,
+      "ratio": 109.8901,
+      "suggested_scalar": 2.0,
+      "log_bad": -4.6995,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2532,
+      "good": 0.2665,
+      "ratio": 1.0525,
+      "suggested_scalar": 0.0218,
+      "log_bad": -1.3736,
+      "log_good": -1.3224
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 113.0,
+      "good": 100.0,
+      "ratio": 0.885,
+      "suggested_scalar": -0.052,
+      "log_bad": 4.7274,
+      "log_good": 4.6052
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1224,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 95.0,
+      "good": 102.0,
+      "ratio": 1.0737,
+      "suggested_scalar": 0.0303,
+      "log_bad": 4.5539,
+      "log_good": 4.625
+    },
+    "brevity.mean_sample_size": {
+      "bad": 95.0,
+      "good": 102.0,
+      "ratio": 1.0737,
+      "suggested_scalar": 0.0303,
+      "log_bad": 4.5539,
+      "log_good": 4.625
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 549.0,
+      "good": 484.0,
+      "ratio": 0.8816,
+      "suggested_scalar": -0.0536,
+      "log_bad": 6.3081,
+      "log_good": 6.1821
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 301.0,
+      "good": 255.0,
+      "ratio": 0.8472,
+      "suggested_scalar": -0.0706,
+      "log_bad": 5.7071,
+      "log_good": 5.5413
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 270.0,
+      "good": 274.0,
+      "ratio": 1.0148,
+      "suggested_scalar": 0.0063,
+      "log_bad": 5.5984,
+      "log_good": 5.6131
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0146,
+      "good": 0.0103,
+      "ratio": 0.7055,
+      "suggested_scalar": -0.1485,
+      "log_bad": -4.2267,
+      "log_good": -4.5756
+    },
+    "heaps.mean_k": {
+      "bad": 3.5369,
+      "good": 4.0024,
+      "ratio": 1.1316,
+      "suggested_scalar": 0.0526,
+      "log_bad": 1.2633,
+      "log_good": 1.3869
+    },
+    "halstead.mean_effort": {
+      "bad": 141558.4404,
+      "good": 76353.6694,
+      "ratio": 0.5394,
+      "suggested_scalar": -0.2627,
+      "log_bad": 11.8605,
+      "log_good": 11.2431
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8647,
+      "good": 0.8549,
+      "ratio": 0.9887,
+      "suggested_scalar": -0.0049,
+      "log_bad": -0.1454,
+      "log_good": -0.1568
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 64.0,
+      "good": 54.0,
+      "ratio": 0.8438,
+      "suggested_scalar": -0.0723,
+      "log_bad": 4.1589,
+      "log_good": 3.989
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 303.0,
+      "good": 232.0,
+      "ratio": 0.7657,
+      "suggested_scalar": -0.1136,
+      "log_bad": 5.7137,
+      "log_good": 5.4467
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3027,
+      "good": 0.375,
+      "ratio": 1.2389,
+      "suggested_scalar": 0.0912,
+      "log_bad": -1.195,
+      "log_good": -0.9808
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.1514,
+      "good": 6.2011,
+      "ratio": 1.2038,
+      "suggested_scalar": 0.0789,
+      "log_bad": 1.6393,
+      "log_good": 1.8247
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1563,
+      "good": 0.1014,
+      "ratio": 0.6488,
+      "suggested_scalar": -0.1841,
+      "log_bad": -1.856,
+      "log_good": -2.2887
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.839,
+      "good": 4.5576,
+      "ratio": 0.7805,
+      "suggested_scalar": -0.1054,
+      "log_bad": 1.7646,
+      "log_good": 1.5168
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 548.0,
+      "good": 483.0,
+      "ratio": 0.8814,
+      "suggested_scalar": -0.0537,
+      "log_bad": 6.3063,
+      "log_good": 6.18
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.1432,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 97.0,
+      "good": 71.0,
+      "ratio": 0.732,
+      "suggested_scalar": -0.1328,
+      "log_bad": 4.5747,
+      "log_good": 4.2627
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 7864.3578,
+      "good": 4241.8705,
+      "ratio": 0.5394,
+      "suggested_scalar": -0.2627,
+      "log_bad": 8.9701,
+      "log_good": 8.3528
+    },
+    "readability.mean_total_lines": {
+      "bad": 47.0,
+      "good": 62.0,
+      "ratio": 1.3191,
+      "suggested_scalar": 0.1179,
+      "log_bad": 3.8501,
+      "log_good": 4.1271
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 6.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.2174,
+      "log_bad": 2.3026,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 3268.3045,
+      "good": 2369.5966,
+      "ratio": 0.725,
+      "suggested_scalar": -0.1368,
+      "log_bad": 8.092,
+      "log_good": 7.7705
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 713.0,
+      "good": 732.0,
+      "ratio": 1.0266,
+      "suggested_scalar": 0.0112,
+      "log_bad": 6.5695,
+      "log_good": 6.5958
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.9787,
+      "good": 30.4516,
+      "ratio": 0.9522,
+      "suggested_scalar": -0.0208,
+      "log_bad": 3.4651,
+      "log_good": 3.4161
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1042,
+      "good": 1.2018,
+      "ratio": 1.0884,
+      "suggested_scalar": 0.036,
+      "log_bad": 0.0991,
+      "log_good": 0.1838
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 39.0,
+      "good": 43.0,
+      "ratio": 1.1026,
+      "suggested_scalar": 0.0416,
+      "log_bad": 3.6636,
+      "log_good": 3.7612
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 1.0,
+      "ratio": 0.1429,
+      "suggested_scalar": -0.8281,
+      "log_bad": 1.9459,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7268,
+      "good": 0.8006,
+      "ratio": 1.1015,
+      "suggested_scalar": 0.0412,
+      "log_bad": -0.3191,
+      "log_good": -0.2224
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 6.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.4675,
+      "log_bad": 0.6931,
+      "log_good": 1.7918
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9359,
+      "good": 0.9484,
+      "ratio": 1.0134,
+      "suggested_scalar": 0.0056,
+      "log_bad": -0.0662,
+      "log_good": -0.053
+    },
+    "halstead.mean_length": {
+      "bad": 501.0,
+      "good": 377.0,
+      "ratio": 0.7525,
+      "suggested_scalar": -0.121,
+      "log_bad": 6.2166,
+      "log_good": 5.9322
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 17.6667,
+      "good": 13.75,
+      "ratio": 0.7783,
+      "suggested_scalar": -0.1067,
+      "log_bad": 2.8717,
+      "log_good": 2.621
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5699,
+      "good": 6.6724,
+      "ratio": 1.0156,
+      "suggested_scalar": 0.0066,
+      "log_bad": 1.8825,
+      "log_good": 1.898
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1537,
+      "good": 0.1303,
+      "ratio": 0.8478,
+      "suggested_scalar": -0.0703,
+      "log_bad": -1.8728,
+      "log_good": -2.0379
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 43.3125,
+      "good": 32.2222,
+      "ratio": 0.7439,
+      "suggested_scalar": -0.1259,
+      "log_bad": 3.7684,
+      "log_good": 3.4727
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 3.0,
+      "ratio": 0.375,
+      "suggested_scalar": -0.4174,
+      "log_bad": 2.0794,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 56.0,
+      "good": 69.0,
+      "ratio": 1.2321,
+      "suggested_scalar": 0.0888,
+      "log_bad": 4.0254,
+      "log_good": 4.2341
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5815,
+      "good": 0.635,
+      "ratio": 1.092,
+      "suggested_scalar": 0.0375,
+      "log_bad": -0.5421,
+      "log_good": -0.4541
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 54.0,
+      "good": 62.0,
+      "ratio": 1.1481,
+      "suggested_scalar": 0.0588,
+      "log_bad": 3.989,
+      "log_good": 4.1271
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.does_not_catch_and_suppress_errors": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 18.0,
+      "good": 28.0,
+      "ratio": 1.5556,
+      "suggested_scalar": 0.1191,
+      "log_bad": 2.8904,
+      "log_good": 3.3322
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1093,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0103,
+      "good": 0.0182,
+      "ratio": 1.767,
+      "suggested_scalar": 0.1535,
+      "log_bad": -4.5756,
+      "log_good": -4.0063
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6667,
+      "good": 1.5,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0284,
+      "log_bad": 0.5108,
+      "log_good": 0.4055
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.75,
+      "good": 0.8333,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0284,
+      "log_bad": -0.2877,
+      "log_good": -0.1824
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0103,
+      "good": 0.0182,
+      "ratio": 1.767,
+      "suggested_scalar": 0.1535,
+      "log_bad": -4.5756,
+      "log_good": -4.0063
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.2458,
+      "good": 4.421,
+      "ratio": 1.0413,
+      "suggested_scalar": 0.0109,
+      "log_bad": 1.4459,
+      "log_good": 1.4864
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 112.0,
+      "good": 100.0,
+      "ratio": 0.8929,
+      "suggested_scalar": -0.0306,
+      "log_bad": 4.7185,
+      "log_good": 4.6052
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6536,
+      "good": 0.5839,
+      "ratio": 0.8934,
+      "suggested_scalar": -0.0304,
+      "log_bad": -0.4253,
+      "log_good": -0.538
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7442,
+      "good": 0.6802,
+      "ratio": 0.914,
+      "suggested_scalar": -0.0242,
+      "log_bad": -0.2954,
+      "log_good": -0.3854
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 8.0833,
+      "good": 7.3333,
+      "ratio": 0.9072,
+      "suggested_scalar": -0.0263,
+      "log_bad": 2.0898,
+      "log_good": 1.9924
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 292.0,
+      "good": 384.0,
+      "ratio": 1.3151,
+      "suggested_scalar": 0.0738,
+      "log_bad": 5.6768,
+      "log_good": 5.9506
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0492,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0006,
+      "good": 0.001,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.1377,
+      "log_bad": -7.4186,
+      "log_good": -6.9078
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0833,
+      "good": 1.0,
+      "ratio": 12.0048,
+      "suggested_scalar": 0.67,
+      "log_bad": -2.4853,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0006,
+      "good": 1.0,
+      "ratio": 1666.6667,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.4186,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.7961,
+      "good": 0.9082,
+      "ratio": 1.1408,
+      "suggested_scalar": 0.0355,
+      "log_bad": -0.228,
+      "log_good": -0.0963
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 110.0,
+      "good": 137.0,
+      "ratio": 1.2455,
+      "suggested_scalar": 0.0592,
+      "log_bad": 4.7005,
+      "log_good": 4.92
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 103.9747,
+      "good": 96.4238,
+      "ratio": 0.9274,
+      "suggested_scalar": -0.0203,
+      "log_bad": 4.6441,
+      "log_good": 4.5688
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.3574,
+      "good": 0.4752,
+      "ratio": 1.3296,
+      "suggested_scalar": 0.0768,
+      "log_bad": -1.0289,
+      "log_good": -0.744
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.5752,
+      "good": 11.7235,
+      "ratio": 1.1086,
+      "suggested_scalar": 0.0278,
+      "log_bad": 2.3585,
+      "log_good": 2.4616
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1621.0,
+      "good": 1957.0,
+      "ratio": 1.2073,
+      "suggested_scalar": 0.0508,
+      "log_bad": 7.3908,
+      "log_good": 7.5792
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.3125,
+      "good": 0.2963,
+      "ratio": 0.9482,
+      "suggested_scalar": -0.0144,
+      "log_bad": -1.1632,
+      "log_good": -1.2164
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6458,
+      "good": 0.7407,
+      "ratio": 1.1469,
+      "suggested_scalar": 0.037,
+      "log_bad": -0.4373,
+      "log_good": -0.3002
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.0833,
+      "good": 7.1111,
+      "ratio": 1.169,
+      "suggested_scalar": 0.0421,
+      "log_bad": 1.8055,
+      "log_good": 1.9617
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1093,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 18.3264,
+      "good": 19.4074,
+      "ratio": 1.059,
+      "suggested_scalar": 0.0155,
+      "log_bad": 2.9083,
+      "log_good": 2.9657
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 68.0,
+      "good": 75.0,
+      "ratio": 1.1029,
+      "suggested_scalar": 0.0264,
+      "log_bad": 4.2195,
+      "log_good": 4.3175
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9326,
+      "good": 0.9557,
+      "ratio": 1.0248,
+      "suggested_scalar": 0.0066,
+      "log_bad": -0.0698,
+      "log_good": -0.0453
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 32.0,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.0174,
+      "log_bad": 3.4012,
+      "log_good": 3.4657
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5799,
+      "good": 0.6147,
+      "ratio": 1.06,
+      "suggested_scalar": 0.0157,
+      "log_bad": -0.5449,
+      "log_good": -0.4866
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.1655,
+      "good": 0.212,
+      "ratio": 1.281,
+      "suggested_scalar": 0.0668,
+      "log_bad": -1.7988,
+      "log_good": -1.5512
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3803,
+      "good": 2.5955,
+      "ratio": 1.0904,
+      "suggested_scalar": 0.0233,
+      "log_bad": 0.8672,
+      "log_good": 0.9538
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 290.0,
+      "good": 382.0,
+      "ratio": 1.3172,
+      "suggested_scalar": 0.0743,
+      "log_bad": 5.6699,
+      "log_good": 5.9454
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 34.0,
+      "good": 38.0,
+      "ratio": 1.1176,
+      "suggested_scalar": 0.03,
+      "log_bad": 3.5264,
+      "log_good": 3.6376
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0651,
+      "good": 0.0651,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.7318,
+      "log_good": -2.7318
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0,
+      "good": 5.9307,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0031,
+      "log_bad": 1.7918,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 21.0,
+      "good": 32.0,
+      "ratio": 1.5238,
+      "suggested_scalar": 0.1136,
+      "log_bad": 3.0445,
+      "log_good": 3.4657
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4541,
+      "good": 1.5231,
+      "ratio": 1.0475,
+      "suggested_scalar": 0.0125,
+      "log_bad": 0.3744,
+      "log_good": 0.4207
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.0953,
+      "good": 5.8526,
+      "ratio": 0.9602,
+      "suggested_scalar": -0.011,
+      "log_bad": 1.8075,
+      "log_good": 1.7669
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7076,
+      "good": 0.7454,
+      "ratio": 1.0534,
+      "suggested_scalar": 0.014,
+      "log_bad": -0.3459,
+      "log_good": -0.2938
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1724,
+      "good": 0.1818,
+      "ratio": 1.0545,
+      "suggested_scalar": 0.0143,
+      "log_bad": -1.7579,
+      "log_good": -1.7048
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.252,
+      "good": 3.424,
+      "ratio": 1.0529,
+      "suggested_scalar": 0.0139,
+      "log_bad": 1.1793,
+      "log_good": 1.2308
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1093,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 264.0,
+      "good": 338.0,
+      "ratio": 1.2803,
+      "suggested_scalar": 0.0666,
+      "log_bad": 5.5759,
+      "log_good": 5.823
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 5.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.247,
+      "log_bad": 0.6931,
+      "log_good": 1.6094
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6331,
+      "good": 0.7508,
+      "ratio": 1.1859,
+      "suggested_scalar": 0.046,
+      "log_bad": -0.4571,
+      "log_good": -0.2866
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 109.0,
+      "ratio": 0.9646,
+      "suggested_scalar": -0.0097,
+      "log_bad": 4.7274,
+      "log_good": 4.6913
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 710.0,
+      "good": 970.0,
+      "ratio": 1.3662,
+      "suggested_scalar": 0.0841,
+      "log_bad": 6.5653,
+      "log_good": 6.8773
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 132.0,
+      "good": 136.0,
+      "ratio": 1.0303,
+      "suggested_scalar": 0.008,
+      "log_bad": 4.8828,
+      "log_good": 4.9127
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0034,
+      "good": 0.0026,
+      "ratio": 0.7647,
+      "suggested_scalar": -0.0723,
+      "log_bad": -5.684,
+      "log_good": -5.9522
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2055,
+      "good": 0.2604,
+      "ratio": 1.2672,
+      "suggested_scalar": 0.0638,
+      "log_bad": -1.5823,
+      "log_good": -1.3455
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 44.0,
+      "good": 73.0,
+      "ratio": 1.6591,
+      "suggested_scalar": 0.1365,
+      "log_bad": 3.7842,
+      "log_good": 4.2905
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1093,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 109.0,
+      "ratio": 0.9646,
+      "suggested_scalar": -0.0097,
+      "log_bad": 4.7274,
+      "log_good": 4.6913
+    },
+    "brevity.mean_sample_size": {
+      "bad": 113.0,
+      "good": 109.0,
+      "ratio": 0.9646,
+      "suggested_scalar": -0.0097,
+      "log_bad": 4.7274,
+      "log_good": 4.6913
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 292.0,
+      "good": 384.0,
+      "ratio": 1.3151,
+      "suggested_scalar": 0.0738,
+      "log_bad": 5.6768,
+      "log_good": 5.9506
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 132.0,
+      "good": 196.0,
+      "ratio": 1.4848,
+      "suggested_scalar": 0.1066,
+      "log_bad": 4.8828,
+      "log_good": 5.2781
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 231.0,
+      "good": 274.0,
+      "ratio": 1.1861,
+      "suggested_scalar": 0.046,
+      "log_bad": 5.4424,
+      "log_good": 5.6131
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0068,
+      "good": 0.0078,
+      "ratio": 1.1471,
+      "suggested_scalar": 0.037,
+      "log_bad": -4.9908,
+      "log_good": -4.8536
+    },
+    "heaps.mean_k": {
+      "bad": 1.8047,
+      "good": 2.1722,
+      "ratio": 1.2036,
+      "suggested_scalar": 0.05,
+      "log_bad": 0.5904,
+      "log_good": 0.7757
+    },
+    "halstead.mean_effort": {
+      "bad": 45859.9879,
+      "good": 72072.5519,
+      "ratio": 1.5716,
+      "suggested_scalar": 0.1219,
+      "log_bad": 10.7333,
+      "log_good": 11.1854
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8937,
+      "good": 0.8647,
+      "ratio": 0.9676,
+      "suggested_scalar": -0.0089,
+      "log_bad": -0.1124,
+      "log_good": -0.1454
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 82.0,
+      "good": 68.0,
+      "ratio": 0.8293,
+      "suggested_scalar": -0.0505,
+      "log_bad": 4.4067,
+      "log_good": 4.2195
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 147.0,
+      "good": 203.0,
+      "ratio": 1.381,
+      "suggested_scalar": 0.087,
+      "log_bad": 4.9904,
+      "log_good": 5.3132
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.6364,
+      "good": 0.4745,
+      "ratio": 0.7456,
+      "suggested_scalar": -0.0791,
+      "log_bad": -0.4519,
+      "log_good": -0.7455
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.4545,
+      "good": 7.0803,
+      "ratio": 1.097,
+      "suggested_scalar": 0.0249,
+      "log_bad": 1.8648,
+      "log_good": 1.9573
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1724,
+      "good": 0.1818,
+      "ratio": 1.0545,
+      "suggested_scalar": 0.0143,
+      "log_bad": -1.7579,
+      "log_good": -1.7048
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.4333,
+      "good": 3.284,
+      "ratio": 1.3496,
+      "suggested_scalar": 0.0808,
+      "log_bad": 0.8892,
+      "log_good": 1.1891
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 291.0,
+      "good": 383.0,
+      "ratio": 1.3162,
+      "suggested_scalar": 0.0741,
+      "log_bad": 5.6733,
+      "log_good": 5.948
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 6.0,
+      "ratio": 6.0,
+      "suggested_scalar": 0.483,
+      "log_bad": 0.0,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 22.0,
+      "good": 37.0,
+      "ratio": 1.6818,
+      "suggested_scalar": 0.1402,
+      "log_bad": 3.091,
+      "log_good": 3.6109
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2547.7771,
+      "good": 4004.0307,
+      "ratio": 1.5716,
+      "suggested_scalar": 0.1219,
+      "log_bad": 7.843,
+      "log_good": 8.2951
+    },
+    "readability.mean_total_lines": {
+      "bad": 48.0,
+      "good": 54.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0318,
+      "log_bad": 3.8712,
+      "log_good": 3.989
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 1899.252,
+      "good": 2252.2672,
+      "ratio": 1.1859,
+      "suggested_scalar": 0.046,
+      "log_bad": 7.5492,
+      "log_good": 7.7197
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 681.0,
+      "good": 754.0,
+      "ratio": 1.1072,
+      "suggested_scalar": 0.0275,
+      "log_bad": 6.5236,
+      "log_good": 6.6254
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.4375,
+      "good": 35.0185,
+      "ratio": 1.0796,
+      "suggested_scalar": 0.0206,
+      "log_bad": 3.4793,
+      "log_good": 3.5559
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1429,
+      "good": 1.2198,
+      "ratio": 1.0673,
+      "suggested_scalar": 0.0176,
+      "log_bad": 0.1336,
+      "log_good": 0.1987
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0492,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 14.0,
+      "good": 26.0,
+      "ratio": 1.8571,
+      "suggested_scalar": 0.1669,
+      "log_bad": 2.6391,
+      "log_good": 3.2581
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 1.0,
+      "ratio": 0.25,
+      "suggested_scalar": -0.3737,
+      "log_bad": 1.3863,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9167,
+      "good": 0.8905,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.0078,
+      "log_bad": -0.087,
+      "log_good": -0.116
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9937,
+      "good": 0.9911,
+      "ratio": 0.9974,
+      "suggested_scalar": -0.0007,
+      "log_bad": -0.0063,
+      "log_good": -0.0089
+    },
+    "halstead.mean_length": {
+      "bad": 279.0,
+      "good": 339.0,
+      "ratio": 1.2151,
+      "suggested_scalar": 0.0525,
+      "log_bad": 5.6312,
+      "log_good": 5.826
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 16.3333,
+      "good": 22.5,
+      "ratio": 1.3776,
+      "suggested_scalar": 0.0864,
+      "log_bad": 2.7932,
+      "log_good": 3.1135
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8202,
+      "good": 6.7682,
+      "ratio": 0.9924,
+      "suggested_scalar": -0.0021,
+      "log_bad": 1.9199,
+      "log_good": 1.9122
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0817,
+      "good": 0.1002,
+      "ratio": 1.2264,
+      "suggested_scalar": 0.055,
+      "log_bad": -2.5047,
+      "log_good": -2.3006
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 24.1463,
+      "good": 32.0,
+      "ratio": 1.3253,
+      "suggested_scalar": 0.0759,
+      "log_bad": 3.1841,
+      "log_good": 3.4657
+    },
+    "branching.mean_branch_count": {
+      "bad": 15.0,
+      "good": 16.0,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.0174,
+      "log_bad": 2.7081,
+      "log_good": 2.7726
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 70.0,
+      "good": 65.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.02,
+      "log_bad": 4.2485,
+      "log_good": 4.1744
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8095,
+      "good": 0.7336,
+      "ratio": 0.9062,
+      "suggested_scalar": -0.0265,
+      "log_bad": -0.2113,
+      "log_good": -0.3098
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 48.0,
+      "good": 54.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0318,
+      "log_bad": 3.8712,
+      "log_good": 3.989
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 16.0,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.0174,
+      "log_bad": 2.7081,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.minimizes_data_in_messages": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0165,
+      "good": 0.0356,
+      "ratio": 2.1576,
+      "suggested_scalar": 0.2073,
+      "log_bad": -4.1044,
+      "log_good": -3.3354
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1667,
+      "good": 1.1667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1542,
+      "log_good": 0.1542
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8571,
+      "good": 0.7885,
+      "ratio": 0.92,
+      "suggested_scalar": -0.0225,
+      "log_bad": -0.1542,
+      "log_good": -0.2376
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0094,
+      "good": 0.0356,
+      "ratio": 3.7872,
+      "suggested_scalar": 0.359,
+      "log_bad": -4.667,
+      "log_good": -3.3354
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7957,
+      "good": 4.761,
+      "ratio": 0.9928,
+      "suggested_scalar": -0.002,
+      "log_bad": 1.5677,
+      "log_good": 1.5605
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 63.0,
+      "good": 93.0,
+      "ratio": 1.4762,
+      "suggested_scalar": 0.105,
+      "log_bad": 4.1431,
+      "log_good": 4.5326
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6375,
+      "good": 0.5974,
+      "ratio": 0.9371,
+      "suggested_scalar": -0.0175,
+      "log_bad": -0.4502,
+      "log_good": -0.5152
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 18.0,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.0154,
+      "log_bad": 2.8332,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7271,
+      "good": 0.6925,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0131,
+      "log_bad": -0.3187,
+      "log_good": -0.3674
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.7857,
+      "good": 2.4231,
+      "ratio": 0.8698,
+      "suggested_scalar": -0.0376,
+      "log_bad": 1.0245,
+      "log_good": 0.885
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 425.0,
+      "good": 365.0,
+      "ratio": 0.8588,
+      "suggested_scalar": -0.041,
+      "log_bad": 6.0521,
+      "log_good": 5.8999
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1093,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 0.0006,
+      "ratio": 0.0006,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -7.4186
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1964,
+      "good": 0.0577,
+      "ratio": 0.2938,
+      "suggested_scalar": -0.3302,
+      "log_bad": -1.6276,
+      "log_good": -2.8525
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9165,
+      "good": 0.8573,
+      "ratio": 0.9354,
+      "suggested_scalar": -0.018,
+      "log_bad": -0.0872,
+      "log_good": -0.154
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 180.0,
+      "good": 164.0,
+      "ratio": 0.9111,
+      "suggested_scalar": -0.0251,
+      "log_bad": 5.193,
+      "log_good": 5.0999
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 103.7248,
+      "good": 99.3657,
+      "ratio": 0.958,
+      "suggested_scalar": -0.0116,
+      "log_bad": 4.6417,
+      "log_good": 4.5988
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5071,
+      "good": 0.478,
+      "ratio": 0.9426,
+      "suggested_scalar": -0.0159,
+      "log_bad": -0.679,
+      "log_good": -0.7381
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.0497,
+      "good": 10.7836,
+      "ratio": 0.9759,
+      "suggested_scalar": -0.0066,
+      "log_bad": 2.4024,
+      "log_good": 2.378
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1933.0,
+      "good": 1728.0,
+      "ratio": 0.8939,
+      "suggested_scalar": -0.0302,
+      "log_bad": 7.5668,
+      "log_good": 7.4547
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0179,
+      "good": 0.0962,
+      "ratio": 5.3743,
+      "suggested_scalar": 0.4534,
+      "log_bad": -4.023,
+      "log_good": -2.3413
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8393,
+      "good": 0.7692,
+      "ratio": 0.9165,
+      "suggested_scalar": -0.0235,
+      "log_bad": -0.1752,
+      "log_good": -0.2624
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.4444,
+      "good": 7.449,
+      "ratio": 0.7887,
+      "suggested_scalar": -0.064,
+      "log_bad": 2.2454,
+      "log_good": 2.0081
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.5255,
+      "good": 1.7441,
+      "ratio": 0.6906,
+      "suggested_scalar": -0.0998,
+      "log_bad": 0.9264,
+      "log_good": 0.5562
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 130.0,
+      "good": 124.0,
+      "ratio": 0.9538,
+      "suggested_scalar": -0.0127,
+      "log_bad": 4.8675,
+      "log_good": 4.8203
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9441,
+      "good": 0.9503,
+      "ratio": 1.0066,
+      "suggested_scalar": 0.0018,
+      "log_bad": -0.0575,
+      "log_good": -0.051
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 30.0,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.0386,
+      "log_bad": 3.2581,
+      "log_good": 3.4012
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5804,
+      "good": 0.57,
+      "ratio": 0.9821,
+      "suggested_scalar": -0.0049,
+      "log_bad": -0.544,
+      "log_good": -0.5621
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2884,
+      "good": 0.2727,
+      "ratio": 0.9456,
+      "suggested_scalar": -0.0151,
+      "log_bad": -1.2434,
+      "log_good": -1.2994
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3835,
+      "good": 2.3257,
+      "ratio": 0.9757,
+      "suggested_scalar": -0.0066,
+      "log_bad": 0.8686,
+      "log_good": 0.844
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 423.0,
+      "good": 363.0,
+      "ratio": 0.8582,
+      "suggested_scalar": -0.0412,
+      "log_bad": 6.0474,
+      "log_good": 5.8944
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0188,
+      "good": 0.0082,
+      "ratio": 0.4362,
+      "suggested_scalar": -0.2237,
+      "log_bad": -3.9739,
+      "log_good": -4.8036
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0,
+      "good": 5.9773,
+      "ratio": 0.9962,
+      "suggested_scalar": -0.001,
+      "log_bad": 1.7918,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 46.0,
+      "good": 36.0,
+      "ratio": 0.7826,
+      "suggested_scalar": -0.0661,
+      "log_bad": 3.8286,
+      "log_good": 3.5835
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9641,
+      "good": 0.9159,
+      "ratio": 0.95,
+      "suggested_scalar": -0.0138,
+      "log_bad": -0.0366,
+      "log_good": -0.0878
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.1249,
+      "good": 6.0846,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0018,
+      "log_bad": 1.8124,
+      "log_good": 1.8058
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7993,
+      "good": 0.7965,
+      "ratio": 0.9965,
+      "suggested_scalar": -0.0009,
+      "log_bad": -0.224,
+      "log_good": -0.2275
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1642,
+      "good": 0.1475,
+      "ratio": 0.8983,
+      "suggested_scalar": -0.0289,
+      "log_bad": -1.8067,
+      "log_good": -1.9139
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.3241,
+      "good": 3.2838,
+      "ratio": 0.9879,
+      "suggested_scalar": -0.0033,
+      "log_bad": 1.2012,
+      "log_good": 1.189
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.1869,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 352.0,
+      "good": 306.0,
+      "ratio": 0.8693,
+      "suggested_scalar": -0.0378,
+      "log_bad": 5.8636,
+      "log_good": 5.7236
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.4961,
+      "good": 0.5842,
+      "ratio": 1.1776,
+      "suggested_scalar": 0.0441,
+      "log_bad": -0.701,
+      "log_good": -0.5375
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 130.0,
+      "good": 123.0,
+      "ratio": 0.9462,
+      "suggested_scalar": -0.0149,
+      "log_bad": 4.8675,
+      "log_good": 4.8122
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1137.0,
+      "good": 1075.0,
+      "ratio": 0.9455,
+      "suggested_scalar": -0.0151,
+      "log_bad": 7.0361,
+      "log_good": 6.9801
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 55.0,
+      "good": 113.0,
+      "ratio": 2.0545,
+      "suggested_scalar": 0.1941,
+      "log_bad": 4.0073,
+      "log_good": 4.7274
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0047,
+      "good": 0.0027,
+      "ratio": 0.5745,
+      "suggested_scalar": -0.1494,
+      "log_bad": -5.3602,
+      "log_good": -5.9145
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2259,
+      "good": 0.2164,
+      "ratio": 0.9579,
+      "suggested_scalar": -0.0116,
+      "log_bad": -1.4877,
+      "log_good": -1.5306
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 74.0,
+      "good": 63.0,
+      "ratio": 0.8514,
+      "suggested_scalar": -0.0434,
+      "log_bad": 4.3041,
+      "log_good": 4.1431
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 130.0,
+      "good": 123.0,
+      "ratio": 0.9462,
+      "suggested_scalar": -0.0149,
+      "log_bad": 4.8675,
+      "log_good": 4.8122
+    },
+    "brevity.mean_sample_size": {
+      "bad": 130.0,
+      "good": 123.0,
+      "ratio": 0.9462,
+      "suggested_scalar": -0.0149,
+      "log_bad": 4.8675,
+      "log_good": 4.8122
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 425.0,
+      "good": 365.0,
+      "ratio": 0.8588,
+      "suggested_scalar": -0.041,
+      "log_bad": 6.0521,
+      "log_good": 5.8999
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 186.0,
+      "good": 155.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0492,
+      "log_bad": 5.2257,
+      "log_good": 5.0434
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 283.0,
+      "good": 253.0,
+      "ratio": 0.894,
+      "suggested_scalar": -0.0302,
+      "log_bad": 5.6454,
+      "log_good": 5.5334
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0047,
+      "good": 1.0,
+      "ratio": 212.766,
+      "suggested_scalar": 1.4451,
+      "log_bad": -5.3602,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.7471,
+      "good": 2.2035,
+      "ratio": 1.2612,
+      "suggested_scalar": 0.0626,
+      "log_bad": 0.558,
+      "log_good": 0.79
+    },
+    "halstead.mean_effort": {
+      "bad": 28761.2171,
+      "good": 47150.4489,
+      "ratio": 1.6394,
+      "suggested_scalar": 0.1333,
+      "log_bad": 10.2668,
+      "log_good": 10.7611
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8722,
+      "good": 0.8764,
+      "ratio": 1.0048,
+      "suggested_scalar": 0.0013,
+      "log_bad": -0.1367,
+      "log_good": -0.1319
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 37.0,
+      "good": 63.0,
+      "ratio": 1.7027,
+      "suggested_scalar": 0.1435,
+      "log_bad": 3.6109,
+      "log_good": 4.1431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 194.0,
+      "good": 155.0,
+      "ratio": 0.799,
+      "suggested_scalar": -0.0605,
+      "log_bad": 5.2679,
+      "log_good": 5.0434
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5222,
+      "good": 0.5183,
+      "ratio": 0.9925,
+      "suggested_scalar": -0.002,
+      "log_bad": -0.6497,
+      "log_good": -0.6572
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.3167,
+      "good": 6.5549,
+      "ratio": 1.0377,
+      "suggested_scalar": 0.01,
+      "log_bad": 1.8432,
+      "log_good": 1.8802
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1642,
+      "good": 0.1475,
+      "ratio": 0.8983,
+      "suggested_scalar": -0.0289,
+      "log_bad": -1.8067,
+      "log_good": -1.9139
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.7778,
+      "good": 2.9796,
+      "ratio": 0.7887,
+      "suggested_scalar": -0.064,
+      "log_bad": 1.3291,
+      "log_good": 1.0918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 424.0,
+      "good": 364.0,
+      "ratio": 0.8585,
+      "suggested_scalar": -0.0411,
+      "log_bad": 6.0497,
+      "log_good": 5.8972
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1869,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 51.0,
+      "good": 42.0,
+      "ratio": 0.8235,
+      "suggested_scalar": -0.0523,
+      "log_bad": 3.9318,
+      "log_good": 3.7377
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1597.8454,
+      "good": 2619.4694,
+      "ratio": 1.6394,
+      "suggested_scalar": 0.1333,
+      "log_bad": 7.3764,
+      "log_good": 7.8707
+    },
+    "readability.mean_total_lines": {
+      "bad": 45.0,
+      "good": 49.0,
+      "ratio": 1.0889,
+      "suggested_scalar": 0.023,
+      "log_bad": 3.8067,
+      "log_good": 3.8918
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 1488.3427,
+      "good": 1752.4946,
+      "ratio": 1.1775,
+      "suggested_scalar": 0.044,
+      "log_bad": 7.3054,
+      "log_good": 7.4688
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 811.0,
+      "good": 743.0,
+      "ratio": 0.9162,
+      "suggested_scalar": -0.0236,
+      "log_bad": 6.6983,
+      "log_good": 6.6107
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 26.0667,
+      "good": 30.5102,
+      "ratio": 1.1705,
+      "suggested_scalar": 0.0424,
+      "log_bad": 3.2607,
+      "log_good": 3.4181
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1055,
+      "good": 1.181,
+      "ratio": 1.0683,
+      "suggested_scalar": 0.0178,
+      "log_bad": 0.1003,
+      "log_good": 0.1664
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1093,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 28.0,
+      "good": 23.0,
+      "ratio": 0.8214,
+      "suggested_scalar": -0.053,
+      "log_bad": 3.3322,
+      "log_good": 3.1355
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 11.0,
+      "good": 3.0,
+      "ratio": 0.2727,
+      "suggested_scalar": -0.3503,
+      "log_bad": 2.3979,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8551,
+      "good": 0.8627,
+      "ratio": 1.0089,
+      "suggested_scalar": 0.0024,
+      "log_bad": -0.1565,
+      "log_good": -0.1477
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.1377,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9871,
+      "good": 0.9806,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0018,
+      "log_bad": -0.013,
+      "log_good": -0.0196
+    },
+    "halstead.mean_length": {
+      "bad": 249.0,
+      "good": 268.0,
+      "ratio": 1.0763,
+      "suggested_scalar": 0.0198,
+      "log_bad": 5.5175,
+      "log_good": 5.591
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.5,
+      "good": 8.1667,
+      "ratio": 0.8597,
+      "suggested_scalar": -0.0408,
+      "log_bad": 2.2513,
+      "log_good": 2.1001
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.0224,
+      "good": 6.9425,
+      "ratio": 0.9886,
+      "suggested_scalar": -0.0031,
+      "log_bad": 1.9491,
+      "log_good": 1.9377
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0963,
+      "good": 0.0899,
+      "ratio": 0.9335,
+      "suggested_scalar": -0.0185,
+      "log_bad": -2.3403,
+      "log_good": -2.4091
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 19.3243,
+      "good": 26.9048,
+      "ratio": 1.3923,
+      "suggested_scalar": 0.0892,
+      "log_bad": 2.9614,
+      "log_good": 3.2923
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 0.4339,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 94.0,
+      "good": 85.0,
+      "ratio": 0.9043,
+      "suggested_scalar": -0.0271,
+      "log_bad": 4.5433,
+      "log_good": 4.4427
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7385,
+      "good": 0.751,
+      "ratio": 1.0169,
+      "suggested_scalar": 0.0045,
+      "log_bad": -0.3031,
+      "log_good": -0.2863
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 56.0,
+      "good": 52.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.02,
+      "log_bad": 4.0254,
+      "log_good": 3.9512
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_blocking_on_async_code": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 10.0,
+      "good": 7.0,
+      "ratio": 0.7,
+      "suggested_scalar": -0.2798,
+      "log_bad": 2.3026,
+      "log_good": 1.9459
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0133,
+      "good": 0.0122,
+      "ratio": 0.9173,
+      "suggested_scalar": -0.0677,
+      "log_bad": -4.32,
+      "log_good": -4.4063
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.8,
+      "good": 0.75,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0506,
+      "log_bad": -0.2231,
+      "log_good": -0.2877
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7656,
+      "good": 0.7885,
+      "ratio": 1.0299,
+      "suggested_scalar": 0.0231,
+      "log_bad": -0.2671,
+      "log_good": -0.2376
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0133,
+      "good": 0.0122,
+      "ratio": 0.9173,
+      "suggested_scalar": -0.0677,
+      "log_bad": -4.32,
+      "log_good": -4.4063
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4702,
+      "good": 4.472,
+      "ratio": 1.0004,
+      "suggested_scalar": 0.0003,
+      "log_bad": 1.4974,
+      "log_good": 1.4978
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 106.0,
+      "good": 82.0,
+      "ratio": 0.7736,
+      "suggested_scalar": -0.2014,
+      "log_bad": 4.6634,
+      "log_good": 4.4067
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5577,
+      "good": 0.4888,
+      "ratio": 0.8765,
+      "suggested_scalar": -0.1034,
+      "log_bad": -0.5839,
+      "log_good": -0.7158
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0541,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7492,
+      "good": 0.7336,
+      "ratio": 0.9792,
+      "suggested_scalar": -0.0165,
+      "log_bad": -0.2887,
+      "log_good": -0.3098
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 9.5,
+      "good": 9.0,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.0424,
+      "log_bad": 2.2513,
+      "log_good": 2.1972
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 450.0,
+      "good": 327.0,
+      "ratio": 0.7267,
+      "suggested_scalar": -0.2504,
+      "log_bad": 6.1092,
+      "log_good": 5.79
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0781,
+      "good": 1.0,
+      "ratio": 12.8041,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.5498,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0015,
+      "good": 0.002,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.2257,
+      "log_bad": -6.5023,
+      "log_good": -6.2146
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9691,
+      "good": 0.9747,
+      "ratio": 1.0058,
+      "suggested_scalar": 0.0045,
+      "log_bad": -0.0314,
+      "log_good": -0.0256
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 169.0,
+      "good": 107.0,
+      "ratio": 0.6331,
+      "suggested_scalar": -0.3585,
+      "log_bad": 5.1299,
+      "log_good": 4.6728
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 91.2565,
+      "good": 85.483,
+      "ratio": 0.9367,
+      "suggested_scalar": -0.0513,
+      "log_bad": 4.5137,
+      "log_good": 4.4483
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6303,
+      "good": 0.5092,
+      "ratio": 0.8079,
+      "suggested_scalar": -0.1674,
+      "log_bad": -0.4616,
+      "log_good": -0.6749
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 15.6682,
+      "good": 18.9452,
+      "ratio": 1.2091,
+      "suggested_scalar": 0.149,
+      "log_bad": 2.7516,
+      "log_good": 2.9416
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2673.0,
+      "good": 2016.0,
+      "ratio": 0.7542,
+      "suggested_scalar": -0.2213,
+      "log_bad": 7.891,
+      "log_good": 7.6089
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0469,
+      "good": 0.0577,
+      "ratio": 1.2303,
+      "suggested_scalar": 0.1626,
+      "log_bad": -3.0597,
+      "log_good": -2.8525
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6719,
+      "good": 0.6731,
+      "ratio": 1.0018,
+      "suggested_scalar": 0.0014,
+      "log_bad": -0.3976,
+      "log_good": -0.3959
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.0313,
+      "good": 6.2885,
+      "ratio": 0.8944,
+      "suggested_scalar": -0.0876,
+      "log_bad": 1.9504,
+      "log_good": 1.8387
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 12.0,
+      "good": 10.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.143,
+      "log_bad": 2.4849,
+      "log_good": 2.3026
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 19.25,
+      "good": 20.8462,
+      "ratio": 1.0829,
+      "suggested_scalar": 0.0625,
+      "log_bad": 2.9575,
+      "log_good": 3.0372
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 65.0,
+      "good": 30.0,
+      "ratio": 0.4615,
+      "suggested_scalar": -0.6065,
+      "log_bad": 4.1744,
+      "log_good": 3.4012
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9575,
+      "good": 0.9398,
+      "ratio": 0.9815,
+      "suggested_scalar": -0.0146,
+      "log_bad": -0.0434,
+      "log_good": -0.0621
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6988,
+      "good": 0.6756,
+      "ratio": 0.9668,
+      "suggested_scalar": -0.0265,
+      "log_bad": -0.3584,
+      "log_good": -0.3922
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4844,
+      "good": 0.3446,
+      "ratio": 0.7114,
+      "suggested_scalar": -0.2671,
+      "log_bad": -0.7248,
+      "log_good": -1.0654
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.3205,
+      "good": 3.0826,
+      "ratio": 0.9284,
+      "suggested_scalar": -0.0583,
+      "log_bad": 1.2001,
+      "log_good": 1.1258
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 448.0,
+      "good": 325.0,
+      "ratio": 0.7254,
+      "suggested_scalar": -0.2518,
+      "log_bad": 6.1048,
+      "log_good": 5.7838
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0541,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9773,
+      "good": 5.9773,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.788,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 82.0,
+      "good": 60.0,
+      "ratio": 0.7317,
+      "suggested_scalar": -0.245,
+      "log_bad": 4.4067,
+      "log_good": 4.0943
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.5487,
+      "good": 1.5593,
+      "ratio": 1.0068,
+      "suggested_scalar": 0.0054,
+      "log_bad": 0.4374,
+      "log_good": 0.4442
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8246,
+      "good": 5.5978,
+      "ratio": 0.9611,
+      "suggested_scalar": -0.0312,
+      "log_bad": 1.7621,
+      "log_good": 1.7224
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7479,
+      "good": 0.7482,
+      "ratio": 1.0004,
+      "suggested_scalar": 0.0003,
+      "log_bad": -0.2905,
+      "log_good": -0.2901
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1351,
+      "good": 0.1475,
+      "ratio": 1.0918,
+      "suggested_scalar": 0.0689,
+      "log_bad": -2.0017,
+      "log_good": -1.9139
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.9583,
+      "good": 4.3526,
+      "ratio": 1.0996,
+      "suggested_scalar": 0.0745,
+      "log_bad": 1.3758,
+      "log_good": 1.4708
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 322.0,
+      "good": 255.0,
+      "ratio": 0.7919,
+      "suggested_scalar": -0.183,
+      "log_bad": 5.7746,
+      "log_good": 5.5413
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 23.0,
+      "good": 18.0,
+      "ratio": 0.7826,
+      "suggested_scalar": -0.1923,
+      "log_bad": 3.1355,
+      "log_good": 2.8904
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9442,
+      "good": 0.6464,
+      "ratio": 0.6846,
+      "suggested_scalar": -0.2972,
+      "log_bad": -0.0574,
+      "log_good": -0.4363
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 109.0,
+      "good": 85.0,
+      "ratio": 0.7798,
+      "suggested_scalar": -0.1951,
+      "log_bad": 4.6913,
+      "log_good": 4.4427
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1399.0,
+      "good": 992.0,
+      "ratio": 0.7091,
+      "suggested_scalar": -0.2697,
+      "log_bad": 7.2435,
+      "log_good": 6.8997
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 190.0,
+      "good": 125.0,
+      "ratio": 0.6579,
+      "suggested_scalar": -0.3284,
+      "log_bad": 5.247,
+      "log_good": 4.8283
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2622,
+      "good": 0.2783,
+      "ratio": 1.0614,
+      "suggested_scalar": 0.0467,
+      "log_bad": -1.3386,
+      "log_good": -1.2791
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 96.0,
+      "good": 51.0,
+      "ratio": 0.5313,
+      "suggested_scalar": -0.4961,
+      "log_bad": 4.5643,
+      "log_good": 3.9318
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.175,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 109.0,
+      "good": 85.0,
+      "ratio": 0.7798,
+      "suggested_scalar": -0.1951,
+      "log_bad": 4.6913,
+      "log_good": 4.4427
+    },
+    "brevity.mean_sample_size": {
+      "bad": 109.0,
+      "good": 85.0,
+      "ratio": 0.7798,
+      "suggested_scalar": -0.1951,
+      "log_bad": 4.6913,
+      "log_good": 4.4427
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 450.0,
+      "good": 327.0,
+      "ratio": 0.7267,
+      "suggested_scalar": -0.2504,
+      "log_bad": 6.1092,
+      "log_good": 5.79
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 230.0,
+      "good": 171.0,
+      "ratio": 0.7435,
+      "suggested_scalar": -0.2325,
+      "log_bad": 5.4381,
+      "log_good": 5.1417
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 262.0,
+      "good": 211.0,
+      "ratio": 0.8053,
+      "suggested_scalar": -0.1698,
+      "log_bad": 5.5683,
+      "log_good": 5.3519
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.3538,
+      "good": 1.3721,
+      "ratio": 1.0135,
+      "suggested_scalar": 0.0105,
+      "log_bad": 0.3029,
+      "log_good": 0.3163
+    },
+    "halstead.mean_effort": {
+      "bad": 66479.3735,
+      "good": 41721.435,
+      "ratio": 0.6276,
+      "suggested_scalar": -0.3654,
+      "log_bad": 11.1046,
+      "log_good": 10.6388
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8606,
+      "good": 0.8734,
+      "ratio": 1.0149,
+      "suggested_scalar": 0.0116,
+      "log_bad": -0.1501,
+      "log_good": -0.1354
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 85.0,
+      "good": 61.0,
+      "ratio": 0.7176,
+      "suggested_scalar": -0.2602,
+      "log_bad": 4.4427,
+      "log_good": 4.1109
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 231.0,
+      "good": 180.0,
+      "ratio": 0.7792,
+      "suggested_scalar": -0.1957,
+      "log_bad": 5.4424,
+      "log_good": 5.193
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4497,
+      "good": 0.4953,
+      "ratio": 1.1014,
+      "suggested_scalar": 0.0758,
+      "log_bad": -0.7992,
+      "log_good": -0.7026
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.2781,
+      "good": 9.271,
+      "ratio": 1.1199,
+      "suggested_scalar": 0.0889,
+      "log_bad": 2.1136,
+      "log_good": 2.2269
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1351,
+      "good": 0.1475,
+      "ratio": 1.0918,
+      "suggested_scalar": 0.0689,
+      "log_bad": -2.0017,
+      "log_good": -1.9139
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.0852,
+      "good": 5.3359,
+      "ratio": 1.3062,
+      "suggested_scalar": 0.2095,
+      "log_bad": 1.4074,
+      "log_good": 1.6745
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 449.0,
+      "good": 326.0,
+      "ratio": 0.7261,
+      "suggested_scalar": -0.2511,
+      "log_bad": 6.107,
+      "log_good": 5.7869
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 8.0,
+      "good": 7.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.1047,
+      "log_bad": 2.0794,
+      "log_good": 1.9459
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 91.0,
+      "good": 42.0,
+      "ratio": 0.4615,
+      "suggested_scalar": -0.6065,
+      "log_bad": 4.5109,
+      "log_good": 3.7377
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3693.2985,
+      "good": 2317.8575,
+      "ratio": 0.6276,
+      "suggested_scalar": -0.3654,
+      "log_bad": 8.2143,
+      "log_good": 7.7484
+    },
+    "readability.mean_total_lines": {
+      "bad": 64.0,
+      "good": 52.0,
+      "ratio": 0.8125,
+      "suggested_scalar": -0.1629,
+      "log_bad": 4.1589,
+      "log_good": 3.9512
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2832.4545,
+      "good": 1939.0534,
+      "ratio": 0.6846,
+      "suggested_scalar": -0.2972,
+      "log_bad": 7.9489,
+      "log_good": 7.57
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 805.0,
+      "good": 654.0,
+      "ratio": 0.8124,
+      "suggested_scalar": -0.1629,
+      "log_bad": 6.6908,
+      "log_good": 6.4831
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 40.6094,
+      "good": 37.5962,
+      "ratio": 0.9258,
+      "suggested_scalar": -0.0605,
+      "log_bad": 3.704,
+      "log_good": 3.6269
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2818,
+      "good": 1.359,
+      "ratio": 1.0602,
+      "suggested_scalar": 0.0459,
+      "log_bad": 0.2483,
+      "log_good": 0.3067
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 42.0,
+      "good": 25.0,
+      "ratio": 0.5952,
+      "suggested_scalar": -0.4069,
+      "log_bad": 3.7377,
+      "log_good": 3.2189
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 1.0,
+      "ratio": 0.2,
+      "suggested_scalar": -1.2624,
+      "log_bad": 1.6094,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7174,
+      "good": 0.8353,
+      "ratio": 1.1643,
+      "suggested_scalar": 0.1194,
+      "log_bad": -0.3321,
+      "log_good": -0.18
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9712,
+      "good": 0.9699,
+      "ratio": 0.9987,
+      "suggested_scalar": -0.0011,
+      "log_bad": -0.0292,
+      "log_good": -0.0306
+    },
+    "halstead.mean_length": {
+      "bad": 421.0,
+      "good": 305.0,
+      "ratio": 0.7245,
+      "suggested_scalar": -0.2528,
+      "log_bad": 6.0426,
+      "log_good": 5.7203
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.2,
+      "good": 10.75,
+      "ratio": 0.9598,
+      "suggested_scalar": -0.0322,
+      "log_bad": 2.4159,
+      "log_good": 2.3749
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7682,
+      "good": 6.4094,
+      "ratio": 0.947,
+      "suggested_scalar": -0.0427,
+      "log_bad": 1.9122,
+      "log_good": 1.8578
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.086,
+      "good": 0.0848,
+      "ratio": 0.986,
+      "suggested_scalar": -0.011,
+      "log_bad": -2.4534,
+      "log_good": -2.4675
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 23.4706,
+      "good": 21.5164,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0682,
+      "log_bad": 3.1557,
+      "log_good": 3.0688
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 76.0,
+      "good": 53.0,
+      "ratio": 0.6974,
+      "suggested_scalar": -0.2827,
+      "log_bad": 4.3307,
+      "log_good": 3.9703
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6336,
+      "good": 0.7583,
+      "ratio": 1.1968,
+      "suggested_scalar": 0.1409,
+      "log_bad": -0.4563,
+      "log_good": -0.2767
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 64.0,
+      "good": 52.0,
+      "ratio": 0.8125,
+      "suggested_scalar": -0.1629,
+      "log_bad": 4.1589,
+      "log_good": 3.9512
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "testing.test_name_describes_behavior": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 30.0,
+      "good": 33.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0868,
+      "log_bad": 3.4012,
+      "log_good": 3.4965
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0776,
+      "good": 0.0664,
+      "ratio": 0.8557,
+      "suggested_scalar": -0.1419,
+      "log_bad": -2.5562,
+      "log_good": -2.7121
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.25,
+      "good": 1.25,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2231,
+      "log_good": 0.2231
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8,
+      "good": 0.7692,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0357,
+      "log_bad": -0.2231,
+      "log_good": -0.2624
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0776,
+      "good": 0.0664,
+      "ratio": 0.8557,
+      "suggested_scalar": -0.1419,
+      "log_bad": -2.5562,
+      "log_good": -2.7121
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7211,
+      "good": 4.6333,
+      "ratio": 0.9814,
+      "suggested_scalar": -0.0171,
+      "log_bad": 1.552,
+      "log_good": 1.5333
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 53.0,
+      "good": 68.0,
+      "ratio": 1.283,
+      "suggested_scalar": 0.2268,
+      "log_bad": 3.9703,
+      "log_good": 4.2195
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3711,
+      "good": 0.3739,
+      "ratio": 1.0075,
+      "suggested_scalar": 0.0068,
+      "log_bad": -0.9913,
+      "log_good": -0.9838
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 12.0,
+      "good": 13.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.0729,
+      "log_bad": 2.4849,
+      "log_good": 2.5649
+    },
+    "heaps.mean_beta": {
+      "bad": 0.4599,
+      "good": 0.4653,
+      "ratio": 1.0117,
+      "suggested_scalar": 0.0106,
+      "log_bad": -0.7767,
+      "log_good": -0.7651
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.2,
+      "good": 3.3077,
+      "ratio": 1.5035,
+      "suggested_scalar": 0.3712,
+      "log_bad": 0.7885,
+      "log_good": 1.1963
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 425.0,
+      "good": 572.0,
+      "ratio": 1.3459,
+      "suggested_scalar": 0.2704,
+      "log_bad": 6.0521,
+      "log_good": 6.3491
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.2417,
+      "good": 1.2398,
+      "ratio": 0.9985,
+      "suggested_scalar": -0.0014,
+      "log_bad": 0.2165,
+      "log_good": 0.215
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 134.0,
+      "good": 187.0,
+      "ratio": 1.3955,
+      "suggested_scalar": 0.3034,
+      "log_bad": 4.8978,
+      "log_good": 5.2311
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 102.6188,
+      "good": 102.3517,
+      "ratio": 0.9974,
+      "suggested_scalar": -0.0024,
+      "log_bad": 4.631,
+      "log_good": 4.6284
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.8396,
+      "good": 0.8214,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.0199,
+      "log_bad": -0.1748,
+      "log_good": -0.1967
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.1671,
+      "good": 13.178,
+      "ratio": 1.0008,
+      "suggested_scalar": 0.0008,
+      "log_bad": 2.5777,
+      "log_good": 2.5785
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1468.0,
+      "good": 2162.0,
+      "ratio": 1.4728,
+      "suggested_scalar": 0.3524,
+      "log_bad": 7.2917,
+      "log_good": 7.6788
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 0.1731,
+      "ratio": 0.1731,
+      "suggested_scalar": -1.5965,
+      "log_bad": 0.0,
+      "log_good": -1.7539
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.775,
+      "good": 0.7308,
+      "ratio": 0.943,
+      "suggested_scalar": -0.0535,
+      "log_bad": -0.2549,
+      "log_good": -0.3136
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.625,
+      "good": 11.0,
+      "ratio": 1.0353,
+      "suggested_scalar": 0.0316,
+      "log_bad": 2.3632,
+      "log_good": 2.3979
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.16,
+      "good": 3.0592,
+      "ratio": 2.6372,
+      "suggested_scalar": 0.8827,
+      "log_bad": 0.1484,
+      "log_good": 1.1182
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 105.0,
+      "good": 156.0,
+      "ratio": 1.4857,
+      "suggested_scalar": 0.3604,
+      "log_bad": 4.654,
+      "log_good": 5.0499
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.921,
+      "good": 0.9307,
+      "ratio": 1.0105,
+      "suggested_scalar": 0.0095,
+      "log_bad": -0.0823,
+      "log_good": -0.0718
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 15.0,
+      "good": 21.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.3063,
+      "log_bad": 2.7081,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.7003,
+      "good": 0.7327,
+      "ratio": 1.0463,
+      "suggested_scalar": 0.0412,
+      "log_bad": -0.3562,
+      "log_good": -0.311
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.7447,
+      "good": 0.7175,
+      "ratio": 0.9635,
+      "suggested_scalar": -0.0339,
+      "log_bad": -0.2948,
+      "log_good": -0.332
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.3364,
+      "good": 3.7405,
+      "ratio": 1.1211,
+      "suggested_scalar": 0.1041,
+      "log_bad": 1.2049,
+      "log_good": 1.3192
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 423.0,
+      "good": 570.0,
+      "ratio": 1.3475,
+      "suggested_scalar": 0.2715,
+      "log_bad": 6.0474,
+      "log_good": 6.3456
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0259,
+      "good": 0.0192,
+      "ratio": 0.7413,
+      "suggested_scalar": -0.2725,
+      "log_bad": -3.6535,
+      "log_good": -3.9528
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.6147,
+      "good": 5.7004,
+      "ratio": 1.0153,
+      "suggested_scalar": 0.0138,
+      "log_bad": 1.7254,
+      "log_good": 1.7405
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 24.0,
+      "good": 26.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.0729,
+      "log_bad": 3.1781,
+      "log_good": 3.2581
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8971,
+      "good": 0.7536,
+      "ratio": 0.84,
+      "suggested_scalar": -0.1587,
+      "log_bad": -0.1086,
+      "log_good": -0.2829
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 4.9811,
+      "good": 5.2328,
+      "ratio": 1.0505,
+      "suggested_scalar": 0.0449,
+      "log_bad": 1.6057,
+      "log_good": 1.6549
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8408,
+      "good": 0.8128,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0308,
+      "log_bad": -0.1734,
+      "log_good": -0.2073
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1837,
+      "good": 0.1613,
+      "ratio": 0.8781,
+      "suggested_scalar": -0.1184,
+      "log_bad": -1.6945,
+      "log_good": -1.8245
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6287,
+      "good": 3.6301,
+      "ratio": 1.0004,
+      "suggested_scalar": 0.0004,
+      "log_bad": 1.2889,
+      "log_good": 1.2893
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 187.0,
+      "good": 255.0,
+      "ratio": 1.3636,
+      "suggested_scalar": 0.2823,
+      "log_bad": 5.2311,
+      "log_good": 5.5413
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.611,
+      "good": 0.8482,
+      "ratio": 1.3882,
+      "suggested_scalar": 0.2986,
+      "log_bad": -0.4927,
+      "log_good": -0.1646
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 68.0,
+      "good": 83.0,
+      "ratio": 1.2206,
+      "suggested_scalar": 0.1814,
+      "log_bad": 4.2195,
+      "log_good": 4.4188
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 813.0,
+      "good": 1194.0,
+      "ratio": 1.4686,
+      "suggested_scalar": 0.3498,
+      "log_bad": 6.7007,
+      "log_good": 7.0851
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 119.0,
+      "good": 139.0,
+      "ratio": 1.1681,
+      "suggested_scalar": 0.1414,
+      "log_bad": 4.7791,
+      "log_good": 4.9345
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2612,
+      "good": 0.2465,
+      "ratio": 0.9437,
+      "suggested_scalar": -0.0527,
+      "log_bad": -1.3425,
+      "log_good": -1.4004
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 68.0,
+      "good": 84.0,
+      "ratio": 1.2353,
+      "suggested_scalar": 0.1923,
+      "log_bad": 4.2195,
+      "log_good": 4.4308
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 68.0,
+      "good": 83.0,
+      "ratio": 1.2206,
+      "suggested_scalar": 0.1814,
+      "log_bad": 4.2195,
+      "log_good": 4.4188
+    },
+    "brevity.mean_sample_size": {
+      "bad": 68.0,
+      "good": 83.0,
+      "ratio": 1.2206,
+      "suggested_scalar": 0.1814,
+      "log_bad": 4.2195,
+      "log_good": 4.4188
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 425.0,
+      "good": 572.0,
+      "ratio": 1.3459,
+      "suggested_scalar": 0.2704,
+      "log_bad": 6.0521,
+      "log_good": 6.3491
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 242.0,
+      "good": 306.0,
+      "ratio": 1.2645,
+      "suggested_scalar": 0.2136,
+      "log_bad": 5.4889,
+      "log_good": 5.7236
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 136.0,
+      "good": 186.0,
+      "ratio": 1.3676,
+      "suggested_scalar": 0.285,
+      "log_bad": 4.9127,
+      "log_good": 5.2257
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 4.9515,
+      "good": 4.9058,
+      "ratio": 0.9908,
+      "suggested_scalar": -0.0084,
+      "log_bad": 1.5997,
+      "log_good": 1.5904
+    },
+    "halstead.mean_effort": {
+      "bad": 43049.8443,
+      "good": 79016.6924,
+      "ratio": 1.8355,
+      "suggested_scalar": 0.5528,
+      "log_bad": 10.6701,
+      "log_good": 11.2774
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8183,
+      "good": 0.8208,
+      "ratio": 1.0031,
+      "suggested_scalar": 0.0028,
+      "log_bad": -0.2005,
+      "log_good": -0.1975
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 38.0,
+      "good": 47.0,
+      "ratio": 1.2368,
+      "suggested_scalar": 0.1935,
+      "log_bad": 3.6376,
+      "log_good": 3.8501
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 201.0,
+      "good": 279.0,
+      "ratio": 1.3881,
+      "suggested_scalar": 0.2985,
+      "log_bad": 5.3033,
+      "log_good": 5.6312
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3582,
+      "good": 0.2995,
+      "ratio": 0.8361,
+      "suggested_scalar": -0.1629,
+      "log_bad": -1.0267,
+      "log_good": -1.2056
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0672,
+      "good": 6.385,
+      "ratio": 1.0524,
+      "suggested_scalar": 0.0465,
+      "log_bad": 1.8029,
+      "log_good": 1.854
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1837,
+      "good": 0.1613,
+      "ratio": 0.8781,
+      "suggested_scalar": -0.1184,
+      "log_bad": -1.6945,
+      "log_good": -1.8245
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.6896,
+      "good": 4.7053,
+      "ratio": 1.0033,
+      "suggested_scalar": 0.003,
+      "log_bad": 1.5453,
+      "log_good": 1.5487
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 424.0,
+      "good": 571.0,
+      "ratio": 1.3467,
+      "suggested_scalar": 0.2709,
+      "log_bad": 6.0497,
+      "log_good": 6.3474
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 79.0,
+      "good": 94.0,
+      "ratio": 1.1899,
+      "suggested_scalar": 0.1582,
+      "log_bad": 4.3694,
+      "log_good": 4.5433
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2391.658,
+      "good": 4389.8162,
+      "ratio": 1.8355,
+      "suggested_scalar": 0.5528,
+      "log_bad": 7.7797,
+      "log_good": 8.387
+    },
+    "readability.mean_total_lines": {
+      "bad": 40.0,
+      "good": 52.0,
+      "ratio": 1.3,
+      "suggested_scalar": 0.2388,
+      "log_bad": 3.6889,
+      "log_good": 3.9512
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.3691,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 1832.9345,
+      "good": 2544.5595,
+      "ratio": 1.3882,
+      "suggested_scalar": 0.2986,
+      "log_bad": 7.5137,
+      "log_good": 7.8417
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 440.0,
+      "good": 578.0,
+      "ratio": 1.3136,
+      "suggested_scalar": 0.2483,
+      "log_bad": 6.0868,
+      "log_good": 6.3596
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.425,
+      "good": 40.3462,
+      "ratio": 1.1389,
+      "suggested_scalar": 0.1184,
+      "log_bad": 3.5674,
+      "log_good": 3.6975
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1044,
+      "good": 1.1031,
+      "ratio": 0.9988,
+      "suggested_scalar": -0.0011,
+      "log_bad": 0.0993,
+      "log_good": 0.0981
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 25.0,
+      "good": 27.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.0701,
+      "log_bad": 3.2189,
+      "log_good": 3.2958
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.5775,
+      "good": 0.6314,
+      "ratio": 1.0933,
+      "suggested_scalar": 0.0812,
+      "log_bad": -0.549,
+      "log_good": -0.4598
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9209,
+      "good": 0.9205,
+      "ratio": 0.9996,
+      "suggested_scalar": -0.0004,
+      "log_bad": -0.0824,
+      "log_good": -0.0828
+    },
+    "halstead.mean_length": {
+      "bad": 320.0,
+      "good": 418.0,
+      "ratio": 1.3062,
+      "suggested_scalar": 0.2432,
+      "log_bad": 5.7683,
+      "log_good": 6.0355
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.125,
+      "good": 1.125,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1178,
+      "log_good": 0.1178
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.0875,
+      "good": 6.375,
+      "ratio": 1.0472,
+      "suggested_scalar": 0.042,
+      "log_bad": 1.8062,
+      "log_good": 1.8524
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1651,
+      "good": 0.1417,
+      "ratio": 0.8583,
+      "suggested_scalar": -0.1391,
+      "log_bad": -1.8012,
+      "log_good": -1.954
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 23.4868,
+      "good": 31.0532,
+      "ratio": 1.3222,
+      "suggested_scalar": 0.2542,
+      "log_bad": 3.1564,
+      "log_good": 3.4357
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 9.0,
+      "ratio": 9.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 2.1972
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 48.0,
+      "good": 56.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.1403,
+      "log_bad": 3.8712,
+      "log_good": 4.0254
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5,
+      "good": 0.5484,
+      "ratio": 1.0968,
+      "suggested_scalar": 0.0841,
+      "log_bad": -0.6931,
+      "log_good": -0.6008
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 40.0,
+      "good": 52.0,
+      "ratio": 1.3,
+      "suggested_scalar": 0.2388,
+      "log_bad": 3.6889,
+      "log_good": 3.9512
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.does_not_force_unwrap_optionals": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 22.0,
+      "good": 27.0,
+      "ratio": 1.2273,
+      "suggested_scalar": 0.0642,
+      "log_bad": 3.091,
+      "log_good": 3.2958
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8723,
+      "good": 0.8,
+      "ratio": 0.9171,
+      "suggested_scalar": -0.0271,
+      "log_bad": -0.1366,
+      "log_good": -0.2231
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4916,
+      "good": 4.3467,
+      "ratio": 0.9677,
+      "suggested_scalar": -0.0103,
+      "log_bad": 1.5022,
+      "log_good": 1.4694
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 94.0,
+      "good": 82.0,
+      "ratio": 0.8723,
+      "suggested_scalar": -0.0428,
+      "log_bad": 4.5433,
+      "log_good": 4.4067
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5,
+      "good": 0.4183,
+      "ratio": 0.8366,
+      "suggested_scalar": -0.056,
+      "log_bad": -0.6931,
+      "log_good": -0.8716
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6867,
+      "good": 0.6256,
+      "ratio": 0.911,
+      "suggested_scalar": -0.0292,
+      "log_bad": -0.3759,
+      "log_good": -0.469
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.2128,
+      "good": 7.9818,
+      "ratio": 1.2847,
+      "suggested_scalar": 0.0786,
+      "log_bad": 1.8266,
+      "log_good": 2.0772
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 313.0,
+      "good": 333.0,
+      "ratio": 1.0639,
+      "suggested_scalar": 0.0194,
+      "log_bad": 5.7462,
+      "log_good": 5.8081
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0031,
+      "good": 0.0006,
+      "ratio": 0.1935,
+      "suggested_scalar": -0.515,
+      "log_bad": -5.7764,
+      "log_good": -7.4186
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1064,
+      "good": 1.0,
+      "ratio": 9.3985,
+      "suggested_scalar": 0.7027,
+      "log_bad": -2.2405,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 0.0017,
+      "ratio": 0.0017,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.3771
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.913,
+      "good": 0.9721,
+      "ratio": 1.0647,
+      "suggested_scalar": 0.0197,
+      "log_bad": -0.091,
+      "log_good": -0.0283
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 114.0,
+      "good": 105.0,
+      "ratio": 0.9211,
+      "suggested_scalar": -0.0258,
+      "log_bad": 4.7362,
+      "log_good": 4.654
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 102.3043,
+      "good": 98.5311,
+      "ratio": 0.9631,
+      "suggested_scalar": -0.0118,
+      "log_bad": 4.628,
+      "log_good": 4.5904
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4103,
+      "good": 0.4699,
+      "ratio": 1.1453,
+      "suggested_scalar": 0.0425,
+      "log_bad": -0.8909,
+      "log_good": -0.7552
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.6717,
+      "good": 14.5638,
+      "ratio": 1.2478,
+      "suggested_scalar": 0.0694,
+      "log_bad": 2.4572,
+      "log_good": 2.6785
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1594.0,
+      "good": 1808.0,
+      "ratio": 1.1343,
+      "suggested_scalar": 0.0395,
+      "log_bad": 7.374,
+      "log_good": 7.5
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2553,
+      "good": 0.2727,
+      "ratio": 1.0682,
+      "suggested_scalar": 0.0207,
+      "log_bad": -1.3653,
+      "log_good": -1.2994
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8298,
+      "good": 0.7273,
+      "ratio": 0.8765,
+      "suggested_scalar": -0.0413,
+      "log_bad": -0.1866,
+      "log_good": -0.3184
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.6596,
+      "good": 6.0545,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0299,
+      "log_bad": 1.8961,
+      "log_good": 1.8008
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 18.2526,
+      "good": 27.6542,
+      "ratio": 1.5151,
+      "suggested_scalar": 0.1303,
+      "log_bad": 2.9043,
+      "log_good": 3.3198
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 53.0,
+      "good": 45.0,
+      "ratio": 0.8491,
+      "suggested_scalar": -0.0513,
+      "log_bad": 3.9703,
+      "log_good": 3.8067
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9374,
+      "good": 0.9586,
+      "ratio": 1.0226,
+      "suggested_scalar": 0.007,
+      "log_bad": -0.0646,
+      "log_good": -0.0423
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 28.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3322,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6054,
+      "good": 0.6455,
+      "ratio": 1.0662,
+      "suggested_scalar": 0.0201,
+      "log_bad": -0.5019,
+      "log_good": -0.4377
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2508,
+      "good": 0.29,
+      "ratio": 1.1563,
+      "suggested_scalar": 0.0455,
+      "log_bad": -1.3831,
+      "log_good": -1.2379
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5342,
+      "good": 2.8206,
+      "ratio": 1.113,
+      "suggested_scalar": 0.0336,
+      "log_bad": 0.9299,
+      "log_good": 1.0369
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 311.0,
+      "good": 331.0,
+      "ratio": 1.0643,
+      "suggested_scalar": 0.0195,
+      "log_bad": 5.7398,
+      "log_good": 5.8021
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 20.0,
+      "good": 35.0,
+      "ratio": 1.75,
+      "suggested_scalar": 0.1755,
+      "log_bad": 2.9957,
+      "log_good": 3.5553
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0863,
+      "good": 0.0631,
+      "ratio": 0.7312,
+      "suggested_scalar": -0.0982,
+      "log_bad": -2.4499,
+      "log_good": -2.763
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7814,
+      "good": 5.8826,
+      "ratio": 1.0175,
+      "suggested_scalar": 0.0054,
+      "log_bad": 1.7546,
+      "log_good": 1.772
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 39.0,
+      "good": 33.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.0524,
+      "log_bad": 3.6636,
+      "log_good": 3.4965
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.5012,
+      "good": 1.5525,
+      "ratio": 1.0342,
+      "suggested_scalar": 0.0105,
+      "log_bad": 0.4063,
+      "log_good": 0.4399
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8168,
+      "good": 5.4979,
+      "ratio": 0.9452,
+      "suggested_scalar": -0.0177,
+      "log_bad": 1.7608,
+      "log_good": 1.7044
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7769,
+      "good": 0.7389,
+      "ratio": 0.9511,
+      "suggested_scalar": -0.0157,
+      "log_bad": -0.2524,
+      "log_good": -0.3026
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1754,
+      "good": 0.1667,
+      "ratio": 0.9504,
+      "suggested_scalar": -0.016,
+      "log_bad": -1.7407,
+      "log_good": -1.7916
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.4164,
+      "good": 3.8163,
+      "ratio": 1.1171,
+      "suggested_scalar": 0.0347,
+      "log_bad": 1.2286,
+      "log_good": 1.3393
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2174,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 263.0,
+      "good": 272.0,
+      "ratio": 1.0342,
+      "suggested_scalar": 0.0106,
+      "log_bad": 5.5722,
+      "log_good": 5.6058
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 5.0,
+      "good": 3.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.1602,
+      "log_bad": 1.6094,
+      "log_good": 1.0986
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6729,
+      "good": 0.6909,
+      "ratio": 1.0267,
+      "suggested_scalar": 0.0083,
+      "log_bad": -0.3962,
+      "log_good": -0.3698
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 95.0,
+      "good": 84.0,
+      "ratio": 0.8842,
+      "suggested_scalar": -0.0386,
+      "log_bad": 4.5539,
+      "log_good": 4.4308
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 767.0,
+      "good": 798.0,
+      "ratio": 1.0404,
+      "suggested_scalar": 0.0124,
+      "log_bad": 6.6425,
+      "log_good": 6.6821
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 137.0,
+      "good": 130.0,
+      "ratio": 0.9489,
+      "suggested_scalar": -0.0164,
+      "log_bad": 4.92,
+      "log_good": 4.8675
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0128,
+      "good": 0.009,
+      "ratio": 0.7031,
+      "suggested_scalar": -0.1105,
+      "log_bad": -4.3583,
+      "log_good": -4.7105
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2556,
+      "good": 0.2763,
+      "ratio": 1.081,
+      "suggested_scalar": 0.0244,
+      "log_bad": -1.3641,
+      "log_good": -1.2863
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 46.0,
+      "good": 55.0,
+      "ratio": 1.1957,
+      "suggested_scalar": 0.056,
+      "log_bad": 3.8286,
+      "log_good": 4.0073
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0902,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 95.0,
+      "good": 84.0,
+      "ratio": 0.8842,
+      "suggested_scalar": -0.0386,
+      "log_bad": 4.5539,
+      "log_good": 4.4308
+    },
+    "brevity.mean_sample_size": {
+      "bad": 95.0,
+      "good": 84.0,
+      "ratio": 0.8842,
+      "suggested_scalar": -0.0386,
+      "log_bad": 4.5539,
+      "log_good": 4.4308
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 313.0,
+      "good": 333.0,
+      "ratio": 1.0639,
+      "suggested_scalar": 0.0194,
+      "log_bad": 5.7462,
+      "log_good": 5.8081
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 146.0,
+      "good": 172.0,
+      "ratio": 1.1781,
+      "suggested_scalar": 0.0514,
+      "log_bad": 4.9836,
+      "log_good": 5.1475
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 230.0,
+      "good": 231.0,
+      "ratio": 1.0043,
+      "suggested_scalar": 0.0014,
+      "log_bad": 5.4381,
+      "log_good": 5.4424
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.006,
+      "ratio": 0.006,
+      "suggested_scalar": -1.6045,
+      "log_bad": 0.0,
+      "log_good": -5.116
+    },
+    "heaps.mean_k": {
+      "bad": 1.9772,
+      "good": 2.4135,
+      "ratio": 1.2207,
+      "suggested_scalar": 0.0625,
+      "log_bad": 0.6817,
+      "log_good": 0.8811
+    },
+    "halstead.mean_effort": {
+      "bad": 58667.9399,
+      "good": 69853.014,
+      "ratio": 1.1907,
+      "suggested_scalar": 0.0547,
+      "log_bad": 10.9796,
+      "log_good": 11.1541
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8854,
+      "good": 0.8601,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.0091,
+      "log_bad": -0.1217,
+      "log_good": -0.1507
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 66.0,
+      "good": 54.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.0629,
+      "log_bad": 4.1897,
+      "log_good": 3.989
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 171.0,
+      "good": 196.0,
+      "ratio": 1.1462,
+      "suggested_scalar": 0.0428,
+      "log_bad": 5.1417,
+      "log_good": 5.2781
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4912,
+      "good": 0.419,
+      "ratio": 0.853,
+      "suggested_scalar": -0.0499,
+      "log_bad": -0.7109,
+      "log_good": -0.8699
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.7281,
+      "good": 7.6,
+      "ratio": 1.1296,
+      "suggested_scalar": 0.0382,
+      "log_bad": 1.9063,
+      "log_good": 2.0281
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1754,
+      "good": 0.1667,
+      "ratio": 0.9504,
+      "suggested_scalar": -0.016,
+      "log_bad": -1.7407,
+      "log_good": -1.7916
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.9034,
+      "good": 3.1765,
+      "ratio": 1.0941,
+      "suggested_scalar": 0.0282,
+      "log_bad": 1.0659,
+      "log_good": 1.1558
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 312.0,
+      "good": 332.0,
+      "ratio": 1.0641,
+      "suggested_scalar": 0.0195,
+      "log_bad": 5.743,
+      "log_good": 5.8051
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2174,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 30.0,
+      "good": 37.0,
+      "ratio": 1.2333,
+      "suggested_scalar": 0.0658,
+      "log_bad": 3.4012,
+      "log_good": 3.6109
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3259.33,
+      "good": 3880.723,
+      "ratio": 1.1907,
+      "suggested_scalar": 0.0547,
+      "log_bad": 8.0893,
+      "log_good": 8.2638
+    },
+    "readability.mean_total_lines": {
+      "bad": 47.0,
+      "good": 55.0,
+      "ratio": 1.1702,
+      "suggested_scalar": 0.0493,
+      "log_bad": 3.8501,
+      "log_good": 4.0073
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2018.8134,
+      "good": 2072.562,
+      "ratio": 1.0266,
+      "suggested_scalar": 0.0082,
+      "log_bad": 7.6103,
+      "log_good": 7.6365
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 629.0,
+      "good": 641.0,
+      "ratio": 1.0191,
+      "suggested_scalar": 0.0059,
+      "log_bad": 6.4441,
+      "log_good": 6.463
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.7021,
+      "good": 31.6727,
+      "ratio": 0.9685,
+      "suggested_scalar": -0.01,
+      "log_bad": 3.4874,
+      "log_good": 3.4555
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1557,
+      "good": 1.2075,
+      "ratio": 1.0448,
+      "suggested_scalar": 0.0138,
+      "log_bad": 0.1447,
+      "log_good": 0.1886
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 13.0,
+      "good": 24.0,
+      "ratio": 1.8462,
+      "suggested_scalar": 0.1923,
+      "log_bad": 2.5649,
+      "log_good": 3.1781
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 1.0,
+      "ratio": 0.2,
+      "suggested_scalar": -0.5048,
+      "log_bad": 1.6094,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8859,
+      "good": 0.864,
+      "ratio": 0.9753,
+      "suggested_scalar": -0.0079,
+      "log_bad": -0.1212,
+      "log_good": -0.1462
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9926,
+      "good": 0.9867,
+      "ratio": 0.9941,
+      "suggested_scalar": -0.0019,
+      "log_bad": -0.0074,
+      "log_good": -0.0134
+    },
+    "halstead.mean_length": {
+      "bad": 308.0,
+      "good": 326.0,
+      "ratio": 1.0584,
+      "suggested_scalar": 0.0178,
+      "log_bad": 5.7301,
+      "log_good": 5.7869
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 8.75,
+      "good": 14.3333,
+      "ratio": 1.6381,
+      "suggested_scalar": 0.1548,
+      "log_bad": 2.1691,
+      "log_good": 2.6626
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5699,
+      "good": 6.3923,
+      "ratio": 0.973,
+      "suggested_scalar": -0.0086,
+      "log_bad": 1.8825,
+      "log_good": 1.8551
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0916,
+      "good": 0.0951,
+      "ratio": 1.0382,
+      "suggested_scalar": 0.0118,
+      "log_bad": -2.3903,
+      "log_good": -2.3528
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.0606,
+      "good": 33.7037,
+      "ratio": 1.1598,
+      "suggested_scalar": 0.0465,
+      "log_bad": 3.3694,
+      "log_good": 3.5176
+    },
+    "branching.mean_branch_count": {
+      "bad": 12.0,
+      "good": 15.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.07,
+      "log_bad": 2.4849,
+      "log_good": 2.7081
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 56.0,
+      "good": 44.0,
+      "ratio": 0.7857,
+      "suggested_scalar": -0.0756,
+      "log_bad": 4.0254,
+      "log_good": 3.7842
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8,
+      "good": 0.7619,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0153,
+      "log_bad": -0.2231,
+      "log_good": -0.2719
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 47.0,
+      "good": 55.0,
+      "ratio": 1.1702,
+      "suggested_scalar": 0.0493,
+      "log_bad": 3.8501,
+      "log_good": 4.0073
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 20.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.033,
+      "log_bad": 2.8904,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.package_name_is_single_lowercase_word": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 4.0,
+      "good": 2.0,
+      "ratio": 0.5,
+      "suggested_scalar": -1.6361,
+      "log_bad": 1.3863,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0173,
+      "good": 0.0196,
+      "ratio": 1.1329,
+      "suggested_scalar": 0.2946,
+      "log_bad": -4.057,
+      "log_good": -3.9322
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.6667,
+      "good": 0.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.4054,
+      "log_good": -0.4054
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.881,
+      "good": 0.875,
+      "ratio": 0.9932,
+      "suggested_scalar": -0.0161,
+      "log_bad": -0.1267,
+      "log_good": -0.1335
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0173,
+      "good": 0.0196,
+      "ratio": 1.1329,
+      "suggested_scalar": 0.2946,
+      "log_bad": -4.057,
+      "log_good": -3.9322
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7618,
+      "good": 4.7675,
+      "ratio": 1.0012,
+      "suggested_scalar": 0.0028,
+      "log_bad": 1.5606,
+      "log_good": 1.5618
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 111.0,
+      "good": 90.0,
+      "ratio": 0.8108,
+      "suggested_scalar": -0.495,
+      "log_bad": 4.7095,
+      "log_good": 4.4998
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5803,
+      "good": 0.527,
+      "ratio": 0.9082,
+      "suggested_scalar": -0.2274,
+      "log_bad": -0.5442,
+      "log_good": -0.6406
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 15.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.1523,
+      "log_bad": 2.7726,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7581,
+      "good": 0.7475,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0332,
+      "log_bad": -0.2769,
+      "log_good": -0.291
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.5476,
+      "good": 0.575,
+      "ratio": 1.05,
+      "suggested_scalar": 0.1152,
+      "log_bad": -0.6022,
+      "log_good": -0.5534
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 289.0,
+      "good": 255.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.2954,
+      "log_bad": 5.6664,
+      "log_good": 5.5413
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0008,
+      "good": 0.001,
+      "ratio": 1.25,
+      "suggested_scalar": 0.5267,
+      "log_bad": -7.1309,
+      "log_good": -6.9078
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1905,
+      "good": 0.15,
+      "ratio": 0.7874,
+      "suggested_scalar": -0.5642,
+      "log_bad": -1.6581,
+      "log_good": -1.8971
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.7944,
+      "good": 0.8361,
+      "ratio": 1.0525,
+      "suggested_scalar": 0.1208,
+      "log_bad": -0.2302,
+      "log_good": -0.179
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 128.0,
+      "good": 109.0,
+      "ratio": 0.8516,
+      "suggested_scalar": -0.3793,
+      "log_bad": 4.852,
+      "log_good": 4.6913
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 98.633,
+      "good": 109.7644,
+      "ratio": 1.1129,
+      "suggested_scalar": 0.2524,
+      "log_bad": 4.5914,
+      "log_good": 4.6983
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.3264,
+      "good": 0.3622,
+      "ratio": 1.1097,
+      "suggested_scalar": 0.2457,
+      "log_bad": -1.1196,
+      "log_good": -1.0156
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 12.5779,
+      "good": 5.7522,
+      "ratio": 0.4573,
+      "suggested_scalar": -1.8467,
+      "log_bad": 2.5319,
+      "log_good": 1.7496
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1302.0,
+      "good": 1009.0,
+      "ratio": 0.775,
+      "suggested_scalar": -0.6018,
+      "log_bad": 7.1717,
+      "log_good": 6.9167
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1667,
+      "good": 0.075,
+      "ratio": 0.4499,
+      "suggested_scalar": -1.8853,
+      "log_bad": -1.7916,
+      "log_good": -2.5903
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8571,
+      "good": 0.85,
+      "ratio": 0.9917,
+      "suggested_scalar": -0.0196,
+      "log_bad": -0.1542,
+      "log_good": -0.1625
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.881,
+      "good": 6.375,
+      "ratio": 0.9265,
+      "suggested_scalar": -0.1803,
+      "log_bad": 1.9288,
+      "log_good": 1.8524
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.4382,
+      "good": 0.4444,
+      "ratio": 1.0141,
+      "suggested_scalar": 0.0332,
+      "log_bad": -0.8251,
+      "log_good": -0.811
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 82.0,
+      "good": 68.0,
+      "ratio": 0.8293,
+      "suggested_scalar": -0.4419,
+      "log_bad": 4.4067,
+      "log_good": 4.2195
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9445,
+      "good": 0.9323,
+      "ratio": 0.9871,
+      "suggested_scalar": -0.0307,
+      "log_bad": -0.0571,
+      "log_good": -0.0701
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 26.0,
+      "ratio": 0.8966,
+      "suggested_scalar": -0.2578,
+      "log_bad": 3.3673,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5215,
+      "good": 0.4985,
+      "ratio": 0.9559,
+      "suggested_scalar": -0.1065,
+      "log_bad": -0.651,
+      "log_good": -0.6962
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.1463,
+      "good": 0.1581,
+      "ratio": 1.0807,
+      "suggested_scalar": 0.1831,
+      "log_bad": -1.9221,
+      "log_good": -1.8445
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.0899,
+      "good": 1.9941,
+      "ratio": 0.9542,
+      "suggested_scalar": -0.1108,
+      "log_bad": 0.7371,
+      "log_good": 0.6902
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 287.0,
+      "good": 253.0,
+      "ratio": 0.8815,
+      "suggested_scalar": -0.2976,
+      "log_bad": 5.6595,
+      "log_good": 5.5334
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0138,
+      "good": 0.0157,
+      "ratio": 1.1377,
+      "suggested_scalar": 0.3045,
+      "log_bad": -4.2831,
+      "log_good": -4.1541
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8826,
+      "good": 5.7279,
+      "ratio": 0.9737,
+      "suggested_scalar": -0.0629,
+      "log_bad": 1.772,
+      "log_good": 1.7453
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 42.0,
+      "good": 39.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.1749,
+      "log_bad": 3.7377,
+      "log_good": 3.6636
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0953,
+      "good": 1.061,
+      "ratio": 0.9687,
+      "suggested_scalar": -0.0751,
+      "log_bad": 0.091,
+      "log_good": 0.0592
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.1297,
+      "good": 5.8474,
+      "ratio": 0.9539,
+      "suggested_scalar": -0.1113,
+      "log_bad": 1.8131,
+      "log_good": 1.766
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8095,
+      "good": 0.8323,
+      "ratio": 1.0282,
+      "suggested_scalar": 0.0656,
+      "log_bad": -0.2113,
+      "log_good": -0.1836
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.16,
+      "good": 0.1667,
+      "ratio": 1.0419,
+      "suggested_scalar": 0.0968,
+      "log_bad": -1.8326,
+      "log_good": -1.7916
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.5465,
+      "good": 2.3984,
+      "ratio": 0.6763,
+      "suggested_scalar": -0.9233,
+      "log_bad": 1.266,
+      "log_good": 0.8748
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 263.0,
+      "good": 230.0,
+      "ratio": 0.8745,
+      "suggested_scalar": -0.3165,
+      "log_bad": 5.5722,
+      "log_good": 5.4381
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6206,
+      "good": 0.5215,
+      "ratio": 0.8403,
+      "suggested_scalar": -0.4107,
+      "log_bad": -0.4771,
+      "log_good": -0.651
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 109.0,
+      "good": 87.0,
+      "ratio": 0.7982,
+      "suggested_scalar": -0.5321,
+      "log_bad": 4.6913,
+      "log_good": 4.4659
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 770.0,
+      "good": 544.0,
+      "ratio": 0.7065,
+      "suggested_scalar": -0.8201,
+      "log_bad": 6.6464,
+      "log_good": 6.2989
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 144.0,
+      "good": 124.0,
+      "ratio": 0.8611,
+      "suggested_scalar": -0.353,
+      "log_bad": 4.9698,
+      "log_good": 4.8203
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1972,
+      "good": 0.2157,
+      "ratio": 1.0938,
+      "suggested_scalar": 0.2117,
+      "log_bad": -1.6235,
+      "log_good": -1.5339
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 38.0,
+      "good": 38.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6376,
+      "log_good": 3.6376
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 109.0,
+      "good": 87.0,
+      "ratio": 0.7982,
+      "suggested_scalar": -0.5321,
+      "log_bad": 4.6913,
+      "log_good": 4.4659
+    },
+    "brevity.mean_sample_size": {
+      "bad": 109.0,
+      "good": 87.0,
+      "ratio": 0.7982,
+      "suggested_scalar": -0.5321,
+      "log_bad": 4.6913,
+      "log_good": 4.4659
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 289.0,
+      "good": 255.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.2954,
+      "log_bad": 5.6664,
+      "log_good": 5.5413
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 121.0,
+      "good": 114.0,
+      "ratio": 0.9421,
+      "suggested_scalar": -0.1407,
+      "log_bad": 4.7958,
+      "log_good": 4.7362
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 232.0,
+      "good": 200.0,
+      "ratio": 0.8621,
+      "suggested_scalar": -0.3503,
+      "log_bad": 5.4467,
+      "log_good": 5.2983
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.7711,
+      "good": 1.6422,
+      "ratio": 0.9272,
+      "suggested_scalar": -0.1784,
+      "log_bad": 0.5716,
+      "log_good": 0.496
+    },
+    "halstead.mean_effort": {
+      "bad": 47404.4738,
+      "good": 39406.7655,
+      "ratio": 0.8313,
+      "suggested_scalar": -0.4362,
+      "log_bad": 10.7665,
+      "log_good": 10.5817
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.9057,
+      "good": 0.9076,
+      "ratio": 1.0021,
+      "suggested_scalar": 0.0049,
+      "log_bad": -0.099,
+      "log_good": -0.097
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 82.0,
+      "good": 64.0,
+      "ratio": 0.7805,
+      "suggested_scalar": -0.585,
+      "log_bad": 4.4067,
+      "log_good": 4.1589
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 130.0,
+      "good": 117.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.2487,
+      "log_bad": 4.8675,
+      "log_good": 4.7622
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5547,
+      "good": 0.4954,
+      "ratio": 0.8931,
+      "suggested_scalar": -0.2669,
+      "log_bad": -0.5893,
+      "log_good": -0.7024
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0156,
+      "good": 4.9908,
+      "ratio": 0.8296,
+      "suggested_scalar": -0.4408,
+      "log_bad": 1.7944,
+      "log_good": 1.6076
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.16,
+      "good": 0.1667,
+      "ratio": 1.0419,
+      "suggested_scalar": 0.0968,
+      "log_bad": -1.8326,
+      "log_good": -1.7916
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.419,
+      "good": 3.4011,
+      "ratio": 0.7697,
+      "suggested_scalar": -0.618,
+      "log_bad": 1.4859,
+      "log_good": 1.2241
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 288.0,
+      "good": 254.0,
+      "ratio": 0.8819,
+      "suggested_scalar": -0.2965,
+      "log_bad": 5.663,
+      "log_good": 5.5373
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 18.0,
+      "good": 17.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.1349,
+      "log_bad": 2.8904,
+      "log_good": 2.8332
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2633.5819,
+      "good": 2189.2648,
+      "ratio": 0.8313,
+      "suggested_scalar": -0.4362,
+      "log_bad": 7.8761,
+      "log_good": 7.6913
+    },
+    "readability.mean_total_lines": {
+      "bad": 42.0,
+      "good": 40.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.1152,
+      "log_bad": 3.7377,
+      "log_good": 3.6889
+    },
+    "indentation.mean_max_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_volume": {
+      "bad": 1861.6699,
+      "good": 1564.5366,
+      "ratio": 0.8404,
+      "suggested_scalar": -0.4104,
+      "log_bad": 7.5292,
+      "log_good": 7.3553
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 623.0,
+      "good": 506.0,
+      "ratio": 0.8122,
+      "suggested_scalar": -0.491,
+      "log_bad": 6.4345,
+      "log_good": 6.2265
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 29.7619,
+      "good": 24.025,
+      "ratio": 0.8072,
+      "suggested_scalar": -0.5055,
+      "log_bad": 3.3932,
+      "log_good": 3.1791
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1964,
+      "good": 1.0709,
+      "ratio": 0.8951,
+      "suggested_scalar": -0.2616,
+      "log_bad": 0.1793,
+      "log_good": 0.0685
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 17.0,
+      "good": 15.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.2954,
+      "log_bad": 2.8332,
+      "log_good": 2.7081
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 8.0,
+      "good": 6.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.6791,
+      "log_bad": 2.0794,
+      "log_good": 1.7918
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9316,
+      "good": 0.9261,
+      "ratio": 0.9941,
+      "suggested_scalar": -0.014,
+      "log_bad": -0.0709,
+      "log_good": -0.0768
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.979,
+      "good": 0.9727,
+      "ratio": 0.9936,
+      "suggested_scalar": -0.0152,
+      "log_bad": -0.0212,
+      "log_good": -0.0277
+    },
+    "halstead.mean_length": {
+      "bad": 274.0,
+      "good": 241.0,
+      "ratio": 0.8796,
+      "suggested_scalar": -0.3029,
+      "log_bad": 5.6131,
+      "log_good": 5.4848
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7682,
+      "good": 6.4429,
+      "ratio": 0.9519,
+      "suggested_scalar": -0.1163,
+      "log_bad": 1.9122,
+      "log_good": 1.863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0931,
+      "good": 0.113,
+      "ratio": 1.2137,
+      "suggested_scalar": 0.4573,
+      "log_bad": -2.3741,
+      "log_good": -2.1804
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.4634,
+      "good": 25.1875,
+      "ratio": 0.9892,
+      "suggested_scalar": -0.0257,
+      "log_bad": 3.2372,
+      "log_good": 3.2263
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 3.0,
+      "ratio": 0.4286,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.9459,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 71.0,
+      "good": 54.0,
+      "ratio": 0.7606,
+      "suggested_scalar": -0.646,
+      "log_bad": 4.2627,
+      "log_good": 3.989
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8362,
+      "good": 0.81,
+      "ratio": 0.9687,
+      "suggested_scalar": -0.0751,
+      "log_bad": -0.1789,
+      "log_good": -0.2107
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 42.0,
+      "good": 40.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.1152,
+      "log_bad": 3.7377,
+      "log_good": 3.6889
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 11.0,
+      "ratio": 0.6471,
+      "suggested_scalar": -1.0275,
+      "log_bad": 2.8332,
+      "log_good": 2.3979
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.error_message_is_descriptive": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 45.0,
+      "good": 48.0,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.0621,
+      "log_bad": 3.8067,
+      "log_good": 3.8712
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0172,
+      "good": 0.0252,
+      "ratio": 1.4651,
+      "suggested_scalar": 0.3673,
+      "log_bad": -4.0628,
+      "log_good": -3.6809
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6667,
+      "good": 1.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.5108,
+      "log_good": 0.5108
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7867,
+      "good": 0.7765,
+      "ratio": 0.987,
+      "suggested_scalar": -0.0126,
+      "log_bad": -0.2399,
+      "log_good": -0.253
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0172,
+      "good": 0.0252,
+      "ratio": 1.4651,
+      "suggested_scalar": 0.3673,
+      "log_bad": -4.0628,
+      "log_good": -3.6809
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.3391,
+      "good": 4.4124,
+      "ratio": 1.0169,
+      "suggested_scalar": 0.0161,
+      "log_bad": 1.4677,
+      "log_good": 1.4844
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 82.0,
+      "good": 95.0,
+      "ratio": 1.1585,
+      "suggested_scalar": 0.1415,
+      "log_bad": 4.4067,
+      "log_good": 4.5539
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4331,
+      "good": 0.4668,
+      "ratio": 1.0778,
+      "suggested_scalar": 0.0721,
+      "log_bad": -0.8368,
+      "log_good": -0.7619
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 14.0,
+      "good": 15.0,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.0664,
+      "log_bad": 2.6391,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5266,
+      "good": 0.5332,
+      "ratio": 1.0125,
+      "suggested_scalar": 0.012,
+      "log_bad": -0.6413,
+      "log_good": -0.6289
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.6133,
+      "good": 5.1765,
+      "ratio": 1.1221,
+      "suggested_scalar": 0.1108,
+      "log_bad": 1.5289,
+      "log_good": 1.6441
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 464.0,
+      "good": 634.0,
+      "ratio": 1.3664,
+      "suggested_scalar": 0.3002,
+      "log_bad": 6.1399,
+      "log_good": 6.452
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.39,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1353,
+      "good": 1.1356,
+      "ratio": 1.0003,
+      "suggested_scalar": 0.0003,
+      "log_bad": 0.1269,
+      "log_good": 0.1272
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 125.0,
+      "good": 199.0,
+      "ratio": 1.592,
+      "suggested_scalar": 0.4472,
+      "log_bad": 4.8283,
+      "log_good": 5.2933
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 99.0355,
+      "good": 97.2466,
+      "ratio": 0.9819,
+      "suggested_scalar": -0.0175,
+      "log_bad": 4.5955,
+      "log_good": 4.5773
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7106,
+      "good": 0.7109,
+      "ratio": 1.0004,
+      "suggested_scalar": 0.0004,
+      "log_bad": -0.3416,
+      "log_good": -0.3412
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 16.815,
+      "good": 14.2779,
+      "ratio": 0.8491,
+      "suggested_scalar": -0.1573,
+      "log_bad": 2.8223,
+      "log_good": 2.6587
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2119.0,
+      "good": 2903.0,
+      "ratio": 1.37,
+      "suggested_scalar": 0.3028,
+      "log_bad": 7.6587,
+      "log_good": 7.9735
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1867,
+      "good": 0.1765,
+      "ratio": 0.9454,
+      "suggested_scalar": -0.054,
+      "log_bad": -1.6783,
+      "log_good": -1.7344
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7067,
+      "good": 0.7294,
+      "ratio": 1.0321,
+      "suggested_scalar": 0.0304,
+      "log_bad": -0.3471,
+      "log_good": -0.3155
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.1867,
+      "good": 7.4588,
+      "ratio": 1.2056,
+      "suggested_scalar": 0.1798,
+      "log_bad": 1.8224,
+      "log_good": 2.0094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 7.4638,
+      "good": 9.1571,
+      "ratio": 1.2269,
+      "suggested_scalar": 0.1967,
+      "log_bad": 2.0101,
+      "log_good": 2.2145
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 105.0,
+      "good": 165.0,
+      "ratio": 1.5714,
+      "suggested_scalar": 0.4347,
+      "log_bad": 4.654,
+      "log_good": 5.1059
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9456,
+      "good": 0.9511,
+      "ratio": 1.0058,
+      "suggested_scalar": 0.0056,
+      "log_bad": -0.0559,
+      "log_good": -0.0501
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 26.0,
+      "ratio": 1.1304,
+      "suggested_scalar": 0.1179,
+      "log_bad": 3.1355,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.7088,
+      "good": 0.7165,
+      "ratio": 1.0109,
+      "suggested_scalar": 0.0104,
+      "log_bad": -0.3442,
+      "log_good": -0.3334
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5022,
+      "good": 0.5142,
+      "ratio": 1.0239,
+      "suggested_scalar": 0.0227,
+      "log_bad": -0.6888,
+      "log_good": -0.6651
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.4344,
+      "good": 3.5273,
+      "ratio": 1.027,
+      "suggested_scalar": 0.0257,
+      "log_bad": 1.2338,
+      "log_good": 1.2605
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 462.0,
+      "good": 632.0,
+      "ratio": 1.368,
+      "suggested_scalar": 0.3014,
+      "log_bad": 6.1356,
+      "log_good": 6.4489
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 13.0,
+      "good": 14.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0713,
+      "log_bad": 2.5649,
+      "log_good": 2.6391
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0259,
+      "good": 0.0237,
+      "ratio": 0.9151,
+      "suggested_scalar": -0.0854,
+      "log_bad": -3.6535,
+      "log_good": -3.7423
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.3923,
+      "good": 5.6724,
+      "ratio": 1.0519,
+      "suggested_scalar": 0.0487,
+      "log_bad": 1.685,
+      "log_good": 1.7356
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 2.0,
+      "good": 16.0,
+      "ratio": 8.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.6931,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7093,
+      "good": 0.8301,
+      "ratio": 1.1703,
+      "suggested_scalar": 0.1513,
+      "log_bad": -0.3435,
+      "log_good": -0.1862
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.3102,
+      "good": 5.6498,
+      "ratio": 1.064,
+      "suggested_scalar": 0.0596,
+      "log_bad": 1.6696,
+      "log_good": 1.7316
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8047,
+      "good": 0.7779,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0326,
+      "log_bad": -0.2173,
+      "log_good": -0.2512
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.0964,
+      "good": 0.086,
+      "ratio": 0.8921,
+      "suggested_scalar": -0.1098,
+      "log_bad": -2.3392,
+      "log_good": -2.4534
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.1006,
+      "good": 3.7786,
+      "ratio": 0.9215,
+      "suggested_scalar": -0.0787,
+      "log_bad": 1.4111,
+      "log_good": 1.3294
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 292.0,
+      "good": 402.0,
+      "ratio": 1.3767,
+      "suggested_scalar": 0.3075,
+      "log_bad": 5.6768,
+      "log_good": 5.9965
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 12.0,
+      "good": 17.0,
+      "ratio": 1.4167,
+      "suggested_scalar": 0.335,
+      "log_bad": 2.4849,
+      "log_good": 2.8332
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9134,
+      "good": 1.0884,
+      "ratio": 1.1916,
+      "suggested_scalar": 0.1686,
+      "log_bad": -0.0906,
+      "log_good": 0.0847
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 83.0,
+      "good": 115.0,
+      "ratio": 1.3855,
+      "suggested_scalar": 0.3136,
+      "log_bad": 4.4188,
+      "log_good": 4.7449
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1004.0,
+      "good": 1502.0,
+      "ratio": 1.496,
+      "suggested_scalar": 0.3874,
+      "log_bad": 6.9117,
+      "log_good": 7.3146
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 142.0,
+      "good": 149.0,
+      "ratio": 1.0493,
+      "suggested_scalar": 0.0463,
+      "log_bad": 4.9558,
+      "log_good": 5.0039
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0302,
+      "good": 0.0284,
+      "ratio": 0.9404,
+      "suggested_scalar": -0.0591,
+      "log_bad": -3.4999,
+      "log_good": -3.5614
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2543,
+      "good": 0.2366,
+      "ratio": 0.9304,
+      "suggested_scalar": -0.0694,
+      "log_bad": -1.3692,
+      "log_good": -1.4414
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 80.0,
+      "good": 111.0,
+      "ratio": 1.3875,
+      "suggested_scalar": 0.315,
+      "log_bad": 4.382,
+      "log_good": 4.7095
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 83.0,
+      "good": 115.0,
+      "ratio": 1.3855,
+      "suggested_scalar": 0.3136,
+      "log_bad": 4.4188,
+      "log_good": 4.7449
+    },
+    "brevity.mean_sample_size": {
+      "bad": 83.0,
+      "good": 115.0,
+      "ratio": 1.3855,
+      "suggested_scalar": 0.3136,
+      "log_bad": 4.4188,
+      "log_good": 4.7449
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 464.0,
+      "good": 634.0,
+      "ratio": 1.3664,
+      "suggested_scalar": 0.3002,
+      "log_bad": 6.1399,
+      "log_good": 6.452
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 238.0,
+      "good": 327.0,
+      "ratio": 1.3739,
+      "suggested_scalar": 0.3056,
+      "log_bad": 5.4723,
+      "log_good": 5.79
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 214.0,
+      "good": 294.0,
+      "ratio": 1.3738,
+      "suggested_scalar": 0.3055,
+      "log_bad": 5.366,
+      "log_good": 5.6836
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 3.4919,
+      "good": 3.9804,
+      "ratio": 1.1399,
+      "suggested_scalar": 0.1259,
+      "log_bad": 1.2504,
+      "log_good": 1.3814
+    },
+    "halstead.mean_effort": {
+      "bad": 75840.5309,
+      "good": 91662.7207,
+      "ratio": 1.2086,
+      "suggested_scalar": 0.1822,
+      "log_bad": 11.2364,
+      "log_good": 11.4259
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.833,
+      "good": 0.8253,
+      "ratio": 0.9908,
+      "suggested_scalar": -0.0089,
+      "log_bad": -0.1827,
+      "log_good": -0.192
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 59.0,
+      "good": 69.0,
+      "ratio": 1.1695,
+      "suggested_scalar": 0.1506,
+      "log_bad": 4.0775,
+      "log_good": 4.2341
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 289.0,
+      "good": 348.0,
+      "ratio": 1.2042,
+      "suggested_scalar": 0.1787,
+      "log_bad": 5.6664,
+      "log_good": 5.8522
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.432,
+      "good": 0.4121,
+      "ratio": 0.9539,
+      "suggested_scalar": -0.0454,
+      "log_bad": -0.8393,
+      "log_good": -0.8865
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.032,
+      "good": 7.5477,
+      "ratio": 0.9397,
+      "suggested_scalar": -0.0598,
+      "log_bad": 2.0834,
+      "log_good": 2.0212
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.0964,
+      "good": 0.086,
+      "ratio": 0.8921,
+      "suggested_scalar": -0.1098,
+      "log_bad": -2.3392,
+      "log_good": -2.4534
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.3636,
+      "good": 3.8986,
+      "ratio": 1.1591,
+      "suggested_scalar": 0.142,
+      "log_bad": 1.213,
+      "log_good": 1.3606
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 463.0,
+      "good": 633.0,
+      "ratio": 1.3672,
+      "suggested_scalar": 0.3008,
+      "log_bad": 6.1377,
+      "log_good": 6.4505
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 22.0,
+      "ratio": 4.4,
+      "suggested_scalar": 1.425,
+      "log_bad": 1.6094,
+      "log_good": 3.091
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 62.0,
+      "good": 95.0,
+      "ratio": 1.5323,
+      "suggested_scalar": 0.4104,
+      "log_bad": 4.1271,
+      "log_good": 4.5539
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4213.3628,
+      "good": 5092.3734,
+      "ratio": 1.2086,
+      "suggested_scalar": 0.1822,
+      "log_bad": 8.346,
+      "log_good": 8.5355
+    },
+    "readability.mean_total_lines": {
+      "bad": 75.0,
+      "good": 85.0,
+      "ratio": 1.1333,
+      "suggested_scalar": 0.1204,
+      "log_bad": 4.3175,
+      "log_good": 4.4427
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 12.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.1754,
+      "log_bad": 2.3026,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2740.1049,
+      "good": 3265.2182,
+      "ratio": 1.1916,
+      "suggested_scalar": 0.1686,
+      "log_bad": 7.9158,
+      "log_good": 8.0911
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 617.0,
+      "good": 823.0,
+      "ratio": 1.3339,
+      "suggested_scalar": 0.2771,
+      "log_bad": 6.4249,
+      "log_good": 6.713
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 27.1467,
+      "good": 33.0588,
+      "ratio": 1.2178,
+      "suggested_scalar": 0.1895,
+      "log_bad": 3.3013,
+      "log_good": 3.4983
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2,
+      "good": 1.2059,
+      "ratio": 1.0049,
+      "suggested_scalar": 0.0047,
+      "log_bad": 0.1823,
+      "log_good": 0.1872
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.39,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7877,
+      "good": 0.7637,
+      "ratio": 0.9695,
+      "suggested_scalar": -0.0298,
+      "log_bad": -0.2386,
+      "log_good": -0.2696
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9611,
+      "good": 0.9684,
+      "ratio": 1.0076,
+      "suggested_scalar": 0.0073,
+      "log_bad": -0.0397,
+      "log_good": -0.0321
+    },
+    "halstead.mean_length": {
+      "bad": 431.0,
+      "good": 497.0,
+      "ratio": 1.1531,
+      "suggested_scalar": 0.137,
+      "log_bad": 6.0661,
+      "log_good": 6.2086
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.3333,
+      "good": 4.8889,
+      "ratio": 1.1282,
+      "suggested_scalar": 0.116,
+      "log_bad": 1.4663,
+      "log_good": 1.587
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.375,
+      "good": 6.8455,
+      "ratio": 1.0738,
+      "suggested_scalar": 0.0685,
+      "log_bad": 1.8524,
+      "log_good": 1.9236
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1123,
+      "good": 0.1126,
+      "ratio": 1.0027,
+      "suggested_scalar": 0.0026,
+      "log_bad": -2.1866,
+      "log_good": -2.1839
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.678,
+      "good": 28.0725,
+      "ratio": 1.0143,
+      "suggested_scalar": 0.0136,
+      "log_bad": 3.3206,
+      "log_good": 3.3348
+    },
+    "branching.mean_branch_count": {
+      "bad": 14.0,
+      "good": 15.0,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.0664,
+      "log_bad": 2.6391,
+      "log_good": 2.7081
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 54.0,
+      "good": 82.0,
+      "ratio": 1.5185,
+      "suggested_scalar": 0.4018,
+      "log_bad": 3.989,
+      "log_good": 4.4067
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6262,
+      "good": 0.6224,
+      "ratio": 0.9939,
+      "suggested_scalar": -0.0059,
+      "log_bad": -0.4681,
+      "log_good": -0.4742
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 75.0,
+      "good": 85.0,
+      "ratio": 1.1333,
+      "suggested_scalar": 0.1204,
+      "log_bad": 4.3175,
+      "log_good": 4.4427
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.verb_phrase_distinguishes_mutation_vs_return": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 15.0,
+      "good": 23.0,
+      "ratio": 1.5333,
+      "suggested_scalar": 0.3197,
+      "log_bad": 2.7081,
+      "log_good": 3.1355
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0214,
+      "good": 0.0059,
+      "ratio": 0.2757,
+      "suggested_scalar": -0.9638,
+      "log_bad": -3.8444,
+      "log_good": -5.1328
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.625,
+      "good": 0.625,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.47,
+      "log_good": -0.47
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9655,
+      "good": 0.931,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.0272,
+      "log_bad": -0.0351,
+      "log_good": -0.0715
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0214,
+      "good": 0.0059,
+      "ratio": 0.2757,
+      "suggested_scalar": -0.9638,
+      "log_bad": -3.8444,
+      "log_good": -5.1328
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7092,
+      "good": 4.7285,
+      "ratio": 1.0041,
+      "suggested_scalar": 0.0031,
+      "log_bad": 1.5495,
+      "log_good": 1.5536
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 100.0,
+      "good": 100.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.6052,
+      "log_good": 4.6052
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5059,
+      "good": 0.5204,
+      "ratio": 1.0287,
+      "suggested_scalar": 0.0211,
+      "log_bad": -0.6814,
+      "log_good": -0.6532
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 17.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.0428,
+      "log_bad": 2.8904,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6843,
+      "good": 0.6645,
+      "ratio": 0.9711,
+      "suggested_scalar": -0.022,
+      "log_bad": -0.3794,
+      "log_good": -0.4087
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.2759,
+      "good": 4.5517,
+      "ratio": 1.0645,
+      "suggested_scalar": 0.0468,
+      "log_bad": 1.453,
+      "log_good": 1.5155
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 327.0,
+      "good": 337.0,
+      "ratio": 1.0306,
+      "suggested_scalar": 0.0225,
+      "log_bad": 5.79,
+      "log_good": 5.8201
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.2152,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.3103,
+      "good": 0.2414,
+      "ratio": 0.778,
+      "suggested_scalar": -0.1878,
+      "log_bad": -1.1702,
+      "log_good": -1.4213
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0007,
+      "good": 0.0019,
+      "ratio": 2.7143,
+      "suggested_scalar": 0.7469,
+      "log_bad": -7.2644,
+      "log_good": -6.2659
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9063,
+      "good": 0.9316,
+      "ratio": 1.0279,
+      "suggested_scalar": 0.0206,
+      "log_bad": -0.0984,
+      "log_good": -0.0709
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 136.0,
+      "good": 147.0,
+      "ratio": 1.0809,
+      "suggested_scalar": 0.0582,
+      "log_bad": 4.9127,
+      "log_good": 4.9904
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 97.6624,
+      "good": 93.52,
+      "ratio": 0.9576,
+      "suggested_scalar": -0.0324,
+      "log_bad": 4.5815,
+      "log_good": 4.5382
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5276,
+      "good": 0.5417,
+      "ratio": 1.0267,
+      "suggested_scalar": 0.0197,
+      "log_bad": -0.6394,
+      "log_good": -0.613
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.2716,
+      "good": 11.4783,
+      "ratio": 1.3877,
+      "suggested_scalar": 0.2451,
+      "log_bad": 2.1128,
+      "log_good": 2.4405
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1436.0,
+      "good": 1565.0,
+      "ratio": 1.0898,
+      "suggested_scalar": 0.0643,
+      "log_bad": 7.2696,
+      "log_good": 7.3556
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 0.069,
+      "ratio": 0.069,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -2.6736
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.931,
+      "good": 0.8966,
+      "ratio": 0.9631,
+      "suggested_scalar": -0.0282,
+      "log_bad": -0.0715,
+      "log_good": -0.1091
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 11.2759,
+      "good": 11.6207,
+      "ratio": 1.0306,
+      "suggested_scalar": 0.0225,
+      "log_bad": 2.4227,
+      "log_good": 2.4528
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.4411,
+      "good": 7.4197,
+      "ratio": 1.3636,
+      "suggested_scalar": 0.232,
+      "log_bad": 1.694,
+      "log_good": 2.0041
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 94.0,
+      "good": 93.0,
+      "ratio": 0.9894,
+      "suggested_scalar": -0.008,
+      "log_bad": 4.5433,
+      "log_good": 4.5326
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9277,
+      "good": 0.9211,
+      "ratio": 0.9929,
+      "suggested_scalar": -0.0053,
+      "log_bad": -0.075,
+      "log_good": -0.0822
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 22.0,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.0333,
+      "log_bad": 3.1355,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.594,
+      "good": 0.6128,
+      "ratio": 1.0316,
+      "suggested_scalar": 0.0233,
+      "log_bad": -0.5209,
+      "log_good": -0.4897
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3477,
+      "good": 0.3791,
+      "ratio": 1.0903,
+      "suggested_scalar": 0.0647,
+      "log_bad": -1.0564,
+      "log_good": -0.97
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4631,
+      "good": 2.5825,
+      "ratio": 1.0485,
+      "suggested_scalar": 0.0354,
+      "log_bad": 0.9014,
+      "log_good": 0.9488
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 325.0,
+      "good": 335.0,
+      "ratio": 1.0308,
+      "suggested_scalar": 0.0227,
+      "log_bad": 5.7838,
+      "log_good": 5.8141
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0336,
+      "good": 0.0297,
+      "ratio": 0.8839,
+      "suggested_scalar": -0.0923,
+      "log_bad": -3.3932,
+      "log_good": -3.5166
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.858,
+      "good": 5.8826,
+      "ratio": 1.0042,
+      "suggested_scalar": 0.0031,
+      "log_bad": 1.7678,
+      "log_good": 1.772
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 27.0,
+      "good": 31.0,
+      "ratio": 1.1481,
+      "suggested_scalar": 0.1033,
+      "log_bad": 3.2958,
+      "log_good": 3.434
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1822,
+      "good": 1.3101,
+      "ratio": 1.1082,
+      "suggested_scalar": 0.0768,
+      "log_bad": 0.1674,
+      "log_good": 0.2701
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9049,
+      "good": 5.9092,
+      "ratio": 1.0007,
+      "suggested_scalar": 0.0005,
+      "log_bad": 1.7758,
+      "log_good": 1.7765
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8039,
+      "good": 0.8038,
+      "ratio": 0.9999,
+      "suggested_scalar": -0.0001,
+      "log_bad": -0.2183,
+      "log_good": -0.2184
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2564,
+      "good": 0.2564,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.361,
+      "log_good": -1.361
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.876,
+      "good": 3.388,
+      "ratio": 1.178,
+      "suggested_scalar": 0.1226,
+      "log_bad": 1.0564,
+      "log_good": 1.2202
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 253.0,
+      "good": 251.0,
+      "ratio": 0.9921,
+      "suggested_scalar": -0.0059,
+      "log_bad": 5.5334,
+      "log_good": 5.5255
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 6.0,
+      "good": 7.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.1153,
+      "log_bad": 1.7918,
+      "log_good": 1.9459
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.671,
+      "good": 0.7065,
+      "ratio": 1.0529,
+      "suggested_scalar": 0.0386,
+      "log_bad": -0.399,
+      "log_good": -0.3474
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 96.0,
+      "good": 101.0,
+      "ratio": 1.0521,
+      "suggested_scalar": 0.038,
+      "log_bad": 4.5643,
+      "log_good": 4.6151
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 819.0,
+      "good": 933.0,
+      "ratio": 1.1392,
+      "suggested_scalar": 0.0975,
+      "log_bad": 6.7081,
+      "log_good": 6.8384
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 152.0,
+      "good": 162.0,
+      "ratio": 1.0658,
+      "suggested_scalar": 0.0477,
+      "log_bad": 5.0239,
+      "log_good": 5.0876
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2324,
+      "good": 0.2047,
+      "ratio": 0.8808,
+      "suggested_scalar": -0.0949,
+      "log_bad": -1.4593,
+      "log_good": -1.5862
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 54.0,
+      "good": 54.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.989,
+      "log_good": 3.989
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 96.0,
+      "good": 101.0,
+      "ratio": 1.0521,
+      "suggested_scalar": 0.038,
+      "log_bad": 4.5643,
+      "log_good": 4.6151
+    },
+    "brevity.mean_sample_size": {
+      "bad": 96.0,
+      "good": 101.0,
+      "ratio": 1.0521,
+      "suggested_scalar": 0.038,
+      "log_bad": 4.5643,
+      "log_good": 4.6151
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 327.0,
+      "good": 337.0,
+      "ratio": 1.0306,
+      "suggested_scalar": 0.0225,
+      "log_bad": 5.79,
+      "log_good": 5.8201
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 152.0,
+      "good": 155.0,
+      "ratio": 1.0197,
+      "suggested_scalar": 0.0146,
+      "log_bad": 5.0239,
+      "log_good": 5.0434
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 208.0,
+      "good": 208.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.3375,
+      "log_good": 5.3375
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.9842,
+      "good": 2.1966,
+      "ratio": 1.107,
+      "suggested_scalar": 0.0761,
+      "log_bad": 0.6852,
+      "log_good": 0.7869
+    },
+    "halstead.mean_effort": {
+      "bad": 45699.7217,
+      "good": 48419.9128,
+      "ratio": 1.0595,
+      "suggested_scalar": 0.0433,
+      "log_bad": 10.7298,
+      "log_good": 10.7877
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8967,
+      "good": 0.8875,
+      "ratio": 0.9897,
+      "suggested_scalar": -0.0077,
+      "log_bad": -0.109,
+      "log_good": -0.1193
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 77.0,
+      "good": 78.0,
+      "ratio": 1.013,
+      "suggested_scalar": 0.0097,
+      "log_bad": 4.3438,
+      "log_good": 4.3567
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 151.0,
+      "good": 157.0,
+      "ratio": 1.0397,
+      "suggested_scalar": 0.0291,
+      "log_bad": 5.0173,
+      "log_good": 5.0562
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4485,
+      "good": 0.4694,
+      "ratio": 1.0466,
+      "suggested_scalar": 0.0341,
+      "log_bad": -0.8018,
+      "log_good": -0.7563
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0221,
+      "good": 6.3469,
+      "ratio": 1.0539,
+      "suggested_scalar": 0.0393,
+      "log_bad": 1.7954,
+      "log_good": 1.848
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2564,
+      "good": 0.2564,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.361,
+      "log_good": -1.361
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.7402,
+      "good": 5.5372,
+      "ratio": 1.1681,
+      "suggested_scalar": 0.1163,
+      "log_bad": 1.5561,
+      "log_good": 1.7115
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 326.0,
+      "good": 336.0,
+      "ratio": 1.0307,
+      "suggested_scalar": 0.0226,
+      "log_bad": 5.7869,
+      "log_good": 5.8171
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 41.0,
+      "good": 43.0,
+      "ratio": 1.0488,
+      "suggested_scalar": 0.0356,
+      "log_bad": 3.7136,
+      "log_good": 3.7612
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2538.8734,
+      "good": 2689.9952,
+      "ratio": 1.0595,
+      "suggested_scalar": 0.0433,
+      "log_bad": 7.8395,
+      "log_good": 7.8973
+    },
+    "readability.mean_total_lines": {
+      "bad": 29.0,
+      "good": 29.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3673,
+      "log_good": 3.3673
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 12.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.3033,
+      "log_bad": 2.0794,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2013.0884,
+      "good": 2119.3901,
+      "ratio": 1.0528,
+      "suggested_scalar": 0.0385,
+      "log_bad": 7.6074,
+      "log_good": 7.6589
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 583.0,
+      "good": 606.0,
+      "ratio": 1.0395,
+      "suggested_scalar": 0.0289,
+      "log_bad": 6.3682,
+      "log_good": 6.4069
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 47.8276,
+      "good": 52.1379,
+      "ratio": 1.0901,
+      "suggested_scalar": 0.0645,
+      "log_bad": 3.8676,
+      "log_good": 3.9539
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1552,
+      "good": 1.2,
+      "ratio": 1.0388,
+      "suggested_scalar": 0.0285,
+      "log_bad": 0.1443,
+      "log_good": 0.1823
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.2152,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 17.0,
+      "good": 21.0,
+      "ratio": 1.2353,
+      "suggested_scalar": 0.1581,
+      "log_bad": 2.8332,
+      "log_good": 3.0445
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 9.0,
+      "good": 7.0,
+      "ratio": 0.7778,
+      "suggested_scalar": -0.188,
+      "log_bad": 2.1972,
+      "log_good": 1.9459
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8379,
+      "good": 0.8287,
+      "ratio": 0.989,
+      "suggested_scalar": -0.0083,
+      "log_bad": -0.1769,
+      "log_good": -0.1879
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9855,
+      "good": 0.9806,
+      "ratio": 0.995,
+      "suggested_scalar": -0.0037,
+      "log_bad": -0.0146,
+      "log_good": -0.0196
+    },
+    "halstead.mean_length": {
+      "bad": 303.0,
+      "good": 319.0,
+      "ratio": 1.0528,
+      "suggested_scalar": 0.0385,
+      "log_bad": 5.7137,
+      "log_good": 5.7652
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.585,
+      "good": 6.6582,
+      "ratio": 1.0111,
+      "suggested_scalar": 0.0083,
+      "log_bad": 1.8848,
+      "log_good": 1.8958
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1066,
+      "good": 0.0999,
+      "ratio": 0.9371,
+      "suggested_scalar": -0.0486,
+      "log_bad": -2.2387,
+      "log_good": -2.3036
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 22.7013,
+      "good": 22.8462,
+      "ratio": 1.0064,
+      "suggested_scalar": 0.0048,
+      "log_bad": 3.1224,
+      "log_good": 3.1288
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.5185,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 61.0,
+      "good": 69.0,
+      "ratio": 1.1311,
+      "suggested_scalar": 0.0922,
+      "log_bad": 4.1109,
+      "log_good": 4.2341
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7404,
+      "good": 0.7404,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3006,
+      "log_good": -0.3006
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 29.0,
+      "good": 29.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3673,
+      "log_good": 3.3673
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 19.0,
+      "ratio": 1.1875,
+      "suggested_scalar": 0.1286,
+      "log_bad": 2.7726,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "documentation.doctests_validate_examples": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 17.0,
+      "good": 25.0,
+      "ratio": 1.4706,
+      "suggested_scalar": 0.3846,
+      "log_bad": 2.8332,
+      "log_good": 3.2189
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0392,
+      "good": 0.0476,
+      "ratio": 1.2143,
+      "suggested_scalar": 0.1936,
+      "log_bad": -3.2391,
+      "log_good": -3.0449
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6667,
+      "good": 1.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.5108,
+      "log_good": 0.5108
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8654,
+      "good": 0.8421,
+      "ratio": 0.9731,
+      "suggested_scalar": -0.0272,
+      "log_bad": -0.1446,
+      "log_good": -0.1719
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0392,
+      "good": 0.0476,
+      "ratio": 1.2143,
+      "suggested_scalar": 0.1936,
+      "log_bad": -3.2391,
+      "log_good": -3.0449
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7863,
+      "good": 4.9945,
+      "ratio": 1.0435,
+      "suggested_scalar": 0.0425,
+      "log_bad": 1.5658,
+      "log_good": 1.6083
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 123.0,
+      "good": 92.0,
+      "ratio": 0.748,
+      "suggested_scalar": -0.2896,
+      "log_bad": 4.8122,
+      "log_good": 4.5218
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.7373,
+      "good": 0.4763,
+      "ratio": 0.646,
+      "suggested_scalar": -0.4358,
+      "log_bad": -0.3048,
+      "log_good": -0.7417
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 21.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0487,
+      "log_bad": 2.9957,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7414,
+      "good": 0.6075,
+      "ratio": 0.8194,
+      "suggested_scalar": -0.1986,
+      "log_bad": -0.2992,
+      "log_good": -0.4984
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.5,
+      "good": 4.0,
+      "ratio": 1.6,
+      "suggested_scalar": 0.4687,
+      "log_bad": 0.9163,
+      "log_good": 1.3863
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 586.0,
+      "good": 546.0,
+      "ratio": 0.9317,
+      "suggested_scalar": -0.0705,
+      "log_bad": 6.3733,
+      "log_good": 6.3026
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1346,
+      "good": 1.0,
+      "ratio": 7.4294,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.0054,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0008,
+      "good": 0.0028,
+      "ratio": 3.5,
+      "suggested_scalar": 1.2494,
+      "log_bad": -7.1309,
+      "log_good": -5.8781
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8285,
+      "good": 0.9889,
+      "ratio": 1.1936,
+      "suggested_scalar": 0.1765,
+      "log_bad": -0.1881,
+      "log_good": -0.0112
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 249.0,
+      "good": 174.0,
+      "ratio": 0.6988,
+      "suggested_scalar": -0.3574,
+      "log_bad": 5.5175,
+      "log_good": 5.1591
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 102.8793,
+      "good": 94.0542,
+      "ratio": 0.9142,
+      "suggested_scalar": -0.0894,
+      "log_bad": 4.6336,
+      "log_good": 4.5439
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4051,
+      "good": 0.6165,
+      "ratio": 1.5218,
+      "suggested_scalar": 0.4188,
+      "log_bad": -0.9036,
+      "log_good": -0.4837
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.4853,
+      "good": 10.1207,
+      "ratio": 1.1927,
+      "suggested_scalar": 0.1758,
+      "log_bad": 2.1383,
+      "log_good": 2.3146
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2496.0,
+      "good": 2169.0,
+      "ratio": 0.869,
+      "suggested_scalar": -0.14,
+      "log_bad": 7.8224,
+      "log_good": 7.682
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2692,
+      "good": 0.1228,
+      "ratio": 0.4562,
+      "suggested_scalar": -0.7828,
+      "log_bad": -1.3123,
+      "log_good": -2.0972
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8269,
+      "good": 0.807,
+      "ratio": 0.9759,
+      "suggested_scalar": -0.0243,
+      "log_bad": -0.1901,
+      "log_good": -0.2144
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 13.0222,
+      "good": 9.5789,
+      "ratio": 0.7356,
+      "suggested_scalar": -0.3063,
+      "log_bad": 2.5667,
+      "log_good": 2.2596
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.8269,
+      "good": 4.0702,
+      "ratio": 2.2279,
+      "suggested_scalar": 0.7989,
+      "log_bad": 0.6026,
+      "log_good": 1.4037
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 213.0,
+      "good": 119.0,
+      "ratio": 0.5587,
+      "suggested_scalar": -0.5806,
+      "log_bad": 5.3613,
+      "log_good": 4.7791
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9515,
+      "good": 0.9604,
+      "ratio": 1.0094,
+      "suggested_scalar": 0.0093,
+      "log_bad": -0.0497,
+      "log_good": -0.0404
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 29.0,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0338,
+      "log_bad": 3.4012,
+      "log_good": 3.3673
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5329,
+      "good": 0.633,
+      "ratio": 1.1878,
+      "suggested_scalar": 0.1717,
+      "log_bad": -0.6294,
+      "log_good": -0.4573
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2106,
+      "good": 0.4191,
+      "ratio": 1.99,
+      "suggested_scalar": 0.6863,
+      "log_bad": -1.5578,
+      "log_good": -0.8696
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.1407,
+      "good": 2.7249,
+      "ratio": 1.2729,
+      "suggested_scalar": 0.2406,
+      "log_bad": 0.7611,
+      "log_good": 1.0024
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 584.0,
+      "good": 544.0,
+      "ratio": 0.9315,
+      "suggested_scalar": -0.0708,
+      "log_bad": 6.3699,
+      "log_good": 6.2989
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 21.0,
+      "good": 24.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.1332,
+      "log_bad": 3.0445,
+      "log_good": 3.1781
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0068,
+      "good": 0.0018,
+      "ratio": 0.2647,
+      "suggested_scalar": -1.3255,
+      "log_bad": -4.9908,
+      "log_good": -6.32
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.1898,
+      "good": 6.2095,
+      "ratio": 1.0032,
+      "suggested_scalar": 0.0032,
+      "log_bad": 1.8229,
+      "log_good": 1.8261
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 36.0,
+      "good": 55.0,
+      "ratio": 1.5278,
+      "suggested_scalar": 0.4227,
+      "log_bad": 3.5835,
+      "log_good": 4.0073
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.5961,
+      "good": 0.9001,
+      "ratio": 1.51,
+      "suggested_scalar": 0.411,
+      "log_bad": -0.5173,
+      "log_good": -0.1052
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.6388,
+      "good": 5.8993,
+      "ratio": 0.8886,
+      "suggested_scalar": -0.1178,
+      "log_bad": 1.8929,
+      "log_good": 1.7748
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7732,
+      "good": 0.8043,
+      "ratio": 1.0402,
+      "suggested_scalar": 0.0393,
+      "log_bad": -0.2572,
+      "log_good": -0.2178
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1186,
+      "good": 0.2192,
+      "ratio": 1.8482,
+      "suggested_scalar": 0.6126,
+      "log_bad": -2.132,
+      "log_good": -1.5178
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.913,
+      "good": 3.1813,
+      "ratio": 1.0921,
+      "suggested_scalar": 0.0879,
+      "log_bad": 1.0692,
+      "log_good": 1.1573
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 10.0,
+      "good": 21.0,
+      "ratio": 2.1,
+      "suggested_scalar": 0.7399,
+      "log_bad": 2.3026,
+      "log_good": 3.0445
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 509.0,
+      "good": 378.0,
+      "ratio": 0.7426,
+      "suggested_scalar": -0.2967,
+      "log_bad": 6.2324,
+      "log_good": 5.9349
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 11.0,
+      "good": 10.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0951,
+      "log_bad": 2.3979,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8215,
+      "good": 0.7285,
+      "ratio": 0.8868,
+      "suggested_scalar": -0.1198,
+      "log_bad": -0.1966,
+      "log_good": -0.3168
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 202.0,
+      "good": 137.0,
+      "ratio": 0.6782,
+      "suggested_scalar": -0.3872,
+      "log_bad": 5.3083,
+      "log_good": 4.92
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1466.0,
+      "good": 1159.0,
+      "ratio": 0.7906,
+      "suggested_scalar": -0.2343,
+      "log_bad": 7.2903,
+      "log_good": 7.0553
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 140.0,
+      "good": 97.0,
+      "ratio": 0.6929,
+      "suggested_scalar": -0.3659,
+      "log_bad": 4.9416,
+      "log_good": 4.5747
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0068,
+      "good": 0.0073,
+      "ratio": 1.0735,
+      "suggested_scalar": 0.0708,
+      "log_bad": -4.9908,
+      "log_good": -4.9199
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1536,
+      "good": 0.2344,
+      "ratio": 1.526,
+      "suggested_scalar": 0.4215,
+      "log_bad": -1.8734,
+      "log_good": -1.4507
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 81.0,
+      "good": 85.0,
+      "ratio": 1.0494,
+      "suggested_scalar": 0.0481,
+      "log_bad": 4.3944,
+      "log_good": 4.4427
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 202.0,
+      "good": 137.0,
+      "ratio": 0.6782,
+      "suggested_scalar": -0.3872,
+      "log_bad": 5.3083,
+      "log_good": 4.92
+    },
+    "brevity.mean_sample_size": {
+      "bad": 202.0,
+      "good": 137.0,
+      "ratio": 0.6782,
+      "suggested_scalar": -0.3872,
+      "log_bad": 5.3083,
+      "log_good": 4.92
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 586.0,
+      "good": 546.0,
+      "ratio": 0.9317,
+      "suggested_scalar": -0.0705,
+      "log_bad": 6.3733,
+      "log_good": 6.3026
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 245.0,
+      "good": 294.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.1818,
+      "log_bad": 5.5013,
+      "log_good": 5.6836
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 429.0,
+      "good": 294.0,
+      "ratio": 0.6853,
+      "suggested_scalar": -0.3769,
+      "log_bad": 6.0615,
+      "log_good": 5.6836
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0171,
+      "good": 0.0385,
+      "ratio": 2.2515,
+      "suggested_scalar": 0.8094,
+      "log_bad": -4.0687,
+      "log_good": -3.2571
+    },
+    "heaps.mean_k": {
+      "bad": 1.9833,
+      "good": 3.2433,
+      "ratio": 1.6353,
+      "suggested_scalar": 0.4905,
+      "log_bad": 0.6848,
+      "log_good": 1.1766
+    },
+    "halstead.mean_effort": {
+      "bad": 55652.0921,
+      "good": 48789.7716,
+      "ratio": 0.8767,
+      "suggested_scalar": -0.1312,
+      "log_bad": 10.9269,
+      "log_good": 10.7953
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8669,
+      "good": 0.8311,
+      "ratio": 0.9587,
+      "suggested_scalar": -0.0421,
+      "log_bad": -0.1428,
+      "log_good": -0.185
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 93.0,
+      "good": 63.0,
+      "ratio": 0.6774,
+      "suggested_scalar": -0.3884,
+      "log_bad": 4.5326,
+      "log_good": 4.1431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 215.0,
+      "good": 238.0,
+      "ratio": 1.107,
+      "suggested_scalar": 0.1014,
+      "log_bad": 5.3706,
+      "log_good": 5.4723
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5904,
+      "good": 0.4023,
+      "ratio": 0.6814,
+      "suggested_scalar": -0.3826,
+      "log_bad": -0.527,
+      "log_good": -0.9106
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.8876,
+      "good": 6.6609,
+      "ratio": 1.1313,
+      "suggested_scalar": 0.1231,
+      "log_bad": 1.7728,
+      "log_good": 1.8963
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1186,
+      "good": 0.2192,
+      "ratio": 1.8482,
+      "suggested_scalar": 0.6126,
+      "log_bad": -2.132,
+      "log_good": -1.5178
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.3351,
+      "good": 4.0134,
+      "ratio": 0.7523,
+      "suggested_scalar": -0.2839,
+      "log_bad": 1.6743,
+      "log_good": 1.3896
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 585.0,
+      "good": 545.0,
+      "ratio": 0.9316,
+      "suggested_scalar": -0.0706,
+      "log_bad": 6.3716,
+      "log_good": 6.3008
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 9.0,
+      "good": 13.0,
+      "ratio": 1.4444,
+      "suggested_scalar": 0.3667,
+      "log_bad": 2.1972,
+      "log_good": 2.5649
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 48.0,
+      "good": 62.0,
+      "ratio": 1.2917,
+      "suggested_scalar": 0.2552,
+      "log_bad": 3.8712,
+      "log_good": 4.1271
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3091.7829,
+      "good": 2710.5429,
+      "ratio": 0.8767,
+      "suggested_scalar": -0.1312,
+      "log_bad": 8.0365,
+      "log_good": 7.9049
+    },
+    "readability.mean_total_lines": {
+      "bad": 45.0,
+      "good": 57.0,
+      "ratio": 1.2667,
+      "suggested_scalar": 0.2357,
+      "log_bad": 3.8067,
+      "log_good": 4.0431
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2464.5926,
+      "good": 2185.3933,
+      "ratio": 0.8867,
+      "suggested_scalar": -0.1199,
+      "log_bad": 7.8098,
+      "log_good": 7.6896
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1166.0,
+      "good": 796.0,
+      "ratio": 0.6827,
+      "suggested_scalar": -0.3807,
+      "log_bad": 7.0613,
+      "log_good": 6.6796
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 43.5778,
+      "good": 36.6667,
+      "ratio": 0.8414,
+      "suggested_scalar": -0.1722,
+      "log_bad": 3.7745,
+      "log_good": 3.6019
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0726,
+      "good": 1.2182,
+      "ratio": 1.1357,
+      "suggested_scalar": 0.1269,
+      "log_bad": 0.0701,
+      "log_good": 0.1974
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 39.0,
+      "good": 55.0,
+      "ratio": 1.4103,
+      "suggested_scalar": 0.3428,
+      "log_bad": 3.6636,
+      "log_good": 4.0073
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 1.0,
+      "ratio": 0.1429,
+      "suggested_scalar": -1.9406,
+      "log_bad": 1.9459,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9057,
+      "good": 0.836,
+      "ratio": 0.923,
+      "suggested_scalar": -0.0799,
+      "log_bad": -0.099,
+      "log_good": -0.1791
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9822,
+      "good": 0.9776,
+      "ratio": 0.9953,
+      "suggested_scalar": -0.0047,
+      "log_bad": -0.018,
+      "log_good": -0.0227
+    },
+    "halstead.mean_length": {
+      "bad": 355.0,
+      "good": 335.0,
+      "ratio": 0.9437,
+      "suggested_scalar": -0.0578,
+      "log_bad": 5.8721,
+      "log_good": 5.8141
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 12.6667,
+      "good": 16.3333,
+      "ratio": 1.2895,
+      "suggested_scalar": 0.2535,
+      "log_bad": 2.539,
+      "log_good": 2.7932
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.6582,
+      "good": 7.098,
+      "ratio": 0.9268,
+      "suggested_scalar": -0.0758,
+      "log_bad": 2.0358,
+      "log_good": 1.9598
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0983,
+      "good": 0.1359,
+      "ratio": 1.3825,
+      "suggested_scalar": 0.323,
+      "log_bad": -2.3197,
+      "log_good": -1.9958
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 22.5806,
+      "good": 22.3254,
+      "ratio": 0.9887,
+      "suggested_scalar": -0.0113,
+      "log_bad": 3.1171,
+      "log_good": 3.1057
+    },
+    "branching.mean_branch_count": {
+      "bad": 14.0,
+      "good": 7.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.6913,
+      "log_bad": 2.6391,
+      "log_good": 1.9459
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 147.0,
+      "good": 70.0,
+      "ratio": 0.4762,
+      "suggested_scalar": -0.7399,
+      "log_bad": 4.9904,
+      "log_good": 4.2485
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8112,
+      "good": 0.7109,
+      "ratio": 0.8764,
+      "suggested_scalar": -0.1316,
+      "log_bad": -0.2092,
+      "log_good": -0.3412
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 52.0,
+      "good": 57.0,
+      "ratio": 1.0962,
+      "suggested_scalar": 0.0916,
+      "log_bad": 3.9512,
+      "log_good": 4.0431
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 1.3825,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.no_async_void_outside_event_handlers": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3055,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0036,
+      "good": 0.0093,
+      "ratio": 2.5833,
+      "suggested_scalar": 0.4183,
+      "log_bad": -5.6268,
+      "log_good": -4.6777
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 0.5,
+      "ratio": 0.5,
+      "suggested_scalar": -0.3055,
+      "log_bad": 0.0,
+      "log_good": -0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7636,
+      "good": 0.7121,
+      "ratio": 0.9326,
+      "suggested_scalar": -0.0308,
+      "log_bad": -0.2697,
+      "log_good": -0.3395
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0036,
+      "good": 0.0093,
+      "ratio": 2.5833,
+      "suggested_scalar": 0.4183,
+      "log_bad": -5.6268,
+      "log_good": -4.6777
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.1244,
+      "good": 4.1029,
+      "ratio": 0.9948,
+      "suggested_scalar": -0.0023,
+      "log_bad": 1.4169,
+      "log_good": 1.4117
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 89.0,
+      "good": 91.0,
+      "ratio": 1.0225,
+      "suggested_scalar": 0.0098,
+      "log_bad": 4.4886,
+      "log_good": 4.5109
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.546,
+      "good": 0.5513,
+      "ratio": 1.0097,
+      "suggested_scalar": 0.0043,
+      "log_bad": -0.6051,
+      "log_good": -0.5955
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 13.0,
+      "good": 14.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0327,
+      "log_bad": 2.5649,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7401,
+      "good": 0.7822,
+      "ratio": 1.0569,
+      "suggested_scalar": 0.0244,
+      "log_bad": -0.301,
+      "log_good": -0.2456
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 9.9636,
+      "good": 10.7273,
+      "ratio": 1.0766,
+      "suggested_scalar": 0.0326,
+      "log_bad": 2.2989,
+      "log_good": 2.3728
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 280.0,
+      "good": 323.0,
+      "ratio": 1.1536,
+      "suggested_scalar": 0.063,
+      "log_bad": 5.6348,
+      "log_good": 5.7777
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 7.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.0679,
+      "log_bad": 1.7918,
+      "log_good": 1.9459
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0909,
+      "good": 0.0303,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.4842,
+      "log_bad": -2.398,
+      "log_good": -3.4966
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8886,
+      "good": 0.9288,
+      "ratio": 1.0452,
+      "suggested_scalar": 0.0195,
+      "log_bad": -0.1181,
+      "log_good": -0.0739
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 104.0,
+      "good": 114.0,
+      "ratio": 1.0962,
+      "suggested_scalar": 0.0405,
+      "log_bad": 4.6444,
+      "log_good": 4.7362
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 103.0542,
+      "good": 98.685,
+      "ratio": 0.9576,
+      "suggested_scalar": -0.0191,
+      "log_bad": 4.6353,
+      "log_good": 4.5919
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5376,
+      "good": 0.5683,
+      "ratio": 1.0571,
+      "suggested_scalar": 0.0245,
+      "log_bad": -0.6206,
+      "log_good": -0.5651
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 18.3498,
+      "good": 21.4392,
+      "ratio": 1.1684,
+      "suggested_scalar": 0.0686,
+      "log_bad": 2.9096,
+      "log_good": 3.0652
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1915.0,
+      "good": 2217.0,
+      "ratio": 1.1577,
+      "suggested_scalar": 0.0645,
+      "log_bad": 7.5575,
+      "log_good": 7.7039
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1273,
+      "good": 0.1364,
+      "ratio": 1.0715,
+      "suggested_scalar": 0.0304,
+      "log_bad": -2.0612,
+      "log_good": -1.9922
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.5455,
+      "good": 0.5455,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.6061,
+      "log_good": -0.6061
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.0909,
+      "good": 4.8939,
+      "ratio": 0.9613,
+      "suggested_scalar": -0.0174,
+      "log_bad": 1.6275,
+      "log_good": 1.588
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 13.0,
+      "good": 14.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0327,
+      "log_bad": 2.5649,
+      "log_good": 2.6391
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 23.1987,
+      "good": 26.7438,
+      "ratio": 1.1528,
+      "suggested_scalar": 0.0627,
+      "log_bad": 3.1441,
+      "log_good": 3.2863
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 60.0,
+      "good": 51.0,
+      "ratio": 0.85,
+      "suggested_scalar": -0.0716,
+      "log_bad": 4.0943,
+      "log_good": 3.9318
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9401,
+      "good": 0.9485,
+      "ratio": 1.0089,
+      "suggested_scalar": 0.0039,
+      "log_bad": -0.0618,
+      "log_good": -0.0529
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 27.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0519,
+      "log_bad": 3.1781,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6898,
+      "good": 0.6973,
+      "ratio": 1.0109,
+      "suggested_scalar": 0.0048,
+      "log_bad": -0.3714,
+      "log_good": -0.3605
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4424,
+      "good": 0.4486,
+      "ratio": 1.014,
+      "suggested_scalar": 0.0061,
+      "log_bad": -0.8155,
+      "log_good": -0.8016
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.2239,
+      "good": 3.304,
+      "ratio": 1.0248,
+      "suggested_scalar": 0.0108,
+      "log_bad": 1.1706,
+      "log_good": 1.1951
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 278.0,
+      "good": 321.0,
+      "ratio": 1.1547,
+      "suggested_scalar": 0.0634,
+      "log_bad": 5.6276,
+      "log_good": 5.7714
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 19.0,
+      "good": 25.0,
+      "ratio": 1.3158,
+      "suggested_scalar": 0.121,
+      "log_bad": 2.9444,
+      "log_good": 3.2189
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0107,
+      "good": 1.0,
+      "ratio": 93.4579,
+      "suggested_scalar": 2.0,
+      "log_bad": -4.5375,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7814,
+      "good": 5.9773,
+      "ratio": 1.0339,
+      "suggested_scalar": 0.0147,
+      "log_bad": 1.7546,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 31.0,
+      "good": 49.0,
+      "ratio": 1.5806,
+      "suggested_scalar": 0.2018,
+      "log_bad": 3.434,
+      "log_good": 3.8918
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3533,
+      "good": 1.4143,
+      "ratio": 1.0451,
+      "suggested_scalar": 0.0194,
+      "log_bad": 0.3025,
+      "log_good": 0.3466
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.736,
+      "good": 5.7459,
+      "ratio": 1.0017,
+      "suggested_scalar": 0.0008,
+      "log_bad": 1.7468,
+      "log_good": 1.7485
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7134,
+      "good": 0.6864,
+      "ratio": 0.9622,
+      "suggested_scalar": -0.017,
+      "log_bad": -0.3377,
+      "log_good": -0.3763
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.0984,
+      "good": 0.1081,
+      "ratio": 1.0986,
+      "suggested_scalar": 0.0414,
+      "log_bad": -2.3187,
+      "log_good": -2.2247
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.2837,
+      "good": 4.6302,
+      "ratio": 1.0809,
+      "suggested_scalar": 0.0343,
+      "log_bad": 1.4548,
+      "log_good": 1.5326
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 201.0,
+      "good": 236.0,
+      "ratio": 1.1741,
+      "suggested_scalar": 0.0708,
+      "log_bad": 5.3033,
+      "log_good": 5.4638
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 10.0,
+      "good": 14.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.1483,
+      "log_bad": 2.3026,
+      "log_good": 2.6391
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5958,
+      "good": 0.6638,
+      "ratio": 1.1141,
+      "suggested_scalar": 0.0476,
+      "log_bad": -0.5179,
+      "log_good": -0.4098
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 90.0,
+      "good": 98.0,
+      "ratio": 1.0889,
+      "suggested_scalar": 0.0375,
+      "log_bad": 4.4998,
+      "log_good": 4.585
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 793.0,
+      "good": 886.0,
+      "ratio": 1.1173,
+      "suggested_scalar": 0.0489,
+      "log_bad": 6.6758,
+      "log_good": 6.7867
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 129.0,
+      "good": 129.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.8598,
+      "log_good": 4.8598
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1964,
+      "good": 0.2167,
+      "ratio": 1.1034,
+      "suggested_scalar": 0.0434,
+      "log_bad": -1.6276,
+      "log_good": -1.5292
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 43.0,
+      "good": 60.0,
+      "ratio": 1.3953,
+      "suggested_scalar": 0.1468,
+      "log_bad": 3.7612,
+      "log_good": 4.0943
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 90.0,
+      "good": 98.0,
+      "ratio": 1.0889,
+      "suggested_scalar": 0.0375,
+      "log_bad": 4.4998,
+      "log_good": 4.585
+    },
+    "brevity.mean_sample_size": {
+      "bad": 90.0,
+      "good": 98.0,
+      "ratio": 1.0889,
+      "suggested_scalar": 0.0375,
+      "log_bad": 4.4998,
+      "log_good": 4.585
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 280.0,
+      "good": 323.0,
+      "ratio": 1.1536,
+      "suggested_scalar": 0.063,
+      "log_bad": 5.6348,
+      "log_good": 5.7777
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 117.0,
+      "good": 148.0,
+      "ratio": 1.265,
+      "suggested_scalar": 0.1036,
+      "log_bad": 4.7622,
+      "log_good": 4.9972
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 172.0,
+      "good": 199.0,
+      "ratio": 1.157,
+      "suggested_scalar": 0.0643,
+      "log_bad": 5.1475,
+      "log_good": 5.2933
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.4573,
+      "good": 1.1637,
+      "ratio": 0.7985,
+      "suggested_scalar": -0.0992,
+      "log_bad": 0.3766,
+      "log_good": 0.1516
+    },
+    "halstead.mean_effort": {
+      "bad": 42565.2947,
+      "good": 54187.4571,
+      "ratio": 1.273,
+      "suggested_scalar": 0.1064,
+      "log_bad": 10.6588,
+      "log_good": 10.9002
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8836,
+      "good": 0.8687,
+      "ratio": 0.9831,
+      "suggested_scalar": -0.0075,
+      "log_bad": -0.1238,
+      "log_good": -0.1408
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 65.0,
+      "good": 64.0,
+      "ratio": 0.9846,
+      "suggested_scalar": -0.0068,
+      "log_bad": 4.1744,
+      "log_good": 4.1589
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 147.0,
+      "good": 177.0,
+      "ratio": 1.2041,
+      "suggested_scalar": 0.0819,
+      "log_bad": 4.9904,
+      "log_good": 5.1761
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5481,
+      "good": 0.5263,
+      "ratio": 0.9602,
+      "suggested_scalar": -0.0179,
+      "log_bad": -0.6013,
+      "log_good": -0.6419
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.625,
+      "good": 7.7719,
+      "ratio": 1.0193,
+      "suggested_scalar": 0.0084,
+      "log_bad": 2.0314,
+      "log_good": 2.0505
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.0984,
+      "good": 0.1081,
+      "ratio": 1.0986,
+      "suggested_scalar": 0.0414,
+      "log_bad": -2.3187,
+      "log_good": -2.2247
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.245,
+      "good": 4.5009,
+      "ratio": 1.0603,
+      "suggested_scalar": 0.0258,
+      "log_bad": 1.4457,
+      "log_good": 1.5043
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 279.0,
+      "good": 322.0,
+      "ratio": 1.1541,
+      "suggested_scalar": 0.0632,
+      "log_bad": 5.6312,
+      "log_good": 5.7746
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 46.0,
+      "good": 59.0,
+      "ratio": 1.2826,
+      "suggested_scalar": 0.1097,
+      "log_bad": 3.8286,
+      "log_good": 4.0775
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2364.7386,
+      "good": 3010.4143,
+      "ratio": 1.273,
+      "suggested_scalar": 0.1064,
+      "log_bad": 7.7684,
+      "log_good": 8.0098
+    },
+    "readability.mean_total_lines": {
+      "bad": 55.0,
+      "good": 66.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0804,
+      "log_bad": 4.0073,
+      "log_good": 4.1897
+    },
+    "indentation.mean_max_depth": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "halstead.mean_volume": {
+      "bad": 1787.3024,
+      "good": 1991.3852,
+      "ratio": 1.1142,
+      "suggested_scalar": 0.0477,
+      "log_bad": 7.4885,
+      "log_good": 7.5966
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 594.0,
+      "good": 671.0,
+      "ratio": 1.1296,
+      "suggested_scalar": 0.0537,
+      "log_bad": 6.3869,
+      "log_good": 6.5088
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 33.6727,
+      "good": 32.4394,
+      "ratio": 0.9634,
+      "suggested_scalar": -0.0164,
+      "log_bad": 3.5167,
+      "log_good": 3.4794
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1656,
+      "good": 1.2197,
+      "ratio": 1.0464,
+      "suggested_scalar": 0.02,
+      "log_bad": 0.1532,
+      "log_good": 0.1986
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 7.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.0679,
+      "log_bad": 1.7918,
+      "log_good": 1.9459
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 13.0,
+      "good": 19.0,
+      "ratio": 1.4615,
+      "suggested_scalar": 0.1673,
+      "log_bad": 2.5649,
+      "log_good": 2.9444
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 2.0,
+      "ratio": 0.4,
+      "suggested_scalar": -0.4039,
+      "log_bad": 1.6094,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7711,
+      "good": 0.75,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.0122,
+      "log_bad": -0.2599,
+      "log_good": -0.2877
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9717,
+      "good": 0.9804,
+      "ratio": 1.009,
+      "suggested_scalar": 0.0039,
+      "log_bad": -0.0287,
+      "log_good": -0.0198
+    },
+    "halstead.mean_length": {
+      "bad": 276.0,
+      "good": 306.0,
+      "ratio": 1.1087,
+      "suggested_scalar": 0.0455,
+      "log_bad": 5.6204,
+      "log_good": 5.7236
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.0,
+      "good": 14.0,
+      "ratio": 1.2727,
+      "suggested_scalar": 0.1063,
+      "log_bad": 2.3979,
+      "log_good": 2.6391
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4919,
+      "good": 6.6147,
+      "ratio": 1.0189,
+      "suggested_scalar": 0.0083,
+      "log_bad": 1.8706,
+      "log_good": 1.8893
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0612,
+      "good": 0.0668,
+      "ratio": 1.0915,
+      "suggested_scalar": 0.0386,
+      "log_bad": -2.7936,
+      "log_good": -2.7061
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 23.8154,
+      "good": 27.2109,
+      "ratio": 1.1426,
+      "suggested_scalar": 0.0587,
+      "log_bad": 3.1703,
+      "log_good": 3.3036
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 9.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.1108,
+      "log_bad": 1.9459,
+      "log_good": 2.1972
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 57.0,
+      "good": 60.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0226,
+      "log_bad": 4.0431,
+      "log_good": 4.0943
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.75,
+      "good": 0.6985,
+      "ratio": 0.9313,
+      "suggested_scalar": -0.0314,
+      "log_bad": -0.2877,
+      "log_good": -0.3588
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 55.0,
+      "good": 66.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0804,
+      "log_bad": 4.0073,
+      "log_good": 4.1897
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 22.0,
+      "good": 26.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0736,
+      "log_bad": 3.091,
+      "log_good": 3.2581
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.no_unrelated_clauses_in_multi_clause_function": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 18.0,
+      "good": 22.0,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.0541,
+      "log_bad": 2.8904,
+      "log_good": 3.091
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1869,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0155,
+      "good": 0.0316,
+      "ratio": 2.0387,
+      "suggested_scalar": 0.192,
+      "log_bad": -4.1669,
+      "log_good": -3.4546
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.1111,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0284,
+      "log_bad": 0.0,
+      "log_good": 0.1054
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8571,
+      "good": 0.8,
+      "ratio": 0.9334,
+      "suggested_scalar": -0.0186,
+      "log_bad": -0.1542,
+      "log_good": -0.2231
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0155,
+      "good": 0.0316,
+      "ratio": 2.0387,
+      "suggested_scalar": 0.192,
+      "log_bad": -4.1669,
+      "log_good": -3.4546
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7722,
+      "good": 4.8553,
+      "ratio": 1.0174,
+      "suggested_scalar": 0.0047,
+      "log_bad": 1.5628,
+      "log_good": 1.5801
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 99.0,
+      "good": 66.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1093,
+      "log_bad": 4.5951,
+      "log_good": 4.1897
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4893,
+      "good": 0.4362,
+      "ratio": 0.8915,
+      "suggested_scalar": -0.031,
+      "log_bad": -0.7148,
+      "log_good": -0.8297
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 16.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0163,
+      "log_bad": 2.8332,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6348,
+      "good": 0.5414,
+      "ratio": 0.8529,
+      "suggested_scalar": -0.0429,
+      "log_bad": -0.4544,
+      "log_good": -0.6136
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.7143,
+      "good": 2.35,
+      "ratio": 0.8658,
+      "suggested_scalar": -0.0389,
+      "log_bad": 0.9985,
+      "log_good": 0.8544
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 387.0,
+      "good": 475.0,
+      "ratio": 1.2274,
+      "suggested_scalar": 0.0552,
+      "log_bad": 5.9584,
+      "log_good": 6.1633
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1093,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2143,
+      "good": 1.0,
+      "ratio": 4.6664,
+      "suggested_scalar": 0.4153,
+      "log_bad": -1.5404,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0006,
+      "good": 1.0,
+      "ratio": 1666.6667,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.4186,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9951,
+      "good": 1.0808,
+      "ratio": 1.0861,
+      "suggested_scalar": 0.0223,
+      "log_bad": -0.0049,
+      "log_good": 0.0777
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 154.0,
+      "good": 184.0,
+      "ratio": 1.1948,
+      "suggested_scalar": 0.048,
+      "log_bad": 5.037,
+      "log_good": 5.2149
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 107.6881,
+      "good": 105.5463,
+      "ratio": 0.9801,
+      "suggested_scalar": -0.0054,
+      "log_bad": 4.6792,
+      "log_good": 4.6591
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5596,
+      "good": 0.6878,
+      "ratio": 1.2291,
+      "suggested_scalar": 0.0556,
+      "log_bad": -0.5805,
+      "log_good": -0.3743
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.2299,
+      "good": 10.1486,
+      "ratio": 1.2331,
+      "suggested_scalar": 0.0565,
+      "log_bad": 2.1078,
+      "log_good": 2.3173
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1575.0,
+      "good": 1678.0,
+      "ratio": 1.0654,
+      "suggested_scalar": 0.0171,
+      "log_bad": 7.362,
+      "log_good": 7.4254
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0476,
+      "good": 0.075,
+      "ratio": 1.5756,
+      "suggested_scalar": 0.1226,
+      "log_bad": -3.0449,
+      "log_good": -2.5903
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8095,
+      "good": 0.75,
+      "ratio": 0.9265,
+      "suggested_scalar": -0.0206,
+      "log_bad": -0.2113,
+      "log_good": -0.2877
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 11.7273,
+      "good": 11.875,
+      "ratio": 1.0126,
+      "suggested_scalar": 0.0034,
+      "log_bad": 2.4619,
+      "log_good": 2.4744
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.1869,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.6803,
+      "good": 1.3775,
+      "ratio": 0.8198,
+      "suggested_scalar": -0.0536,
+      "log_bad": 0.519,
+      "log_good": 0.3203
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 118.0,
+      "good": 142.0,
+      "ratio": 1.2034,
+      "suggested_scalar": 0.0499,
+      "log_bad": 4.7707,
+      "log_good": 4.9558
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9445,
+      "good": 0.9334,
+      "ratio": 0.9882,
+      "suggested_scalar": -0.0032,
+      "log_bad": -0.0571,
+      "log_good": -0.0689
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 23.0,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.012,
+      "log_bad": 3.091,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5886,
+      "good": 0.6013,
+      "ratio": 1.0216,
+      "suggested_scalar": 0.0058,
+      "log_bad": -0.53,
+      "log_good": -0.5087
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3636,
+      "good": 0.5011,
+      "ratio": 1.3782,
+      "suggested_scalar": 0.0865,
+      "log_bad": -1.0117,
+      "log_good": -0.6909
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4306,
+      "good": 2.5082,
+      "ratio": 1.0319,
+      "suggested_scalar": 0.0085,
+      "log_bad": 0.8881,
+      "log_good": 0.9196
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 385.0,
+      "good": 473.0,
+      "ratio": 1.2286,
+      "suggested_scalar": 0.0555,
+      "log_bad": 5.9532,
+      "log_good": 6.1591
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 7.0,
+      "good": 10.0,
+      "ratio": 1.4286,
+      "suggested_scalar": 0.0962,
+      "log_bad": 1.9459,
+      "log_good": 2.3026
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0594,
+      "good": 0.0484,
+      "ratio": 0.8148,
+      "suggested_scalar": -0.0552,
+      "log_bad": -2.8235,
+      "log_good": -3.0283
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.858,
+      "good": 5.8329,
+      "ratio": 0.9957,
+      "suggested_scalar": -0.0012,
+      "log_bad": 1.7678,
+      "log_good": 1.7635
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 34.0,
+      "good": 41.0,
+      "ratio": 1.2059,
+      "suggested_scalar": 0.0505,
+      "log_bad": 3.5264,
+      "log_good": 3.7136
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8569,
+      "good": 0.812,
+      "ratio": 0.9476,
+      "suggested_scalar": -0.0145,
+      "log_bad": -0.1544,
+      "log_good": -0.2083
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7489,
+      "good": 5.653,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0045,
+      "log_bad": 1.749,
+      "log_good": 1.7322
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8146,
+      "good": 0.8324,
+      "ratio": 1.0219,
+      "suggested_scalar": 0.0058,
+      "log_bad": -0.2051,
+      "log_good": -0.1834
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1765,
+      "good": 0.1304,
+      "ratio": 0.7388,
+      "suggested_scalar": -0.0816,
+      "log_bad": -1.7344,
+      "log_good": -2.0371
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.8688,
+      "good": 3.1857,
+      "ratio": 1.1105,
+      "suggested_scalar": 0.0282,
+      "log_bad": 1.0539,
+      "log_good": 1.1587
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 295.0,
+      "good": 318.0,
+      "ratio": 1.078,
+      "suggested_scalar": 0.0202,
+      "log_bad": 5.687,
+      "log_good": 5.7621
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 3.0,
+      "good": 8.0,
+      "ratio": 2.6667,
+      "suggested_scalar": 0.2644,
+      "log_bad": 1.0986,
+      "log_good": 2.0794
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7778,
+      "good": 0.7455,
+      "ratio": 0.9585,
+      "suggested_scalar": -0.0114,
+      "log_bad": -0.2513,
+      "log_good": -0.2937
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 102.0,
+      "good": 102.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.625,
+      "log_good": 4.625
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 944.0,
+      "good": 1001.0,
+      "ratio": 1.0604,
+      "suggested_scalar": 0.0158,
+      "log_bad": 6.8501,
+      "log_good": 6.9088
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 161.0,
+      "good": 135.0,
+      "ratio": 0.8385,
+      "suggested_scalar": -0.0475,
+      "log_bad": 5.0814,
+      "log_good": 4.9053
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0052,
+      "good": 0.0042,
+      "ratio": 0.8077,
+      "suggested_scalar": -0.0576,
+      "log_bad": -5.2591,
+      "log_good": -5.4727
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2636,
+      "good": 0.2632,
+      "ratio": 0.9985,
+      "suggested_scalar": -0.0004,
+      "log_bad": -1.3333,
+      "log_good": -1.3348
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 68.0,
+      "good": 97.0,
+      "ratio": 1.4265,
+      "suggested_scalar": 0.0958,
+      "log_bad": 4.2195,
+      "log_good": 4.5747
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 8.0,
+      "good": 9.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0318,
+      "log_bad": 2.0794,
+      "log_good": 2.1972
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 102.0,
+      "good": 102.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.625,
+      "log_good": 4.625
+    },
+    "brevity.mean_sample_size": {
+      "bad": 102.0,
+      "good": 102.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.625,
+      "log_good": 4.625
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 387.0,
+      "good": 475.0,
+      "ratio": 1.2274,
+      "suggested_scalar": 0.0552,
+      "log_bad": 5.9584,
+      "log_good": 6.1633
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 191.0,
+      "good": 250.0,
+      "ratio": 1.3089,
+      "suggested_scalar": 0.0726,
+      "log_bad": 5.2523,
+      "log_good": 5.5215
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 238.0,
+      "good": 245.0,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.0078,
+      "log_bad": 5.4723,
+      "log_good": 5.5013
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0021,
+      "ratio": 0.0021,
+      "suggested_scalar": -1.6623,
+      "log_bad": 0.0,
+      "log_good": -6.1658
+    },
+    "heaps.mean_k": {
+      "bad": 2.4418,
+      "good": 3.9504,
+      "ratio": 1.6178,
+      "suggested_scalar": 0.1297,
+      "log_bad": 0.8927,
+      "log_good": 1.3738
+    },
+    "halstead.mean_effort": {
+      "bad": 53671.2712,
+      "good": 80745.3742,
+      "ratio": 1.5044,
+      "suggested_scalar": 0.1101,
+      "log_bad": 10.8906,
+      "log_good": 11.2991
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8616,
+      "good": 0.8472,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0045,
+      "log_bad": -0.149,
+      "log_good": -0.1658
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 77.0,
+      "good": 43.0,
+      "ratio": 0.5584,
+      "suggested_scalar": -0.1571,
+      "log_bad": 4.3438,
+      "log_good": 3.7612
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 191.0,
+      "good": 235.0,
+      "ratio": 1.2304,
+      "suggested_scalar": 0.0559,
+      "log_bad": 5.2523,
+      "log_good": 5.4596
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.461,
+      "good": 0.3804,
+      "ratio": 0.8252,
+      "suggested_scalar": -0.0518,
+      "log_bad": -0.7744,
+      "log_good": -0.9665
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.1299,
+      "good": 5.4402,
+      "ratio": 0.8875,
+      "suggested_scalar": -0.0322,
+      "log_bad": 1.8132,
+      "log_good": 1.6938
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1765,
+      "good": 0.1304,
+      "ratio": 0.7388,
+      "suggested_scalar": -0.0816,
+      "log_bad": -1.7344,
+      "log_good": -2.0371
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.6909,
+      "good": 4.9326,
+      "ratio": 1.0515,
+      "suggested_scalar": 0.0135,
+      "log_bad": 1.5456,
+      "log_good": 1.5959
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 386.0,
+      "good": 474.0,
+      "ratio": 1.228,
+      "suggested_scalar": 0.0554,
+      "log_bad": 5.9558,
+      "log_good": 6.1612
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 50.0,
+      "good": 82.0,
+      "ratio": 1.64,
+      "suggested_scalar": 0.1334,
+      "log_bad": 3.912,
+      "log_good": 4.4067
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2981.7373,
+      "good": 4485.8541,
+      "ratio": 1.5044,
+      "suggested_scalar": 0.1101,
+      "log_bad": 8.0003,
+      "log_good": 8.4087
+    },
+    "readability.mean_total_lines": {
+      "bad": 33.0,
+      "good": 40.0,
+      "ratio": 1.2121,
+      "suggested_scalar": 0.0519,
+      "log_bad": 3.4965,
+      "log_good": 3.6889
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2333.5335,
+      "good": 2236.4258,
+      "ratio": 0.9584,
+      "suggested_scalar": -0.0115,
+      "log_bad": 7.7551,
+      "log_good": 7.7126
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 648.0,
+      "good": 669.0,
+      "ratio": 1.0324,
+      "suggested_scalar": 0.0086,
+      "log_bad": 6.4739,
+      "log_good": 6.5058
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.6061,
+      "good": 40.8,
+      "ratio": 1.2909,
+      "suggested_scalar": 0.0688,
+      "log_bad": 3.4534,
+      "log_good": 3.7087
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0313,
+      "good": 1.0548,
+      "ratio": 1.0228,
+      "suggested_scalar": 0.0061,
+      "log_bad": 0.0308,
+      "log_good": 0.0534
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1093,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 14.0,
+      "good": 27.0,
+      "ratio": 1.9286,
+      "suggested_scalar": 0.1771,
+      "log_bad": 2.6391,
+      "log_good": 3.2958
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 9.0,
+      "good": 1.0,
+      "ratio": 0.1111,
+      "suggested_scalar": -0.5924,
+      "log_bad": 2.1972,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8305,
+      "good": 0.7421,
+      "ratio": 0.8936,
+      "suggested_scalar": -0.0303,
+      "log_bad": -0.1857,
+      "log_good": -0.2983
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 5.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.247,
+      "log_bad": 0.6931,
+      "log_good": 1.6094
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9573,
+      "good": 0.9527,
+      "ratio": 0.9952,
+      "suggested_scalar": -0.0013,
+      "log_bad": -0.0436,
+      "log_good": -0.0485
+    },
+    "halstead.mean_length": {
+      "bad": 352.0,
+      "good": 370.0,
+      "ratio": 1.0511,
+      "suggested_scalar": 0.0134,
+      "log_bad": 5.8636,
+      "log_good": 5.9135
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.25,
+      "good": 4.7778,
+      "ratio": 0.9101,
+      "suggested_scalar": -0.0254,
+      "log_bad": 1.6582,
+      "log_good": 1.564
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6724,
+      "good": 6.6724,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.898,
+      "log_good": 1.898
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1219,
+      "good": 0.149,
+      "ratio": 1.2223,
+      "suggested_scalar": 0.0541,
+      "log_bad": -2.1046,
+      "log_good": -1.9038
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 23.0,
+      "good": 36.1047,
+      "ratio": 1.5698,
+      "suggested_scalar": 0.1216,
+      "log_bad": 3.1355,
+      "log_good": 3.5864
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1093,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 71.0,
+      "good": 70.0,
+      "ratio": 0.9859,
+      "suggested_scalar": -0.0038,
+      "log_bad": 4.2627,
+      "log_good": 4.2485
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7143,
+      "good": 0.6041,
+      "ratio": 0.8457,
+      "suggested_scalar": -0.0452,
+      "log_bad": -0.3365,
+      "log_good": -0.504
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 42.0,
+      "good": 40.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0132,
+      "log_bad": 3.7377,
+      "log_good": 3.6889
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 15.0,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.0186,
+      "log_bad": 2.6391,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.does_not_throw_from_finally_block": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 14.0,
+      "good": 9.0,
+      "ratio": 0.6429,
+      "suggested_scalar": -0.1512,
+      "log_bad": 2.6391,
+      "log_good": 2.1972
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0186,
+      "good": 0.0144,
+      "ratio": 0.7742,
+      "suggested_scalar": -0.0876,
+      "log_bad": -3.9846,
+      "log_good": -4.2405
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.8333,
+      "good": 0.8,
+      "ratio": 0.96,
+      "suggested_scalar": -0.014,
+      "log_bad": -0.1824,
+      "log_good": -0.2231
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.75,
+      "good": 0.6883,
+      "ratio": 0.9177,
+      "suggested_scalar": -0.0294,
+      "log_bad": -0.2877,
+      "log_good": -0.3735
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0186,
+      "good": 0.0144,
+      "ratio": 0.7742,
+      "suggested_scalar": -0.0876,
+      "log_bad": -3.9846,
+      "log_good": -4.2405
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.0531,
+      "good": 3.7558,
+      "ratio": 0.9266,
+      "suggested_scalar": -0.0261,
+      "log_bad": 1.3995,
+      "log_good": 1.3233
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 103.0,
+      "good": 99.0,
+      "ratio": 0.9612,
+      "suggested_scalar": -0.0136,
+      "log_bad": 4.6347,
+      "log_good": 4.5951
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5995,
+      "good": 0.5683,
+      "ratio": 0.948,
+      "suggested_scalar": -0.0183,
+      "log_bad": -0.5117,
+      "log_good": -0.5651
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7595,
+      "good": 0.7708,
+      "ratio": 1.0149,
+      "suggested_scalar": 0.0051,
+      "log_bad": -0.2751,
+      "log_good": -0.2603
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 11.3333,
+      "good": 12.6753,
+      "ratio": 1.1184,
+      "suggested_scalar": 0.0383,
+      "log_bad": 2.4277,
+      "log_good": 2.5397
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 376.0,
+      "good": 347.0,
+      "ratio": 0.9229,
+      "suggested_scalar": -0.0275,
+      "log_bad": 5.9296,
+      "log_good": 5.8493
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 7.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.0528,
+      "log_bad": 1.7918,
+      "log_good": 1.9459
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0008,
+      "good": 0.0004,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2373,
+      "log_bad": -7.1309,
+      "log_good": -7.824
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0417,
+      "good": 0.039,
+      "ratio": 0.9353,
+      "suggested_scalar": -0.0229,
+      "log_bad": -3.1773,
+      "log_good": -3.2442
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0008,
+      "good": 0.0004,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2373,
+      "log_bad": -7.1309,
+      "log_good": -7.824
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8795,
+      "good": 0.9009,
+      "ratio": 1.0243,
+      "suggested_scalar": 0.0082,
+      "log_bad": -0.1284,
+      "log_good": -0.1044
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 118.0,
+      "good": 117.0,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0029,
+      "log_bad": 4.7707,
+      "log_good": 4.7622
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 92.0244,
+      "good": 98.3662,
+      "ratio": 1.0689,
+      "suggested_scalar": 0.0228,
+      "log_bad": 4.5221,
+      "log_good": 4.5887
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5067,
+      "good": 0.4913,
+      "ratio": 0.9696,
+      "suggested_scalar": -0.0106,
+      "log_bad": -0.6798,
+      "log_good": -0.7107
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 18.8398,
+      "good": 12.4836,
+      "ratio": 0.6626,
+      "suggested_scalar": -0.1409,
+      "log_bad": 2.936,
+      "log_good": 2.5244
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2442.0,
+      "good": 2424.0,
+      "ratio": 0.9926,
+      "suggested_scalar": -0.0025,
+      "log_bad": 7.8006,
+      "log_good": 7.7932
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1667,
+      "good": 0.1558,
+      "ratio": 0.9346,
+      "suggested_scalar": -0.0231,
+      "log_bad": -1.7916,
+      "log_good": -1.8592
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6389,
+      "good": 0.5195,
+      "ratio": 0.8131,
+      "suggested_scalar": -0.0708,
+      "log_bad": -0.448,
+      "log_good": -0.6549
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.2222,
+      "good": 4.5065,
+      "ratio": 0.863,
+      "suggested_scalar": -0.0505,
+      "log_bad": 1.6529,
+      "log_good": 1.5055
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.1748,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 24.8889,
+      "good": 32.5829,
+      "ratio": 1.3091,
+      "suggested_scalar": 0.0922,
+      "log_bad": 3.2144,
+      "log_good": 3.4838
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 50.0,
+      "good": 53.0,
+      "ratio": 1.06,
+      "suggested_scalar": 0.0199,
+      "log_bad": 3.912,
+      "log_good": 3.9703
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9593,
+      "good": 0.9537,
+      "ratio": 0.9942,
+      "suggested_scalar": -0.002,
+      "log_bad": -0.0416,
+      "log_good": -0.0474
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 29.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3673,
+      "log_good": 3.3673
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6765,
+      "good": 0.6885,
+      "ratio": 1.0177,
+      "suggested_scalar": 0.006,
+      "log_bad": -0.3908,
+      "log_good": -0.3732
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2594,
+      "good": 0.2783,
+      "ratio": 1.0729,
+      "suggested_scalar": 0.0241,
+      "log_bad": -1.3494,
+      "log_good": -1.2791
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0911,
+      "good": 3.2106,
+      "ratio": 1.0387,
+      "suggested_scalar": 0.013,
+      "log_bad": 1.1285,
+      "log_good": 1.1665
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 374.0,
+      "good": 345.0,
+      "ratio": 0.9225,
+      "suggested_scalar": -0.0276,
+      "log_bad": 5.9243,
+      "log_good": 5.8435
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 24.0,
+      "good": 29.0,
+      "ratio": 1.2083,
+      "suggested_scalar": 0.0648,
+      "log_bad": 3.1781,
+      "log_good": 3.3673
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 0.0029,
+      "ratio": 0.0029,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.843
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0224,
+      "good": 6.0,
+      "ratio": 0.9963,
+      "suggested_scalar": -0.0013,
+      "log_bad": 1.7955,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 51.0,
+      "good": 50.0,
+      "ratio": 0.9804,
+      "suggested_scalar": -0.0068,
+      "log_bad": 3.9318,
+      "log_good": 3.912
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.5475,
+      "good": 1.5207,
+      "ratio": 0.9827,
+      "suggested_scalar": -0.006,
+      "log_bad": 0.4366,
+      "log_good": 0.4192
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8922,
+      "good": 5.8136,
+      "ratio": 0.9867,
+      "suggested_scalar": -0.0046,
+      "log_bad": 1.7736,
+      "log_good": 1.7602
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.673,
+      "good": 0.626,
+      "ratio": 0.9302,
+      "suggested_scalar": -0.0248,
+      "log_bad": -0.396,
+      "log_good": -0.4684
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1111,
+      "good": 0.0833,
+      "ratio": 0.7498,
+      "suggested_scalar": -0.0986,
+      "log_bad": -2.1973,
+      "log_good": -2.4853
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.3405,
+      "good": 3.5332,
+      "ratio": 0.814,
+      "suggested_scalar": -0.0704,
+      "log_bad": 1.468,
+      "log_good": 1.2622
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 320.0,
+      "good": 287.0,
+      "ratio": 0.8969,
+      "suggested_scalar": -0.0373,
+      "log_bad": 5.7683,
+      "log_good": 5.6595
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 16.0,
+      "good": 17.0,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.0208,
+      "log_bad": 2.7726,
+      "log_good": 2.8332
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7756,
+      "good": 0.7093,
+      "ratio": 0.9145,
+      "suggested_scalar": -0.0306,
+      "log_bad": -0.2541,
+      "log_good": -0.3435
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 114.0,
+      "good": 108.0,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.0185,
+      "log_bad": 4.7362,
+      "log_good": 4.6821
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 929.0,
+      "good": 812.0,
+      "ratio": 0.8741,
+      "suggested_scalar": -0.0461,
+      "log_bad": 6.8341,
+      "log_good": 6.6995
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 142.0,
+      "good": 134.0,
+      "ratio": 0.9437,
+      "suggested_scalar": -0.0198,
+      "log_bad": 4.9558,
+      "log_good": 4.8978
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0053,
+      "good": 0.0058,
+      "ratio": 1.0943,
+      "suggested_scalar": 0.0309,
+      "log_bad": -5.24,
+      "log_good": -5.1499
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2101,
+      "good": 0.2161,
+      "ratio": 1.0286,
+      "suggested_scalar": 0.0096,
+      "log_bad": -1.5602,
+      "log_good": -1.532
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 68.0,
+      "good": 53.0,
+      "ratio": 0.7794,
+      "suggested_scalar": -0.0853,
+      "log_bad": 4.2195,
+      "log_good": 3.9703
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0624,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 114.0,
+      "good": 108.0,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.0185,
+      "log_bad": 4.7362,
+      "log_good": 4.6821
+    },
+    "brevity.mean_sample_size": {
+      "bad": 114.0,
+      "good": 108.0,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.0185,
+      "log_bad": 4.7362,
+      "log_good": 4.6821
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 376.0,
+      "good": 347.0,
+      "ratio": 0.9229,
+      "suggested_scalar": -0.0275,
+      "log_bad": 5.9296,
+      "log_good": 5.8493
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 194.0,
+      "good": 176.0,
+      "ratio": 0.9072,
+      "suggested_scalar": -0.0333,
+      "log_bad": 5.2679,
+      "log_good": 5.1705
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 253.0,
+      "good": 229.0,
+      "ratio": 0.9051,
+      "suggested_scalar": -0.0341,
+      "log_bad": 5.5334,
+      "log_good": 5.4337
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.416,
+      "good": 1.3504,
+      "ratio": 0.9537,
+      "suggested_scalar": -0.0162,
+      "log_bad": 0.3478,
+      "log_good": 0.3004
+    },
+    "halstead.mean_effort": {
+      "bad": 64744.481,
+      "good": 59067.8516,
+      "ratio": 0.9123,
+      "suggested_scalar": -0.0314,
+      "log_bad": 11.0782,
+      "log_good": 10.9864
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8623,
+      "good": 0.8606,
+      "ratio": 0.998,
+      "suggested_scalar": -0.0007,
+      "log_bad": -0.1482,
+      "log_good": -0.1501
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 74.0,
+      "good": 70.0,
+      "ratio": 0.9459,
+      "suggested_scalar": -0.019,
+      "log_bad": 4.3041,
+      "log_good": 4.2485
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 206.0,
+      "good": 187.0,
+      "ratio": 0.9078,
+      "suggested_scalar": -0.0331,
+      "log_bad": 5.3279,
+      "log_good": 5.2311
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5932,
+      "good": 0.5641,
+      "ratio": 0.9509,
+      "suggested_scalar": -0.0172,
+      "log_bad": -0.5222,
+      "log_good": -0.5725
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.8729,
+      "good": 6.9402,
+      "ratio": 0.8815,
+      "suggested_scalar": -0.0432,
+      "log_bad": 2.0634,
+      "log_good": 1.9373
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1111,
+      "good": 0.0833,
+      "ratio": 0.7498,
+      "suggested_scalar": -0.0986,
+      "log_bad": -2.1973,
+      "log_good": -2.4853
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.5333,
+      "good": 3.6739,
+      "ratio": 0.8104,
+      "suggested_scalar": -0.0719,
+      "log_bad": 1.5115,
+      "log_good": 1.3013
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 375.0,
+      "good": 346.0,
+      "ratio": 0.9227,
+      "suggested_scalar": -0.0275,
+      "log_bad": 5.9269,
+      "log_good": 5.8464
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 43.0,
+      "good": 38.0,
+      "ratio": 0.8837,
+      "suggested_scalar": -0.0423,
+      "log_bad": 3.7612,
+      "log_good": 3.6376
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3596.9156,
+      "good": 3281.5473,
+      "ratio": 0.9123,
+      "suggested_scalar": -0.0314,
+      "log_bad": 8.1878,
+      "log_good": 8.0961
+    },
+    "readability.mean_total_lines": {
+      "bad": 72.0,
+      "good": 77.0,
+      "ratio": 1.0694,
+      "suggested_scalar": 0.023,
+      "log_bad": 4.2767,
+      "log_good": 4.3438
+    },
+    "indentation.mean_max_depth": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "halstead.mean_volume": {
+      "bad": 2326.9022,
+      "good": 2128.0235,
+      "ratio": 0.9145,
+      "suggested_scalar": -0.0306,
+      "log_bad": 7.7523,
+      "log_good": 7.6629
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 790.0,
+      "good": 755.0,
+      "ratio": 0.9557,
+      "suggested_scalar": -0.0155,
+      "log_bad": 6.672,
+      "log_good": 6.6267
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.7361,
+      "good": 30.3377,
+      "ratio": 0.9267,
+      "suggested_scalar": -0.026,
+      "log_bad": 3.4885,
+      "log_good": 3.4124
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2944,
+      "good": 1.2281,
+      "ratio": 0.9488,
+      "suggested_scalar": -0.018,
+      "log_bad": 0.258,
+      "log_good": 0.2055
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 7.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.0528,
+      "log_bad": 1.7918,
+      "log_good": 1.9459
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 21.0,
+      "good": 17.0,
+      "ratio": 0.8095,
+      "suggested_scalar": -0.0723,
+      "log_bad": 3.0445,
+      "log_good": 2.8332
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8656,
+      "good": 0.8676,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0008,
+      "log_bad": -0.1443,
+      "log_good": -0.142
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.989,
+      "good": 0.9857,
+      "ratio": 0.9967,
+      "suggested_scalar": -0.0011,
+      "log_bad": -0.0111,
+      "log_good": -0.0144
+    },
+    "halstead.mean_length": {
+      "bad": 348.0,
+      "good": 321.0,
+      "ratio": 0.9224,
+      "suggested_scalar": -0.0276,
+      "log_bad": 5.8522,
+      "log_good": 5.7714
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.1667,
+      "good": 14.0,
+      "ratio": 1.2537,
+      "suggested_scalar": 0.0774,
+      "log_bad": 2.4129,
+      "log_good": 2.6391
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8329,
+      "good": 6.7549,
+      "ratio": 0.9886,
+      "suggested_scalar": -0.0039,
+      "log_bad": 1.9217,
+      "log_good": 1.9103
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0796,
+      "good": 0.0727,
+      "ratio": 0.9133,
+      "suggested_scalar": -0.031,
+      "log_bad": -2.5307,
+      "log_good": -2.6214
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.8243,
+      "good": 27.7571,
+      "ratio": 0.9976,
+      "suggested_scalar": -0.0008,
+      "log_bad": 3.3259,
+      "log_good": 3.3235
+    },
+    "branching.mean_branch_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 70.0,
+      "good": 66.0,
+      "ratio": 0.9429,
+      "suggested_scalar": -0.0201,
+      "log_bad": 4.2485,
+      "log_good": 4.1897
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7312,
+      "good": 0.7686,
+      "ratio": 1.0511,
+      "suggested_scalar": 0.0171,
+      "log_bad": -0.3131,
+      "log_good": -0.2632
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 72.0,
+      "good": 77.0,
+      "ratio": 1.0694,
+      "suggested_scalar": 0.023,
+      "log_bad": 4.2767,
+      "log_good": 4.3438
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 25.0,
+      "good": 21.0,
+      "ratio": 0.84,
+      "suggested_scalar": -0.0597,
+      "log_bad": 3.2189,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.struct_under_32_fields": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 0.8113,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0126,
+      "good": 0.0169,
+      "ratio": 1.3413,
+      "suggested_scalar": 0.1718,
+      "log_bad": -4.3741,
+      "log_good": -4.0804
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 0.918,
+      "ratio": 0.918,
+      "suggested_scalar": -0.0501,
+      "log_bad": 0.0,
+      "log_good": -0.0856
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0126,
+      "good": 0.0169,
+      "ratio": 1.3413,
+      "suggested_scalar": 0.1718,
+      "log_bad": -4.3741,
+      "log_good": -4.0804
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4955,
+      "good": 4.5508,
+      "ratio": 1.0123,
+      "suggested_scalar": 0.0072,
+      "log_bad": 1.5031,
+      "log_good": 1.5153
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 101.0,
+      "good": 68.0,
+      "ratio": 0.6733,
+      "suggested_scalar": -0.2315,
+      "log_bad": 4.6151,
+      "log_good": 4.2195
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.8808,
+      "good": 0.5692,
+      "ratio": 0.6462,
+      "suggested_scalar": -0.2555,
+      "log_bad": -0.1269,
+      "log_good": -0.5635
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 11.0,
+      "good": 15.0,
+      "ratio": 1.3636,
+      "suggested_scalar": 0.1815,
+      "log_bad": 2.3979,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7972,
+      "good": 0.6138,
+      "ratio": 0.7699,
+      "suggested_scalar": -0.153,
+      "log_bad": -0.2266,
+      "log_good": -0.4881
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.5172,
+      "good": 3.1803,
+      "ratio": 0.9042,
+      "suggested_scalar": -0.0589,
+      "log_bad": 1.2577,
+      "log_good": 1.157
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 238.0,
+      "good": 356.0,
+      "ratio": 1.4958,
+      "suggested_scalar": 0.2357,
+      "log_bad": 5.4723,
+      "log_good": 5.8749
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.4057,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1552,
+      "good": 1.0,
+      "ratio": 6.4433,
+      "suggested_scalar": 1.0903,
+      "log_bad": -1.863,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.5537,
+      "good": 0.8834,
+      "ratio": 1.5954,
+      "suggested_scalar": 0.2734,
+      "log_bad": -0.5911,
+      "log_good": -0.124
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 112.0,
+      "good": 136.0,
+      "ratio": 1.2143,
+      "suggested_scalar": 0.1136,
+      "log_bad": 4.7185,
+      "log_good": 4.9127
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 85.2389,
+      "good": 91.8487,
+      "ratio": 1.0775,
+      "suggested_scalar": 0.0437,
+      "log_bad": 4.4455,
+      "log_good": 4.5201
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.2068,
+      "good": 0.5352,
+      "ratio": 2.588,
+      "suggested_scalar": 0.5565,
+      "log_bad": -1.576,
+      "log_good": -0.6251
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 21.1868,
+      "good": 15.1324,
+      "ratio": 0.7142,
+      "suggested_scalar": -0.197,
+      "log_bad": 3.0534,
+      "log_good": 2.7168
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1411.0,
+      "good": 1633.0,
+      "ratio": 1.1573,
+      "suggested_scalar": 0.0855,
+      "log_bad": 7.2521,
+      "log_good": 7.3982
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 0.0328,
+      "ratio": 0.0328,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -3.4173
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 0.918,
+      "ratio": 0.918,
+      "suggested_scalar": -0.0501,
+      "log_bad": 0.0,
+      "log_good": -0.0856
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 4.8571,
+      "good": 5.8361,
+      "ratio": 1.2016,
+      "suggested_scalar": 0.1075,
+      "log_bad": 1.5804,
+      "log_good": 1.7641
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0083,
+      "good": 1.4921,
+      "ratio": 1.4798,
+      "suggested_scalar": 0.2294,
+      "log_bad": 0.0083,
+      "log_good": 0.4002
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 95.0,
+      "good": 113.0,
+      "ratio": 1.1895,
+      "suggested_scalar": 0.1015,
+      "log_bad": 4.5539,
+      "log_good": 4.7274
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.7107,
+      "good": 0.9219,
+      "ratio": 1.2972,
+      "suggested_scalar": 0.1523,
+      "log_bad": -0.3415,
+      "log_good": -0.0813
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 14.0,
+      "good": 20.0,
+      "ratio": 1.4286,
+      "suggested_scalar": 0.2087,
+      "log_bad": 2.6391,
+      "log_good": 2.9957
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5549,
+      "good": 0.6044,
+      "ratio": 1.0892,
+      "suggested_scalar": 0.05,
+      "log_bad": -0.589,
+      "log_good": -0.5035
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.0169,
+      "good": 0.3588,
+      "ratio": 21.2308,
+      "suggested_scalar": 1.7882,
+      "log_bad": -4.0804,
+      "log_good": -1.025
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2468,
+      "good": 2.5279,
+      "ratio": 1.1251,
+      "suggested_scalar": 0.069,
+      "log_bad": 0.8095,
+      "log_good": 0.9274
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 236.0,
+      "good": 354.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.2373,
+      "log_bad": 5.4638,
+      "log_good": 5.8693
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 0.0506,
+      "ratio": 0.0506,
+      "suggested_scalar": -1.7463,
+      "log_bad": 0.0,
+      "log_good": -2.9838
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.6724,
+      "good": 5.7814,
+      "ratio": 1.0192,
+      "suggested_scalar": 0.0111,
+      "log_bad": 1.7356,
+      "log_good": 1.7546
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 17.0,
+      "good": 22.0,
+      "ratio": 1.2941,
+      "suggested_scalar": 0.1509,
+      "log_bad": 2.8332,
+      "log_good": 3.091
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6143,
+      "good": 0.6993,
+      "ratio": 1.1384,
+      "suggested_scalar": 0.0758,
+      "log_bad": -0.4873,
+      "log_good": -0.3577
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6265,
+      "good": 5.4811,
+      "ratio": 0.9742,
+      "suggested_scalar": -0.0153,
+      "log_bad": 1.7275,
+      "log_good": 1.7013
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7925,
+      "good": 0.7872,
+      "ratio": 0.9933,
+      "suggested_scalar": -0.0039,
+      "log_bad": -0.2326,
+      "log_good": -0.2393
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.0333,
+      "good": 0.0896,
+      "ratio": 2.6907,
+      "suggested_scalar": 0.5793,
+      "log_bad": -3.4022,
+      "log_good": -2.4124
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.6029,
+      "good": 3.89,
+      "ratio": 0.8451,
+      "suggested_scalar": -0.0985,
+      "log_bad": 1.5267,
+      "log_good": 1.3584
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.2373,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 234.0,
+      "good": 258.0,
+      "ratio": 1.1026,
+      "suggested_scalar": 0.0571,
+      "log_bad": 5.4553,
+      "log_good": 5.553
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.643,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.4217,
+      "good": 0.5925,
+      "ratio": 1.405,
+      "suggested_scalar": 0.199,
+      "log_bad": -0.8635,
+      "log_good": -0.5234
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 120.0,
+      "good": 108.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0617,
+      "log_bad": 4.7875,
+      "log_good": 4.6821
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 893.0,
+      "good": 952.0,
+      "ratio": 1.0661,
+      "suggested_scalar": 0.0374,
+      "log_bad": 6.7946,
+      "log_good": 6.8586
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 90.0,
+      "good": 111.0,
+      "ratio": 1.2333,
+      "suggested_scalar": 0.1227,
+      "log_bad": 4.4998,
+      "log_good": 4.7095
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2017,
+      "good": 0.2556,
+      "ratio": 1.2672,
+      "suggested_scalar": 0.1386,
+      "log_bad": -1.601,
+      "log_good": -1.3641
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 6.0,
+      "good": 40.0,
+      "ratio": 6.6667,
+      "suggested_scalar": 1.1103,
+      "log_bad": 1.7918,
+      "log_good": 3.6889
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 120.0,
+      "good": 108.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0617,
+      "log_bad": 4.7875,
+      "log_good": 4.6821
+    },
+    "brevity.mean_sample_size": {
+      "bad": 120.0,
+      "good": 108.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0617,
+      "log_bad": 4.7875,
+      "log_good": 4.6821
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 238.0,
+      "good": 356.0,
+      "ratio": 1.4958,
+      "suggested_scalar": 0.2357,
+      "log_bad": 5.4723,
+      "log_good": 5.8749
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 111.0,
+      "good": 188.0,
+      "ratio": 1.6937,
+      "suggested_scalar": 0.3084,
+      "log_bad": 4.7095,
+      "log_good": 5.2364
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 194.0,
+      "good": 205.0,
+      "ratio": 1.0567,
+      "suggested_scalar": 0.0323,
+      "log_bad": 5.2679,
+      "log_good": 5.323
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0126,
+      "good": 0.0056,
+      "ratio": 0.4444,
+      "suggested_scalar": -0.4746,
+      "log_bad": -4.3741,
+      "log_good": -5.185
+    },
+    "heaps.mean_k": {
+      "bad": 1.5157,
+      "good": 3.0631,
+      "ratio": 2.0209,
+      "suggested_scalar": 0.4118,
+      "log_bad": 0.4159,
+      "log_good": 1.1194
+    },
+    "halstead.mean_effort": {
+      "bad": 9160.7806,
+      "good": 41105.5928,
+      "ratio": 4.4871,
+      "suggested_scalar": 0.8786,
+      "log_bad": 9.1227,
+      "log_good": 10.6239
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8146,
+      "good": 0.8114,
+      "ratio": 0.9961,
+      "suggested_scalar": -0.0023,
+      "log_bad": -0.2051,
+      "log_good": -0.209
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 87.0,
+      "good": 48.0,
+      "ratio": 0.5517,
+      "suggested_scalar": -0.3481,
+      "log_bad": 4.4659,
+      "log_good": 3.8712
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 100.0,
+      "good": 181.0,
+      "ratio": 1.81,
+      "suggested_scalar": 0.3472,
+      "log_bad": 4.6052,
+      "log_good": 5.1985
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.875,
+      "good": 0.5956,
+      "ratio": 0.6807,
+      "suggested_scalar": -0.2251,
+      "log_bad": -0.1335,
+      "log_good": -0.5182
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.9732,
+      "good": 7.0,
+      "ratio": 0.8779,
+      "suggested_scalar": -0.0762,
+      "log_bad": 2.0761,
+      "log_good": 1.9459
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.0333,
+      "good": 0.0896,
+      "ratio": 2.6907,
+      "suggested_scalar": 0.5793,
+      "log_bad": -3.4022,
+      "log_good": -2.4124
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.2009,
+      "good": 3.5392,
+      "ratio": 0.8425,
+      "suggested_scalar": -0.1003,
+      "log_bad": 1.4353,
+      "log_good": 1.2639
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 237.0,
+      "good": 355.0,
+      "ratio": 1.4979,
+      "suggested_scalar": 0.2365,
+      "log_bad": 5.4681,
+      "log_good": 5.8721
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 2.0,
+      "good": 31.0,
+      "ratio": 15.5,
+      "suggested_scalar": 1.6041,
+      "log_bad": 0.6931,
+      "log_good": 3.434
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 508.9323,
+      "good": 2283.644,
+      "ratio": 4.4871,
+      "suggested_scalar": 0.8786,
+      "log_bad": 6.2323,
+      "log_good": 7.7335
+    },
+    "readability.mean_total_lines": {
+      "bad": 49.0,
+      "good": 61.0,
+      "ratio": 1.2449,
+      "suggested_scalar": 0.1282,
+      "log_bad": 3.8918,
+      "log_good": 4.1109
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1265.0602,
+      "good": 1777.5391,
+      "ratio": 1.4051,
+      "suggested_scalar": 0.1991,
+      "log_bad": 7.1429,
+      "log_good": 7.483
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 628.0,
+      "good": 646.0,
+      "ratio": 1.0287,
+      "suggested_scalar": 0.0165,
+      "log_bad": 6.4425,
+      "log_good": 6.4708
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 20.7755,
+      "good": 25.6721,
+      "ratio": 1.2357,
+      "suggested_scalar": 0.1239,
+      "log_bad": 3.0338,
+      "log_good": 3.2454
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.379,
+      "good": 1.2892,
+      "ratio": 0.9349,
+      "suggested_scalar": -0.0394,
+      "log_bad": 0.3214,
+      "log_good": 0.254
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.4057,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 6.0,
+      "good": 17.0,
+      "ratio": 2.8333,
+      "suggested_scalar": 0.6095,
+      "log_bad": 1.7918,
+      "log_good": 2.8332
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 9.0,
+      "good": 1.0,
+      "ratio": 0.1111,
+      "suggested_scalar": -1.2859,
+      "log_bad": 2.1972,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9915,
+      "good": 0.8798,
+      "ratio": 0.8873,
+      "suggested_scalar": -0.07,
+      "log_bad": -0.0085,
+      "log_good": -0.1281
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.2373,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9889,
+      "good": 0.9299,
+      "ratio": 0.9403,
+      "suggested_scalar": -0.036,
+      "log_bad": -0.0112,
+      "log_good": -0.0727
+    },
+    "halstead.mean_length": {
+      "bad": 190.0,
+      "good": 292.0,
+      "ratio": 1.5368,
+      "suggested_scalar": 0.2515,
+      "log_bad": 5.247,
+      "log_good": 5.6768
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9069,
+      "good": 6.7549,
+      "ratio": 0.978,
+      "suggested_scalar": -0.013,
+      "log_bad": 1.9325,
+      "log_good": 1.9103
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.079,
+      "good": 0.1151,
+      "ratio": 1.457,
+      "suggested_scalar": 0.2203,
+      "log_bad": -2.5383,
+      "log_good": -2.162
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 7.2414,
+      "good": 23.125,
+      "ratio": 3.1934,
+      "suggested_scalar": 0.6795,
+      "log_bad": 1.9798,
+      "log_good": 3.1409
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.4057,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 98.0,
+      "good": 81.0,
+      "ratio": 0.8265,
+      "suggested_scalar": -0.1115,
+      "log_bad": 4.585,
+      "log_good": 4.3944
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.9691,
+      "good": 0.8049,
+      "ratio": 0.8306,
+      "suggested_scalar": -0.1087,
+      "log_bad": -0.0314,
+      "log_good": -0.217
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 58.0,
+      "good": 61.0,
+      "ratio": 1.0517,
+      "suggested_scalar": 0.0295,
+      "log_bad": 4.0604,
+      "log_good": 4.1109
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 24.0,
+      "good": 19.0,
+      "ratio": 0.7917,
+      "suggested_scalar": -0.1367,
+      "log_bad": 3.1781,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.uses_keyword_arguments_over_option_hash": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 23.0,
+      "good": 13.0,
+      "ratio": 0.5652,
+      "suggested_scalar": -0.3481,
+      "log_bad": 3.1355,
+      "log_good": 2.5649
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1755,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0089,
+      "good": 0.0117,
+      "ratio": 1.3146,
+      "suggested_scalar": 0.1669,
+      "log_bad": -4.7217,
+      "log_good": -4.4482
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.8,
+      "good": 1.6,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0719,
+      "log_bad": 0.5878,
+      "log_good": 0.47
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9057,
+      "good": 0.902,
+      "ratio": 0.9959,
+      "suggested_scalar": -0.0025,
+      "log_bad": -0.099,
+      "log_good": -0.1031
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0089,
+      "good": 0.0117,
+      "ratio": 1.3146,
+      "suggested_scalar": 0.1669,
+      "log_bad": -4.7217,
+      "log_good": -4.4482
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.587,
+      "good": 4.4927,
+      "ratio": 0.9794,
+      "suggested_scalar": -0.0127,
+      "log_bad": 1.5232,
+      "log_good": 1.5025
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 90.0,
+      "good": 75.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1112,
+      "log_bad": 4.4998,
+      "log_good": 4.3175
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4421,
+      "good": 0.43,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.0169,
+      "log_bad": -0.8162,
+      "log_good": -0.844
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.0,
+      "good": 20.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0298,
+      "log_bad": 3.0445,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6068,
+      "good": 0.6692,
+      "ratio": 1.1028,
+      "suggested_scalar": 0.0597,
+      "log_bad": -0.4996,
+      "log_good": -0.4017
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.8868,
+      "good": 3.9216,
+      "ratio": 1.009,
+      "suggested_scalar": 0.0054,
+      "log_bad": 1.3576,
+      "log_good": 1.3665
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 336.0,
+      "good": 256.0,
+      "ratio": 0.7619,
+      "suggested_scalar": -0.1659,
+      "log_bad": 5.8171,
+      "log_good": 5.5452
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0006,
+      "good": 0.0007,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.094,
+      "log_bad": -7.4186,
+      "log_good": -7.2644
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0377,
+      "good": 1.0,
+      "ratio": 26.5252,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.2781,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0023,
+      "good": 0.0014,
+      "ratio": 0.6087,
+      "suggested_scalar": -0.3029,
+      "log_bad": -6.0748,
+      "log_good": -6.5713
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9409,
+      "good": 0.8626,
+      "ratio": 0.9168,
+      "suggested_scalar": -0.053,
+      "log_bad": -0.0609,
+      "log_good": -0.1478
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 138.0,
+      "good": 102.0,
+      "ratio": 0.7391,
+      "suggested_scalar": -0.1844,
+      "log_bad": 4.9273,
+      "log_good": 4.625
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 89.9591,
+      "good": 88.7145,
+      "ratio": 0.9862,
+      "suggested_scalar": -0.0085,
+      "log_bad": 4.4994,
+      "log_good": 4.4854
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.3552,
+      "good": 0.3255,
+      "ratio": 0.9164,
+      "suggested_scalar": -0.0533,
+      "log_bad": -1.0351,
+      "log_good": -1.1224
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.3254,
+      "good": 12.9362,
+      "ratio": 0.9708,
+      "suggested_scalar": -0.0181,
+      "log_bad": 2.5897,
+      "log_good": 2.56
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1749.0,
+      "good": 1431.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.1224,
+      "log_bad": 7.4668,
+      "log_good": 7.2661
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0566,
+      "good": 0.0588,
+      "ratio": 1.0389,
+      "suggested_scalar": 0.0233,
+      "log_bad": -2.8717,
+      "log_good": -2.8336
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8868,
+      "good": 0.8627,
+      "ratio": 0.9728,
+      "suggested_scalar": -0.0168,
+      "log_bad": -0.1201,
+      "log_good": -0.1477
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.5882,
+      "good": 5.0196,
+      "ratio": 0.7619,
+      "suggested_scalar": -0.1659,
+      "log_bad": 1.8853,
+      "log_good": 1.6134
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.6287,
+      "good": 2.6605,
+      "ratio": 1.0121,
+      "suggested_scalar": 0.0073,
+      "log_bad": 0.9665,
+      "log_good": 0.9785
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 130.0,
+      "good": 94.0,
+      "ratio": 0.7231,
+      "suggested_scalar": -0.1978,
+      "log_bad": 4.8675,
+      "log_good": 4.5433
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9325,
+      "good": 0.9509,
+      "ratio": 1.0197,
+      "suggested_scalar": 0.0119,
+      "log_bad": -0.0699,
+      "log_good": -0.0503
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 25.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0239,
+      "log_bad": 3.2581,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6015,
+      "good": 0.6059,
+      "ratio": 1.0073,
+      "suggested_scalar": 0.0044,
+      "log_bad": -0.5083,
+      "log_good": -0.501
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.1826,
+      "good": 0.1496,
+      "ratio": 0.8193,
+      "suggested_scalar": -0.1216,
+      "log_bad": -1.7005,
+      "log_good": -1.8998
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5093,
+      "good": 2.5372,
+      "ratio": 1.0111,
+      "suggested_scalar": 0.0067,
+      "log_bad": 0.92,
+      "log_good": 0.9311
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 334.0,
+      "good": 254.0,
+      "ratio": 0.7605,
+      "suggested_scalar": -0.1671,
+      "log_bad": 5.8111,
+      "log_good": 5.5373
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 28.0,
+      "good": 29.0,
+      "ratio": 1.0357,
+      "suggested_scalar": 0.0214,
+      "log_bad": 3.3322,
+      "log_good": 3.3673
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0446,
+      "good": 0.1016,
+      "ratio": 2.278,
+      "suggested_scalar": 0.5023,
+      "log_bad": -3.11,
+      "log_good": -2.2867
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9773,
+      "good": 5.8329,
+      "ratio": 0.9758,
+      "suggested_scalar": -0.0149,
+      "log_bad": 1.788,
+      "log_good": 1.7635
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.3193,
+      "good": 0.3966,
+      "ratio": 1.2421,
+      "suggested_scalar": 0.1323,
+      "log_bad": -1.1416,
+      "log_good": -0.9248
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8136,
+      "good": 5.5633,
+      "ratio": 0.9569,
+      "suggested_scalar": -0.0269,
+      "log_bad": 1.7602,
+      "log_good": 1.7162
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7674,
+      "good": 0.7702,
+      "ratio": 1.0036,
+      "suggested_scalar": 0.0022,
+      "log_bad": -0.2647,
+      "log_good": -0.2611
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1452,
+      "good": 0.1207,
+      "ratio": 0.8313,
+      "suggested_scalar": -0.1128,
+      "log_bad": -1.9296,
+      "log_good": -2.1144
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6504,
+      "good": 3.5967,
+      "ratio": 0.9853,
+      "suggested_scalar": -0.009,
+      "log_bad": 1.2948,
+      "log_good": 1.28
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 296.0,
+      "good": 235.0,
+      "ratio": 0.7939,
+      "suggested_scalar": -0.1408,
+      "log_bad": 5.6904,
+      "log_good": 5.4596
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.4229,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6881,
+      "good": 0.5045,
+      "ratio": 0.7332,
+      "suggested_scalar": -0.1894,
+      "log_bad": -0.3738,
+      "log_good": -0.6842
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 96.0,
+      "good": 80.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1112,
+      "log_bad": 4.5643,
+      "log_good": 4.382
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1075.0,
+      "good": 866.0,
+      "ratio": 0.8056,
+      "suggested_scalar": -0.1319,
+      "log_bad": 6.9801,
+      "log_good": 6.7639
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 142.0,
+      "good": 106.0,
+      "ratio": 0.7465,
+      "suggested_scalar": -0.1784,
+      "log_bad": 4.9558,
+      "log_good": 4.6634
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2589,
+      "good": 0.3086,
+      "ratio": 1.192,
+      "suggested_scalar": 0.1071,
+      "log_bad": -1.3513,
+      "log_good": -1.1757
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 43.0,
+      "good": 38.0,
+      "ratio": 0.8837,
+      "suggested_scalar": -0.0754,
+      "log_bad": 3.7612,
+      "log_good": 3.6376
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 96.0,
+      "good": 80.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1112,
+      "log_bad": 4.5643,
+      "log_good": 4.382
+    },
+    "brevity.mean_sample_size": {
+      "bad": 96.0,
+      "good": 80.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1112,
+      "log_bad": 4.5643,
+      "log_good": 4.382
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 336.0,
+      "good": 256.0,
+      "ratio": 0.7619,
+      "suggested_scalar": -0.1659,
+      "log_bad": 5.8171,
+      "log_good": 5.5452
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 172.0,
+      "good": 129.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1755,
+      "log_bad": 5.1475,
+      "log_good": 4.8598
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 259.0,
+      "good": 210.0,
+      "ratio": 0.8108,
+      "suggested_scalar": -0.128,
+      "log_bad": 5.5568,
+      "log_good": 5.3471
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.006,
+      "good": 0.0078,
+      "ratio": 1.3,
+      "suggested_scalar": 0.1601,
+      "log_bad": -5.116,
+      "log_good": -4.8536
+    },
+    "heaps.mean_k": {
+      "bad": 2.8483,
+      "good": 1.9389,
+      "ratio": 0.6807,
+      "suggested_scalar": -0.2346,
+      "log_bad": 1.0467,
+      "log_good": 0.6621
+    },
+    "halstead.mean_effort": {
+      "bad": 59545.3053,
+      "good": 40110.478,
+      "ratio": 0.6736,
+      "suggested_scalar": -0.2411,
+      "log_bad": 10.9945,
+      "log_good": 10.5994
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8829,
+      "good": 0.88,
+      "ratio": 0.9967,
+      "suggested_scalar": -0.002,
+      "log_bad": -0.1245,
+      "log_good": -0.1278
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 64.0,
+      "good": 50.0,
+      "ratio": 0.7813,
+      "suggested_scalar": -0.1506,
+      "log_bad": 4.1589,
+      "log_good": 3.912
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 176.0,
+      "good": 137.0,
+      "ratio": 0.7784,
+      "suggested_scalar": -0.1528,
+      "log_bad": 5.1705,
+      "log_good": 4.92
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4203,
+      "good": 0.4314,
+      "ratio": 1.0264,
+      "suggested_scalar": 0.0159,
+      "log_bad": -0.8668,
+      "log_good": -0.8407
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.7899,
+      "good": 8.4902,
+      "ratio": 1.0899,
+      "suggested_scalar": 0.0525,
+      "log_bad": 2.0528,
+      "log_good": 2.1389
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1452,
+      "good": 0.1207,
+      "ratio": 0.8313,
+      "suggested_scalar": -0.1128,
+      "log_bad": -1.9296,
+      "log_good": -2.1144
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.376,
+      "good": 2.6478,
+      "ratio": 0.7843,
+      "suggested_scalar": -0.1482,
+      "log_bad": 1.2167,
+      "log_good": 0.9737
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 335.0,
+      "good": 255.0,
+      "ratio": 0.7612,
+      "suggested_scalar": -0.1665,
+      "log_bad": 5.8141,
+      "log_good": 5.5413
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.2474,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 23.0,
+      "good": 19.0,
+      "ratio": 0.8261,
+      "suggested_scalar": -0.1166,
+      "log_bad": 3.1355,
+      "log_good": 2.9444
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3308.0725,
+      "good": 2228.3599,
+      "ratio": 0.6736,
+      "suggested_scalar": -0.2411,
+      "log_bad": 8.1041,
+      "log_good": 7.709
+    },
+    "readability.mean_total_lines": {
+      "bad": 51.0,
+      "good": 51.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9318,
+      "log_good": 3.9318
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2064.4093,
+      "good": 1513.6029,
+      "ratio": 0.7332,
+      "suggested_scalar": -0.1893,
+      "log_bad": 7.6326,
+      "log_good": 7.3222
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 697.0,
+      "good": 564.0,
+      "ratio": 0.8092,
+      "suggested_scalar": -0.1292,
+      "log_bad": 6.5468,
+      "log_good": 6.3351
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.8824,
+      "good": 26.9216,
+      "ratio": 0.8717,
+      "suggested_scalar": -0.0837,
+      "log_bad": 3.4302,
+      "log_good": 3.2929
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3025,
+      "good": 1.336,
+      "ratio": 1.0257,
+      "suggested_scalar": 0.0155,
+      "log_bad": 0.2643,
+      "log_good": 0.2897
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 11.0,
+      "good": 10.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0581,
+      "log_bad": 2.3979,
+      "log_good": 2.3026
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.4229,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9223,
+      "good": 0.9191,
+      "ratio": 0.9965,
+      "suggested_scalar": -0.0021,
+      "log_bad": -0.0809,
+      "log_good": -0.0844
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9761,
+      "good": 0.9874,
+      "ratio": 1.0116,
+      "suggested_scalar": 0.007,
+      "log_bad": -0.0242,
+      "log_good": -0.0127
+    },
+    "halstead.mean_length": {
+      "bad": 318.0,
+      "good": 243.0,
+      "ratio": 0.7642,
+      "suggested_scalar": -0.1641,
+      "log_bad": 5.7621,
+      "log_good": 5.4931
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 12.2,
+      "good": 11.4,
+      "ratio": 0.9344,
+      "suggested_scalar": -0.0414,
+      "log_bad": 2.5014,
+      "log_good": 2.4336
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.585,
+      "good": 6.3219,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0249,
+      "log_bad": 1.8848,
+      "log_good": 1.844
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0985,
+      "good": 0.0901,
+      "ratio": 0.9147,
+      "suggested_scalar": -0.0544,
+      "log_bad": -2.3177,
+      "log_good": -2.4068
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 28.8438,
+      "good": 26.5,
+      "ratio": 0.9187,
+      "suggested_scalar": -0.0517,
+      "log_bad": 3.3619,
+      "log_good": 3.2771
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 58.0,
+      "good": 44.0,
+      "ratio": 0.7586,
+      "suggested_scalar": -0.1685,
+      "log_bad": 4.0604,
+      "log_good": 3.7842
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.834,
+      "good": 0.819,
+      "ratio": 0.982,
+      "suggested_scalar": -0.0111,
+      "log_bad": -0.1815,
+      "log_good": -0.1997
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 53.0,
+      "good": 51.0,
+      "ratio": 0.9623,
+      "suggested_scalar": -0.0235,
+      "log_bad": 3.9703,
+      "log_good": 3.9318
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.no_rescue_as_flow_control": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 21.0,
+      "good": 22.0,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.0164,
+      "log_bad": 3.0445,
+      "log_good": 3.091
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0102,
+      "good": 1.0,
+      "ratio": 98.0392,
+      "suggested_scalar": 1.6134,
+      "log_bad": -4.5854,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6,
+      "good": 1.6,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.47,
+      "log_good": 0.47
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7407,
+      "good": 0.8667,
+      "ratio": 1.1701,
+      "suggested_scalar": 0.0553,
+      "log_bad": -0.3002,
+      "log_good": -0.1431
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0102,
+      "good": 1.0,
+      "ratio": 98.0392,
+      "suggested_scalar": 1.6134,
+      "log_bad": -4.5854,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4144,
+      "good": 4.4004,
+      "ratio": 0.9968,
+      "suggested_scalar": -0.0011,
+      "log_bad": 1.4849,
+      "log_good": 1.4817
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 69.0,
+      "good": 62.0,
+      "ratio": 0.8986,
+      "suggested_scalar": -0.0376,
+      "log_bad": 4.2341,
+      "log_good": 4.1271
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4364,
+      "good": 0.4089,
+      "ratio": 0.937,
+      "suggested_scalar": -0.0229,
+      "log_bad": -0.8292,
+      "log_good": -0.8943
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 13.0,
+      "good": 11.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.0588,
+      "log_bad": 2.5649,
+      "log_good": 2.3979
+    },
+    "heaps.mean_beta": {
+      "bad": 0.635,
+      "good": 0.6118,
+      "ratio": 0.9635,
+      "suggested_scalar": -0.0131,
+      "log_bad": -0.4541,
+      "log_good": -0.4913
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.037,
+      "good": 3.7333,
+      "ratio": 0.9248,
+      "suggested_scalar": -0.0275,
+      "log_bad": 1.3955,
+      "log_good": 1.3173
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 295.0,
+      "good": 276.0,
+      "ratio": 0.9356,
+      "suggested_scalar": -0.0234,
+      "log_bad": 5.687,
+      "log_good": 5.6204
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0038,
+      "good": 0.0021,
+      "ratio": 0.5526,
+      "suggested_scalar": -0.2087,
+      "log_bad": -5.5728,
+      "log_good": -6.1658
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0019,
+      "good": 0.0021,
+      "ratio": 1.1053,
+      "suggested_scalar": 0.0352,
+      "log_bad": -6.2659,
+      "log_good": -6.1658
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9614,
+      "good": 1.008,
+      "ratio": 1.0485,
+      "suggested_scalar": 0.0167,
+      "log_bad": -0.0394,
+      "log_good": 0.008
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 110.0,
+      "good": 108.0,
+      "ratio": 0.9818,
+      "suggested_scalar": -0.0065,
+      "log_bad": 4.7005,
+      "log_good": 4.6821
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 91.9693,
+      "good": 93.5285,
+      "ratio": 1.017,
+      "suggested_scalar": 0.0059,
+      "log_bad": 4.5215,
+      "log_good": 4.5383
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.585,
+      "good": 0.56,
+      "ratio": 0.9573,
+      "suggested_scalar": -0.0154,
+      "log_bad": -0.5361,
+      "log_good": -0.5798
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.4943,
+      "good": 13.1841,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0082,
+      "log_bad": 2.6023,
+      "log_good": 2.579
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1590.0,
+      "good": 1463.0,
+      "ratio": 0.9201,
+      "suggested_scalar": -0.0293,
+      "log_bad": 7.3715,
+      "log_good": 7.2882
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2407,
+      "good": 0.1333,
+      "ratio": 0.5538,
+      "suggested_scalar": -0.2079,
+      "log_bad": -1.4242,
+      "log_good": -2.0152
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7037,
+      "good": 0.8222,
+      "ratio": 1.1684,
+      "suggested_scalar": 0.0548,
+      "log_bad": -0.3514,
+      "log_good": -0.1958
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.463,
+      "good": 6.1333,
+      "ratio": 1.1227,
+      "suggested_scalar": 0.0407,
+      "log_bad": 1.698,
+      "log_good": 1.8137
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.5912,
+      "good": 2.4178,
+      "ratio": 0.9331,
+      "suggested_scalar": -0.0244,
+      "log_bad": 0.9521,
+      "log_good": 0.8829
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 102.0,
+      "good": 106.0,
+      "ratio": 1.0392,
+      "suggested_scalar": 0.0135,
+      "log_bad": 4.625,
+      "log_good": 4.6634
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9301,
+      "good": 0.9356,
+      "ratio": 1.0059,
+      "suggested_scalar": 0.0021,
+      "log_bad": -0.0725,
+      "log_good": -0.0666
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 18.0,
+      "good": 15.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0642,
+      "log_bad": 2.8904,
+      "log_good": 2.7081
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6723,
+      "good": 0.6671,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.0027,
+      "log_bad": -0.3971,
+      "log_good": -0.4048
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3515,
+      "good": 0.3321,
+      "ratio": 0.9448,
+      "suggested_scalar": -0.02,
+      "log_bad": -1.0455,
+      "log_good": -1.1023
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0518,
+      "good": 3.0041,
+      "ratio": 0.9844,
+      "suggested_scalar": -0.0055,
+      "log_bad": 1.1157,
+      "log_good": 1.1
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 293.0,
+      "good": 274.0,
+      "ratio": 0.9352,
+      "suggested_scalar": -0.0236,
+      "log_bad": 5.6802,
+      "log_good": 5.6131
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0881,
+      "good": 0.0942,
+      "ratio": 1.0692,
+      "suggested_scalar": 0.0236,
+      "log_bad": -2.4293,
+      "log_good": -2.3623
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.4919,
+      "good": 5.2854,
+      "ratio": 0.9624,
+      "suggested_scalar": -0.0135,
+      "log_bad": 1.7033,
+      "log_good": 1.6649
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 8.0,
+      "good": 2.0,
+      "ratio": 0.25,
+      "suggested_scalar": -0.4878,
+      "log_bad": 2.0794,
+      "log_good": 0.6931
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.376,
+      "good": 0.133,
+      "ratio": 0.3537,
+      "suggested_scalar": -0.3657,
+      "log_bad": -0.9782,
+      "log_good": -2.0174
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4214,
+      "good": 5.24,
+      "ratio": 0.9665,
+      "suggested_scalar": -0.012,
+      "log_bad": 1.6904,
+      "log_good": 1.6563
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8038,
+      "good": 0.8326,
+      "ratio": 1.0358,
+      "suggested_scalar": 0.0124,
+      "log_bad": -0.2184,
+      "log_good": -0.1832
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1692,
+      "good": 0.2373,
+      "ratio": 1.4025,
+      "suggested_scalar": 0.119,
+      "log_bad": -1.7767,
+      "log_good": -1.4384
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6735,
+      "good": 3.631,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0041,
+      "log_bad": 1.3011,
+      "log_good": 1.2895
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 229.0,
+      "good": 213.0,
+      "ratio": 0.9301,
+      "suggested_scalar": -0.0255,
+      "log_bad": 5.4337,
+      "log_good": 5.3613
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5661,
+      "good": 0.5279,
+      "ratio": 0.9325,
+      "suggested_scalar": -0.0246,
+      "log_bad": -0.569,
+      "log_good": -0.6388
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 71.0,
+      "good": 64.0,
+      "ratio": 0.9014,
+      "suggested_scalar": -0.0365,
+      "log_bad": 4.2627,
+      "log_good": 4.1589
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 897.0,
+      "good": 875.0,
+      "ratio": 0.9755,
+      "suggested_scalar": -0.0087,
+      "log_bad": 6.7991,
+      "log_good": 6.7742
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 116.0,
+      "good": 116.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.7536,
+      "log_good": 4.7536
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0034,
+      "good": 1.0,
+      "ratio": 294.1176,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.684,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.3254,
+      "good": 0.3406,
+      "ratio": 1.0467,
+      "suggested_scalar": 0.0161,
+      "log_bad": -1.1227,
+      "log_good": -1.077
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 55.0,
+      "good": 47.0,
+      "ratio": 0.8545,
+      "suggested_scalar": -0.0553,
+      "log_bad": 4.0073,
+      "log_good": 3.8501
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 71.0,
+      "good": 64.0,
+      "ratio": 0.9014,
+      "suggested_scalar": -0.0365,
+      "log_bad": 4.2627,
+      "log_good": 4.1589
+    },
+    "brevity.mean_sample_size": {
+      "bad": 71.0,
+      "good": 64.0,
+      "ratio": 0.9014,
+      "suggested_scalar": -0.0365,
+      "log_bad": 4.2627,
+      "log_good": 4.1589
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 295.0,
+      "good": 276.0,
+      "ratio": 0.9356,
+      "suggested_scalar": -0.0234,
+      "log_bad": 5.687,
+      "log_good": 5.6204
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 141.0,
+      "good": 133.0,
+      "ratio": 0.9433,
+      "suggested_scalar": -0.0206,
+      "log_bad": 4.9488,
+      "log_good": 4.8903
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 177.0,
+      "good": 168.0,
+      "ratio": 0.9492,
+      "suggested_scalar": -0.0184,
+      "log_bad": 5.1761,
+      "log_good": 5.124
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.1477,
+      "good": 2.2466,
+      "ratio": 1.046,
+      "suggested_scalar": 0.0158,
+      "log_bad": 0.7644,
+      "log_good": 0.8094
+    },
+    "halstead.mean_effort": {
+      "bad": 34762.5347,
+      "good": 29317.4492,
+      "ratio": 0.8434,
+      "suggested_scalar": -0.0599,
+      "log_bad": 10.4563,
+      "log_good": 10.2859
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8816,
+      "good": 0.8733,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.0033,
+      "log_bad": -0.126,
+      "log_good": -0.1355
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 51.0,
+      "good": 47.0,
+      "ratio": 0.9216,
+      "suggested_scalar": -0.0287,
+      "log_bad": 3.9318,
+      "log_good": 3.8501
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 162.0,
+      "good": 150.0,
+      "ratio": 0.9259,
+      "suggested_scalar": -0.0271,
+      "log_bad": 5.0876,
+      "log_good": 5.0106
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4273,
+      "good": 0.4074,
+      "ratio": 0.9534,
+      "suggested_scalar": -0.0168,
+      "log_bad": -0.8503,
+      "log_good": -0.898
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.1545,
+      "good": 8.1019,
+      "ratio": 0.9935,
+      "suggested_scalar": -0.0023,
+      "log_bad": 2.0986,
+      "log_good": 2.0921
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1692,
+      "good": 0.2373,
+      "ratio": 1.4025,
+      "suggested_scalar": 0.119,
+      "log_bad": -1.7767,
+      "log_good": -1.4384
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.7436,
+      "good": 3.5722,
+      "ratio": 0.9542,
+      "suggested_scalar": -0.0165,
+      "log_bad": 1.32,
+      "log_good": 1.2732
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 294.0,
+      "good": 275.0,
+      "ratio": 0.9354,
+      "suggested_scalar": -0.0235,
+      "log_bad": 5.6836,
+      "log_good": 5.6168
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 7.0,
+      "good": 4.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -0.1969,
+      "log_bad": 1.9459,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 39.0,
+      "good": 30.0,
+      "ratio": 0.7692,
+      "suggested_scalar": -0.0923,
+      "log_bad": 3.6636,
+      "log_good": 3.4012
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1931.2519,
+      "good": 1628.7472,
+      "ratio": 0.8434,
+      "suggested_scalar": -0.0599,
+      "log_bad": 7.5659,
+      "log_good": 7.3956
+    },
+    "readability.mean_total_lines": {
+      "bad": 54.0,
+      "good": 45.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0642,
+      "log_bad": 3.989,
+      "log_good": 3.8067
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 1698.1698,
+      "good": 1583.8162,
+      "ratio": 0.9327,
+      "suggested_scalar": -0.0245,
+      "log_bad": 7.4373,
+      "log_good": 7.3676
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 521.0,
+      "good": 487.0,
+      "ratio": 0.9347,
+      "suggested_scalar": -0.0237,
+      "log_bad": 6.2558,
+      "log_good": 6.1883
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 28.2407,
+      "good": 31.2,
+      "ratio": 1.1048,
+      "suggested_scalar": 0.0351,
+      "log_bad": 3.3408,
+      "log_good": 3.4404
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2922,
+      "good": 1.2657,
+      "ratio": 0.9795,
+      "suggested_scalar": -0.0073,
+      "log_bad": 0.2563,
+      "log_good": 0.2356
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 21.0,
+      "good": 20.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0172,
+      "log_bad": 3.0445,
+      "log_good": 2.9957
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8297,
+      "good": 0.8592,
+      "ratio": 1.0356,
+      "suggested_scalar": 0.0123,
+      "log_bad": -0.1867,
+      "log_good": -0.1518
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9859,
+      "good": 0.9883,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.0009,
+      "log_bad": -0.0142,
+      "log_good": -0.0118
+    },
+    "halstead.mean_length": {
+      "bad": 278.0,
+      "good": 266.0,
+      "ratio": 0.9568,
+      "suggested_scalar": -0.0155,
+      "log_bad": 5.6276,
+      "log_good": 5.5835
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 12.8,
+      "good": 11.6,
+      "ratio": 0.9062,
+      "suggested_scalar": -0.0346,
+      "log_bad": 2.5494,
+      "log_good": 2.451
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.1497,
+      "good": 6.0,
+      "ratio": 0.9757,
+      "suggested_scalar": -0.0087,
+      "log_bad": 1.8164,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0887,
+      "good": 0.0909,
+      "ratio": 1.0248,
+      "suggested_scalar": 0.0086,
+      "log_bad": -2.4225,
+      "log_good": -2.398
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 20.4706,
+      "good": 18.5106,
+      "ratio": 0.9043,
+      "suggested_scalar": -0.0354,
+      "log_bad": 3.019,
+      "log_good": 2.9183
+    },
+    "branching.mean_branch_count": {
+      "bad": 13.0,
+      "good": 6.0,
+      "ratio": 0.4615,
+      "suggested_scalar": -0.2721,
+      "log_bad": 2.5649,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 47.0,
+      "good": 44.0,
+      "ratio": 0.9362,
+      "suggested_scalar": -0.0232,
+      "log_bad": 3.8501,
+      "log_good": 3.7842
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6893,
+      "good": 0.7202,
+      "ratio": 1.0448,
+      "suggested_scalar": 0.0154,
+      "log_bad": -0.3721,
+      "log_good": -0.3282
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 54.0,
+      "good": 45.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0642,
+      "log_bad": 3.989,
+      "log_good": 3.8067
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.no_bare_except": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 38.0,
+      "good": 44.0,
+      "ratio": 1.1579,
+      "suggested_scalar": 0.2669,
+      "log_bad": 3.6376,
+      "log_good": 3.7842
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.7381,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0341,
+      "good": 0.0478,
+      "ratio": 1.4018,
+      "suggested_scalar": 0.6148,
+      "log_bad": -3.3785,
+      "log_good": -3.0407
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.6667,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.93,
+      "log_bad": 0.0,
+      "log_good": 0.5108
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9804,
+      "good": 1.0,
+      "ratio": 1.02,
+      "suggested_scalar": 0.036,
+      "log_bad": -0.0198,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0341,
+      "good": 0.0478,
+      "ratio": 1.4018,
+      "suggested_scalar": 0.6148,
+      "log_bad": -3.3785,
+      "log_good": -3.0407
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4839,
+      "good": 4.5963,
+      "ratio": 1.0251,
+      "suggested_scalar": 0.0451,
+      "log_bad": 1.5005,
+      "log_good": 1.5253
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 106.0,
+      "good": 111.0,
+      "ratio": 1.0472,
+      "suggested_scalar": 0.0839,
+      "log_bad": 4.6634,
+      "log_good": 4.7095
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6064,
+      "good": 0.5769,
+      "ratio": 0.9514,
+      "suggested_scalar": -0.0908,
+      "log_bad": -0.5002,
+      "log_good": -0.5501
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 18.0,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.1041,
+      "log_bad": 2.8332,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.732,
+      "good": 0.7065,
+      "ratio": 0.9652,
+      "suggested_scalar": -0.0645,
+      "log_bad": -0.312,
+      "log_good": -0.3474
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.8824,
+      "good": 5.4737,
+      "ratio": 0.9305,
+      "suggested_scalar": -0.1311,
+      "log_bad": 1.772,
+      "log_good": 1.7
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 381.0,
+      "good": 460.0,
+      "ratio": 1.2073,
+      "suggested_scalar": 0.343,
+      "log_bad": 5.9428,
+      "log_good": 6.1312
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8276,
+      "good": 0.8483,
+      "ratio": 1.025,
+      "suggested_scalar": 0.045,
+      "log_bad": -0.1892,
+      "log_good": -0.1645
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 144.0,
+      "good": 169.0,
+      "ratio": 1.1736,
+      "suggested_scalar": 0.2914,
+      "log_bad": 4.9698,
+      "log_good": 5.1299
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 108.9306,
+      "good": 104.3356,
+      "ratio": 0.9578,
+      "suggested_scalar": -0.0785,
+      "log_bad": 4.6907,
+      "log_good": 4.6476
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4053,
+      "good": 0.4357,
+      "ratio": 1.075,
+      "suggested_scalar": 0.1317,
+      "log_bad": -0.9031,
+      "log_good": -0.8308
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.5482,
+      "good": 9.8565,
+      "ratio": 1.153,
+      "suggested_scalar": 0.2593,
+      "log_bad": 2.1457,
+      "log_good": 2.2881
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1892.0,
+      "good": 2146.0,
+      "ratio": 1.1342,
+      "suggested_scalar": 0.2293,
+      "log_bad": 7.5454,
+      "log_good": 7.6714
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.3529,
+      "good": 0.2632,
+      "ratio": 0.7458,
+      "suggested_scalar": -0.5339,
+      "log_bad": -1.0416,
+      "log_good": -1.3348
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9412,
+      "good": 0.9825,
+      "ratio": 1.0439,
+      "suggested_scalar": 0.0782,
+      "log_bad": -0.0606,
+      "log_good": -0.0177
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.4706,
+      "good": 8.0702,
+      "ratio": 1.0803,
+      "suggested_scalar": 0.1405,
+      "log_bad": 2.011,
+      "log_good": 2.0882
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.7381,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 25.3195,
+      "good": 23.9335,
+      "ratio": 0.9453,
+      "suggested_scalar": -0.1025,
+      "log_bad": 3.2316,
+      "log_good": 3.1753
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 117.0,
+      "good": 127.0,
+      "ratio": 1.0855,
+      "suggested_scalar": 0.1493,
+      "log_bad": 4.7622,
+      "log_good": 4.8442
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.954,
+      "good": 0.9583,
+      "ratio": 1.0045,
+      "suggested_scalar": 0.0082,
+      "log_bad": -0.0471,
+      "log_good": -0.0426
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 36.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.3319,
+      "log_bad": 3.4012,
+      "log_good": 3.5835
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5629,
+      "good": 0.5895,
+      "ratio": 1.0473,
+      "suggested_scalar": 0.0841,
+      "log_bad": -0.5747,
+      "log_good": -0.5285
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2427,
+      "good": 0.2489,
+      "ratio": 1.0255,
+      "suggested_scalar": 0.0459,
+      "log_bad": -1.4159,
+      "log_good": -1.3907
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2878,
+      "good": 2.4359,
+      "ratio": 1.0647,
+      "suggested_scalar": 0.1142,
+      "log_bad": 0.8276,
+      "log_good": 0.8903
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 379.0,
+      "good": 458.0,
+      "ratio": 1.2084,
+      "suggested_scalar": 0.3447,
+      "log_bad": 5.9375,
+      "log_good": 6.1269
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 18.0,
+      "good": 20.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.1918,
+      "log_bad": 2.8904,
+      "log_good": 2.9957
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0525,
+      "good": 0.05,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0888,
+      "log_bad": -2.9469,
+      "log_good": -2.9957
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.1497,
+      "good": 6.1293,
+      "ratio": 0.9967,
+      "suggested_scalar": -0.006,
+      "log_bad": 1.8164,
+      "log_good": 1.8131
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 26.0,
+      "good": 39.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.7381,
+      "log_bad": 3.2581,
+      "log_good": 3.6636
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7391,
+      "good": 0.9012,
+      "ratio": 1.2193,
+      "suggested_scalar": 0.361,
+      "log_bad": -0.3023,
+      "log_good": -0.104
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.2607,
+      "good": 6.1691,
+      "ratio": 0.9854,
+      "suggested_scalar": -0.0268,
+      "log_bad": 1.8343,
+      "log_good": 1.8196
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7291,
+      "good": 0.7499,
+      "ratio": 1.0285,
+      "suggested_scalar": 0.0512,
+      "log_bad": -0.3159,
+      "log_good": -0.2878
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -1.2619,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.15,
+      "good": 0.1972,
+      "ratio": 1.3147,
+      "suggested_scalar": 0.4981,
+      "log_bad": -1.8971,
+      "log_good": -1.6235
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.9237,
+      "good": 3.1395,
+      "ratio": 1.0738,
+      "suggested_scalar": 0.1296,
+      "log_bad": 1.0728,
+      "log_good": 1.1441
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 325.0,
+      "good": 388.0,
+      "ratio": 1.1938,
+      "suggested_scalar": 0.3226,
+      "log_bad": 5.7838,
+      "log_good": 5.961
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 7.0,
+      "good": 13.0,
+      "ratio": 1.8571,
+      "suggested_scalar": 1.1269,
+      "log_bad": 1.9459,
+      "log_good": 2.5649
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7132,
+      "good": 0.8448,
+      "ratio": 1.1845,
+      "suggested_scalar": 0.3083,
+      "log_bad": -0.338,
+      "log_good": -0.1687
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 132.0,
+      "good": 137.0,
+      "ratio": 1.0379,
+      "suggested_scalar": 0.0677,
+      "log_bad": 4.8828,
+      "log_good": 4.92
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 867.0,
+      "good": 1049.0,
+      "ratio": 1.2099,
+      "suggested_scalar": 0.3469,
+      "log_bad": 6.765,
+      "log_good": 6.9556
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 142.0,
+      "good": 156.0,
+      "ratio": 1.0986,
+      "suggested_scalar": 0.1712,
+      "log_bad": 4.9558,
+      "log_good": 5.0499
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0079,
+      "good": 0.0065,
+      "ratio": 0.8228,
+      "suggested_scalar": -0.3551,
+      "log_bad": -4.8409,
+      "log_good": -5.036
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2231,
+      "good": 0.2326,
+      "ratio": 1.0426,
+      "suggested_scalar": 0.0759,
+      "log_bad": -1.5001,
+      "log_good": -1.4584
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 56.0,
+      "good": 69.0,
+      "ratio": 1.2321,
+      "suggested_scalar": 0.38,
+      "log_bad": 4.0254,
+      "log_good": 4.2341
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 132.0,
+      "good": 137.0,
+      "ratio": 1.0379,
+      "suggested_scalar": 0.0677,
+      "log_bad": 4.8828,
+      "log_good": 4.92
+    },
+    "brevity.mean_sample_size": {
+      "bad": 132.0,
+      "good": 137.0,
+      "ratio": 1.0379,
+      "suggested_scalar": 0.0677,
+      "log_bad": 4.8828,
+      "log_good": 4.92
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 381.0,
+      "good": 460.0,
+      "ratio": 1.2073,
+      "suggested_scalar": 0.343,
+      "log_bad": 5.9428,
+      "log_good": 6.1312
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 168.0,
+      "good": 206.0,
+      "ratio": 1.2262,
+      "suggested_scalar": 0.3712,
+      "log_bad": 5.124,
+      "log_good": 5.3279
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 282.0,
+      "good": 328.0,
+      "ratio": 1.1631,
+      "suggested_scalar": 0.2751,
+      "log_bad": 5.6419,
+      "log_good": 5.793
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0131,
+      "good": 0.0109,
+      "ratio": 0.8321,
+      "suggested_scalar": -0.3347,
+      "log_bad": -4.3351,
+      "log_good": -4.519
+    },
+    "heaps.mean_k": {
+      "bad": 1.7875,
+      "good": 1.9262,
+      "ratio": 1.0776,
+      "suggested_scalar": 0.136,
+      "log_bad": 0.5808,
+      "log_good": 0.6555
+    },
+    "halstead.mean_effort": {
+      "bad": 59961.7058,
+      "good": 94884.8329,
+      "ratio": 1.5824,
+      "suggested_scalar": 0.8355,
+      "log_bad": 11.0015,
+      "log_good": 11.4604
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8888,
+      "good": 0.8691,
+      "ratio": 0.9778,
+      "suggested_scalar": -0.0408,
+      "log_bad": -0.1179,
+      "log_good": -0.1403
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 76.0,
+      "good": 75.0,
+      "ratio": 0.9868,
+      "suggested_scalar": -0.0241,
+      "log_bad": 4.3307,
+      "log_good": 4.3175
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 176.0,
+      "good": 217.0,
+      "ratio": 1.233,
+      "suggested_scalar": 0.3812,
+      "log_bad": 5.1705,
+      "log_good": 5.3799
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5833,
+      "good": 0.4911,
+      "ratio": 0.8419,
+      "suggested_scalar": -0.3132,
+      "log_bad": -0.5391,
+      "log_good": -0.7111
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0208,
+      "good": 6.2071,
+      "ratio": 1.0309,
+      "suggested_scalar": 0.0555,
+      "log_bad": 1.7952,
+      "log_good": 1.8257
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.15,
+      "good": 0.1972,
+      "ratio": 1.3147,
+      "suggested_scalar": 0.4981,
+      "log_bad": -1.8971,
+      "log_good": -1.6235
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.1815,
+      "good": 4.0477,
+      "ratio": 1.2723,
+      "suggested_scalar": 0.4384,
+      "log_bad": 1.1574,
+      "log_good": 1.3981
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 1.2619,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 380.0,
+      "good": 459.0,
+      "ratio": 1.2079,
+      "suggested_scalar": 0.3439,
+      "log_bad": 5.9402,
+      "log_good": 6.1291
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 38.0,
+      "good": 44.0,
+      "ratio": 1.1579,
+      "suggested_scalar": 0.2669,
+      "log_bad": 3.6376,
+      "log_good": 3.7842
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3331.2059,
+      "good": 5271.3796,
+      "ratio": 1.5824,
+      "suggested_scalar": 0.8355,
+      "log_bad": 8.1111,
+      "log_good": 8.57
+    },
+    "readability.mean_total_lines": {
+      "bad": 51.0,
+      "good": 57.0,
+      "ratio": 1.1176,
+      "suggested_scalar": 0.2025,
+      "log_bad": 3.9318,
+      "log_good": 4.0431
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2139.4787,
+      "good": 2534.3171,
+      "ratio": 1.1845,
+      "suggested_scalar": 0.3083,
+      "log_bad": 7.6683,
+      "log_good": 7.8377
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 827.0,
+      "good": 881.0,
+      "ratio": 1.0653,
+      "suggested_scalar": 0.1152,
+      "log_bad": 6.7178,
+      "log_good": 6.7811
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.7255,
+      "good": 36.4035,
+      "ratio": 1.019,
+      "suggested_scalar": 0.0342,
+      "log_bad": 3.5759,
+      "log_good": 3.5947
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0676,
+      "good": 1.1148,
+      "ratio": 1.0442,
+      "suggested_scalar": 0.0788,
+      "log_bad": 0.0654,
+      "log_good": 0.1087
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 17.0,
+      "good": 24.0,
+      "ratio": 1.4118,
+      "suggested_scalar": 0.6278,
+      "log_bad": 2.8332,
+      "log_good": 3.1781
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8831,
+      "good": 0.8866,
+      "ratio": 1.004,
+      "suggested_scalar": 0.0072,
+      "log_bad": -0.1243,
+      "log_good": -0.1204
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 9.0,
+      "good": 13.0,
+      "ratio": 1.4444,
+      "suggested_scalar": 0.6694,
+      "log_bad": 2.1972,
+      "log_good": 2.5649
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9835,
+      "good": 0.9876,
+      "ratio": 1.0042,
+      "suggested_scalar": 0.0076,
+      "log_bad": -0.0166,
+      "log_good": -0.0125
+    },
+    "halstead.mean_length": {
+      "bad": 318.0,
+      "good": 373.0,
+      "ratio": 1.173,
+      "suggested_scalar": 0.2904,
+      "log_bad": 5.7621,
+      "log_good": 5.9216
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 14.3333,
+      "good": 14.0,
+      "ratio": 0.9767,
+      "suggested_scalar": -0.0428,
+      "log_bad": 2.6626,
+      "log_good": 2.6391
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.0444,
+      "good": 7.098,
+      "ratio": 1.0076,
+      "suggested_scalar": 0.0138,
+      "log_bad": 1.9522,
+      "log_good": 1.9598
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0893,
+      "good": 0.096,
+      "ratio": 1.075,
+      "suggested_scalar": 0.1317,
+      "log_bad": -2.4158,
+      "log_good": -2.3434
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 28.0263,
+      "good": 37.44,
+      "ratio": 1.3359,
+      "suggested_scalar": 0.5272,
+      "log_bad": 3.3331,
+      "log_good": 3.6227
+    },
+    "branching.mean_branch_count": {
+      "bad": 18.0,
+      "good": 15.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.3319,
+      "log_bad": 2.8904,
+      "log_good": 2.7081
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 84.0,
+      "good": 83.0,
+      "ratio": 0.9881,
+      "suggested_scalar": -0.0218,
+      "log_bad": 4.4308,
+      "log_good": 4.4188
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8014,
+      "good": 0.7896,
+      "ratio": 0.9853,
+      "suggested_scalar": -0.027,
+      "log_bad": -0.2214,
+      "log_good": -0.2362
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 51.0,
+      "good": 57.0,
+      "ratio": 1.1176,
+      "suggested_scalar": 0.2025,
+      "log_bad": 3.9318,
+      "log_good": 4.0431
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 15.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.2279,
+      "log_bad": 2.8332,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.receiver_name_is_short_type_abbreviation": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0253,
+      "good": 0.0033,
+      "ratio": 0.1304,
+      "suggested_scalar": -2.0,
+      "log_bad": -3.677,
+      "log_good": -5.7138
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.8,
+      "good": 0.8,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2231,
+      "log_good": -0.2231
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8462,
+      "good": 0.85,
+      "ratio": 1.0045,
+      "suggested_scalar": 0.0044,
+      "log_bad": -0.167,
+      "log_good": -0.1625
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0253,
+      "good": 0.0033,
+      "ratio": 0.1304,
+      "suggested_scalar": -2.0,
+      "log_bad": -3.677,
+      "log_good": -5.7138
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8293,
+      "good": 4.7547,
+      "ratio": 0.9846,
+      "suggested_scalar": -0.0153,
+      "log_bad": 1.5747,
+      "log_good": 1.5591
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 97.0,
+      "good": 86.0,
+      "ratio": 0.8866,
+      "suggested_scalar": -0.1182,
+      "log_bad": 4.5747,
+      "log_good": 4.4543
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4829,
+      "good": 0.4576,
+      "ratio": 0.9476,
+      "suggested_scalar": -0.0528,
+      "log_bad": -0.7279,
+      "log_good": -0.7818
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 15.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0634,
+      "log_bad": 2.7726,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6534,
+      "good": 0.6429,
+      "ratio": 0.9839,
+      "suggested_scalar": -0.0159,
+      "log_bad": -0.4256,
+      "log_good": -0.4418
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.2821,
+      "good": 0.275,
+      "ratio": 0.9748,
+      "suggested_scalar": -0.025,
+      "log_bad": -1.2655,
+      "log_good": -1.291
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 316.0,
+      "good": 304.0,
+      "ratio": 0.962,
+      "suggested_scalar": -0.038,
+      "log_bad": 5.7557,
+      "log_good": 5.717
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2821,
+      "good": 0.3,
+      "ratio": 1.0635,
+      "suggested_scalar": 0.0604,
+      "log_bad": -1.2655,
+      "log_good": -1.204
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8773,
+      "good": 0.9115,
+      "ratio": 1.039,
+      "suggested_scalar": 0.0376,
+      "log_bad": -0.1309,
+      "log_good": -0.0927
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 133.0,
+      "good": 137.0,
+      "ratio": 1.0301,
+      "suggested_scalar": 0.0291,
+      "log_bad": 4.8903,
+      "log_good": 4.92
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 110.0988,
+      "good": 110.6313,
+      "ratio": 1.0048,
+      "suggested_scalar": 0.0047,
+      "log_bad": 4.7014,
+      "log_good": 4.7062
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4857,
+      "good": 0.5116,
+      "ratio": 1.0533,
+      "suggested_scalar": 0.051,
+      "log_bad": -0.7222,
+      "log_good": -0.6702
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.1838,
+      "good": 9.2911,
+      "ratio": 1.2933,
+      "suggested_scalar": 0.2526,
+      "log_bad": 1.9718,
+      "log_good": 2.2291
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1242.0,
+      "good": 1245.0,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.0024,
+      "log_bad": 7.1245,
+      "log_good": 7.1269
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1026,
+      "good": 0.15,
+      "ratio": 1.462,
+      "suggested_scalar": 0.3729,
+      "log_bad": -2.2769,
+      "log_good": -1.8971
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8462,
+      "good": 0.85,
+      "ratio": 1.0045,
+      "suggested_scalar": 0.0044,
+      "log_bad": -0.167,
+      "log_good": -0.1625
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.1026,
+      "good": 7.6,
+      "ratio": 0.938,
+      "suggested_scalar": -0.0629,
+      "log_bad": 2.0922,
+      "log_good": 2.0281
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.2025,
+      "good": 0.1994,
+      "ratio": 0.9847,
+      "suggested_scalar": -0.0151,
+      "log_bad": -1.597,
+      "log_good": -1.6124
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 89.0,
+      "good": 90.0,
+      "ratio": 1.0112,
+      "suggested_scalar": 0.011,
+      "log_bad": 4.4886,
+      "log_good": 4.4998
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.937,
+      "good": 0.9471,
+      "ratio": 1.0108,
+      "suggested_scalar": 0.0105,
+      "log_bad": -0.0651,
+      "log_good": -0.0544
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 24.0,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0401,
+      "log_bad": 3.2189,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5588,
+      "good": 0.5703,
+      "ratio": 1.0206,
+      "suggested_scalar": 0.02,
+      "log_bad": -0.582,
+      "log_good": -0.5616
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2803,
+      "good": 0.2914,
+      "ratio": 1.0396,
+      "suggested_scalar": 0.0381,
+      "log_bad": -1.2719,
+      "log_good": -1.2331
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2664,
+      "good": 2.3271,
+      "ratio": 1.0268,
+      "suggested_scalar": 0.026,
+      "log_bad": 0.8182,
+      "log_good": 0.8446
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 314.0,
+      "good": 302.0,
+      "ratio": 0.9618,
+      "suggested_scalar": -0.0383,
+      "log_bad": 5.7494,
+      "log_good": 5.7104
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0032,
+      "good": 0.0066,
+      "ratio": 2.0625,
+      "suggested_scalar": 0.7108,
+      "log_bad": -5.7446,
+      "log_good": -5.0207
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8074,
+      "good": 5.7549,
+      "ratio": 0.991,
+      "suggested_scalar": -0.0089,
+      "log_bad": 1.7591,
+      "log_good": 1.7501
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 44.0,
+      "good": 47.0,
+      "ratio": 1.0682,
+      "suggested_scalar": 0.0648,
+      "log_bad": 3.7842,
+      "log_good": 3.8501
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9158,
+      "good": 0.9277,
+      "ratio": 1.013,
+      "suggested_scalar": 0.0127,
+      "log_bad": -0.088,
+      "log_good": -0.075
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8533,
+      "good": 5.7151,
+      "ratio": 0.9764,
+      "suggested_scalar": -0.0235,
+      "log_bad": 1.767,
+      "log_good": 1.7431
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8316,
+      "good": 0.8262,
+      "ratio": 0.9935,
+      "suggested_scalar": -0.0064,
+      "log_bad": -0.1844,
+      "log_good": -0.1909
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1702,
+      "good": 0.1667,
+      "ratio": 0.9794,
+      "suggested_scalar": -0.0204,
+      "log_bad": -1.7708,
+      "log_good": -1.7916
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.6803,
+      "good": 3.0481,
+      "ratio": 1.1372,
+      "suggested_scalar": 0.1263,
+      "log_bad": 0.9859,
+      "log_good": 1.1145
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 257.0,
+      "good": 249.0,
+      "ratio": 0.9689,
+      "suggested_scalar": -0.0311,
+      "log_bad": 5.5491,
+      "log_good": 5.5175
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.649,
+      "good": 0.6362,
+      "ratio": 0.9803,
+      "suggested_scalar": -0.0196,
+      "log_bad": -0.4323,
+      "log_good": -0.4522
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 92.0,
+      "good": 86.0,
+      "ratio": 0.9348,
+      "suggested_scalar": -0.0662,
+      "log_bad": 4.5218,
+      "log_good": 4.4543
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 709.0,
+      "good": 732.0,
+      "ratio": 1.0324,
+      "suggested_scalar": 0.0313,
+      "log_bad": 6.5639,
+      "log_good": 6.5958
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 151.0,
+      "good": 152.0,
+      "ratio": 1.0066,
+      "suggested_scalar": 0.0065,
+      "log_bad": 5.0173,
+      "log_good": 5.0239
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2025,
+      "good": 0.1941,
+      "ratio": 0.9585,
+      "suggested_scalar": -0.0416,
+      "log_bad": -1.597,
+      "log_good": -1.6394
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 50.0,
+      "good": 54.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.0756,
+      "log_bad": 3.912,
+      "log_good": 3.989
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 92.0,
+      "good": 86.0,
+      "ratio": 0.9348,
+      "suggested_scalar": -0.0662,
+      "log_bad": 4.5218,
+      "log_good": 4.4543
+    },
+    "brevity.mean_sample_size": {
+      "bad": 92.0,
+      "good": 86.0,
+      "ratio": 0.9348,
+      "suggested_scalar": -0.0662,
+      "log_bad": 4.5218,
+      "log_good": 4.4543
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 316.0,
+      "good": 304.0,
+      "ratio": 0.962,
+      "suggested_scalar": -0.038,
+      "log_bad": 5.7557,
+      "log_good": 5.717
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 143.0,
+      "good": 130.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0936,
+      "log_bad": 4.9628,
+      "log_good": 4.8675
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 212.0,
+      "good": 202.0,
+      "ratio": 0.9528,
+      "suggested_scalar": -0.0474,
+      "log_bad": 5.3566,
+      "log_good": 5.3083
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.333,
+      "good": 2.5305,
+      "ratio": 1.0847,
+      "suggested_scalar": 0.0798,
+      "log_bad": 0.8472,
+      "log_good": 0.9284
+    },
+    "halstead.mean_effort": {
+      "bad": 51040.4718,
+      "good": 56149.7992,
+      "ratio": 1.1001,
+      "suggested_scalar": 0.0937,
+      "log_bad": 10.8404,
+      "log_good": 10.9358
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8973,
+      "good": 0.8893,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.0088,
+      "log_bad": -0.1084,
+      "log_good": -0.1173
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 72.0,
+      "good": 62.0,
+      "ratio": 0.8611,
+      "suggested_scalar": -0.1468,
+      "log_bad": 4.2767,
+      "log_good": 4.1271
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 144.0,
+      "good": 145.0,
+      "ratio": 1.0069,
+      "suggested_scalar": 0.0068,
+      "log_bad": 4.9698,
+      "log_good": 4.9767
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4436,
+      "good": 0.4015,
+      "ratio": 0.9051,
+      "suggested_scalar": -0.0979,
+      "log_bad": -0.8128,
+      "log_good": -0.9125
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.3308,
+      "good": 5.3431,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0023,
+      "log_bad": 1.6735,
+      "log_good": 1.6758
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1702,
+      "good": 0.1667,
+      "ratio": 0.9794,
+      "suggested_scalar": -0.0204,
+      "log_bad": -1.7708,
+      "log_good": -1.7916
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.241,
+      "good": 3.04,
+      "ratio": 0.938,
+      "suggested_scalar": -0.0629,
+      "log_bad": 1.1759,
+      "log_good": 1.1119
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 315.0,
+      "good": 303.0,
+      "ratio": 0.9619,
+      "suggested_scalar": -0.0381,
+      "log_bad": 5.7526,
+      "log_good": 5.7137
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 31.0,
+      "good": 35.0,
+      "ratio": 1.129,
+      "suggested_scalar": 0.1192,
+      "log_bad": 3.434,
+      "log_good": 3.5553
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2835.5818,
+      "good": 3119.4333,
+      "ratio": 1.1001,
+      "suggested_scalar": 0.0937,
+      "log_bad": 7.95,
+      "log_good": 8.0454
+    },
+    "readability.mean_total_lines": {
+      "bad": 39.0,
+      "good": 40.0,
+      "ratio": 1.0256,
+      "suggested_scalar": 0.0249,
+      "log_bad": 3.6636,
+      "log_good": 3.6889
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1946.9743,
+      "good": 1908.6006,
+      "ratio": 0.9803,
+      "suggested_scalar": -0.0195,
+      "log_bad": 7.574,
+      "log_good": 7.5541
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 548.0,
+      "good": 535.0,
+      "ratio": 0.9763,
+      "suggested_scalar": -0.0236,
+      "log_bad": 6.3063,
+      "log_good": 6.2823
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.4359,
+      "good": 29.725,
+      "ratio": 0.9766,
+      "suggested_scalar": -0.0232,
+      "log_bad": 3.4156,
+      "log_good": 3.392
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0462,
+      "good": 1.046,
+      "ratio": 0.9998,
+      "suggested_scalar": -0.0002,
+      "log_bad": 0.0452,
+      "log_good": 0.045
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 22.0,
+      "good": 23.0,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.0436,
+      "log_bad": 3.091,
+      "log_good": 3.1355
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 11.0,
+      "good": 12.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0854,
+      "log_bad": 2.3979,
+      "log_good": 2.4849
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8794,
+      "good": 0.8594,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.0226,
+      "log_bad": -0.1285,
+      "log_good": -0.1515
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9855,
+      "good": 0.9762,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.0093,
+      "log_bad": -0.0146,
+      "log_good": -0.0241
+    },
+    "halstead.mean_length": {
+      "bad": 295.0,
+      "good": 297.0,
+      "ratio": 1.0068,
+      "suggested_scalar": 0.0066,
+      "log_bad": 5.687,
+      "log_good": 5.6937
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.6,
+      "good": 5.6,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7228,
+      "log_good": 1.7228
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5236,
+      "good": 6.4263,
+      "ratio": 0.9851,
+      "suggested_scalar": -0.0148,
+      "log_bad": 1.8754,
+      "log_good": 1.8604
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1159,
+      "good": 0.1051,
+      "ratio": 0.9068,
+      "suggested_scalar": -0.096,
+      "log_bad": -2.155,
+      "log_good": -2.2528
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 26.2153,
+      "good": 29.4194,
+      "ratio": 1.1222,
+      "suggested_scalar": 0.1132,
+      "log_bad": 3.2663,
+      "log_good": 3.3817
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.3981,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 59.0,
+      "good": 55.0,
+      "ratio": 0.9322,
+      "suggested_scalar": -0.0689,
+      "log_bad": 4.0775,
+      "log_good": 4.0073
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7642,
+      "good": 0.7327,
+      "ratio": 0.9588,
+      "suggested_scalar": -0.0413,
+      "log_bad": -0.2689,
+      "log_good": -0.311
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 39.0,
+      "good": 40.0,
+      "ratio": 1.0256,
+      "suggested_scalar": 0.0249,
+      "log_bad": 3.6636,
+      "log_good": 3.6889
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.file_name_matches_primary_export": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 29.0,
+      "good": 29.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3673,
+      "log_good": 3.3673
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.017,
+      "good": 0.017,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.0745,
+      "log_good": -4.0745
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0909,
+      "good": 1.0909,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.087,
+      "log_good": 0.087
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7619,
+      "good": 0.7619,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2719,
+      "log_good": -0.2719
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.017,
+      "good": 0.017,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.0745,
+      "log_good": -4.0745
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5858,
+      "good": 4.5858,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.523,
+      "log_good": 1.523
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 60.0,
+      "good": 60.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0943,
+      "log_good": 4.0943
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3543,
+      "good": 0.3543,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.0376,
+      "log_good": -1.0376
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5742,
+      "good": 0.5742,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.5548,
+      "log_good": -0.5548
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.5714,
+      "good": 3.5714,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.273,
+      "log_good": 1.273
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 352.0,
+      "good": 352.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.8636,
+      "log_good": 5.8636
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1101,
+      "good": 1.1101,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1045,
+      "log_good": 0.1045
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 106.0,
+      "good": 106.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.6634,
+      "log_good": 4.6634
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.5636,
+      "good": 101.5636,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.6207,
+      "log_good": 4.6207
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7835,
+      "good": 0.7835,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.244,
+      "log_good": -0.244
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 14.6807,
+      "good": 14.6807,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6865,
+      "log_good": 2.6865
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1285.0,
+      "good": 1285.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 7.1585,
+      "log_good": 7.1585
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.119,
+      "good": 0.119,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.1286,
+      "log_good": -2.1286
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7143,
+      "good": 0.7143,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3365,
+      "log_good": -0.3365
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.381,
+      "good": 8.381,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.126,
+      "log_good": 2.126
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 4.2449,
+      "good": 4.2449,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.4457,
+      "log_good": 1.4457
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 98.0,
+      "good": 98.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.585,
+      "log_good": 4.585
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9317,
+      "good": 0.9317,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0707,
+      "log_good": -0.0707
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6576,
+      "good": 0.6576,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.4192,
+      "log_good": -0.4192
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.62,
+      "good": 0.62,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.478,
+      "log_good": -0.478
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9205,
+      "good": 2.9205,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0718,
+      "log_good": 1.0718
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 350.0,
+      "good": 350.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.8579,
+      "log_good": 5.8579
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0511,
+      "good": 0.0511,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.974,
+      "log_good": -2.974
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.6439,
+      "good": 5.6439,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7306,
+      "log_good": 1.7306
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.4472,
+      "good": 0.4472,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.8047,
+      "log_good": -0.8047
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.129,
+      "good": 5.129,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6349,
+      "log_good": 1.6349
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8125,
+      "good": 0.8125,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2076,
+      "log_good": -0.2076
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.16,
+      "good": 0.16,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.8326,
+      "log_good": -1.8326
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.8315,
+      "good": 3.8315,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3433,
+      "log_good": 1.3433
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 207.0,
+      "good": 207.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.3327,
+      "log_good": 5.3327
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6379,
+      "good": 0.6379,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.4496,
+      "log_good": -0.4496
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 64.0,
+      "good": 64.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.1589,
+      "log_good": 4.1589
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 650.0,
+      "good": 650.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.477,
+      "log_good": 6.477
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 103.0,
+      "good": 103.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.6347,
+      "log_good": 4.6347
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0114,
+      "good": 0.0114,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.4741,
+      "log_good": -4.4741
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2841,
+      "good": 0.2841,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.2584,
+      "log_good": -1.2584
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 76.0,
+      "good": 76.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3307,
+      "log_good": 4.3307
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 64.0,
+      "good": 64.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.1589,
+      "log_good": 4.1589
+    },
+    "brevity.mean_sample_size": {
+      "bad": 64.0,
+      "good": 64.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.1589,
+      "log_good": 4.1589
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 352.0,
+      "good": 352.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.8636,
+      "log_good": 5.8636
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 196.0,
+      "good": 196.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.2781,
+      "log_good": 5.2781
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 152.0,
+      "good": 152.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.0239,
+      "log_good": 5.0239
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.3265,
+      "good": 2.3265,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.8444,
+      "log_good": 0.8444
+    },
+    "halstead.mean_effort": {
+      "bad": 57062.4285,
+      "good": 57062.4285,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 10.9519,
+      "log_good": 10.9519
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8548,
+      "good": 0.8548,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1569,
+      "log_good": -0.1569
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 38.0,
+      "good": 38.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6376,
+      "log_good": 3.6376
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 221.0,
+      "good": 221.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.3982,
+      "log_good": 5.3982
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3491,
+      "good": 0.3491,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.0524,
+      "log_good": -1.0524
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.1321,
+      "good": 6.1321,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8135,
+      "log_good": 1.8135
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.16,
+      "good": 0.16,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.8326,
+      "log_good": -1.8326
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.8753,
+      "good": 3.8753,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3546,
+      "log_good": 1.3546
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 351.0,
+      "good": 351.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.8608,
+      "log_good": 5.8608
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 74.0,
+      "good": 74.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3041,
+      "log_good": 4.3041
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3170.1349,
+      "good": 3170.1349,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 8.0615,
+      "log_good": 8.0615
+    },
+    "readability.mean_total_lines": {
+      "bad": 42.0,
+      "good": 42.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7377,
+      "log_good": 3.7377
+    },
+    "indentation.mean_max_depth": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "halstead.mean_volume": {
+      "bad": 1913.8326,
+      "good": 1913.8326,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 7.5569,
+      "log_good": 7.5569
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 440.0,
+      "good": 440.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.0868,
+      "log_good": 6.0868
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 29.4048,
+      "good": 29.4048,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3812,
+      "log_good": 3.3812
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1438,
+      "good": 1.1438,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1344,
+      "log_good": 0.1344
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6425,
+      "good": 0.6425,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.4424,
+      "log_good": -0.4424
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9697,
+      "good": 0.9697,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0308,
+      "log_good": -0.0308
+    },
+    "halstead.mean_length": {
+      "bad": 324.0,
+      "good": 324.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.7807,
+      "log_good": 5.7807
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.4545,
+      "good": 4.4545,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.4939,
+      "log_good": 1.4939
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1525,
+      "good": 0.1525,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.8806,
+      "log_good": -1.8806
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.8158,
+      "good": 29.8158,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.395,
+      "log_good": 3.395
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 37.0,
+      "good": 37.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6109,
+      "log_good": 3.6109
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5,
+      "good": 0.5,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.6931,
+      "log_good": -0.6931
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 42.0,
+      "good": 42.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7377,
+      "log_good": 3.7377
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.does_not_assert_result_without_value": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 8.0,
+      "good": 7.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.4972,
+      "log_bad": 2.0794,
+      "log_good": 1.9459
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0237,
+      "good": 0.0301,
+      "ratio": 1.27,
+      "suggested_scalar": 0.8901,
+      "log_bad": -3.7423,
+      "log_good": -3.5032
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.2857,
+      "good": 0.2857,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.2528,
+      "log_good": -1.2528
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7381,
+      "good": 0.7381,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3037,
+      "log_good": -0.3037
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0263,
+      "good": 0.0351,
+      "ratio": 1.3346,
+      "suggested_scalar": 1.0747,
+      "log_bad": -3.6382,
+      "log_good": -3.3496
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7163,
+      "good": 4.6948,
+      "ratio": 0.9954,
+      "suggested_scalar": -0.017,
+      "log_bad": 1.551,
+      "log_good": 1.5465
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 101.0,
+      "good": 101.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.6151,
+      "log_good": 4.6151
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6663,
+      "good": 0.5742,
+      "ratio": 0.8618,
+      "suggested_scalar": -0.5539,
+      "log_bad": -0.406,
+      "log_good": -0.5548
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6803,
+      "good": 0.6311,
+      "ratio": 0.9277,
+      "suggested_scalar": -0.2795,
+      "log_bad": -0.3852,
+      "log_good": -0.4603
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.5714,
+      "good": 4.5714,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.5198,
+      "log_good": 1.5198
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 380.0,
+      "good": 399.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.1817,
+      "log_bad": 5.9402,
+      "log_good": 5.989
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0065,
+      "good": 0.0042,
+      "ratio": 0.6462,
+      "suggested_scalar": -1.6261,
+      "log_bad": -5.036,
+      "log_good": -5.4727
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2857,
+      "good": 0.2381,
+      "ratio": 0.8334,
+      "suggested_scalar": -0.6786,
+      "log_bad": -1.2528,
+      "log_good": -1.4351
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9252,
+      "good": 0.9715,
+      "ratio": 1.05,
+      "suggested_scalar": 0.1818,
+      "log_bad": -0.0777,
+      "log_good": -0.0289
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 123.0,
+      "good": 125.0,
+      "ratio": 1.0163,
+      "suggested_scalar": 0.0601,
+      "log_bad": 4.8122,
+      "log_good": 4.8283
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 94.6011,
+      "good": 96.1529,
+      "ratio": 1.0164,
+      "suggested_scalar": 0.0606,
+      "log_bad": 4.5497,
+      "log_good": 4.5659
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5356,
+      "good": 0.6307,
+      "ratio": 1.1776,
+      "suggested_scalar": 0.6086,
+      "log_bad": -0.6244,
+      "log_good": -0.4609
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 18.7723,
+      "good": 20.0489,
+      "ratio": 1.068,
+      "suggested_scalar": 0.245,
+      "log_bad": 2.9324,
+      "log_good": 2.9982
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1397.0,
+      "good": 1426.0,
+      "ratio": 1.0208,
+      "suggested_scalar": 0.0765,
+      "log_bad": 7.2421,
+      "log_good": 7.2626
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0476,
+      "good": 0.0714,
+      "ratio": 1.5,
+      "suggested_scalar": 1.5097,
+      "log_bad": -3.0449,
+      "log_good": -2.6395
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7143,
+      "good": 0.7143,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3365,
+      "log_good": -0.3365
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.5556,
+      "good": 11.0833,
+      "ratio": 1.05,
+      "suggested_scalar": 0.1816,
+      "log_bad": 2.3567,
+      "log_good": 2.4054
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 1.5097,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 8.0544,
+      "good": 8.0544,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0862,
+      "log_good": 2.0862
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 107.0,
+      "good": 113.0,
+      "ratio": 1.0561,
+      "suggested_scalar": 0.2031,
+      "log_bad": 4.6728,
+      "log_good": 4.7274
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9495,
+      "good": 0.9473,
+      "ratio": 0.9977,
+      "suggested_scalar": -0.0086,
+      "log_bad": -0.0518,
+      "log_good": -0.0541
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 29.0,
+      "ratio": 1.0741,
+      "suggested_scalar": 0.2661,
+      "log_bad": 3.2958,
+      "log_good": 3.3673
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5626,
+      "good": 0.5849,
+      "ratio": 1.0396,
+      "suggested_scalar": 0.1447,
+      "log_bad": -0.5752,
+      "log_good": -0.5363
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.381,
+      "good": 0.4836,
+      "ratio": 1.2693,
+      "suggested_scalar": 0.8879,
+      "log_bad": -0.965,
+      "log_good": -0.7265
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2864,
+      "good": 2.4088,
+      "ratio": 1.0535,
+      "suggested_scalar": 0.1942,
+      "log_bad": 0.827,
+      "log_good": 0.8791
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 378.0,
+      "good": 397.0,
+      "ratio": 1.0503,
+      "suggested_scalar": 0.1826,
+      "log_bad": 5.9349,
+      "log_good": 5.9839
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0158,
+      "good": 0.0175,
+      "ratio": 1.1076,
+      "suggested_scalar": 0.3805,
+      "log_bad": -4.1477,
+      "log_good": -4.0456
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0661,
+      "good": 6.0,
+      "ratio": 0.9891,
+      "suggested_scalar": -0.0408,
+      "log_bad": 1.8027,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 14.0,
+      "good": 9.0,
+      "ratio": 0.6429,
+      "suggested_scalar": -1.6451,
+      "log_bad": 2.6391,
+      "log_good": 2.1972
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6284,
+      "good": 0.5341,
+      "ratio": 0.8499,
+      "suggested_scalar": -0.6054,
+      "log_bad": -0.4646,
+      "log_good": -0.6272
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8511,
+      "good": 5.7874,
+      "ratio": 0.9891,
+      "suggested_scalar": -0.0408,
+      "log_bad": 1.7666,
+      "log_good": 1.7557
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7775,
+      "good": 0.7825,
+      "ratio": 1.0064,
+      "suggested_scalar": 0.0239,
+      "log_bad": -0.2517,
+      "log_good": -0.2453
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.16,
+      "good": 0.16,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.8326,
+      "log_good": -1.8326
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.3327,
+      "good": 4.4776,
+      "ratio": 1.0334,
+      "suggested_scalar": 0.1225,
+      "log_bad": 1.4662,
+      "log_good": 1.4991
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -1.5097,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 279.0,
+      "good": 282.0,
+      "ratio": 1.0108,
+      "suggested_scalar": 0.0398,
+      "log_bad": 5.6312,
+      "log_good": 5.6419
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 17.0,
+      "good": 24.0,
+      "ratio": 1.4118,
+      "suggested_scalar": 1.284,
+      "log_bad": 2.8332,
+      "log_good": 3.1781
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.688,
+      "good": 0.7524,
+      "ratio": 1.0936,
+      "suggested_scalar": 0.3332,
+      "log_bad": -0.374,
+      "log_good": -0.2845
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 115.0,
+      "good": 104.0,
+      "ratio": 0.9043,
+      "suggested_scalar": -0.3744,
+      "log_bad": 4.7449,
+      "log_good": 4.6444
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 698.0,
+      "good": 731.0,
+      "ratio": 1.0473,
+      "suggested_scalar": 0.172,
+      "log_bad": 6.5482,
+      "log_good": 6.5944
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 110.0,
+      "good": 123.0,
+      "ratio": 1.1182,
+      "suggested_scalar": 0.4159,
+      "log_bad": 4.7005,
+      "log_good": 4.8122
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0053,
+      "good": 0.005,
+      "ratio": 0.9434,
+      "suggested_scalar": -0.217,
+      "log_bad": -5.24,
+      "log_good": -5.2983
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2,
+      "good": 0.208,
+      "ratio": 1.04,
+      "suggested_scalar": 0.146,
+      "log_bad": -1.6094,
+      "log_good": -1.5702
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 54.0,
+      "good": 81.0,
+      "ratio": 1.5,
+      "suggested_scalar": 1.5097,
+      "log_bad": 3.989,
+      "log_good": 4.3944
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 115.0,
+      "good": 104.0,
+      "ratio": 0.9043,
+      "suggested_scalar": -0.3744,
+      "log_bad": 4.7449,
+      "log_good": 4.6444
+    },
+    "brevity.mean_sample_size": {
+      "bad": 115.0,
+      "good": 104.0,
+      "ratio": 0.9043,
+      "suggested_scalar": -0.3744,
+      "log_bad": 4.7449,
+      "log_good": 4.6444
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 380.0,
+      "good": 399.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.1817,
+      "log_bad": 5.9402,
+      "log_good": 5.989
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 227.0,
+      "good": 239.0,
+      "ratio": 1.0529,
+      "suggested_scalar": 0.1918,
+      "log_bad": 5.425,
+      "log_good": 5.4765
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 230.0,
+      "good": 228.0,
+      "ratio": 0.9913,
+      "suggested_scalar": -0.0325,
+      "log_bad": 5.4381,
+      "log_good": 5.4293
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0079,
+      "good": 0.005,
+      "ratio": 0.6329,
+      "suggested_scalar": -1.7032,
+      "log_bad": -4.8409,
+      "log_good": -5.2983
+    },
+    "heaps.mean_k": {
+      "bad": 2.1088,
+      "good": 2.5278,
+      "ratio": 1.1987,
+      "suggested_scalar": 0.6748,
+      "log_bad": 0.7461,
+      "log_good": 0.9273
+    },
+    "halstead.mean_effort": {
+      "bad": 41420.3737,
+      "good": 55911.0825,
+      "ratio": 1.3498,
+      "suggested_scalar": 1.117,
+      "log_bad": 10.6315,
+      "log_good": 10.9315
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8547,
+      "good": 0.8637,
+      "ratio": 1.0105,
+      "suggested_scalar": 0.039,
+      "log_bad": -0.157,
+      "log_good": -0.1465
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 74.0,
+      "good": 72.0,
+      "ratio": 0.973,
+      "suggested_scalar": -0.102,
+      "log_bad": 4.3041,
+      "log_good": 4.2767
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 200.0,
+      "good": 216.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.2866,
+      "log_bad": 5.2983,
+      "log_good": 5.3753
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.6098,
+      "good": 0.512,
+      "ratio": 0.8396,
+      "suggested_scalar": -0.6509,
+      "log_bad": -0.4946,
+      "log_good": -0.6694
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.6748,
+      "good": 5.848,
+      "ratio": 1.0305,
+      "suggested_scalar": 0.1119,
+      "log_bad": 1.736,
+      "log_good": 1.7661
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.16,
+      "good": 0.16,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.8326,
+      "log_good": -1.8326
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.5556,
+      "good": 5.732,
+      "ratio": 1.0318,
+      "suggested_scalar": 0.1164,
+      "log_bad": 1.7148,
+      "log_good": 1.7461
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 379.0,
+      "good": 398.0,
+      "ratio": 1.0501,
+      "suggested_scalar": 0.1821,
+      "log_bad": 5.9375,
+      "log_good": 5.9865
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 19.0,
+      "good": 16.0,
+      "ratio": 0.8421,
+      "suggested_scalar": -0.6399,
+      "log_bad": 2.9444,
+      "log_good": 2.7726
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 45.0,
+      "good": 77.0,
+      "ratio": 1.7111,
+      "suggested_scalar": 2.0,
+      "log_bad": 3.8067,
+      "log_good": 4.3438
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2301.1319,
+      "good": 3106.1713,
+      "ratio": 1.3498,
+      "suggested_scalar": 1.117,
+      "log_bad": 7.7412,
+      "log_good": 8.0411
+    },
+    "readability.mean_total_lines": {
+      "bad": 36.0,
+      "good": 36.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5835,
+      "log_good": 3.5835
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2064.0456,
+      "good": 2257.1337,
+      "ratio": 1.0935,
+      "suggested_scalar": 0.333,
+      "log_bad": 7.6324,
+      "log_good": 7.7219
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 611.0,
+      "good": 592.0,
+      "ratio": 0.9689,
+      "suggested_scalar": -0.1176,
+      "log_bad": 6.4151,
+      "log_good": 6.3835
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.3889,
+      "good": 36.3056,
+      "ratio": 1.0259,
+      "suggested_scalar": 0.0952,
+      "log_bad": 3.5664,
+      "log_good": 3.592
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2,
+      "good": 1.1753,
+      "ratio": 0.9794,
+      "suggested_scalar": -0.0774,
+      "log_bad": 0.1823,
+      "log_good": 0.1615
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 12.0,
+      "good": 10.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.6789,
+      "log_bad": 2.4849,
+      "log_good": 2.3026
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8387,
+      "good": 0.727,
+      "ratio": 0.8668,
+      "suggested_scalar": -0.5322,
+      "log_bad": -0.1759,
+      "log_good": -0.3188
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9872,
+      "good": 0.9837,
+      "ratio": 0.9965,
+      "suggested_scalar": -0.0132,
+      "log_bad": -0.0129,
+      "log_good": -0.0164
+    },
+    "halstead.mean_length": {
+      "bad": 310.0,
+      "good": 339.0,
+      "ratio": 1.0935,
+      "suggested_scalar": 0.333,
+      "log_bad": 5.7366,
+      "log_good": 5.826
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.8571,
+      "good": 6.8571,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9253,
+      "log_good": 1.9253
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8455,
+      "good": 6.7004,
+      "ratio": 0.9788,
+      "suggested_scalar": -0.0798,
+      "log_bad": 1.9236,
+      "log_good": 1.9022
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1632,
+      "good": 0.1678,
+      "ratio": 1.0282,
+      "suggested_scalar": 0.1035,
+      "log_bad": -1.8128,
+      "log_good": -1.785
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 20.0676,
+      "good": 24.7708,
+      "ratio": 1.2344,
+      "suggested_scalar": 0.784,
+      "log_bad": 2.9991,
+      "log_good": 3.2097
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 1.5097,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 75.0,
+      "good": 64.0,
+      "ratio": 0.8533,
+      "suggested_scalar": -0.5906,
+      "log_bad": 4.3175,
+      "log_good": 4.1589
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7652,
+      "good": 0.6447,
+      "ratio": 0.8425,
+      "suggested_scalar": -0.638,
+      "log_bad": -0.2676,
+      "log_good": -0.439
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 42.0,
+      "good": 42.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7377,
+      "log_good": 3.7377
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 30.0,
+      "good": 30.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4012,
+      "log_good": 3.4012
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "variable_naming.no_hungarian_notation": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 134.0,
+      "good": 44.0,
+      "ratio": 0.3284,
+      "suggested_scalar": -2.0,
+      "log_bad": 4.8978,
+      "log_good": 3.7842
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 33.3333,
+      "good": 33.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5066,
+      "log_good": 3.5066
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0047,
+      "good": 0.0047,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.3602,
+      "log_good": -5.3602
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6185,
+      "good": 1.6185,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.4815,
+      "log_good": 0.4815
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.852,
+      "good": 0.852,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1602,
+      "log_good": -0.1602
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0113,
+      "good": 0.0113,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.483,
+      "log_good": -4.483
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.831,
+      "good": 4.7437,
+      "ratio": 0.9819,
+      "suggested_scalar": -0.0328,
+      "log_bad": 1.5751,
+      "log_good": 1.5568
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 116.0,
+      "good": 108.6667,
+      "ratio": 0.9368,
+      "suggested_scalar": -0.1173,
+      "log_bad": 4.7536,
+      "log_good": 4.6883
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4343,
+      "good": 0.4009,
+      "ratio": 0.9231,
+      "suggested_scalar": -0.1437,
+      "log_bad": -0.834,
+      "log_good": -0.914
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.6667,
+      "good": 21.6667,
+      "ratio": 1.0484,
+      "suggested_scalar": 0.0849,
+      "log_bad": 3.0285,
+      "log_good": 3.0758
+    },
+    "heaps.mean_beta": {
+      "bad": 0.574,
+      "good": 0.5628,
+      "ratio": 0.9805,
+      "suggested_scalar": -0.0354,
+      "log_bad": -0.5551,
+      "log_good": -0.5748
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.1157,
+      "good": 3.1157,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.1365,
+      "log_good": 1.1365
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 586.3333,
+      "good": 585.6667,
+      "ratio": 0.9989,
+      "suggested_scalar": -0.002,
+      "log_bad": 6.3739,
+      "log_good": 6.3728
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.6667,
+      "good": 3.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.2993,
+      "log_good": 1.2993
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0001,
+      "good": 0.0001,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -9.2103,
+      "log_good": -9.2103
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.021,
+      "good": 0.021,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.8632,
+      "log_good": -3.8632
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0011,
+      "good": 0.0012,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.1563,
+      "log_bad": -6.8124,
+      "log_good": -6.7254
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0398,
+      "good": 1.0784,
+      "ratio": 1.0371,
+      "suggested_scalar": 0.0655,
+      "log_bad": 0.039,
+      "log_good": 0.0755
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 199.3333,
+      "good": 200.0,
+      "ratio": 1.0033,
+      "suggested_scalar": 0.006,
+      "log_bad": 5.295,
+      "log_good": 5.2983
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 67.4553,
+      "good": 98.6028,
+      "ratio": 1.4618,
+      "suggested_scalar": 0.6818,
+      "log_bad": 4.2115,
+      "log_good": 4.5911
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5846,
+      "good": 0.5932,
+      "ratio": 1.0147,
+      "suggested_scalar": 0.0262,
+      "log_bad": -0.5368,
+      "log_good": -0.5222
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.6299,
+      "good": 10.4369,
+      "ratio": 0.9818,
+      "suggested_scalar": -0.0329,
+      "log_bad": 2.3637,
+      "log_good": 2.3453
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2597.3333,
+      "good": 2326.0,
+      "ratio": 0.8955,
+      "suggested_scalar": -0.1982,
+      "log_bad": 7.8622,
+      "log_good": 7.7519
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0607,
+      "good": 0.0607,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.8018,
+      "log_good": -2.8018
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8217,
+      "good": 0.8217,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1964,
+      "log_good": -0.1964
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.792,
+      "good": 8.7819,
+      "ratio": 0.9989,
+      "suggested_scalar": -0.0021,
+      "log_bad": 2.1738,
+      "log_good": 2.1727
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.4044,
+      "good": 3.4044,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.2251,
+      "log_good": 1.2251
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 139.3333,
+      "good": 170.0,
+      "ratio": 1.2201,
+      "suggested_scalar": 0.3573,
+      "log_bad": 4.9369,
+      "log_good": 5.1358
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9546,
+      "good": 0.9525,
+      "ratio": 0.9978,
+      "suggested_scalar": -0.004,
+      "log_bad": -0.0465,
+      "log_good": -0.0487
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.3333,
+      "good": 28.3333,
+      "ratio": 0.9659,
+      "suggested_scalar": -0.0623,
+      "log_bad": 3.3787,
+      "log_good": 3.344
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6368,
+      "good": 0.6125,
+      "ratio": 0.9618,
+      "suggested_scalar": -0.0699,
+      "log_bad": -0.4513,
+      "log_good": -0.4902
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.374,
+      "good": 0.3719,
+      "ratio": 0.9944,
+      "suggested_scalar": -0.0101,
+      "log_bad": -0.9835,
+      "log_good": -0.9891
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7566,
+      "good": 2.5834,
+      "ratio": 0.9372,
+      "suggested_scalar": -0.1165,
+      "log_bad": 1.014,
+      "log_good": 0.9491
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 584.3333,
+      "good": 583.6667,
+      "ratio": 0.9989,
+      "suggested_scalar": -0.002,
+      "log_bad": 6.3705,
+      "log_good": 6.3693
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.042,
+      "good": 0.0383,
+      "ratio": 0.9119,
+      "suggested_scalar": -0.1656,
+      "log_bad": -3.1701,
+      "log_good": -3.2623
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0555,
+      "good": 6.0983,
+      "ratio": 1.0071,
+      "suggested_scalar": 0.0126,
+      "log_bad": 1.801,
+      "log_good": 1.808
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 15.3333,
+      "good": 15.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.73,
+      "log_good": 2.73
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6608,
+      "good": 0.614,
+      "ratio": 0.9292,
+      "suggested_scalar": -0.1319,
+      "log_bad": -0.4143,
+      "log_good": -0.4878
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7344,
+      "good": 5.6804,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.017,
+      "log_bad": 1.7465,
+      "log_good": 1.737
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7977,
+      "good": 0.7779,
+      "ratio": 0.9752,
+      "suggested_scalar": -0.0451,
+      "log_bad": -0.226,
+      "log_good": -0.2512
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1902,
+      "good": 0.1902,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.6597,
+      "log_good": -1.6597
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.2524,
+      "good": 3.2287,
+      "ratio": 0.9927,
+      "suggested_scalar": -0.0131,
+      "log_bad": 1.1794,
+      "log_good": 1.1721
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.3333,
+      "good": 3.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.204,
+      "log_good": 1.204
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 440.3333,
+      "good": 440.6667,
+      "ratio": 1.0008,
+      "suggested_scalar": 0.0014,
+      "log_bad": 6.0875,
+      "log_good": 6.0883
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 13.6667,
+      "good": 13.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.615,
+      "log_good": 2.615
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.2766,
+      "good": 1.252,
+      "ratio": 0.9807,
+      "suggested_scalar": -0.0349,
+      "log_bad": 0.2442,
+      "log_good": 0.2247
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 120.3333,
+      "good": 115.0,
+      "ratio": 0.9557,
+      "suggested_scalar": -0.0814,
+      "log_bad": 4.7903,
+      "log_good": 4.7449
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1543.3333,
+      "good": 1270.6667,
+      "ratio": 0.8233,
+      "suggested_scalar": -0.3491,
+      "log_bad": 7.3417,
+      "log_good": 7.1473
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 217.6667,
+      "good": 218.0,
+      "ratio": 1.0015,
+      "suggested_scalar": 0.0027,
+      "log_bad": 5.383,
+      "log_good": 5.3845
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0063,
+      "good": 0.0064,
+      "ratio": 1.0159,
+      "suggested_scalar": 0.0283,
+      "log_bad": -5.0672,
+      "log_good": -5.0515
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2896,
+      "good": 0.2859,
+      "ratio": 0.9872,
+      "suggested_scalar": -0.0231,
+      "log_bad": -1.2393,
+      "log_good": -1.2521
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 99.6667,
+      "good": 100.6667,
+      "ratio": 1.01,
+      "suggested_scalar": 0.0179,
+      "log_bad": 4.6018,
+      "log_good": 4.6118
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 9.6667,
+      "good": 9.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.2687,
+      "log_good": 2.2687
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 120.3333,
+      "good": 115.0,
+      "ratio": 0.9557,
+      "suggested_scalar": -0.0814,
+      "log_bad": 4.7903,
+      "log_good": 4.7449
+    },
+    "brevity.mean_sample_size": {
+      "bad": 120.3333,
+      "good": 115.0,
+      "ratio": 0.9557,
+      "suggested_scalar": -0.0814,
+      "log_bad": 4.7903,
+      "log_good": 4.7449
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 586.3333,
+      "good": 585.6667,
+      "ratio": 0.9989,
+      "suggested_scalar": -0.002,
+      "log_bad": 6.3739,
+      "log_good": 6.3728
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 326.3333,
+      "good": 325.0,
+      "ratio": 0.9959,
+      "suggested_scalar": -0.0074,
+      "log_bad": 5.7879,
+      "log_good": 5.7838
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 340.3333,
+      "good": 336.0,
+      "ratio": 0.9873,
+      "suggested_scalar": -0.023,
+      "log_bad": 5.8299,
+      "log_good": 5.8171
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0057,
+      "good": 0.0058,
+      "ratio": 1.0175,
+      "suggested_scalar": 0.0312,
+      "log_bad": -5.1673,
+      "log_good": -5.1499
+    },
+    "heaps.mean_k": {
+      "bad": 3.0993,
+      "good": 3.2211,
+      "ratio": 1.0393,
+      "suggested_scalar": 0.0692,
+      "log_bad": 1.1312,
+      "log_good": 1.1697
+    },
+    "halstead.mean_effort": {
+      "bad": 144982.1358,
+      "good": 148551.8653,
+      "ratio": 1.0246,
+      "suggested_scalar": 0.0437,
+      "log_bad": 11.8844,
+      "log_good": 11.9087
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8298,
+      "good": 0.8299,
+      "ratio": 1.0001,
+      "suggested_scalar": 0.0002,
+      "log_bad": -0.1866,
+      "log_good": -0.1865
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 86.6667,
+      "good": 80.3333,
+      "ratio": 0.9269,
+      "suggested_scalar": -0.1363,
+      "log_bad": 4.4621,
+      "log_good": 4.3862
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 340.6667,
+      "good": 337.3333,
+      "ratio": 0.9902,
+      "suggested_scalar": -0.0177,
+      "log_bad": 5.8309,
+      "log_good": 5.8211
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4013,
+      "good": 0.368,
+      "ratio": 0.917,
+      "suggested_scalar": -0.1556,
+      "log_bad": -0.913,
+      "log_good": -0.9997
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.7639,
+      "good": 6.3597,
+      "ratio": 0.8191,
+      "suggested_scalar": -0.3583,
+      "log_bad": 2.0495,
+      "log_good": 1.85
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1902,
+      "good": 0.1902,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.6597,
+      "log_good": -1.6597
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.7316,
+      "good": 4.1837,
+      "ratio": 0.6215,
+      "suggested_scalar": -0.8542,
+      "log_bad": 1.9068,
+      "log_good": 1.4312
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 585.3333,
+      "good": 584.6667,
+      "ratio": 0.9989,
+      "suggested_scalar": -0.002,
+      "log_bad": 6.3722,
+      "log_good": 6.371
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.6667,
+      "good": 2.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9808,
+      "log_good": 0.9808
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 77.0,
+      "good": 76.6667,
+      "ratio": 0.9957,
+      "suggested_scalar": -0.0078,
+      "log_bad": 4.3438,
+      "log_good": 4.3395
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 8054.5631,
+      "good": 8252.8814,
+      "ratio": 1.0246,
+      "suggested_scalar": 0.0437,
+      "log_bad": 8.994,
+      "log_good": 9.0183
+    },
+    "readability.mean_total_lines": {
+      "bad": 66.6667,
+      "good": 66.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.1997,
+      "log_good": 4.1997
+    },
+    "indentation.mean_max_depth": {
+      "bad": 7.3333,
+      "good": 7.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9924,
+      "log_good": 1.9924
+    },
+    "halstead.mean_volume": {
+      "bad": 3829.7777,
+      "good": 3756.1066,
+      "ratio": 0.9808,
+      "suggested_scalar": -0.0349,
+      "log_bad": 8.2506,
+      "log_good": 8.2311
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 943.0,
+      "good": 900.0,
+      "ratio": 0.9544,
+      "suggested_scalar": -0.0838,
+      "log_bad": 6.8491,
+      "log_good": 6.8024
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 37.0842,
+      "good": 32.9144,
+      "ratio": 0.8876,
+      "suggested_scalar": -0.2142,
+      "log_bad": 3.6132,
+      "log_good": 3.4939
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.542,
+      "good": 1.174,
+      "ratio": 0.7613,
+      "suggested_scalar": -0.4897,
+      "log_bad": 0.4331,
+      "log_good": 0.1604
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.6667,
+      "good": 3.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.2993,
+      "log_good": 1.2993
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 37.6667,
+      "good": 37.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6288,
+      "log_good": 3.6288
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.826,
+      "good": 0.827,
+      "ratio": 1.0012,
+      "suggested_scalar": 0.0022,
+      "log_bad": -0.1912,
+      "log_good": -0.19
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9814,
+      "good": 0.9813,
+      "ratio": 0.9999,
+      "suggested_scalar": -0.0002,
+      "log_bad": -0.0188,
+      "log_good": -0.0189
+    },
+    "halstead.mean_length": {
+      "bad": 558.3333,
+      "good": 555.3333,
+      "ratio": 0.9946,
+      "suggested_scalar": -0.0097,
+      "log_bad": 6.325,
+      "log_good": 6.3196
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 8.1296,
+      "good": 8.1296,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0955,
+      "log_good": 2.0955
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9107,
+      "good": 6.8453,
+      "ratio": 0.9905,
+      "suggested_scalar": -0.0171,
+      "log_bad": 1.9331,
+      "log_good": 1.9236
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.125,
+      "good": 0.1391,
+      "ratio": 1.1128,
+      "suggested_scalar": 0.1919,
+      "log_bad": -2.0794,
+      "log_good": -1.9726
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 37.2932,
+      "good": 38.9747,
+      "ratio": 1.0451,
+      "suggested_scalar": 0.0792,
+      "log_bad": 3.6188,
+      "log_good": 3.6629
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 79.6667,
+      "good": 73.3333,
+      "ratio": 0.9205,
+      "suggested_scalar": -0.1488,
+      "log_bad": 4.3779,
+      "log_good": 4.295
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7065,
+      "good": 0.7003,
+      "ratio": 0.9912,
+      "suggested_scalar": -0.0158,
+      "log_bad": -0.3474,
+      "log_good": -0.3562
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 67.3333,
+      "good": 67.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2097,
+      "log_good": 4.2097
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.3333,
+      "good": 16.3333,
+      "ratio": 0.9423,
+      "suggested_scalar": -0.1067,
+      "log_bad": 2.8526,
+      "log_good": 2.7932
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.context_is_first_parameter": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 4.0,
+      "good": 2.0,
+      "ratio": 0.5,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.3863,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.02,
+      "good": 0.0184,
+      "ratio": 0.92,
+      "suggested_scalar": -0.2406,
+      "log_bad": -3.912,
+      "log_good": -3.9954
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8462,
+      "good": 0.8367,
+      "ratio": 0.9888,
+      "suggested_scalar": -0.0326,
+      "log_bad": -0.167,
+      "log_good": -0.1783
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.02,
+      "good": 0.0184,
+      "ratio": 0.92,
+      "suggested_scalar": -0.2406,
+      "log_bad": -3.912,
+      "log_good": -3.9954
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 5.0194,
+      "good": 5.0313,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.0068,
+      "log_bad": 1.6133,
+      "log_good": 1.6157
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 104.0,
+      "good": 97.0,
+      "ratio": 0.9327,
+      "suggested_scalar": -0.2011,
+      "log_bad": 4.6444,
+      "log_good": 4.5747
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5285,
+      "good": 0.5227,
+      "ratio": 0.989,
+      "suggested_scalar": -0.0318,
+      "log_bad": -0.6377,
+      "log_good": -0.6487
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6763,
+      "good": 0.6616,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.0634,
+      "log_bad": -0.3911,
+      "log_good": -0.4131
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.9231,
+      "good": 0.8367,
+      "ratio": 0.9064,
+      "suggested_scalar": -0.2836,
+      "log_bad": -0.08,
+      "log_good": -0.1783
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 451.0,
+      "good": 434.0,
+      "ratio": 0.9623,
+      "suggested_scalar": -0.1109,
+      "log_bad": 6.1115,
+      "log_good": 6.073
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0026,
+      "good": 0.0028,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.2138,
+      "log_bad": -5.9522,
+      "log_good": -5.8781
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1346,
+      "good": 0.1224,
+      "ratio": 0.9094,
+      "suggested_scalar": -0.2741,
+      "log_bad": -2.0054,
+      "log_good": -2.1005
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9619,
+      "good": 0.967,
+      "ratio": 1.0053,
+      "suggested_scalar": 0.0153,
+      "log_bad": -0.0388,
+      "log_good": -0.0336
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 180.0,
+      "good": 174.0,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0978,
+      "log_bad": 5.193,
+      "log_good": 5.1591
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 110.564,
+      "good": 111.741,
+      "ratio": 1.0106,
+      "suggested_scalar": 0.0306,
+      "log_bad": 4.7056,
+      "log_good": 4.7162
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.58,
+      "good": 0.5982,
+      "ratio": 1.0314,
+      "suggested_scalar": 0.0892,
+      "log_bad": -0.5447,
+      "log_good": -0.5138
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 6.7711,
+      "good": 6.0525,
+      "ratio": 0.8939,
+      "suggested_scalar": -0.3237,
+      "log_bad": 1.9127,
+      "log_good": 1.8005
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1549.0,
+      "good": 1431.0,
+      "ratio": 0.9238,
+      "suggested_scalar": -0.2286,
+      "log_bad": 7.3454,
+      "log_good": 7.2661
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1346,
+      "good": 0.1224,
+      "ratio": 0.9094,
+      "suggested_scalar": -0.2741,
+      "log_bad": -2.0054,
+      "log_good": -2.1005
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7885,
+      "good": 0.7755,
+      "ratio": 0.9835,
+      "suggested_scalar": -0.048,
+      "log_bad": -0.2376,
+      "log_good": -0.2542
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.6731,
+      "good": 8.8571,
+      "ratio": 1.0212,
+      "suggested_scalar": 0.0606,
+      "log_bad": 2.1602,
+      "log_good": 2.1812
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.9172,
+      "good": 0.6672,
+      "ratio": 0.7274,
+      "suggested_scalar": -0.9182,
+      "log_bad": -0.0864,
+      "log_good": -0.4047
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 132.0,
+      "good": 126.0,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.1342,
+      "log_bad": 4.8828,
+      "log_good": 4.8363
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9368,
+      "good": 0.9323,
+      "ratio": 0.9952,
+      "suggested_scalar": -0.0139,
+      "log_bad": -0.0653,
+      "log_good": -0.0701
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 26.0,
+      "ratio": 0.8966,
+      "suggested_scalar": -0.3151,
+      "log_bad": 3.3673,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5565,
+      "good": 0.559,
+      "ratio": 1.0045,
+      "suggested_scalar": 0.0129,
+      "log_bad": -0.5861,
+      "log_good": -0.5816
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3318,
+      "good": 0.3889,
+      "ratio": 1.1721,
+      "suggested_scalar": 0.4582,
+      "log_bad": -1.1032,
+      "log_good": -0.9444
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2547,
+      "good": 2.2678,
+      "ratio": 1.0058,
+      "suggested_scalar": 0.0167,
+      "log_bad": 0.813,
+      "log_good": 0.8188
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 449.0,
+      "good": 432.0,
+      "ratio": 0.9621,
+      "suggested_scalar": -0.1114,
+      "log_bad": 6.107,
+      "log_good": 6.0684
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0288,
+      "good": 0.0276,
+      "ratio": 0.9583,
+      "suggested_scalar": -0.1228,
+      "log_bad": -3.5474,
+      "log_good": -3.5899
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.9773,
+      "ratio": 1.0039,
+      "suggested_scalar": 0.0112,
+      "log_bad": 1.7841,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 43.0,
+      "good": 45.0,
+      "ratio": 1.0465,
+      "suggested_scalar": 0.1312,
+      "log_bad": 3.7612,
+      "log_good": 3.8067
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9852,
+      "good": 0.9586,
+      "ratio": 0.973,
+      "suggested_scalar": -0.079,
+      "log_bad": -0.0149,
+      "log_good": -0.0423
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.0366,
+      "good": 5.9645,
+      "ratio": 0.9881,
+      "suggested_scalar": -0.0347,
+      "log_bad": 1.7978,
+      "log_good": 1.7858
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.843,
+      "good": 0.8417,
+      "ratio": 0.9985,
+      "suggested_scalar": -0.0045,
+      "log_bad": -0.1708,
+      "log_good": -0.1723
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1333,
+      "good": 0.1404,
+      "ratio": 1.0533,
+      "suggested_scalar": 0.1497,
+      "log_bad": -2.0152,
+      "log_good": -1.9633
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.6021,
+      "good": 2.4602,
+      "ratio": 0.9455,
+      "suggested_scalar": -0.1618,
+      "log_bad": 0.9563,
+      "log_good": 0.9002
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 359.0,
+      "good": 331.0,
+      "ratio": 0.922,
+      "suggested_scalar": -0.2343,
+      "log_bad": 5.8833,
+      "log_good": 5.8021
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8711,
+      "good": 0.8272,
+      "ratio": 0.9496,
+      "suggested_scalar": -0.1492,
+      "log_bad": -0.138,
+      "log_good": -0.1897
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 106.0,
+      "ratio": 0.9381,
+      "suggested_scalar": -0.1845,
+      "log_bad": 4.7274,
+      "log_good": 4.6634
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 804.0,
+      "good": 733.0,
+      "ratio": 0.9117,
+      "suggested_scalar": -0.2668,
+      "log_bad": 6.6896,
+      "log_good": 6.5971
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 178.0,
+      "good": 171.0,
+      "ratio": 0.9607,
+      "suggested_scalar": -0.1158,
+      "log_bad": 5.1818,
+      "log_good": 5.1417
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2483,
+      "good": 0.2581,
+      "ratio": 1.0395,
+      "suggested_scalar": 0.1117,
+      "log_bad": -1.3931,
+      "log_good": -1.3544
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 90.0,
+      "good": 90.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.4998,
+      "log_good": 4.4998
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 106.0,
+      "ratio": 0.9381,
+      "suggested_scalar": -0.1845,
+      "log_bad": 4.7274,
+      "log_good": 4.6634
+    },
+    "brevity.mean_sample_size": {
+      "bad": 113.0,
+      "good": 106.0,
+      "ratio": 0.9381,
+      "suggested_scalar": -0.1845,
+      "log_bad": 4.7274,
+      "log_good": 4.6634
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 451.0,
+      "good": 434.0,
+      "ratio": 0.9623,
+      "suggested_scalar": -0.1109,
+      "log_bad": 6.1115,
+      "log_good": 6.073
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 215.0,
+      "good": 209.0,
+      "ratio": 0.9721,
+      "suggested_scalar": -0.0817,
+      "log_bad": 5.3706,
+      "log_good": 5.3423
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 279.0,
+      "good": 264.0,
+      "ratio": 0.9462,
+      "suggested_scalar": -0.1595,
+      "log_bad": 5.6312,
+      "log_good": 5.5759
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.9955,
+      "good": 2.1105,
+      "ratio": 1.0576,
+      "suggested_scalar": 0.1617,
+      "log_bad": 0.6909,
+      "log_good": 0.7469
+    },
+    "halstead.mean_effort": {
+      "bad": 89927.9415,
+      "good": 77697.5204,
+      "ratio": 0.864,
+      "suggested_scalar": -0.4218,
+      "log_bad": 11.4068,
+      "log_good": 11.2606
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8851,
+      "good": 0.8865,
+      "ratio": 1.0016,
+      "suggested_scalar": 0.0046,
+      "log_bad": -0.1221,
+      "log_good": -0.1205
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 75.0,
+      "good": 71.0,
+      "ratio": 0.9467,
+      "suggested_scalar": -0.1581,
+      "log_bad": 4.3175,
+      "log_good": 4.2627
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 212.0,
+      "good": 205.0,
+      "ratio": 0.967,
+      "suggested_scalar": -0.0969,
+      "log_bad": 5.3566,
+      "log_good": 5.323
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4111,
+      "good": 0.408,
+      "ratio": 0.9925,
+      "suggested_scalar": -0.0218,
+      "log_bad": -0.8889,
+      "log_good": -0.8965
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.4667,
+      "good": 4.2126,
+      "ratio": 0.9431,
+      "suggested_scalar": -0.169,
+      "log_bad": 1.4966,
+      "log_good": 1.4381
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1333,
+      "good": 0.1404,
+      "ratio": 1.0533,
+      "suggested_scalar": 0.1497,
+      "log_bad": -2.0152,
+      "log_good": -1.9633
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.8082,
+      "good": 3.5429,
+      "ratio": 0.9303,
+      "suggested_scalar": -0.2084,
+      "log_bad": 1.3372,
+      "log_good": 1.2649
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 450.0,
+      "good": 433.0,
+      "ratio": 0.9622,
+      "suggested_scalar": -0.1111,
+      "log_bad": 6.1092,
+      "log_good": 6.0707
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 59.0,
+      "good": 67.0,
+      "ratio": 1.1356,
+      "suggested_scalar": 0.3669,
+      "log_bad": 4.0775,
+      "log_good": 4.2047
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4995.9968,
+      "good": 4316.5289,
+      "ratio": 0.864,
+      "suggested_scalar": -0.4218,
+      "log_bad": 8.5164,
+      "log_good": 8.3702
+    },
+    "readability.mean_total_lines": {
+      "bad": 52.0,
+      "good": 49.0,
+      "ratio": 0.9423,
+      "suggested_scalar": -0.1715,
+      "log_bad": 3.9512,
+      "log_good": 3.8918
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.8301,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "halstead.mean_volume": {
+      "bad": 2613.1715,
+      "good": 2481.5672,
+      "ratio": 0.9496,
+      "suggested_scalar": -0.1491,
+      "log_bad": 7.8683,
+      "log_good": 7.8166
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 687.0,
+      "good": 631.0,
+      "ratio": 0.9185,
+      "suggested_scalar": -0.2453,
+      "log_bad": 6.5323,
+      "log_good": 6.4473
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 28.5577,
+      "good": 28.0,
+      "ratio": 0.9805,
+      "suggested_scalar": -0.0569,
+      "log_bad": 3.3519,
+      "log_good": 3.3322
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0339,
+      "good": 1.0178,
+      "ratio": 0.9844,
+      "suggested_scalar": -0.0453,
+      "log_bad": 0.0333,
+      "log_good": 0.0176
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 32.0,
+      "good": 32.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4657,
+      "log_good": 3.4657
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 6.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.4448,
+      "log_bad": 1.9459,
+      "log_good": 1.7918
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8357,
+      "good": 0.7976,
+      "ratio": 0.9544,
+      "suggested_scalar": -0.1346,
+      "log_bad": -0.1795,
+      "log_good": -0.2261
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9835,
+      "good": 0.982,
+      "ratio": 0.9985,
+      "suggested_scalar": -0.0044,
+      "log_bad": -0.0166,
+      "log_good": -0.0182
+    },
+    "halstead.mean_length": {
+      "bad": 390.0,
+      "good": 376.0,
+      "ratio": 0.9641,
+      "suggested_scalar": -0.1055,
+      "log_bad": 5.9661,
+      "log_good": 5.9296
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 12.0,
+      "good": 11.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.2511,
+      "log_bad": 2.4849,
+      "log_good": 2.3979
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8202,
+      "good": 6.7279,
+      "ratio": 0.9865,
+      "suggested_scalar": -0.0393,
+      "log_bad": 1.9199,
+      "log_good": 1.9063
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1392,
+      "good": 0.1463,
+      "ratio": 1.051,
+      "suggested_scalar": 0.1435,
+      "log_bad": -1.9718,
+      "log_good": -1.9221
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 34.4133,
+      "good": 31.3099,
+      "ratio": 0.9098,
+      "suggested_scalar": -0.2727,
+      "log_bad": 3.5384,
+      "log_good": 3.4439
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 6.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.4448,
+      "log_bad": 1.9459,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 74.0,
+      "good": 71.0,
+      "ratio": 0.9595,
+      "suggested_scalar": -0.1194,
+      "log_bad": 4.3041,
+      "log_good": 4.2627
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6774,
+      "good": 0.6591,
+      "ratio": 0.973,
+      "suggested_scalar": -0.079,
+      "log_bad": -0.3895,
+      "log_good": -0.4169
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 52.0,
+      "good": 49.0,
+      "ratio": 0.9423,
+      "suggested_scalar": -0.1715,
+      "log_bad": 3.9512,
+      "log_good": 3.8918
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 12.0,
+      "good": 10.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.5261,
+      "log_bad": 2.4849,
+      "log_good": 2.3026
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "dependencies.no_mutable_exports": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 22.0,
+      "good": 23.0,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.0155,
+      "log_bad": 3.091,
+      "log_good": 3.1355
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 13.0,
+      "good": 18.0,
+      "ratio": 1.3846,
+      "suggested_scalar": 0.1133,
+      "log_bad": 2.5649,
+      "log_good": 2.8904
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0032,
+      "good": 0.0028,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0465,
+      "log_bad": -5.7446,
+      "log_good": -5.8781
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 0.1667,
+      "ratio": 0.1667,
+      "suggested_scalar": -0.6237,
+      "log_bad": 0.0,
+      "log_good": -1.7916
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8421,
+      "good": 0.8043,
+      "ratio": 0.9551,
+      "suggested_scalar": -0.016,
+      "log_bad": -0.1719,
+      "log_good": -0.2178
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0032,
+      "good": 0.0028,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0465,
+      "log_bad": -5.7446,
+      "log_good": -5.8781
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.9578,
+      "good": 4.9015,
+      "ratio": 0.9886,
+      "suggested_scalar": -0.004,
+      "log_bad": 1.601,
+      "log_good": 1.5895
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 85.0,
+      "good": 77.0,
+      "ratio": 0.9059,
+      "suggested_scalar": -0.0344,
+      "log_bad": 4.4427,
+      "log_good": 4.3438
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.519,
+      "good": 0.3673,
+      "ratio": 0.7077,
+      "suggested_scalar": -0.1204,
+      "log_bad": -0.6559,
+      "log_good": -1.0016
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 23.0,
+      "good": 22.0,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.0155,
+      "log_bad": 3.1355,
+      "log_good": 3.091
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6947,
+      "good": 0.6539,
+      "ratio": 0.9413,
+      "suggested_scalar": -0.0211,
+      "log_bad": -0.3643,
+      "log_good": -0.4248
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.4211,
+      "good": 1.1304,
+      "ratio": 0.7954,
+      "suggested_scalar": -0.0797,
+      "log_bad": 0.3514,
+      "log_good": 0.1226
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 309.0,
+      "good": 358.0,
+      "ratio": 1.1586,
+      "suggested_scalar": 0.0512,
+      "log_bad": 5.7333,
+      "log_good": 5.8805
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 3.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.1778,
+      "log_bad": 1.6094,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0008,
+      "good": 0.0007,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0465,
+      "log_bad": -7.1309,
+      "log_good": -7.2644
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0263,
+      "good": 1.0,
+      "ratio": 38.0228,
+      "suggested_scalar": 1.2666,
+      "log_bad": -3.6382,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0016,
+      "good": 0.0014,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0465,
+      "log_bad": -6.4378,
+      "log_good": -6.5713
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9197,
+      "good": 1.0124,
+      "ratio": 1.1008,
+      "suggested_scalar": 0.0334,
+      "log_bad": -0.0837,
+      "log_good": 0.0123
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 79.0,
+      "good": 98.0,
+      "ratio": 1.2405,
+      "suggested_scalar": 0.075,
+      "log_bad": 4.3694,
+      "log_good": 4.585
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 90.0728,
+      "good": 91.2629,
+      "ratio": 1.0132,
+      "suggested_scalar": 0.0046,
+      "log_bad": 4.5006,
+      "log_good": 4.5137
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5,
+      "good": 0.5434,
+      "ratio": 1.0868,
+      "suggested_scalar": 0.029,
+      "log_bad": -0.6931,
+      "log_good": -0.6099
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 19.3129,
+      "good": 11.7164,
+      "ratio": 0.6067,
+      "suggested_scalar": -0.174,
+      "log_bad": 2.9608,
+      "log_good": 2.461
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1290.0,
+      "good": 1440.0,
+      "ratio": 1.1163,
+      "suggested_scalar": 0.0383,
+      "log_bad": 7.1624,
+      "log_good": 7.2724
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1316,
+      "good": 0.1087,
+      "ratio": 0.826,
+      "suggested_scalar": -0.0666,
+      "log_bad": -2.028,
+      "log_good": -2.2192
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8158,
+      "good": 0.7826,
+      "ratio": 0.9593,
+      "suggested_scalar": -0.0145,
+      "log_bad": -0.2036,
+      "log_good": -0.2451
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.1316,
+      "good": 7.7826,
+      "ratio": 0.9571,
+      "suggested_scalar": -0.0153,
+      "log_bad": 2.0958,
+      "log_good": 2.0519
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.0859,
+      "good": 1.1569,
+      "ratio": 0.5546,
+      "suggested_scalar": -0.2052,
+      "log_bad": 0.7352,
+      "log_good": 0.1457
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 37.0,
+      "good": 54.0,
+      "ratio": 1.4595,
+      "suggested_scalar": 0.1316,
+      "log_bad": 3.6109,
+      "log_good": 3.989
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9399,
+      "good": 0.9467,
+      "ratio": 1.0072,
+      "suggested_scalar": 0.0025,
+      "log_bad": -0.062,
+      "log_good": -0.0548
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 29.0,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0118,
+      "log_bad": 3.4012,
+      "log_good": 3.3673
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.562,
+      "good": 0.6208,
+      "ratio": 1.1046,
+      "suggested_scalar": 0.0346,
+      "log_bad": -0.5763,
+      "log_good": -0.4767
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3094,
+      "good": 0.3624,
+      "ratio": 1.1713,
+      "suggested_scalar": 0.055,
+      "log_bad": -1.1731,
+      "log_good": -1.015
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2832,
+      "good": 2.6374,
+      "ratio": 1.1551,
+      "suggested_scalar": 0.0502,
+      "log_bad": 0.8256,
+      "log_good": 0.9698
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 307.0,
+      "good": 356.0,
+      "ratio": 1.1596,
+      "suggested_scalar": 0.0516,
+      "log_bad": 5.7268,
+      "log_good": 5.8749
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 32.0,
+      "good": 12.0,
+      "ratio": 0.375,
+      "suggested_scalar": -0.3415,
+      "log_bad": 3.4657,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0291,
+      "good": 0.0335,
+      "ratio": 1.1512,
+      "suggested_scalar": 0.049,
+      "log_bad": -3.537,
+      "log_good": -3.3962
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0661,
+      "good": 6.0,
+      "ratio": 0.9891,
+      "suggested_scalar": -0.0038,
+      "log_bad": 1.8027,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 18.0,
+      "good": 19.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.0188,
+      "log_bad": 2.8904,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.6466,
+      "good": 1.538,
+      "ratio": 0.934,
+      "suggested_scalar": -0.0238,
+      "log_bad": 0.4987,
+      "log_good": 0.4305
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0253,
+      "good": 0.0204,
+      "ratio": 0.8063,
+      "suggested_scalar": -0.0749,
+      "log_bad": -3.677,
+      "log_good": -3.8922
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.69,
+      "good": 5.4738,
+      "ratio": 0.962,
+      "suggested_scalar": -0.0135,
+      "log_bad": 1.7387,
+      "log_good": 1.7
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8173,
+      "good": 0.8169,
+      "ratio": 0.9995,
+      "suggested_scalar": -0.0002,
+      "log_bad": -0.2017,
+      "log_good": -0.2022
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1739,
+      "good": 0.193,
+      "ratio": 1.1098,
+      "suggested_scalar": 0.0363,
+      "log_bad": -1.7493,
+      "log_good": -1.6451
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.3946,
+      "good": 3.4229,
+      "ratio": 0.7789,
+      "suggested_scalar": -0.087,
+      "log_bad": 1.4804,
+      "log_good": 1.2305
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 251.0,
+      "good": 275.0,
+      "ratio": 1.0956,
+      "suggested_scalar": 0.0318,
+      "log_bad": 5.5255,
+      "log_good": 5.6168
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 17.0,
+      "good": 22.0,
+      "ratio": 1.2941,
+      "suggested_scalar": 0.0898,
+      "log_bad": 2.8332,
+      "log_good": 3.091
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6388,
+      "good": 0.7269,
+      "ratio": 1.1379,
+      "suggested_scalar": 0.045,
+      "log_bad": -0.4482,
+      "log_good": -0.319
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 89.0,
+      "good": 80.0,
+      "ratio": 0.8989,
+      "suggested_scalar": -0.0371,
+      "log_bad": 4.4886,
+      "log_good": 4.382
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 594.0,
+      "good": 720.0,
+      "ratio": 1.2121,
+      "suggested_scalar": 0.067,
+      "log_bad": 6.3869,
+      "log_good": 6.5793
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 107.0,
+      "good": 127.0,
+      "ratio": 1.1869,
+      "suggested_scalar": 0.0597,
+      "log_bad": 4.6728,
+      "log_good": 4.8442
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0032,
+      "good": 1.0,
+      "ratio": 312.5,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.7446,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2265,
+      "good": 0.2626,
+      "ratio": 1.1594,
+      "suggested_scalar": 0.0515,
+      "log_bad": -1.485,
+      "log_good": -1.3371
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 51.0,
+      "good": 55.0,
+      "ratio": 1.0784,
+      "suggested_scalar": 0.0263,
+      "log_bad": 3.9318,
+      "log_good": 4.0073
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 6.0,
+      "ratio": 6.0,
+      "suggested_scalar": 0.6238,
+      "log_bad": 0.0,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 89.0,
+      "good": 80.0,
+      "ratio": 0.8989,
+      "suggested_scalar": -0.0371,
+      "log_bad": 4.4886,
+      "log_good": 4.382
+    },
+    "brevity.mean_sample_size": {
+      "bad": 89.0,
+      "good": 80.0,
+      "ratio": 0.8989,
+      "suggested_scalar": -0.0371,
+      "log_bad": 4.4886,
+      "log_good": 4.382
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 309.0,
+      "good": 358.0,
+      "ratio": 1.1586,
+      "suggested_scalar": 0.0512,
+      "log_bad": 5.7333,
+      "log_good": 5.8805
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 168.0,
+      "good": 201.0,
+      "ratio": 1.1964,
+      "suggested_scalar": 0.0624,
+      "log_bad": 5.124,
+      "log_good": 5.3033
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 205.0,
+      "good": 218.0,
+      "ratio": 1.0634,
+      "suggested_scalar": 0.0214,
+      "log_bad": 5.323,
+      "log_good": 5.3845
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0097,
+      "good": 0.0084,
+      "ratio": 0.866,
+      "suggested_scalar": -0.0501,
+      "log_bad": -4.6356,
+      "log_good": -4.7795
+    },
+    "heaps.mean_k": {
+      "bad": 1.9991,
+      "good": 2.0047,
+      "ratio": 1.0028,
+      "suggested_scalar": 0.001,
+      "log_bad": 0.6927,
+      "log_good": 0.6955
+    },
+    "halstead.mean_effort": {
+      "bad": 55924.2666,
+      "good": 83667.0838,
+      "ratio": 1.4961,
+      "suggested_scalar": 0.1403,
+      "log_bad": 10.9318,
+      "log_good": 11.3346
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8787,
+      "good": 0.8658,
+      "ratio": 0.9853,
+      "suggested_scalar": -0.0051,
+      "log_bad": -0.1293,
+      "log_good": -0.1441
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 55.0,
+      "good": 48.0,
+      "ratio": 0.8727,
+      "suggested_scalar": -0.0474,
+      "log_bad": 4.0073,
+      "log_good": 3.8712
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 192.0,
+      "good": 221.0,
+      "ratio": 1.151,
+      "suggested_scalar": 0.049,
+      "log_bad": 5.2575,
+      "log_good": 5.3982
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.519,
+      "good": 0.3673,
+      "ratio": 0.7077,
+      "suggested_scalar": -0.1204,
+      "log_bad": -0.6559,
+      "log_good": -1.0016
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.519,
+      "good": 7.3469,
+      "ratio": 0.9771,
+      "suggested_scalar": -0.0081,
+      "log_bad": 2.0174,
+      "log_good": 1.9943
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1739,
+      "good": 0.193,
+      "ratio": 1.1098,
+      "suggested_scalar": 0.0363,
+      "log_bad": -1.7493,
+      "log_good": -1.6451
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.1512,
+      "good": 7.0091,
+      "ratio": 1.1395,
+      "suggested_scalar": 0.0455,
+      "log_bad": 1.8166,
+      "log_good": 1.9472
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 308.0,
+      "good": 357.0,
+      "ratio": 1.1591,
+      "suggested_scalar": 0.0514,
+      "log_bad": 5.7301,
+      "log_good": 5.8777
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 39.0,
+      "good": 48.0,
+      "ratio": 1.2308,
+      "suggested_scalar": 0.0723,
+      "log_bad": 3.6636,
+      "log_good": 3.8712
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3106.9037,
+      "good": 4648.1713,
+      "ratio": 1.4961,
+      "suggested_scalar": 0.1403,
+      "log_bad": 8.0414,
+      "log_good": 8.4442
+    },
+    "readability.mean_total_lines": {
+      "bad": 38.0,
+      "good": 46.0,
+      "ratio": 1.2105,
+      "suggested_scalar": 0.0665,
+      "log_bad": 3.6376,
+      "log_good": 3.8286
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1916.4079,
+      "good": 2180.8417,
+      "ratio": 1.138,
+      "suggested_scalar": 0.045,
+      "log_bad": 7.5582,
+      "log_good": 7.6875
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 565.0,
+      "good": 546.0,
+      "ratio": 0.9664,
+      "suggested_scalar": -0.0119,
+      "log_bad": 6.3368,
+      "log_good": 6.3026
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.6842,
+      "good": 30.0652,
+      "ratio": 0.9199,
+      "suggested_scalar": -0.0291,
+      "log_bad": 3.4869,
+      "log_good": 3.4034
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2826,
+      "good": 1.2727,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.0027,
+      "log_bad": 0.2489,
+      "log_good": 0.2411
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 3.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.1778,
+      "log_bad": 1.6094,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 10.0,
+      "good": 24.0,
+      "ratio": 2.4,
+      "suggested_scalar": 0.3048,
+      "log_bad": 2.3026,
+      "log_good": 3.1781
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8446,
+      "good": 0.8255,
+      "ratio": 0.9774,
+      "suggested_scalar": -0.008,
+      "log_bad": -0.1689,
+      "log_good": -0.1918
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.966,
+      "good": 0.9739,
+      "ratio": 1.0082,
+      "suggested_scalar": 0.0028,
+      "log_bad": -0.0346,
+      "log_good": -0.0264
+    },
+    "halstead.mean_length": {
+      "bad": 299.0,
+      "good": 348.0,
+      "ratio": 1.1639,
+      "suggested_scalar": 0.0528,
+      "log_bad": 5.7004,
+      "log_good": 5.8522
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 32.0,
+      "good": 6.3333,
+      "ratio": 0.1979,
+      "suggested_scalar": -0.564,
+      "log_bad": 3.4657,
+      "log_good": 1.8458
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4757,
+      "good": 6.3219,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0084,
+      "log_bad": 1.8681,
+      "log_good": 1.844
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1304,
+      "good": 0.1396,
+      "ratio": 1.0706,
+      "suggested_scalar": 0.0237,
+      "log_bad": -2.0371,
+      "log_good": -1.969
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.1818,
+      "good": 38.3646,
+      "ratio": 1.3147,
+      "suggested_scalar": 0.0953,
+      "log_bad": 3.3735,
+      "log_good": 3.6471
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 41.0,
+      "good": 36.0,
+      "ratio": 0.878,
+      "suggested_scalar": -0.0453,
+      "log_bad": 3.7136,
+      "log_good": 3.5835
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7512,
+      "good": 0.7477,
+      "ratio": 0.9953,
+      "suggested_scalar": -0.0016,
+      "log_bad": -0.2861,
+      "log_good": -0.2908
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 38.0,
+      "good": 46.0,
+      "ratio": 1.2105,
+      "suggested_scalar": 0.0665,
+      "log_bad": 3.6376,
+      "log_good": 3.8286
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 15.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0635,
+      "log_bad": 2.8904,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    }
+  },
+  "error_handling.catches_specific_exception": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 42.0,
+      "good": 46.0,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.1656,
+      "log_bad": 3.7377,
+      "log_good": 3.8286
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0556,
+      "good": 0.0591,
+      "ratio": 1.0629,
+      "suggested_scalar": 0.1111,
+      "log_bad": -2.8896,
+      "log_good": -2.8285
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9455,
+      "good": 0.9643,
+      "ratio": 1.0199,
+      "suggested_scalar": 0.0358,
+      "log_bad": -0.056,
+      "log_good": -0.0364
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0556,
+      "good": 0.0591,
+      "ratio": 1.0629,
+      "suggested_scalar": 0.1111,
+      "log_bad": -2.8896,
+      "log_good": -2.8285
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5058,
+      "good": 4.5799,
+      "ratio": 1.0164,
+      "suggested_scalar": 0.0297,
+      "log_bad": 1.5054,
+      "log_good": 1.5217
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 106.0,
+      "good": 94.0,
+      "ratio": 0.8868,
+      "suggested_scalar": -0.2187,
+      "log_bad": 4.6634,
+      "log_good": 4.5433
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.704,
+      "good": 0.5717,
+      "ratio": 0.8121,
+      "suggested_scalar": -0.379,
+      "log_bad": -0.351,
+      "log_good": -0.5591
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 15.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.2279,
+      "log_bad": 2.8332,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.739,
+      "good": 0.6778,
+      "ratio": 0.9172,
+      "suggested_scalar": -0.1574,
+      "log_bad": -0.3025,
+      "log_good": -0.3889
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.6727,
+      "good": 5.0714,
+      "ratio": 0.894,
+      "suggested_scalar": -0.204,
+      "log_bad": 1.7357,
+      "log_good": 1.6236
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 432.0,
+      "good": 474.0,
+      "ratio": 1.0972,
+      "suggested_scalar": 0.1689,
+      "log_bad": 6.0684,
+      "log_good": 6.1612
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8592,
+      "good": 0.9432,
+      "ratio": 1.0978,
+      "suggested_scalar": 0.1698,
+      "log_bad": -0.1518,
+      "log_good": -0.0585
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 167.0,
+      "good": 182.0,
+      "ratio": 1.0898,
+      "suggested_scalar": 0.1566,
+      "log_bad": 5.118,
+      "log_good": 5.204
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 105.1167,
+      "good": 102.0454,
+      "ratio": 0.9708,
+      "suggested_scalar": -0.054,
+      "log_bad": 4.6551,
+      "log_good": 4.6254
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4292,
+      "good": 0.4884,
+      "ratio": 1.1379,
+      "suggested_scalar": 0.2352,
+      "log_bad": -0.8458,
+      "log_good": -0.7166
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.5231,
+      "good": 12.09,
+      "ratio": 1.1489,
+      "suggested_scalar": 0.2527,
+      "log_bad": 2.3536,
+      "log_good": 2.4924
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2066.0,
+      "good": 2068.0,
+      "ratio": 1.001,
+      "suggested_scalar": 0.0018,
+      "log_bad": 7.6334,
+      "log_good": 7.6343
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2727,
+      "good": 0.2679,
+      "ratio": 0.9824,
+      "suggested_scalar": -0.0323,
+      "log_bad": -1.2994,
+      "log_good": -1.3171
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9455,
+      "good": 0.9464,
+      "ratio": 1.001,
+      "suggested_scalar": 0.0017,
+      "log_bad": -0.056,
+      "log_good": -0.0551
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.8545,
+      "good": 8.4643,
+      "ratio": 1.0776,
+      "suggested_scalar": 0.1361,
+      "log_bad": 2.0611,
+      "log_good": 2.1359
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 19.0202,
+      "good": 13.9949,
+      "ratio": 0.7358,
+      "suggested_scalar": -0.5585,
+      "log_bad": 2.9455,
+      "log_good": 2.6387
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 141.0,
+      "good": 144.0,
+      "ratio": 1.0213,
+      "suggested_scalar": 0.0383,
+      "log_bad": 4.9488,
+      "log_good": 4.9698
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9578,
+      "good": 0.9628,
+      "ratio": 1.0052,
+      "suggested_scalar": 0.0095,
+      "log_bad": -0.0431,
+      "log_good": -0.0379
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 28.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3322,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5924,
+      "good": 0.6074,
+      "ratio": 1.0253,
+      "suggested_scalar": 0.0455,
+      "log_bad": -0.5236,
+      "log_good": -0.4986
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2395,
+      "good": 0.2924,
+      "ratio": 1.2209,
+      "suggested_scalar": 0.3633,
+      "log_bad": -1.4292,
+      "log_good": -1.2296
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4537,
+      "good": 2.5468,
+      "ratio": 1.0379,
+      "suggested_scalar": 0.0678,
+      "log_bad": 0.8976,
+      "log_good": 0.9348
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 430.0,
+      "good": 472.0,
+      "ratio": 1.0977,
+      "suggested_scalar": 0.1697,
+      "log_bad": 6.0638,
+      "log_good": 6.157
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 17.0,
+      "good": 15.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.2279,
+      "log_bad": 2.8332,
+      "log_good": 2.7081
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0625,
+      "good": 0.0612,
+      "ratio": 0.9792,
+      "suggested_scalar": -0.0383,
+      "log_bad": -2.7726,
+      "log_good": -2.7936
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 5.9069,
+      "ratio": 0.996,
+      "suggested_scalar": -0.0073,
+      "log_bad": 1.7801,
+      "log_good": 1.7761
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 25.0,
+      "good": 37.0,
+      "ratio": 1.48,
+      "suggested_scalar": 0.7137,
+      "log_bad": 3.2189,
+      "log_good": 3.6109
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6605,
+      "good": 0.7758,
+      "ratio": 1.1746,
+      "suggested_scalar": 0.2929,
+      "log_bad": -0.4148,
+      "log_good": -0.2539
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.1155,
+      "good": 5.9778,
+      "ratio": 0.9775,
+      "suggested_scalar": -0.0415,
+      "log_bad": 1.8108,
+      "log_good": 1.7881
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7597,
+      "good": 0.7753,
+      "ratio": 1.0205,
+      "suggested_scalar": 0.037,
+      "log_bad": -0.2748,
+      "log_good": -0.2545
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1667,
+      "good": 0.1884,
+      "ratio": 1.1302,
+      "suggested_scalar": 0.2228,
+      "log_bad": -1.7916,
+      "log_good": -1.6692
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.2439,
+      "good": 3.4771,
+      "ratio": 1.0719,
+      "suggested_scalar": 0.1264,
+      "log_bad": 1.1768,
+      "log_good": 1.2462
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 1.2619,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 368.0,
+      "good": 381.0,
+      "ratio": 1.0353,
+      "suggested_scalar": 0.0632,
+      "log_bad": 5.9081,
+      "log_good": 5.9428
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 5.0,
+      "good": 11.0,
+      "ratio": 2.2,
+      "suggested_scalar": 1.4354,
+      "log_bad": 1.6094,
+      "log_good": 2.3979
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7513,
+      "good": 0.7887,
+      "ratio": 1.0498,
+      "suggested_scalar": 0.0884,
+      "log_bad": -0.286,
+      "log_good": -0.2374
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 138.0,
+      "good": 129.0,
+      "ratio": 0.9348,
+      "suggested_scalar": -0.1228,
+      "log_bad": 4.9273,
+      "log_good": 4.8598
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1040.0,
+      "good": 1046.0,
+      "ratio": 1.0058,
+      "suggested_scalar": 0.0105,
+      "log_bad": 6.947,
+      "log_good": 6.9527
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 154.0,
+      "good": 149.0,
+      "ratio": 0.9675,
+      "suggested_scalar": -0.0601,
+      "log_bad": 5.037,
+      "log_good": 5.0039
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0093,
+      "good": 0.0084,
+      "ratio": 0.9032,
+      "suggested_scalar": -0.1853,
+      "log_bad": -4.6777,
+      "log_good": -4.7795
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2407,
+      "good": 0.2532,
+      "ratio": 1.0519,
+      "suggested_scalar": 0.0922,
+      "log_bad": -1.4242,
+      "log_good": -1.3736
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 65.0,
+      "good": 71.0,
+      "ratio": 1.0923,
+      "suggested_scalar": 0.1607,
+      "log_bad": 4.1744,
+      "log_good": 4.2627
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 138.0,
+      "good": 129.0,
+      "ratio": 0.9348,
+      "suggested_scalar": -0.1228,
+      "log_bad": 4.9273,
+      "log_good": 4.8598
+    },
+    "brevity.mean_sample_size": {
+      "bad": 138.0,
+      "good": 129.0,
+      "ratio": 0.9348,
+      "suggested_scalar": -0.1228,
+      "log_bad": 4.9273,
+      "log_good": 4.8598
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 432.0,
+      "good": 474.0,
+      "ratio": 1.0972,
+      "suggested_scalar": 0.1689,
+      "log_bad": 6.0684,
+      "log_good": 6.1612
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 203.0,
+      "good": 220.0,
+      "ratio": 1.0837,
+      "suggested_scalar": 0.1464,
+      "log_bad": 5.3132,
+      "log_good": 5.3936
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 311.0,
+      "good": 313.0,
+      "ratio": 1.0064,
+      "suggested_scalar": 0.0117,
+      "log_bad": 5.7398,
+      "log_good": 5.7462
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0023,
+      "good": 0.0042,
+      "ratio": 1.8261,
+      "suggested_scalar": 1.0962,
+      "log_bad": -6.0748,
+      "log_good": -5.4727
+    },
+    "heaps.mean_k": {
+      "bad": 1.7929,
+      "good": 2.266,
+      "ratio": 1.2639,
+      "suggested_scalar": 0.4263,
+      "log_bad": 0.5838,
+      "log_good": 0.818
+    },
+    "halstead.mean_effort": {
+      "bad": 62298.8183,
+      "good": 74786.4684,
+      "ratio": 1.2004,
+      "suggested_scalar": 0.3326,
+      "log_bad": 11.0397,
+      "log_good": 11.2224
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8603,
+      "good": 0.8526,
+      "ratio": 0.991,
+      "suggested_scalar": -0.0164,
+      "log_bad": -0.1505,
+      "log_good": -0.1595
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 78.0,
+      "good": 66.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.3041,
+      "log_bad": 4.3567,
+      "log_good": 4.1897
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 181.0,
+      "good": 212.0,
+      "ratio": 1.1713,
+      "suggested_scalar": 0.2878,
+      "log_bad": 5.1985,
+      "log_good": 5.3566
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5689,
+      "good": 0.489,
+      "ratio": 0.8596,
+      "suggested_scalar": -0.2755,
+      "log_bad": -0.5641,
+      "log_good": -0.7154
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.2275,
+      "good": 5.7473,
+      "ratio": 0.9229,
+      "suggested_scalar": -0.1461,
+      "log_bad": 1.829,
+      "log_good": 1.7487
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1667,
+      "good": 0.1884,
+      "ratio": 1.1302,
+      "suggested_scalar": 0.2228,
+      "log_bad": -1.7916,
+      "log_good": -1.6692
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.1418,
+      "good": 3.8696,
+      "ratio": 1.2317,
+      "suggested_scalar": 0.3793,
+      "log_bad": 1.1448,
+      "log_good": 1.3532
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 431.0,
+      "good": 473.0,
+      "ratio": 1.0974,
+      "suggested_scalar": 0.1693,
+      "log_bad": 6.0661,
+      "log_good": 6.1591
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 41.0,
+      "good": 47.0,
+      "ratio": 1.1463,
+      "suggested_scalar": 0.2486,
+      "log_bad": 3.7136,
+      "log_good": 3.8501
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3461.0455,
+      "good": 4154.8038,
+      "ratio": 1.2004,
+      "suggested_scalar": 0.3326,
+      "log_bad": 8.1493,
+      "log_good": 8.332
+    },
+    "readability.mean_total_lines": {
+      "bad": 55.0,
+      "good": 56.0,
+      "ratio": 1.0182,
+      "suggested_scalar": 0.0328,
+      "log_bad": 4.0073,
+      "log_good": 4.0254
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 12.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.5237,
+      "log_bad": 2.7726,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2253.8534,
+      "good": 2366.2066,
+      "ratio": 1.0498,
+      "suggested_scalar": 0.0886,
+      "log_bad": 7.7204,
+      "log_good": 7.769
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 842.0,
+      "good": 812.0,
+      "ratio": 0.9644,
+      "suggested_scalar": -0.066,
+      "log_bad": 6.7358,
+      "log_good": 6.6995
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 36.2182,
+      "good": 35.6964,
+      "ratio": 0.9856,
+      "suggested_scalar": -0.0264,
+      "log_bad": 3.5896,
+      "log_good": 3.575
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1081,
+      "good": 1.1371,
+      "ratio": 1.0262,
+      "suggested_scalar": 0.047,
+      "log_bad": 0.1026,
+      "log_good": 0.1285
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8886,
+      "good": 0.8766,
+      "ratio": 0.9865,
+      "suggested_scalar": -0.0248,
+      "log_bad": -0.1181,
+      "log_good": -0.1317
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9815,
+      "good": 0.97,
+      "ratio": 0.9883,
+      "suggested_scalar": -0.0215,
+      "log_bad": -0.0187,
+      "log_good": -0.0305
+    },
+    "halstead.mean_length": {
+      "bad": 335.0,
+      "good": 361.0,
+      "ratio": 1.0776,
+      "suggested_scalar": 0.1361,
+      "log_bad": 5.8141,
+      "log_good": 5.8889
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 12.0,
+      "good": 13.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.1457,
+      "log_bad": 2.4849,
+      "log_good": 2.5649
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.1085,
+      "good": 7.0112,
+      "ratio": 0.9863,
+      "suggested_scalar": -0.0251,
+      "log_bad": 1.9613,
+      "log_good": 1.9475
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0986,
+      "good": 0.1064,
+      "ratio": 1.0791,
+      "suggested_scalar": 0.1386,
+      "log_bad": -2.3167,
+      "log_good": -2.2405
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.641,
+      "good": 31.6061,
+      "ratio": 1.1434,
+      "suggested_scalar": 0.244,
+      "log_bad": 3.3193,
+      "log_good": 3.4534
+    },
+    "branching.mean_branch_count": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 95.0,
+      "good": 89.0,
+      "ratio": 0.9368,
+      "suggested_scalar": -0.1188,
+      "log_bad": 4.5539,
+      "log_good": 4.4886
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.791,
+      "good": 0.7732,
+      "ratio": 0.9775,
+      "suggested_scalar": -0.0414,
+      "log_bad": -0.2345,
+      "log_good": -0.2572
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 55.0,
+      "good": 56.0,
+      "ratio": 1.0182,
+      "suggested_scalar": 0.0328,
+      "log_bad": 4.0073,
+      "log_good": 4.0254
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 18.0,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.1041,
+      "log_bad": 2.8332,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "variable_naming.screaming_snake_for_constants": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 33.3333,
+      "good": 35.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0302,
+      "log_bad": 3.5066,
+      "log_good": 3.5553
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 37.6667,
+      "good": 37.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6288,
+      "log_good": 3.6288
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0068,
+      "good": 0.0069,
+      "ratio": 1.0147,
+      "suggested_scalar": 0.009,
+      "log_bad": -4.9908,
+      "log_good": -4.9762
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.9524,
+      "good": 1.9524,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6691,
+      "log_good": 0.6691
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7842,
+      "good": 0.7781,
+      "ratio": 0.9922,
+      "suggested_scalar": -0.0048,
+      "log_bad": -0.2431,
+      "log_good": -0.2509
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0138,
+      "good": 0.014,
+      "ratio": 1.0145,
+      "suggested_scalar": 0.0089,
+      "log_bad": -4.2831,
+      "log_good": -4.2687
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.9089,
+      "good": 5.1573,
+      "ratio": 1.0506,
+      "suggested_scalar": 0.0306,
+      "log_bad": 1.591,
+      "log_good": 1.6404
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 127.0,
+      "good": 124.6667,
+      "ratio": 0.9816,
+      "suggested_scalar": -0.0115,
+      "log_bad": 4.8442,
+      "log_good": 4.8256
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4286,
+      "good": 0.4255,
+      "ratio": 0.9928,
+      "suggested_scalar": -0.0045,
+      "log_bad": -0.8472,
+      "log_good": -0.8545
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 22.3333,
+      "good": 22.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1061,
+      "log_good": 3.1061
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5442,
+      "good": 0.5419,
+      "ratio": 0.9958,
+      "suggested_scalar": -0.0026,
+      "log_bad": -0.6084,
+      "log_good": -0.6127
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.3488,
+      "good": 3.3863,
+      "ratio": 1.0112,
+      "suggested_scalar": 0.0069,
+      "log_bad": 1.2086,
+      "log_good": 1.2197
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 719.3333,
+      "good": 711.6667,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.0066,
+      "log_bad": 6.5783,
+      "log_good": 6.5676
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0006,
+      "good": 0.0006,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.4186,
+      "log_good": -7.4186
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0159,
+      "good": 0.0166,
+      "ratio": 1.044,
+      "suggested_scalar": 0.0267,
+      "log_bad": -4.1414,
+      "log_good": -4.0984
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0008,
+      "good": 0.0008,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.1309,
+      "log_good": -7.1309
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0809,
+      "good": 1.0875,
+      "ratio": 1.0061,
+      "suggested_scalar": 0.0038,
+      "log_bad": 0.0778,
+      "log_good": 0.0839
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 231.0,
+      "good": 225.6667,
+      "ratio": 0.9769,
+      "suggested_scalar": -0.0145,
+      "log_bad": 5.4424,
+      "log_good": 5.4191
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 90.2622,
+      "good": 91.6606,
+      "ratio": 1.0155,
+      "suggested_scalar": 0.0095,
+      "log_bad": 4.5027,
+      "log_good": 4.5181
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6837,
+      "good": 0.6914,
+      "ratio": 1.0113,
+      "suggested_scalar": 0.0069,
+      "log_bad": -0.3802,
+      "log_good": -0.369
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 15.9967,
+      "good": 17.1906,
+      "ratio": 1.0746,
+      "suggested_scalar": 0.0446,
+      "log_bad": 2.7724,
+      "log_good": 2.8444
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2873.0,
+      "good": 2833.3333,
+      "ratio": 0.9862,
+      "suggested_scalar": -0.0086,
+      "log_bad": 7.9631,
+      "log_good": 7.9492
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1352,
+      "good": 0.1391,
+      "ratio": 1.0288,
+      "suggested_scalar": 0.0176,
+      "log_bad": -2.001,
+      "log_good": -1.9726
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7556,
+      "good": 0.7484,
+      "ratio": 0.9905,
+      "suggested_scalar": -0.0059,
+      "log_bad": -0.2802,
+      "log_good": -0.2898
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.9669,
+      "good": 9.1167,
+      "ratio": 1.0167,
+      "suggested_scalar": 0.0103,
+      "log_bad": 2.1935,
+      "log_good": 2.2101
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.3333,
+      "good": 2.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.8473,
+      "log_good": 0.8473
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 4.1877,
+      "good": 4.2205,
+      "ratio": 1.0078,
+      "suggested_scalar": 0.0048,
+      "log_bad": 1.4322,
+      "log_good": 1.44
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 162.0,
+      "good": 162.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.0876,
+      "log_good": 5.0876
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9529,
+      "good": 0.9495,
+      "ratio": 0.9964,
+      "suggested_scalar": -0.0022,
+      "log_bad": -0.0482,
+      "log_good": -0.0518
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 37.3333,
+      "good": 37.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6199,
+      "log_good": 3.6199
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6577,
+      "good": 0.6482,
+      "ratio": 0.9856,
+      "suggested_scalar": -0.009,
+      "log_bad": -0.419,
+      "log_good": -0.4336
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5245,
+      "good": 0.5306,
+      "ratio": 1.0116,
+      "suggested_scalar": 0.0072,
+      "log_bad": -0.6453,
+      "log_good": -0.6337
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9217,
+      "good": 2.8434,
+      "ratio": 0.9732,
+      "suggested_scalar": -0.0168,
+      "log_bad": 1.0722,
+      "log_good": 1.045
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 717.3333,
+      "good": 709.6667,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.0067,
+      "log_bad": 6.5755,
+      "log_good": 6.5648
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 26.3333,
+      "good": 26.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2708,
+      "log_good": 3.2708
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0299,
+      "good": 0.0304,
+      "ratio": 1.0167,
+      "suggested_scalar": 0.0103,
+      "log_bad": -3.5099,
+      "log_good": -3.4933
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.2223,
+      "good": 6.3159,
+      "ratio": 1.015,
+      "suggested_scalar": 0.0092,
+      "log_bad": 1.8281,
+      "log_good": 1.8431
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 32.3333,
+      "good": 24.6667,
+      "ratio": 0.7629,
+      "suggested_scalar": -0.1675,
+      "log_bad": 3.4761,
+      "log_good": 3.2055
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1984,
+      "good": 1.2425,
+      "ratio": 1.0368,
+      "suggested_scalar": 0.0224,
+      "log_bad": 0.181,
+      "log_good": 0.2171
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0044,
+      "good": 0.1113,
+      "ratio": 25.2955,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.4262,
+      "log_good": -2.1955
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9472,
+      "good": 5.9238,
+      "ratio": 0.9961,
+      "suggested_scalar": -0.0024,
+      "log_bad": 1.7829,
+      "log_good": 1.779
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7889,
+      "good": 0.8166,
+      "ratio": 1.0351,
+      "suggested_scalar": 0.0214,
+      "log_bad": -0.2371,
+      "log_good": -0.2026
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1902,
+      "good": 0.1926,
+      "ratio": 1.0126,
+      "suggested_scalar": 0.0078,
+      "log_bad": -1.6597,
+      "log_good": -1.6471
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.9904,
+      "good": 4.1382,
+      "ratio": 1.037,
+      "suggested_scalar": 0.0225,
+      "log_bad": 1.3839,
+      "log_good": 1.4203
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 7.6667,
+      "good": 7.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0369,
+      "log_good": 2.0369
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 473.6667,
+      "good": 466.0,
+      "ratio": 0.9838,
+      "suggested_scalar": -0.0101,
+      "log_bad": 6.1605,
+      "log_good": 6.1442
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 21.3333,
+      "good": 21.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0603,
+      "log_good": 3.0603
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.5172,
+      "good": 1.4957,
+      "ratio": 0.9858,
+      "suggested_scalar": -0.0088,
+      "log_bad": 0.4169,
+      "log_good": 0.4026
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 137.6667,
+      "good": 134.6667,
+      "ratio": 0.9782,
+      "suggested_scalar": -0.0136,
+      "log_bad": 4.9248,
+      "log_good": 4.9028
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1540.3333,
+      "good": 1514.3333,
+      "ratio": 0.9831,
+      "suggested_scalar": -0.0105,
+      "log_bad": 7.3398,
+      "log_good": 7.3227
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 248.6667,
+      "good": 244.0,
+      "ratio": 0.9812,
+      "suggested_scalar": -0.0117,
+      "log_bad": 5.5161,
+      "log_good": 5.4972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0087,
+      "good": 0.0088,
+      "ratio": 1.0115,
+      "suggested_scalar": 0.0071,
+      "log_bad": -4.7444,
+      "log_good": -4.733
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2615,
+      "good": 0.2648,
+      "ratio": 1.0126,
+      "suggested_scalar": 0.0078,
+      "log_bad": -1.3413,
+      "log_good": -1.3288
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 142.6667,
+      "good": 142.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.9605,
+      "log_good": 4.9605
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.3333,
+      "good": 6.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8458,
+      "log_good": 1.8458
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 137.6667,
+      "good": 134.6667,
+      "ratio": 0.9782,
+      "suggested_scalar": -0.0136,
+      "log_bad": 4.9248,
+      "log_good": 4.9028
+    },
+    "brevity.mean_sample_size": {
+      "bad": 137.6667,
+      "good": 134.6667,
+      "ratio": 0.9782,
+      "suggested_scalar": -0.0136,
+      "log_bad": 4.9248,
+      "log_good": 4.9028
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 719.3333,
+      "good": 711.6667,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.0066,
+      "log_bad": 6.5783,
+      "log_good": 6.5676
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 399.0,
+      "good": 396.6667,
+      "ratio": 0.9942,
+      "suggested_scalar": -0.0036,
+      "log_bad": 5.989,
+      "log_good": 5.9831
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 367.0,
+      "good": 359.3333,
+      "ratio": 0.9791,
+      "suggested_scalar": -0.0131,
+      "log_bad": 5.9054,
+      "log_good": 5.8843
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0108,
+      "good": 0.0109,
+      "ratio": 1.0093,
+      "suggested_scalar": 0.0057,
+      "log_bad": -4.5282,
+      "log_good": -4.519
+    },
+    "heaps.mean_k": {
+      "bad": 4.3333,
+      "good": 4.3247,
+      "ratio": 0.998,
+      "suggested_scalar": -0.0012,
+      "log_bad": 1.4663,
+      "log_good": 1.4643
+    },
+    "halstead.mean_effort": {
+      "bad": 238060.113,
+      "good": 236061.2397,
+      "ratio": 0.9916,
+      "suggested_scalar": -0.0052,
+      "log_bad": 12.3803,
+      "log_good": 12.3718
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8372,
+      "good": 0.8376,
+      "ratio": 1.0005,
+      "suggested_scalar": 0.0003,
+      "log_bad": -0.1777,
+      "log_good": -0.1772
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 89.6667,
+      "good": 87.3333,
+      "ratio": 0.974,
+      "suggested_scalar": -0.0163,
+      "log_bad": 4.4961,
+      "log_good": 4.4697
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 403.3333,
+      "good": 401.0,
+      "ratio": 0.9942,
+      "suggested_scalar": -0.0036,
+      "log_bad": 5.9998,
+      "log_good": 5.994
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3634,
+      "good": 0.3589,
+      "ratio": 0.9876,
+      "suggested_scalar": -0.0077,
+      "log_bad": -1.0123,
+      "log_good": -1.0247
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.6906,
+      "good": 6.7351,
+      "ratio": 1.0067,
+      "suggested_scalar": 0.0041,
+      "log_bad": 1.9007,
+      "log_good": 1.9073
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1902,
+      "good": 0.1926,
+      "ratio": 1.0126,
+      "suggested_scalar": 0.0078,
+      "log_bad": -1.6597,
+      "log_good": -1.6471
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.7479,
+      "good": 5.6718,
+      "ratio": 0.9868,
+      "suggested_scalar": -0.0083,
+      "log_bad": 1.7488,
+      "log_good": 1.7355
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 718.3333,
+      "good": 710.6667,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.0066,
+      "log_bad": 6.5769,
+      "log_good": 6.5662
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 11.6667,
+      "good": 11.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4567,
+      "log_good": 2.4567
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 134.0,
+      "good": 134.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.8978,
+      "log_good": 4.8978
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 13225.5618,
+      "good": 13114.5133,
+      "ratio": 0.9916,
+      "suggested_scalar": -0.0052,
+      "log_bad": 9.4899,
+      "log_good": 9.4815
+    },
+    "readability.mean_total_lines": {
+      "bad": 80.6667,
+      "good": 78.3333,
+      "ratio": 0.9711,
+      "suggested_scalar": -0.0182,
+      "log_bad": 4.3903,
+      "log_good": 4.361
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.6667,
+      "good": 6.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8971,
+      "log_good": 1.8971
+    },
+    "halstead.mean_volume": {
+      "bad": 4551.6939,
+      "good": 4487.1756,
+      "ratio": 0.9858,
+      "suggested_scalar": -0.0088,
+      "log_bad": 8.4233,
+      "log_good": 8.409
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 983.3333,
+      "good": 996.3333,
+      "ratio": 1.0132,
+      "suggested_scalar": 0.0081,
+      "log_bad": 6.8909,
+      "log_good": 6.9041
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 33.7721,
+      "good": 34.2518,
+      "ratio": 1.0142,
+      "suggested_scalar": 0.0087,
+      "log_bad": 3.5196,
+      "log_good": 3.5337
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2703,
+      "good": 1.252,
+      "ratio": 0.9856,
+      "suggested_scalar": -0.009,
+      "log_bad": 0.2393,
+      "log_good": 0.2247
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 31.0,
+      "good": 31.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.434,
+      "log_good": 3.434
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7168,
+      "good": 0.7116,
+      "ratio": 0.9927,
+      "suggested_scalar": -0.0045,
+      "log_bad": -0.333,
+      "log_good": -0.3402
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9711,
+      "good": 0.9708,
+      "ratio": 0.9997,
+      "suggested_scalar": -0.0002,
+      "log_bad": -0.0293,
+      "log_good": -0.0296
+    },
+    "halstead.mean_length": {
+      "bad": 652.0,
+      "good": 645.0,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.0067,
+      "log_bad": 6.48,
+      "log_good": 6.4693
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 12.9524,
+      "good": 12.9524,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5613,
+      "log_good": 2.5613
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.1035,
+      "good": 7.0726,
+      "ratio": 0.9957,
+      "suggested_scalar": -0.0027,
+      "log_bad": 1.9606,
+      "log_good": 1.9562
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1388,
+      "good": 0.1395,
+      "ratio": 1.005,
+      "suggested_scalar": 0.0031,
+      "log_bad": -1.9747,
+      "log_good": -1.9697
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 52.0999,
+      "good": 52.3894,
+      "ratio": 1.0056,
+      "suggested_scalar": 0.0034,
+      "log_bad": 3.9532,
+      "log_good": 3.9587
+    },
+    "branching.mean_branch_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 83.6667,
+      "good": 80.6667,
+      "ratio": 0.9641,
+      "suggested_scalar": -0.0226,
+      "log_bad": 4.4268,
+      "log_good": 4.3903
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.611,
+      "good": 0.6027,
+      "ratio": 0.9864,
+      "suggested_scalar": -0.0085,
+      "log_bad": -0.4927,
+      "log_good": -0.5063
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 81.3333,
+      "good": 79.0,
+      "ratio": 0.9713,
+      "suggested_scalar": -0.018,
+      "log_bad": 4.3986,
+      "log_good": 4.3694
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 20.3333,
+      "good": 20.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0123,
+      "log_good": 3.0123
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 25.0,
+      "ratio": 25.0,
+      "suggested_scalar": 1.9927,
+      "log_bad": 0.0,
+      "log_good": 3.2189
+    }
+  },
+  "code_smells.no_long_parameter_list": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 16.0,
+      "good": 21.0,
+      "ratio": 1.3125,
+      "suggested_scalar": 0.0787,
+      "log_bad": 2.7726,
+      "log_good": 3.0445
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 8.0,
+      "good": 2.0,
+      "ratio": 0.25,
+      "suggested_scalar": -0.4014,
+      "log_bad": 2.0794,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0083,
+      "good": 0.0335,
+      "ratio": 4.0361,
+      "suggested_scalar": 0.404,
+      "log_bad": -4.7915,
+      "log_good": -3.3962
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 6.6667,
+      "good": 1.3333,
+      "ratio": 0.2,
+      "suggested_scalar": -0.466,
+      "log_bad": 1.8971,
+      "log_good": 0.2877
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8947,
+      "good": 0.8525,
+      "ratio": 0.9528,
+      "suggested_scalar": -0.014,
+      "log_bad": -0.1113,
+      "log_good": -0.1596
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0083,
+      "good": 0.0335,
+      "ratio": 4.0361,
+      "suggested_scalar": 0.404,
+      "log_bad": -4.7915,
+      "log_good": -3.3962
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6432,
+      "good": 4.613,
+      "ratio": 0.9935,
+      "suggested_scalar": -0.0019,
+      "log_bad": 1.5354,
+      "log_good": 1.5289
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 108.0,
+      "good": 76.0,
+      "ratio": 0.7037,
+      "suggested_scalar": -0.1017,
+      "log_bad": 4.6821,
+      "log_good": 4.3307
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5123,
+      "good": 0.5096,
+      "ratio": 0.9947,
+      "suggested_scalar": -0.0015,
+      "log_bad": -0.6688,
+      "log_good": -0.6741
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 19.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.0157,
+      "log_bad": 2.8904,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6485,
+      "good": 0.5883,
+      "ratio": 0.9072,
+      "suggested_scalar": -0.0282,
+      "log_bad": -0.4331,
+      "log_good": -0.5305
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.386,
+      "good": 3.6066,
+      "ratio": 0.8223,
+      "suggested_scalar": -0.0566,
+      "log_bad": 1.4784,
+      "log_good": 1.2828
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 484.0,
+      "good": 448.0,
+      "ratio": 0.9256,
+      "suggested_scalar": -0.0224,
+      "log_bad": 6.1821,
+      "log_good": 6.1048
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0005,
+      "good": 0.0005,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.6009,
+      "log_good": -7.6009
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0877,
+      "good": 1.0,
+      "ratio": 11.4025,
+      "suggested_scalar": 0.7047,
+      "log_bad": -2.4338,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.001,
+      "good": 1.0,
+      "ratio": 1.0e3,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.9078,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0058,
+      "good": 0.9941,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0034,
+      "log_bad": 0.0058,
+      "log_good": -0.0059
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 187.0,
+      "good": 172.0,
+      "ratio": 0.9198,
+      "suggested_scalar": -0.0242,
+      "log_bad": 5.2311,
+      "log_good": 5.1475
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 95.3116,
+      "good": 105.1954,
+      "ratio": 1.1037,
+      "suggested_scalar": 0.0286,
+      "log_bad": 4.5572,
+      "log_good": 4.6558
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6273,
+      "good": 0.6063,
+      "ratio": 0.9665,
+      "suggested_scalar": -0.0099,
+      "log_bad": -0.4663,
+      "log_good": -0.5004
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 17.0928,
+      "good": 16.7312,
+      "ratio": 0.9788,
+      "suggested_scalar": -0.0062,
+      "log_bad": 2.8387,
+      "log_good": 2.8173
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1968.0,
+      "good": 1879.0,
+      "ratio": 0.9548,
+      "suggested_scalar": -0.0134,
+      "log_bad": 7.5848,
+      "log_good": 7.5385
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0526,
+      "good": 0.0164,
+      "ratio": 0.3118,
+      "suggested_scalar": -0.3374,
+      "log_bad": -2.945,
+      "log_good": -4.1105
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8772,
+      "good": 0.8361,
+      "ratio": 0.9531,
+      "suggested_scalar": -0.0139,
+      "log_bad": -0.131,
+      "log_good": -0.179
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.3077,
+      "good": 7.3443,
+      "ratio": 0.7891,
+      "suggested_scalar": -0.0686,
+      "log_bad": 2.2308,
+      "log_good": 1.9939
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.6756,
+      "good": 3.3862,
+      "ratio": 0.5966,
+      "suggested_scalar": -0.1495,
+      "log_bad": 1.7362,
+      "log_good": 1.2197
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 142.0,
+      "good": 132.0,
+      "ratio": 0.9296,
+      "suggested_scalar": -0.0211,
+      "log_bad": 4.9558,
+      "log_good": 4.8828
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.964,
+      "good": 0.9628,
+      "ratio": 0.9988,
+      "suggested_scalar": -0.0004,
+      "log_bad": -0.0367,
+      "log_good": -0.0379
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 23.0,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.0129,
+      "log_bad": 3.091,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5981,
+      "good": 0.6179,
+      "ratio": 1.0331,
+      "suggested_scalar": 0.0094,
+      "log_bad": -0.514,
+      "log_good": -0.4814
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4606,
+      "good": 0.3924,
+      "ratio": 0.8519,
+      "suggested_scalar": -0.0464,
+      "log_bad": -0.7752,
+      "log_good": -0.9355
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.488,
+      "good": 2.617,
+      "ratio": 1.0518,
+      "suggested_scalar": 0.0146,
+      "log_bad": 0.9115,
+      "log_good": 0.962
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 482.0,
+      "good": 446.0,
+      "ratio": 0.9253,
+      "suggested_scalar": -0.0225,
+      "log_bad": 6.1779,
+      "log_good": 6.1003
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 20.0,
+      "good": 18.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0305,
+      "log_bad": 2.9957,
+      "log_good": 2.8904
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0517,
+      "good": 0.029,
+      "ratio": 0.5609,
+      "suggested_scalar": -0.1674,
+      "log_bad": -2.9623,
+      "log_good": -3.5405
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.8329,
+      "ratio": 0.9875,
+      "suggested_scalar": -0.0037,
+      "log_bad": 1.7761,
+      "log_good": 1.7635
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 45.0,
+      "good": 40.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0341,
+      "log_bad": 3.8067,
+      "log_good": 3.6889
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7961,
+      "good": 0.7824,
+      "ratio": 0.9828,
+      "suggested_scalar": -0.005,
+      "log_bad": -0.228,
+      "log_good": -0.2454
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5718,
+      "good": 5.71,
+      "ratio": 1.0248,
+      "suggested_scalar": 0.0071,
+      "log_bad": 1.7177,
+      "log_good": 1.7422
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7861,
+      "good": 0.7909,
+      "ratio": 1.0061,
+      "suggested_scalar": 0.0018,
+      "log_bad": -0.2407,
+      "log_good": -0.2346
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.0806,
+      "good": 0.0758,
+      "ratio": 0.9404,
+      "suggested_scalar": -0.0178,
+      "log_bad": -2.5183,
+      "log_good": -2.5797
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.1343,
+      "good": 4.0904,
+      "ratio": 0.9894,
+      "suggested_scalar": -0.0031,
+      "log_bad": 1.4193,
+      "log_good": 1.4086
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 327.0,
+      "good": 337.0,
+      "ratio": 1.0306,
+      "suggested_scalar": 0.0087,
+      "log_bad": 5.79,
+      "log_good": 5.8201
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 18.0,
+      "good": 2.0,
+      "ratio": 0.1111,
+      "suggested_scalar": -0.6362,
+      "log_bad": 2.8904,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0177,
+      "good": 0.7414,
+      "ratio": 0.7285,
+      "suggested_scalar": -0.0917,
+      "log_bad": 0.0175,
+      "log_good": -0.2992
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 114.0,
+      "good": 107.0,
+      "ratio": 0.9386,
+      "suggested_scalar": -0.0183,
+      "log_bad": 4.7362,
+      "log_good": 4.6728
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1133.0,
+      "good": 1088.0,
+      "ratio": 0.9603,
+      "suggested_scalar": -0.0117,
+      "log_bad": 7.0326,
+      "log_good": 6.9921
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 191.0,
+      "good": 130.0,
+      "ratio": 0.6806,
+      "suggested_scalar": -0.1114,
+      "log_bad": 5.2523,
+      "log_good": 4.8675
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2996,
+      "good": 0.25,
+      "ratio": 0.8344,
+      "suggested_scalar": -0.0524,
+      "log_bad": -1.2053,
+      "log_good": -1.3863
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 87.0,
+      "good": 85.0,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0067,
+      "log_bad": 4.4659,
+      "log_good": 4.4427
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 114.0,
+      "good": 107.0,
+      "ratio": 0.9386,
+      "suggested_scalar": -0.0183,
+      "log_bad": 4.7362,
+      "log_good": 4.6728
+    },
+    "brevity.mean_sample_size": {
+      "bad": 114.0,
+      "good": 107.0,
+      "ratio": 0.9386,
+      "suggested_scalar": -0.0183,
+      "log_bad": 4.7362,
+      "log_good": 4.6728
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 484.0,
+      "good": 448.0,
+      "ratio": 0.9256,
+      "suggested_scalar": -0.0224,
+      "log_bad": 6.1821,
+      "log_good": 6.1048
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 271.0,
+      "good": 245.0,
+      "ratio": 0.9041,
+      "suggested_scalar": -0.0292,
+      "log_bad": 5.6021,
+      "log_good": 5.5013
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 267.0,
+      "good": 261.0,
+      "ratio": 0.9775,
+      "suggested_scalar": -0.0066,
+      "log_bad": 5.5872,
+      "log_good": 5.5645
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.248,
+      "good": 3.156,
+      "ratio": 1.4039,
+      "suggested_scalar": 0.0982,
+      "log_bad": 0.81,
+      "log_good": 1.1493
+    },
+    "halstead.mean_effort": {
+      "bad": 74590.6096,
+      "good": 62740.9808,
+      "ratio": 0.8411,
+      "suggested_scalar": -0.0501,
+      "log_bad": 11.2198,
+      "log_good": 11.0468
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8154,
+      "good": 0.847,
+      "ratio": 1.0388,
+      "suggested_scalar": 0.011,
+      "log_bad": -0.2041,
+      "log_good": -0.1661
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 86.0,
+      "good": 53.0,
+      "ratio": 0.6163,
+      "suggested_scalar": -0.1401,
+      "log_bad": 4.4543,
+      "log_good": 3.9703
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 261.0,
+      "good": 226.0,
+      "ratio": 0.8659,
+      "suggested_scalar": -0.0417,
+      "log_bad": 5.5645,
+      "log_good": 5.4205
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4385,
+      "good": 0.436,
+      "ratio": 0.9943,
+      "suggested_scalar": -0.0017,
+      "log_bad": -0.8244,
+      "log_good": -0.8301
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0588,
+      "good": 6.3256,
+      "ratio": 1.044,
+      "suggested_scalar": 0.0125,
+      "log_bad": 1.8015,
+      "log_good": 1.8446
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.0806,
+      "good": 0.0758,
+      "ratio": 0.9404,
+      "suggested_scalar": -0.0178,
+      "log_bad": -2.5183,
+      "log_good": -2.5797
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.662,
+      "good": 3.3318,
+      "ratio": 0.7147,
+      "suggested_scalar": -0.0973,
+      "log_bad": 1.5394,
+      "log_good": 1.2035
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 483.0,
+      "good": 447.0,
+      "ratio": 0.9255,
+      "suggested_scalar": -0.0224,
+      "log_bad": 6.18,
+      "log_good": 6.1026
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 67.0,
+      "good": 66.0,
+      "ratio": 0.9851,
+      "suggested_scalar": -0.0044,
+      "log_bad": 4.2047,
+      "log_good": 4.1897
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4143.9228,
+      "good": 3485.61,
+      "ratio": 0.8411,
+      "suggested_scalar": -0.0501,
+      "log_bad": 8.3294,
+      "log_good": 8.1564
+    },
+    "readability.mean_total_lines": {
+      "bad": 52.0,
+      "good": 61.0,
+      "ratio": 1.1731,
+      "suggested_scalar": 0.0462,
+      "log_bad": 3.9512,
+      "log_good": 4.1109
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 6.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.1479,
+      "log_bad": 2.3026,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 3053.2092,
+      "good": 2224.2622,
+      "ratio": 0.7285,
+      "suggested_scalar": -0.0917,
+      "log_bad": 8.0239,
+      "log_good": 7.7072
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 791.0,
+      "good": 718.0,
+      "ratio": 0.9077,
+      "suggested_scalar": -0.028,
+      "log_bad": 6.6733,
+      "log_good": 6.5765
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 29.9615,
+      "good": 29.7213,
+      "ratio": 0.992,
+      "suggested_scalar": -0.0023,
+      "log_bad": 3.3999,
+      "log_good": 3.3919
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2066,
+      "good": 1.1133,
+      "ratio": 0.9227,
+      "suggested_scalar": -0.0233,
+      "log_bad": 0.1878,
+      "log_good": 0.1073
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 35.0,
+      "good": 37.0,
+      "ratio": 1.0571,
+      "suggested_scalar": 0.0161,
+      "log_bad": 3.5553,
+      "log_good": 3.6109
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 1.0,
+      "ratio": 0.2,
+      "suggested_scalar": -0.466,
+      "log_bad": 1.6094,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7951,
+      "good": 0.8042,
+      "ratio": 1.0114,
+      "suggested_scalar": 0.0033,
+      "log_bad": -0.2293,
+      "log_good": -0.2179
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 5.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.2653,
+      "log_bad": 0.6931,
+      "log_good": 1.6094
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9706,
+      "good": 0.9788,
+      "ratio": 1.0084,
+      "suggested_scalar": 0.0024,
+      "log_bad": -0.0298,
+      "log_good": -0.0214
+    },
+    "halstead.mean_length": {
+      "bad": 452.0,
+      "good": 356.0,
+      "ratio": 0.7876,
+      "suggested_scalar": -0.0691,
+      "log_bad": 6.1137,
+      "log_good": 5.8749
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 16.3333,
+      "good": 12.3333,
+      "ratio": 0.7551,
+      "suggested_scalar": -0.0813,
+      "log_bad": 2.7932,
+      "log_good": 2.5123
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8329,
+      "good": 6.7415,
+      "ratio": 0.9866,
+      "suggested_scalar": -0.0039,
+      "log_bad": 1.9217,
+      "log_good": 1.9083
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1378,
+      "good": 0.1304,
+      "ratio": 0.9463,
+      "suggested_scalar": -0.016,
+      "log_bad": -1.982,
+      "log_good": -2.0371
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 24.4302,
+      "good": 28.2075,
+      "ratio": 1.1546,
+      "suggested_scalar": 0.0416,
+      "log_bad": 3.1958,
+      "log_good": 3.3396
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.3181,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 82.0,
+      "good": 75.0,
+      "ratio": 0.9146,
+      "suggested_scalar": -0.0258,
+      "log_bad": 4.4067,
+      "log_good": 4.3175
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6742,
+      "good": 0.6743,
+      "ratio": 1.0001,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3942,
+      "log_good": -0.3941
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 57.0,
+      "good": 61.0,
+      "ratio": 1.0702,
+      "suggested_scalar": 0.0196,
+      "log_bad": 4.0431,
+      "log_good": 4.1109
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "variable_naming.boolean_has_is_has_prefix": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 24.0,
+      "good": 66.0,
+      "ratio": 2.75,
+      "suggested_scalar": 2.0,
+      "log_bad": 3.1781,
+      "log_good": 4.1897
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 19.6667,
+      "good": 19.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9789,
+      "log_good": 2.9789
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.9524,
+      "good": 0.9524,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0488,
+      "log_good": -0.0488
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7444,
+      "good": 0.7444,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2952,
+      "log_good": -0.2952
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0097,
+      "good": 0.0097,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.6356,
+      "log_good": -4.6356
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4446,
+      "good": 4.4753,
+      "ratio": 1.0069,
+      "suggested_scalar": 0.0136,
+      "log_bad": 1.4917,
+      "log_good": 1.4986
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 79.0,
+      "good": 81.0,
+      "ratio": 1.0253,
+      "suggested_scalar": 0.0494,
+      "log_bad": 4.3694,
+      "log_good": 4.3944
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4356,
+      "good": 0.4613,
+      "ratio": 1.059,
+      "suggested_scalar": 0.1133,
+      "log_bad": -0.831,
+      "log_good": -0.7737
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5794,
+      "good": 0.5775,
+      "ratio": 0.9967,
+      "suggested_scalar": -0.0065,
+      "log_bad": -0.5458,
+      "log_good": -0.549
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.7345,
+      "good": 3.7345,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3176,
+      "log_good": 1.3176
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 435.0,
+      "good": 435.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.0753,
+      "log_good": 6.0753
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.6667,
+      "good": 2.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9808,
+      "log_good": 0.9808
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0068,
+      "good": 0.0062,
+      "ratio": 0.9118,
+      "suggested_scalar": -0.1826,
+      "log_bad": -4.9908,
+      "log_good": -5.0832
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0012,
+      "good": 0.0011,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.172,
+      "log_bad": -6.7254,
+      "log_good": -6.8124
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1644,
+      "good": 1.1409,
+      "ratio": 0.9798,
+      "suggested_scalar": -0.0403,
+      "log_bad": 0.1522,
+      "log_good": 0.1318
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 146.3333,
+      "good": 146.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.9859,
+      "log_good": 4.9859
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 100.2974,
+      "good": 78.4495,
+      "ratio": 0.7822,
+      "suggested_scalar": -0.4857,
+      "log_bad": 4.6081,
+      "log_good": 4.3625
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6479,
+      "good": 0.6414,
+      "ratio": 0.99,
+      "suggested_scalar": -0.0199,
+      "log_bad": -0.434,
+      "log_good": -0.4441
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.8675,
+      "good": 19.6668,
+      "ratio": 1.4182,
+      "suggested_scalar": 0.6908,
+      "log_bad": 2.6295,
+      "log_good": 2.9789
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1917.3333,
+      "good": 2089.3333,
+      "ratio": 1.0897,
+      "suggested_scalar": 0.1698,
+      "log_bad": 7.5587,
+      "log_good": 7.6446
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1071,
+      "good": 0.1071,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.234,
+      "log_good": -2.234
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6954,
+      "good": 0.6954,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3633,
+      "log_good": -0.3633
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.1187,
+      "good": 7.1187,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9627,
+      "log_good": 1.9627
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.134,
+      "good": 2.134,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.758,
+      "log_good": 0.758
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 135.3333,
+      "good": 121.3333,
+      "ratio": 0.8966,
+      "suggested_scalar": -0.2159,
+      "log_bad": 4.9077,
+      "log_good": 4.7985
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9498,
+      "good": 0.9551,
+      "ratio": 1.0056,
+      "suggested_scalar": 0.011,
+      "log_bad": -0.0515,
+      "log_good": -0.0459
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6837,
+      "good": 0.7041,
+      "ratio": 1.0298,
+      "suggested_scalar": 0.0581,
+      "log_bad": -0.3802,
+      "log_good": -0.3508
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4752,
+      "good": 0.472,
+      "ratio": 0.9933,
+      "suggested_scalar": -0.0134,
+      "log_bad": -0.744,
+      "log_good": -0.7508
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.1621,
+      "good": 3.38,
+      "ratio": 1.0689,
+      "suggested_scalar": 0.1318,
+      "log_bad": 1.1512,
+      "log_good": 1.2179
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 433.0,
+      "good": 433.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.0707,
+      "log_good": 6.0707
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0158,
+      "good": 0.0158,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.1477,
+      "log_good": -4.1477
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.5282,
+      "good": 5.5552,
+      "ratio": 1.0049,
+      "suggested_scalar": 0.0096,
+      "log_bad": 1.7099,
+      "log_good": 1.7147
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.3592,
+      "good": 0.4683,
+      "ratio": 1.3037,
+      "suggested_scalar": 0.5244,
+      "log_bad": -1.0239,
+      "log_good": -0.7586
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.1647,
+      "good": 5.2167,
+      "ratio": 1.0101,
+      "suggested_scalar": 0.0198,
+      "log_bad": 1.6418,
+      "log_good": 1.6519
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8042,
+      "good": 0.8059,
+      "ratio": 1.0021,
+      "suggested_scalar": 0.0042,
+      "log_bad": -0.2179,
+      "log_good": -0.2158
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1362,
+      "good": 0.1362,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.9936,
+      "log_good": -1.9936
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.7174,
+      "good": 4.4268,
+      "ratio": 1.1908,
+      "suggested_scalar": 0.3453,
+      "log_bad": 1.313,
+      "log_good": 1.4877
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 285.3333,
+      "good": 286.0,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0046,
+      "log_bad": 5.6537,
+      "log_good": 5.656
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8475,
+      "good": 0.8522,
+      "ratio": 1.0055,
+      "suggested_scalar": 0.0109,
+      "log_bad": -0.1655,
+      "log_good": -0.1599
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 77.3333,
+      "good": 80.3333,
+      "ratio": 1.0388,
+      "suggested_scalar": 0.0752,
+      "log_bad": 4.3481,
+      "log_good": 4.3862
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1038.6667,
+      "good": 1210.6667,
+      "ratio": 1.1656,
+      "suggested_scalar": 0.303,
+      "log_bad": 6.9457,
+      "log_good": 7.0989
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 164.3333,
+      "good": 164.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.1019,
+      "log_good": 5.1019
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0015,
+      "good": 0.0015,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.5023,
+      "log_good": -6.5023
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2088,
+      "good": 0.2088,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.5664,
+      "log_good": -1.5664
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 63.3333,
+      "good": 62.6667,
+      "ratio": 0.9895,
+      "suggested_scalar": -0.0209,
+      "log_bad": 4.1484,
+      "log_good": 4.1378
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.6667,
+      "good": 4.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.5405,
+      "log_good": 1.5405
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 77.3333,
+      "good": 80.3333,
+      "ratio": 1.0388,
+      "suggested_scalar": 0.0752,
+      "log_bad": 4.3481,
+      "log_good": 4.3862
+    },
+    "brevity.mean_sample_size": {
+      "bad": 77.3333,
+      "good": 80.3333,
+      "ratio": 1.0388,
+      "suggested_scalar": 0.0752,
+      "log_bad": 4.3481,
+      "log_good": 4.3862
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 435.0,
+      "good": 435.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.0753,
+      "log_good": 6.0753
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 241.0,
+      "good": 241.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.4848,
+      "log_good": 5.4848
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 215.6667,
+      "good": 217.6667,
+      "ratio": 1.0093,
+      "suggested_scalar": 0.0182,
+      "log_bad": 5.3737,
+      "log_good": 5.383
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.3985,
+      "good": 2.5416,
+      "ratio": 1.0597,
+      "suggested_scalar": 0.1146,
+      "log_bad": 0.8748,
+      "log_good": 0.9328
+    },
+    "halstead.mean_effort": {
+      "bad": 85538.722,
+      "good": 83008.8454,
+      "ratio": 0.9704,
+      "suggested_scalar": -0.0594,
+      "log_bad": 11.3567,
+      "log_good": 11.3267
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8234,
+      "good": 0.8244,
+      "ratio": 1.0012,
+      "suggested_scalar": 0.0024,
+      "log_bad": -0.1943,
+      "log_good": -0.1931
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 56.0,
+      "good": 58.0,
+      "ratio": 1.0357,
+      "suggested_scalar": 0.0694,
+      "log_bad": 4.0254,
+      "log_good": 4.0604
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 239.0,
+      "good": 239.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.4765,
+      "log_good": 5.4765
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.36,
+      "good": 0.3805,
+      "ratio": 1.0569,
+      "suggested_scalar": 0.1095,
+      "log_bad": -1.0217,
+      "log_good": -0.9663
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.0967,
+      "good": 8.2677,
+      "ratio": 1.165,
+      "suggested_scalar": 0.302,
+      "log_bad": 1.9596,
+      "log_good": 2.1124
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1362,
+      "good": 0.1362,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.9936,
+      "log_good": -1.9936
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.8806,
+      "good": 5.1205,
+      "ratio": 1.3195,
+      "suggested_scalar": 0.5482,
+      "log_bad": 1.356,
+      "log_good": 1.6333
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 434.0,
+      "good": 434.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.073,
+      "log_good": 6.073
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 58.6667,
+      "good": 58.0,
+      "ratio": 0.9886,
+      "suggested_scalar": -0.0226,
+      "log_bad": 4.0719,
+      "log_good": 4.0604
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4752.1512,
+      "good": 4611.6025,
+      "ratio": 0.9704,
+      "suggested_scalar": -0.0594,
+      "log_bad": 8.4664,
+      "log_good": 8.4363
+    },
+    "readability.mean_total_lines": {
+      "bad": 61.3333,
+      "good": 61.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.1163,
+      "log_good": 4.1163
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2542.5533,
+      "good": 2556.7236,
+      "ratio": 1.0056,
+      "suggested_scalar": 0.011,
+      "log_bad": 7.8409,
+      "log_good": 7.8465
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 606.3333,
+      "good": 618.3333,
+      "ratio": 1.0198,
+      "suggested_scalar": 0.0387,
+      "log_bad": 6.4074,
+      "log_good": 6.427
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.1644,
+      "good": 32.9621,
+      "ratio": 1.0927,
+      "suggested_scalar": 0.1754,
+      "log_bad": 3.4067,
+      "log_good": 3.4954
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1739,
+      "good": 1.4322,
+      "ratio": 1.22,
+      "suggested_scalar": 0.3932,
+      "log_bad": 0.1603,
+      "log_good": 0.3592
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.6667,
+      "good": 2.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9808,
+      "log_good": 0.9808
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7951,
+      "good": 0.798,
+      "ratio": 1.0036,
+      "suggested_scalar": 0.0072,
+      "log_bad": -0.2293,
+      "log_good": -0.2256
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9953,
+      "good": 0.9958,
+      "ratio": 1.0005,
+      "suggested_scalar": 0.001,
+      "log_bad": -0.0047,
+      "log_good": -0.0042
+    },
+    "halstead.mean_length": {
+      "bad": 403.3333,
+      "good": 403.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.9998,
+      "log_good": 5.9998
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.7619,
+      "good": 6.7619,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9113,
+      "log_good": 1.9113
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2722,
+      "good": 6.3272,
+      "ratio": 1.0088,
+      "suggested_scalar": 0.0173,
+      "log_bad": 1.8361,
+      "log_good": 1.8449
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1254,
+      "good": 0.1153,
+      "ratio": 0.9195,
+      "suggested_scalar": -0.166,
+      "log_bad": -2.0762,
+      "log_good": -2.1602
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 33.7029,
+      "good": 32.4893,
+      "ratio": 0.964,
+      "suggested_scalar": -0.0725,
+      "log_bad": 3.5176,
+      "log_good": 3.4809
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.6667,
+      "good": 6.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8971,
+      "log_good": 1.8971
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 52.6667,
+      "good": 55.6667,
+      "ratio": 1.057,
+      "suggested_scalar": 0.1095,
+      "log_bad": 3.964,
+      "log_good": 4.0194
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7064,
+      "good": 0.7123,
+      "ratio": 1.0084,
+      "suggested_scalar": 0.0164,
+      "log_bad": -0.3476,
+      "log_good": -0.3393
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 61.3333,
+      "good": 61.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.1163,
+      "log_good": 4.1163
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 20.6667,
+      "good": 24.3333,
+      "ratio": 1.1774,
+      "suggested_scalar": 0.3229,
+      "log_bad": 3.0285,
+      "log_good": 3.1918
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "documentation.exported_symbol_has_doc_comment": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0082,
+      "good": 0.0061,
+      "ratio": 0.7439,
+      "suggested_scalar": -0.3411,
+      "log_bad": -4.8036,
+      "log_good": -5.0995
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.8333,
+      "good": 0.8333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1824,
+      "log_good": -0.1824
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.75,
+      "good": 0.8361,
+      "ratio": 1.1148,
+      "suggested_scalar": 0.1253,
+      "log_bad": -0.2877,
+      "log_good": -0.179
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0082,
+      "good": 0.0061,
+      "ratio": 0.7439,
+      "suggested_scalar": -0.3411,
+      "log_bad": -4.8036,
+      "log_good": -5.0995
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8583,
+      "good": 4.9007,
+      "ratio": 1.0087,
+      "suggested_scalar": 0.01,
+      "log_bad": 1.5807,
+      "log_good": 1.5894
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 78.0,
+      "good": 132.0,
+      "ratio": 1.6923,
+      "suggested_scalar": 0.6066,
+      "log_bad": 4.3567,
+      "log_good": 4.8828
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3802,
+      "good": 0.5629,
+      "ratio": 1.4805,
+      "suggested_scalar": 0.4524,
+      "log_bad": -0.9671,
+      "log_good": -0.5747
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 19.0,
+      "ratio": 1.1875,
+      "suggested_scalar": 0.1981,
+      "log_bad": 2.7726,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5954,
+      "good": 0.6651,
+      "ratio": 1.1171,
+      "suggested_scalar": 0.1276,
+      "log_bad": -0.5185,
+      "log_good": -0.4078
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.5714,
+      "good": 0.5246,
+      "ratio": 0.9181,
+      "suggested_scalar": -0.0985,
+      "log_bad": -0.5597,
+      "log_good": -0.6451
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 366.0,
+      "good": 495.0,
+      "ratio": 1.3525,
+      "suggested_scalar": 0.3481,
+      "log_bad": 5.9026,
+      "log_good": 6.2046
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0008,
+      "good": 0.0006,
+      "ratio": 0.75,
+      "suggested_scalar": -0.3317,
+      "log_bad": -7.1309,
+      "log_good": -7.4186
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1429,
+      "good": 0.2131,
+      "ratio": 1.4913,
+      "suggested_scalar": 0.4608,
+      "log_bad": -1.9456,
+      "log_good": -1.546
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9933,
+      "good": 0.9499,
+      "ratio": 0.9563,
+      "suggested_scalar": -0.0515,
+      "log_bad": -0.0067,
+      "log_good": -0.0514
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 145.0,
+      "good": 208.0,
+      "ratio": 1.4345,
+      "suggested_scalar": 0.416,
+      "log_bad": 4.9767,
+      "log_good": 5.3375
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 111.2404,
+      "good": 110.193,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.0109,
+      "log_bad": 4.7117,
+      "log_good": 4.7022
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6301,
+      "good": 0.4676,
+      "ratio": 0.7421,
+      "suggested_scalar": -0.3439,
+      "log_bad": -0.4619,
+      "log_good": -0.7601
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 6.4411,
+      "good": 5.5472,
+      "ratio": 0.8612,
+      "suggested_scalar": -0.1723,
+      "log_bad": 1.8627,
+      "log_good": 1.7133
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1304.0,
+      "good": 1816.0,
+      "ratio": 1.3926,
+      "suggested_scalar": 0.3819,
+      "log_bad": 7.1732,
+      "log_good": 7.5044
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0536,
+      "good": 0.2787,
+      "ratio": 5.1996,
+      "suggested_scalar": 1.9008,
+      "log_bad": -2.9262,
+      "log_good": -1.2776
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7143,
+      "good": 0.8033,
+      "ratio": 1.1246,
+      "suggested_scalar": 0.1354,
+      "log_bad": -0.3365,
+      "log_good": -0.219
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.5357,
+      "good": 8.1148,
+      "ratio": 1.2416,
+      "suggested_scalar": 0.2495,
+      "log_bad": 1.8773,
+      "log_good": 2.0937
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.3878,
+      "good": 0.3805,
+      "ratio": 0.9812,
+      "suggested_scalar": -0.0219,
+      "log_bad": -0.9473,
+      "log_good": -0.9663
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 103.0,
+      "good": 143.0,
+      "ratio": 1.3883,
+      "suggested_scalar": 0.3783,
+      "log_bad": 4.6347,
+      "log_good": 4.9628
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9121,
+      "good": 0.9499,
+      "ratio": 1.0414,
+      "suggested_scalar": 0.0468,
+      "log_bad": -0.092,
+      "log_good": -0.0514
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 33.0,
+      "ratio": 1.4348,
+      "suggested_scalar": 0.4162,
+      "log_bad": 3.1355,
+      "log_good": 3.4965
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6204,
+      "good": 0.5611,
+      "ratio": 0.9044,
+      "suggested_scalar": -0.1158,
+      "log_bad": -0.4774,
+      "log_good": -0.5779
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.467,
+      "good": 0.2657,
+      "ratio": 0.569,
+      "suggested_scalar": -0.6502,
+      "log_bad": -0.7614,
+      "log_good": -1.3254
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6343,
+      "good": 2.2785,
+      "ratio": 0.8649,
+      "suggested_scalar": -0.1673,
+      "log_bad": 0.9686,
+      "log_good": 0.8235
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 364.0,
+      "good": 493.0,
+      "ratio": 1.3544,
+      "suggested_scalar": 0.3498,
+      "log_bad": 5.8972,
+      "log_good": 6.2005
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0082,
+      "good": 0.0061,
+      "ratio": 0.7439,
+      "suggested_scalar": -0.3411,
+      "log_bad": -4.8036,
+      "log_good": -5.0995
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.858,
+      "good": 6.0,
+      "ratio": 1.0242,
+      "suggested_scalar": 0.0276,
+      "log_bad": 1.7678,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 39.0,
+      "good": 62.0,
+      "ratio": 1.5897,
+      "suggested_scalar": 0.5345,
+      "log_bad": 3.6636,
+      "log_good": 4.1271
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9758,
+      "good": 0.9804,
+      "ratio": 1.0047,
+      "suggested_scalar": 0.0054,
+      "log_bad": -0.0245,
+      "log_good": -0.0198
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5272,
+      "good": 6.1343,
+      "ratio": 1.1098,
+      "suggested_scalar": 0.1202,
+      "log_bad": 1.7097,
+      "log_good": 1.8139
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8293,
+      "good": 0.8168,
+      "ratio": 0.9849,
+      "suggested_scalar": -0.0175,
+      "log_bad": -0.1872,
+      "log_good": -0.2024
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1642,
+      "good": 0.1528,
+      "ratio": 0.9306,
+      "suggested_scalar": -0.083,
+      "log_bad": -1.8067,
+      "log_good": -1.8786
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.5379,
+      "good": 2.3553,
+      "ratio": 0.9281,
+      "suggested_scalar": -0.0861,
+      "log_bad": 0.9313,
+      "log_good": 0.8567
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 248.0,
+      "good": 413.0,
+      "ratio": 1.6653,
+      "suggested_scalar": 0.5881,
+      "log_bad": 5.5134,
+      "log_good": 6.0234
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7459,
+      "good": 1.1365,
+      "ratio": 1.5237,
+      "suggested_scalar": 0.4855,
+      "log_bad": -0.2932,
+      "log_good": 0.128
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 76.0,
+      "good": 131.0,
+      "ratio": 1.7237,
+      "suggested_scalar": 0.6278,
+      "log_bad": 4.3307,
+      "log_good": 4.8752
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 646.0,
+      "good": 930.0,
+      "ratio": 1.4396,
+      "suggested_scalar": 0.4201,
+      "log_bad": 6.4708,
+      "log_good": 6.8352
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 170.0,
+      "good": 239.0,
+      "ratio": 1.4059,
+      "suggested_scalar": 0.3928,
+      "log_bad": 5.1358,
+      "log_good": 5.4765
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2377,
+      "good": 0.2242,
+      "ratio": 0.9432,
+      "suggested_scalar": -0.0674,
+      "log_bad": -1.4367,
+      "log_good": -1.4952
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 64.0,
+      "good": 75.0,
+      "ratio": 1.1719,
+      "suggested_scalar": 0.1829,
+      "log_bad": 4.1589,
+      "log_good": 4.3175
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 76.0,
+      "good": 131.0,
+      "ratio": 1.7237,
+      "suggested_scalar": 0.6278,
+      "log_bad": 4.3307,
+      "log_good": 4.8752
+    },
+    "brevity.mean_sample_size": {
+      "bad": 76.0,
+      "good": 131.0,
+      "ratio": 1.7237,
+      "suggested_scalar": 0.6278,
+      "log_bad": 4.3307,
+      "log_good": 4.8752
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 366.0,
+      "good": 495.0,
+      "ratio": 1.3525,
+      "suggested_scalar": 0.3481,
+      "log_bad": 5.9026,
+      "log_good": 6.2046
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 171.0,
+      "good": 205.0,
+      "ratio": 1.1988,
+      "suggested_scalar": 0.2091,
+      "log_bad": 5.1417,
+      "log_good": 5.323
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 199.0,
+      "good": 338.0,
+      "ratio": 1.6985,
+      "suggested_scalar": 0.6108,
+      "log_bad": 5.2933,
+      "log_good": 5.823
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.567,
+      "good": 2.4463,
+      "ratio": 0.953,
+      "suggested_scalar": -0.0555,
+      "log_bad": 0.9427,
+      "log_good": 0.8946
+    },
+    "halstead.mean_effort": {
+      "bad": 79536.6225,
+      "good": 135811.2224,
+      "ratio": 1.7075,
+      "suggested_scalar": 0.6169,
+      "log_bad": 11.284,
+      "log_good": 11.819
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8846,
+      "good": 0.8722,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0163,
+      "log_bad": -0.1226,
+      "log_good": -0.1367
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 55.0,
+      "good": 99.0,
+      "ratio": 1.8,
+      "suggested_scalar": 0.6777,
+      "log_bad": 4.0073,
+      "log_good": 4.5951
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 186.0,
+      "good": 245.0,
+      "ratio": 1.3172,
+      "suggested_scalar": 0.3177,
+      "log_bad": 5.2257,
+      "log_good": 5.5013
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3034,
+      "good": 0.4183,
+      "ratio": 1.3787,
+      "suggested_scalar": 0.3703,
+      "log_bad": -1.1927,
+      "log_good": -0.8716
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.4552,
+      "good": 4.4712,
+      "ratio": 1.0036,
+      "suggested_scalar": 0.0041,
+      "log_bad": 1.4941,
+      "log_good": 1.4977
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1642,
+      "good": 0.1528,
+      "ratio": 0.9306,
+      "suggested_scalar": -0.083,
+      "log_bad": -1.8067,
+      "log_good": -1.8786
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.6143,
+      "good": 3.2459,
+      "ratio": 1.2416,
+      "suggested_scalar": 0.2495,
+      "log_bad": 0.961,
+      "log_good": 1.1774
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 365.0,
+      "good": 494.0,
+      "ratio": 1.3534,
+      "suggested_scalar": 0.3489,
+      "log_bad": 5.8999,
+      "log_good": 6.2025
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 54.0,
+      "good": 51.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.0659,
+      "log_bad": 3.989,
+      "log_good": 3.9318
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4418.7012,
+      "good": 7545.0679,
+      "ratio": 1.7075,
+      "suggested_scalar": 0.6169,
+      "log_bad": 8.3936,
+      "log_good": 8.9286
+    },
+    "readability.mean_total_lines": {
+      "bad": 56.0,
+      "good": 61.0,
+      "ratio": 1.0893,
+      "suggested_scalar": 0.0986,
+      "log_bad": 4.0254,
+      "log_good": 4.1109
+    },
+    "indentation.mean_max_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_volume": {
+      "bad": 2237.6032,
+      "good": 3409.4868,
+      "ratio": 1.5237,
+      "suggested_scalar": 0.4856,
+      "log_bad": 7.7132,
+      "log_good": 8.1343
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 495.0,
+      "good": 797.0,
+      "ratio": 1.6101,
+      "suggested_scalar": 0.5492,
+      "log_bad": 6.2046,
+      "log_good": 6.6809
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 22.0893,
+      "good": 28.5902,
+      "ratio": 1.2943,
+      "suggested_scalar": 0.2974,
+      "log_bad": 3.0951,
+      "log_good": 3.3531
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0515,
+      "good": 1.045,
+      "ratio": 0.9938,
+      "suggested_scalar": -0.0071,
+      "log_bad": 0.0502,
+      "log_good": 0.044
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 26.0,
+      "good": 39.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.4675,
+      "log_bad": 3.2581,
+      "log_good": 3.6636
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 8.0,
+      "good": 13.0,
+      "ratio": 1.625,
+      "suggested_scalar": 0.5598,
+      "log_bad": 2.0794,
+      "log_good": 2.5649
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7823,
+      "good": 0.8765,
+      "ratio": 1.1204,
+      "suggested_scalar": 0.1311,
+      "log_bad": -0.2455,
+      "log_good": -0.1318
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9783,
+      "good": 0.9815,
+      "ratio": 1.0033,
+      "suggested_scalar": 0.0038,
+      "log_bad": -0.0219,
+      "log_good": -0.0187
+    },
+    "halstead.mean_length": {
+      "bad": 356.0,
+      "good": 484.0,
+      "ratio": 1.3596,
+      "suggested_scalar": 0.3541,
+      "log_bad": 5.8749,
+      "log_good": 6.1821
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.1667,
+      "good": 9.8333,
+      "ratio": 1.0727,
+      "suggested_scalar": 0.0809,
+      "log_bad": 2.2156,
+      "log_good": 2.2858
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2479,
+      "good": 7.0334,
+      "ratio": 1.1257,
+      "suggested_scalar": 0.1365,
+      "log_bad": 1.8322,
+      "log_good": 1.9507
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1311,
+      "good": 0.1129,
+      "ratio": 0.8612,
+      "suggested_scalar": -0.1723,
+      "log_bad": -2.0318,
+      "log_good": -2.1813
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 35.5455,
+      "good": 39.8333,
+      "ratio": 1.1206,
+      "suggested_scalar": 0.1313,
+      "log_bad": 3.5708,
+      "log_good": 3.6847
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 17.0,
+      "ratio": 5.6667,
+      "suggested_scalar": 2.0,
+      "log_bad": 1.0986,
+      "log_good": 2.8332
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 44.0,
+      "good": 87.0,
+      "ratio": 1.9773,
+      "suggested_scalar": 0.786,
+      "log_bad": 3.7842,
+      "log_good": 4.4659
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6784,
+      "good": 0.7781,
+      "ratio": 1.147,
+      "suggested_scalar": 0.1581,
+      "log_bad": -0.388,
+      "log_good": -0.2509
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 56.0,
+      "good": 61.0,
+      "ratio": 1.0893,
+      "suggested_scalar": 0.0986,
+      "log_bad": 4.0254,
+      "log_good": 4.1109
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 11.0,
+      "good": 10.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.1099,
+      "log_bad": 2.3979,
+      "log_good": 2.3026
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.has_verb_in_name": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 47.0,
+      "good": 47.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8501,
+      "log_good": 3.8501
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0248,
+      "good": 0.0248,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.6969,
+      "log_good": -3.6969
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.2222,
+      "good": 1.2222,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2007,
+      "log_good": 0.2007
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.4894,
+      "good": 0.4894,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.7146,
+      "log_good": -0.7146
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0248,
+      "good": 0.0248,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.6969,
+      "log_good": -3.6969
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6192,
+      "good": 4.6271,
+      "ratio": 1.0017,
+      "suggested_scalar": 0.0115,
+      "log_bad": 1.5302,
+      "log_good": 1.5319
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 59.0,
+      "good": 59.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0775,
+      "log_good": 4.0775
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3074,
+      "good": 0.3074,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.1796,
+      "log_good": -1.1796
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.3983,
+      "good": 0.3983,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.9205,
+      "log_good": -0.9205
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.7447,
+      "good": 3.7447,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3203,
+      "log_good": 1.3203
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 483.0,
+      "good": 483.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.18,
+      "log_good": 6.18
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0052,
+      "good": 0.0051,
+      "ratio": 0.9808,
+      "suggested_scalar": -0.1305,
+      "log_bad": -5.2591,
+      "log_good": -5.2785
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.3244,
+      "good": 1.3244,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.281,
+      "log_good": 0.281
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 130.0,
+      "good": 130.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.8675,
+      "log_good": 4.8675
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 99.5843,
+      "good": 97.2343,
+      "ratio": 0.9764,
+      "suggested_scalar": -0.1605,
+      "log_bad": 4.601,
+      "log_good": 4.5771
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.8091,
+      "good": 0.8091,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2118,
+      "log_good": -0.2118
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.1422,
+      "good": 15.0029,
+      "ratio": 1.3465,
+      "suggested_scalar": 2.0,
+      "log_bad": 2.4107,
+      "log_good": 2.7082
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1550.0,
+      "good": 1573.0,
+      "ratio": 1.0148,
+      "suggested_scalar": 0.099,
+      "log_bad": 7.346,
+      "log_good": 7.3607
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1489,
+      "good": 0.1489,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.9045,
+      "log_good": -1.9045
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.4468,
+      "good": 0.4468,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.8056,
+      "log_good": -0.8056
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.2766,
+      "good": 10.2766,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3299,
+      "log_good": 2.3299
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.1689,
+      "good": 3.1689,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.1534,
+      "log_good": 1.1534
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 120.0,
+      "good": 120.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.7875,
+      "log_good": 4.7875
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.8746,
+      "good": 0.8746,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.134,
+      "log_good": -0.134
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.7555,
+      "good": 0.7502,
+      "ratio": 0.993,
+      "suggested_scalar": -0.0473,
+      "log_bad": -0.2804,
+      "log_good": -0.2874
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.7256,
+      "good": 0.7256,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3208,
+      "log_good": -0.3208
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 4.0897,
+      "good": 4.0025,
+      "ratio": 0.9787,
+      "suggested_scalar": -0.1449,
+      "log_bad": 1.4085,
+      "log_good": 1.3869
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 481.0,
+      "good": 481.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.1759,
+      "log_good": 6.1759
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0083,
+      "good": 0.0083,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.7915,
+      "log_good": -4.7915
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.4263,
+      "good": 5.4263,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6913,
+      "log_good": 1.6913
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.4273,
+      "good": 0.4273,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.8503,
+      "log_good": -0.8503
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 4.9446,
+      "good": 4.9446,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.5983,
+      "log_good": 1.5983
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8513,
+      "good": 0.8527,
+      "ratio": 1.0016,
+      "suggested_scalar": 0.011,
+      "log_bad": -0.161,
+      "log_good": -0.1593
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1296,
+      "good": 0.1296,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.0433,
+      "log_good": -2.0433
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.338,
+      "good": 3.8734,
+      "ratio": 1.1604,
+      "suggested_scalar": 1.0001,
+      "log_bad": 1.2054,
+      "log_good": 1.3541
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 188.0,
+      "good": 188.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.2364,
+      "log_good": 5.2364
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8412,
+      "good": 0.8412,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1729,
+      "log_good": -0.1729
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 62.0,
+      "good": 62.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.1271,
+      "log_good": 4.1271
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 766.0,
+      "good": 789.0,
+      "ratio": 1.03,
+      "suggested_scalar": 0.1989,
+      "log_bad": 6.6412,
+      "log_good": 6.6708
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 123.0,
+      "good": 123.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.8122,
+      "log_good": 4.8122
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.029,
+      "good": 0.029,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.5405,
+      "log_good": -3.5405
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2712,
+      "good": 0.2712,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.3049,
+      "log_good": -1.3049
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 58.0,
+      "good": 58.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0604,
+      "log_good": 4.0604
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 62.0,
+      "good": 62.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.1271,
+      "log_good": 4.1271
+    },
+    "brevity.mean_sample_size": {
+      "bad": 62.0,
+      "good": 62.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.1271,
+      "log_good": 4.1271
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 483.0,
+      "good": 483.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.18,
+      "log_good": 6.18
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 303.0,
+      "good": 303.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.7137,
+      "log_good": 5.7137
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 150.0,
+      "good": 150.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.0106,
+      "log_good": 5.0106
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 4.9336,
+      "good": 4.9336,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.5961,
+      "log_good": 1.5961
+    },
+    "halstead.mean_effort": {
+      "bad": 73722.2386,
+      "good": 73722.2386,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 11.2081,
+      "log_good": 11.2081
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8304,
+      "good": 0.8304,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1858,
+      "log_good": -0.1858
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 40.0,
+      "good": 40.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6889,
+      "log_good": 3.6889
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 306.0,
+      "good": 306.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.7236,
+      "log_good": 5.7236
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3,
+      "good": 0.3,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.204,
+      "log_good": -1.204
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.8923,
+      "good": 6.0692,
+      "ratio": 1.03,
+      "suggested_scalar": 0.1989,
+      "log_bad": 1.7736,
+      "log_good": 1.8032
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1296,
+      "good": 0.1296,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.0433,
+      "log_good": -2.0433
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.1106,
+      "good": 5.2217,
+      "ratio": 1.2703,
+      "suggested_scalar": 1.6084,
+      "log_bad": 1.4136,
+      "log_good": 1.6528
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 482.0,
+      "good": 482.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.1779,
+      "log_good": 6.1779
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 56.0,
+      "good": 56.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0254,
+      "log_good": 4.0254
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4095.6799,
+      "good": 4095.6799,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 8.3177,
+      "log_good": 8.3177
+    },
+    "readability.mean_total_lines": {
+      "bad": 47.0,
+      "good": 47.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8501,
+      "log_good": 3.8501
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2523.6539,
+      "good": 2523.6539,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 7.8335,
+      "log_good": 7.8335
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 379.0,
+      "good": 393.0,
+      "ratio": 1.0369,
+      "suggested_scalar": 0.2439,
+      "log_bad": 5.9375,
+      "log_good": 5.9738
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.8298,
+      "good": 32.3191,
+      "ratio": 1.0154,
+      "suggested_scalar": 0.1026,
+      "log_bad": 3.4604,
+      "log_good": 3.4757
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1444,
+      "good": 1.1722,
+      "ratio": 1.0243,
+      "suggested_scalar": 0.1614,
+      "log_bad": 0.1349,
+      "log_good": 0.1589
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7021,
+      "good": 0.7021,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3537,
+      "log_good": -0.3537
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9374,
+      "good": 0.9374,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0646,
+      "log_good": -0.0646
+    },
+    "halstead.mean_length": {
+      "bad": 429.0,
+      "good": 429.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.0615,
+      "log_good": 6.0615
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.8889,
+      "good": 5.8889,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7731,
+      "log_good": 1.7731
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.9542,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7841,
+      "log_good": 1.7841
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1955,
+      "good": 0.1926,
+      "ratio": 0.9852,
+      "suggested_scalar": -0.1005,
+      "log_bad": -1.6322,
+      "log_good": -1.6471
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.2125,
+      "good": 29.2125,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3746,
+      "log_good": 3.3746
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 39.0,
+      "good": 39.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6636,
+      "log_good": 3.6636
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6133,
+      "good": 0.6133,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.4889,
+      "log_good": -0.4889
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 47.0,
+      "good": 47.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8501,
+      "log_good": 3.8501
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 20.0,
+      "good": 23.0,
+      "ratio": 1.15,
+      "suggested_scalar": 0.9396,
+      "log_bad": 2.9957,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.does_not_swallow_errors": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 27.0,
+      "good": 40.0,
+      "ratio": 1.4815,
+      "suggested_scalar": 0.3065,
+      "log_bad": 3.2958,
+      "log_good": 3.6889
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0157,
+      "good": 0.0217,
+      "ratio": 1.3822,
+      "suggested_scalar": 0.2524,
+      "log_bad": -4.1541,
+      "log_good": -3.8304
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1111,
+      "good": 1.1111,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1054,
+      "log_good": 0.1054
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.6447,
+      "good": 0.7356,
+      "ratio": 1.141,
+      "suggested_scalar": 0.1028,
+      "log_bad": -0.439,
+      "log_good": -0.3071
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0157,
+      "good": 0.0217,
+      "ratio": 1.3822,
+      "suggested_scalar": 0.2524,
+      "log_bad": -4.1541,
+      "log_good": -3.8304
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.2746,
+      "good": 4.5257,
+      "ratio": 1.0587,
+      "suggested_scalar": 0.0445,
+      "log_bad": 1.4527,
+      "log_good": 1.5098
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 74.0,
+      "good": 98.0,
+      "ratio": 1.3243,
+      "suggested_scalar": 0.219,
+      "log_bad": 4.3041,
+      "log_good": 4.585
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.45,
+      "good": 0.4611,
+      "ratio": 1.0247,
+      "suggested_scalar": 0.019,
+      "log_bad": -0.7985,
+      "log_good": -0.7741
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 20.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.04,
+      "log_bad": 2.9444,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5985,
+      "good": 0.5354,
+      "ratio": 0.8946,
+      "suggested_scalar": -0.0869,
+      "log_bad": -0.5133,
+      "log_good": -0.6247
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.2632,
+      "good": 4.8736,
+      "ratio": 1.1432,
+      "suggested_scalar": 0.1043,
+      "log_bad": 1.45,
+      "log_good": 1.5838
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 319.0,
+      "good": 600.0,
+      "ratio": 1.8809,
+      "suggested_scalar": 0.4926,
+      "log_bad": 5.7652,
+      "log_good": 6.3969
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.5405,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0041,
+      "good": 0.0021,
+      "ratio": 0.5122,
+      "suggested_scalar": -0.5217,
+      "log_bad": -5.4968,
+      "log_good": -6.1658
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0007,
+      "good": 0.0004,
+      "ratio": 0.5714,
+      "suggested_scalar": -0.4364,
+      "log_bad": -7.2644,
+      "log_good": -7.824
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0102,
+      "good": 1.1386,
+      "ratio": 1.1271,
+      "suggested_scalar": 0.0933,
+      "log_bad": 0.0101,
+      "log_good": 0.1298
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 102.0,
+      "good": 206.0,
+      "ratio": 2.0196,
+      "suggested_scalar": 0.5481,
+      "log_bad": 4.625,
+      "log_good": 5.3279
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 113.1126,
+      "good": 107.8248,
+      "ratio": 0.9533,
+      "suggested_scalar": -0.0373,
+      "log_bad": 4.7284,
+      "log_good": 4.6805
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6289,
+      "good": 0.7145,
+      "ratio": 1.1361,
+      "suggested_scalar": 0.0995,
+      "log_bad": -0.4638,
+      "log_good": -0.3362
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 14.6674,
+      "good": 10.6376,
+      "ratio": 0.7253,
+      "suggested_scalar": -0.2505,
+      "log_bad": 2.6856,
+      "log_good": 2.3644
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1453.0,
+      "good": 2371.0,
+      "ratio": 1.6318,
+      "suggested_scalar": 0.3818,
+      "log_bad": 7.2814,
+      "log_good": 7.7711
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2105,
+      "good": 0.1609,
+      "ratio": 0.7644,
+      "suggested_scalar": -0.2095,
+      "log_bad": -1.5583,
+      "log_good": -1.827
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.5658,
+      "good": 0.6782,
+      "ratio": 1.1987,
+      "suggested_scalar": 0.1413,
+      "log_bad": -0.5695,
+      "log_good": -0.3883
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 4.1974,
+      "good": 6.8966,
+      "ratio": 1.6431,
+      "suggested_scalar": 0.3872,
+      "log_bad": 1.4345,
+      "log_good": 1.931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 8.0,
+      "good": 1.0,
+      "ratio": 0.125,
+      "suggested_scalar": -1.6214,
+      "log_bad": 2.0794,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.7202,
+      "good": 5.7656,
+      "ratio": 1.5498,
+      "suggested_scalar": 0.3416,
+      "log_bad": 1.3138,
+      "log_good": 1.7519
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 79.0,
+      "good": 161.0,
+      "ratio": 2.038,
+      "suggested_scalar": 0.5551,
+      "log_bad": 4.3694,
+      "log_good": 5.0814
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.939,
+      "good": 0.9385,
+      "ratio": 0.9995,
+      "suggested_scalar": -0.0004,
+      "log_bad": -0.0629,
+      "log_good": -0.0635
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 33.0,
+      "ratio": 1.2692,
+      "suggested_scalar": 0.1859,
+      "log_bad": 3.2581,
+      "log_good": 3.4965
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6662,
+      "good": 0.6837,
+      "ratio": 1.0263,
+      "suggested_scalar": 0.0202,
+      "log_bad": -0.4062,
+      "log_good": -0.3802
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4196,
+      "good": 0.5635,
+      "ratio": 1.3429,
+      "suggested_scalar": 0.2299,
+      "log_bad": -0.8685,
+      "log_good": -0.5736
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9959,
+      "good": 3.1613,
+      "ratio": 1.0552,
+      "suggested_scalar": 0.0419,
+      "log_bad": 1.0972,
+      "log_good": 1.151
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 317.0,
+      "good": 598.0,
+      "ratio": 1.8864,
+      "suggested_scalar": 0.4949,
+      "log_bad": 5.7589,
+      "log_good": 6.3936
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 16.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.2243,
+      "log_bad": 2.4849,
+      "log_good": 2.7726
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0063,
+      "good": 0.0083,
+      "ratio": 1.3175,
+      "suggested_scalar": 0.215,
+      "log_bad": -5.0672,
+      "log_good": -4.7915
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.6724,
+      "good": 5.9307,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.0347,
+      "log_bad": 1.7356,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 15.0,
+      "good": 44.0,
+      "ratio": 2.9333,
+      "suggested_scalar": 0.8391,
+      "log_bad": 2.7081,
+      "log_good": 3.7842
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9802,
+      "good": 0.7909,
+      "ratio": 0.8069,
+      "suggested_scalar": -0.1673,
+      "log_bad": -0.02,
+      "log_good": -0.2346
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4851,
+      "good": 5.6441,
+      "ratio": 1.029,
+      "suggested_scalar": 0.0223,
+      "log_bad": 1.702,
+      "log_good": 1.7306
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7536,
+      "good": 0.7631,
+      "ratio": 1.0126,
+      "suggested_scalar": 0.0098,
+      "log_bad": -0.2829,
+      "log_good": -0.2704
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1059,
+      "good": 0.1122,
+      "ratio": 1.0595,
+      "suggested_scalar": 0.0451,
+      "log_bad": -2.2453,
+      "log_good": -2.1875
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.8298,
+      "good": 3.2615,
+      "ratio": 0.8516,
+      "suggested_scalar": -0.1252,
+      "log_bad": 1.3428,
+      "log_good": 1.1822
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 227.0,
+      "good": 350.0,
+      "ratio": 1.5419,
+      "suggested_scalar": 0.3376,
+      "log_bad": 5.425,
+      "log_good": 5.8579
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 13.0,
+      "ratio": 13.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 2.5649
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6127,
+      "good": 1.1002,
+      "ratio": 1.7957,
+      "suggested_scalar": 0.4564,
+      "log_bad": -0.4899,
+      "log_good": 0.0955
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 80.0,
+      "good": 115.0,
+      "ratio": 1.4375,
+      "suggested_scalar": 0.283,
+      "log_bad": 4.382,
+      "log_good": 4.7449
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 592.0,
+      "good": 1174.0,
+      "ratio": 1.9831,
+      "suggested_scalar": 0.5339,
+      "log_bad": 6.3835,
+      "log_good": 7.0682
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 111.0,
+      "good": 161.0,
+      "ratio": 1.4505,
+      "suggested_scalar": 0.29,
+      "log_bad": 4.7095,
+      "log_good": 5.0814
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0251,
+      "good": 0.0167,
+      "ratio": 0.6653,
+      "suggested_scalar": -0.3177,
+      "log_bad": -3.6849,
+      "log_good": -4.0923
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2508,
+      "good": 0.2567,
+      "ratio": 1.0235,
+      "suggested_scalar": 0.0181,
+      "log_bad": -1.3831,
+      "log_good": -1.3598
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 55.0,
+      "good": 92.0,
+      "ratio": 1.6727,
+      "suggested_scalar": 0.4011,
+      "log_bad": 4.0073,
+      "log_good": 4.5218
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 80.0,
+      "good": 115.0,
+      "ratio": 1.4375,
+      "suggested_scalar": 0.283,
+      "log_bad": 4.382,
+      "log_good": 4.7449
+    },
+    "brevity.mean_sample_size": {
+      "bad": 80.0,
+      "good": 115.0,
+      "ratio": 1.4375,
+      "suggested_scalar": 0.283,
+      "log_bad": 4.382,
+      "log_good": 4.7449
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 319.0,
+      "good": 600.0,
+      "ratio": 1.8809,
+      "suggested_scalar": 0.4926,
+      "log_bad": 5.7652,
+      "log_good": 6.3969
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 143.0,
+      "good": 324.0,
+      "ratio": 2.2657,
+      "suggested_scalar": 0.6378,
+      "log_bad": 4.9628,
+      "log_good": 5.7807
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 173.0,
+      "good": 263.0,
+      "ratio": 1.5202,
+      "suggested_scalar": 0.3266,
+      "log_bad": 5.1533,
+      "log_good": 5.5722
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.801,
+      "good": 3.8428,
+      "ratio": 1.3719,
+      "suggested_scalar": 0.2466,
+      "log_bad": 1.03,
+      "log_good": 1.3462
+    },
+    "halstead.mean_effort": {
+      "bad": 55254.8208,
+      "good": 134898.7134,
+      "ratio": 2.4414,
+      "suggested_scalar": 0.696,
+      "log_bad": 10.9197,
+      "log_good": 11.8123
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8676,
+      "good": 0.8245,
+      "ratio": 0.9503,
+      "suggested_scalar": -0.0397,
+      "log_bad": -0.142,
+      "log_good": -0.193
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 48.0,
+      "good": 65.0,
+      "ratio": 1.3542,
+      "suggested_scalar": 0.2364,
+      "log_bad": 3.8712,
+      "log_good": 4.1744
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 185.0,
+      "good": 338.0,
+      "ratio": 1.827,
+      "suggested_scalar": 0.4699,
+      "log_bad": 5.2204,
+      "log_good": 5.823
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.451,
+      "good": 0.3738,
+      "ratio": 0.8288,
+      "suggested_scalar": -0.1464,
+      "log_bad": -0.7963,
+      "log_good": -0.984
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.8039,
+      "good": 5.699,
+      "ratio": 0.9819,
+      "suggested_scalar": -0.0142,
+      "log_bad": 1.7585,
+      "log_good": 1.7403
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1059,
+      "good": 0.1122,
+      "ratio": 1.0595,
+      "suggested_scalar": 0.0451,
+      "log_bad": -2.2453,
+      "log_good": -2.1875
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.3686,
+      "good": 3.4885,
+      "ratio": 1.4728,
+      "suggested_scalar": 0.3019,
+      "log_bad": 0.8623,
+      "log_good": 1.2495
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 318.0,
+      "good": 599.0,
+      "ratio": 1.8836,
+      "suggested_scalar": 0.4937,
+      "log_bad": 5.7621,
+      "log_good": 6.3953
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 8.0,
+      "good": 22.0,
+      "ratio": 2.75,
+      "suggested_scalar": 0.7888,
+      "log_bad": 2.0794,
+      "log_good": 3.091
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 43.0,
+      "good": 89.0,
+      "ratio": 2.0698,
+      "suggested_scalar": 0.5672,
+      "log_bad": 3.7612,
+      "log_good": 4.4886
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3069.7123,
+      "good": 7494.373,
+      "ratio": 2.4414,
+      "suggested_scalar": 0.696,
+      "log_bad": 8.0293,
+      "log_good": 8.9219
+    },
+    "readability.mean_total_lines": {
+      "bad": 76.0,
+      "good": 87.0,
+      "ratio": 1.1447,
+      "suggested_scalar": 0.1054,
+      "log_bad": 4.3307,
+      "log_good": 4.4659
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 10.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.174,
+      "log_bad": 2.0794,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 1837.9982,
+      "good": 3300.7402,
+      "ratio": 1.7958,
+      "suggested_scalar": 0.4565,
+      "log_bad": 7.5164,
+      "log_good": 8.1019
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 485.0,
+      "good": 750.0,
+      "ratio": 1.5464,
+      "suggested_scalar": 0.3399,
+      "log_bad": 6.1841,
+      "log_good": 6.6201
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 18.0,
+      "good": 26.1264,
+      "ratio": 1.4515,
+      "suggested_scalar": 0.2905,
+      "log_bad": 2.8904,
+      "log_good": 3.2629
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0575,
+      "good": 1.0876,
+      "ratio": 1.0285,
+      "suggested_scalar": 0.0219,
+      "log_bad": 0.0559,
+      "log_good": 0.084
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.5405,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 17.0,
+      "good": 33.0,
+      "ratio": 1.9412,
+      "suggested_scalar": 0.5172,
+      "log_bad": 2.8332,
+      "log_good": 3.4965
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8106,
+      "good": 0.7457,
+      "ratio": 0.9199,
+      "suggested_scalar": -0.0651,
+      "log_bad": -0.21,
+      "log_good": -0.2934
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9705,
+      "good": 0.9739,
+      "ratio": 1.0035,
+      "suggested_scalar": 0.0027,
+      "log_bad": -0.0299,
+      "log_good": -0.0264
+    },
+    "halstead.mean_length": {
+      "bad": 296.0,
+      "good": 499.0,
+      "ratio": 1.6858,
+      "suggested_scalar": 0.4072,
+      "log_bad": 5.6904,
+      "log_good": 6.2126
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 8.8889,
+      "good": 10.1111,
+      "ratio": 1.1375,
+      "suggested_scalar": 0.1005,
+      "log_bad": 2.1848,
+      "log_good": 2.3136
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.3219,
+      "good": 6.8455,
+      "ratio": 1.0828,
+      "suggested_scalar": 0.062,
+      "log_bad": 1.844,
+      "log_good": 1.9236
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0984,
+      "good": 0.1367,
+      "ratio": 1.3892,
+      "suggested_scalar": 0.2563,
+      "log_bad": -2.3187,
+      "log_good": -1.99
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.0625,
+      "good": 40.8692,
+      "ratio": 1.3595,
+      "suggested_scalar": 0.2395,
+      "log_bad": 3.4033,
+      "log_good": 3.7104
+    },
+    "branching.mean_branch_count": {
+      "bad": 16.0,
+      "good": 14.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.1041,
+      "log_bad": 2.7726,
+      "log_good": 2.6391
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 46.0,
+      "good": 77.0,
+      "ratio": 1.6739,
+      "suggested_scalar": 0.4017,
+      "log_bad": 3.8286,
+      "log_good": 4.3438
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6821,
+      "good": 0.6502,
+      "ratio": 0.9532,
+      "suggested_scalar": -0.0373,
+      "log_bad": -0.3826,
+      "log_good": -0.4305
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 76.0,
+      "good": 87.0,
+      "ratio": 1.1447,
+      "suggested_scalar": 0.1054,
+      "log_bad": 4.3307,
+      "log_good": 4.4659
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "scope_and_assignment.no_var_declarations": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 9.0,
+      "good": 22.0,
+      "ratio": 2.4444,
+      "suggested_scalar": 0.3022,
+      "log_bad": 2.1972,
+      "log_good": 3.091
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 8.0,
+      "good": 10.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0755,
+      "log_bad": 2.0794,
+      "log_good": 2.3026
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1371,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0258,
+      "good": 0.0264,
+      "ratio": 1.0233,
+      "suggested_scalar": 0.0078,
+      "log_bad": -3.6574,
+      "log_good": -3.6344
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3333,
+      "good": 1.75,
+      "ratio": 1.3125,
+      "suggested_scalar": 0.092,
+      "log_bad": 0.2877,
+      "log_good": 0.5596
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8519,
+      "good": 0.9318,
+      "ratio": 1.0938,
+      "suggested_scalar": 0.0303,
+      "log_bad": -0.1603,
+      "log_good": -0.0706
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0258,
+      "good": 0.0264,
+      "ratio": 1.0233,
+      "suggested_scalar": 0.0078,
+      "log_bad": -3.6574,
+      "log_good": -3.6344
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6977,
+      "good": 4.8093,
+      "ratio": 1.0238,
+      "suggested_scalar": 0.0079,
+      "log_bad": 1.5471,
+      "log_good": 1.5706
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 82.0,
+      "good": 91.0,
+      "ratio": 1.1098,
+      "suggested_scalar": 0.0352,
+      "log_bad": 4.4067,
+      "log_good": 4.5109
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3427,
+      "good": 0.4292,
+      "ratio": 1.2524,
+      "suggested_scalar": 0.0761,
+      "log_bad": -1.0709,
+      "log_good": -0.8458
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.0,
+      "good": 20.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0165,
+      "log_bad": 3.0445,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6224,
+      "good": 0.607,
+      "ratio": 0.9753,
+      "suggested_scalar": -0.0085,
+      "log_bad": -0.4742,
+      "log_good": -0.4992
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.8148,
+      "good": 2.7727,
+      "ratio": 0.7268,
+      "suggested_scalar": -0.1079,
+      "log_bad": 1.3389,
+      "log_good": 1.0198
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 465.0,
+      "good": 454.0,
+      "ratio": 0.9763,
+      "suggested_scalar": -0.0081,
+      "log_bad": 6.142,
+      "log_good": 6.1181
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.002,
+      "good": 0.0014,
+      "ratio": 0.7,
+      "suggested_scalar": -0.1206,
+      "log_bad": -6.2146,
+      "log_good": -6.5713
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 0.0027,
+      "ratio": 0.0027,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.9145
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.119,
+      "good": 1.0564,
+      "ratio": 0.9441,
+      "suggested_scalar": -0.0195,
+      "log_bad": 0.1124,
+      "log_good": 0.0549
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 121.0,
+      "good": 124.0,
+      "ratio": 1.0248,
+      "suggested_scalar": 0.0083,
+      "log_bad": 4.7958,
+      "log_good": 4.8203
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 107.4519,
+      "good": 99.1728,
+      "ratio": 0.923,
+      "suggested_scalar": -0.0271,
+      "log_bad": 4.677,
+      "log_good": 4.5969
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6121,
+      "good": 0.5276,
+      "ratio": 0.862,
+      "suggested_scalar": -0.0502,
+      "log_bad": -0.4909,
+      "log_good": -0.6394
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.3057,
+      "good": 9.0598,
+      "ratio": 1.0908,
+      "suggested_scalar": 0.0294,
+      "log_bad": 2.1169,
+      "log_good": 2.2038
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1496.0,
+      "good": 1464.0,
+      "ratio": 0.9786,
+      "suggested_scalar": -0.0073,
+      "log_bad": 7.3106,
+      "log_good": 7.2889
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2407,
+      "good": 0.1136,
+      "ratio": 0.472,
+      "suggested_scalar": -0.2539,
+      "log_bad": -1.4242,
+      "log_good": -2.1751
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7778,
+      "good": 0.8636,
+      "ratio": 1.1103,
+      "suggested_scalar": 0.0354,
+      "log_bad": -0.2513,
+      "log_good": -0.1466
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.6111,
+      "good": 10.3182,
+      "ratio": 1.1982,
+      "suggested_scalar": 0.0612,
+      "log_bad": 2.1531,
+      "log_good": 2.3339
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 7.299,
+      "good": 4.4029,
+      "ratio": 0.6032,
+      "suggested_scalar": -0.1709,
+      "log_bad": 1.9877,
+      "log_good": 1.4823
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 110.0,
+      "good": 96.0,
+      "ratio": 0.8727,
+      "suggested_scalar": -0.046,
+      "log_bad": 4.7005,
+      "log_good": 4.5643
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9186,
+      "good": 0.9579,
+      "ratio": 1.0428,
+      "suggested_scalar": 0.0142,
+      "log_bad": -0.0849,
+      "log_good": -0.043
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 28.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0233,
+      "log_bad": 3.4012,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6063,
+      "good": 0.5745,
+      "ratio": 0.9476,
+      "suggested_scalar": -0.0182,
+      "log_bad": -0.5004,
+      "log_good": -0.5543
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.378,
+      "good": 0.2832,
+      "ratio": 0.7492,
+      "suggested_scalar": -0.0976,
+      "log_bad": -0.9729,
+      "log_good": -1.2616
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5399,
+      "good": 2.3499,
+      "ratio": 0.9252,
+      "suggested_scalar": -0.0263,
+      "log_bad": 0.9321,
+      "log_good": 0.8544
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 463.0,
+      "good": 452.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0081,
+      "log_bad": 6.1377,
+      "log_good": 6.1137
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 26.0,
+      "good": 18.0,
+      "ratio": 0.6923,
+      "suggested_scalar": -0.1243,
+      "log_bad": 3.2581,
+      "log_good": 2.8904
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.9542,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7841,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 0.4688,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.5017,
+      "good": 0.9843,
+      "ratio": 1.9619,
+      "suggested_scalar": 0.2279,
+      "log_bad": -0.6898,
+      "log_good": -0.0158
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0165,
+      "good": 0.0161,
+      "ratio": 0.9758,
+      "suggested_scalar": -0.0083,
+      "log_bad": -4.1044,
+      "log_good": -4.1289
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.3792,
+      "good": 5.3745,
+      "ratio": 0.9991,
+      "suggested_scalar": -0.0003,
+      "log_bad": 1.6825,
+      "log_good": 1.6817
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.789,
+      "good": 0.8077,
+      "ratio": 1.0237,
+      "suggested_scalar": 0.0079,
+      "log_bad": -0.237,
+      "log_good": -0.2136
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1563,
+      "good": 0.2281,
+      "ratio": 1.4594,
+      "suggested_scalar": 0.1278,
+      "log_bad": -1.856,
+      "log_good": -1.478
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.882,
+      "good": 3.01,
+      "ratio": 1.0444,
+      "suggested_scalar": 0.0147,
+      "log_bad": 1.0585,
+      "log_good": 1.1019
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 347.0,
+      "good": 369.0,
+      "ratio": 1.0634,
+      "suggested_scalar": 0.0208,
+      "log_bad": 5.8493,
+      "log_good": 5.9108
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 25.0,
+      "good": 23.0,
+      "ratio": 0.92,
+      "suggested_scalar": -0.0282,
+      "log_bad": 3.2189,
+      "log_good": 3.1355
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9303,
+      "good": 0.9154,
+      "ratio": 0.984,
+      "suggested_scalar": -0.0055,
+      "log_bad": -0.0722,
+      "log_good": -0.0884
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 77.0,
+      "good": 86.0,
+      "ratio": 1.1169,
+      "suggested_scalar": 0.0374,
+      "log_bad": 4.3438,
+      "log_good": 4.4543
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 606.0,
+      "good": 668.0,
+      "ratio": 1.1023,
+      "suggested_scalar": 0.0329,
+      "log_bad": 6.4069,
+      "log_good": 6.5043
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 158.0,
+      "good": 152.0,
+      "ratio": 0.962,
+      "suggested_scalar": -0.0131,
+      "log_bad": 5.0626,
+      "log_good": 5.0239
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 0.0198,
+      "ratio": 0.0198,
+      "suggested_scalar": -1.3263,
+      "log_bad": 0.0,
+      "log_good": -3.9221
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2065,
+      "good": 0.2445,
+      "ratio": 1.184,
+      "suggested_scalar": 0.0571,
+      "log_bad": -1.5775,
+      "log_good": -1.4085
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 74.0,
+      "good": 61.0,
+      "ratio": 0.8243,
+      "suggested_scalar": -0.0653,
+      "log_bad": 4.3041,
+      "log_good": 4.1109
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0973,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 77.0,
+      "good": 86.0,
+      "ratio": 1.1169,
+      "suggested_scalar": 0.0374,
+      "log_bad": 4.3438,
+      "log_good": 4.4543
+    },
+    "brevity.mean_sample_size": {
+      "bad": 77.0,
+      "good": 86.0,
+      "ratio": 1.1169,
+      "suggested_scalar": 0.0374,
+      "log_bad": 4.3438,
+      "log_good": 4.4543
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 465.0,
+      "good": 454.0,
+      "ratio": 0.9763,
+      "suggested_scalar": -0.0081,
+      "log_bad": 6.142,
+      "log_good": 6.1181
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 288.0,
+      "good": 283.0,
+      "ratio": 0.9826,
+      "suggested_scalar": -0.0059,
+      "log_bad": 5.663,
+      "log_good": 5.6454
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 254.0,
+      "good": 275.0,
+      "ratio": 1.0827,
+      "suggested_scalar": 0.0269,
+      "log_bad": 5.5373,
+      "log_good": 5.6168
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.9549,
+      "good": 2.3295,
+      "ratio": 1.1916,
+      "suggested_scalar": 0.0593,
+      "log_bad": 0.6703,
+      "log_good": 0.8457
+    },
+    "halstead.mean_effort": {
+      "bad": 127203.6122,
+      "good": 92763.551,
+      "ratio": 0.7293,
+      "suggested_scalar": -0.1068,
+      "log_bad": 11.7535,
+      "log_good": 11.4378
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8584,
+      "good": 0.8363,
+      "ratio": 0.9743,
+      "suggested_scalar": -0.0088,
+      "log_bad": -0.1527,
+      "log_good": -0.1788
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 52.0,
+      "good": 63.0,
+      "ratio": 1.2115,
+      "suggested_scalar": 0.0649,
+      "log_bad": 3.9512,
+      "log_good": 4.1431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 281.0,
+      "good": 270.0,
+      "ratio": 0.9609,
+      "suggested_scalar": -0.0135,
+      "log_bad": 5.6384,
+      "log_good": 5.5984
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3471,
+      "good": 0.4194,
+      "ratio": 1.2083,
+      "suggested_scalar": 0.064,
+      "log_bad": -1.0581,
+      "log_good": -0.8689
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.0083,
+      "good": 5.3871,
+      "ratio": 1.0756,
+      "suggested_scalar": 0.0247,
+      "log_bad": 1.6111,
+      "log_good": 1.684
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1563,
+      "good": 0.2281,
+      "ratio": 1.4594,
+      "suggested_scalar": 0.1278,
+      "log_bad": -1.856,
+      "log_good": -1.478
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.6825,
+      "good": 4.3654,
+      "ratio": 1.1854,
+      "suggested_scalar": 0.0575,
+      "log_bad": 1.3036,
+      "log_good": 1.4737
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 464.0,
+      "good": 453.0,
+      "ratio": 0.9763,
+      "suggested_scalar": -0.0081,
+      "log_bad": 6.1399,
+      "log_good": 6.1159
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 59.0,
+      "good": 45.0,
+      "ratio": 0.7627,
+      "suggested_scalar": -0.0916,
+      "log_bad": 4.0775,
+      "log_good": 3.8067
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 7066.8673,
+      "good": 5153.5306,
+      "ratio": 0.7293,
+      "suggested_scalar": -0.1068,
+      "log_bad": 8.8632,
+      "log_good": 8.5474
+    },
+    "readability.mean_total_lines": {
+      "bad": 54.0,
+      "good": 44.0,
+      "ratio": 0.8148,
+      "suggested_scalar": -0.0693,
+      "log_bad": 3.989,
+      "log_good": 3.7842
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 8.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0755,
+      "log_bad": 2.3026,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2790.9653,
+      "good": 2746.2893,
+      "ratio": 0.984,
+      "suggested_scalar": -0.0055,
+      "log_bad": 7.9341,
+      "log_good": 7.918
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 589.0,
+      "good": 623.0,
+      "ratio": 1.0577,
+      "suggested_scalar": 0.019,
+      "log_bad": 6.3784,
+      "log_good": 6.4345
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 26.5185,
+      "good": 31.9773,
+      "ratio": 1.2058,
+      "suggested_scalar": 0.0633,
+      "log_bad": 3.2778,
+      "log_good": 3.465
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0714,
+      "good": 1.1488,
+      "ratio": 1.0722,
+      "suggested_scalar": 0.0236,
+      "log_bad": 0.069,
+      "log_good": 0.1387
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 18.0,
+      "good": 34.0,
+      "ratio": 1.8889,
+      "suggested_scalar": 0.2151,
+      "log_bad": 2.8904,
+      "log_good": 3.5264
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.83,
+      "good": 0.878,
+      "ratio": 1.0578,
+      "suggested_scalar": 0.019,
+      "log_bad": -0.1863,
+      "log_good": -0.1301
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9577,
+      "good": 0.9686,
+      "ratio": 1.0114,
+      "suggested_scalar": 0.0038,
+      "log_bad": -0.0432,
+      "log_good": -0.0319
+    },
+    "halstead.mean_length": {
+      "bad": 439.0,
+      "good": 422.0,
+      "ratio": 0.9613,
+      "suggested_scalar": -0.0134,
+      "log_bad": 6.0845,
+      "log_good": 6.045
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 20.6667,
+      "good": 13.75,
+      "ratio": 0.6653,
+      "suggested_scalar": -0.1378,
+      "log_bad": 3.0285,
+      "log_good": 2.621
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2668,
+      "good": 6.4263,
+      "ratio": 1.0255,
+      "suggested_scalar": 0.0085,
+      "log_bad": 1.8353,
+      "log_good": 1.8604
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1925,
+      "good": 0.1933,
+      "ratio": 1.0042,
+      "suggested_scalar": 0.0014,
+      "log_bad": -1.6477,
+      "log_good": -1.6435
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 45.5769,
+      "good": 33.7778,
+      "ratio": 0.7411,
+      "suggested_scalar": -0.1013,
+      "log_bad": 3.8194,
+      "log_good": 3.5198
+    },
+    "branching.mean_branch_count": {
+      "bad": 13.0,
+      "good": 5.0,
+      "ratio": 0.3846,
+      "suggested_scalar": -0.3231,
+      "log_bad": 2.5649,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 42.0,
+      "good": 52.0,
+      "ratio": 1.2381,
+      "suggested_scalar": 0.0722,
+      "log_bad": 3.7377,
+      "log_good": 3.9512
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7087,
+      "good": 0.7782,
+      "ratio": 1.0981,
+      "suggested_scalar": 0.0316,
+      "log_bad": -0.3443,
+      "log_good": -0.2508
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 54.0,
+      "good": 44.0,
+      "ratio": 0.8148,
+      "suggested_scalar": -0.0693,
+      "log_bad": 3.989,
+      "log_good": 3.7842
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0565,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    }
+  },
+  "naming_conventions.dangerous_method_ends_with_bang": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0071,
+      "good": 0.0153,
+      "ratio": 2.1549,
+      "suggested_scalar": 0.2715,
+      "log_bad": -4.9477,
+      "log_good": -4.1799
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.2727,
+      "good": 0.2,
+      "ratio": 0.7334,
+      "suggested_scalar": -0.1097,
+      "log_bad": -1.2994,
+      "log_good": -1.6094
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8148,
+      "good": 0.7273,
+      "ratio": 0.8926,
+      "suggested_scalar": -0.0402,
+      "log_bad": -0.2048,
+      "log_good": -0.3184
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0071,
+      "good": 0.0153,
+      "ratio": 2.1549,
+      "suggested_scalar": 0.2715,
+      "log_bad": -4.9477,
+      "log_good": -4.1799
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5033,
+      "good": 4.3942,
+      "ratio": 0.9758,
+      "suggested_scalar": -0.0087,
+      "log_bad": 1.5048,
+      "log_good": 1.4803
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 89.0,
+      "good": 62.0,
+      "ratio": 0.6966,
+      "suggested_scalar": -0.1279,
+      "log_bad": 4.4886,
+      "log_good": 4.1271
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5075,
+      "good": 0.36,
+      "ratio": 0.7094,
+      "suggested_scalar": -0.1214,
+      "log_bad": -0.6783,
+      "log_good": -1.0217
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 23.0,
+      "good": 18.0,
+      "ratio": 0.7826,
+      "suggested_scalar": -0.0867,
+      "log_bad": 3.1355,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7745,
+      "good": 0.686,
+      "ratio": 0.8857,
+      "suggested_scalar": -0.0429,
+      "log_bad": -0.2555,
+      "log_good": -0.3769
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.8148,
+      "good": 2.9091,
+      "ratio": 1.0335,
+      "suggested_scalar": 0.0117,
+      "log_bad": 1.0349,
+      "log_good": 1.0678
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 282.0,
+      "good": 262.0,
+      "ratio": 0.9291,
+      "suggested_scalar": -0.026,
+      "log_bad": 5.6419,
+      "log_good": 5.5683
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0043,
+      "good": 0.0015,
+      "ratio": 0.3488,
+      "suggested_scalar": -0.3725,
+      "log_bad": -5.4491,
+      "log_good": -6.5023
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0926,
+      "good": 0.0727,
+      "ratio": 0.7851,
+      "suggested_scalar": -0.0856,
+      "log_bad": -2.3795,
+      "log_good": -2.6214
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0065,
+      "good": 0.0081,
+      "ratio": 1.2462,
+      "suggested_scalar": 0.0778,
+      "log_bad": -5.036,
+      "log_good": -4.8159
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8542,
+      "good": 0.7938,
+      "ratio": 0.9293,
+      "suggested_scalar": -0.0259,
+      "log_bad": -0.1576,
+      "log_good": -0.2309
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 107.0,
+      "good": 101.0,
+      "ratio": 0.9439,
+      "suggested_scalar": -0.0204,
+      "log_bad": 4.6728,
+      "log_good": 4.6151
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 106.1554,
+      "good": 105.7764,
+      "ratio": 0.9964,
+      "suggested_scalar": -0.0013,
+      "log_bad": 4.6649,
+      "log_good": 4.6613
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4448,
+      "good": 0.6782,
+      "ratio": 1.5247,
+      "suggested_scalar": 0.1492,
+      "log_bad": -0.8101,
+      "log_good": -0.3883
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.2487,
+      "good": 10.0645,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.0393,
+      "log_bad": 2.4203,
+      "log_good": 2.309
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1393.0,
+      "good": 1361.0,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0082,
+      "log_bad": 7.2392,
+      "log_good": 7.216
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1296,
+      "good": 0.1636,
+      "ratio": 1.2623,
+      "suggested_scalar": 0.0824,
+      "log_bad": -2.0433,
+      "log_good": -1.8103
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7963,
+      "good": 0.7091,
+      "ratio": 0.8905,
+      "suggested_scalar": -0.041,
+      "log_bad": -0.2278,
+      "log_good": -0.3438
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.7551,
+      "good": 5.1373,
+      "ratio": 0.8927,
+      "suggested_scalar": -0.0402,
+      "log_bad": 1.7501,
+      "log_good": 1.6365
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.262,
+      "good": 1.2826,
+      "ratio": 1.0163,
+      "suggested_scalar": 0.0057,
+      "log_bad": 0.2327,
+      "log_good": 0.2489
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 97.0,
+      "good": 88.0,
+      "ratio": 0.9072,
+      "suggested_scalar": -0.0344,
+      "log_bad": 4.5747,
+      "log_good": 4.4773
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9076,
+      "good": 0.857,
+      "ratio": 0.9442,
+      "suggested_scalar": -0.0203,
+      "log_bad": -0.097,
+      "log_good": -0.1543
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 25.0,
+      "ratio": 0.8929,
+      "suggested_scalar": -0.0401,
+      "log_bad": 3.3322,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5901,
+      "good": 0.6738,
+      "ratio": 1.1418,
+      "suggested_scalar": 0.0469,
+      "log_bad": -0.5275,
+      "log_good": -0.3948
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.175,
+      "good": 0.45,
+      "ratio": 2.5714,
+      "suggested_scalar": 0.334,
+      "log_bad": -1.743,
+      "log_good": -0.7985
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4396,
+      "good": 3.0653,
+      "ratio": 1.2565,
+      "suggested_scalar": 0.0807,
+      "log_bad": 0.8918,
+      "log_good": 1.1201
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 280.0,
+      "good": 260.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.0262,
+      "log_bad": 5.6348,
+      "log_good": 5.5607
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 9.0,
+      "good": 10.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0373,
+      "log_bad": 2.1972,
+      "log_good": 2.3026
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.6147,
+      "ratio": 0.9505,
+      "suggested_scalar": -0.0179,
+      "log_bad": 1.7761,
+      "log_good": 1.7254
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 10.0,
+      "good": 13.0,
+      "ratio": 1.3,
+      "suggested_scalar": 0.0928,
+      "log_bad": 2.3026,
+      "log_good": 2.5649
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.4479,
+      "good": 0.5539,
+      "ratio": 1.2367,
+      "suggested_scalar": 0.0751,
+      "log_bad": -0.8032,
+      "log_good": -0.5908
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9659,
+      "good": 5.7341,
+      "ratio": 0.9611,
+      "suggested_scalar": -0.014,
+      "log_bad": 1.7861,
+      "log_good": 1.7464
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7624,
+      "good": 0.7826,
+      "ratio": 1.0265,
+      "suggested_scalar": 0.0092,
+      "log_bad": -0.2713,
+      "log_good": -0.2451
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1818,
+      "good": 0.2143,
+      "ratio": 1.1788,
+      "suggested_scalar": 0.0582,
+      "log_bad": -1.7048,
+      "log_good": -1.5404
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.3539,
+      "good": 3.1725,
+      "ratio": 0.9459,
+      "suggested_scalar": -0.0197,
+      "log_bad": 1.2101,
+      "log_good": 1.1545
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 249.0,
+      "good": 194.0,
+      "ratio": 0.7791,
+      "suggested_scalar": -0.0883,
+      "log_bad": 5.5175,
+      "log_good": 5.2679
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5029,
+      "good": 0.4208,
+      "ratio": 0.8367,
+      "suggested_scalar": -0.063,
+      "log_bad": -0.6874,
+      "log_good": -0.8656
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 94.0,
+      "good": 71.0,
+      "ratio": 0.7553,
+      "suggested_scalar": -0.0992,
+      "log_bad": 4.5433,
+      "log_good": 4.2627
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 733.0,
+      "good": 700.0,
+      "ratio": 0.955,
+      "suggested_scalar": -0.0163,
+      "log_bad": 6.5971,
+      "log_good": 6.5511
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 114.0,
+      "good": 101.0,
+      "ratio": 0.886,
+      "suggested_scalar": -0.0428,
+      "log_bad": 4.7362,
+      "log_good": 4.6151
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1454,
+      "good": 0.1794,
+      "ratio": 1.2338,
+      "suggested_scalar": 0.0743,
+      "log_bad": -1.9283,
+      "log_good": -1.7181
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 47.0,
+      "good": 69.0,
+      "ratio": 1.4681,
+      "suggested_scalar": 0.1358,
+      "log_bad": 3.8501,
+      "log_good": 4.2341
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 11.0,
+      "good": 10.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0337,
+      "log_bad": 2.3979,
+      "log_good": 2.3026
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 94.0,
+      "good": 71.0,
+      "ratio": 0.7553,
+      "suggested_scalar": -0.0992,
+      "log_bad": 4.5433,
+      "log_good": 4.2627
+    },
+    "brevity.mean_sample_size": {
+      "bad": 94.0,
+      "good": 71.0,
+      "ratio": 0.7553,
+      "suggested_scalar": -0.0992,
+      "log_bad": 4.5433,
+      "log_good": 4.2627
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 282.0,
+      "good": 262.0,
+      "ratio": 0.9291,
+      "suggested_scalar": -0.026,
+      "log_bad": 5.6419,
+      "log_good": 5.5683
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 124.0,
+      "good": 104.0,
+      "ratio": 0.8387,
+      "suggested_scalar": -0.0622,
+      "log_bad": 4.8203,
+      "log_good": 4.6444
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 203.0,
+      "good": 153.0,
+      "ratio": 0.7537,
+      "suggested_scalar": -0.1,
+      "log_bad": 5.3132,
+      "log_good": 5.0304
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0035,
+      "good": 1.0,
+      "ratio": 285.7143,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.655,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.3052,
+      "good": 1.7747,
+      "ratio": 1.3597,
+      "suggested_scalar": 0.1087,
+      "log_bad": 0.2664,
+      "log_good": 0.5736
+    },
+    "halstead.mean_effort": {
+      "bad": 39477.3449,
+      "good": 43071.3687,
+      "ratio": 1.091,
+      "suggested_scalar": 0.0308,
+      "log_bad": 10.5835,
+      "log_good": 10.6706
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.9102,
+      "good": 0.9324,
+      "ratio": 1.0244,
+      "suggested_scalar": 0.0085,
+      "log_bad": -0.0941,
+      "log_good": -0.07
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 61.0,
+      "good": 37.0,
+      "ratio": 0.6066,
+      "suggested_scalar": -0.1768,
+      "log_bad": 4.1109,
+      "log_good": 3.6109
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 119.0,
+      "good": 111.0,
+      "ratio": 0.9328,
+      "suggested_scalar": -0.0246,
+      "log_bad": 4.7791,
+      "log_good": 4.7095
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4953,
+      "good": 0.3564,
+      "ratio": 0.7196,
+      "suggested_scalar": -0.1164,
+      "log_bad": -0.7026,
+      "log_good": -1.0317
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.8505,
+      "good": 6.9307,
+      "ratio": 1.0117,
+      "suggested_scalar": 0.0041,
+      "log_bad": 1.9243,
+      "log_good": 1.936
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1818,
+      "good": 0.2143,
+      "ratio": 1.1788,
+      "suggested_scalar": 0.0582,
+      "log_bad": -1.7048,
+      "log_good": -1.5404
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.5568,
+      "good": 2.0549,
+      "ratio": 0.8037,
+      "suggested_scalar": -0.0773,
+      "log_bad": 0.9388,
+      "log_good": 0.7202
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 281.0,
+      "good": 261.0,
+      "ratio": 0.9288,
+      "suggested_scalar": -0.0261,
+      "log_bad": 5.6384,
+      "log_good": 5.5645
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 18.0,
+      "good": 51.0,
+      "ratio": 2.8333,
+      "suggested_scalar": 0.3683,
+      "log_bad": 2.8904,
+      "log_good": 3.9318
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2193.1858,
+      "good": 2392.8538,
+      "ratio": 1.091,
+      "suggested_scalar": 0.0308,
+      "log_bad": 7.6931,
+      "log_good": 7.7802
+    },
+    "readability.mean_total_lines": {
+      "bad": 49.0,
+      "good": 51.0,
+      "ratio": 1.0408,
+      "suggested_scalar": 0.0141,
+      "log_bad": 3.8918,
+      "log_good": 3.9318
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1508.8459,
+      "good": 1262.2896,
+      "ratio": 0.8366,
+      "suggested_scalar": -0.0631,
+      "log_bad": 7.3191,
+      "log_good": 7.1407
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 571.0,
+      "good": 444.0,
+      "ratio": 0.7776,
+      "suggested_scalar": -0.089,
+      "log_bad": 6.3474,
+      "log_good": 6.0958
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 21.1224,
+      "good": 22.098,
+      "ratio": 1.0462,
+      "suggested_scalar": 0.016,
+      "log_bad": 3.0503,
+      "log_good": 3.0955
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.121,
+      "good": 1.1329,
+      "ratio": 1.0106,
+      "suggested_scalar": 0.0037,
+      "log_bad": 0.1142,
+      "log_good": 0.1248
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 6.0,
+      "good": 3.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2451,
+      "log_bad": 1.7918,
+      "log_good": 1.0986
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0789,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9277,
+      "good": 0.7371,
+      "ratio": 0.7945,
+      "suggested_scalar": -0.0813,
+      "log_bad": -0.075,
+      "log_good": -0.305
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9789,
+      "good": 0.9666,
+      "ratio": 0.9874,
+      "suggested_scalar": -0.0045,
+      "log_bad": -0.0213,
+      "log_good": -0.034
+    },
+    "halstead.mean_length": {
+      "bad": 233.0,
+      "good": 212.0,
+      "ratio": 0.9099,
+      "suggested_scalar": -0.0334,
+      "log_bad": 5.451,
+      "log_good": 5.3566
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.7273,
+      "good": 6.7,
+      "ratio": 1.1698,
+      "suggested_scalar": 0.0555,
+      "log_bad": 1.7452,
+      "log_good": 1.9021
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5546,
+      "good": 6.1497,
+      "ratio": 0.9382,
+      "suggested_scalar": -0.0226,
+      "log_bad": 1.8802,
+      "log_good": 1.8164
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0893,
+      "good": 0.0769,
+      "ratio": 0.8611,
+      "suggested_scalar": -0.0529,
+      "log_bad": -2.4158,
+      "log_good": -2.5652
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 26.1639,
+      "good": 34.1216,
+      "ratio": 1.3041,
+      "suggested_scalar": 0.0939,
+      "log_bad": 3.2644,
+      "log_good": 3.5299
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 9.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.0889,
+      "log_bad": 1.9459,
+      "log_good": 2.1972
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 53.0,
+      "good": 36.0,
+      "ratio": 0.6792,
+      "suggested_scalar": -0.1368,
+      "log_bad": 3.9703,
+      "log_good": 3.5835
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7685,
+      "good": 0.549,
+      "ratio": 0.7144,
+      "suggested_scalar": -0.119,
+      "log_bad": -0.2633,
+      "log_good": -0.5997
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 54.0,
+      "good": 55.0,
+      "ratio": 1.0185,
+      "suggested_scalar": 0.0065,
+      "log_bad": 3.989,
+      "log_good": 4.0073
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_any_type_annotation": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 32.0,
+      "good": 36.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.056,
+      "log_bad": 3.4657,
+      "log_good": 3.5835
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0522,
+      "good": 0.0547,
+      "ratio": 1.0479,
+      "suggested_scalar": 0.0222,
+      "log_bad": -2.9527,
+      "log_good": -2.9059
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 1.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1928,
+      "log_bad": 0.4055,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9649,
+      "good": 0.9701,
+      "ratio": 1.0054,
+      "suggested_scalar": 0.0026,
+      "log_bad": -0.0357,
+      "log_good": -0.0304
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0522,
+      "good": 0.0547,
+      "ratio": 1.0479,
+      "suggested_scalar": 0.0222,
+      "log_bad": -2.9527,
+      "log_good": -2.9059
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7286,
+      "good": 4.6594,
+      "ratio": 0.9854,
+      "suggested_scalar": -0.007,
+      "log_bad": 1.5536,
+      "log_good": 1.5389
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 107.0,
+      "good": 107.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.6728,
+      "log_good": 4.6728
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5154,
+      "good": 0.4469,
+      "ratio": 0.8671,
+      "suggested_scalar": -0.0678,
+      "log_bad": -0.6628,
+      "log_good": -0.8054
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7049,
+      "good": 0.6565,
+      "ratio": 0.9313,
+      "suggested_scalar": -0.0338,
+      "log_bad": -0.3497,
+      "log_good": -0.4208
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.0,
+      "good": 4.5373,
+      "ratio": 1.1343,
+      "suggested_scalar": 0.0599,
+      "log_bad": 1.3863,
+      "log_good": 1.5123
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 479.0,
+      "good": 530.0,
+      "ratio": 1.1065,
+      "suggested_scalar": 0.0481,
+      "log_bad": 6.1717,
+      "log_good": 6.2729
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1368,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 0.0149,
+      "ratio": 0.0149,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -4.2064
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9632,
+      "good": 1.0232,
+      "ratio": 1.0623,
+      "suggested_scalar": 0.0287,
+      "log_bad": -0.0375,
+      "log_good": 0.0229
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 209.0,
+      "good": 211.0,
+      "ratio": 1.0096,
+      "suggested_scalar": 0.0045,
+      "log_bad": 5.3423,
+      "log_good": 5.3519
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.1961,
+      "good": 103.3913,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.0037,
+      "log_bad": 4.6463,
+      "log_good": 4.6385
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4456,
+      "good": 0.4575,
+      "ratio": 1.0267,
+      "suggested_scalar": 0.0125,
+      "log_bad": -0.8083,
+      "log_good": -0.782
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.6567,
+      "good": 9.2652,
+      "ratio": 0.9595,
+      "suggested_scalar": -0.0197,
+      "log_bad": 2.2677,
+      "log_good": 2.2263
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2244.0,
+      "good": 2420.0,
+      "ratio": 1.0784,
+      "suggested_scalar": 0.0359,
+      "log_bad": 7.716,
+      "log_good": 7.7915
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0702,
+      "good": 0.1045,
+      "ratio": 1.4886,
+      "suggested_scalar": 0.1892,
+      "log_bad": -2.6564,
+      "log_good": -2.2586
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9649,
+      "good": 0.9552,
+      "ratio": 0.9899,
+      "suggested_scalar": -0.0048,
+      "log_bad": -0.0357,
+      "log_good": -0.0458
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.4035,
+      "good": 8.0303,
+      "ratio": 0.9556,
+      "suggested_scalar": -0.0216,
+      "log_bad": 2.1286,
+      "log_good": 2.0832
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3296,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 8.4211,
+      "good": 10.9352,
+      "ratio": 1.2985,
+      "suggested_scalar": 0.1242,
+      "log_bad": 2.1307,
+      "log_good": 2.392
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 146.0,
+      "good": 156.0,
+      "ratio": 1.0685,
+      "suggested_scalar": 0.0315,
+      "log_bad": 4.9836,
+      "log_good": 5.0499
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1928,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9574,
+      "good": 0.9589,
+      "ratio": 1.0016,
+      "suggested_scalar": 0.0007,
+      "log_bad": -0.0435,
+      "log_good": -0.042
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 31.0,
+      "ratio": 1.1481,
+      "suggested_scalar": 0.0657,
+      "log_bad": 3.2958,
+      "log_good": 3.434
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.598,
+      "good": 0.6037,
+      "ratio": 1.0095,
+      "suggested_scalar": 0.0045,
+      "log_bad": -0.5142,
+      "log_good": -0.5047
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.283,
+      "good": 0.2614,
+      "ratio": 0.9237,
+      "suggested_scalar": -0.0377,
+      "log_bad": -1.2623,
+      "log_good": -1.3417
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4878,
+      "good": 2.5235,
+      "ratio": 1.0144,
+      "suggested_scalar": 0.0068,
+      "log_bad": 0.9114,
+      "log_good": 0.9256
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 477.0,
+      "good": 528.0,
+      "ratio": 1.1069,
+      "suggested_scalar": 0.0483,
+      "log_bad": 6.1675,
+      "log_good": 6.2691
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 19.0,
+      "good": 21.0,
+      "ratio": 1.1053,
+      "suggested_scalar": 0.0476,
+      "log_bad": 2.9444,
+      "log_good": 3.0445
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0522,
+      "good": 0.0453,
+      "ratio": 0.8678,
+      "suggested_scalar": -0.0674,
+      "log_bad": -2.9527,
+      "log_good": -3.0944
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0444,
+      "good": 6.0444,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7991,
+      "log_good": 1.7991
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 62.0,
+      "good": 54.0,
+      "ratio": 0.871,
+      "suggested_scalar": -0.0657,
+      "log_bad": 4.1271,
+      "log_good": 3.989
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9185,
+      "good": 0.8619,
+      "ratio": 0.9384,
+      "suggested_scalar": -0.0302,
+      "log_bad": -0.085,
+      "log_good": -0.1486
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9371,
+      "good": 5.8471,
+      "ratio": 0.9848,
+      "suggested_scalar": -0.0073,
+      "log_bad": 1.7812,
+      "log_good": 1.7659
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7823,
+      "good": 0.7709,
+      "ratio": 0.9854,
+      "suggested_scalar": -0.007,
+      "log_bad": -0.2455,
+      "log_good": -0.2602
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3296,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2083,
+      "good": 0.1829,
+      "ratio": 0.8781,
+      "suggested_scalar": -0.0618,
+      "log_bad": -1.5688,
+      "log_good": -1.6988
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1075,
+      "good": 3.0439,
+      "ratio": 0.9795,
+      "suggested_scalar": -0.0098,
+      "log_bad": 1.1338,
+      "log_good": 1.1131
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 387.0,
+      "good": 443.0,
+      "ratio": 1.1447,
+      "suggested_scalar": 0.0643,
+      "log_bad": 5.9584,
+      "log_good": 6.0936
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 9.0,
+      "good": 12.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1368,
+      "log_bad": 2.1972,
+      "log_good": 2.4849
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8539,
+      "good": 0.9618,
+      "ratio": 1.1264,
+      "suggested_scalar": 0.0566,
+      "log_bad": -0.1579,
+      "log_good": -0.0389
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 128.0,
+      "good": 121.0,
+      "ratio": 0.9453,
+      "suggested_scalar": -0.0267,
+      "log_bad": 4.852,
+      "log_good": 4.7958
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1282.0,
+      "good": 1352.0,
+      "ratio": 1.0546,
+      "suggested_scalar": 0.0253,
+      "log_bad": 7.1562,
+      "log_good": 7.2093
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 196.0,
+      "good": 194.0,
+      "ratio": 0.9898,
+      "suggested_scalar": -0.0049,
+      "log_bad": 5.2781,
+      "log_good": 5.2679
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3296,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0084,
+      "good": 0.0075,
+      "ratio": 0.8929,
+      "suggested_scalar": -0.0539,
+      "log_bad": -4.7795,
+      "log_good": -4.8929
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2422,
+      "good": 0.2717,
+      "ratio": 1.1218,
+      "suggested_scalar": 0.0546,
+      "log_bad": -1.418,
+      "log_good": -1.3031
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 61.0,
+      "good": 77.0,
+      "ratio": 1.2623,
+      "suggested_scalar": 0.1108,
+      "log_bad": 4.1109,
+      "log_good": 4.3438
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 128.0,
+      "good": 121.0,
+      "ratio": 0.9453,
+      "suggested_scalar": -0.0267,
+      "log_bad": 4.852,
+      "log_good": 4.7958
+    },
+    "brevity.mean_sample_size": {
+      "bad": 128.0,
+      "good": 121.0,
+      "ratio": 0.9453,
+      "suggested_scalar": -0.0267,
+      "log_bad": 4.852,
+      "log_good": 4.7958
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 479.0,
+      "good": 530.0,
+      "ratio": 1.1065,
+      "suggested_scalar": 0.0481,
+      "log_bad": 6.1717,
+      "log_good": 6.2729
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 219.0,
+      "good": 259.0,
+      "ratio": 1.1826,
+      "suggested_scalar": 0.0798,
+      "log_bad": 5.3891,
+      "log_good": 5.5568
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 326.0,
+      "good": 364.0,
+      "ratio": 1.1166,
+      "suggested_scalar": 0.0524,
+      "log_bad": 5.7869,
+      "log_good": 5.8972
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0021,
+      "good": 0.0019,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.0476,
+      "log_bad": -6.1658,
+      "log_good": -6.2659
+    },
+    "heaps.mean_k": {
+      "bad": 1.9133,
+      "good": 2.3336,
+      "ratio": 1.2197,
+      "suggested_scalar": 0.0944,
+      "log_bad": 0.6488,
+      "log_good": 0.8474
+    },
+    "halstead.mean_effort": {
+      "bad": 84730.1278,
+      "good": 114161.0664,
+      "ratio": 1.3473,
+      "suggested_scalar": 0.1418,
+      "log_bad": 11.3472,
+      "log_good": 11.6454
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.3296,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8482,
+      "good": 0.8451,
+      "ratio": 0.9963,
+      "suggested_scalar": -0.0017,
+      "log_bad": -0.1646,
+      "log_good": -0.1683
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 80.0,
+      "good": 76.0,
+      "ratio": 0.95,
+      "suggested_scalar": -0.0244,
+      "log_bad": 4.382,
+      "log_good": 4.3307
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 184.0,
+      "good": 234.0,
+      "ratio": 1.2717,
+      "suggested_scalar": 0.1143,
+      "log_bad": 5.2149,
+      "log_good": 5.4553
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4163,
+      "good": 0.3602,
+      "ratio": 0.8652,
+      "suggested_scalar": -0.0688,
+      "log_bad": -0.8763,
+      "log_good": -1.0211
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.134,
+      "good": 6.4076,
+      "ratio": 1.0446,
+      "suggested_scalar": 0.0207,
+      "log_bad": 1.8138,
+      "log_good": 1.8575
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2083,
+      "good": 0.1829,
+      "ratio": 0.8781,
+      "suggested_scalar": -0.0618,
+      "log_bad": -1.5688,
+      "log_good": -1.6988
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.3614,
+      "good": 3.2121,
+      "ratio": 0.9556,
+      "suggested_scalar": -0.0216,
+      "log_bad": 1.2124,
+      "log_good": 1.1669
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 4.0,
+      "good": 1.0,
+      "ratio": 0.25,
+      "suggested_scalar": -0.6591,
+      "log_bad": 1.3863,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 478.0,
+      "good": 529.0,
+      "ratio": 1.1067,
+      "suggested_scalar": 0.0482,
+      "log_bad": 6.1696,
+      "log_good": 6.271
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 45.0,
+      "good": 53.0,
+      "ratio": 1.1778,
+      "suggested_scalar": 0.0778,
+      "log_bad": 3.8067,
+      "log_good": 3.9703
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4707.2293,
+      "good": 6342.2815,
+      "ratio": 1.3473,
+      "suggested_scalar": 0.1418,
+      "log_bad": 8.4569,
+      "log_good": 8.755
+    },
+    "readability.mean_total_lines": {
+      "bad": 57.0,
+      "good": 66.0,
+      "ratio": 1.1579,
+      "suggested_scalar": 0.0697,
+      "log_bad": 4.0431,
+      "log_good": 4.1897
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 12.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1928,
+      "log_bad": 2.0794,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2561.7575,
+      "good": 2885.3479,
+      "ratio": 1.1263,
+      "suggested_scalar": 0.0566,
+      "log_bad": 7.8484,
+      "log_good": 7.9674
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 902.0,
+      "good": 959.0,
+      "ratio": 1.0632,
+      "suggested_scalar": 0.0291,
+      "log_bad": 6.8046,
+      "log_good": 6.8659
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 37.9649,
+      "good": 34.8939,
+      "ratio": 0.9191,
+      "suggested_scalar": -0.0401,
+      "log_bad": 3.6367,
+      "log_good": 3.5523
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1124,
+      "good": 1.1264,
+      "ratio": 1.0126,
+      "suggested_scalar": 0.0059,
+      "log_bad": 0.1065,
+      "log_good": 0.119
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1368,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 24.0,
+      "good": 31.0,
+      "ratio": 1.2917,
+      "suggested_scalar": 0.1217,
+      "log_bad": 3.1781,
+      "log_good": 3.434
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8837,
+      "good": 0.8804,
+      "ratio": 0.9963,
+      "suggested_scalar": -0.0018,
+      "log_bad": -0.1236,
+      "log_good": -0.1274
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9816,
+      "good": 0.9673,
+      "ratio": 0.9854,
+      "suggested_scalar": -0.007,
+      "log_bad": -0.0186,
+      "log_good": -0.0332
+    },
+    "halstead.mean_length": {
+      "bad": 380.0,
+      "good": 428.0,
+      "ratio": 1.1263,
+      "suggested_scalar": 0.0566,
+      "log_bad": 5.9402,
+      "log_good": 6.0591
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.0,
+      "good": 12.5,
+      "ratio": 1.25,
+      "suggested_scalar": 0.1061,
+      "log_bad": 2.3026,
+      "log_good": 2.5257
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.0,
+      "good": 6.9189,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0055,
+      "log_bad": 1.9459,
+      "log_good": 1.9343
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0979,
+      "good": 0.107,
+      "ratio": 1.093,
+      "suggested_scalar": 0.0423,
+      "log_bad": -2.3238,
+      "log_good": -2.2349
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 33.075,
+      "good": 39.5658,
+      "ratio": 1.1962,
+      "suggested_scalar": 0.0852,
+      "log_bad": 3.4988,
+      "log_good": 3.678
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 7.0,
+      "ratio": 1.75,
+      "suggested_scalar": 0.2661,
+      "log_bad": 1.3863,
+      "log_good": 1.9459
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 87.0,
+      "good": 76.0,
+      "ratio": 0.8736,
+      "suggested_scalar": -0.0643,
+      "log_bad": 4.4659,
+      "log_good": 4.3307
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8129,
+      "good": 0.7885,
+      "ratio": 0.97,
+      "suggested_scalar": -0.0145,
+      "log_bad": -0.2071,
+      "log_good": -0.2376
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 57.0,
+      "good": 67.0,
+      "ratio": 1.1754,
+      "suggested_scalar": 0.0769,
+      "log_bad": 4.0431,
+      "log_good": 4.2047
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.uses_type_declarations_on_parameters": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.uses_errors_is_for_sentinel_comparison": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0361,
+      "good": 0.0319,
+      "ratio": 0.8837,
+      "suggested_scalar": -0.442,
+      "log_bad": -3.3215,
+      "log_good": -3.4451
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8333,
+      "good": 0.8333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1824,
+      "log_good": -0.1824
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0361,
+      "good": 0.0319,
+      "ratio": 0.8837,
+      "suggested_scalar": -0.442,
+      "log_bad": -3.3215,
+      "log_good": -3.4451
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8313,
+      "good": 4.7983,
+      "ratio": 0.9932,
+      "suggested_scalar": -0.0245,
+      "log_bad": 1.5751,
+      "log_good": 1.5683
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 79.0,
+      "good": 79.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3694,
+      "log_good": 4.3694
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.525,
+      "good": 0.5409,
+      "ratio": 1.0303,
+      "suggested_scalar": 0.1066,
+      "log_bad": -0.6444,
+      "log_good": -0.6145
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 12.0,
+      "good": 11.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.311,
+      "log_bad": 2.4849,
+      "log_good": 2.3979
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7302,
+      "good": 0.7246,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.0275,
+      "log_bad": -0.3144,
+      "log_good": -0.3221
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.8056,
+      "good": 1.8056,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.5909,
+      "log_good": 0.5909
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 249.0,
+      "good": 251.0,
+      "ratio": 1.008,
+      "suggested_scalar": 0.0286,
+      "log_bad": 5.5175,
+      "log_good": 5.5255
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0833,
+      "good": 0.0833,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.4853,
+      "log_good": -2.4853
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9304,
+      "good": 0.9285,
+      "ratio": 0.998,
+      "suggested_scalar": -0.0073,
+      "log_bad": -0.0721,
+      "log_good": -0.0742
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 101.0,
+      "good": 110.0,
+      "ratio": 1.0891,
+      "suggested_scalar": 0.3051,
+      "log_bad": 4.6151,
+      "log_good": 4.7005
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.4717,
+      "good": 104.9036,
+      "ratio": 1.0041,
+      "suggested_scalar": 0.0147,
+      "log_bad": 4.6489,
+      "log_good": 4.653
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4194,
+      "good": 0.44,
+      "ratio": 1.0491,
+      "suggested_scalar": 0.1714,
+      "log_bad": -0.8689,
+      "log_good": -0.821
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 17.135,
+      "good": 16.4269,
+      "ratio": 0.9587,
+      "suggested_scalar": -0.1508,
+      "log_bad": 2.8411,
+      "log_good": 2.7989
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1059.0,
+      "good": 1092.0,
+      "ratio": 1.0312,
+      "suggested_scalar": 0.1097,
+      "log_bad": 6.9651,
+      "log_good": 6.9958
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1944,
+      "good": 0.1111,
+      "ratio": 0.5715,
+      "suggested_scalar": -1.9995,
+      "log_bad": -1.6378,
+      "log_good": -2.1973
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7778,
+      "good": 0.7778,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2513,
+      "log_good": -0.2513
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.9167,
+      "good": 6.9722,
+      "ratio": 1.008,
+      "suggested_scalar": 0.0286,
+      "log_bad": 1.9339,
+      "log_good": 1.9419
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.3233,
+      "good": 2.3233,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.843,
+      "log_good": 0.843
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 68.0,
+      "good": 75.0,
+      "ratio": 1.1029,
+      "suggested_scalar": 0.3502,
+      "log_bad": 4.2195,
+      "log_good": 4.3175
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9346,
+      "good": 0.9391,
+      "ratio": 1.0048,
+      "suggested_scalar": 0.0172,
+      "log_bad": -0.0676,
+      "log_good": -0.0628
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 17.0,
+      "ratio": 0.8095,
+      "suggested_scalar": -0.7552,
+      "log_bad": 3.0445,
+      "log_good": 2.8332
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5326,
+      "good": 0.5394,
+      "ratio": 1.0128,
+      "suggested_scalar": 0.0453,
+      "log_bad": -0.63,
+      "log_good": -0.6173
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2389,
+      "good": 0.2691,
+      "ratio": 1.1264,
+      "suggested_scalar": 0.4254,
+      "log_bad": -1.4317,
+      "log_good": -1.3127
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.1394,
+      "good": 2.171,
+      "ratio": 1.0148,
+      "suggested_scalar": 0.0524,
+      "log_bad": 0.7605,
+      "log_good": 0.7752
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 247.0,
+      "good": 249.0,
+      "ratio": 1.0081,
+      "suggested_scalar": 0.0288,
+      "log_bad": 5.5094,
+      "log_good": 5.5175
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8074,
+      "good": 5.7549,
+      "ratio": 0.991,
+      "suggested_scalar": -0.0325,
+      "log_bad": 1.7591,
+      "log_good": 1.7501
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 33.0,
+      "good": 35.0,
+      "ratio": 1.0606,
+      "suggested_scalar": 0.2103,
+      "log_bad": 3.4965,
+      "log_good": 3.5553
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9116,
+      "good": 0.9024,
+      "ratio": 0.9899,
+      "suggested_scalar": -0.0363,
+      "log_bad": -0.0926,
+      "log_good": -0.1027
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4383,
+      "good": 5.4521,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0091,
+      "log_bad": 1.6935,
+      "log_good": 1.696
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8319,
+      "good": 0.8338,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0082,
+      "log_bad": -0.184,
+      "log_good": -0.1818
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1429,
+      "good": 0.1429,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.9456,
+      "log_good": -1.9456
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.1394,
+      "good": 4.053,
+      "ratio": 0.9791,
+      "suggested_scalar": -0.0754,
+      "log_bad": 1.4206,
+      "log_good": 1.3995
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 211.0,
+      "good": 209.0,
+      "ratio": 0.9905,
+      "suggested_scalar": -0.034,
+      "log_bad": 5.3519,
+      "log_good": 5.3423
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.4602,
+      "good": 0.477,
+      "ratio": 1.0365,
+      "suggested_scalar": 0.1281,
+      "log_bad": -0.7761,
+      "log_good": -0.7402
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 80.0,
+      "good": 81.0,
+      "ratio": 1.0125,
+      "suggested_scalar": 0.0444,
+      "log_bad": 4.382,
+      "log_good": 4.3944
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 627.0,
+      "good": 675.0,
+      "ratio": 1.0766,
+      "suggested_scalar": 0.2636,
+      "log_bad": 6.4409,
+      "log_good": 6.5147
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 102.0,
+      "good": 112.0,
+      "ratio": 1.098,
+      "suggested_scalar": 0.3343,
+      "log_bad": 4.625,
+      "log_good": 4.7185
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.253,
+      "good": 0.2829,
+      "ratio": 1.1182,
+      "suggested_scalar": 0.3992,
+      "log_bad": -1.3744,
+      "log_good": -1.2627
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 33.0,
+      "good": 36.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.311,
+      "log_bad": 3.4965,
+      "log_good": 3.5835
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 80.0,
+      "good": 81.0,
+      "ratio": 1.0125,
+      "suggested_scalar": 0.0444,
+      "log_bad": 4.382,
+      "log_good": 4.3944
+    },
+    "brevity.mean_sample_size": {
+      "bad": 80.0,
+      "good": 81.0,
+      "ratio": 1.0125,
+      "suggested_scalar": 0.0444,
+      "log_bad": 4.382,
+      "log_good": 4.3944
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 249.0,
+      "good": 251.0,
+      "ratio": 1.008,
+      "suggested_scalar": 0.0286,
+      "log_bad": 5.5175,
+      "log_good": 5.5255
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 123.0,
+      "good": 119.0,
+      "ratio": 0.9675,
+      "suggested_scalar": -0.1182,
+      "log_bad": 4.8122,
+      "log_good": 4.7791
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 177.0,
+      "good": 176.0,
+      "ratio": 0.9944,
+      "suggested_scalar": -0.0202,
+      "log_bad": 5.1761,
+      "log_good": 5.1705
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.5762,
+      "good": 1.6359,
+      "ratio": 1.0379,
+      "suggested_scalar": 0.1329,
+      "log_bad": 0.455,
+      "log_good": 0.4922
+    },
+    "halstead.mean_effort": {
+      "bad": 25492.1633,
+      "good": 21972.1328,
+      "ratio": 0.8619,
+      "suggested_scalar": -0.5311,
+      "log_bad": 10.1461,
+      "log_good": 9.9975
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8602,
+      "good": 0.86,
+      "ratio": 0.9998,
+      "suggested_scalar": -0.0008,
+      "log_bad": -0.1506,
+      "log_good": -0.1508
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 58.0,
+      "good": 62.0,
+      "ratio": 1.069,
+      "suggested_scalar": 0.2383,
+      "log_bad": 4.0604,
+      "log_good": 4.1271
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 117.0,
+      "good": 115.0,
+      "ratio": 0.9829,
+      "suggested_scalar": -0.0616,
+      "log_bad": 4.7622,
+      "log_good": 4.7449
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5248,
+      "good": 0.5182,
+      "ratio": 0.9874,
+      "suggested_scalar": -0.0452,
+      "log_bad": -0.6447,
+      "log_good": -0.6574
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.2079,
+      "good": 6.1364,
+      "ratio": 0.9885,
+      "suggested_scalar": -0.0414,
+      "log_bad": 1.8258,
+      "log_good": 1.8142
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1429,
+      "good": 0.1429,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.9456,
+      "log_good": -1.9456
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.0841,
+      "good": 3.0919,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.009,
+      "log_bad": 1.1263,
+      "log_good": 1.1288
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 248.0,
+      "good": 250.0,
+      "ratio": 1.0081,
+      "suggested_scalar": 0.0287,
+      "log_bad": 5.5134,
+      "log_good": 5.5215
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 23.0,
+      "good": 27.0,
+      "ratio": 1.1739,
+      "suggested_scalar": 0.573,
+      "log_bad": 3.1355,
+      "log_good": 3.2958
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1416.2313,
+      "good": 1220.674,
+      "ratio": 0.8619,
+      "suggested_scalar": -0.5311,
+      "log_bad": 7.2558,
+      "log_good": 7.1072
+    },
+    "readability.mean_total_lines": {
+      "bad": 36.0,
+      "good": 36.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5835,
+      "log_good": 3.5835
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1380.528,
+      "good": 1430.9582,
+      "ratio": 1.0365,
+      "suggested_scalar": 0.1282,
+      "log_bad": 7.2302,
+      "log_good": 7.2661
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 495.0,
+      "good": 503.0,
+      "ratio": 1.0162,
+      "suggested_scalar": 0.0573,
+      "log_bad": 6.2046,
+      "log_good": 6.2206
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 28.25,
+      "good": 29.1667,
+      "ratio": 1.0324,
+      "suggested_scalar": 0.1141,
+      "log_bad": 3.3411,
+      "log_good": 3.373
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.127,
+      "good": 1.1212,
+      "ratio": 0.9949,
+      "suggested_scalar": -0.0184,
+      "log_bad": 0.1196,
+      "log_good": 0.1144
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 23.0,
+      "good": 26.0,
+      "ratio": 1.1304,
+      "suggested_scalar": 0.4382,
+      "log_bad": 3.1355,
+      "log_good": 3.2581
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.891,
+      "good": 0.8708,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.082,
+      "log_bad": -0.1154,
+      "log_good": -0.1383
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9856,
+      "good": 0.9866,
+      "ratio": 1.001,
+      "suggested_scalar": 0.0036,
+      "log_bad": -0.0145,
+      "log_good": -0.0135
+    },
+    "halstead.mean_length": {
+      "bad": 219.0,
+      "good": 227.0,
+      "ratio": 1.0365,
+      "suggested_scalar": 0.1282,
+      "log_bad": 5.3891,
+      "log_good": 5.425
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.3219,
+      "good": 6.3399,
+      "ratio": 1.0028,
+      "suggested_scalar": 0.0102,
+      "log_bad": 1.844,
+      "log_good": 1.8469
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1161,
+      "good": 0.109,
+      "ratio": 0.9388,
+      "suggested_scalar": -0.2255,
+      "log_bad": -2.1533,
+      "log_good": -2.2164
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 18.4655,
+      "good": 15.3548,
+      "ratio": 0.8315,
+      "suggested_scalar": -0.6593,
+      "log_bad": 2.9159,
+      "log_good": 2.7314
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 4.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.9459,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 53.0,
+      "good": 57.0,
+      "ratio": 1.0755,
+      "suggested_scalar": 0.26,
+      "log_bad": 3.9703,
+      "log_good": 4.0431
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8136,
+      "good": 0.7955,
+      "ratio": 0.9778,
+      "suggested_scalar": -0.0804,
+      "log_bad": -0.2063,
+      "log_good": -0.2288
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 36.0,
+      "good": 36.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5835,
+      "log_good": 3.5835
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_array_constructor_with_arguments": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 14.0,
+      "good": 16.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.0632,
+      "log_bad": 2.6391,
+      "log_good": 2.7726
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.079,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.2,
+      "good": 2.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0451,
+      "log_bad": 0.7885,
+      "log_good": 0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.76,
+      "good": 0.7143,
+      "ratio": 0.9399,
+      "suggested_scalar": -0.0293,
+      "log_bad": -0.2744,
+      "log_good": -0.3365
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5714,
+      "good": 4.7014,
+      "ratio": 1.0284,
+      "suggested_scalar": 0.0133,
+      "log_bad": 1.5198,
+      "log_good": 1.5479
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 53.0,
+      "good": 53.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9703,
+      "log_good": 3.9703
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.245,
+      "good": 0.2533,
+      "ratio": 1.0339,
+      "suggested_scalar": 0.0158,
+      "log_bad": -1.4065,
+      "log_good": -1.3732
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.4055,
+      "good": 0.4081,
+      "ratio": 1.0064,
+      "suggested_scalar": 0.003,
+      "log_bad": -0.9026,
+      "log_good": -0.8962
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.28,
+      "good": 2.0476,
+      "ratio": 0.8981,
+      "suggested_scalar": -0.0509,
+      "log_bad": 0.8242,
+      "log_good": 0.7167
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 422.0,
+      "good": 412.0,
+      "ratio": 0.9763,
+      "suggested_scalar": -0.0113,
+      "log_bad": 6.045,
+      "log_good": 6.021
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0365,
+      "good": 1.0315,
+      "ratio": 0.9952,
+      "suggested_scalar": -0.0023,
+      "log_bad": 0.0358,
+      "log_good": 0.031
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 131.0,
+      "good": 114.0,
+      "ratio": 0.8702,
+      "suggested_scalar": -0.0658,
+      "log_bad": 4.8752,
+      "log_good": 4.7362
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 106.1064,
+      "good": 103.0591,
+      "ratio": 0.9713,
+      "suggested_scalar": -0.0138,
+      "log_bad": 4.6644,
+      "log_good": 4.6353
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7482,
+      "good": 0.7737,
+      "ratio": 1.0341,
+      "suggested_scalar": 0.0159,
+      "log_bad": -0.2901,
+      "log_good": -0.2566
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.0182,
+      "good": 14.9517,
+      "ratio": 1.1485,
+      "suggested_scalar": 0.0655,
+      "log_bad": 2.5663,
+      "log_good": 2.7048
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1357.0,
+      "good": 1309.0,
+      "ratio": 0.9646,
+      "suggested_scalar": -0.017,
+      "log_bad": 7.213,
+      "log_good": 7.177
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.16,
+      "good": 0.1429,
+      "ratio": 0.8931,
+      "suggested_scalar": -0.0535,
+      "log_bad": -1.8326,
+      "log_good": -1.9456
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.66,
+      "good": 0.6429,
+      "ratio": 0.9741,
+      "suggested_scalar": -0.0124,
+      "log_bad": -0.4155,
+      "log_good": -0.4418
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.44,
+      "good": 9.8095,
+      "ratio": 1.1623,
+      "suggested_scalar": 0.0712,
+      "log_bad": 2.133,
+      "log_good": 2.2834
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.2016,
+      "good": 3.712,
+      "ratio": 1.1594,
+      "suggested_scalar": 0.07,
+      "log_bad": 1.1637,
+      "log_good": 1.3116
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 108.0,
+      "good": 90.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0863,
+      "log_bad": 4.6821,
+      "log_good": 4.4998
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.8279,
+      "good": 0.8277,
+      "ratio": 0.9998,
+      "suggested_scalar": -0.0001,
+      "log_bad": -0.1889,
+      "log_good": -0.1891
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6699,
+      "good": 0.67,
+      "ratio": 1.0001,
+      "suggested_scalar": 0.0001,
+      "log_bad": -0.4006,
+      "log_good": -0.4005
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.6143,
+      "good": 0.639,
+      "ratio": 1.0402,
+      "suggested_scalar": 0.0187,
+      "log_bad": -0.4873,
+      "log_good": -0.4479
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.029,
+      "good": 3.0301,
+      "ratio": 1.0004,
+      "suggested_scalar": 0.0002,
+      "log_bad": 1.1082,
+      "log_good": 1.1086
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 420.0,
+      "good": 410.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0114,
+      "log_bad": 6.0403,
+      "log_good": 6.0162
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 19.0,
+      "good": 18.0,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.0256,
+      "log_bad": 2.9444,
+      "log_good": 2.8904
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 0.0146,
+      "ratio": 0.0146,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -4.2267
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.5546,
+      "good": 5.585,
+      "ratio": 1.0055,
+      "suggested_scalar": 0.0026,
+      "log_bad": 1.7146,
+      "log_good": 1.7201
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 9.0,
+      "good": 7.0,
+      "ratio": 0.7778,
+      "suggested_scalar": -0.1189,
+      "log_bad": 2.1972,
+      "log_good": 1.9459
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8398,
+      "good": 0.974,
+      "ratio": 1.1598,
+      "suggested_scalar": 0.0701,
+      "log_bad": -0.1746,
+      "log_good": -0.0263
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.1108,
+      "good": 5.1149,
+      "ratio": 1.0008,
+      "suggested_scalar": 0.0004,
+      "log_bad": 1.6314,
+      "log_good": 1.6322
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.823,
+      "good": 0.8418,
+      "ratio": 1.0228,
+      "suggested_scalar": 0.0107,
+      "log_bad": -0.1948,
+      "log_good": -0.1722
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1525,
+      "good": 0.2075,
+      "ratio": 1.3607,
+      "suggested_scalar": 0.1457,
+      "log_bad": -1.8806,
+      "log_good": -1.5726
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6081,
+      "good": 3.8667,
+      "ratio": 1.0717,
+      "suggested_scalar": 0.0328,
+      "log_bad": 1.2832,
+      "log_good": 1.3524
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 243.0,
+      "good": 233.0,
+      "ratio": 0.9588,
+      "suggested_scalar": -0.0199,
+      "log_bad": 5.4931,
+      "log_good": 5.451
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 22.0,
+      "good": 24.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0412,
+      "log_bad": 3.091,
+      "log_good": 3.1781
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8038,
+      "good": 0.7828,
+      "ratio": 0.9739,
+      "suggested_scalar": -0.0125,
+      "log_bad": -0.2184,
+      "log_good": -0.2449
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 52.0,
+      "good": 52.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9512,
+      "log_good": 3.9512
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 563.0,
+      "good": 550.0,
+      "ratio": 0.9769,
+      "suggested_scalar": -0.0111,
+      "log_bad": 6.3333,
+      "log_good": 6.3099
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 163.0,
+      "good": 139.0,
+      "ratio": 0.8528,
+      "suggested_scalar": -0.0754,
+      "log_bad": 5.0938,
+      "log_good": 4.9345
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 0.017,
+      "ratio": 0.017,
+      "suggested_scalar": -1.928,
+      "log_bad": 0.0,
+      "log_good": -4.0745
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.237,
+      "good": 0.2233,
+      "ratio": 0.9422,
+      "suggested_scalar": -0.0282,
+      "log_bad": -1.4397,
+      "log_good": -1.4992
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 78.0,
+      "good": 87.0,
+      "ratio": 1.1154,
+      "suggested_scalar": 0.0517,
+      "log_bad": 4.3567,
+      "log_good": 4.4659
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0863,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 52.0,
+      "good": 52.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9512,
+      "log_good": 3.9512
+    },
+    "brevity.mean_sample_size": {
+      "bad": 52.0,
+      "good": 52.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9512,
+      "log_good": 3.9512
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 422.0,
+      "good": 412.0,
+      "ratio": 0.9763,
+      "suggested_scalar": -0.0113,
+      "log_bad": 6.045,
+      "log_good": 6.021
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 230.0,
+      "good": 245.0,
+      "ratio": 1.0652,
+      "suggested_scalar": 0.0299,
+      "log_bad": 5.4381,
+      "log_good": 5.5013
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 184.0,
+      "good": 180.0,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.0104,
+      "log_bad": 5.2149,
+      "log_good": 5.193
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 5.0587,
+      "good": 4.794,
+      "ratio": 0.9477,
+      "suggested_scalar": -0.0254,
+      "log_bad": 1.6211,
+      "log_good": 1.5674
+    },
+    "halstead.mean_effort": {
+      "bad": 139475.4174,
+      "good": 115831.4856,
+      "ratio": 0.8305,
+      "suggested_scalar": -0.0879,
+      "log_bad": 11.8456,
+      "log_good": 11.6599
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8966,
+      "good": 0.8973,
+      "ratio": 1.0008,
+      "suggested_scalar": 0.0004,
+      "log_bad": -0.1091,
+      "log_good": -0.1084
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 31.0,
+      "good": 31.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.434,
+      "log_good": 3.434
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 258.0,
+      "good": 271.0,
+      "ratio": 1.0504,
+      "suggested_scalar": 0.0233,
+      "log_bad": 5.553,
+      "log_good": 5.6021
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.2061,
+      "good": 0.2368,
+      "ratio": 1.149,
+      "suggested_scalar": 0.0657,
+      "log_bad": -1.5794,
+      "log_good": -1.4405
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.2977,
+      "good": 4.8246,
+      "ratio": 1.1226,
+      "suggested_scalar": 0.0547,
+      "log_bad": 1.4581,
+      "log_good": 1.5737
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1525,
+      "good": 0.2075,
+      "ratio": 1.3607,
+      "suggested_scalar": 0.1457,
+      "log_bad": -1.8806,
+      "log_good": -1.5726
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.8229,
+      "good": 4.4366,
+      "ratio": 1.1605,
+      "suggested_scalar": 0.0704,
+      "log_bad": 1.341,
+      "log_good": 1.4899
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 421.0,
+      "good": 411.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0114,
+      "log_bad": 6.0426,
+      "log_good": 6.0186
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 81.0,
+      "good": 85.0,
+      "ratio": 1.0494,
+      "suggested_scalar": 0.0228,
+      "log_bad": 4.3944,
+      "log_good": 4.4427
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 7748.6343,
+      "good": 6435.0825,
+      "ratio": 0.8305,
+      "suggested_scalar": -0.0879,
+      "log_bad": 8.9553,
+      "log_good": 8.7695
+    },
+    "readability.mean_total_lines": {
+      "bad": 50.0,
+      "good": 42.0,
+      "ratio": 0.84,
+      "suggested_scalar": -0.0825,
+      "log_bad": 3.912,
+      "log_good": 3.7377
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2411.4545,
+      "good": 2348.4474,
+      "ratio": 0.9739,
+      "suggested_scalar": -0.0125,
+      "log_bad": 7.788,
+      "log_good": 7.7615
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 448.0,
+      "good": 432.0,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.0172,
+      "log_bad": 6.1048,
+      "log_good": 6.0684
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 25.96,
+      "good": 29.9048,
+      "ratio": 1.152,
+      "suggested_scalar": 0.0669,
+      "log_bad": 3.2566,
+      "log_good": 3.398
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0894,
+      "good": 1.109,
+      "ratio": 1.018,
+      "suggested_scalar": 0.0084,
+      "log_bad": 0.0856,
+      "log_good": 0.1035
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 8.0,
+      "good": 14.0,
+      "ratio": 1.75,
+      "suggested_scalar": 0.2648,
+      "log_bad": 2.0794,
+      "log_good": 2.6391
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6667,
+      "good": 0.6352,
+      "ratio": 0.9528,
+      "suggested_scalar": -0.0229,
+      "log_bad": -0.4054,
+      "log_good": -0.4538
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9043,
+      "good": 0.9159,
+      "ratio": 1.0128,
+      "suggested_scalar": 0.006,
+      "log_bad": -0.1006,
+      "log_good": -0.0878
+    },
+    "halstead.mean_length": {
+      "bad": 421.0,
+      "good": 410.0,
+      "ratio": 0.9739,
+      "suggested_scalar": -0.0125,
+      "log_bad": 6.0426,
+      "log_good": 6.0162
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.8,
+      "good": 8.8333,
+      "ratio": 0.7486,
+      "suggested_scalar": -0.137,
+      "log_bad": 2.4681,
+      "log_good": 2.1785
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.7004,
+      "good": 5.7004,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7405,
+      "log_good": 1.7405
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1695,
+      "good": 0.1872,
+      "ratio": 1.1044,
+      "suggested_scalar": 0.047,
+      "log_bad": -1.7749,
+      "log_good": -1.6756
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 57.8387,
+      "good": 49.3226,
+      "ratio": 0.8528,
+      "suggested_scalar": -0.0754,
+      "log_bad": 4.0577,
+      "log_good": 3.8984
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 6.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1361,
+      "log_bad": 2.0794,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5761,
+      "good": 0.5167,
+      "ratio": 0.8969,
+      "suggested_scalar": -0.0515,
+      "log_bad": -0.5515,
+      "log_good": -0.6603
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 50.0,
+      "good": 42.0,
+      "ratio": 0.84,
+      "suggested_scalar": -0.0825,
+      "log_bad": 3.912,
+      "log_good": 3.7377
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1919,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.getter_not_prefixed_with_get": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 25.0,
+      "good": 27.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.1812,
+      "log_bad": 3.2189,
+      "log_good": 3.2958
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0152,
+      "good": 0.0065,
+      "ratio": 0.4276,
+      "suggested_scalar": -2.0,
+      "log_bad": -4.1865,
+      "log_good": -5.036
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1429,
+      "good": 1.1429,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1336,
+      "log_good": 0.1336
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9024,
+      "good": 0.9,
+      "ratio": 0.9973,
+      "suggested_scalar": -0.0063,
+      "log_bad": -0.1027,
+      "log_good": -0.1054
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0152,
+      "good": 0.0065,
+      "ratio": 0.4276,
+      "suggested_scalar": -2.0,
+      "log_bad": -4.1865,
+      "log_good": -5.036
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7762,
+      "good": 4.7518,
+      "ratio": 0.9949,
+      "suggested_scalar": -0.0121,
+      "log_bad": 1.5636,
+      "log_good": 1.5585
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 84.0,
+      "good": 82.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0567,
+      "log_bad": 4.4308,
+      "log_good": 4.4067
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4204,
+      "good": 0.4447,
+      "ratio": 1.0578,
+      "suggested_scalar": 0.1323,
+      "log_bad": -0.8665,
+      "log_good": -0.8104
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5859,
+      "good": 0.5984,
+      "ratio": 1.0213,
+      "suggested_scalar": 0.0497,
+      "log_bad": -0.5346,
+      "log_good": -0.5135
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.4634,
+      "good": 0.475,
+      "ratio": 1.025,
+      "suggested_scalar": 0.0582,
+      "log_bad": -0.7692,
+      "log_good": -0.7444
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 329.0,
+      "good": 306.0,
+      "ratio": 0.9301,
+      "suggested_scalar": -0.1706,
+      "log_bad": 5.7961,
+      "log_good": 5.7236
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2927,
+      "good": 0.275,
+      "ratio": 0.9395,
+      "suggested_scalar": -0.1469,
+      "log_bad": -1.2286,
+      "log_good": -1.291
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9774,
+      "good": 0.9905,
+      "ratio": 1.0134,
+      "suggested_scalar": 0.0313,
+      "log_bad": -0.0229,
+      "log_good": -0.0095
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 150.0,
+      "good": 137.0,
+      "ratio": 0.9133,
+      "suggested_scalar": -0.2134,
+      "log_bad": 5.0106,
+      "log_good": 4.92
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.6902,
+      "good": 107.0492,
+      "ratio": 1.0225,
+      "suggested_scalar": 0.0525,
+      "log_bad": 4.651,
+      "log_good": 4.6733
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5457,
+      "good": 0.4885,
+      "ratio": 0.8952,
+      "suggested_scalar": -0.2607,
+      "log_bad": -0.6057,
+      "log_good": -0.7164
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.9151,
+      "good": 7.2198,
+      "ratio": 0.9122,
+      "suggested_scalar": -0.2165,
+      "log_bad": 2.0688,
+      "log_good": 1.9768
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1394.0,
+      "good": 1272.0,
+      "ratio": 0.9125,
+      "suggested_scalar": -0.2156,
+      "log_bad": 7.2399,
+      "log_good": 7.1483
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0976,
+      "good": 0.1,
+      "ratio": 1.0246,
+      "suggested_scalar": 0.0572,
+      "log_bad": -2.3269,
+      "log_good": -2.3026
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.878,
+      "good": 0.875,
+      "ratio": 0.9966,
+      "suggested_scalar": -0.0081,
+      "log_bad": -0.1301,
+      "log_good": -0.1335
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.0244,
+      "good": 7.65,
+      "ratio": 0.9533,
+      "suggested_scalar": -0.1125,
+      "log_bad": 2.0825,
+      "log_good": 2.0347
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.4438,
+      "good": 0.4494,
+      "ratio": 1.0126,
+      "suggested_scalar": 0.0295,
+      "log_bad": -0.8124,
+      "log_good": -0.7998
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 97.0,
+      "good": 85.0,
+      "ratio": 0.8763,
+      "suggested_scalar": -0.3109,
+      "log_bad": 4.5747,
+      "log_good": 4.4427
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9203,
+      "good": 0.9236,
+      "ratio": 1.0036,
+      "suggested_scalar": 0.0084,
+      "log_bad": -0.0831,
+      "log_good": -0.0795
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 22.0,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.1047,
+      "log_bad": 3.1355,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6191,
+      "good": 0.5833,
+      "ratio": 0.9422,
+      "suggested_scalar": -0.1402,
+      "log_bad": -0.4795,
+      "log_good": -0.5391
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.367,
+      "good": 0.2862,
+      "ratio": 0.7798,
+      "suggested_scalar": -0.5855,
+      "log_bad": -1.0024,
+      "log_good": -1.2511
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6252,
+      "good": 2.4,
+      "ratio": 0.9142,
+      "suggested_scalar": -0.2112,
+      "log_bad": 0.9652,
+      "log_good": 0.8755
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 327.0,
+      "good": 304.0,
+      "ratio": 0.9297,
+      "suggested_scalar": -0.1717,
+      "log_bad": 5.79,
+      "log_good": 5.717
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0091,
+      "good": 0.0098,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.1745,
+      "log_bad": -4.6995,
+      "log_good": -4.6254
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8826,
+      "good": 5.8826,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.772,
+      "log_good": 1.772
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 41.0,
+      "good": 40.0,
+      "ratio": 0.9756,
+      "suggested_scalar": -0.0581,
+      "log_bad": 3.7136,
+      "log_good": 3.6889
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2831,
+      "good": 1.334,
+      "ratio": 1.0397,
+      "suggested_scalar": 0.0916,
+      "log_bad": 0.2493,
+      "log_good": 0.2882
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6713,
+      "good": 5.5538,
+      "ratio": 0.9793,
+      "suggested_scalar": -0.0493,
+      "log_bad": 1.7354,
+      "log_good": 1.7145
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8119,
+      "good": 0.8078,
+      "ratio": 0.995,
+      "suggested_scalar": -0.0119,
+      "log_bad": -0.2084,
+      "log_good": -0.2134
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.18,
+      "good": 0.1837,
+      "ratio": 1.0206,
+      "suggested_scalar": 0.0479,
+      "log_bad": -1.7148,
+      "log_good": -1.6945
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.8134,
+      "good": 2.687,
+      "ratio": 0.9551,
+      "suggested_scalar": -0.1082,
+      "log_bad": 1.0344,
+      "log_good": 0.9884
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 237.0,
+      "good": 242.0,
+      "ratio": 1.0211,
+      "suggested_scalar": 0.0492,
+      "log_bad": 5.4681,
+      "log_good": 5.4889
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 6.0,
+      "good": 7.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.3629,
+      "log_bad": 1.7918,
+      "log_good": 1.9459
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6648,
+      "good": 0.6315,
+      "ratio": 0.9499,
+      "suggested_scalar": -0.121,
+      "log_bad": -0.4083,
+      "log_good": -0.4597
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 87.0,
+      "good": 85.0,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0548,
+      "log_bad": 4.4659,
+      "log_good": 4.4427
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 819.0,
+      "good": 741.0,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.2356,
+      "log_bad": 6.7081,
+      "log_good": 6.608
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 160.0,
+      "good": 147.0,
+      "ratio": 0.9187,
+      "suggested_scalar": -0.1995,
+      "log_bad": 5.0752,
+      "log_good": 4.9904
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1611,
+      "good": 0.1732,
+      "ratio": 1.0751,
+      "suggested_scalar": 0.1705,
+      "log_bad": -1.8257,
+      "log_good": -1.7533
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 42.0,
+      "good": 37.0,
+      "ratio": 0.881,
+      "suggested_scalar": -0.2984,
+      "log_bad": 3.7377,
+      "log_good": 3.6109
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 87.0,
+      "good": 85.0,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0548,
+      "log_bad": 4.4659,
+      "log_good": 4.4427
+    },
+    "brevity.mean_sample_size": {
+      "bad": 87.0,
+      "good": 85.0,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0548,
+      "log_bad": 4.4659,
+      "log_good": 4.4427
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 329.0,
+      "good": 306.0,
+      "ratio": 0.9301,
+      "suggested_scalar": -0.1706,
+      "log_bad": 5.7961,
+      "log_good": 5.7236
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 140.0,
+      "good": 135.0,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.0856,
+      "log_bad": 4.9416,
+      "log_good": 4.9053
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 191.0,
+      "good": 193.0,
+      "ratio": 1.0105,
+      "suggested_scalar": 0.0245,
+      "log_bad": 5.2523,
+      "log_good": 5.2627
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 3.0568,
+      "good": 2.892,
+      "ratio": 0.9461,
+      "suggested_scalar": -0.1305,
+      "log_bad": 1.1174,
+      "log_good": 1.0619
+    },
+    "halstead.mean_effort": {
+      "bad": 60159.0424,
+      "good": 51058.1359,
+      "ratio": 0.8487,
+      "suggested_scalar": -0.3862,
+      "log_bad": 11.0047,
+      "log_good": 10.8407
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8802,
+      "good": 0.8665,
+      "ratio": 0.9844,
+      "suggested_scalar": -0.0369,
+      "log_bad": -0.1276,
+      "log_good": -0.1433
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 61.0,
+      "good": 60.0,
+      "ratio": 0.9836,
+      "suggested_scalar": -0.0389,
+      "log_bad": 4.1109,
+      "log_good": 4.0943
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 152.0,
+      "good": 151.0,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0155,
+      "log_bad": 5.0239,
+      "log_good": 5.0173
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.36,
+      "good": 0.3869,
+      "ratio": 1.0747,
+      "suggested_scalar": 0.1697,
+      "log_bad": -1.0217,
+      "log_good": -0.9496
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.46,
+      "good": 5.4088,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.0222,
+      "log_bad": 1.6974,
+      "log_good": 1.688
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.18,
+      "good": 0.1837,
+      "ratio": 1.0206,
+      "suggested_scalar": 0.0479,
+      "log_bad": -1.7148,
+      "log_good": -1.6945
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.633,
+      "good": 3.06,
+      "ratio": 0.8423,
+      "suggested_scalar": -0.4041,
+      "log_bad": 1.2901,
+      "log_good": 1.1184
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 328.0,
+      "good": 305.0,
+      "ratio": 0.9299,
+      "suggested_scalar": -0.1712,
+      "log_bad": 5.793,
+      "log_good": 5.7203
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 30.0,
+      "good": 25.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.4292,
+      "log_bad": 3.4012,
+      "log_good": 3.2189
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3342.169,
+      "good": 2836.5631,
+      "ratio": 0.8487,
+      "suggested_scalar": -0.3862,
+      "log_bad": 8.1144,
+      "log_good": 7.9503
+    },
+    "readability.mean_total_lines": {
+      "bad": 41.0,
+      "good": 40.0,
+      "ratio": 0.9756,
+      "suggested_scalar": -0.0581,
+      "log_bad": 3.7136,
+      "log_good": 3.6889
+    },
+    "indentation.mean_max_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_volume": {
+      "bad": 1994.403,
+      "good": 1894.5505,
+      "ratio": 0.9499,
+      "suggested_scalar": -0.1209,
+      "log_bad": 7.5981,
+      "log_good": 7.5467
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 531.0,
+      "good": 530.0,
+      "ratio": 0.9981,
+      "suggested_scalar": -0.0044,
+      "log_bad": 6.2748,
+      "log_good": 6.2729
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.5854,
+      "good": 30.525,
+      "ratio": 0.9368,
+      "suggested_scalar": -0.1538,
+      "log_bad": 3.4839,
+      "log_good": 3.4185
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1111,
+      "good": 1.0877,
+      "ratio": 0.9789,
+      "suggested_scalar": -0.0501,
+      "log_bad": 0.1054,
+      "log_good": 0.0841
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 23.0,
+      "good": 22.0,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.1047,
+      "log_bad": 3.1355,
+      "log_good": 3.091
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 12.0,
+      "good": 11.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.2049,
+      "log_bad": 2.4849,
+      "log_good": 2.3979
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8734,
+      "good": 0.8967,
+      "ratio": 1.0267,
+      "suggested_scalar": 0.062,
+      "log_bad": -0.1354,
+      "log_good": -0.109
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9421,
+      "good": 0.9504,
+      "ratio": 1.0088,
+      "suggested_scalar": 0.0207,
+      "log_bad": -0.0596,
+      "log_good": -0.0509
+    },
+    "halstead.mean_length": {
+      "bad": 312.0,
+      "good": 298.0,
+      "ratio": 0.9551,
+      "suggested_scalar": -0.1081,
+      "log_bad": 5.743,
+      "log_good": 5.6971
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.2857,
+      "good": 5.1429,
+      "ratio": 0.973,
+      "suggested_scalar": -0.0645,
+      "log_bad": 1.665,
+      "log_good": 1.6376
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4429,
+      "good": 6.4094,
+      "ratio": 0.9948,
+      "suggested_scalar": -0.0123,
+      "log_bad": 1.863,
+      "log_good": 1.8578
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.101,
+      "good": 0.1063,
+      "ratio": 1.0525,
+      "suggested_scalar": 0.1204,
+      "log_bad": -2.2926,
+      "log_good": -2.2415
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.1639,
+      "good": 26.95,
+      "ratio": 0.8935,
+      "suggested_scalar": -0.2652,
+      "log_bad": 3.4066,
+      "log_good": 3.294
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 54.0,
+      "good": 53.0,
+      "ratio": 0.9815,
+      "suggested_scalar": -0.044,
+      "log_bad": 3.989,
+      "log_good": 3.9703
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7801,
+      "good": 0.8083,
+      "ratio": 1.0361,
+      "suggested_scalar": 0.0836,
+      "log_bad": -0.2483,
+      "log_good": -0.2128
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 41.0,
+      "good": 40.0,
+      "ratio": 0.9756,
+      "suggested_scalar": -0.0581,
+      "log_bad": 3.7136,
+      "log_good": 3.6889
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 12.0,
+      "good": 11.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.2049,
+      "log_bad": 2.4849,
+      "log_good": 2.3979
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.uses_custom_error_type_with_context": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 2.0,
+      "good": 6.0,
+      "ratio": 3.0,
+      "suggested_scalar": 1.0442,
+      "log_bad": 0.6931,
+      "log_good": 1.7918
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0102,
+      "good": 0.0079,
+      "ratio": 0.7745,
+      "suggested_scalar": -0.2429,
+      "log_bad": -4.5854,
+      "log_good": -4.8409
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.25,
+      "good": 2.25,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.8109,
+      "log_good": 0.8109
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8478,
+      "good": 0.8254,
+      "ratio": 0.9736,
+      "suggested_scalar": -0.0254,
+      "log_bad": -0.1651,
+      "log_good": -0.1919
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0127,
+      "good": 0.0059,
+      "ratio": 0.4646,
+      "suggested_scalar": -0.7287,
+      "log_bad": -4.3662,
+      "log_good": -5.1328
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5292,
+      "good": 4.5341,
+      "ratio": 1.0011,
+      "suggested_scalar": 0.001,
+      "log_bad": 1.5105,
+      "log_good": 1.5116
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 111.0,
+      "good": 88.0,
+      "ratio": 0.7928,
+      "suggested_scalar": -0.2207,
+      "log_bad": 4.7095,
+      "log_good": 4.4773
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5807,
+      "good": 0.4416,
+      "ratio": 0.7605,
+      "suggested_scalar": -0.2603,
+      "log_bad": -0.5435,
+      "log_good": -0.8174
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7406,
+      "good": 0.6064,
+      "ratio": 0.8188,
+      "suggested_scalar": -0.19,
+      "log_bad": -0.3003,
+      "log_good": -0.5002
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 7.1304,
+      "good": 7.1746,
+      "ratio": 1.0062,
+      "suggested_scalar": 0.0059,
+      "log_bad": 1.9644,
+      "log_good": 1.9705
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 393.0,
+      "good": 509.0,
+      "ratio": 1.2952,
+      "suggested_scalar": 0.2458,
+      "log_bad": 5.9738,
+      "log_good": 6.2324
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.1733,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0012,
+      "good": 0.0023,
+      "ratio": 1.9167,
+      "suggested_scalar": 0.6183,
+      "log_bad": -6.7254,
+      "log_good": -6.0748
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1304,
+      "good": 0.0159,
+      "ratio": 0.1219,
+      "suggested_scalar": -2.0,
+      "log_bad": -2.0371,
+      "log_good": -4.1414
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9068,
+      "good": 1.0925,
+      "ratio": 1.2048,
+      "suggested_scalar": 0.1771,
+      "log_bad": -0.0978,
+      "log_good": 0.0885
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 128.0,
+      "good": 150.0,
+      "ratio": 1.1719,
+      "suggested_scalar": 0.1507,
+      "log_bad": 4.852,
+      "log_good": 5.0106
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.4777,
+      "good": 90.5365,
+      "ratio": 0.8922,
+      "suggested_scalar": -0.1084,
+      "log_bad": 4.6198,
+      "log_good": 4.5058
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5408,
+      "good": 0.6614,
+      "ratio": 1.223,
+      "suggested_scalar": 0.1913,
+      "log_bad": -0.6147,
+      "log_good": -0.4134
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.3398,
+      "good": 13.7151,
+      "ratio": 1.6445,
+      "suggested_scalar": 0.4728,
+      "log_bad": 2.121,
+      "log_good": 2.6185
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1665.0,
+      "good": 2182.0,
+      "ratio": 1.3105,
+      "suggested_scalar": 0.257,
+      "log_bad": 7.4176,
+      "log_good": 7.688
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.087,
+      "good": 0.0952,
+      "ratio": 1.0943,
+      "suggested_scalar": 0.0856,
+      "log_bad": -2.4418,
+      "log_good": -2.3518
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8043,
+      "good": 0.7778,
+      "ratio": 0.9671,
+      "suggested_scalar": -0.0318,
+      "log_bad": -0.2178,
+      "log_good": -0.2513
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.5435,
+      "good": 8.2097,
+      "ratio": 0.9609,
+      "suggested_scalar": -0.0379,
+      "log_bad": 2.1452,
+      "log_good": 2.1053
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 8.0,
+      "good": 10.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.2121,
+      "log_bad": 2.0794,
+      "log_good": 2.3026
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 15.9395,
+      "good": 24.9695,
+      "ratio": 1.5665,
+      "suggested_scalar": 0.4266,
+      "log_bad": 2.7688,
+      "log_good": 3.2177
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 95.0,
+      "good": 94.0,
+      "ratio": 0.9895,
+      "suggested_scalar": -0.0101,
+      "log_bad": 4.5539,
+      "log_good": 4.5433
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9449,
+      "good": 0.9566,
+      "ratio": 1.0124,
+      "suggested_scalar": 0.0117,
+      "log_bad": -0.0567,
+      "log_good": -0.0444
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 32.0,
+      "good": 31.0,
+      "ratio": 0.9688,
+      "suggested_scalar": -0.0302,
+      "log_bad": 3.4657,
+      "log_good": 3.434
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5814,
+      "good": 0.6586,
+      "ratio": 1.1328,
+      "suggested_scalar": 0.1185,
+      "log_bad": -0.5423,
+      "log_good": -0.4176
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3018,
+      "good": 0.3964,
+      "ratio": 1.3135,
+      "suggested_scalar": 0.2591,
+      "log_bad": -1.198,
+      "log_good": -0.9253
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3888,
+      "good": 2.9289,
+      "ratio": 1.2261,
+      "suggested_scalar": 0.1937,
+      "log_bad": 0.8708,
+      "log_good": 1.0746
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 391.0,
+      "good": 507.0,
+      "ratio": 1.2967,
+      "suggested_scalar": 0.2469,
+      "log_bad": 5.9687,
+      "log_good": 6.2285
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 16.0,
+      "good": 26.0,
+      "ratio": 1.625,
+      "suggested_scalar": 0.4614,
+      "log_bad": 2.7726,
+      "log_good": 3.2581
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0483,
+      "good": 0.0806,
+      "ratio": 1.6687,
+      "suggested_scalar": 0.4867,
+      "log_bad": -3.0303,
+      "log_good": -2.5183
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0224,
+      "good": 6.0224,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7955,
+      "log_good": 1.7955
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 25.0,
+      "good": 46.0,
+      "ratio": 1.84,
+      "suggested_scalar": 0.5795,
+      "log_bad": 3.2189,
+      "log_good": 3.8286
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0294,
+      "good": 1.2059,
+      "ratio": 1.1715,
+      "suggested_scalar": 0.1504,
+      "log_bad": 0.029,
+      "log_good": 0.1872
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.039,
+      "good": 5.5308,
+      "ratio": 0.9158,
+      "suggested_scalar": -0.0835,
+      "log_bad": 1.7982,
+      "log_good": 1.7103
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7521,
+      "good": 0.7529,
+      "ratio": 1.0011,
+      "suggested_scalar": 0.001,
+      "log_bad": -0.2849,
+      "log_good": -0.2838
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.098,
+      "good": 0.1,
+      "ratio": 1.0204,
+      "suggested_scalar": 0.0192,
+      "log_bad": -2.3228,
+      "log_good": -2.3026
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.8879,
+      "good": 3.7034,
+      "ratio": 1.2824,
+      "suggested_scalar": 0.2364,
+      "log_bad": 1.0605,
+      "log_good": 1.3093
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 325.0,
+      "good": 387.0,
+      "ratio": 1.1908,
+      "suggested_scalar": 0.1659,
+      "log_bad": 5.7838,
+      "log_good": 5.9584
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 7.0,
+      "good": 15.0,
+      "ratio": 2.1429,
+      "suggested_scalar": 0.7244,
+      "log_bad": 1.9459,
+      "log_good": 2.7081
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8131,
+      "good": 0.9775,
+      "ratio": 1.2022,
+      "suggested_scalar": 0.175,
+      "log_bad": -0.2069,
+      "log_good": -0.0228
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 116.0,
+      "good": 98.0,
+      "ratio": 0.8448,
+      "suggested_scalar": -0.1603,
+      "log_bad": 4.7536,
+      "log_good": 4.585
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 712.0,
+      "good": 981.0,
+      "ratio": 1.3778,
+      "suggested_scalar": 0.3046,
+      "log_bad": 6.5681,
+      "log_good": 6.8886
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 147.0,
+      "good": 149.0,
+      "ratio": 1.0136,
+      "suggested_scalar": 0.0128,
+      "log_bad": 4.9904,
+      "log_good": 5.0039
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0102,
+      "good": 0.0157,
+      "ratio": 1.5392,
+      "suggested_scalar": 0.4099,
+      "log_bad": -4.5854,
+      "log_good": -4.1541
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2468,
+      "good": 0.2574,
+      "ratio": 1.0429,
+      "suggested_scalar": 0.04,
+      "log_bad": -1.3992,
+      "log_good": -1.3571
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 81.0,
+      "good": 108.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.2734,
+      "log_bad": 4.3944,
+      "log_good": 4.6821
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 116.0,
+      "good": 98.0,
+      "ratio": 0.8448,
+      "suggested_scalar": -0.1603,
+      "log_bad": 4.7536,
+      "log_good": 4.585
+    },
+    "brevity.mean_sample_size": {
+      "bad": 116.0,
+      "good": 98.0,
+      "ratio": 0.8448,
+      "suggested_scalar": -0.1603,
+      "log_bad": 4.7536,
+      "log_good": 4.585
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 393.0,
+      "good": 509.0,
+      "ratio": 1.2952,
+      "suggested_scalar": 0.2458,
+      "log_bad": 5.9738,
+      "log_good": 6.2324
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 203.0,
+      "good": 298.0,
+      "ratio": 1.468,
+      "suggested_scalar": 0.3649,
+      "log_bad": 5.3132,
+      "log_good": 5.6971
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 261.0,
+      "good": 280.0,
+      "ratio": 1.0728,
+      "suggested_scalar": 0.0668,
+      "log_bad": 5.5645,
+      "log_good": 5.6348
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.4338,
+      "good": 2.4777,
+      "ratio": 1.7281,
+      "suggested_scalar": 0.5199,
+      "log_bad": 0.3603,
+      "log_good": 0.9073
+    },
+    "halstead.mean_effort": {
+      "bad": 72620.0929,
+      "good": 118821.018,
+      "ratio": 1.6362,
+      "suggested_scalar": 0.468,
+      "log_bad": 11.193,
+      "log_good": 11.6854
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8806,
+      "good": 0.8361,
+      "ratio": 0.9495,
+      "suggested_scalar": -0.0493,
+      "log_bad": -0.1272,
+      "log_good": -0.179
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 79.0,
+      "good": 57.0,
+      "ratio": 0.7215,
+      "suggested_scalar": -0.3102,
+      "log_bad": 4.3694,
+      "log_good": 4.0431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 212.0,
+      "good": 305.0,
+      "ratio": 1.4387,
+      "suggested_scalar": 0.3457,
+      "log_bad": 5.3566,
+      "log_good": 5.7203
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5469,
+      "good": 0.3667,
+      "ratio": 0.6705,
+      "suggested_scalar": -0.3799,
+      "log_bad": -0.6035,
+      "log_good": -1.0032
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.5625,
+      "good": 6.54,
+      "ratio": 1.1757,
+      "suggested_scalar": 0.1539,
+      "log_bad": 1.716,
+      "log_good": 1.8779
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.098,
+      "good": 0.1,
+      "ratio": 1.0204,
+      "suggested_scalar": 0.0192,
+      "log_bad": -2.3228,
+      "log_good": -2.3026
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.8407,
+      "good": 3.4743,
+      "ratio": 0.9046,
+      "suggested_scalar": -0.0953,
+      "log_bad": 1.3457,
+      "log_good": 1.2454
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 392.0,
+      "good": 508.0,
+      "ratio": 1.2959,
+      "suggested_scalar": 0.2464,
+      "log_bad": 5.9713,
+      "log_good": 6.2305
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 10.0,
+      "ratio": 3.3333,
+      "suggested_scalar": 1.1443,
+      "log_bad": 1.0986,
+      "log_good": 2.3026
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 52.0,
+      "good": 81.0,
+      "ratio": 1.5577,
+      "suggested_scalar": 0.4212,
+      "log_bad": 3.9512,
+      "log_good": 4.3944
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4034.4496,
+      "good": 6601.1677,
+      "ratio": 1.6362,
+      "suggested_scalar": 0.468,
+      "log_bad": 8.3026,
+      "log_good": 8.795
+    },
+    "readability.mean_total_lines": {
+      "bad": 46.0,
+      "good": 62.0,
+      "ratio": 1.3478,
+      "suggested_scalar": 0.2837,
+      "log_bad": 3.8286,
+      "log_good": 4.1271
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 16.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.2734,
+      "log_bad": 2.4849,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2439.1953,
+      "good": 2932.582,
+      "ratio": 1.2023,
+      "suggested_scalar": 0.1751,
+      "log_bad": 7.7994,
+      "log_good": 7.9836
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 697.0,
+      "good": 745.0,
+      "ratio": 1.0689,
+      "suggested_scalar": 0.0633,
+      "log_bad": 6.5468,
+      "log_good": 6.6134
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.0,
+      "good": 33.8065,
+      "ratio": 0.9659,
+      "suggested_scalar": -0.033,
+      "log_bad": 3.5553,
+      "log_good": 3.5207
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1429,
+      "good": 1.2762,
+      "ratio": 1.1166,
+      "suggested_scalar": 0.1049,
+      "log_bad": 0.1336,
+      "log_good": 0.2439
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.1733,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 1.0,
+      "ratio": 0.1667,
+      "suggested_scalar": -1.703,
+      "log_bad": 1.7918,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.84,
+      "good": 0.7907,
+      "ratio": 0.9413,
+      "suggested_scalar": -0.0575,
+      "log_bad": -0.1744,
+      "log_good": -0.2348
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9851,
+      "good": 0.9568,
+      "ratio": 0.9713,
+      "suggested_scalar": -0.0277,
+      "log_bad": -0.015,
+      "log_good": -0.0442
+    },
+    "halstead.mean_length": {
+      "bad": 359.0,
+      "good": 454.0,
+      "ratio": 1.2646,
+      "suggested_scalar": 0.2231,
+      "log_bad": 5.8833,
+      "log_good": 6.1181
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.25,
+      "good": 14.5,
+      "ratio": 1.4146,
+      "suggested_scalar": 0.3297,
+      "log_bad": 2.3273,
+      "log_good": 2.6741
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.858,
+      "good": 6.6147,
+      "ratio": 0.9645,
+      "suggested_scalar": -0.0343,
+      "log_bad": 1.9254,
+      "log_good": 1.8893
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1222,
+      "good": 0.1366,
+      "ratio": 1.1178,
+      "suggested_scalar": 0.1059,
+      "log_bad": -2.1021,
+      "log_good": -1.9907
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.7722,
+      "good": 40.5175,
+      "ratio": 1.3609,
+      "suggested_scalar": 0.2929,
+      "log_bad": 3.3936,
+      "log_good": 3.7017
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.3854,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 70.0,
+      "good": 55.0,
+      "ratio": 0.7857,
+      "suggested_scalar": -0.2292,
+      "log_bad": 4.2485,
+      "log_good": 4.0073
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6897,
+      "good": 0.6143,
+      "ratio": 0.8907,
+      "suggested_scalar": -0.11,
+      "log_bad": -0.3715,
+      "log_good": -0.4873
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 46.0,
+      "good": 63.0,
+      "ratio": 1.3696,
+      "suggested_scalar": 0.2989,
+      "log_bad": 3.8286,
+      "log_good": 4.1431
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 12.0,
+      "good": 19.0,
+      "ratio": 1.5833,
+      "suggested_scalar": 0.4368,
+      "log_bad": 2.4849,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "consistency.override_annotation_present": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 35.0,
+      "good": 39.0,
+      "ratio": 1.1143,
+      "suggested_scalar": 0.0973,
+      "log_bad": 3.5553,
+      "log_good": 3.6636
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.016,
+      "good": 0.0219,
+      "ratio": 1.3687,
+      "suggested_scalar": 0.2822,
+      "log_bad": -4.1352,
+      "log_good": -3.8213
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.6,
+      "good": 0.6364,
+      "ratio": 1.0607,
+      "suggested_scalar": 0.0529,
+      "log_bad": -0.5108,
+      "log_good": -0.4519
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.6892,
+      "good": 0.6494,
+      "ratio": 0.9423,
+      "suggested_scalar": -0.0535,
+      "log_bad": -0.3722,
+      "log_good": -0.4317
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.016,
+      "good": 0.0219,
+      "ratio": 1.3687,
+      "suggested_scalar": 0.2822,
+      "log_bad": -4.1352,
+      "log_good": -3.8213
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5461,
+      "good": 4.5022,
+      "ratio": 0.9903,
+      "suggested_scalar": -0.0087,
+      "log_bad": 1.5143,
+      "log_good": 1.5046
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 102.0,
+      "good": 99.0,
+      "ratio": 0.9706,
+      "suggested_scalar": -0.0268,
+      "log_bad": 4.625,
+      "log_good": 4.5951
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4674,
+      "good": 0.4301,
+      "ratio": 0.9202,
+      "suggested_scalar": -0.0748,
+      "log_bad": -0.7606,
+      "log_good": -0.8437
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 18.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0947,
+      "log_bad": 2.9957,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6294,
+      "good": 0.6019,
+      "ratio": 0.9563,
+      "suggested_scalar": -0.0402,
+      "log_bad": -0.463,
+      "log_good": -0.5077
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 7.027,
+      "good": 6.961,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.0085,
+      "log_bad": 1.9498,
+      "log_good": 1.9403
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 500.0,
+      "good": 502.0,
+      "ratio": 1.004,
+      "suggested_scalar": 0.0036,
+      "log_bad": 6.2146,
+      "log_good": 6.2186
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0004,
+      "good": 0.0004,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.824,
+      "log_good": -7.824
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1081,
+      "good": 1.0,
+      "ratio": 9.2507,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.2247,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0029,
+      "good": 0.003,
+      "ratio": 1.0345,
+      "suggested_scalar": 0.0305,
+      "log_bad": -5.843,
+      "log_good": -5.8091
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0401,
+      "good": 1.0738,
+      "ratio": 1.0324,
+      "suggested_scalar": 0.0287,
+      "log_bad": 0.0393,
+      "log_good": 0.0712
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 172.0,
+      "good": 168.0,
+      "ratio": 0.9767,
+      "suggested_scalar": -0.0212,
+      "log_bad": 5.1475,
+      "log_good": 5.124
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 96.8706,
+      "good": 94.8523,
+      "ratio": 0.9792,
+      "suggested_scalar": -0.0189,
+      "log_bad": 4.5734,
+      "log_good": 4.5523
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6954,
+      "good": 0.6926,
+      "ratio": 0.996,
+      "suggested_scalar": -0.0036,
+      "log_bad": -0.3633,
+      "log_good": -0.3673
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.3296,
+      "good": 10.8245,
+      "ratio": 1.0479,
+      "suggested_scalar": 0.0421,
+      "log_bad": 2.335,
+      "log_good": 2.3818
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2418.0,
+      "good": 2364.0,
+      "ratio": 0.9777,
+      "suggested_scalar": -0.0203,
+      "log_bad": 7.7907,
+      "log_good": 7.7681
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0541,
+      "good": 0.0519,
+      "ratio": 0.9593,
+      "suggested_scalar": -0.0373,
+      "log_bad": -2.9169,
+      "log_good": -2.9584
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6486,
+      "good": 0.6104,
+      "ratio": 0.9411,
+      "suggested_scalar": -0.0546,
+      "log_bad": -0.4329,
+      "log_good": -0.4936
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.7568,
+      "good": 6.5195,
+      "ratio": 0.9649,
+      "suggested_scalar": -0.0321,
+      "log_bad": 1.9105,
+      "log_good": 1.8748
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 17.2155,
+      "good": 16.7907,
+      "ratio": 0.9753,
+      "suggested_scalar": -0.0225,
+      "log_bad": 2.8458,
+      "log_good": 2.8208
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 76.0,
+      "good": 73.0,
+      "ratio": 0.9605,
+      "suggested_scalar": -0.0362,
+      "log_bad": 4.3307,
+      "log_good": 4.2905
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9521,
+      "good": 0.9581,
+      "ratio": 1.0063,
+      "suggested_scalar": 0.0056,
+      "log_bad": -0.0491,
+      "log_good": -0.0428
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 26.0,
+      "ratio": 0.963,
+      "suggested_scalar": -0.0339,
+      "log_bad": 3.2958,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6816,
+      "good": 0.6823,
+      "ratio": 1.001,
+      "suggested_scalar": 0.0009,
+      "log_bad": -0.3833,
+      "log_good": -0.3823
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5402,
+      "good": 0.526,
+      "ratio": 0.9737,
+      "suggested_scalar": -0.0239,
+      "log_bad": -0.6158,
+      "log_good": -0.6425
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.1403,
+      "good": 3.1478,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.0021,
+      "log_bad": 1.1443,
+      "log_good": 1.1467
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 498.0,
+      "good": 500.0,
+      "ratio": 1.004,
+      "suggested_scalar": 0.0036,
+      "log_bad": 6.2106,
+      "log_good": 6.2146
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.004,
+      "good": 0.004,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.5215,
+      "log_good": -5.5215
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.1898,
+      "good": 6.1293,
+      "ratio": 0.9902,
+      "suggested_scalar": -0.0088,
+      "log_bad": 1.8229,
+      "log_good": 1.8131
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 61.0,
+      "good": 56.0,
+      "ratio": 0.918,
+      "suggested_scalar": -0.0769,
+      "log_bad": 4.1109,
+      "log_good": 4.0254
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.5185,
+      "good": 1.5399,
+      "ratio": 1.0141,
+      "suggested_scalar": 0.0126,
+      "log_bad": 0.4177,
+      "log_good": 0.4317
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7912,
+      "good": 5.6287,
+      "ratio": 0.9719,
+      "suggested_scalar": -0.0256,
+      "log_bad": 1.7563,
+      "log_good": 1.7279
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7345,
+      "good": 0.7345,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3086,
+      "log_good": -0.3086
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1591,
+      "good": 0.163,
+      "ratio": 1.0245,
+      "suggested_scalar": 0.0218,
+      "log_bad": -1.8382,
+      "log_good": -1.814
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.214,
+      "good": 3.2901,
+      "ratio": 1.0237,
+      "suggested_scalar": 0.021,
+      "log_bad": 1.1675,
+      "log_good": 1.1909
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 321.0,
+      "good": 332.0,
+      "ratio": 1.0343,
+      "suggested_scalar": 0.0303,
+      "log_bad": 5.7714,
+      "log_good": 5.8051
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 17.0,
+      "good": 20.0,
+      "ratio": 1.1765,
+      "suggested_scalar": 0.1461,
+      "log_bad": 2.8332,
+      "log_good": 2.9957
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9653,
+      "good": 0.9546,
+      "ratio": 0.9889,
+      "suggested_scalar": -0.01,
+      "log_bad": -0.0353,
+      "log_good": -0.0465
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 106.0,
+      "ratio": 0.9381,
+      "suggested_scalar": -0.0575,
+      "log_bad": 4.7274,
+      "log_good": 4.6634
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1072.0,
+      "good": 1017.0,
+      "ratio": 0.9487,
+      "suggested_scalar": -0.0473,
+      "log_bad": 6.9773,
+      "log_good": 6.9246
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 184.0,
+      "good": 179.0,
+      "ratio": 0.9728,
+      "suggested_scalar": -0.0248,
+      "log_bad": 5.2149,
+      "log_good": 5.1874
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.008,
+      "good": 0.008,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.8283,
+      "log_good": -4.8283
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.202,
+      "good": 0.2251,
+      "ratio": 1.1144,
+      "suggested_scalar": 0.0973,
+      "log_bad": -1.5995,
+      "log_good": -1.4912
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 101.0,
+      "good": 103.0,
+      "ratio": 1.0198,
+      "suggested_scalar": 0.0176,
+      "log_bad": 4.6151,
+      "log_good": 4.6347
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 10.0,
+      "good": 11.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0857,
+      "log_bad": 2.3026,
+      "log_good": 2.3979
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 106.0,
+      "ratio": 0.9381,
+      "suggested_scalar": -0.0575,
+      "log_bad": 4.7274,
+      "log_good": 4.6634
+    },
+    "brevity.mean_sample_size": {
+      "bad": 113.0,
+      "good": 106.0,
+      "ratio": 0.9381,
+      "suggested_scalar": -0.0575,
+      "log_bad": 4.7274,
+      "log_good": 4.6634
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 500.0,
+      "good": 502.0,
+      "ratio": 1.004,
+      "suggested_scalar": 0.0036,
+      "log_bad": 6.2146,
+      "log_good": 6.2186
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 269.0,
+      "good": 275.0,
+      "ratio": 1.0223,
+      "suggested_scalar": 0.0198,
+      "log_bad": 5.5947,
+      "log_good": 5.6168
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 253.0,
+      "good": 257.0,
+      "ratio": 1.0158,
+      "suggested_scalar": 0.0141,
+      "log_bad": 5.5334,
+      "log_good": 5.5491
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.002,
+      "good": 0.002,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.2146,
+      "log_good": -6.2146
+    },
+    "heaps.mean_k": {
+      "bad": 2.6067,
+      "good": 2.7516,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.0486,
+      "log_bad": 0.9581,
+      "log_good": 1.0122
+    },
+    "halstead.mean_effort": {
+      "bad": 95909.9757,
+      "good": 91291.1446,
+      "ratio": 0.9518,
+      "suggested_scalar": -0.0444,
+      "log_bad": 11.4712,
+      "log_good": 11.4218
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8491,
+      "good": 0.8366,
+      "ratio": 0.9853,
+      "suggested_scalar": -0.0133,
+      "log_bad": -0.1636,
+      "log_good": -0.1784
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 75.0,
+      "good": 73.0,
+      "ratio": 0.9733,
+      "suggested_scalar": -0.0243,
+      "log_bad": 4.3175,
+      "log_good": 4.2905
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 250.0,
+      "good": 253.0,
+      "ratio": 1.012,
+      "suggested_scalar": 0.0107,
+      "log_bad": 5.5215,
+      "log_good": 5.5334
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3779,
+      "good": 0.3631,
+      "ratio": 0.9608,
+      "suggested_scalar": -0.0359,
+      "log_bad": -0.9731,
+      "log_good": -1.0131
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.2326,
+      "good": 6.0536,
+      "ratio": 0.9713,
+      "suggested_scalar": -0.0262,
+      "log_bad": 1.8298,
+      "log_good": 1.8007
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1591,
+      "good": 0.163,
+      "ratio": 1.0245,
+      "suggested_scalar": 0.0218,
+      "log_bad": -1.8382,
+      "log_good": -1.814
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.8813,
+      "good": 2.7896,
+      "ratio": 0.9682,
+      "suggested_scalar": -0.0291,
+      "log_bad": 1.0582,
+      "log_good": 1.0259
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 499.0,
+      "good": 501.0,
+      "ratio": 1.004,
+      "suggested_scalar": 0.0036,
+      "log_bad": 6.2126,
+      "log_good": 6.2166
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 92.0,
+      "good": 95.0,
+      "ratio": 1.0326,
+      "suggested_scalar": 0.0288,
+      "log_bad": 4.5218,
+      "log_good": 4.5539
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5328.332,
+      "good": 5071.7303,
+      "ratio": 0.9518,
+      "suggested_scalar": -0.0444,
+      "log_bad": 8.5808,
+      "log_good": 8.5314
+    },
+    "readability.mean_total_lines": {
+      "bad": 74.0,
+      "good": 77.0,
+      "ratio": 1.0405,
+      "suggested_scalar": 0.0357,
+      "log_bad": 4.3041,
+      "log_good": 4.3438
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2895.8326,
+      "good": 2863.8821,
+      "ratio": 0.989,
+      "suggested_scalar": -0.01,
+      "log_bad": 7.971,
+      "log_good": 7.9599
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 770.0,
+      "good": 751.0,
+      "ratio": 0.9753,
+      "suggested_scalar": -0.0225,
+      "log_bad": 6.6464,
+      "log_good": 6.6214
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.4324,
+      "good": 29.5065,
+      "ratio": 0.9387,
+      "suggested_scalar": -0.0568,
+      "log_bad": 3.4478,
+      "log_good": 3.3846
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2188,
+      "good": 1.2455,
+      "ratio": 1.0219,
+      "suggested_scalar": 0.0195,
+      "log_bad": 0.1979,
+      "log_good": 0.2195
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 28.0,
+      "good": 31.0,
+      "ratio": 1.1071,
+      "suggested_scalar": 0.0915,
+      "log_bad": 3.3322,
+      "log_good": 3.434
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 8.0,
+      "good": 1.0,
+      "ratio": 0.125,
+      "suggested_scalar": -1.8694,
+      "log_bad": 2.0794,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7134,
+      "good": 0.7139,
+      "ratio": 1.0007,
+      "suggested_scalar": 0.0006,
+      "log_bad": -0.3377,
+      "log_good": -0.337
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9523,
+      "good": 0.959,
+      "ratio": 1.007,
+      "suggested_scalar": 0.0063,
+      "log_bad": -0.0489,
+      "log_good": -0.0419
+    },
+    "halstead.mean_length": {
+      "bad": 434.0,
+      "good": 432.0,
+      "ratio": 0.9954,
+      "suggested_scalar": -0.0042,
+      "log_bad": 6.073,
+      "log_good": 6.0684
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.4,
+      "good": 7.0909,
+      "ratio": 0.9582,
+      "suggested_scalar": -0.0384,
+      "log_bad": 2.0015,
+      "log_good": 1.9588
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8202,
+      "good": 6.7279,
+      "ratio": 0.9865,
+      "suggested_scalar": -0.0122,
+      "log_bad": 1.9199,
+      "log_good": 1.9063
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1114,
+      "good": 0.1163,
+      "ratio": 1.044,
+      "suggested_scalar": 0.0387,
+      "log_bad": -2.1946,
+      "log_good": -2.1516
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 33.12,
+      "good": 31.8767,
+      "ratio": 0.9625,
+      "suggested_scalar": -0.0344,
+      "log_bad": 3.5001,
+      "log_good": 3.4619
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 65.0,
+      "good": 61.0,
+      "ratio": 0.9385,
+      "suggested_scalar": -0.0571,
+      "log_bad": 4.1744,
+      "log_good": 4.1109
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6008,
+      "good": 0.5992,
+      "ratio": 0.9973,
+      "suggested_scalar": -0.0024,
+      "log_bad": -0.5095,
+      "log_good": -0.5122
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 74.0,
+      "good": 77.0,
+      "ratio": 1.0405,
+      "suggested_scalar": 0.0357,
+      "log_bad": 4.3041,
+      "log_good": 4.3438
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.uses_question_mark_for_propagation": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 5.0,
+      "good": 9.0,
+      "ratio": 1.8,
+      "suggested_scalar": 0.7304,
+      "log_bad": 1.6094,
+      "log_good": 2.1972
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.8614,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0129,
+      "good": 0.01,
+      "ratio": 0.7752,
+      "suggested_scalar": -0.3164,
+      "log_bad": -4.3505,
+      "log_good": -4.6052
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.25,
+      "ratio": 1.25,
+      "suggested_scalar": 0.2773,
+      "log_bad": 0.0,
+      "log_good": 0.2231
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9,
+      "good": 0.8333,
+      "ratio": 0.9259,
+      "suggested_scalar": -0.0957,
+      "log_bad": -0.1054,
+      "log_good": -0.1824
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0129,
+      "good": 0.01,
+      "ratio": 0.7752,
+      "suggested_scalar": -0.3164,
+      "log_bad": -4.3505,
+      "log_good": -4.6052
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5333,
+      "good": 4.7941,
+      "ratio": 1.0575,
+      "suggested_scalar": 0.0695,
+      "log_bad": 1.5115,
+      "log_good": 1.5674
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 91.0,
+      "good": 97.0,
+      "ratio": 1.0659,
+      "suggested_scalar": 0.0793,
+      "log_bad": 4.5109,
+      "log_good": 4.5747
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4537,
+      "good": 0.4704,
+      "ratio": 1.0368,
+      "suggested_scalar": 0.0449,
+      "log_bad": -0.7903,
+      "log_good": -0.7542
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 21.0,
+      "ratio": 1.1053,
+      "suggested_scalar": 0.1244,
+      "log_bad": 2.9444,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6855,
+      "good": 0.6881,
+      "ratio": 1.0038,
+      "suggested_scalar": 0.0047,
+      "log_bad": -0.3776,
+      "log_good": -0.3738
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.76,
+      "good": 4.2963,
+      "ratio": 0.7459,
+      "suggested_scalar": -0.3643,
+      "log_bad": 1.7509,
+      "log_good": 1.4578
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 465.0,
+      "good": 501.0,
+      "ratio": 1.0774,
+      "suggested_scalar": 0.0927,
+      "log_bad": 6.142,
+      "log_good": 6.2166
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0032,
+      "good": 0.0024,
+      "ratio": 0.75,
+      "suggested_scalar": -0.3575,
+      "log_bad": -5.7446,
+      "log_good": -6.0323
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.02,
+      "good": 0.0185,
+      "ratio": 0.925,
+      "suggested_scalar": -0.0969,
+      "log_bad": -3.912,
+      "log_good": -3.99
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0006,
+      "good": 0.003,
+      "ratio": 5.0,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.4186,
+      "log_good": -5.8091
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1002,
+      "good": 1.0778,
+      "ratio": 0.9796,
+      "suggested_scalar": -0.0256,
+      "log_bad": 0.0955,
+      "log_good": 0.0749
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 148.0,
+      "good": 154.0,
+      "ratio": 1.0405,
+      "suggested_scalar": 0.0494,
+      "log_bad": 4.9972,
+      "log_good": 5.037
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 103.8902,
+      "good": 97.8896,
+      "ratio": 0.9422,
+      "suggested_scalar": -0.0739,
+      "log_bad": 4.6433,
+      "log_good": 4.5838
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6228,
+      "good": 0.634,
+      "ratio": 1.018,
+      "suggested_scalar": 0.0221,
+      "log_bad": -0.4735,
+      "log_good": -0.4557
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 6.87,
+      "good": 8.9346,
+      "ratio": 1.3005,
+      "suggested_scalar": 0.3265,
+      "log_bad": 1.9272,
+      "log_good": 2.1899
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1585.0,
+      "good": 1645.0,
+      "ratio": 1.0379,
+      "suggested_scalar": 0.0462,
+      "log_bad": 7.3683,
+      "log_good": 7.4055
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.18,
+      "good": 0.1111,
+      "ratio": 0.6172,
+      "suggested_scalar": -0.5996,
+      "log_bad": -1.7148,
+      "log_good": -2.1973
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.82,
+      "good": 0.7963,
+      "ratio": 0.9711,
+      "suggested_scalar": -0.0364,
+      "log_bad": -0.1985,
+      "log_good": -0.2278
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.3,
+      "good": 9.4528,
+      "ratio": 1.0164,
+      "suggested_scalar": 0.0203,
+      "log_bad": 2.23,
+      "log_good": 2.2463
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 16.7424,
+      "good": 12.9492,
+      "ratio": 0.7734,
+      "suggested_scalar": -0.3193,
+      "log_bad": 2.8179,
+      "log_good": 2.561
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 108.0,
+      "good": 101.0,
+      "ratio": 0.9352,
+      "suggested_scalar": -0.0833,
+      "log_bad": 4.6821,
+      "log_good": 4.6151
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9531,
+      "good": 0.9557,
+      "ratio": 1.0027,
+      "suggested_scalar": 0.0034,
+      "log_bad": -0.048,
+      "log_good": -0.0453
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 31.0,
+      "ratio": 1.0333,
+      "suggested_scalar": 0.0407,
+      "log_bad": 3.4012,
+      "log_good": 3.434
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6057,
+      "good": 0.5891,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.0345,
+      "log_bad": -0.5014,
+      "log_good": -0.5292
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3931,
+      "good": 0.3647,
+      "ratio": 0.9278,
+      "suggested_scalar": -0.0932,
+      "log_bad": -0.9337,
+      "log_good": -1.0087
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.536,
+      "good": 2.4334,
+      "ratio": 0.9595,
+      "suggested_scalar": -0.0513,
+      "log_bad": 0.9306,
+      "log_good": 0.8893
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 463.0,
+      "good": 499.0,
+      "ratio": 1.0778,
+      "suggested_scalar": 0.093,
+      "log_bad": 6.1377,
+      "log_good": 6.2126
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 25.0,
+      "good": 19.0,
+      "ratio": 0.76,
+      "suggested_scalar": -0.341,
+      "log_bad": 3.2189,
+      "log_good": 2.9444
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0473,
+      "good": 0.0739,
+      "ratio": 1.5624,
+      "suggested_scalar": 0.5545,
+      "log_bad": -3.0512,
+      "log_good": -2.605
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.8826,
+      "ratio": 1.0085,
+      "suggested_scalar": 0.0105,
+      "log_bad": 1.7635,
+      "log_good": 1.772
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 40.0,
+      "good": 52.0,
+      "ratio": 1.3,
+      "suggested_scalar": 0.326,
+      "log_bad": 3.6889,
+      "log_good": 3.9512
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8419,
+      "good": 0.9752,
+      "ratio": 1.1583,
+      "suggested_scalar": 0.1826,
+      "log_bad": -0.1721,
+      "log_good": -0.0251
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4604,
+      "good": 5.4817,
+      "ratio": 1.0039,
+      "suggested_scalar": 0.0048,
+      "log_bad": 1.6975,
+      "log_good": 1.7014
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7772,
+      "good": 0.815,
+      "ratio": 1.0486,
+      "suggested_scalar": 0.059,
+      "log_bad": -0.2521,
+      "log_good": -0.2046
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1379,
+      "good": 0.1429,
+      "ratio": 1.0363,
+      "suggested_scalar": 0.0443,
+      "log_bad": -1.9812,
+      "log_good": -1.9456
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.6211,
+      "good": 2.9891,
+      "ratio": 1.1404,
+      "suggested_scalar": 0.1633,
+      "log_bad": 0.9636,
+      "log_good": 1.095
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 333.0,
+      "good": 390.0,
+      "ratio": 1.1712,
+      "suggested_scalar": 0.1963,
+      "log_bad": 5.8081,
+      "log_good": 5.9661
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 27.0,
+      "good": 29.0,
+      "ratio": 1.0741,
+      "suggested_scalar": 0.0888,
+      "log_bad": 3.2958,
+      "log_good": 3.3673
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.948,
+      "good": 1.0406,
+      "ratio": 1.0977,
+      "suggested_scalar": 0.1158,
+      "log_bad": -0.0534,
+      "log_good": 0.0398
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 92.0,
+      "good": 101.0,
+      "ratio": 1.0978,
+      "suggested_scalar": 0.116,
+      "log_bad": 4.5218,
+      "log_good": 4.6151
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 672.0,
+      "good": 803.0,
+      "ratio": 1.1949,
+      "suggested_scalar": 0.2213,
+      "log_bad": 6.5103,
+      "log_good": 6.6884
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 148.0,
+      "good": 161.0,
+      "ratio": 1.0878,
+      "suggested_scalar": 0.1046,
+      "log_bad": 4.9972,
+      "log_good": 5.0814
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0258,
+      "good": 0.014,
+      "ratio": 0.5426,
+      "suggested_scalar": -0.7597,
+      "log_bad": -3.6574,
+      "log_good": -4.2687
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.271,
+      "good": 0.2834,
+      "ratio": 1.0458,
+      "suggested_scalar": 0.0556,
+      "log_bad": -1.3056,
+      "log_good": -1.2609
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 74.0,
+      "good": 100.0,
+      "ratio": 1.3514,
+      "suggested_scalar": 0.3742,
+      "log_bad": 4.3041,
+      "log_good": 4.6052
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.8614,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 92.0,
+      "good": 101.0,
+      "ratio": 1.0978,
+      "suggested_scalar": 0.116,
+      "log_bad": 4.5218,
+      "log_good": 4.6151
+    },
+    "brevity.mean_sample_size": {
+      "bad": 92.0,
+      "good": 101.0,
+      "ratio": 1.0978,
+      "suggested_scalar": 0.116,
+      "log_bad": 4.5218,
+      "log_good": 4.6151
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 465.0,
+      "good": 501.0,
+      "ratio": 1.0774,
+      "suggested_scalar": 0.0927,
+      "log_bad": 6.142,
+      "log_good": 6.2166
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 275.0,
+      "good": 306.0,
+      "ratio": 1.1127,
+      "suggested_scalar": 0.1327,
+      "log_bad": 5.6168,
+      "log_good": 5.7236
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 249.0,
+      "good": 283.0,
+      "ratio": 1.1365,
+      "suggested_scalar": 0.1591,
+      "log_bad": 5.5175,
+      "log_good": 5.6454
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.5883,
+      "good": 1.5145,
+      "ratio": 0.9535,
+      "suggested_scalar": -0.0591,
+      "log_bad": 0.4627,
+      "log_good": 0.4151
+    },
+    "halstead.mean_effort": {
+      "bad": 103499.5392,
+      "good": 118035.5912,
+      "ratio": 1.1404,
+      "suggested_scalar": 0.1633,
+      "log_bad": 11.5473,
+      "log_good": 11.6787
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.837,
+      "good": 0.8233,
+      "ratio": 0.9836,
+      "suggested_scalar": -0.0205,
+      "log_bad": -0.1779,
+      "log_good": -0.1944
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 61.0,
+      "good": 66.0,
+      "ratio": 1.082,
+      "suggested_scalar": 0.0979,
+      "log_bad": 4.1109,
+      "log_good": 4.1897
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 289.0,
+      "good": 312.0,
+      "ratio": 1.0796,
+      "suggested_scalar": 0.0952,
+      "log_bad": 5.6664,
+      "log_good": 5.743
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3851,
+      "good": 0.3961,
+      "ratio": 1.0286,
+      "suggested_scalar": 0.035,
+      "log_bad": -0.9543,
+      "log_good": -0.9261
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.5405,
+      "good": 5.2143,
+      "ratio": 1.1484,
+      "suggested_scalar": 0.1719,
+      "log_bad": 1.513,
+      "log_good": 1.6514
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1379,
+      "good": 0.1429,
+      "ratio": 1.0363,
+      "suggested_scalar": 0.0443,
+      "log_bad": -1.9812,
+      "log_good": -1.9456
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.72,
+      "good": 3.7811,
+      "ratio": 1.0164,
+      "suggested_scalar": 0.0202,
+      "log_bad": 1.3137,
+      "log_good": 1.33
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 464.0,
+      "good": 500.0,
+      "ratio": 1.0776,
+      "suggested_scalar": 0.0929,
+      "log_bad": 6.1399,
+      "log_good": 6.2146
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.2266,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 52.0,
+      "good": 73.0,
+      "ratio": 1.4038,
+      "suggested_scalar": 0.4215,
+      "log_bad": 3.9512,
+      "log_good": 4.2905
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5749.9744,
+      "good": 6557.5328,
+      "ratio": 1.1404,
+      "suggested_scalar": 0.1633,
+      "log_bad": 8.657,
+      "log_good": 8.7884
+    },
+    "readability.mean_total_lines": {
+      "bad": 50.0,
+      "good": 53.0,
+      "ratio": 1.06,
+      "suggested_scalar": 0.0724,
+      "log_bad": 3.912,
+      "log_good": 3.9703
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 12.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.3575,
+      "log_bad": 2.7726,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2843.9063,
+      "good": 3121.7588,
+      "ratio": 1.0977,
+      "suggested_scalar": 0.1158,
+      "log_bad": 7.9529,
+      "log_good": 8.0462
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 625.0,
+      "good": 676.0,
+      "ratio": 1.0816,
+      "suggested_scalar": 0.0975,
+      "log_bad": 6.4378,
+      "log_good": 6.5162
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.5,
+      "good": 29.5472,
+      "ratio": 0.9688,
+      "suggested_scalar": -0.0394,
+      "log_bad": 3.4177,
+      "log_good": 3.386
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1053,
+      "good": 1.1744,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.0754,
+      "log_bad": 0.1001,
+      "log_good": 0.1608
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 15.0,
+      "good": 18.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.2266,
+      "log_bad": 2.7081,
+      "log_good": 2.8904
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8438,
+      "good": 0.8128,
+      "ratio": 0.9633,
+      "suggested_scalar": -0.0465,
+      "log_bad": -0.1698,
+      "log_good": -0.2073
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9361,
+      "good": 0.9706,
+      "ratio": 1.0369,
+      "suggested_scalar": 0.045,
+      "log_bad": -0.066,
+      "log_good": -0.0298
+    },
+    "halstead.mean_length": {
+      "bad": 437.0,
+      "good": 473.0,
+      "ratio": 1.0824,
+      "suggested_scalar": 0.0984,
+      "log_bad": 6.0799,
+      "log_good": 6.1591
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 24.0,
+      "good": 12.75,
+      "ratio": 0.5313,
+      "suggested_scalar": -0.786,
+      "log_bad": 3.1781,
+      "log_good": 2.5455
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5236,
+      "good": 6.6582,
+      "ratio": 1.0206,
+      "suggested_scalar": 0.0254,
+      "log_bad": 1.8754,
+      "log_good": 1.8958
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1737,
+      "good": 0.186,
+      "ratio": 1.0708,
+      "suggested_scalar": 0.085,
+      "log_bad": -1.7504,
+      "log_good": -1.682
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 36.3934,
+      "good": 37.8106,
+      "ratio": 1.0389,
+      "suggested_scalar": 0.0475,
+      "log_bad": 3.5944,
+      "log_good": 3.6326
+    },
+    "branching.mean_branch_count": {
+      "bad": 9.0,
+      "good": 6.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.5039,
+      "log_bad": 2.1972,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 57.0,
+      "good": 61.0,
+      "ratio": 1.0702,
+      "suggested_scalar": 0.0843,
+      "log_bad": 4.0431,
+      "log_good": 4.1109
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7028,
+      "good": 0.6466,
+      "ratio": 0.92,
+      "suggested_scalar": -0.1036,
+      "log_bad": -0.3527,
+      "log_good": -0.436
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 50.0,
+      "good": 54.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.0956,
+      "log_bad": 3.912,
+      "log_good": 3.989
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 12.0,
+      "good": 15.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.2773,
+      "log_bad": 2.4849,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_unnecessary_conditions": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 19.0,
+      "good": 17.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.0908,
+      "log_bad": 2.9444,
+      "log_good": 2.8332
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0281,
+      "good": 0.0344,
+      "ratio": 1.2242,
+      "suggested_scalar": 0.1651,
+      "log_bad": -3.572,
+      "log_good": -3.3697
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1667,
+      "good": 1.1667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1542,
+      "log_good": 0.1542
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8276,
+      "good": 0.8378,
+      "ratio": 1.0123,
+      "suggested_scalar": 0.01,
+      "log_bad": -0.1892,
+      "log_good": -0.177
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0298,
+      "good": 0.0367,
+      "ratio": 1.2315,
+      "suggested_scalar": 0.1699,
+      "log_bad": -3.5132,
+      "log_good": -3.305
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8459,
+      "good": 4.8878,
+      "ratio": 1.0086,
+      "suggested_scalar": 0.007,
+      "log_bad": 1.5781,
+      "log_good": 1.5867
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 120.0,
+      "good": 93.0,
+      "ratio": 0.775,
+      "suggested_scalar": -0.208,
+      "log_bad": 4.7875,
+      "log_good": 4.5326
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4716,
+      "good": 0.4656,
+      "ratio": 0.9873,
+      "suggested_scalar": -0.0104,
+      "log_bad": -0.7516,
+      "log_good": -0.7644
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 27.0,
+      "good": 25.0,
+      "ratio": 0.9259,
+      "suggested_scalar": -0.0628,
+      "log_bad": 3.2958,
+      "log_good": 3.2189
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6314,
+      "good": 0.6456,
+      "ratio": 1.0225,
+      "suggested_scalar": 0.0181,
+      "log_bad": -0.4598,
+      "log_good": -0.4376
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.9655,
+      "good": 1.2973,
+      "ratio": 0.66,
+      "suggested_scalar": -0.339,
+      "log_bad": 0.6757,
+      "log_good": 0.2603
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 604.0,
+      "good": 436.0,
+      "ratio": 0.7219,
+      "suggested_scalar": -0.2659,
+      "log_bad": 6.4036,
+      "log_good": 6.0776
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1821,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0018,
+      "good": 0.0013,
+      "ratio": 0.7222,
+      "suggested_scalar": -0.2655,
+      "log_bad": -6.32,
+      "log_good": -6.6454
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0862,
+      "good": 1.0,
+      "ratio": 11.6009,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.4511,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0004,
+      "good": 0.0006,
+      "ratio": 1.5,
+      "suggested_scalar": 0.3308,
+      "log_bad": -7.824,
+      "log_good": -7.4186
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0866,
+      "good": 1.0634,
+      "ratio": 0.9786,
+      "suggested_scalar": -0.0176,
+      "log_bad": 0.0831,
+      "log_good": 0.0615
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 182.0,
+      "good": 135.0,
+      "ratio": 0.7418,
+      "suggested_scalar": -0.2438,
+      "log_bad": 5.204,
+      "log_good": 4.9053
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 100.6302,
+      "good": 94.9376,
+      "ratio": 0.9434,
+      "suggested_scalar": -0.0475,
+      "log_bad": 4.6115,
+      "log_good": 4.5532
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5672,
+      "good": 0.5448,
+      "ratio": 0.9605,
+      "suggested_scalar": -0.0329,
+      "log_bad": -0.567,
+      "log_good": -0.6073
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 12.7986,
+      "good": 14.3975,
+      "ratio": 1.1249,
+      "suggested_scalar": 0.0961,
+      "log_bad": 2.5493,
+      "log_good": 2.6671
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2232.0,
+      "good": 1594.0,
+      "ratio": 0.7142,
+      "suggested_scalar": -0.2747,
+      "log_bad": 7.7107,
+      "log_good": 7.374
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1379,
+      "good": 0.0541,
+      "ratio": 0.3923,
+      "suggested_scalar": -0.7635,
+      "log_bad": -1.9812,
+      "log_good": -2.9169
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7759,
+      "good": 0.8108,
+      "ratio": 1.045,
+      "suggested_scalar": 0.0359,
+      "log_bad": -0.2537,
+      "log_good": -0.2097
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.4138,
+      "good": 11.7838,
+      "ratio": 1.1316,
+      "suggested_scalar": 0.1008,
+      "log_bad": 2.3431,
+      "log_good": 2.4667
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.4126,
+      "good": 1.5603,
+      "ratio": 0.6467,
+      "suggested_scalar": -0.3556,
+      "log_bad": 0.8807,
+      "log_good": 0.4449
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 137.0,
+      "good": 95.0,
+      "ratio": 0.6934,
+      "suggested_scalar": -0.2987,
+      "log_bad": 4.92,
+      "log_good": 4.5539
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9322,
+      "good": 0.9334,
+      "ratio": 1.0013,
+      "suggested_scalar": 0.001,
+      "log_bad": -0.0702,
+      "log_good": -0.0689
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 36.0,
+      "good": 30.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1488,
+      "log_bad": 3.5835,
+      "log_good": 3.4012
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5927,
+      "good": 0.5759,
+      "ratio": 0.9717,
+      "suggested_scalar": -0.0235,
+      "log_bad": -0.5231,
+      "log_good": -0.5518
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3339,
+      "good": 0.318,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0398,
+      "log_bad": -1.0969,
+      "log_good": -1.1457
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4554,
+      "good": 2.358,
+      "ratio": 0.9603,
+      "suggested_scalar": -0.033,
+      "log_bad": 0.8983,
+      "log_good": 0.8578
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 602.0,
+      "good": 434.0,
+      "ratio": 0.7209,
+      "suggested_scalar": -0.267,
+      "log_bad": 6.4003,
+      "log_good": 6.073
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 17.0,
+      "good": 12.0,
+      "ratio": 0.7059,
+      "suggested_scalar": -0.2842,
+      "log_bad": 2.8332,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0315,
+      "good": 0.0436,
+      "ratio": 1.3841,
+      "suggested_scalar": 0.2652,
+      "log_bad": -3.4578,
+      "log_good": -3.1327
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.1699,
+      "good": 6.0875,
+      "ratio": 0.9866,
+      "suggested_scalar": -0.011,
+      "log_bad": 1.8197,
+      "log_good": 1.8062
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 26.0,
+      "good": 23.0,
+      "ratio": 0.8846,
+      "suggested_scalar": -0.1,
+      "log_bad": 3.2581,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0498,
+      "good": 1.1682,
+      "ratio": 1.1128,
+      "suggested_scalar": 0.0872,
+      "log_bad": 0.0486,
+      "log_good": 0.1555
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8571,
+      "good": 5.5989,
+      "ratio": 0.9559,
+      "suggested_scalar": -0.0368,
+      "log_bad": 1.7677,
+      "log_good": 1.7226
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7854,
+      "good": 0.8029,
+      "ratio": 1.0223,
+      "suggested_scalar": 0.018,
+      "log_bad": -0.2416,
+      "log_good": -0.2195
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1471,
+      "good": 0.1957,
+      "ratio": 1.3304,
+      "suggested_scalar": 0.2329,
+      "log_bad": -1.9166,
+      "log_good": -1.6312
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.5775,
+      "good": 3.7944,
+      "ratio": 1.0606,
+      "suggested_scalar": 0.048,
+      "log_bad": 1.2747,
+      "log_good": 1.3335
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 474.0,
+      "good": 347.0,
+      "ratio": 0.7321,
+      "suggested_scalar": -0.2545,
+      "log_bad": 6.1612,
+      "log_good": 5.8493
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 24.0,
+      "good": 22.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.071,
+      "log_bad": 3.1781,
+      "log_good": 3.091
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.2202,
+      "good": 0.8283,
+      "ratio": 0.6788,
+      "suggested_scalar": -0.3161,
+      "log_bad": 0.199,
+      "log_good": -0.1884
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 117.0,
+      "good": 94.0,
+      "ratio": 0.8034,
+      "suggested_scalar": -0.1786,
+      "log_bad": 4.7622,
+      "log_good": 4.5433
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1140.0,
+      "good": 901.0,
+      "ratio": 0.7904,
+      "suggested_scalar": -0.192,
+      "log_bad": 7.0388,
+      "log_good": 6.8035
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 208.0,
+      "good": 147.0,
+      "ratio": 0.7067,
+      "suggested_scalar": -0.2832,
+      "log_bad": 5.3375,
+      "log_good": 4.9904
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0033,
+      "good": 0.0046,
+      "ratio": 1.3939,
+      "suggested_scalar": 0.271,
+      "log_bad": -5.7138,
+      "log_good": -5.3817
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2202,
+      "good": 0.2661,
+      "ratio": 1.2084,
+      "suggested_scalar": 0.1545,
+      "log_bad": -1.5132,
+      "log_good": -1.3239
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 101.0,
+      "good": 74.0,
+      "ratio": 0.7327,
+      "suggested_scalar": -0.2538,
+      "log_bad": 4.6151,
+      "log_good": 4.3041
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 117.0,
+      "good": 94.0,
+      "ratio": 0.8034,
+      "suggested_scalar": -0.1786,
+      "log_bad": 4.7622,
+      "log_good": 4.5433
+    },
+    "brevity.mean_sample_size": {
+      "bad": 117.0,
+      "good": 94.0,
+      "ratio": 0.8034,
+      "suggested_scalar": -0.1786,
+      "log_bad": 4.7622,
+      "log_good": 4.5433
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 604.0,
+      "good": 436.0,
+      "ratio": 0.7219,
+      "suggested_scalar": -0.2659,
+      "log_bad": 6.4036,
+      "log_good": 6.0776
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 345.0,
+      "good": 263.0,
+      "ratio": 0.7623,
+      "suggested_scalar": -0.2214,
+      "log_bad": 5.8435,
+      "log_good": 5.5722
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 362.0,
+      "good": 272.0,
+      "ratio": 0.7514,
+      "suggested_scalar": -0.2332,
+      "log_bad": 5.8916,
+      "log_good": 5.6058
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.2044,
+      "good": 1.9328,
+      "ratio": 0.8768,
+      "suggested_scalar": -0.1073,
+      "log_bad": 0.7905,
+      "log_good": 0.659
+    },
+    "halstead.mean_effort": {
+      "bad": 163160.4898,
+      "good": 86970.8122,
+      "ratio": 0.533,
+      "suggested_scalar": -0.5134,
+      "log_bad": 12.0025,
+      "log_good": 11.3733
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8525,
+      "good": 0.8542,
+      "ratio": 1.002,
+      "suggested_scalar": 0.0016,
+      "log_bad": -0.1596,
+      "log_good": -0.1576
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 84.0,
+      "good": 63.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.2347,
+      "log_bad": 4.4308,
+      "log_good": 4.1431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 322.0,
+      "good": 233.0,
+      "ratio": 0.7236,
+      "suggested_scalar": -0.264,
+      "log_bad": 5.7746,
+      "log_good": 5.451
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3571,
+      "good": 0.3852,
+      "ratio": 1.0787,
+      "suggested_scalar": 0.0618,
+      "log_bad": -1.0297,
+      "log_good": -0.954
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.2637,
+      "good": 6.6741,
+      "ratio": 1.0655,
+      "suggested_scalar": 0.0518,
+      "log_bad": 1.8348,
+      "log_good": 1.8982
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1471,
+      "good": 0.1957,
+      "ratio": 1.3304,
+      "suggested_scalar": 0.2329,
+      "log_bad": -1.9166,
+      "log_good": -1.6312
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.9046,
+      "good": 7.2866,
+      "ratio": 1.2341,
+      "suggested_scalar": 0.1716,
+      "log_bad": 1.7757,
+      "log_good": 1.986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 603.0,
+      "good": 435.0,
+      "ratio": 0.7214,
+      "suggested_scalar": -0.2665,
+      "log_bad": 6.4019,
+      "log_good": 6.0753
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 11.0,
+      "good": 10.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0778,
+      "log_bad": 2.3979,
+      "log_good": 2.3026
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 73.0,
+      "good": 51.0,
+      "ratio": 0.6986,
+      "suggested_scalar": -0.2926,
+      "log_bad": 4.2905,
+      "log_good": 3.9318
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 9064.4717,
+      "good": 4831.7118,
+      "ratio": 0.533,
+      "suggested_scalar": -0.5134,
+      "log_bad": 9.1121,
+      "log_good": 8.483
+    },
+    "readability.mean_total_lines": {
+      "bad": 58.0,
+      "good": 37.0,
+      "ratio": 0.6379,
+      "suggested_scalar": -0.3668,
+      "log_bad": 4.0604,
+      "log_good": 3.6109
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 4.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.3308,
+      "log_bad": 1.7918,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 3660.652,
+      "good": 2484.8803,
+      "ratio": 0.6788,
+      "suggested_scalar": -0.3161,
+      "log_bad": 8.2054,
+      "log_good": 7.818
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 909.0,
+      "good": 676.0,
+      "ratio": 0.7437,
+      "suggested_scalar": -0.2416,
+      "log_bad": 6.8123,
+      "log_good": 6.5162
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 37.2414,
+      "good": 41.8378,
+      "ratio": 1.1234,
+      "suggested_scalar": 0.095,
+      "log_bad": 3.6174,
+      "log_good": 3.7338
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1304,
+      "good": 1.1813,
+      "ratio": 1.045,
+      "suggested_scalar": 0.0359,
+      "log_bad": 0.1226,
+      "log_good": 0.1666
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1821,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 29.0,
+      "good": 23.0,
+      "ratio": 0.7931,
+      "suggested_scalar": -0.1891,
+      "log_bad": 3.3673,
+      "log_good": 3.1355
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 1.0,
+      "ratio": 0.2,
+      "suggested_scalar": -1.3132,
+      "log_bad": 1.6094,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.846,
+      "good": 0.853,
+      "ratio": 1.0083,
+      "suggested_scalar": 0.0067,
+      "log_bad": -0.1672,
+      "log_good": -0.159
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9864,
+      "good": 0.9929,
+      "ratio": 1.0066,
+      "suggested_scalar": 0.0054,
+      "log_bad": -0.0137,
+      "log_good": -0.0071
+    },
+    "halstead.mean_length": {
+      "bad": 530.0,
+      "good": 380.0,
+      "ratio": 0.717,
+      "suggested_scalar": -0.2715,
+      "log_bad": 6.2729,
+      "log_good": 5.9402
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.0,
+      "good": 6.3333,
+      "ratio": 0.6333,
+      "suggested_scalar": -0.3727,
+      "log_bad": 2.3026,
+      "log_good": 1.8458
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8704,
+      "good": 6.5546,
+      "ratio": 0.954,
+      "suggested_scalar": -0.0384,
+      "log_bad": 1.9272,
+      "log_good": 1.8802
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1548,
+      "good": 0.165,
+      "ratio": 1.0659,
+      "suggested_scalar": 0.0521,
+      "log_bad": -1.8656,
+      "log_good": -1.8018
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 44.5714,
+      "good": 35.0,
+      "ratio": 0.7853,
+      "suggested_scalar": -0.1973,
+      "log_bad": 3.7971,
+      "log_good": 3.5553
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 2.0,
+      "ratio": 0.25,
+      "suggested_scalar": -1.1312,
+      "log_bad": 2.0794,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 65.0,
+      "good": 52.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1821,
+      "log_bad": 4.1744,
+      "log_good": 3.9512
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.721,
+      "good": 0.7279,
+      "ratio": 1.0096,
+      "suggested_scalar": 0.0078,
+      "log_bad": -0.3271,
+      "log_good": -0.3176
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 58.0,
+      "good": 37.0,
+      "ratio": 0.6379,
+      "suggested_scalar": -0.3668,
+      "log_bad": 4.0604,
+      "log_good": 3.6109
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.initialism_uses_consistent_casing": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 15.0,
+      "good": 18.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.5261,
+      "log_bad": 2.7081,
+      "log_good": 2.8904
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 12.0,
+      "good": 14.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.4448,
+      "log_bad": 2.4849,
+      "log_good": 2.6391
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0292,
+      "good": 0.0329,
+      "ratio": 1.1267,
+      "suggested_scalar": 0.3442,
+      "log_bad": -3.5336,
+      "log_good": -3.4143
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 1.5,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.4055,
+      "log_good": 0.4055
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8824,
+      "good": 0.8857,
+      "ratio": 1.0037,
+      "suggested_scalar": 0.0108,
+      "log_bad": -0.1251,
+      "log_good": -0.1214
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0292,
+      "good": 0.0329,
+      "ratio": 1.1267,
+      "suggested_scalar": 0.3442,
+      "log_bad": -3.5336,
+      "log_good": -3.4143
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 5.0201,
+      "good": 5.104,
+      "ratio": 1.0167,
+      "suggested_scalar": 0.0478,
+      "log_bad": 1.6134,
+      "log_good": 1.63
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 104.0,
+      "good": 96.0,
+      "ratio": 0.9231,
+      "suggested_scalar": -0.231,
+      "log_bad": 4.6444,
+      "log_good": 4.5643
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5698,
+      "good": 0.5476,
+      "ratio": 0.961,
+      "suggested_scalar": -0.1147,
+      "log_bad": -0.5625,
+      "log_good": -0.6022
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.1991,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7334,
+      "good": 0.6959,
+      "ratio": 0.9489,
+      "suggested_scalar": -0.1514,
+      "log_bad": -0.3101,
+      "log_good": -0.3625
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.4706,
+      "good": 0.4571,
+      "ratio": 0.9713,
+      "suggested_scalar": -0.084,
+      "log_bad": -0.7537,
+      "log_good": -0.7829
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 308.0,
+      "good": 304.0,
+      "ratio": 0.987,
+      "suggested_scalar": -0.0377,
+      "log_bad": 5.7301,
+      "log_good": 5.717
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2059,
+      "good": 0.2286,
+      "ratio": 1.1102,
+      "suggested_scalar": 0.3018,
+      "log_bad": -1.5804,
+      "log_good": -1.4758
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8775,
+      "good": 0.9188,
+      "ratio": 1.0471,
+      "suggested_scalar": 0.1327,
+      "log_bad": -0.1307,
+      "log_good": -0.0847
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 143.0,
+      "good": 128.0,
+      "ratio": 0.8951,
+      "suggested_scalar": -0.3197,
+      "log_bad": 4.9628,
+      "log_good": 4.852
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 96.3229,
+      "good": 95.7494,
+      "ratio": 0.994,
+      "suggested_scalar": -0.0172,
+      "log_bad": 4.5677,
+      "log_good": 4.5617
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.3876,
+      "good": 0.396,
+      "ratio": 1.0217,
+      "suggested_scalar": 0.0619,
+      "log_bad": -0.9478,
+      "log_good": -0.9263
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.6222,
+      "good": 10.3123,
+      "ratio": 1.0717,
+      "suggested_scalar": 0.1999,
+      "log_bad": 2.2641,
+      "log_good": 2.3333
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1206.0,
+      "good": 1177.0,
+      "ratio": 0.976,
+      "suggested_scalar": -0.0702,
+      "log_bad": 7.0951,
+      "log_good": 7.0707
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0882,
+      "good": 0.1429,
+      "ratio": 1.6202,
+      "suggested_scalar": 1.3923,
+      "log_bad": -2.4281,
+      "log_good": -1.9456
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8529,
+      "good": 0.8571,
+      "ratio": 1.0049,
+      "suggested_scalar": 0.0142,
+      "log_bad": -0.1591,
+      "log_good": -0.1542
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.0588,
+      "good": 8.6857,
+      "ratio": 0.9588,
+      "suggested_scalar": -0.1214,
+      "log_bad": 2.2037,
+      "log_good": 2.1617
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.3668,
+      "good": 0.3624,
+      "ratio": 0.988,
+      "suggested_scalar": -0.0348,
+      "log_bad": -1.0029,
+      "log_good": -1.015
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 78.0,
+      "good": 62.0,
+      "ratio": 0.7949,
+      "suggested_scalar": -0.6624,
+      "log_bad": 4.3567,
+      "log_good": 4.1271
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9485,
+      "good": 0.9428,
+      "ratio": 0.994,
+      "suggested_scalar": -0.0174,
+      "log_bad": -0.0529,
+      "log_good": -0.0589
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 23.0,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.2625,
+      "log_bad": 3.0445,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.4959,
+      "good": 0.4911,
+      "ratio": 0.9903,
+      "suggested_scalar": -0.0281,
+      "log_bad": -0.7014,
+      "log_good": -0.7111
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.134,
+      "good": 0.1225,
+      "ratio": 0.9142,
+      "suggested_scalar": -0.2589,
+      "log_bad": -2.0099,
+      "log_good": -2.0996
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.9836,
+      "good": 1.9649,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.0273,
+      "log_bad": 0.6849,
+      "log_good": 0.6754
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 306.0,
+      "good": 302.0,
+      "ratio": 0.9869,
+      "suggested_scalar": -0.038,
+      "log_bad": 5.7236,
+      "log_good": 5.7104
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 12.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.2511,
+      "log_bad": 2.3979,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0097,
+      "good": 0.0099,
+      "ratio": 1.0206,
+      "suggested_scalar": 0.0589,
+      "log_bad": -4.6356,
+      "log_good": -4.6152
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0224,
+      "good": 5.9542,
+      "ratio": 0.9887,
+      "suggested_scalar": -0.0329,
+      "log_bad": 1.7955,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 50.0,
+      "good": 48.0,
+      "ratio": 0.96,
+      "suggested_scalar": -0.1178,
+      "log_bad": 3.912,
+      "log_good": 3.8712
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3483,
+      "good": 1.4352,
+      "ratio": 1.0645,
+      "suggested_scalar": 0.1802,
+      "log_bad": 0.2988,
+      "log_good": 0.3613
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8629,
+      "good": 5.7074,
+      "ratio": 0.9735,
+      "suggested_scalar": -0.0776,
+      "log_bad": 1.7686,
+      "log_good": 1.7418
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8336,
+      "good": 0.8572,
+      "ratio": 1.0283,
+      "suggested_scalar": 0.0806,
+      "log_bad": -0.182,
+      "log_good": -0.1541
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.15,
+      "good": 0.1463,
+      "ratio": 0.9753,
+      "suggested_scalar": -0.0721,
+      "log_bad": -1.8971,
+      "log_good": -1.9221
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.102,
+      "good": 3.2113,
+      "ratio": 1.0352,
+      "suggested_scalar": 0.0999,
+      "log_bad": 1.132,
+      "log_good": 1.1667
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 281.0,
+      "good": 280.0,
+      "ratio": 0.9964,
+      "suggested_scalar": -0.0103,
+      "log_bad": 5.6384,
+      "log_good": 5.6348
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6365,
+      "good": 0.6146,
+      "ratio": 0.9656,
+      "suggested_scalar": -0.101,
+      "log_bad": -0.4518,
+      "log_good": -0.4868
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 103.0,
+      "good": 93.0,
+      "ratio": 0.9029,
+      "suggested_scalar": -0.2947,
+      "log_bad": 4.6347,
+      "log_good": 4.5326
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 739.0,
+      "good": 702.0,
+      "ratio": 0.9499,
+      "suggested_scalar": -0.1482,
+      "log_bad": 6.6053,
+      "log_good": 6.5539
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 151.0,
+      "good": 136.0,
+      "ratio": 0.9007,
+      "suggested_scalar": -0.3019,
+      "log_bad": 5.0173,
+      "log_good": 4.9127
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2175,
+      "good": 0.2336,
+      "ratio": 1.074,
+      "suggested_scalar": 0.206,
+      "log_bad": -1.5256,
+      "log_good": -1.4541
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 43.0,
+      "good": 45.0,
+      "ratio": 1.0465,
+      "suggested_scalar": 0.1312,
+      "log_bad": 3.7612,
+      "log_good": 3.8067
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 103.0,
+      "good": 93.0,
+      "ratio": 0.9029,
+      "suggested_scalar": -0.2947,
+      "log_bad": 4.6347,
+      "log_good": 4.5326
+    },
+    "brevity.mean_sample_size": {
+      "bad": 103.0,
+      "good": 93.0,
+      "ratio": 0.9029,
+      "suggested_scalar": -0.2947,
+      "log_bad": 4.6347,
+      "log_good": 4.5326
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 308.0,
+      "good": 304.0,
+      "ratio": 0.987,
+      "suggested_scalar": -0.0377,
+      "log_bad": 5.7301,
+      "log_good": 5.717
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 141.0,
+      "good": 146.0,
+      "ratio": 1.0355,
+      "suggested_scalar": 0.1005,
+      "log_bad": 4.9488,
+      "log_good": 4.9836
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 231.0,
+      "good": 228.0,
+      "ratio": 0.987,
+      "suggested_scalar": -0.0377,
+      "log_bad": 5.4424,
+      "log_good": 5.4293
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.7297,
+      "good": 1.8788,
+      "ratio": 1.0862,
+      "suggested_scalar": 0.2386,
+      "log_bad": 0.5479,
+      "log_good": 0.6306
+    },
+    "halstead.mean_effort": {
+      "bad": 36478.4451,
+      "good": 39502.5586,
+      "ratio": 1.0829,
+      "suggested_scalar": 0.2298,
+      "log_bad": 10.5045,
+      "log_good": 10.5841
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8768,
+      "good": 0.8728,
+      "ratio": 0.9954,
+      "suggested_scalar": -0.0132,
+      "log_bad": -0.1315,
+      "log_good": -0.136
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 83.0,
+      "good": 73.0,
+      "ratio": 0.8795,
+      "suggested_scalar": -0.3704,
+      "log_bad": 4.4188,
+      "log_good": 4.2905
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 134.0,
+      "good": 144.0,
+      "ratio": 1.0746,
+      "suggested_scalar": 0.2077,
+      "log_bad": 4.8978,
+      "log_good": 4.9698
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5315,
+      "good": 0.5078,
+      "ratio": 0.9554,
+      "suggested_scalar": -0.1316,
+      "log_bad": -0.6321,
+      "log_good": -0.6777
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.1678,
+      "good": 5.4844,
+      "ratio": 1.0613,
+      "suggested_scalar": 0.1716,
+      "log_bad": 1.6424,
+      "log_good": 1.7019
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.15,
+      "good": 0.1463,
+      "ratio": 0.9753,
+      "suggested_scalar": -0.0721,
+      "log_bad": -1.8971,
+      "log_good": -1.9221
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.3421,
+      "good": 3.9806,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.2508,
+      "log_bad": 1.4684,
+      "log_good": 1.3814
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 307.0,
+      "good": 303.0,
+      "ratio": 0.987,
+      "suggested_scalar": -0.0378,
+      "log_bad": 5.7268,
+      "log_good": 5.7137
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 16.0,
+      "good": 15.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.1862,
+      "log_bad": 2.7726,
+      "log_good": 2.7081
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2026.5803,
+      "good": 2194.5866,
+      "ratio": 1.0829,
+      "suggested_scalar": 0.2298,
+      "log_bad": 7.6141,
+      "log_good": 7.6937
+    },
+    "readability.mean_total_lines": {
+      "bad": 34.0,
+      "good": 35.0,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.0836,
+      "log_bad": 3.5264,
+      "log_good": 3.5553
+    },
+    "indentation.mean_max_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_volume": {
+      "bad": 1909.6253,
+      "good": 1843.7895,
+      "ratio": 0.9655,
+      "suggested_scalar": -0.1012,
+      "log_bad": 7.5547,
+      "log_good": 7.5196
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 608.0,
+      "good": 599.0,
+      "ratio": 0.9852,
+      "suggested_scalar": -0.043,
+      "log_bad": 6.4102,
+      "log_good": 6.3953
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 34.2353,
+      "good": 32.4571,
+      "ratio": 0.9481,
+      "suggested_scalar": -0.1539,
+      "log_bad": 3.5333,
+      "log_good": 3.4799
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1976,
+      "good": 1.2089,
+      "ratio": 1.0094,
+      "suggested_scalar": 0.0271,
+      "log_bad": 0.1803,
+      "log_good": 0.1897
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 26.0,
+      "good": 26.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2581,
+      "log_good": 3.2581
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 8.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.3853,
+      "log_bad": 1.9459,
+      "log_good": 2.0794
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9431,
+      "good": 0.9464,
+      "ratio": 1.0035,
+      "suggested_scalar": 0.0101,
+      "log_bad": -0.0586,
+      "log_good": -0.0551
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9755,
+      "good": 0.9796,
+      "ratio": 1.0042,
+      "suggested_scalar": 0.0121,
+      "log_bad": -0.0248,
+      "log_good": -0.0206
+    },
+    "halstead.mean_length": {
+      "bad": 285.0,
+      "good": 280.0,
+      "ratio": 0.9825,
+      "suggested_scalar": -0.0511,
+      "log_bad": 5.6525,
+      "log_good": 5.6348
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.0,
+      "good": 6.5,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.231,
+      "log_bad": 1.7918,
+      "log_good": 1.8718
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6865,
+      "good": 6.5392,
+      "ratio": 0.978,
+      "suggested_scalar": -0.0643,
+      "log_bad": 1.9001,
+      "log_good": 1.8778
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1171,
+      "good": 0.124,
+      "ratio": 1.0589,
+      "suggested_scalar": 0.1652,
+      "log_bad": -2.1447,
+      "log_good": -2.0875
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 19.1024,
+      "good": 21.4247,
+      "ratio": 1.1216,
+      "suggested_scalar": 0.331,
+      "log_bad": 2.9498,
+      "log_good": 3.0645
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 1.4739,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 76.0,
+      "good": 65.0,
+      "ratio": 0.8553,
+      "suggested_scalar": -0.4511,
+      "log_bad": 4.3307,
+      "log_good": 4.1744
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8139,
+      "good": 0.8026,
+      "ratio": 0.9861,
+      "suggested_scalar": -0.0403,
+      "log_bad": -0.2059,
+      "log_good": -0.2199
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 34.0,
+      "good": 35.0,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.0836,
+      "log_bad": 3.5264,
+      "log_good": 3.5553
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.async_method_named_with_async_suffix": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0161,
+      "good": 0.0175,
+      "ratio": 1.087,
+      "suggested_scalar": 0.1203,
+      "log_bad": -4.1289,
+      "log_good": -4.0456
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.25,
+      "good": 1.25,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2231,
+      "log_good": 0.2231
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7647,
+      "good": 0.75,
+      "ratio": 0.9808,
+      "suggested_scalar": -0.028,
+      "log_bad": -0.2683,
+      "log_good": -0.2877
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0161,
+      "good": 0.0175,
+      "ratio": 1.087,
+      "suggested_scalar": 0.1203,
+      "log_bad": -4.1289,
+      "log_good": -4.0456
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6753,
+      "good": 4.6673,
+      "ratio": 0.9983,
+      "suggested_scalar": -0.0025,
+      "log_bad": 1.5423,
+      "log_good": 1.5406
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 100.0,
+      "good": 86.0,
+      "ratio": 0.86,
+      "suggested_scalar": -0.2176,
+      "log_bad": 4.6052,
+      "log_good": 4.4543
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5014,
+      "good": 0.4498,
+      "ratio": 0.8971,
+      "suggested_scalar": -0.1567,
+      "log_bad": -0.6904,
+      "log_good": -0.799
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 15.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0931,
+      "log_bad": 2.7726,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6907,
+      "good": 0.666,
+      "ratio": 0.9642,
+      "suggested_scalar": -0.0525,
+      "log_bad": -0.37,
+      "log_good": -0.4065
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 8.549,
+      "good": 8.5833,
+      "ratio": 1.004,
+      "suggested_scalar": 0.0058,
+      "log_bad": 2.1458,
+      "log_good": 2.1498
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 435.0,
+      "good": 399.0,
+      "ratio": 0.9172,
+      "suggested_scalar": -0.1246,
+      "log_bad": 6.0753,
+      "log_good": 5.989
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0012,
+      "good": 0.0013,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.1155,
+      "log_bad": -6.7254,
+      "log_good": -6.6454
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0784,
+      "good": 0.0208,
+      "ratio": 0.2653,
+      "suggested_scalar": -1.9143,
+      "log_bad": -2.5459,
+      "log_good": -3.8728
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9726,
+      "good": 0.9954,
+      "ratio": 1.0234,
+      "suggested_scalar": 0.0334,
+      "log_bad": -0.0278,
+      "log_good": -0.0046
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 168.0,
+      "good": 142.0,
+      "ratio": 0.8452,
+      "suggested_scalar": -0.2426,
+      "log_bad": 5.124,
+      "log_good": 4.9558
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 89.2978,
+      "good": 84.4468,
+      "ratio": 0.9457,
+      "suggested_scalar": -0.0806,
+      "log_bad": 4.492,
+      "log_good": 4.4361
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7143,
+      "good": 0.7312,
+      "ratio": 1.0237,
+      "suggested_scalar": 0.0337,
+      "log_bad": -0.3365,
+      "log_good": -0.3131
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.9471,
+      "good": 15.6044,
+      "ratio": 1.1188,
+      "suggested_scalar": 0.162,
+      "log_bad": 2.6353,
+      "log_good": 2.7476
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2490.0,
+      "good": 2286.0,
+      "ratio": 0.9181,
+      "suggested_scalar": -0.1233,
+      "log_bad": 7.82,
+      "log_good": 7.7346
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6863,
+      "good": 0.6667,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.0418,
+      "log_bad": -0.3764,
+      "log_good": -0.4054
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.5294,
+      "good": 8.3125,
+      "ratio": 0.9746,
+      "suggested_scalar": -0.0372,
+      "log_bad": 2.1435,
+      "log_good": 2.1178
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 15.6986,
+      "good": 16.6597,
+      "ratio": 1.0612,
+      "suggested_scalar": 0.0857,
+      "log_bad": 2.7536,
+      "log_good": 2.813
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 70.0,
+      "good": 52.0,
+      "ratio": 0.7429,
+      "suggested_scalar": -0.4288,
+      "log_bad": 4.2485,
+      "log_good": 3.9512
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9374,
+      "good": 0.9332,
+      "ratio": 0.9955,
+      "suggested_scalar": -0.0065,
+      "log_bad": -0.0646,
+      "log_good": -0.0691
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.7209,
+      "good": 0.7297,
+      "ratio": 1.0122,
+      "suggested_scalar": 0.0175,
+      "log_bad": -0.3273,
+      "log_good": -0.3151
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.6097,
+      "good": 0.6222,
+      "ratio": 1.0205,
+      "suggested_scalar": 0.0293,
+      "log_bad": -0.4948,
+      "log_good": -0.4745
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.5827,
+      "good": 3.699,
+      "ratio": 1.0325,
+      "suggested_scalar": 0.0461,
+      "log_bad": 1.2761,
+      "log_good": 1.3081
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 433.0,
+      "good": 397.0,
+      "ratio": 0.9169,
+      "suggested_scalar": -0.1252,
+      "log_bad": 6.0707,
+      "log_good": 5.9839
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 11.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.1255,
+      "log_bad": 2.4849,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0224,
+      "good": 5.9542,
+      "ratio": 0.9887,
+      "suggested_scalar": -0.0164,
+      "log_bad": 1.7955,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 78.0,
+      "good": 70.0,
+      "ratio": 0.8974,
+      "suggested_scalar": -0.1561,
+      "log_bad": 4.3567,
+      "log_good": 4.2485
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.5213,
+      "good": 1.5688,
+      "ratio": 1.0312,
+      "suggested_scalar": 0.0444,
+      "log_bad": 0.4196,
+      "log_good": 0.4503
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.908,
+      "good": 5.7024,
+      "ratio": 0.9652,
+      "suggested_scalar": -0.0511,
+      "log_bad": 1.7763,
+      "log_good": 1.7409
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7763,
+      "good": 0.7839,
+      "ratio": 1.0098,
+      "suggested_scalar": 0.0141,
+      "log_bad": -0.2532,
+      "log_good": -0.2435
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1905,
+      "good": 0.2,
+      "ratio": 1.0499,
+      "suggested_scalar": 0.0702,
+      "log_bad": -1.6581,
+      "log_good": -1.6094
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.7346,
+      "good": 3.9502,
+      "ratio": 1.0577,
+      "suggested_scalar": 0.081,
+      "log_bad": 1.3176,
+      "log_good": 1.3738
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 249.0,
+      "good": 226.0,
+      "ratio": 0.9076,
+      "suggested_scalar": -0.1398,
+      "log_bad": 5.5175,
+      "log_good": 5.4205
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8925,
+      "good": 0.7926,
+      "ratio": 0.8881,
+      "suggested_scalar": -0.1713,
+      "log_bad": -0.1137,
+      "log_good": -0.2324
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 105.0,
+      "good": 90.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.2224,
+      "log_bad": 4.654,
+      "log_good": 4.4998
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1366.0,
+      "good": 1240.0,
+      "ratio": 0.9078,
+      "suggested_scalar": -0.1396,
+      "log_bad": 7.2196,
+      "log_good": 7.1229
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 187.0,
+      "good": 160.0,
+      "ratio": 0.8556,
+      "suggested_scalar": -0.225,
+      "log_bad": 5.2311,
+      "log_good": 5.0752
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2621,
+      "good": 0.2857,
+      "ratio": 1.09,
+      "suggested_scalar": 0.1244,
+      "log_bad": -1.339,
+      "log_good": -1.2528
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 87.0,
+      "good": 83.0,
+      "ratio": 0.954,
+      "suggested_scalar": -0.0679,
+      "log_bad": 4.4659,
+      "log_good": 4.4188
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 105.0,
+      "good": 90.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.2224,
+      "log_bad": 4.654,
+      "log_good": 4.4998
+    },
+    "brevity.mean_sample_size": {
+      "bad": 105.0,
+      "good": 90.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.2224,
+      "log_bad": 4.654,
+      "log_good": 4.4998
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 435.0,
+      "good": 399.0,
+      "ratio": 0.9172,
+      "suggested_scalar": -0.1246,
+      "log_bad": 6.0753,
+      "log_good": 5.989
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 212.0,
+      "good": 203.0,
+      "ratio": 0.9575,
+      "suggested_scalar": -0.0626,
+      "log_bad": 5.3566,
+      "log_good": 5.3132
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 211.0,
+      "good": 190.0,
+      "ratio": 0.9005,
+      "suggested_scalar": -0.1512,
+      "log_bad": 5.3519,
+      "log_good": 5.247
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.8879,
+      "good": 2.0059,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.0875,
+      "log_bad": 0.6355,
+      "log_good": 0.6961
+    },
+    "halstead.mean_effort": {
+      "bad": 66547.0922,
+      "good": 61454.8642,
+      "ratio": 0.9235,
+      "suggested_scalar": -0.1148,
+      "log_bad": 11.1057,
+      "log_good": 11.0261
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8799,
+      "good": 0.8784,
+      "ratio": 0.9983,
+      "suggested_scalar": -0.0025,
+      "log_bad": -0.1279,
+      "log_good": -0.1297
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 79.0,
+      "good": 65.0,
+      "ratio": 0.8228,
+      "suggested_scalar": -0.2814,
+      "log_bad": 4.3694,
+      "log_good": 4.1744
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 216.0,
+      "good": 210.0,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.0406,
+      "log_bad": 5.3753,
+      "log_good": 5.3471
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4286,
+      "good": 0.4155,
+      "ratio": 0.9694,
+      "suggested_scalar": -0.0448,
+      "log_bad": -0.8472,
+      "log_good": -0.8783
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.131,
+      "good": 8.7324,
+      "ratio": 1.074,
+      "suggested_scalar": 0.1029,
+      "log_bad": 2.0957,
+      "log_good": 2.167
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1905,
+      "good": 0.2,
+      "ratio": 1.0499,
+      "suggested_scalar": 0.0702,
+      "log_bad": -1.6581,
+      "log_good": -1.6094
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.488,
+      "good": 4.7536,
+      "ratio": 1.0592,
+      "suggested_scalar": 0.0829,
+      "log_bad": 1.5014,
+      "log_good": 1.5589
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 434.0,
+      "good": 398.0,
+      "ratio": 0.9171,
+      "suggested_scalar": -0.1249,
+      "log_bad": 6.073,
+      "log_good": 5.9865
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 80.0,
+      "good": 76.0,
+      "ratio": 0.95,
+      "suggested_scalar": -0.074,
+      "log_bad": 4.382,
+      "log_good": 4.3307
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3697.0607,
+      "good": 3414.1591,
+      "ratio": 0.9235,
+      "suggested_scalar": -0.1148,
+      "log_bad": 8.2153,
+      "log_good": 8.1357
+    },
+    "readability.mean_total_lines": {
+      "bad": 51.0,
+      "good": 48.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0875,
+      "log_bad": 3.9318,
+      "log_good": 3.8712
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2677.474,
+      "good": 2377.718,
+      "ratio": 0.888,
+      "suggested_scalar": -0.1713,
+      "log_bad": 7.8926,
+      "log_good": 7.7739
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 695.0,
+      "good": 618.0,
+      "ratio": 0.8892,
+      "suggested_scalar": -0.1694,
+      "log_bad": 6.5439,
+      "log_good": 6.4265
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 47.4706,
+      "good": 46.375,
+      "ratio": 0.9769,
+      "suggested_scalar": -0.0337,
+      "log_bad": 3.8601,
+      "log_good": 3.8368
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.287,
+      "good": 1.3469,
+      "ratio": 1.0465,
+      "suggested_scalar": 0.0656,
+      "log_bad": 0.2523,
+      "log_good": 0.2978
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 33.0,
+      "good": 33.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4965,
+      "log_good": 3.4965
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 1.0,
+      "ratio": 0.25,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.3863,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6787,
+      "good": 0.6637,
+      "ratio": 0.9779,
+      "suggested_scalar": -0.0322,
+      "log_bad": -0.3876,
+      "log_good": -0.4099
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9369,
+      "good": 0.9347,
+      "ratio": 0.9977,
+      "suggested_scalar": -0.0034,
+      "log_bad": -0.0652,
+      "log_good": -0.0675
+    },
+    "halstead.mean_length": {
+      "bad": 403.0,
+      "good": 370.0,
+      "ratio": 0.9181,
+      "suggested_scalar": -0.1233,
+      "log_bad": 5.9989,
+      "log_good": 5.9135
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.25,
+      "good": 10.5,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0995,
+      "log_bad": 2.4204,
+      "log_good": 2.3514
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7142,
+      "good": 6.4919,
+      "ratio": 0.9669,
+      "suggested_scalar": -0.0486,
+      "log_bad": 1.9042,
+      "log_good": 1.8706
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0853,
+      "good": 0.0888,
+      "ratio": 1.041,
+      "suggested_scalar": 0.058,
+      "log_bad": -2.4616,
+      "log_good": -2.4214
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 24.8544,
+      "good": 25.8462,
+      "ratio": 1.0399,
+      "suggested_scalar": 0.0565,
+      "log_bad": 3.213,
+      "log_good": 3.2522
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 72.0,
+      "good": 59.0,
+      "ratio": 0.8194,
+      "suggested_scalar": -0.2873,
+      "log_bad": 4.2767,
+      "log_good": 4.0775
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5877,
+      "good": 0.5632,
+      "ratio": 0.9583,
+      "suggested_scalar": -0.0614,
+      "log_bad": -0.5315,
+      "log_good": -0.5741
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 51.0,
+      "good": 48.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0875,
+      "log_bad": 3.9318,
+      "log_good": 3.8712
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 23.0,
+      "good": 26.0,
+      "ratio": 1.1304,
+      "suggested_scalar": 0.1769,
+      "log_bad": 3.1355,
+      "log_good": 3.2581
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "variable_naming.negated_boolean_name": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 79.0,
+      "good": 76.0,
+      "ratio": 0.962,
+      "suggested_scalar": -0.4213,
+      "log_bad": 4.3694,
+      "log_good": 4.3307
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 53.3333,
+      "good": 52.3333,
+      "ratio": 0.9812,
+      "suggested_scalar": -0.206,
+      "log_bad": 3.9766,
+      "log_good": 3.9576
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.3333,
+      "good": 2.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.8473,
+      "log_good": 0.8473
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0088,
+      "good": 0.009,
+      "ratio": 1.0227,
+      "suggested_scalar": 0.2446,
+      "log_bad": -4.733,
+      "log_good": -4.7105
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1282,
+      "good": 1.1282,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1206,
+      "log_good": 0.1206
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9135,
+      "good": 0.9135,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0905,
+      "log_good": -0.0905
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0268,
+      "good": 0.0271,
+      "ratio": 1.0112,
+      "suggested_scalar": 0.1212,
+      "log_bad": -3.6194,
+      "log_good": -3.6082
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8506,
+      "good": 4.8414,
+      "ratio": 0.9981,
+      "suggested_scalar": -0.0207,
+      "log_bad": 1.5791,
+      "log_good": 1.5772
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 143.0,
+      "good": 139.0,
+      "ratio": 0.972,
+      "suggested_scalar": -0.3088,
+      "log_bad": 4.9628,
+      "log_good": 4.9345
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5448,
+      "good": 0.5412,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0722,
+      "log_bad": -0.6073,
+      "log_good": -0.614
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5696,
+      "good": 0.5767,
+      "ratio": 1.0125,
+      "suggested_scalar": 0.1348,
+      "log_bad": -0.5628,
+      "log_good": -0.5504
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.7569,
+      "good": 2.7569,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0141,
+      "log_good": 1.0141
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 813.0,
+      "good": 814.3333,
+      "ratio": 1.0016,
+      "suggested_scalar": 0.0178,
+      "log_bad": 6.7007,
+      "log_good": 6.7024
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.3333,
+      "good": 2.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.8473,
+      "log_good": 0.8473
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0038,
+      "good": 0.0033,
+      "ratio": 0.8684,
+      "suggested_scalar": -1.5354,
+      "log_bad": -5.5728,
+      "log_good": -5.7138
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0193,
+      "good": 0.0193,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.9477,
+      "log_good": -3.9477
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0056,
+      "good": 0.0056,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.185,
+      "log_good": -5.185
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0679,
+      "good": 1.0735,
+      "ratio": 1.0052,
+      "suggested_scalar": 0.0569,
+      "log_bad": 0.0657,
+      "log_good": 0.0709
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 263.3333,
+      "good": 263.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.5734,
+      "log_good": 5.5734
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 79.5453,
+      "good": 84.5486,
+      "ratio": 1.0629,
+      "suggested_scalar": 0.6639,
+      "log_bad": 4.3763,
+      "log_good": 4.4373
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6261,
+      "good": 0.6341,
+      "ratio": 1.0128,
+      "suggested_scalar": 0.1382,
+      "log_bad": -0.4682,
+      "log_good": -0.4555
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 22.7193,
+      "good": 18.9054,
+      "ratio": 0.8321,
+      "suggested_scalar": -2.0,
+      "log_bad": 3.1232,
+      "log_good": 2.9394
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 3347.3333,
+      "good": 3299.6667,
+      "ratio": 0.9858,
+      "suggested_scalar": -0.1561,
+      "log_bad": 8.1159,
+      "log_good": 8.1016
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2161,
+      "good": 0.2161,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.532,
+      "log_good": -1.532
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8992,
+      "good": 0.8992,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1062,
+      "log_good": -0.1062
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 11.8333,
+      "good": 11.8508,
+      "ratio": 1.0015,
+      "suggested_scalar": 0.0161,
+      "log_bad": 2.4709,
+      "log_good": 2.4724
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.5,
+      "good": 2.5,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9163,
+      "log_good": 0.9163
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.8477,
+      "good": 1.8477,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6139,
+      "log_good": 0.6139
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 207.0,
+      "good": 208.0,
+      "ratio": 1.0048,
+      "suggested_scalar": 0.0524,
+      "log_bad": 5.3327,
+      "log_good": 5.3375
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9578,
+      "good": 0.9599,
+      "ratio": 1.0022,
+      "suggested_scalar": 0.0238,
+      "log_bad": -0.0431,
+      "log_good": -0.0409
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 34.3333,
+      "good": 34.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5361,
+      "log_good": 3.5361
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6703,
+      "good": 0.6729,
+      "ratio": 1.0039,
+      "suggested_scalar": 0.0421,
+      "log_bad": -0.4,
+      "log_good": -0.3962
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4476,
+      "good": 0.4591,
+      "ratio": 1.0257,
+      "suggested_scalar": 0.2761,
+      "log_bad": -0.8039,
+      "log_good": -0.7785
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0331,
+      "good": 3.0575,
+      "ratio": 1.008,
+      "suggested_scalar": 0.0872,
+      "log_bad": 1.1096,
+      "log_good": 1.1176
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 811.0,
+      "good": 812.3333,
+      "ratio": 1.0016,
+      "suggested_scalar": 0.0179,
+      "log_bad": 6.6983,
+      "log_good": 6.6999
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 15.6667,
+      "good": 15.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7515,
+      "log_good": 2.7515
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0274,
+      "good": 0.0262,
+      "ratio": 0.9562,
+      "suggested_scalar": -0.4874,
+      "log_bad": -3.5972,
+      "log_good": -3.642
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.2348,
+      "good": 6.2478,
+      "ratio": 1.0021,
+      "suggested_scalar": 0.0227,
+      "log_bad": 1.8301,
+      "log_good": 1.8322
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 28.3333,
+      "good": 28.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.344,
+      "log_good": 3.344
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.816,
+      "good": 0.8125,
+      "ratio": 0.9957,
+      "suggested_scalar": -0.0468,
+      "log_bad": -0.2033,
+      "log_good": -0.2076
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.051,
+      "good": 6.0268,
+      "ratio": 0.996,
+      "suggested_scalar": -0.0436,
+      "log_bad": 1.8002,
+      "log_good": 1.7962
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.778,
+      "good": 0.7749,
+      "ratio": 0.996,
+      "suggested_scalar": -0.0435,
+      "log_bad": -0.251,
+      "log_good": -0.255
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1935,
+      "good": 0.1935,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.6425,
+      "log_good": -1.6425
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.7585,
+      "good": 4.344,
+      "ratio": 0.9129,
+      "suggested_scalar": -0.9919,
+      "log_bad": 1.5599,
+      "log_good": 1.4688
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 555.3333,
+      "good": 548.3333,
+      "ratio": 0.9874,
+      "suggested_scalar": -0.1381,
+      "log_bad": 6.3196,
+      "log_good": 6.3069
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 24.0,
+      "good": 23.6667,
+      "ratio": 0.9861,
+      "suggested_scalar": -0.1522,
+      "log_bad": 3.1781,
+      "log_good": 3.1641
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.6747,
+      "good": 1.6653,
+      "ratio": 0.9944,
+      "suggested_scalar": -0.0613,
+      "log_bad": 0.5156,
+      "log_good": 0.51
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 166.6667,
+      "good": 161.0,
+      "ratio": 0.966,
+      "suggested_scalar": -0.3765,
+      "log_bad": 5.116,
+      "log_good": 5.0814
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1979.6667,
+      "good": 1907.0,
+      "ratio": 0.9633,
+      "suggested_scalar": -0.407,
+      "log_bad": 7.5907,
+      "log_good": 7.5533
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 260.3333,
+      "good": 260.6667,
+      "ratio": 1.0013,
+      "suggested_scalar": 0.0139,
+      "log_bad": 5.562,
+      "log_good": 5.5632
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0015,
+      "good": 0.0015,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.5023,
+      "log_good": -6.5023
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2385,
+      "good": 0.2362,
+      "ratio": 0.9904,
+      "suggested_scalar": -0.1055,
+      "log_bad": -1.4334,
+      "log_good": -1.4431
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 119.3333,
+      "good": 121.3333,
+      "ratio": 1.0168,
+      "suggested_scalar": 0.1809,
+      "log_bad": 4.7819,
+      "log_good": 4.7985
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 166.6667,
+      "good": 161.0,
+      "ratio": 0.966,
+      "suggested_scalar": -0.3765,
+      "log_bad": 5.116,
+      "log_good": 5.0814
+    },
+    "brevity.mean_sample_size": {
+      "bad": 166.6667,
+      "good": 161.0,
+      "ratio": 0.966,
+      "suggested_scalar": -0.3765,
+      "log_bad": 5.116,
+      "log_good": 5.0814
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 813.0,
+      "good": 814.3333,
+      "ratio": 1.0016,
+      "suggested_scalar": 0.0178,
+      "log_bad": 6.7007,
+      "log_good": 6.7024
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 461.3333,
+      "good": 460.6667,
+      "ratio": 0.9986,
+      "suggested_scalar": -0.0157,
+      "log_bad": 6.1341,
+      "log_good": 6.1327
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 421.0,
+      "good": 417.0,
+      "ratio": 0.9905,
+      "suggested_scalar": -0.1039,
+      "log_bad": 6.0426,
+      "log_good": 6.0331
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0025,
+      "good": 0.0025,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.9915,
+      "log_good": -5.9915
+    },
+    "heaps.mean_k": {
+      "bad": 3.7146,
+      "good": 3.4592,
+      "ratio": 0.9312,
+      "suggested_scalar": -0.7753,
+      "log_bad": 1.3123,
+      "log_good": 1.241
+    },
+    "halstead.mean_effort": {
+      "bad": 210281.8816,
+      "good": 215986.2418,
+      "ratio": 1.0271,
+      "suggested_scalar": 0.2913,
+      "log_bad": 12.2562,
+      "log_good": 12.283
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8198,
+      "good": 0.8221,
+      "ratio": 1.0028,
+      "suggested_scalar": 0.0305,
+      "log_bad": -0.1987,
+      "log_good": -0.1959
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 108.6667,
+      "good": 104.6667,
+      "ratio": 0.9632,
+      "suggested_scalar": -0.4082,
+      "log_bad": 4.6883,
+      "log_good": 4.6508
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 441.6667,
+      "good": 441.3333,
+      "ratio": 0.9992,
+      "suggested_scalar": -0.0082,
+      "log_bad": 6.0906,
+      "log_good": 6.0898
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4579,
+      "good": 0.4399,
+      "ratio": 0.9607,
+      "suggested_scalar": -0.4365,
+      "log_bad": -0.7811,
+      "log_good": -0.8212
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.5302,
+      "good": 7.2533,
+      "ratio": 0.9632,
+      "suggested_scalar": -0.4077,
+      "log_bad": 2.0189,
+      "log_good": 1.9815
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1935,
+      "good": 0.1935,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.6425,
+      "log_good": -1.6425
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 8.6814,
+      "good": 8.3259,
+      "ratio": 0.9591,
+      "suggested_scalar": -0.4551,
+      "log_bad": 2.1612,
+      "log_good": 2.1194
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 812.0,
+      "good": 813.3333,
+      "ratio": 1.0016,
+      "suggested_scalar": 0.0179,
+      "log_bad": 6.6995,
+      "log_good": 6.7011
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 16.6667,
+      "good": 15.3333,
+      "ratio": 0.92,
+      "suggested_scalar": -0.9075,
+      "log_bad": 2.8134,
+      "log_good": 2.73
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 108.6667,
+      "good": 110.3333,
+      "ratio": 1.0153,
+      "suggested_scalar": 0.1656,
+      "log_bad": 4.6883,
+      "log_good": 4.7035
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 11682.3268,
+      "good": 11999.2357,
+      "ratio": 1.0271,
+      "suggested_scalar": 0.2913,
+      "log_bad": 9.3658,
+      "log_good": 9.3926
+    },
+    "readability.mean_total_lines": {
+      "bad": 68.6667,
+      "good": 68.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2293,
+      "log_good": 4.2293
+    },
+    "indentation.mean_max_depth": {
+      "bad": 5.3333,
+      "good": 5.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.674,
+      "log_good": 1.674
+    },
+    "halstead.mean_volume": {
+      "bad": 5024.1167,
+      "good": 4995.9218,
+      "ratio": 0.9944,
+      "suggested_scalar": -0.0612,
+      "log_bad": 8.522,
+      "log_good": 8.5164
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1103.6667,
+      "good": 1079.3333,
+      "ratio": 0.978,
+      "suggested_scalar": -0.2426,
+      "log_bad": 7.0064,
+      "log_good": 6.9841
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 46.6656,
+      "good": 45.9924,
+      "ratio": 0.9856,
+      "suggested_scalar": -0.1581,
+      "log_bad": 3.843,
+      "log_good": 3.8285
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3626,
+      "good": 1.3033,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.4843,
+      "log_bad": 0.3094,
+      "log_good": 0.2649
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.3333,
+      "good": 2.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.8473,
+      "log_good": 0.8473
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 31.6667,
+      "good": 31.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4553,
+      "log_good": 3.4553
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8041,
+      "good": 0.7985,
+      "ratio": 0.993,
+      "suggested_scalar": -0.0761,
+      "log_bad": -0.218,
+      "log_good": -0.225
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9897,
+      "good": 0.9924,
+      "ratio": 1.0027,
+      "suggested_scalar": 0.0297,
+      "log_bad": -0.0104,
+      "log_good": -0.0076
+    },
+    "halstead.mean_length": {
+      "bad": 702.0,
+      "good": 702.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.5539,
+      "log_good": 6.5539
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.2564,
+      "good": 6.2564,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8336,
+      "log_good": 1.8336
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.3807,
+      "good": 7.3306,
+      "ratio": 0.9932,
+      "suggested_scalar": -0.0741,
+      "log_bad": 1.9989,
+      "log_good": 1.9921
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1377,
+      "good": 0.1395,
+      "ratio": 1.0131,
+      "suggested_scalar": 0.1413,
+      "log_bad": -1.9827,
+      "log_good": -1.9697
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 41.4714,
+      "good": 42.8694,
+      "ratio": 1.0337,
+      "suggested_scalar": 0.3608,
+      "log_bad": 3.725,
+      "log_good": 3.7582
+    },
+    "branching.mean_branch_count": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 120.3333,
+      "good": 115.6667,
+      "ratio": 0.9612,
+      "suggested_scalar": -0.4305,
+      "log_bad": 4.7903,
+      "log_good": 4.7507
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7167,
+      "good": 0.7092,
+      "ratio": 0.9895,
+      "suggested_scalar": -0.1145,
+      "log_bad": -0.3331,
+      "log_good": -0.3436
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 69.3333,
+      "good": 69.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2389,
+      "log_good": 4.2389
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.3333,
+      "good": 21.0,
+      "ratio": 0.9844,
+      "suggested_scalar": -0.1714,
+      "log_bad": 3.0603,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.does_not_swallow_exceptions": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 18.0,
+      "good": 21.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.0597,
+      "log_bad": 2.8904,
+      "log_good": 3.0445
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 0.0172,
+      "ratio": 0.0172,
+      "suggested_scalar": -1.5725,
+      "log_bad": 0.0,
+      "log_good": -4.0628
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3333,
+      "good": 1.5,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0456,
+      "log_bad": 0.2877,
+      "log_good": 0.4055
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7455,
+      "good": 0.8167,
+      "ratio": 1.0955,
+      "suggested_scalar": 0.0353,
+      "log_bad": -0.2937,
+      "log_good": -0.2025
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 0.0172,
+      "ratio": 0.0172,
+      "suggested_scalar": -1.5725,
+      "log_bad": 0.0,
+      "log_good": -4.0628
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.3736,
+      "good": 4.4872,
+      "ratio": 1.026,
+      "suggested_scalar": 0.0099,
+      "log_bad": 1.4756,
+      "log_good": 1.5012
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 99.0,
+      "good": 135.0,
+      "ratio": 1.3636,
+      "suggested_scalar": 0.12,
+      "log_bad": 4.5951,
+      "log_good": 4.9053
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5111,
+      "good": 0.5771,
+      "ratio": 1.1291,
+      "suggested_scalar": 0.047,
+      "log_bad": -0.6712,
+      "log_good": -0.5497
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 12.0,
+      "good": 13.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.031,
+      "log_bad": 2.4849,
+      "log_good": 2.5649
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7485,
+      "good": 0.7836,
+      "ratio": 1.0469,
+      "suggested_scalar": 0.0177,
+      "log_bad": -0.2897,
+      "log_good": -0.2439
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 7.3455,
+      "good": 8.0,
+      "ratio": 1.0891,
+      "suggested_scalar": 0.033,
+      "log_bad": 1.9941,
+      "log_good": 2.0794
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 339.0,
+      "good": 524.0,
+      "ratio": 1.5457,
+      "suggested_scalar": 0.1686,
+      "log_bad": 5.826,
+      "log_good": 6.2615
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1091,
+      "good": 0.15,
+      "ratio": 1.3749,
+      "suggested_scalar": 0.1232,
+      "log_bad": -2.2155,
+      "log_good": -1.8971
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9424,
+      "good": 0.9577,
+      "ratio": 1.0162,
+      "suggested_scalar": 0.0062,
+      "log_bad": -0.0593,
+      "log_good": -0.0432
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 134.0,
+      "good": 233.0,
+      "ratio": 1.7388,
+      "suggested_scalar": 0.2141,
+      "log_bad": 4.8978,
+      "log_good": 5.451
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.6478,
+      "good": 100.4656,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0045,
+      "log_bad": 4.6215,
+      "log_good": 4.6098
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5414,
+      "good": 0.5564,
+      "ratio": 1.0277,
+      "suggested_scalar": 0.0106,
+      "log_bad": -0.6136,
+      "log_good": -0.5863
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 14.5799,
+      "good": 18.4034,
+      "ratio": 1.2622,
+      "suggested_scalar": 0.0901,
+      "log_bad": 2.6796,
+      "log_good": 2.9125
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1981.0,
+      "good": 2844.0,
+      "ratio": 1.4356,
+      "suggested_scalar": 0.14,
+      "log_bad": 7.5914,
+      "log_good": 7.953
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2545,
+      "good": 0.3167,
+      "ratio": 1.2444,
+      "suggested_scalar": 0.0846,
+      "log_bad": -1.3685,
+      "log_good": -1.1498
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7091,
+      "good": 0.7833,
+      "ratio": 1.1046,
+      "suggested_scalar": 0.0385,
+      "log_bad": -0.3438,
+      "log_good": -0.2442
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.1636,
+      "good": 8.7333,
+      "ratio": 1.4169,
+      "suggested_scalar": 0.1349,
+      "log_bad": 1.8187,
+      "log_good": 2.1671
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 13.8261,
+      "good": 16.0,
+      "ratio": 1.1572,
+      "suggested_scalar": 0.0565,
+      "log_bad": 2.6266,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 89.0,
+      "good": 157.0,
+      "ratio": 1.764,
+      "suggested_scalar": 0.2197,
+      "log_bad": 4.4886,
+      "log_good": 5.0562
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9431,
+      "good": 0.9565,
+      "ratio": 1.0142,
+      "suggested_scalar": 0.0055,
+      "log_bad": -0.0586,
+      "log_good": -0.0445
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 27.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.0973,
+      "log_bad": 3.0445,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6795,
+      "good": 0.6702,
+      "ratio": 0.9863,
+      "suggested_scalar": -0.0053,
+      "log_bad": -0.3864,
+      "log_good": -0.4002
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3769,
+      "good": 0.3985,
+      "ratio": 1.0573,
+      "suggested_scalar": 0.0216,
+      "log_bad": -0.9758,
+      "log_good": -0.92
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.1197,
+      "good": 3.032,
+      "ratio": 0.9719,
+      "suggested_scalar": -0.011,
+      "log_bad": 1.1377,
+      "log_good": 1.1092
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 337.0,
+      "good": 522.0,
+      "ratio": 1.549,
+      "suggested_scalar": 0.1694,
+      "log_bad": 5.8201,
+      "log_good": 6.2577
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 21.0,
+      "good": 28.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1113,
+      "log_bad": 3.0445,
+      "log_good": 3.3322
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 0.0057,
+      "ratio": 0.0057,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.1673
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.9069,
+      "ratio": 1.0127,
+      "suggested_scalar": 0.0049,
+      "log_bad": 1.7635,
+      "log_good": 1.7761
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 27.0,
+      "good": 55.0,
+      "ratio": 2.037,
+      "suggested_scalar": 0.2754,
+      "log_bad": 3.2958,
+      "log_good": 4.0073
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2468,
+      "good": 1.1884,
+      "ratio": 0.9532,
+      "suggested_scalar": -0.0186,
+      "log_bad": 0.2206,
+      "log_good": 0.1726
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7368,
+      "good": 6.1182,
+      "ratio": 1.0665,
+      "suggested_scalar": 0.0249,
+      "log_bad": 1.7469,
+      "log_good": 1.8113
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7498,
+      "good": 0.7597,
+      "ratio": 1.0132,
+      "suggested_scalar": 0.0051,
+      "log_bad": -0.2879,
+      "log_good": -0.2748
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2029,
+      "good": 0.1781,
+      "ratio": 0.8778,
+      "suggested_scalar": -0.0505,
+      "log_bad": -1.595,
+      "log_good": -1.7254
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.8184,
+      "good": 4.2899,
+      "ratio": 1.1235,
+      "suggested_scalar": 0.0451,
+      "log_bad": 1.3398,
+      "log_good": 1.4563
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 254.0,
+      "good": 383.0,
+      "ratio": 1.5079,
+      "suggested_scalar": 0.159,
+      "log_bad": 5.5373,
+      "log_good": 5.948
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 9.0,
+      "good": 19.0,
+      "ratio": 2.1111,
+      "suggested_scalar": 0.2892,
+      "log_bad": 2.1972,
+      "log_good": 2.9444
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7359,
+      "good": 1.1181,
+      "ratio": 1.5194,
+      "suggested_scalar": 0.1619,
+      "log_bad": -0.3067,
+      "log_good": 0.1116
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 100.0,
+      "good": 140.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.1302,
+      "log_bad": 4.6052,
+      "log_good": 4.9416
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 959.0,
+      "good": 1546.0,
+      "ratio": 1.6121,
+      "suggested_scalar": 0.1848,
+      "log_bad": 6.8659,
+      "log_good": 7.3434
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 163.0,
+      "good": 224.0,
+      "ratio": 1.3742,
+      "suggested_scalar": 0.123,
+      "log_bad": 5.0938,
+      "log_good": 5.4116
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2094,
+      "good": 0.229,
+      "ratio": 1.0936,
+      "suggested_scalar": 0.0346,
+      "log_bad": -1.5635,
+      "log_good": -1.474
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 53.0,
+      "good": 85.0,
+      "ratio": 1.6038,
+      "suggested_scalar": 0.1828,
+      "log_bad": 3.9703,
+      "log_good": 4.4427
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1569,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 100.0,
+      "good": 140.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.1302,
+      "log_bad": 4.6052,
+      "log_good": 4.9416
+    },
+    "brevity.mean_sample_size": {
+      "bad": 100.0,
+      "good": 140.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.1302,
+      "log_bad": 4.6052,
+      "log_good": 4.9416
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 339.0,
+      "good": 524.0,
+      "ratio": 1.5457,
+      "suggested_scalar": 0.1686,
+      "log_bad": 5.826,
+      "log_good": 6.2615
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 155.0,
+      "good": 229.0,
+      "ratio": 1.4774,
+      "suggested_scalar": 0.1511,
+      "log_bad": 5.0434,
+      "log_good": 5.4337
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 208.0,
+      "good": 317.0,
+      "ratio": 1.524,
+      "suggested_scalar": 0.1631,
+      "log_bad": 5.3375,
+      "log_good": 5.7589
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.3361,
+      "good": 1.1504,
+      "ratio": 0.861,
+      "suggested_scalar": -0.0579,
+      "log_bad": 0.2898,
+      "log_good": 0.1401
+    },
+    "halstead.mean_effort": {
+      "bad": 48439.3065,
+      "good": 93923.4966,
+      "ratio": 1.939,
+      "suggested_scalar": 0.2563,
+      "log_bad": 10.7881,
+      "log_good": 11.4502
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8635,
+      "good": 0.8582,
+      "ratio": 0.9939,
+      "suggested_scalar": -0.0024,
+      "log_bad": -0.1468,
+      "log_good": -0.1529
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 78.0,
+      "good": 108.0,
+      "ratio": 1.3846,
+      "suggested_scalar": 0.126,
+      "log_bad": 4.3567,
+      "log_good": 4.6821
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 170.0,
+      "good": 250.0,
+      "ratio": 1.4706,
+      "suggested_scalar": 0.1493,
+      "log_bad": 5.1358,
+      "log_good": 5.5215
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4925,
+      "good": 0.4464,
+      "ratio": 0.9064,
+      "suggested_scalar": -0.038,
+      "log_bad": -0.7083,
+      "log_good": -0.8065
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.1567,
+      "good": 6.6352,
+      "ratio": 0.9271,
+      "suggested_scalar": -0.0293,
+      "log_bad": 1.968,
+      "log_good": 1.8924
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2029,
+      "good": 0.1781,
+      "ratio": 0.8778,
+      "suggested_scalar": -0.0505,
+      "log_bad": -1.595,
+      "log_good": -1.7254
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.3398,
+      "good": 4.5781,
+      "ratio": 1.3708,
+      "suggested_scalar": 0.1221,
+      "log_bad": 1.2059,
+      "log_good": 1.5213
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 338.0,
+      "good": 523.0,
+      "ratio": 1.5473,
+      "suggested_scalar": 0.169,
+      "log_bad": 5.823,
+      "log_good": 6.2596
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 44.0,
+      "good": 69.0,
+      "ratio": 1.5682,
+      "suggested_scalar": 0.1741,
+      "log_bad": 3.7842,
+      "log_good": 4.2341
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2691.0726,
+      "good": 5217.972,
+      "ratio": 1.939,
+      "suggested_scalar": 0.2563,
+      "log_bad": 7.8977,
+      "log_good": 8.5599
+    },
+    "readability.mean_total_lines": {
+      "bad": 55.0,
+      "good": 60.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0337,
+      "log_bad": 4.0073,
+      "log_good": 4.0943
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2207.5758,
+      "good": 3354.4106,
+      "ratio": 1.5195,
+      "suggested_scalar": 0.1619,
+      "log_bad": 7.6997,
+      "log_good": 8.118
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 635.0,
+      "good": 938.0,
+      "ratio": 1.4772,
+      "suggested_scalar": 0.151,
+      "log_bad": 6.4536,
+      "log_good": 6.8437
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 34.5818,
+      "good": 46.15,
+      "ratio": 1.3345,
+      "suggested_scalar": 0.1117,
+      "log_bad": 3.5433,
+      "log_good": 3.8319
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1694,
+      "good": 1.1525,
+      "ratio": 0.9855,
+      "suggested_scalar": -0.0056,
+      "log_bad": 0.1565,
+      "log_good": 0.1419
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 24.0,
+      "good": 40.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.1977,
+      "log_bad": 3.1781,
+      "log_good": 3.6889
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 9.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1569,
+      "log_bad": 1.7918,
+      "log_good": 2.1972
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8268,
+      "good": 0.8198,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0033,
+      "log_bad": -0.1902,
+      "log_good": -0.1987
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9924,
+      "good": 0.9889,
+      "ratio": 0.9965,
+      "suggested_scalar": -0.0014,
+      "log_bad": -0.0076,
+      "log_good": -0.0112
+    },
+    "halstead.mean_length": {
+      "bad": 333.0,
+      "good": 474.0,
+      "ratio": 1.4234,
+      "suggested_scalar": 0.1367,
+      "log_bad": 5.8081,
+      "log_good": 6.1612
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 17.0,
+      "good": 27.0,
+      "ratio": 1.5882,
+      "suggested_scalar": 0.1791,
+      "log_bad": 2.8332,
+      "log_good": 3.2958
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6439,
+      "good": 7.1293,
+      "ratio": 1.0731,
+      "suggested_scalar": 0.0273,
+      "log_bad": 1.8937,
+      "log_good": 1.9642
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0786,
+      "good": 0.0806,
+      "ratio": 1.0254,
+      "suggested_scalar": 0.0097,
+      "log_bad": -2.5434,
+      "log_good": -2.5183
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 21.9423,
+      "good": 28.0,
+      "ratio": 1.2761,
+      "suggested_scalar": 0.0944,
+      "log_bad": 3.0884,
+      "log_good": 3.3322
+    },
+    "branching.mean_branch_count": {
+      "bad": 14.0,
+      "good": 19.0,
+      "ratio": 1.3571,
+      "suggested_scalar": 0.1182,
+      "log_bad": 2.6391,
+      "log_good": 2.9444
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 66.0,
+      "good": 104.0,
+      "ratio": 1.5758,
+      "suggested_scalar": 0.176,
+      "log_bad": 4.1897,
+      "log_good": 4.6444
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7452,
+      "good": 0.7319,
+      "ratio": 0.9822,
+      "suggested_scalar": -0.007,
+      "log_bad": -0.2941,
+      "log_good": -0.3121
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 55.0,
+      "good": 60.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0337,
+      "log_bad": 4.0073,
+      "log_good": 4.0943
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_implicit_null_initial": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 34.0,
+      "good": 39.0,
+      "ratio": 1.1471,
+      "suggested_scalar": 0.0422,
+      "log_bad": 3.5264,
+      "log_good": 3.6636
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.014,
+      "good": 0.0139,
+      "ratio": 0.9929,
+      "suggested_scalar": -0.0022,
+      "log_bad": -4.2687,
+      "log_good": -4.2759
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0769,
+      "good": 1.0667,
+      "ratio": 0.9905,
+      "suggested_scalar": -0.0029,
+      "log_bad": 0.0741,
+      "log_good": 0.0646
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8714,
+      "good": 0.8276,
+      "ratio": 0.9497,
+      "suggested_scalar": -0.0159,
+      "log_bad": -0.1377,
+      "log_good": -0.1892
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.014,
+      "good": 0.0139,
+      "ratio": 0.9929,
+      "suggested_scalar": -0.0022,
+      "log_bad": -4.2687,
+      "log_good": -4.2759
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4605,
+      "good": 4.5641,
+      "ratio": 1.0232,
+      "suggested_scalar": 0.0071,
+      "log_bad": 1.4953,
+      "log_good": 1.5182
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 80.0,
+      "good": 81.0,
+      "ratio": 1.0125,
+      "suggested_scalar": 0.0038,
+      "log_bad": 4.382,
+      "log_good": 4.3944
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.46,
+      "good": 0.4827,
+      "ratio": 1.0493,
+      "suggested_scalar": 0.0148,
+      "log_bad": -0.7765,
+      "log_good": -0.7284
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 19.0,
+      "ratio": 1.1176,
+      "suggested_scalar": 0.0342,
+      "log_bad": 2.8332,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5858,
+      "good": 0.571,
+      "ratio": 0.9747,
+      "suggested_scalar": -0.0079,
+      "log_bad": -0.5348,
+      "log_good": -0.5604
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.8857,
+      "good": 4.0,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.0089,
+      "log_bad": 1.3573,
+      "log_good": 1.3863
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 430.0,
+      "good": 431.0,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0007,
+      "log_bad": 6.0638,
+      "log_good": 6.0661
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0015,
+      "good": 1.0,
+      "ratio": 666.6667,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.5023,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0901,
+      "good": 1.0642,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0074,
+      "log_bad": 0.0863,
+      "log_good": 0.0622
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 147.0,
+      "good": 129.0,
+      "ratio": 0.8776,
+      "suggested_scalar": -0.0402,
+      "log_bad": 4.9904,
+      "log_good": 4.8598
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 95.32,
+      "good": 92.8203,
+      "ratio": 0.9738,
+      "suggested_scalar": -0.0082,
+      "log_bad": 4.5572,
+      "log_good": 4.5307
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5548,
+      "good": 0.6186,
+      "ratio": 1.115,
+      "suggested_scalar": 0.0335,
+      "log_bad": -0.5891,
+      "log_good": -0.4803
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 16.7552,
+      "good": 19.2242,
+      "ratio": 1.1474,
+      "suggested_scalar": 0.0423,
+      "log_bad": 2.8187,
+      "log_good": 2.9562
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1967.0,
+      "good": 1816.0,
+      "ratio": 0.9232,
+      "suggested_scalar": -0.0246,
+      "log_bad": 7.5843,
+      "log_good": 7.5044
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1429,
+      "good": 0.1897,
+      "ratio": 1.3275,
+      "suggested_scalar": 0.0871,
+      "log_bad": -1.9456,
+      "log_good": -1.6623
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8286,
+      "good": 0.7931,
+      "ratio": 0.9572,
+      "suggested_scalar": -0.0135,
+      "log_bad": -0.188,
+      "log_good": -0.2318
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.1429,
+      "good": 7.431,
+      "ratio": 1.2097,
+      "suggested_scalar": 0.0586,
+      "log_bad": 1.8153,
+      "log_good": 2.0057
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1247,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.9584,
+      "good": 5.2414,
+      "ratio": 1.7717,
+      "suggested_scalar": 0.1759,
+      "log_bad": 1.0846,
+      "log_good": 1.6566
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 139.0,
+      "good": 120.0,
+      "ratio": 0.8633,
+      "suggested_scalar": -0.0452,
+      "log_bad": 4.9345,
+      "log_good": 4.7875
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9418,
+      "good": 0.9564,
+      "ratio": 1.0155,
+      "suggested_scalar": 0.0047,
+      "log_bad": -0.06,
+      "log_good": -0.0446
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 25.0,
+      "ratio": 1.1364,
+      "suggested_scalar": 0.0393,
+      "log_bad": 3.091,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6457,
+      "good": 0.625,
+      "ratio": 0.9679,
+      "suggested_scalar": -0.01,
+      "log_bad": -0.4374,
+      "log_good": -0.47
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3014,
+      "good": 0.3986,
+      "ratio": 1.3225,
+      "suggested_scalar": 0.086,
+      "log_bad": -1.1993,
+      "log_good": -0.9198
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.8221,
+      "good": 2.6667,
+      "ratio": 0.9449,
+      "suggested_scalar": -0.0174,
+      "log_bad": 1.0375,
+      "log_good": 0.9808
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 428.0,
+      "good": 429.0,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0007,
+      "log_bad": 6.0591,
+      "log_good": 6.0615
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 22.0,
+      "good": 13.0,
+      "ratio": 0.5909,
+      "suggested_scalar": -0.1618,
+      "log_bad": 3.091,
+      "log_good": 2.5649
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0651,
+      "good": 0.0951,
+      "ratio": 1.4608,
+      "suggested_scalar": 0.1166,
+      "log_bad": -2.7318,
+      "log_good": -2.3528
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.9542,
+      "ratio": 1.0208,
+      "suggested_scalar": 0.0063,
+      "log_bad": 1.7635,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.3756,
+      "good": 0.4594,
+      "ratio": 1.2231,
+      "suggested_scalar": 0.0619,
+      "log_bad": -0.9792,
+      "log_good": -0.7778
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0068,
+      "good": 0.0078,
+      "ratio": 1.1471,
+      "suggested_scalar": 0.0422,
+      "log_bad": -4.9908,
+      "log_good": -4.8536
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5087,
+      "good": 5.4635,
+      "ratio": 0.9918,
+      "suggested_scalar": -0.0025,
+      "log_bad": 1.7063,
+      "log_good": 1.6981
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7647,
+      "good": 0.7665,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.0007,
+      "log_bad": -0.2683,
+      "log_good": -0.2659
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2135,
+      "good": 0.1471,
+      "ratio": 0.689,
+      "suggested_scalar": -0.1146,
+      "log_bad": -1.5441,
+      "log_good": -1.9166
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.0933,
+      "good": 4.3845,
+      "ratio": 1.0711,
+      "suggested_scalar": 0.0211,
+      "log_bad": 1.4094,
+      "log_good": 1.4781
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 340.0,
+      "good": 314.0,
+      "ratio": 0.9235,
+      "suggested_scalar": -0.0245,
+      "log_bad": 5.8289,
+      "log_good": 5.7494
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 10.0,
+      "good": 14.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.1035,
+      "log_bad": 2.3026,
+      "log_good": 2.6391
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8429,
+      "good": 0.8495,
+      "ratio": 1.0078,
+      "suggested_scalar": 0.0024,
+      "log_bad": -0.1709,
+      "log_good": -0.1631
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 91.0,
+      "good": 95.0,
+      "ratio": 1.044,
+      "suggested_scalar": 0.0132,
+      "log_bad": 4.5109,
+      "log_good": 4.5539
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1017.0,
+      "good": 931.0,
+      "ratio": 0.9154,
+      "suggested_scalar": -0.0272,
+      "log_bad": 6.9246,
+      "log_good": 6.8363
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 158.0,
+      "good": 138.0,
+      "ratio": 0.8734,
+      "suggested_scalar": -0.0416,
+      "log_bad": 5.0626,
+      "log_good": 4.9273
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 0.0093,
+      "ratio": 0.0093,
+      "suggested_scalar": -1.4388,
+      "log_bad": 0.0,
+      "log_good": -4.6777
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2581,
+      "good": 0.3225,
+      "ratio": 1.2495,
+      "suggested_scalar": 0.0685,
+      "log_bad": -1.3544,
+      "log_good": -1.1317
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 67.0,
+      "good": 71.0,
+      "ratio": 1.0597,
+      "suggested_scalar": 0.0178,
+      "log_bad": 4.2047,
+      "log_good": 4.2627
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 13.0,
+      "good": 15.0,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.044,
+      "log_bad": 2.5649,
+      "log_good": 2.7081
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 91.0,
+      "good": 95.0,
+      "ratio": 1.044,
+      "suggested_scalar": 0.0132,
+      "log_bad": 4.5109,
+      "log_good": 4.5539
+    },
+    "brevity.mean_sample_size": {
+      "bad": 91.0,
+      "good": 95.0,
+      "ratio": 1.044,
+      "suggested_scalar": 0.0132,
+      "log_bad": 4.5109,
+      "log_good": 4.5539
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 430.0,
+      "good": 431.0,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0007,
+      "log_bad": 6.0638,
+      "log_good": 6.0661
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 203.0,
+      "good": 224.0,
+      "ratio": 1.1034,
+      "suggested_scalar": 0.0303,
+      "log_bad": 5.3132,
+      "log_good": 5.4116
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 258.0,
+      "good": 235.0,
+      "ratio": 0.9109,
+      "suggested_scalar": -0.0287,
+      "log_bad": 5.553,
+      "log_good": 5.4596
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0047,
+      "good": 0.0046,
+      "ratio": 0.9787,
+      "suggested_scalar": -0.0066,
+      "log_bad": -5.3602,
+      "log_good": -5.3817
+    },
+    "heaps.mean_k": {
+      "bad": 2.8992,
+      "good": 3.3215,
+      "ratio": 1.1457,
+      "suggested_scalar": 0.0418,
+      "log_bad": 1.0644,
+      "log_good": 1.2004
+    },
+    "halstead.mean_effort": {
+      "bad": 75775.9381,
+      "good": 78506.589,
+      "ratio": 1.036,
+      "suggested_scalar": 0.0109,
+      "log_bad": 11.2355,
+      "log_good": 11.2709
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8465,
+      "good": 0.8316,
+      "ratio": 0.9824,
+      "suggested_scalar": -0.0055,
+      "log_bad": -0.1666,
+      "log_good": -0.1844
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 58.0,
+      "good": 56.0,
+      "ratio": 0.9655,
+      "suggested_scalar": -0.0108,
+      "log_bad": 4.0604,
+      "log_good": 4.0254
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 242.0,
+      "good": 264.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0268,
+      "log_bad": 5.4889,
+      "log_good": 5.5759
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4082,
+      "good": 0.4574,
+      "ratio": 1.1205,
+      "suggested_scalar": 0.035,
+      "log_bad": -0.896,
+      "log_good": -0.7822
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.9184,
+      "good": 7.2171,
+      "ratio": 1.0432,
+      "suggested_scalar": 0.013,
+      "log_bad": 1.9342,
+      "log_good": 1.9765
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2135,
+      "good": 0.1471,
+      "ratio": 0.689,
+      "suggested_scalar": -0.1146,
+      "log_bad": -1.5441,
+      "log_good": -1.9166
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.8127,
+      "good": 3.3627,
+      "ratio": 1.1955,
+      "suggested_scalar": 0.0549,
+      "log_bad": 1.0341,
+      "log_good": 1.2127
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 429.0,
+      "good": 430.0,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0007,
+      "log_bad": 6.0615,
+      "log_good": 6.0638
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 10.0,
+      "good": 13.0,
+      "ratio": 1.3,
+      "suggested_scalar": 0.0807,
+      "log_bad": 2.3026,
+      "log_good": 2.5649
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 41.0,
+      "good": 56.0,
+      "ratio": 1.3659,
+      "suggested_scalar": 0.0959,
+      "log_bad": 3.7136,
+      "log_good": 4.0254
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4209.7743,
+      "good": 4361.4772,
+      "ratio": 1.036,
+      "suggested_scalar": 0.0109,
+      "log_bad": 8.3452,
+      "log_good": 8.3806
+    },
+    "readability.mean_total_lines": {
+      "bad": 70.0,
+      "good": 58.0,
+      "ratio": 0.8286,
+      "suggested_scalar": -0.0578,
+      "log_bad": 4.2485,
+      "log_good": 4.0604
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2528.7712,
+      "good": 2548.6197,
+      "ratio": 1.0078,
+      "suggested_scalar": 0.0024,
+      "log_bad": 7.8355,
+      "log_good": 7.8433
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 697.0,
+      "good": 681.0,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0071,
+      "log_bad": 6.5468,
+      "log_good": 6.5236
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 26.8,
+      "good": 30.1034,
+      "ratio": 1.1233,
+      "suggested_scalar": 0.0358,
+      "log_bad": 3.2884,
+      "log_good": 3.4046
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2444,
+      "good": 1.2585,
+      "ratio": 1.0113,
+      "suggested_scalar": 0.0035,
+      "log_bad": 0.2187,
+      "log_good": 0.2299
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8794,
+      "good": 0.8217,
+      "ratio": 0.9344,
+      "suggested_scalar": -0.0209,
+      "log_bad": -0.1285,
+      "log_good": -0.1964
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9897,
+      "good": 0.9787,
+      "ratio": 0.9889,
+      "suggested_scalar": -0.0034,
+      "log_bad": -0.0104,
+      "log_good": -0.0215
+    },
+    "halstead.mean_length": {
+      "bad": 400.0,
+      "good": 402.0,
+      "ratio": 1.005,
+      "suggested_scalar": 0.0015,
+      "log_bad": 5.9915,
+      "log_good": 5.9965
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.4615,
+      "good": 4.2,
+      "ratio": 0.65,
+      "suggested_scalar": -0.1325,
+      "log_bad": 1.8659,
+      "log_good": 1.4351
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5078,
+      "good": 6.5699,
+      "ratio": 1.0095,
+      "suggested_scalar": 0.0029,
+      "log_bad": 1.873,
+      "log_good": 1.8825
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1033,
+      "good": 0.1235,
+      "ratio": 1.1955,
+      "suggested_scalar": 0.0549,
+      "log_bad": -2.2701,
+      "log_good": -2.0915
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.9655,
+      "good": 30.8036,
+      "ratio": 1.028,
+      "suggested_scalar": 0.0085,
+      "log_bad": 3.4,
+      "log_good": 3.4276
+    },
+    "branching.mean_branch_count": {
+      "bad": 10.0,
+      "good": 11.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0293,
+      "log_bad": 2.3026,
+      "log_good": 2.3979
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 60.0,
+      "good": 59.0,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0052,
+      "log_bad": 4.0943,
+      "log_good": 4.0775
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7403,
+      "good": 0.6979,
+      "ratio": 0.9427,
+      "suggested_scalar": -0.0181,
+      "log_bad": -0.3007,
+      "log_good": -0.3597
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 70.0,
+      "good": 58.0,
+      "ratio": 0.8286,
+      "suggested_scalar": -0.0578,
+      "log_bad": 4.2485,
+      "log_good": 4.0604
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "file_structure.headers_have_include_guards": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0009,
+      "good": 0.001,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0476,
+      "log_bad": -7.0131,
+      "log_good": -6.9078
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.781,
+      "good": 0.8119,
+      "ratio": 1.0396,
+      "suggested_scalar": 0.0175,
+      "log_bad": -0.2472,
+      "log_good": -0.2084
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0018,
+      "good": 0.002,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0476,
+      "log_bad": -6.32,
+      "log_good": -6.2146
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7614,
+      "good": 4.8005,
+      "ratio": 1.0082,
+      "suggested_scalar": 0.0037,
+      "log_bad": 1.5605,
+      "log_good": 1.5687
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 162.0,
+      "good": 141.0,
+      "ratio": 0.8704,
+      "suggested_scalar": -0.0628,
+      "log_bad": 5.0876,
+      "log_good": 4.9488
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5157,
+      "good": 0.4499,
+      "ratio": 0.8724,
+      "suggested_scalar": -0.0617,
+      "log_bad": -0.6622,
+      "log_good": -0.7987
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 24.0,
+      "good": 22.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0393,
+      "log_bad": 3.1781,
+      "log_good": 3.091
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5263,
+      "good": 0.4776,
+      "ratio": 0.9075,
+      "suggested_scalar": -0.0439,
+      "log_bad": -0.6419,
+      "log_good": -0.739
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.581,
+      "good": 3.7228,
+      "ratio": 1.0396,
+      "suggested_scalar": 0.0176,
+      "log_bad": 1.2756,
+      "log_good": 1.3145
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1089.0,
+      "good": 1015.0,
+      "ratio": 0.932,
+      "suggested_scalar": -0.0318,
+      "log_bad": 6.993,
+      "log_good": 6.9226
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.4286,
+      "good": 0.4059,
+      "ratio": 0.947,
+      "suggested_scalar": -0.0246,
+      "log_bad": -0.8472,
+      "log_good": -0.9016
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1347,
+      "good": 1.1796,
+      "ratio": 1.0396,
+      "suggested_scalar": 0.0175,
+      "log_bad": 0.1264,
+      "log_good": 0.1652
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 291.0,
+      "good": 249.0,
+      "ratio": 0.8557,
+      "suggested_scalar": -0.0705,
+      "log_bad": 5.6733,
+      "log_good": 5.5175
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 100.5577,
+      "good": 97.5545,
+      "ratio": 0.9701,
+      "suggested_scalar": -0.0137,
+      "log_bad": 4.6107,
+      "log_good": 4.5804
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.807,
+      "good": 0.8195,
+      "ratio": 1.0155,
+      "suggested_scalar": 0.007,
+      "log_bad": -0.2144,
+      "log_good": -0.1991
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.7689,
+      "good": 11.6808,
+      "ratio": 1.1957,
+      "suggested_scalar": 0.0808,
+      "log_bad": 2.2792,
+      "log_good": 2.4579
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 3903.0,
+      "good": 3570.0,
+      "ratio": 0.9147,
+      "suggested_scalar": -0.0403,
+      "log_bad": 8.2695,
+      "log_good": 8.1803
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1619,
+      "good": 0.1782,
+      "ratio": 1.1007,
+      "suggested_scalar": 0.0434,
+      "log_bad": -1.8208,
+      "log_good": -1.7248
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7619,
+      "good": 0.7921,
+      "ratio": 1.0396,
+      "suggested_scalar": 0.0176,
+      "log_bad": -0.2719,
+      "log_good": -0.2331
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.6765,
+      "good": 10.4639,
+      "ratio": 0.9801,
+      "suggested_scalar": -0.0091,
+      "log_bad": 2.368,
+      "log_good": 2.3479
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 44.0,
+      "good": 44.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7842,
+      "log_good": 3.7842
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 21.0054,
+      "good": 21.3093,
+      "ratio": 1.0145,
+      "suggested_scalar": 0.0065,
+      "log_bad": 3.0448,
+      "log_good": 3.0591
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 186.0,
+      "good": 158.0,
+      "ratio": 0.8495,
+      "suggested_scalar": -0.0738,
+      "log_bad": 5.2257,
+      "log_good": 5.0626
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9794,
+      "good": 0.9772,
+      "ratio": 0.9978,
+      "suggested_scalar": -0.001,
+      "log_bad": -0.0208,
+      "log_good": -0.0231
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 32.0,
+      "good": 33.0,
+      "ratio": 1.0313,
+      "suggested_scalar": 0.0139,
+      "log_bad": 3.4657,
+      "log_good": 3.4965
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.7082,
+      "good": 0.7115,
+      "ratio": 1.0047,
+      "suggested_scalar": 0.0021,
+      "log_bad": -0.345,
+      "log_good": -0.3404
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.6973,
+      "good": 0.6871,
+      "ratio": 0.9854,
+      "suggested_scalar": -0.0067,
+      "log_bad": -0.3605,
+      "log_good": -0.3753
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.4267,
+      "good": 3.466,
+      "ratio": 1.0115,
+      "suggested_scalar": 0.0052,
+      "log_bad": 1.2316,
+      "log_good": 1.243
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1087.0,
+      "good": 1013.0,
+      "ratio": 0.9319,
+      "suggested_scalar": -0.0319,
+      "log_bad": 6.9912,
+      "log_good": 6.9207
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0331,
+      "good": 0.0355,
+      "ratio": 1.0725,
+      "suggested_scalar": 0.0317,
+      "log_bad": -3.4082,
+      "log_good": -3.3382
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.1497,
+      "good": 6.1085,
+      "ratio": 0.9933,
+      "suggested_scalar": -0.003,
+      "log_bad": 1.8164,
+      "log_good": 1.8097
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 53.0,
+      "good": 36.0,
+      "ratio": 0.6792,
+      "suggested_scalar": -0.1749,
+      "log_bad": 3.9703,
+      "log_good": 3.5835
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4148,
+      "good": 1.4978,
+      "ratio": 1.0587,
+      "suggested_scalar": 0.0258,
+      "log_bad": 0.347,
+      "log_good": 0.404
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 0.012,
+      "ratio": 0.012,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -4.4228
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6201,
+      "good": 5.4422,
+      "ratio": 0.9683,
+      "suggested_scalar": -0.0145,
+      "log_bad": 1.7263,
+      "log_good": 1.6942
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7742,
+      "good": 0.7859,
+      "ratio": 1.0151,
+      "suggested_scalar": 0.0068,
+      "log_bad": -0.2559,
+      "log_good": -0.2409
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1322,
+      "good": 0.1293,
+      "ratio": 0.9781,
+      "suggested_scalar": -0.01,
+      "log_bad": -2.0234,
+      "log_good": -2.0456
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1255,
+      "good": 3.4177,
+      "ratio": 1.0935,
+      "suggested_scalar": 0.0404,
+      "log_bad": 1.1396,
+      "log_good": 1.229
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 531.0,
+      "good": 497.0,
+      "ratio": 0.936,
+      "suggested_scalar": -0.0299,
+      "log_bad": 6.2748,
+      "log_good": 6.2086
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 26.0,
+      "good": 26.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2581,
+      "log_good": 3.2581
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 2.6056,
+      "good": 2.3608,
+      "ratio": 0.906,
+      "suggested_scalar": -0.0446,
+      "log_bad": 0.9577,
+      "log_good": 0.859
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 165.0,
+      "good": 142.0,
+      "ratio": 0.8606,
+      "suggested_scalar": -0.0679,
+      "log_bad": 5.1059,
+      "log_good": 4.9558
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1795.0,
+      "good": 1588.0,
+      "ratio": 0.8847,
+      "suggested_scalar": -0.0554,
+      "log_bad": 7.4928,
+      "log_good": 7.3702
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 362.0,
+      "good": 315.0,
+      "ratio": 0.8702,
+      "suggested_scalar": -0.0629,
+      "log_bad": 5.8916,
+      "log_good": 5.7526
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1745,
+      "good": 0.1813,
+      "ratio": 1.039,
+      "suggested_scalar": 0.0173,
+      "log_bad": -1.7458,
+      "log_good": -1.7076
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 187.0,
+      "good": 175.0,
+      "ratio": 0.9358,
+      "suggested_scalar": -0.03,
+      "log_bad": 5.2311,
+      "log_good": 5.1648
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 165.0,
+      "good": 142.0,
+      "ratio": 0.8606,
+      "suggested_scalar": -0.0679,
+      "log_bad": 5.1059,
+      "log_good": 4.9558
+    },
+    "brevity.mean_sample_size": {
+      "bad": 165.0,
+      "good": 142.0,
+      "ratio": 0.8606,
+      "suggested_scalar": -0.0679,
+      "log_bad": 5.1059,
+      "log_good": 4.9558
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1089.0,
+      "good": 1015.0,
+      "ratio": 0.932,
+      "suggested_scalar": -0.0318,
+      "log_bad": 6.993,
+      "log_good": 6.9226
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 688.0,
+      "good": 663.0,
+      "ratio": 0.9637,
+      "suggested_scalar": -0.0167,
+      "log_bad": 6.5338,
+      "log_good": 6.4968
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 397.0,
+      "good": 358.0,
+      "ratio": 0.9018,
+      "suggested_scalar": -0.0468,
+      "log_bad": 5.9839,
+      "log_good": 5.8805
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 4.3474,
+      "good": 5.3541,
+      "ratio": 1.2316,
+      "suggested_scalar": 0.0942,
+      "log_bad": 1.4696,
+      "log_good": 1.6779
+    },
+    "halstead.mean_effort": {
+      "bad": 348274.7534,
+      "good": 340842.1816,
+      "ratio": 0.9787,
+      "suggested_scalar": -0.0098,
+      "log_bad": 12.7607,
+      "log_good": 12.7392
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.7629,
+      "good": 0.7612,
+      "ratio": 0.9978,
+      "suggested_scalar": -0.001,
+      "log_bad": -0.2706,
+      "log_good": -0.2729
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 130.0,
+      "good": 108.0,
+      "ratio": 0.8308,
+      "suggested_scalar": -0.0838,
+      "log_bad": 4.8675,
+      "log_good": 4.6821
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 703.0,
+      "good": 677.0,
+      "ratio": 0.963,
+      "suggested_scalar": -0.017,
+      "log_bad": 6.5554,
+      "log_good": 6.5177
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3849,
+      "good": 0.3614,
+      "ratio": 0.9389,
+      "suggested_scalar": -0.0285,
+      "log_bad": -0.9548,
+      "log_good": -1.0178
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.1684,
+      "good": 6.3775,
+      "ratio": 1.0339,
+      "suggested_scalar": 0.0151,
+      "log_bad": 1.8194,
+      "log_good": 1.8528
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1322,
+      "good": 0.1293,
+      "ratio": 0.9781,
+      "suggested_scalar": -0.01,
+      "log_bad": -2.0234,
+      "log_good": -2.0456
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.5721,
+      "good": 4.8732,
+      "ratio": 1.0659,
+      "suggested_scalar": 0.0288,
+      "log_bad": 1.52,
+      "log_good": 1.5838
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1088.0,
+      "good": 1014.0,
+      "ratio": 0.932,
+      "suggested_scalar": -0.0319,
+      "log_bad": 6.9921,
+      "log_good": 6.9217
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 202.0,
+      "good": 180.0,
+      "ratio": 0.8911,
+      "suggested_scalar": -0.0521,
+      "log_bad": 5.3083,
+      "log_good": 5.193
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 19348.5974,
+      "good": 18935.6768,
+      "ratio": 0.9787,
+      "suggested_scalar": -0.0098,
+      "log_bad": 9.8704,
+      "log_good": 9.8488
+    },
+    "readability.mean_total_lines": {
+      "bad": 102.0,
+      "good": 97.0,
+      "ratio": 0.951,
+      "suggested_scalar": -0.0227,
+      "log_bad": 4.625,
+      "log_good": 4.5747
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 7816.9403,
+      "good": 7082.4349,
+      "ratio": 0.906,
+      "suggested_scalar": -0.0446,
+      "log_bad": 8.964,
+      "log_good": 8.8654
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1139.0,
+      "good": 1030.0,
+      "ratio": 0.9043,
+      "suggested_scalar": -0.0455,
+      "log_bad": 7.0379,
+      "log_good": 6.9373
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 36.4118,
+      "good": 34.7835,
+      "ratio": 0.9553,
+      "suggested_scalar": -0.0207,
+      "log_bad": 3.5949,
+      "log_good": 3.5491
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1281,
+      "good": 1.1662,
+      "ratio": 1.0338,
+      "suggested_scalar": 0.015,
+      "log_bad": 0.1205,
+      "log_good": 0.1538
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 19.0,
+      "good": 16.0,
+      "ratio": 0.8421,
+      "suggested_scalar": -0.0777,
+      "log_bad": 2.9444,
+      "log_good": 2.7726
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 45.0,
+      "good": 41.0,
+      "ratio": 0.9111,
+      "suggested_scalar": -0.0421,
+      "log_bad": 3.8067,
+      "log_good": 3.7136
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6196,
+      "good": 0.6378,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.0131,
+      "log_bad": -0.4787,
+      "log_good": -0.4497
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9776,
+      "good": 0.9718,
+      "ratio": 0.9941,
+      "suggested_scalar": -0.0027,
+      "log_bad": -0.0227,
+      "log_good": -0.0286
+    },
+    "halstead.mean_length": {
+      "bad": 1065.0,
+      "good": 992.0,
+      "ratio": 0.9315,
+      "suggested_scalar": -0.0321,
+      "log_bad": 6.9707,
+      "log_good": 6.8997
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.3663,
+      "good": 7.1497,
+      "ratio": 0.9706,
+      "suggested_scalar": -0.0135,
+      "log_bad": 1.9969,
+      "log_good": 1.9671
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1769,
+      "good": 0.1859,
+      "ratio": 1.0509,
+      "suggested_scalar": 0.0224,
+      "log_bad": -1.7322,
+      "log_good": -1.6825
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 44.5538,
+      "good": 48.125,
+      "ratio": 1.0802,
+      "suggested_scalar": 0.0349,
+      "log_bad": 3.7967,
+      "log_good": 3.8738
+    },
+    "branching.mean_branch_count": {
+      "bad": 17.0,
+      "good": 18.0,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.0258,
+      "log_bad": 2.8332,
+      "log_good": 2.8904
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 112.0,
+      "good": 90.0,
+      "ratio": 0.8036,
+      "suggested_scalar": -0.0989,
+      "log_bad": 4.7185,
+      "log_good": 4.4998
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.529,
+      "good": 0.5112,
+      "ratio": 0.9664,
+      "suggested_scalar": -0.0155,
+      "log_bad": -0.6368,
+      "log_good": -0.671
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 105.0,
+      "good": 101.0,
+      "ratio": 0.9619,
+      "suggested_scalar": -0.0176,
+      "log_bad": 4.654,
+      "log_good": 4.6151
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 19.0,
+      "ratio": 1.3571,
+      "suggested_scalar": 0.1381,
+      "log_bad": 2.6391,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.4968,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    }
+  },
+  "code_smells.context_not_stored_in_struct": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0167,
+      "good": 0.0182,
+      "ratio": 1.0898,
+      "suggested_scalar": 0.2482,
+      "log_bad": -4.0923,
+      "log_good": -4.0063
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3333,
+      "good": 1.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.83,
+      "log_bad": 0.2877,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8393,
+      "good": 0.8491,
+      "ratio": 1.0117,
+      "suggested_scalar": 0.0335,
+      "log_bad": -0.1752,
+      "log_good": -0.1636
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0167,
+      "good": 0.0182,
+      "ratio": 1.0898,
+      "suggested_scalar": 0.2482,
+      "log_bad": -4.0923,
+      "log_good": -4.0063
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8822,
+      "good": 4.8943,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0071,
+      "log_bad": 1.5856,
+      "log_good": 1.5881
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 122.0,
+      "good": 106.0,
+      "ratio": 0.8689,
+      "suggested_scalar": -0.4056,
+      "log_bad": 4.804,
+      "log_good": 4.6634
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5275,
+      "good": 0.5057,
+      "ratio": 0.9587,
+      "suggested_scalar": -0.1218,
+      "log_bad": -0.6396,
+      "log_good": -0.6818
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 18.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.304,
+      "log_bad": 2.9957,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6629,
+      "good": 0.6655,
+      "ratio": 1.0039,
+      "suggested_scalar": 0.0113,
+      "log_bad": -0.4111,
+      "log_good": -0.4072
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.8036,
+      "good": 0.8113,
+      "ratio": 1.0096,
+      "suggested_scalar": 0.0275,
+      "log_bad": -0.2187,
+      "log_good": -0.2091
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 478.0,
+      "good": 439.0,
+      "ratio": 0.9184,
+      "suggested_scalar": -0.2456,
+      "log_bad": 6.1696,
+      "log_good": 6.0845
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0023,
+      "good": 0.0025,
+      "ratio": 1.087,
+      "suggested_scalar": 0.2406,
+      "log_bad": -6.0748,
+      "log_good": -5.9915
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1429,
+      "good": 0.1132,
+      "ratio": 0.7922,
+      "suggested_scalar": -0.6723,
+      "log_bad": -1.9456,
+      "log_good": -2.1786
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9623,
+      "good": 0.9712,
+      "ratio": 1.0092,
+      "suggested_scalar": 0.0266,
+      "log_bad": -0.0384,
+      "log_good": -0.0292
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 194.0,
+      "good": 168.0,
+      "ratio": 0.866,
+      "suggested_scalar": -0.4152,
+      "log_bad": 5.2679,
+      "log_good": 5.124
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 107.5523,
+      "good": 106.7467,
+      "ratio": 0.9925,
+      "suggested_scalar": -0.0217,
+      "log_bad": 4.678,
+      "log_good": 4.6705
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5241,
+      "good": 0.5685,
+      "ratio": 1.0847,
+      "suggested_scalar": 0.2346,
+      "log_bad": -0.6461,
+      "log_good": -0.5648
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.1029,
+      "good": 11.4197,
+      "ratio": 1.1303,
+      "suggested_scalar": 0.3535,
+      "log_bad": 2.3128,
+      "log_good": 2.4353
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1744.0,
+      "good": 1595.0,
+      "ratio": 0.9146,
+      "suggested_scalar": -0.2577,
+      "log_bad": 7.4639,
+      "log_good": 7.3746
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0893,
+      "good": 0.1132,
+      "ratio": 1.2676,
+      "suggested_scalar": 0.6843,
+      "log_bad": -2.4158,
+      "log_good": -2.1786
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7857,
+      "good": 0.7925,
+      "ratio": 1.0087,
+      "suggested_scalar": 0.0249,
+      "log_bad": -0.2412,
+      "log_good": -0.2326
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.5357,
+      "good": 8.283,
+      "ratio": 0.9704,
+      "suggested_scalar": -0.0867,
+      "log_bad": 2.1443,
+      "log_good": 2.1142
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.515,
+      "good": 0.5304,
+      "ratio": 1.0299,
+      "suggested_scalar": 0.085,
+      "log_bad": -0.6636,
+      "log_good": -0.6341
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 151.0,
+      "good": 125.0,
+      "ratio": 0.8278,
+      "suggested_scalar": -0.5452,
+      "log_bad": 5.0173,
+      "log_good": 4.8283
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9389,
+      "good": 0.9342,
+      "ratio": 0.995,
+      "suggested_scalar": -0.0145,
+      "log_bad": -0.063,
+      "log_good": -0.0681
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 32.0,
+      "good": 32.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4657,
+      "log_good": 3.4657
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5636,
+      "good": 0.5724,
+      "ratio": 1.0156,
+      "suggested_scalar": 0.0447,
+      "log_bad": -0.5734,
+      "log_good": -0.5579
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3172,
+      "good": 0.3593,
+      "ratio": 1.1327,
+      "suggested_scalar": 0.3596,
+      "log_bad": -1.1482,
+      "log_good": -1.0236
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2917,
+      "good": 2.3387,
+      "ratio": 1.0205,
+      "suggested_scalar": 0.0586,
+      "log_bad": 0.8293,
+      "log_good": 0.8496
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 476.0,
+      "good": 437.0,
+      "ratio": 0.9181,
+      "suggested_scalar": -0.2467,
+      "log_bad": 6.1654,
+      "log_good": 6.0799
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 22.0,
+      "good": 21.0,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.1342,
+      "log_bad": 3.091,
+      "log_good": 3.0445
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0167,
+      "good": 0.0159,
+      "ratio": 0.9521,
+      "suggested_scalar": -0.1416,
+      "log_bad": -4.0923,
+      "log_good": -4.1414
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0875,
+      "good": 6.0224,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.031,
+      "log_bad": 1.8062,
+      "log_good": 1.7955
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 42.0,
+      "good": 42.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7377,
+      "log_good": 3.7377
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7985,
+      "good": 0.8614,
+      "ratio": 1.0788,
+      "suggested_scalar": 0.2188,
+      "log_bad": -0.225,
+      "log_good": -0.1492
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.1176,
+      "good": 5.9629,
+      "ratio": 0.9747,
+      "suggested_scalar": -0.0739,
+      "log_bad": 1.8112,
+      "log_good": 1.7856
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.802,
+      "good": 0.8127,
+      "ratio": 1.0133,
+      "suggested_scalar": 0.0382,
+      "log_bad": -0.2206,
+      "log_good": -0.2074
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.125,
+      "good": 0.1311,
+      "ratio": 1.0488,
+      "suggested_scalar": 0.1375,
+      "log_bad": -2.0794,
+      "log_good": -2.0318
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1785,
+      "good": 3.3793,
+      "ratio": 1.0632,
+      "suggested_scalar": 0.1768,
+      "log_bad": 1.1564,
+      "log_good": 1.2177
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 382.0,
+      "good": 340.0,
+      "ratio": 0.8901,
+      "suggested_scalar": -0.3361,
+      "log_bad": 5.9454,
+      "log_good": 5.8289
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.6439,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0026,
+      "good": 0.8858,
+      "ratio": 0.8835,
+      "suggested_scalar": -0.3574,
+      "log_bad": 0.0026,
+      "log_good": -0.1213
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 123.0,
+      "good": 108.0,
+      "ratio": 0.878,
+      "suggested_scalar": -0.3753,
+      "log_bad": 4.8122,
+      "log_good": 4.6821
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 942.0,
+      "good": 849.0,
+      "ratio": 0.9013,
+      "suggested_scalar": -0.2999,
+      "log_bad": 6.848,
+      "log_good": 6.7441
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 213.0,
+      "good": 181.0,
+      "ratio": 0.8498,
+      "suggested_scalar": -0.4697,
+      "log_bad": 5.3613,
+      "log_good": 5.1985
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2322,
+      "good": 0.2392,
+      "ratio": 1.0301,
+      "suggested_scalar": 0.0857,
+      "log_bad": -1.4602,
+      "log_good": -1.4305
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 86.0,
+      "good": 87.0,
+      "ratio": 1.0116,
+      "suggested_scalar": 0.0334,
+      "log_bad": 4.4543,
+      "log_good": 4.4659
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 123.0,
+      "good": 108.0,
+      "ratio": 0.878,
+      "suggested_scalar": -0.3753,
+      "log_bad": 4.8122,
+      "log_good": 4.6821
+    },
+    "brevity.mean_sample_size": {
+      "bad": 123.0,
+      "good": 108.0,
+      "ratio": 0.878,
+      "suggested_scalar": -0.3753,
+      "log_bad": 4.8122,
+      "log_good": 4.6821
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 478.0,
+      "good": 439.0,
+      "ratio": 0.9184,
+      "suggested_scalar": -0.2456,
+      "log_bad": 6.1696,
+      "log_good": 6.0845
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 224.0,
+      "good": 211.0,
+      "ratio": 0.942,
+      "suggested_scalar": -0.1725,
+      "log_bad": 5.4116,
+      "log_good": 5.3519
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 313.0,
+      "good": 276.0,
+      "ratio": 0.8818,
+      "suggested_scalar": -0.363,
+      "log_bad": 5.7462,
+      "log_good": 5.6204
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.352,
+      "good": 2.1888,
+      "ratio": 0.9306,
+      "suggested_scalar": -0.2075,
+      "log_bad": 0.8553,
+      "log_good": 0.7834
+    },
+    "halstead.mean_effort": {
+      "bad": 113900.6615,
+      "good": 104002.7401,
+      "ratio": 0.9131,
+      "suggested_scalar": -0.2623,
+      "log_bad": 11.6431,
+      "log_good": 11.5522
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8812,
+      "good": 0.8828,
+      "ratio": 1.0018,
+      "suggested_scalar": 0.0052,
+      "log_bad": -0.1265,
+      "log_good": -0.1247
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 90.0,
+      "good": 74.0,
+      "ratio": 0.8222,
+      "suggested_scalar": -0.5648,
+      "log_bad": 4.4998,
+      "log_good": 4.3041
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 221.0,
+      "good": 214.0,
+      "ratio": 0.9683,
+      "suggested_scalar": -0.0929,
+      "log_bad": 5.3982,
+      "log_good": 5.366
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4175,
+      "good": 0.4048,
+      "ratio": 0.9696,
+      "suggested_scalar": -0.0891,
+      "log_bad": -0.8735,
+      "log_good": -0.9044
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.8557,
+      "good": 5.0536,
+      "ratio": 1.0408,
+      "suggested_scalar": 0.1153,
+      "log_bad": 1.5802,
+      "log_good": 1.6201
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.125,
+      "good": 0.1311,
+      "ratio": 1.0488,
+      "suggested_scalar": 0.1375,
+      "log_bad": -2.0794,
+      "log_good": -2.0318
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.0467,
+      "good": 4.0181,
+      "ratio": 0.9929,
+      "suggested_scalar": -0.0205,
+      "log_bad": 1.3979,
+      "log_good": 1.3908
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 477.0,
+      "good": 438.0,
+      "ratio": 0.9182,
+      "suggested_scalar": -0.2461,
+      "log_bad": 6.1675,
+      "log_good": 6.0822
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 57.0,
+      "good": 60.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.148,
+      "log_bad": 4.0431,
+      "log_good": 4.0943
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6327.8145,
+      "good": 5777.93,
+      "ratio": 0.9131,
+      "suggested_scalar": -0.2623,
+      "log_bad": 8.7527,
+      "log_good": 8.6618
+    },
+    "readability.mean_total_lines": {
+      "bad": 56.0,
+      "good": 53.0,
+      "ratio": 0.9464,
+      "suggested_scalar": -0.1589,
+      "log_bad": 4.0254,
+      "log_good": 3.9703
+    },
+    "indentation.mean_max_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "halstead.mean_volume": {
+      "bad": 3007.94,
+      "good": 2657.5286,
+      "ratio": 0.8835,
+      "suggested_scalar": -0.3574,
+      "log_bad": 8.009,
+      "log_good": 7.8852
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 761.0,
+      "good": 682.0,
+      "ratio": 0.8962,
+      "suggested_scalar": -0.3162,
+      "log_bad": 6.6346,
+      "log_good": 6.525
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 29.9286,
+      "good": 28.9057,
+      "ratio": 0.9658,
+      "suggested_scalar": -0.1003,
+      "log_bad": 3.3988,
+      "log_good": 3.364
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0711,
+      "good": 1.0837,
+      "ratio": 1.0118,
+      "suggested_scalar": 0.0337,
+      "log_bad": 0.0687,
+      "log_good": 0.0804
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 28.0,
+      "good": 25.0,
+      "ratio": 0.8929,
+      "suggested_scalar": -0.327,
+      "log_bad": 3.3322,
+      "log_good": 3.2189
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 8.0,
+      "good": 6.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.8301,
+      "log_bad": 2.0794,
+      "log_good": 1.7918
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8508,
+      "good": 0.8235,
+      "ratio": 0.9679,
+      "suggested_scalar": -0.0941,
+      "log_bad": -0.1616,
+      "log_good": -0.1942
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9556,
+      "good": 0.9579,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.0069,
+      "log_bad": -0.0454,
+      "log_good": -0.043
+    },
+    "halstead.mean_length": {
+      "bad": 434.0,
+      "good": 395.0,
+      "ratio": 0.9101,
+      "suggested_scalar": -0.2717,
+      "log_bad": 6.073,
+      "log_good": 5.9789
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 13.0,
+      "good": 12.6667,
+      "ratio": 0.9744,
+      "suggested_scalar": -0.0749,
+      "log_bad": 2.5649,
+      "log_good": 2.539
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9425,
+      "good": 6.7549,
+      "ratio": 0.973,
+      "suggested_scalar": -0.079,
+      "log_bad": 1.9377,
+      "log_good": 1.9103
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1287,
+      "good": 0.1325,
+      "ratio": 1.0295,
+      "suggested_scalar": 0.084,
+      "log_bad": -2.0503,
+      "log_good": -2.0212
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 37.8667,
+      "good": 39.1351,
+      "ratio": 1.0335,
+      "suggested_scalar": 0.0951,
+      "log_bad": 3.6341,
+      "log_good": 3.667
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.5261,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 81.0,
+      "good": 68.0,
+      "ratio": 0.8395,
+      "suggested_scalar": -0.5048,
+      "log_bad": 4.3944,
+      "log_good": 4.2195
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7252,
+      "good": 0.6848,
+      "ratio": 0.9443,
+      "suggested_scalar": -0.1654,
+      "log_bad": -0.3213,
+      "log_good": -0.3786
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 56.0,
+      "good": 53.0,
+      "ratio": 0.9464,
+      "suggested_scalar": -0.1589,
+      "log_bad": 4.0254,
+      "log_good": 3.9703
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_var_keyword_for_properties": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.does_not_use_lossy_numeric_cast": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1977,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 0.022,
+      "ratio": 0.022,
+      "suggested_scalar": -1.0884,
+      "log_bad": 0.0,
+      "log_good": -3.8167
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.1667,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.044,
+      "log_bad": 0.0,
+      "log_good": 0.1542
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8571,
+      "good": 0.8226,
+      "ratio": 0.9597,
+      "suggested_scalar": -0.0117,
+      "log_bad": -0.1542,
+      "log_good": -0.1953
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 0.0239,
+      "ratio": 0.0239,
+      "suggested_scalar": -1.0648,
+      "log_bad": 0.0,
+      "log_good": -3.7339
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7955,
+      "good": 4.7164,
+      "ratio": 0.9835,
+      "suggested_scalar": -0.0047,
+      "log_bad": 1.5677,
+      "log_good": 1.551
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 129.0,
+      "good": 116.0,
+      "ratio": 0.8992,
+      "suggested_scalar": -0.0303,
+      "log_bad": 4.8598,
+      "log_good": 4.7536
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5974,
+      "good": 0.4352,
+      "ratio": 0.7285,
+      "suggested_scalar": -0.0903,
+      "log_bad": -0.5152,
+      "log_good": -0.8319
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 21.0,
+      "ratio": 1.1053,
+      "suggested_scalar": 0.0285,
+      "log_bad": 2.9444,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.777,
+      "good": 0.5986,
+      "ratio": 0.7704,
+      "suggested_scalar": -0.0744,
+      "log_bad": -0.2523,
+      "log_good": -0.5132
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.9429,
+      "good": 5.2903,
+      "ratio": 2.7229,
+      "suggested_scalar": 0.2857,
+      "log_bad": 0.6642,
+      "log_good": 1.6659
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 344.0,
+      "good": 545.0,
+      "ratio": 1.5843,
+      "suggested_scalar": 0.1312,
+      "log_bad": 5.8406,
+      "log_good": 6.3008
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 6.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.3133,
+      "log_bad": 0.6931,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 0.0009,
+      "ratio": 0.0009,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -7.0131
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.3714,
+      "good": 0.0806,
+      "ratio": 0.217,
+      "suggested_scalar": -0.4357,
+      "log_bad": -0.9905,
+      "log_good": -2.5183
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.7906,
+      "good": 1.0712,
+      "ratio": 1.3549,
+      "suggested_scalar": 0.0866,
+      "log_bad": -0.235,
+      "log_good": 0.0688
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 168.0,
+      "good": 179.0,
+      "ratio": 1.0655,
+      "suggested_scalar": 0.0181,
+      "log_bad": 5.124,
+      "log_good": 5.1874
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 108.1917,
+      "good": 99.1831,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0248,
+      "log_bad": 4.6839,
+      "log_good": 4.597
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.3324,
+      "good": 0.5827,
+      "ratio": 1.753,
+      "suggested_scalar": 0.1601,
+      "log_bad": -1.1014,
+      "log_good": -0.5401
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.6845,
+      "good": 19.1593,
+      "ratio": 2.4932,
+      "suggested_scalar": 0.2605,
+      "log_bad": 2.0392,
+      "log_good": 2.9528
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1405.0,
+      "good": 2187.0,
+      "ratio": 1.5566,
+      "suggested_scalar": 0.1262,
+      "log_bad": 7.2478,
+      "log_good": 7.6903
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0857,
+      "good": 0.1129,
+      "ratio": 1.3174,
+      "suggested_scalar": 0.0786,
+      "log_bad": -2.4569,
+      "log_good": -2.1813
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8286,
+      "good": 0.7581,
+      "ratio": 0.9149,
+      "suggested_scalar": -0.0254,
+      "log_bad": -0.188,
+      "log_good": -0.2769
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.8286,
+      "good": 8.9344,
+      "ratio": 0.909,
+      "suggested_scalar": -0.0272,
+      "log_bad": 2.2853,
+      "log_good": 2.1899
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 24.0,
+      "good": 32.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.082,
+      "log_bad": 3.1781,
+      "log_good": 3.4657
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 6.7396,
+      "good": 22.5931,
+      "ratio": 3.3523,
+      "suggested_scalar": 0.345,
+      "log_bad": 1.908,
+      "log_good": 3.1176
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 128.0,
+      "good": 102.0,
+      "ratio": 0.7969,
+      "suggested_scalar": -0.0648,
+      "log_bad": 4.852,
+      "log_good": 4.625
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9299,
+      "good": 0.9505,
+      "ratio": 1.0222,
+      "suggested_scalar": 0.0062,
+      "log_bad": -0.0727,
+      "log_good": -0.0508
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 31.0,
+      "good": 31.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.434,
+      "log_good": 3.434
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5039,
+      "good": 0.6232,
+      "ratio": 1.2368,
+      "suggested_scalar": 0.0606,
+      "log_bad": -0.6854,
+      "log_good": -0.4729
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.1901,
+      "good": 0.4107,
+      "ratio": 2.1604,
+      "suggested_scalar": 0.2197,
+      "log_bad": -1.6602,
+      "log_good": -0.8899
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.0158,
+      "good": 2.6541,
+      "ratio": 1.3166,
+      "suggested_scalar": 0.0785,
+      "log_bad": 0.701,
+      "log_good": 0.9761
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 342.0,
+      "good": 543.0,
+      "ratio": 1.5877,
+      "suggested_scalar": 0.1318,
+      "log_bad": 5.8348,
+      "log_good": 6.2971
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0476,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0407,
+      "good": 0.0789,
+      "ratio": 1.9386,
+      "suggested_scalar": 0.1888,
+      "log_bad": -3.2015,
+      "log_good": -2.5396
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0,
+      "good": 6.0875,
+      "ratio": 1.0146,
+      "suggested_scalar": 0.0041,
+      "log_bad": 1.7918,
+      "log_good": 1.8062
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 16.0,
+      "good": 45.0,
+      "ratio": 2.8125,
+      "suggested_scalar": 0.2949,
+      "log_bad": 2.7726,
+      "log_good": 3.8067
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.023,
+      "good": 1.4072,
+      "ratio": 1.3756,
+      "suggested_scalar": 0.0909,
+      "log_bad": 0.0227,
+      "log_good": 0.3416
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.3182,
+      "good": 5.769,
+      "ratio": 0.9131,
+      "suggested_scalar": -0.0259,
+      "log_bad": 1.8434,
+      "log_good": 1.7525
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7993,
+      "good": 0.7748,
+      "ratio": 0.9693,
+      "suggested_scalar": -0.0089,
+      "log_bad": -0.224,
+      "log_good": -0.2552
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.125,
+      "good": 0.1014,
+      "ratio": 0.8112,
+      "suggested_scalar": -0.0597,
+      "log_bad": -2.0794,
+      "log_good": -2.2887
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.7721,
+      "good": 4.3771,
+      "ratio": 1.579,
+      "suggested_scalar": 0.1303,
+      "log_bad": 1.0196,
+      "log_good": 1.4764
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 7.0,
+      "good": 1.0,
+      "ratio": 0.1429,
+      "suggested_scalar": -0.5549,
+      "log_bad": 1.9459,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 297.0,
+      "good": 393.0,
+      "ratio": 1.3232,
+      "suggested_scalar": 0.0799,
+      "log_bad": 5.6937,
+      "log_good": 5.9738
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 7.0,
+      "ratio": 7.0,
+      "suggested_scalar": 0.5549,
+      "log_bad": 0.0,
+      "log_good": 1.9459
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7736,
+      "good": 1.1339,
+      "ratio": 1.4657,
+      "suggested_scalar": 0.109,
+      "log_bad": -0.2567,
+      "log_good": 0.1257
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 131.0,
+      "good": 116.0,
+      "ratio": 0.8855,
+      "suggested_scalar": -0.0347,
+      "log_bad": 4.8752,
+      "log_good": 4.7536
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 799.0,
+      "good": 1049.0,
+      "ratio": 1.3129,
+      "suggested_scalar": 0.0776,
+      "log_bad": 6.6834,
+      "log_good": 6.9556
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 186.0,
+      "good": 189.0,
+      "ratio": 1.0161,
+      "suggested_scalar": 0.0046,
+      "log_bad": 5.2257,
+      "log_good": 5.2417
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0174,
+      "good": 0.0147,
+      "ratio": 0.8448,
+      "suggested_scalar": -0.0481,
+      "log_bad": -4.0513,
+      "log_good": -4.2199
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1076,
+      "good": 0.2477,
+      "ratio": 2.302,
+      "suggested_scalar": 0.2378,
+      "log_bad": -2.2293,
+      "log_good": -1.3955
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 32.0,
+      "good": 89.0,
+      "ratio": 2.7813,
+      "suggested_scalar": 0.2917,
+      "log_bad": 3.4657,
+      "log_good": 4.4886
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 131.0,
+      "good": 116.0,
+      "ratio": 0.8855,
+      "suggested_scalar": -0.0347,
+      "log_bad": 4.8752,
+      "log_good": 4.7536
+    },
+    "brevity.mean_sample_size": {
+      "bad": 131.0,
+      "good": 116.0,
+      "ratio": 0.8855,
+      "suggested_scalar": -0.0347,
+      "log_bad": 4.8752,
+      "log_good": 4.7536
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 344.0,
+      "good": 545.0,
+      "ratio": 1.5843,
+      "suggested_scalar": 0.1312,
+      "log_bad": 5.8406,
+      "log_good": 6.3008
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 122.0,
+      "good": 298.0,
+      "ratio": 2.4426,
+      "suggested_scalar": 0.2547,
+      "log_bad": 4.804,
+      "log_good": 5.6971
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 261.0,
+      "good": 316.0,
+      "ratio": 1.2107,
+      "suggested_scalar": 0.0545,
+      "log_bad": 5.5645,
+      "log_good": 5.7557
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0203,
+      "good": 1.0,
+      "ratio": 49.2611,
+      "suggested_scalar": 1.1114,
+      "log_bad": -3.8971,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.4704,
+      "good": 2.7266,
+      "ratio": 1.8543,
+      "suggested_scalar": 0.1761,
+      "log_bad": 0.3855,
+      "log_good": 1.0031
+    },
+    "halstead.mean_effort": {
+      "bad": 68271.6823,
+      "good": 117233.7158,
+      "ratio": 1.7172,
+      "suggested_scalar": 0.1542,
+      "log_bad": 11.1313,
+      "log_good": 11.6719
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8983,
+      "good": 0.8412,
+      "ratio": 0.9364,
+      "suggested_scalar": -0.0187,
+      "log_bad": -0.1073,
+      "log_good": -0.1729
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 98.0,
+      "good": 85.0,
+      "ratio": 0.8673,
+      "suggested_scalar": -0.0406,
+      "log_bad": 4.585,
+      "log_good": 4.4427
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 145.0,
+      "good": 307.0,
+      "ratio": 2.1172,
+      "suggested_scalar": 0.2139,
+      "log_bad": 4.9767,
+      "log_good": 5.7268
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5119,
+      "good": 0.3966,
+      "ratio": 0.7748,
+      "suggested_scalar": -0.0728,
+      "log_bad": -0.6696,
+      "log_good": -0.9248
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.756,
+      "good": 5.8603,
+      "ratio": 1.2322,
+      "suggested_scalar": 0.0595,
+      "log_bad": 1.5594,
+      "log_good": 1.7682
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.125,
+      "good": 0.1014,
+      "ratio": 0.8112,
+      "suggested_scalar": -0.0597,
+      "log_bad": -2.0794,
+      "log_good": -2.2887
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.5084,
+      "good": 4.8961,
+      "ratio": 1.086,
+      "suggested_scalar": 0.0235,
+      "log_bad": 1.5059,
+      "log_good": 1.5884
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 343.0,
+      "good": 544.0,
+      "ratio": 1.586,
+      "suggested_scalar": 0.1315,
+      "log_bad": 5.8377,
+      "log_good": 6.2989
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 0.3953,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 20.0,
+      "good": 73.0,
+      "ratio": 3.65,
+      "suggested_scalar": 0.3692,
+      "log_bad": 2.9957,
+      "log_good": 4.2905
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3792.8712,
+      "good": 6512.9842,
+      "ratio": 1.7172,
+      "suggested_scalar": 0.1542,
+      "log_bad": 8.2409,
+      "log_good": 8.7816
+    },
+    "readability.mean_total_lines": {
+      "bad": 35.0,
+      "good": 61.0,
+      "ratio": 1.7429,
+      "suggested_scalar": 0.1584,
+      "log_bad": 3.5553,
+      "log_good": 4.1109
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 16.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1977,
+      "log_bad": 2.0794,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2320.7162,
+      "good": 3401.5586,
+      "ratio": 1.4657,
+      "suggested_scalar": 0.109,
+      "log_bad": 7.7496,
+      "log_good": 8.132
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 697.0,
+      "good": 824.0,
+      "ratio": 1.1822,
+      "suggested_scalar": 0.0477,
+      "log_bad": 6.5468,
+      "log_good": 6.7142
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 38.7714,
+      "good": 34.459,
+      "ratio": 0.8888,
+      "suggested_scalar": -0.0336,
+      "log_bad": 3.6577,
+      "log_good": 3.5398
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0481,
+      "good": 1.1653,
+      "ratio": 1.1118,
+      "suggested_scalar": 0.0302,
+      "log_bad": 0.047,
+      "log_good": 0.153
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 6.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.3133,
+      "log_bad": 0.6931,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 10.0,
+      "good": 11.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0272,
+      "log_bad": 2.3026,
+      "log_good": 2.3979
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 13.0,
+      "good": 5.0,
+      "ratio": 0.3846,
+      "suggested_scalar": -0.2725,
+      "log_bad": 2.5649,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9327,
+      "good": 0.8142,
+      "ratio": 0.8729,
+      "suggested_scalar": -0.0387,
+      "log_bad": -0.0697,
+      "log_good": -0.2055
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9872,
+      "good": 0.9801,
+      "ratio": 0.9928,
+      "suggested_scalar": -0.0021,
+      "log_bad": -0.0129,
+      "log_good": -0.0201
+    },
+    "halstead.mean_length": {
+      "bad": 331.0,
+      "good": 496.0,
+      "ratio": 1.4985,
+      "suggested_scalar": 0.1153,
+      "log_bad": 5.8021,
+      "log_good": 6.2066
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.3333,
+      "good": 10.0,
+      "ratio": 1.579,
+      "suggested_scalar": 0.1303,
+      "log_bad": 1.8458,
+      "log_good": 2.3026
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.0334,
+      "good": 6.858,
+      "ratio": 0.9751,
+      "suggested_scalar": -0.0072,
+      "log_bad": 1.9507,
+      "log_good": 1.9254
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0873,
+      "good": 0.1363,
+      "ratio": 1.5613,
+      "suggested_scalar": 0.127,
+      "log_bad": -2.4384,
+      "log_good": -1.9929
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.4184,
+      "good": 34.4647,
+      "ratio": 1.1715,
+      "suggested_scalar": 0.0451,
+      "log_bad": 3.3816,
+      "log_good": 3.5399
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 7.0,
+      "ratio": 2.3333,
+      "suggested_scalar": 0.2416,
+      "log_bad": 1.0986,
+      "log_good": 1.9459
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 86.0,
+      "good": 71.0,
+      "ratio": 0.8256,
+      "suggested_scalar": -0.0547,
+      "log_bad": 4.4543,
+      "log_good": 4.2627
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8774,
+      "good": 0.7184,
+      "ratio": 0.8188,
+      "suggested_scalar": -0.057,
+      "log_bad": -0.1308,
+      "log_good": -0.3307
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 35.0,
+      "good": 62.0,
+      "ratio": 1.7714,
+      "suggested_scalar": 0.1631,
+      "log_bad": 3.5553,
+      "log_good": 4.1271
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "dependencies.uses_import_type_for_type_only_imports": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 32.0,
+      "good": 33.0,
+      "ratio": 1.0313,
+      "suggested_scalar": 0.0167,
+      "log_bad": 3.4657,
+      "log_good": 3.4965
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 17.0,
+      "good": 18.0,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.031,
+      "log_bad": 2.8332,
+      "log_good": 2.8904
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0256,
+      "good": 0.0264,
+      "ratio": 1.0313,
+      "suggested_scalar": 0.0167,
+      "log_bad": -3.6652,
+      "log_good": -3.6344
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7,
+      "good": 0.7,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3567,
+      "log_good": -0.3567
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0256,
+      "good": 0.0264,
+      "ratio": 1.0313,
+      "suggested_scalar": 0.0167,
+      "log_bad": -3.6652,
+      "log_good": -3.6344
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.9865,
+      "good": 4.9645,
+      "ratio": 0.9956,
+      "suggested_scalar": -0.0024,
+      "log_bad": 1.6067,
+      "log_good": 1.6023
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 82.0,
+      "good": 68.0,
+      "ratio": 0.8293,
+      "suggested_scalar": -0.1015,
+      "log_bad": 4.4067,
+      "log_good": 4.2195
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4053,
+      "good": 0.384,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.0293,
+      "log_bad": -0.9031,
+      "log_good": -0.9571
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.0,
+      "good": 18.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0836,
+      "log_bad": 3.0445,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5466,
+      "good": 0.5561,
+      "ratio": 1.0174,
+      "suggested_scalar": 0.0093,
+      "log_bad": -0.604,
+      "log_good": -0.5868
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.4,
+      "good": 1.4,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.3365,
+      "log_good": 0.3365
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 429.0,
+      "good": 417.0,
+      "ratio": 0.972,
+      "suggested_scalar": -0.0154,
+      "log_bad": 6.0615,
+      "log_good": 6.0331
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.025,
+      "good": 1.0,
+      "ratio": 40.0,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.6889,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0006,
+      "good": 0.0006,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.4186,
+      "log_good": -7.4186
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0198,
+      "good": 0.9908,
+      "ratio": 0.9716,
+      "suggested_scalar": -0.0156,
+      "log_bad": 0.0196,
+      "log_good": -0.0092
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 131.0,
+      "good": 124.0,
+      "ratio": 0.9466,
+      "suggested_scalar": -0.0298,
+      "log_bad": 4.8752,
+      "log_good": 4.8203
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 82.5082,
+      "good": 78.6146,
+      "ratio": 0.9528,
+      "suggested_scalar": -0.0262,
+      "log_bad": 4.4129,
+      "log_good": 4.3646
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6916,
+      "good": 0.7692,
+      "ratio": 1.1122,
+      "suggested_scalar": 0.0577,
+      "log_bad": -0.3687,
+      "log_good": -0.2624
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 16.7666,
+      "good": 20.4352,
+      "ratio": 1.2188,
+      "suggested_scalar": 0.1073,
+      "log_bad": 2.8194,
+      "log_good": 3.0173
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1708.0,
+      "good": 1694.0,
+      "ratio": 0.9918,
+      "suggested_scalar": -0.0045,
+      "log_bad": 7.4431,
+      "log_good": 7.4348
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.025,
+      "good": 1.0,
+      "ratio": 40.0,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.6889,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7,
+      "good": 0.7,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3567,
+      "log_good": -0.3567
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.725,
+      "good": 10.425,
+      "ratio": 0.972,
+      "suggested_scalar": -0.0154,
+      "log_bad": 2.3726,
+      "log_good": 2.3442
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.04,
+      "good": 2.04,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.7129,
+      "log_good": 0.7129
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 66.0,
+      "good": 57.0,
+      "ratio": 0.8636,
+      "suggested_scalar": -0.0795,
+      "log_bad": 4.1897,
+      "log_good": 4.0431
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9107,
+      "good": 0.8877,
+      "ratio": 0.9747,
+      "suggested_scalar": -0.0139,
+      "log_bad": -0.0935,
+      "log_good": -0.1191
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 21.0,
+      "ratio": 0.84,
+      "suggested_scalar": -0.0945,
+      "log_bad": 3.2189,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6552,
+      "good": 0.6818,
+      "ratio": 1.0406,
+      "suggested_scalar": 0.0216,
+      "log_bad": -0.4228,
+      "log_good": -0.383
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5831,
+      "good": 0.6578,
+      "ratio": 1.1281,
+      "suggested_scalar": 0.0654,
+      "log_bad": -0.5394,
+      "log_good": -0.4189
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.8998,
+      "good": 3.1429,
+      "ratio": 1.0838,
+      "suggested_scalar": 0.0436,
+      "log_bad": 1.0646,
+      "log_good": 1.1451
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 427.0,
+      "good": 415.0,
+      "ratio": 0.9719,
+      "suggested_scalar": -0.0155,
+      "log_bad": 6.0568,
+      "log_good": 6.0283
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.028,
+      "good": 0.0288,
+      "ratio": 1.0286,
+      "suggested_scalar": 0.0153,
+      "log_bad": -3.5756,
+      "log_good": -3.5474
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0661,
+      "good": 5.9542,
+      "ratio": 0.9816,
+      "suggested_scalar": -0.0101,
+      "log_bad": 1.8027,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 33.0,
+      "good": 34.0,
+      "ratio": 1.0303,
+      "suggested_scalar": 0.0162,
+      "log_bad": 3.4965,
+      "log_good": 3.5264
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4961,
+      "good": 1.5355,
+      "ratio": 1.0263,
+      "suggested_scalar": 0.0141,
+      "log_bad": 0.4029,
+      "log_good": 0.4289
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6917,
+      "good": 5.5311,
+      "ratio": 0.9718,
+      "suggested_scalar": -0.0155,
+      "log_bad": 1.739,
+      "log_good": 1.7104
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.822,
+      "good": 0.8338,
+      "ratio": 1.0144,
+      "suggested_scalar": 0.0077,
+      "log_bad": -0.196,
+      "log_good": -0.1818
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1489,
+      "good": 0.1489,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.9045,
+      "log_good": -1.9045
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.0947,
+      "good": 4.5205,
+      "ratio": 1.104,
+      "suggested_scalar": 0.0536,
+      "log_bad": 1.4097,
+      "log_good": 1.5086
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 265.0,
+      "good": 243.0,
+      "ratio": 0.917,
+      "suggested_scalar": -0.047,
+      "log_bad": 5.5797,
+      "log_good": 5.4931
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 31.0,
+      "good": 30.0,
+      "ratio": 0.9677,
+      "suggested_scalar": -0.0178,
+      "log_bad": 3.434,
+      "log_good": 3.4012
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8074,
+      "good": 0.7548,
+      "ratio": 0.9349,
+      "suggested_scalar": -0.0365,
+      "log_bad": -0.2139,
+      "log_good": -0.2813
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 89.0,
+      "good": 74.0,
+      "ratio": 0.8315,
+      "suggested_scalar": -0.1001,
+      "log_bad": 4.4886,
+      "log_good": 4.3041
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 976.0,
+      "good": 967.0,
+      "ratio": 0.9908,
+      "suggested_scalar": -0.005,
+      "log_bad": 6.8835,
+      "log_good": 6.8742
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 139.0,
+      "good": 133.0,
+      "ratio": 0.9568,
+      "suggested_scalar": -0.0239,
+      "log_bad": 4.9345,
+      "log_good": 4.8903
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2611,
+      "good": 0.2638,
+      "ratio": 1.0103,
+      "suggested_scalar": 0.0056,
+      "log_bad": -1.3429,
+      "log_good": -1.3326
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 93.0,
+      "good": 106.0,
+      "ratio": 1.1398,
+      "suggested_scalar": 0.0709,
+      "log_bad": 4.5326,
+      "log_good": 4.6634
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 89.0,
+      "good": 74.0,
+      "ratio": 0.8315,
+      "suggested_scalar": -0.1001,
+      "log_bad": 4.4886,
+      "log_good": 4.3041
+    },
+    "brevity.mean_sample_size": {
+      "bad": 89.0,
+      "good": 74.0,
+      "ratio": 0.8315,
+      "suggested_scalar": -0.1001,
+      "log_bad": 4.4886,
+      "log_good": 4.3041
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 429.0,
+      "good": 417.0,
+      "ratio": 0.972,
+      "suggested_scalar": -0.0154,
+      "log_bad": 6.0615,
+      "log_good": 6.0331
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 251.0,
+      "good": 246.0,
+      "ratio": 0.9801,
+      "suggested_scalar": -0.0109,
+      "log_bad": 5.5255,
+      "log_good": 5.5053
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 225.0,
+      "good": 202.0,
+      "ratio": 0.8978,
+      "suggested_scalar": -0.0585,
+      "log_bad": 5.4161,
+      "log_good": 5.3083
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0023,
+      "good": 0.0024,
+      "ratio": 1.0435,
+      "suggested_scalar": 0.0231,
+      "log_bad": -6.0748,
+      "log_good": -6.0323
+    },
+    "heaps.mean_k": {
+      "bad": 3.3942,
+      "good": 2.8217,
+      "ratio": 0.8313,
+      "suggested_scalar": -0.1002,
+      "log_bad": 1.2221,
+      "log_good": 1.0373
+    },
+    "halstead.mean_effort": {
+      "bad": 73835.4379,
+      "good": 67285.6334,
+      "ratio": 0.9113,
+      "suggested_scalar": -0.0504,
+      "log_bad": 11.2096,
+      "log_good": 11.1167
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8789,
+      "good": 0.8907,
+      "ratio": 1.0134,
+      "suggested_scalar": 0.0072,
+      "log_bad": -0.1291,
+      "log_good": -0.1157
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 57.0,
+      "good": 47.0,
+      "ratio": 0.8246,
+      "suggested_scalar": -0.1046,
+      "log_bad": 4.0431,
+      "log_good": 3.8501
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 242.0,
+      "good": 239.0,
+      "ratio": 0.9876,
+      "suggested_scalar": -0.0068,
+      "log_bad": 5.4889,
+      "log_good": 5.4765
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4046,
+      "good": 0.3548,
+      "ratio": 0.8769,
+      "suggested_scalar": -0.0712,
+      "log_bad": -0.9049,
+      "log_good": -1.0362
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.4504,
+      "good": 7.7984,
+      "ratio": 1.0467,
+      "suggested_scalar": 0.0248,
+      "log_bad": 2.0083,
+      "log_good": 2.0539
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1489,
+      "good": 0.1489,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.9045,
+      "log_good": -1.9045
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 7.2445,
+      "good": 7.7203,
+      "ratio": 1.0657,
+      "suggested_scalar": 0.0345,
+      "log_bad": 1.9802,
+      "log_good": 2.0439
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 428.0,
+      "good": 416.0,
+      "ratio": 0.972,
+      "suggested_scalar": -0.0154,
+      "log_bad": 6.0591,
+      "log_good": 6.0307
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 87.0,
+      "good": 101.0,
+      "ratio": 1.1609,
+      "suggested_scalar": 0.0809,
+      "log_bad": 4.4659,
+      "log_good": 4.6151
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4101.9688,
+      "good": 3738.0907,
+      "ratio": 0.9113,
+      "suggested_scalar": -0.0504,
+      "log_bad": 8.3192,
+      "log_good": 8.2263
+    },
+    "readability.mean_total_lines": {
+      "bad": 40.0,
+      "good": 40.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6889,
+      "log_good": 3.6889
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2422.2273,
+      "good": 2264.5362,
+      "ratio": 0.9349,
+      "suggested_scalar": -0.0365,
+      "log_bad": 7.7924,
+      "log_good": 7.7251
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 589.0,
+      "good": 539.0,
+      "ratio": 0.9151,
+      "suggested_scalar": -0.0481,
+      "log_bad": 6.3784,
+      "log_good": 6.2897
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 41.475,
+      "good": 41.175,
+      "ratio": 0.9928,
+      "suggested_scalar": -0.0039,
+      "log_bad": 3.7251,
+      "log_good": 3.7178
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3409,
+      "good": 1.3905,
+      "ratio": 1.037,
+      "suggested_scalar": 0.0197,
+      "log_bad": 0.2933,
+      "log_good": 0.3297
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 14.0,
+      "good": 13.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.0402,
+      "log_bad": 2.6391,
+      "log_good": 2.5649
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6717,
+      "good": 0.5844,
+      "ratio": 0.87,
+      "suggested_scalar": -0.0755,
+      "log_bad": -0.3979,
+      "log_good": -0.5372
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9626,
+      "good": 0.9651,
+      "ratio": 1.0026,
+      "suggested_scalar": 0.0014,
+      "log_bad": -0.0381,
+      "log_good": -0.0355
+    },
+    "halstead.mean_length": {
+      "bad": 381.0,
+      "good": 372.0,
+      "ratio": 0.9764,
+      "suggested_scalar": -0.013,
+      "log_bad": 5.9428,
+      "log_good": 5.9189
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.8333,
+      "good": 7.0,
+      "ratio": 1.0244,
+      "suggested_scalar": 0.0131,
+      "log_bad": 1.9218,
+      "log_good": 1.9459
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4757,
+      "good": 6.2095,
+      "ratio": 0.9589,
+      "suggested_scalar": -0.0228,
+      "log_bad": 1.8681,
+      "log_good": 1.8261
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1471,
+      "good": 0.1452,
+      "ratio": 0.9871,
+      "suggested_scalar": -0.007,
+      "log_bad": -1.9166,
+      "log_good": -1.9296
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.4825,
+      "good": 29.7128,
+      "ratio": 0.9747,
+      "suggested_scalar": -0.0139,
+      "log_bad": 3.4172,
+      "log_good": 3.3916
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 53.0,
+      "good": 44.0,
+      "ratio": 0.8302,
+      "suggested_scalar": -0.1009,
+      "log_bad": 3.9703,
+      "log_good": 3.7842
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5867,
+      "good": 0.4752,
+      "ratio": 0.81,
+      "suggested_scalar": -0.1143,
+      "log_bad": -0.5332,
+      "log_good": -0.744
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 40.0,
+      "good": 40.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6889,
+      "log_good": 3.6889
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.uses_throws_for_recoverable_errors": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 31.0,
+      "good": 44.0,
+      "ratio": 1.4194,
+      "suggested_scalar": 0.1014,
+      "log_bad": 3.434,
+      "log_good": 3.7842
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0833,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0056,
+      "good": 1.0,
+      "ratio": 178.5714,
+      "suggested_scalar": 1.5012,
+      "log_bad": -5.185,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7778,
+      "good": 0.8103,
+      "ratio": 1.0418,
+      "suggested_scalar": 0.0119,
+      "log_bad": -0.2513,
+      "log_good": -0.2104
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0056,
+      "good": 1.0,
+      "ratio": 178.5714,
+      "suggested_scalar": 1.5012,
+      "log_bad": -5.185,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4663,
+      "good": 4.5421,
+      "ratio": 1.017,
+      "suggested_scalar": 0.0049,
+      "log_bad": 1.4966,
+      "log_good": 1.5134
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 94.0,
+      "good": 84.0,
+      "ratio": 0.8936,
+      "suggested_scalar": -0.0326,
+      "log_bad": 4.5433,
+      "log_good": 4.4308
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4844,
+      "good": 0.3877,
+      "ratio": 0.8004,
+      "suggested_scalar": -0.0645,
+      "log_bad": -0.7248,
+      "log_good": -0.9475
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 15.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0528,
+      "log_bad": 2.8904,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6748,
+      "good": 0.6079,
+      "ratio": 0.9009,
+      "suggested_scalar": -0.0302,
+      "log_bad": -0.3933,
+      "log_good": -0.4977
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.0741,
+      "good": 6.0,
+      "ratio": 0.9878,
+      "suggested_scalar": -0.0036,
+      "log_bad": 1.804,
+      "log_good": 1.7918
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 360.0,
+      "good": 352.0,
+      "ratio": 0.9778,
+      "suggested_scalar": -0.0065,
+      "log_bad": 5.8861,
+      "log_good": 5.8636
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.001,
+      "good": 0.0009,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0305,
+      "log_bad": -6.9078,
+      "log_good": -7.0131
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0741,
+      "good": 1.0,
+      "ratio": 13.4953,
+      "suggested_scalar": 0.7535,
+      "log_bad": -2.6023,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.001,
+      "good": 1.0,
+      "ratio": 1.0e3,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.9078,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9432,
+      "good": 0.9515,
+      "ratio": 1.0088,
+      "suggested_scalar": 0.0025,
+      "log_bad": -0.0585,
+      "log_good": -0.0497
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 126.0,
+      "good": 121.0,
+      "ratio": 0.9603,
+      "suggested_scalar": -0.0117,
+      "log_bad": 4.8363,
+      "log_good": 4.7958
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 100.4086,
+      "good": 90.225,
+      "ratio": 0.8986,
+      "suggested_scalar": -0.031,
+      "log_bad": 4.6092,
+      "log_good": 4.5023
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5543,
+      "good": 0.5954,
+      "ratio": 1.0741,
+      "suggested_scalar": 0.0207,
+      "log_bad": -0.59,
+      "log_good": -0.5185
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.5145,
+      "good": 19.7059,
+      "ratio": 1.4581,
+      "suggested_scalar": 0.1092,
+      "log_bad": 2.6038,
+      "log_good": 2.9809
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1999.0,
+      "good": 2125.0,
+      "ratio": 1.063,
+      "suggested_scalar": 0.0177,
+      "log_bad": 7.6004,
+      "log_good": 7.6615
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.3148,
+      "good": 0.3448,
+      "ratio": 1.0953,
+      "suggested_scalar": 0.0264,
+      "log_bad": -1.1558,
+      "log_good": -1.0648
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7407,
+      "good": 0.7759,
+      "ratio": 1.0475,
+      "suggested_scalar": 0.0134,
+      "log_bad": -0.3002,
+      "log_good": -0.2537
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.6667,
+      "good": 6.069,
+      "ratio": 0.9103,
+      "suggested_scalar": -0.0272,
+      "log_bad": 1.8971,
+      "log_good": 1.8032
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 13.476,
+      "good": 15.0345,
+      "ratio": 1.1157,
+      "suggested_scalar": 0.0317,
+      "log_bad": 2.6009,
+      "log_good": 2.7103
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 58.0,
+      "good": 35.0,
+      "ratio": 0.6034,
+      "suggested_scalar": -0.1462,
+      "log_bad": 4.0604,
+      "log_good": 3.5553
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9134,
+      "good": 0.9328,
+      "ratio": 1.0212,
+      "suggested_scalar": 0.0061,
+      "log_bad": -0.0906,
+      "log_good": -0.0696
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 29.0,
+      "ratio": 1.0741,
+      "suggested_scalar": 0.0207,
+      "log_bad": 3.2958,
+      "log_good": 3.3673
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6608,
+      "good": 0.6856,
+      "ratio": 1.0375,
+      "suggested_scalar": 0.0107,
+      "log_bad": -0.4143,
+      "log_good": -0.3775
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3855,
+      "good": 0.3714,
+      "ratio": 0.9634,
+      "suggested_scalar": -0.0108,
+      "log_bad": -0.9532,
+      "log_good": -0.9905
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9484,
+      "good": 3.1811,
+      "ratio": 1.0789,
+      "suggested_scalar": 0.022,
+      "log_bad": 1.0813,
+      "log_good": 1.1572
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 358.0,
+      "good": 350.0,
+      "ratio": 0.9777,
+      "suggested_scalar": -0.0065,
+      "log_bad": 5.8805,
+      "log_good": 5.8579
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 28.0,
+      "good": 28.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3322,
+      "log_good": 3.3322
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0583,
+      "good": 0.0739,
+      "ratio": 1.2676,
+      "suggested_scalar": 0.0687,
+      "log_bad": -2.8422,
+      "log_good": -2.605
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0444,
+      "good": 5.9542,
+      "ratio": 0.9851,
+      "suggested_scalar": -0.0044,
+      "log_bad": 1.7991,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 33.0,
+      "good": 38.0,
+      "ratio": 1.1515,
+      "suggested_scalar": 0.0408,
+      "log_bad": 3.4965,
+      "log_good": 3.6376
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.6772,
+      "good": 1.7357,
+      "ratio": 1.0349,
+      "suggested_scalar": 0.0099,
+      "log_bad": 0.5171,
+      "log_good": 0.5514
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8747,
+      "good": 5.6401,
+      "ratio": 0.9601,
+      "suggested_scalar": -0.0118,
+      "log_bad": 1.7707,
+      "log_good": 1.7299
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7389,
+      "good": 0.7628,
+      "ratio": 1.0323,
+      "suggested_scalar": 0.0092,
+      "log_bad": -0.3026,
+      "log_good": -0.2708
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1692,
+      "good": 0.1714,
+      "ratio": 1.013,
+      "suggested_scalar": 0.0037,
+      "log_bad": -1.7767,
+      "log_good": -1.7638
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6762,
+      "good": 4.4391,
+      "ratio": 1.2075,
+      "suggested_scalar": 0.0546,
+      "log_bad": 1.3019,
+      "log_good": 1.4905
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2007,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 274.0,
+      "good": 273.0,
+      "ratio": 0.9964,
+      "suggested_scalar": -0.0011,
+      "log_bad": 5.6131,
+      "log_good": 5.6095
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0646,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7472,
+      "good": 0.7351,
+      "ratio": 0.9838,
+      "suggested_scalar": -0.0047,
+      "log_bad": -0.2914,
+      "log_good": -0.3077
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 94.0,
+      "good": 83.0,
+      "ratio": 0.883,
+      "suggested_scalar": -0.036,
+      "log_bad": 4.5433,
+      "log_good": 4.4188
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 974.0,
+      "good": 1115.0,
+      "ratio": 1.1448,
+      "suggested_scalar": 0.0391,
+      "log_bad": 6.8814,
+      "log_good": 7.0166
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 157.0,
+      "good": 148.0,
+      "ratio": 0.9427,
+      "suggested_scalar": -0.0171,
+      "log_bad": 5.0562,
+      "log_good": 4.9972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0194,
+      "good": 0.0142,
+      "ratio": 0.732,
+      "suggested_scalar": -0.0903,
+      "log_bad": -3.9425,
+      "log_good": -4.2545
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2111,
+      "good": 0.2472,
+      "ratio": 1.171,
+      "suggested_scalar": 0.0457,
+      "log_bad": -1.5554,
+      "log_good": -1.3976
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 67.0,
+      "good": 74.0,
+      "ratio": 1.1045,
+      "suggested_scalar": 0.0288,
+      "log_bad": 4.2047,
+      "log_good": 4.3041
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 94.0,
+      "good": 83.0,
+      "ratio": 0.883,
+      "suggested_scalar": -0.036,
+      "log_bad": 4.5433,
+      "log_good": 4.4188
+    },
+    "brevity.mean_sample_size": {
+      "bad": 94.0,
+      "good": 83.0,
+      "ratio": 0.883,
+      "suggested_scalar": -0.036,
+      "log_bad": 4.5433,
+      "log_good": 4.4188
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 360.0,
+      "good": 352.0,
+      "ratio": 0.9778,
+      "suggested_scalar": -0.0065,
+      "log_bad": 5.8861,
+      "log_good": 5.8636
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 164.0,
+      "good": 165.0,
+      "ratio": 1.0061,
+      "suggested_scalar": 0.0018,
+      "log_bad": 5.0999,
+      "log_good": 5.1059
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 227.0,
+      "good": 216.0,
+      "ratio": 0.9515,
+      "suggested_scalar": -0.0144,
+      "log_bad": 5.425,
+      "log_good": 5.3753
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0056,
+      "good": 0.0114,
+      "ratio": 2.0357,
+      "suggested_scalar": 0.2058,
+      "log_bad": -5.185,
+      "log_good": -4.4741
+    },
+    "heaps.mean_k": {
+      "bad": 2.1182,
+      "good": 2.7064,
+      "ratio": 1.2777,
+      "suggested_scalar": 0.071,
+      "log_bad": 0.7506,
+      "log_good": 0.9956
+    },
+    "halstead.mean_effort": {
+      "bad": 70913.7055,
+      "good": 86048.7282,
+      "ratio": 1.2134,
+      "suggested_scalar": 0.056,
+      "log_bad": 11.1692,
+      "log_good": 11.3627
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8963,
+      "good": 0.8847,
+      "ratio": 0.9871,
+      "suggested_scalar": -0.0038,
+      "log_bad": -0.1095,
+      "log_good": -0.1225
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 67.0,
+      "good": 55.0,
+      "ratio": 0.8209,
+      "suggested_scalar": -0.0571,
+      "log_bad": 4.2047,
+      "log_good": 4.0073
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 185.0,
+      "good": 197.0,
+      "ratio": 1.0649,
+      "suggested_scalar": 0.0182,
+      "log_bad": 5.2204,
+      "log_good": 5.2832
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4206,
+      "good": 0.3471,
+      "ratio": 0.8252,
+      "suggested_scalar": -0.0556,
+      "log_bad": -0.8661,
+      "log_good": -1.0581
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.7302,
+      "good": 9.2149,
+      "ratio": 1.1921,
+      "suggested_scalar": 0.0509,
+      "log_bad": 2.0451,
+      "log_good": 2.2208
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1692,
+      "good": 0.1714,
+      "ratio": 1.013,
+      "suggested_scalar": 0.0037,
+      "log_bad": -1.7767,
+      "log_good": -1.7638
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.8761,
+      "good": 2.872,
+      "ratio": 0.9986,
+      "suggested_scalar": -0.0004,
+      "log_bad": 1.0564,
+      "log_good": 1.055
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 359.0,
+      "good": 351.0,
+      "ratio": 0.9777,
+      "suggested_scalar": -0.0065,
+      "log_bad": 5.8833,
+      "log_good": 5.8608
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 54.0,
+      "good": 53.0,
+      "ratio": 0.9815,
+      "suggested_scalar": -0.0054,
+      "log_bad": 3.989,
+      "log_good": 3.9703
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3939.6503,
+      "good": 4780.4849,
+      "ratio": 1.2134,
+      "suggested_scalar": 0.056,
+      "log_bad": 8.2788,
+      "log_good": 8.4723
+    },
+    "readability.mean_total_lines": {
+      "bad": 54.0,
+      "good": 58.0,
+      "ratio": 1.0741,
+      "suggested_scalar": 0.0207,
+      "log_bad": 3.989,
+      "log_good": 4.0604
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2241.6694,
+      "good": 2205.3495,
+      "ratio": 0.9838,
+      "suggested_scalar": -0.0047,
+      "log_bad": 7.715,
+      "log_good": 7.6986
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 678.0,
+      "good": 668.0,
+      "ratio": 0.9853,
+      "suggested_scalar": -0.0043,
+      "log_bad": 6.5191,
+      "log_good": 6.5043
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.7778,
+      "good": 35.431,
+      "ratio": 0.9903,
+      "suggested_scalar": -0.0028,
+      "log_bad": 3.5773,
+      "log_good": 3.5676
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.178,
+      "good": 1.3056,
+      "ratio": 1.1083,
+      "suggested_scalar": 0.0298,
+      "log_bad": 0.1638,
+      "log_good": 0.2667
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 15.0,
+      "good": 20.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0833,
+      "log_bad": 2.7081,
+      "log_good": 2.9957
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 1.0,
+      "ratio": 0.25,
+      "suggested_scalar": -0.4014,
+      "log_bad": 1.3863,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8029,
+      "good": 0.8059,
+      "ratio": 1.0037,
+      "suggested_scalar": 0.0011,
+      "log_bad": -0.2195,
+      "log_good": -0.2158
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9612,
+      "good": 0.9745,
+      "ratio": 1.0138,
+      "suggested_scalar": 0.004,
+      "log_bad": -0.0396,
+      "log_good": -0.0258
+    },
+    "halstead.mean_length": {
+      "bad": 342.0,
+      "good": 345.0,
+      "ratio": 1.0088,
+      "suggested_scalar": 0.0025,
+      "log_bad": 5.8348,
+      "log_good": 5.8435
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.5714,
+      "good": 6.4286,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.0064,
+      "log_bad": 1.8827,
+      "log_good": 1.8608
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5546,
+      "good": 6.375,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.008,
+      "log_bad": 1.8802,
+      "log_good": 1.8524
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0821,
+      "good": 0.0776,
+      "ratio": 0.9452,
+      "suggested_scalar": -0.0163,
+      "log_bad": -2.4998,
+      "log_good": -2.5562
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 31.6343,
+      "good": 39.0182,
+      "ratio": 1.2334,
+      "suggested_scalar": 0.0607,
+      "log_bad": 3.4542,
+      "log_good": 3.664
+    },
+    "branching.mean_branch_count": {
+      "bad": 17.0,
+      "good": 20.0,
+      "ratio": 1.1765,
+      "suggested_scalar": 0.0471,
+      "log_bad": 2.8332,
+      "log_good": 2.9957
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 53.0,
+      "good": 42.0,
+      "ratio": 0.7925,
+      "suggested_scalar": -0.0674,
+      "log_bad": 3.9703,
+      "log_good": 3.7377
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7048,
+      "good": 0.6574,
+      "ratio": 0.9327,
+      "suggested_scalar": -0.0202,
+      "log_bad": -0.3498,
+      "log_good": -0.4195
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 54.0,
+      "good": 58.0,
+      "ratio": 1.0741,
+      "suggested_scalar": 0.0207,
+      "log_bad": 3.989,
+      "log_good": 4.0604
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 23.0,
+      "ratio": 1.2105,
+      "suggested_scalar": 0.0553,
+      "log_bad": 2.9444,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "testing.test_has_assertion": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 27.0,
+      "good": 29.0,
+      "ratio": 1.0741,
+      "suggested_scalar": 0.0228,
+      "log_bad": 3.2958,
+      "log_good": 3.3673
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0447,
+      "good": 0.0428,
+      "ratio": 0.9575,
+      "suggested_scalar": -0.0139,
+      "log_bad": -3.1078,
+      "log_good": -3.1512
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1667,
+      "good": 1.1667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1542,
+      "log_good": 0.1542
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8704,
+      "good": 0.8605,
+      "ratio": 0.9886,
+      "suggested_scalar": -0.0037,
+      "log_bad": -0.1388,
+      "log_good": -0.1502
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0447,
+      "good": 0.0428,
+      "ratio": 0.9575,
+      "suggested_scalar": -0.0139,
+      "log_bad": -3.1078,
+      "log_good": -3.1512
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6384,
+      "good": 4.6711,
+      "ratio": 1.007,
+      "suggested_scalar": 0.0022,
+      "log_bad": 1.5344,
+      "log_good": 1.5414
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 115.0,
+      "good": 85.0,
+      "ratio": 0.7391,
+      "suggested_scalar": -0.0965,
+      "log_bad": 4.7449,
+      "log_good": 4.4427
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.509,
+      "good": 0.416,
+      "ratio": 0.8173,
+      "suggested_scalar": -0.0644,
+      "log_bad": -0.6753,
+      "log_good": -0.8771
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 16.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0194,
+      "log_bad": 2.8332,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5813,
+      "good": 0.5104,
+      "ratio": 0.878,
+      "suggested_scalar": -0.0415,
+      "log_bad": -0.5425,
+      "log_good": -0.6726
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.8519,
+      "good": 2.6047,
+      "ratio": 0.9133,
+      "suggested_scalar": -0.0289,
+      "log_bad": 1.048,
+      "log_good": 0.9573
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 537.0,
+      "good": 537.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.286,
+      "log_good": 6.286
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1296,
+      "good": 1.0,
+      "ratio": 7.716,
+      "suggested_scalar": 0.6522,
+      "log_bad": -2.0433,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0785,
+      "good": 1.1655,
+      "ratio": 1.0807,
+      "suggested_scalar": 0.0248,
+      "log_bad": 0.0756,
+      "log_good": 0.1532
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 210.0,
+      "good": 187.0,
+      "ratio": 0.8905,
+      "suggested_scalar": -0.037,
+      "log_bad": 5.3471,
+      "log_good": 5.2311
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 109.3365,
+      "good": 107.1223,
+      "ratio": 0.9797,
+      "suggested_scalar": -0.0065,
+      "log_bad": 4.6944,
+      "log_good": 4.674
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5989,
+      "good": 0.7015,
+      "ratio": 1.1713,
+      "suggested_scalar": 0.0505,
+      "log_bad": -0.5127,
+      "log_good": -0.3545
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 4.5682,
+      "good": 5.4324,
+      "ratio": 1.1892,
+      "suggested_scalar": 0.0553,
+      "log_bad": 1.5191,
+      "log_good": 1.6924
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1885.0,
+      "good": 1804.0,
+      "ratio": 0.957,
+      "suggested_scalar": -0.014,
+      "log_bad": 7.5417,
+      "log_good": 7.4978
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0556,
+      "good": 0.093,
+      "ratio": 1.6727,
+      "suggested_scalar": 0.1642,
+      "log_bad": -2.8896,
+      "log_good": -2.3752
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8519,
+      "good": 0.8372,
+      "ratio": 0.9827,
+      "suggested_scalar": -0.0056,
+      "log_bad": -0.1603,
+      "log_good": -0.1777
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 11.4255,
+      "good": 12.4884,
+      "ratio": 1.093,
+      "suggested_scalar": 0.0284,
+      "log_bad": 2.4358,
+      "log_good": 2.5248
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1294,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.7188,
+      "good": 1.5879,
+      "ratio": 0.9238,
+      "suggested_scalar": -0.0253,
+      "log_bad": 0.5416,
+      "log_good": 0.4624
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 169.0,
+      "good": 152.0,
+      "ratio": 0.8994,
+      "suggested_scalar": -0.0338,
+      "log_bad": 5.1299,
+      "log_good": 5.0239
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.95,
+      "good": 0.9355,
+      "ratio": 0.9847,
+      "suggested_scalar": -0.0049,
+      "log_bad": -0.0513,
+      "log_good": -0.0667
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 25.0,
+      "ratio": 1.0417,
+      "suggested_scalar": 0.013,
+      "log_bad": 3.1781,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6117,
+      "good": 0.6386,
+      "ratio": 1.044,
+      "suggested_scalar": 0.0137,
+      "log_bad": -0.4915,
+      "log_good": -0.4485
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4019,
+      "good": 0.5215,
+      "ratio": 1.2976,
+      "suggested_scalar": 0.0832,
+      "log_bad": -0.9116,
+      "log_good": -0.651
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5751,
+      "good": 2.7669,
+      "ratio": 1.0745,
+      "suggested_scalar": 0.0229,
+      "log_bad": 0.9459,
+      "log_good": 1.0177
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 535.0,
+      "good": 535.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.2823,
+      "log_good": 6.2823
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0559,
+      "good": 0.0484,
+      "ratio": 0.8658,
+      "suggested_scalar": -0.046,
+      "log_bad": -2.8842,
+      "log_good": -3.0283
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.9069,
+      "ratio": 0.9921,
+      "suggested_scalar": -0.0025,
+      "log_bad": 1.7841,
+      "log_good": 1.7761
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 38.0,
+      "good": 33.0,
+      "ratio": 0.8684,
+      "suggested_scalar": -0.045,
+      "log_bad": 3.6376,
+      "log_good": 3.4965
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.786,
+      "good": 0.7546,
+      "ratio": 0.9601,
+      "suggested_scalar": -0.013,
+      "log_bad": -0.2408,
+      "log_good": -0.2816
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.707,
+      "good": 5.4904,
+      "ratio": 0.962,
+      "suggested_scalar": -0.0124,
+      "log_bad": 1.7417,
+      "log_good": 1.703
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.779,
+      "good": 0.7908,
+      "ratio": 1.0151,
+      "suggested_scalar": 0.0048,
+      "log_bad": -0.2497,
+      "log_good": -0.2347
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.129,
+      "good": 0.14,
+      "ratio": 1.0853,
+      "suggested_scalar": 0.0261,
+      "log_bad": -2.0479,
+      "log_good": -1.9661
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.1373,
+      "good": 2.3308,
+      "ratio": 1.0905,
+      "suggested_scalar": 0.0277,
+      "log_bad": 0.7595,
+      "log_good": 0.8462
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 380.0,
+      "good": 342.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0336,
+      "log_bad": 5.9402,
+      "log_good": 5.8348
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 7.0,
+      "good": 6.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0492,
+      "log_bad": 1.9459,
+      "log_good": 1.7918
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0177,
+      "good": 0.9272,
+      "ratio": 0.9111,
+      "suggested_scalar": -0.0297,
+      "log_bad": 0.0175,
+      "log_good": -0.0756
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 119.0,
+      "good": 100.0,
+      "ratio": 0.8403,
+      "suggested_scalar": -0.0555,
+      "log_bad": 4.7791,
+      "log_good": 4.6052
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1038.0,
+      "good": 955.0,
+      "ratio": 0.92,
+      "suggested_scalar": -0.0266,
+      "log_bad": 6.9451,
+      "log_good": 6.8617
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 193.0,
+      "good": 166.0,
+      "ratio": 0.8601,
+      "suggested_scalar": -0.0481,
+      "log_bad": 5.2627,
+      "log_good": 5.112
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0019,
+      "good": 1.0,
+      "ratio": 526.3158,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.2659,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2756,
+      "good": 0.2868,
+      "ratio": 1.0406,
+      "suggested_scalar": 0.0127,
+      "log_bad": -1.2888,
+      "log_good": -1.249
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 76.0,
+      "good": 94.0,
+      "ratio": 1.2368,
+      "suggested_scalar": 0.0678,
+      "log_bad": 4.3307,
+      "log_good": 4.5433
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 119.0,
+      "good": 100.0,
+      "ratio": 0.8403,
+      "suggested_scalar": -0.0555,
+      "log_bad": 4.7791,
+      "log_good": 4.6052
+    },
+    "brevity.mean_sample_size": {
+      "bad": 119.0,
+      "good": 100.0,
+      "ratio": 0.8403,
+      "suggested_scalar": -0.0555,
+      "log_bad": 4.7791,
+      "log_good": 4.6052
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 537.0,
+      "good": 537.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.286,
+      "log_good": 6.286
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 274.0,
+      "good": 285.0,
+      "ratio": 1.0401,
+      "suggested_scalar": 0.0126,
+      "log_bad": 5.6131,
+      "log_good": 5.6525
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 291.0,
+      "good": 254.0,
+      "ratio": 0.8729,
+      "suggested_scalar": -0.0434,
+      "log_bad": 5.6733,
+      "log_good": 5.5373
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0019,
+      "good": 0.0019,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.2659,
+      "log_good": -6.2659
+    },
+    "heaps.mean_k": {
+      "bad": 3.2559,
+      "good": 4.3395,
+      "ratio": 1.3328,
+      "suggested_scalar": 0.0917,
+      "log_bad": 1.1805,
+      "log_good": 1.4678
+    },
+    "halstead.mean_effort": {
+      "bad": 77702.7814,
+      "good": 96199.6168,
+      "ratio": 1.238,
+      "suggested_scalar": 0.0682,
+      "log_bad": 11.2606,
+      "log_good": 11.4742
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8277,
+      "good": 0.8264,
+      "ratio": 0.9984,
+      "suggested_scalar": -0.0005,
+      "log_bad": -0.1891,
+      "log_good": -0.1907
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 91.0,
+      "good": 60.0,
+      "ratio": 0.6593,
+      "suggested_scalar": -0.1329,
+      "log_bad": 4.5109,
+      "log_good": 4.0943
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 253.0,
+      "good": 268.0,
+      "ratio": 1.0593,
+      "suggested_scalar": 0.0184,
+      "log_bad": 5.5334,
+      "log_good": 5.591
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4048,
+      "good": 0.3583,
+      "ratio": 0.8851,
+      "suggested_scalar": -0.0389,
+      "log_bad": -0.9044,
+      "log_good": -1.0264
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.9429,
+      "good": 5.107,
+      "ratio": 1.0332,
+      "suggested_scalar": 0.0104,
+      "log_bad": 1.598,
+      "log_good": 1.6306
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.129,
+      "good": 0.14,
+      "ratio": 1.0853,
+      "suggested_scalar": 0.0261,
+      "log_bad": -2.0479,
+      "log_good": -1.9661
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.5702,
+      "good": 4.9953,
+      "ratio": 1.093,
+      "suggested_scalar": 0.0284,
+      "log_bad": 1.5196,
+      "log_good": 1.6085
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 536.0,
+      "good": 536.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.2841,
+      "log_good": 6.2841
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 10.0,
+      "good": 8.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0712,
+      "log_bad": 2.3026,
+      "log_good": 2.0794
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 60.0,
+      "good": 86.0,
+      "ratio": 1.4333,
+      "suggested_scalar": 0.1149,
+      "log_bad": 4.0943,
+      "log_good": 4.4543
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4316.8212,
+      "good": 5344.4232,
+      "ratio": 1.238,
+      "suggested_scalar": 0.0682,
+      "log_bad": 8.3703,
+      "log_good": 8.5838
+    },
+    "readability.mean_total_lines": {
+      "bad": 47.0,
+      "good": 43.0,
+      "ratio": 0.9149,
+      "suggested_scalar": -0.0284,
+      "log_bad": 3.8501,
+      "log_good": 3.7612
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 4.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1294,
+      "log_bad": 1.7918,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 3053.0886,
+      "good": 2781.6757,
+      "ratio": 0.9111,
+      "suggested_scalar": -0.0297,
+      "log_bad": 8.0239,
+      "log_good": 7.9308
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 732.0,
+      "good": 652.0,
+      "ratio": 0.8907,
+      "suggested_scalar": -0.0369,
+      "log_bad": 6.5958,
+      "log_good": 6.48
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.8085,
+      "good": 40.7442,
+      "ratio": 1.2419,
+      "suggested_scalar": 0.0691,
+      "log_bad": 3.4907,
+      "log_good": 3.7073
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0154,
+      "good": 1.0288,
+      "ratio": 1.0132,
+      "suggested_scalar": 0.0042,
+      "log_bad": 0.0153,
+      "log_good": 0.0284
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 29.0,
+      "good": 30.0,
+      "ratio": 1.0345,
+      "suggested_scalar": 0.0108,
+      "log_bad": 3.3673,
+      "log_good": 3.4012
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 1.0,
+      "ratio": 0.1429,
+      "suggested_scalar": -0.6211,
+      "log_bad": 1.9459,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8421,
+      "good": 0.7485,
+      "ratio": 0.8888,
+      "suggested_scalar": -0.0376,
+      "log_bad": -0.1719,
+      "log_good": -0.2897
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9739,
+      "good": 0.9464,
+      "ratio": 0.9718,
+      "suggested_scalar": -0.0091,
+      "log_bad": -0.0264,
+      "log_good": -0.0551
+    },
+    "halstead.mean_length": {
+      "bad": 446.0,
+      "good": 434.0,
+      "ratio": 0.9731,
+      "suggested_scalar": -0.0087,
+      "log_bad": 6.1003,
+      "log_good": 6.073
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.1667,
+      "good": 1.1667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1542,
+      "log_good": 0.1542
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8948,
+      "good": 6.6439,
+      "ratio": 0.9636,
+      "suggested_scalar": -0.0118,
+      "log_bad": 1.9308,
+      "log_good": 1.8937
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1457,
+      "good": 0.1582,
+      "ratio": 1.0858,
+      "suggested_scalar": 0.0263,
+      "log_bad": -1.9262,
+      "log_good": -1.8439
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.4505,
+      "good": 34.5833,
+      "ratio": 1.3588,
+      "suggested_scalar": 0.0979,
+      "log_bad": 3.2367,
+      "log_good": 3.5434
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0918,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 85.0,
+      "good": 67.0,
+      "ratio": 0.7882,
+      "suggested_scalar": -0.076,
+      "log_bad": 4.4427,
+      "log_good": 4.2047
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7388,
+      "good": 0.6299,
+      "ratio": 0.8526,
+      "suggested_scalar": -0.0509,
+      "log_bad": -0.3027,
+      "log_good": -0.4622
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 54.0,
+      "good": 43.0,
+      "ratio": 0.7963,
+      "suggested_scalar": -0.0727,
+      "log_bad": 3.989,
+      "log_good": 3.7612
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "file_structure.no_magic_numbers": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 32.0,
+      "good": 37.0,
+      "ratio": 1.1563,
+      "suggested_scalar": 0.3466,
+      "log_bad": 3.4657,
+      "log_good": 3.6109
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0089,
+      "good": 0.0072,
+      "ratio": 0.809,
+      "suggested_scalar": -0.506,
+      "log_bad": -4.7217,
+      "log_good": -4.9337
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.375,
+      "good": 1.3,
+      "ratio": 0.9455,
+      "suggested_scalar": -0.1339,
+      "log_bad": 0.3185,
+      "log_good": 0.2624
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8442,
+      "good": 0.883,
+      "ratio": 1.046,
+      "suggested_scalar": 0.1073,
+      "log_bad": -0.1694,
+      "log_good": -0.1244
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0089,
+      "good": 0.0072,
+      "ratio": 0.809,
+      "suggested_scalar": -0.506,
+      "log_bad": -4.7217,
+      "log_good": -4.9337
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5765,
+      "good": 4.6696,
+      "ratio": 1.0203,
+      "suggested_scalar": 0.0481,
+      "log_bad": 1.5209,
+      "log_good": 1.5411
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 106.0,
+      "good": 121.0,
+      "ratio": 1.1415,
+      "suggested_scalar": 0.3159,
+      "log_bad": 4.6634,
+      "log_good": 4.7958
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4978,
+      "good": 0.572,
+      "ratio": 1.1491,
+      "suggested_scalar": 0.3317,
+      "log_bad": -0.6976,
+      "log_good": -0.5586
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6575,
+      "good": 0.6228,
+      "ratio": 0.9472,
+      "suggested_scalar": -0.1294,
+      "log_bad": -0.4193,
+      "log_good": -0.4735
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.1299,
+      "good": 3.4043,
+      "ratio": 0.8243,
+      "suggested_scalar": -0.4612,
+      "log_bad": 1.4183,
+      "log_good": 1.225
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 450.0,
+      "good": 552.0,
+      "ratio": 1.2267,
+      "suggested_scalar": 0.4877,
+      "log_bad": 6.1092,
+      "log_good": 6.3135
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0014,
+      "good": 0.001,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.8032,
+      "log_bad": -6.5713,
+      "log_good": -6.9078
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9855,
+      "good": 0.9312,
+      "ratio": 0.9449,
+      "suggested_scalar": -0.1353,
+      "log_bad": -0.0146,
+      "log_good": -0.0713
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 135.0,
+      "good": 178.0,
+      "ratio": 1.3185,
+      "suggested_scalar": 0.66,
+      "log_bad": 4.9053,
+      "log_good": 5.1818
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 82.0402,
+      "good": 61.0117,
+      "ratio": 0.7437,
+      "suggested_scalar": -0.7069,
+      "log_bad": 4.4072,
+      "log_good": 4.1111
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5768,
+      "good": 0.6134,
+      "ratio": 1.0635,
+      "suggested_scalar": 0.1469,
+      "log_bad": -0.5503,
+      "log_good": -0.4887
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 20.539,
+      "good": 32.2775,
+      "ratio": 1.5715,
+      "suggested_scalar": 1.0791,
+      "log_bad": 3.0223,
+      "log_good": 3.4744
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2189.0,
+      "good": 3024.0,
+      "ratio": 1.3815,
+      "suggested_scalar": 0.7713,
+      "log_bad": 7.6912,
+      "log_good": 8.0143
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0779,
+      "good": 0.0532,
+      "ratio": 0.6829,
+      "suggested_scalar": -0.9103,
+      "log_bad": -2.5523,
+      "log_good": -2.9337
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7792,
+      "good": 0.8298,
+      "ratio": 1.0649,
+      "suggested_scalar": 0.1502,
+      "log_bad": -0.2495,
+      "log_good": -0.1866
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.8442,
+      "good": 5.8723,
+      "ratio": 1.0048,
+      "suggested_scalar": 0.0114,
+      "log_bad": 1.7654,
+      "log_good": 1.7702
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.126,
+      "good": 4.0706,
+      "ratio": 0.7941,
+      "suggested_scalar": -0.5503,
+      "log_bad": 1.6343,
+      "log_good": 1.4038
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 114.0,
+      "good": 157.0,
+      "ratio": 1.3772,
+      "suggested_scalar": 0.764,
+      "log_bad": 4.7362,
+      "log_good": 5.0562
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9533,
+      "good": 0.9406,
+      "ratio": 0.9867,
+      "suggested_scalar": -0.032,
+      "log_bad": -0.0478,
+      "log_good": -0.0612
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 26.0,
+      "ratio": 0.963,
+      "suggested_scalar": -0.0901,
+      "log_bad": 3.2958,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6469,
+      "good": 0.6839,
+      "ratio": 1.0572,
+      "suggested_scalar": 0.1328,
+      "log_bad": -0.4356,
+      "log_good": -0.3799
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3594,
+      "good": 0.3273,
+      "ratio": 0.9107,
+      "suggested_scalar": -0.2233,
+      "log_bad": -1.0233,
+      "log_good": -1.1169
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.8318,
+      "good": 3.1632,
+      "ratio": 1.117,
+      "suggested_scalar": 0.2642,
+      "log_bad": 1.0409,
+      "log_good": 1.1516
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 448.0,
+      "good": 550.0,
+      "ratio": 1.2277,
+      "suggested_scalar": 0.4896,
+      "log_bad": 6.1048,
+      "log_good": 6.3099
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 19.0,
+      "good": 17.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.2655,
+      "log_bad": 2.9444,
+      "log_good": 2.8332
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0156,
+      "good": 0.0199,
+      "ratio": 1.2756,
+      "suggested_scalar": 0.5811,
+      "log_bad": -4.1605,
+      "log_good": -3.917
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.858,
+      "good": 5.858,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7678,
+      "log_good": 1.7678
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7789,
+      "good": 0.6413,
+      "ratio": 0.8233,
+      "suggested_scalar": -0.464,
+      "log_bad": -0.2499,
+      "log_good": -0.4443
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7439,
+      "good": 5.9319,
+      "ratio": 1.0327,
+      "suggested_scalar": 0.0769,
+      "log_bad": 1.7481,
+      "log_good": 1.7803
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7812,
+      "good": 0.7971,
+      "ratio": 1.0204,
+      "suggested_scalar": 0.0481,
+      "log_bad": -0.2469,
+      "log_good": -0.2268
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1538,
+      "good": 0.1754,
+      "ratio": 1.1404,
+      "suggested_scalar": 0.3137,
+      "log_bad": -1.8721,
+      "log_good": -1.7407
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.532,
+      "good": 5.6813,
+      "ratio": 1.2536,
+      "suggested_scalar": 0.5395,
+      "log_bad": 1.5112,
+      "log_good": 1.7372
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 21.0,
+      "good": 15.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.8032,
+      "log_bad": 3.0445,
+      "log_good": 2.7081
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 344.0,
+      "good": 428.0,
+      "ratio": 1.2442,
+      "suggested_scalar": 0.5215,
+      "log_bad": 5.8406,
+      "log_good": 6.0591
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 14.0,
+      "good": 18.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.5999,
+      "log_bad": 2.6391,
+      "log_good": 2.8904
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9195,
+      "good": 1.0747,
+      "ratio": 1.1688,
+      "suggested_scalar": 0.3723,
+      "log_bad": -0.0839,
+      "log_good": 0.072
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 111.0,
+      "good": 131.0,
+      "ratio": 1.1802,
+      "suggested_scalar": 0.3955,
+      "log_bad": 4.7095,
+      "log_good": 4.8752
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1136.0,
+      "good": 1855.0,
+      "ratio": 1.6329,
+      "suggested_scalar": 1.1705,
+      "log_bad": 7.0353,
+      "log_good": 7.5256
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 160.0,
+      "good": 197.0,
+      "ratio": 1.2312,
+      "suggested_scalar": 0.4966,
+      "log_bad": 5.0752,
+      "log_good": 5.2832
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0267,
+      "good": 0.0145,
+      "ratio": 0.5431,
+      "suggested_scalar": -1.4573,
+      "log_bad": -3.6231,
+      "log_good": -4.2336
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2156,
+      "good": 0.2047,
+      "ratio": 0.9494,
+      "suggested_scalar": -0.1238,
+      "log_bad": -1.5343,
+      "log_good": -1.5862
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 77.0,
+      "good": 106.0,
+      "ratio": 1.3766,
+      "suggested_scalar": 0.763,
+      "log_bad": 4.3438,
+      "log_good": 4.6634
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 16.0,
+      "good": 20.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.5327,
+      "log_bad": 2.7726,
+      "log_good": 2.9957
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 111.0,
+      "good": 131.0,
+      "ratio": 1.1802,
+      "suggested_scalar": 0.3955,
+      "log_bad": 4.7095,
+      "log_good": 4.8752
+    },
+    "brevity.mean_sample_size": {
+      "bad": 111.0,
+      "good": 131.0,
+      "ratio": 1.1802,
+      "suggested_scalar": 0.3955,
+      "log_bad": 4.7095,
+      "log_good": 4.8752
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 450.0,
+      "good": 552.0,
+      "ratio": 1.2267,
+      "suggested_scalar": 0.4877,
+      "log_bad": 6.1092,
+      "log_good": 6.3135
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 223.0,
+      "good": 271.0,
+      "ratio": 1.2152,
+      "suggested_scalar": 0.4654,
+      "log_bad": 5.4072,
+      "log_good": 5.6021
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 267.0,
+      "good": 319.0,
+      "ratio": 1.1948,
+      "suggested_scalar": 0.4248,
+      "log_bad": 5.5872,
+      "log_good": 5.7652
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0467,
+      "good": 0.0272,
+      "ratio": 0.5824,
+      "suggested_scalar": -1.2903,
+      "log_bad": -3.064,
+      "log_good": -3.6045
+    },
+    "heaps.mean_k": {
+      "bad": 2.0792,
+      "good": 2.9012,
+      "ratio": 1.3953,
+      "suggested_scalar": 0.7952,
+      "log_bad": 0.732,
+      "log_good": 1.0651
+    },
+    "halstead.mean_effort": {
+      "bad": 75420.8399,
+      "good": 86917.3819,
+      "ratio": 1.1524,
+      "suggested_scalar": 0.3387,
+      "log_bad": 11.2308,
+      "log_good": 11.3727
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8454,
+      "good": 0.8434,
+      "ratio": 0.9976,
+      "suggested_scalar": -0.0057,
+      "log_bad": -0.1679,
+      "log_good": -0.1703
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 79.0,
+      "good": 95.0,
+      "ratio": 1.2025,
+      "suggested_scalar": 0.4402,
+      "log_bad": 4.3694,
+      "log_good": 4.5539
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 250.0,
+      "good": 269.0,
+      "ratio": 1.076,
+      "suggested_scalar": 0.1749,
+      "log_bad": 5.5215,
+      "log_good": 5.5947
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4667,
+      "good": 0.4663,
+      "ratio": 0.9991,
+      "suggested_scalar": -0.002,
+      "log_bad": -0.7621,
+      "log_good": -0.7629
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.4148,
+      "good": 10.4213,
+      "ratio": 1.2384,
+      "suggested_scalar": 0.5105,
+      "log_bad": 2.13,
+      "log_good": 2.3439
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1538,
+      "good": 0.1754,
+      "ratio": 1.1404,
+      "suggested_scalar": 0.3137,
+      "log_bad": -1.8721,
+      "log_good": -1.7407
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.7377,
+      "good": 8.6393,
+      "ratio": 2.3114,
+      "suggested_scalar": 2.0,
+      "log_bad": 1.3185,
+      "log_good": 2.1563
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 449.0,
+      "good": 551.0,
+      "ratio": 1.2272,
+      "suggested_scalar": 0.4887,
+      "log_bad": 6.107,
+      "log_good": 6.3117
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 57.0,
+      "good": 58.0,
+      "ratio": 1.0175,
+      "suggested_scalar": 0.0415,
+      "log_bad": 4.0431,
+      "log_good": 4.0604
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4190.0467,
+      "good": 4828.7434,
+      "ratio": 1.1524,
+      "suggested_scalar": 0.3387,
+      "log_bad": 8.3405,
+      "log_good": 8.4823
+    },
+    "readability.mean_total_lines": {
+      "bad": 77.0,
+      "good": 94.0,
+      "ratio": 1.2208,
+      "suggested_scalar": 0.4762,
+      "log_bad": 4.3438,
+      "log_good": 4.5433
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2758.4474,
+      "good": 3224.1903,
+      "ratio": 1.1688,
+      "suggested_scalar": 0.3724,
+      "log_bad": 7.9224,
+      "log_good": 8.0784
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 773.0,
+      "good": 956.0,
+      "ratio": 1.2367,
+      "suggested_scalar": 0.5072,
+      "log_bad": 6.6503,
+      "log_good": 6.8628
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 27.2468,
+      "good": 30.9574,
+      "ratio": 1.1362,
+      "suggested_scalar": 0.3048,
+      "log_bad": 3.3049,
+      "log_good": 3.4326
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.405,
+      "good": 1.6532,
+      "ratio": 1.1767,
+      "suggested_scalar": 0.3883,
+      "log_bad": 0.34,
+      "log_good": 0.5027
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8343,
+      "good": 0.8645,
+      "ratio": 1.0362,
+      "suggested_scalar": 0.0849,
+      "log_bad": -0.1812,
+      "log_good": -0.1456
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9899,
+      "good": 0.9635,
+      "ratio": 0.9733,
+      "suggested_scalar": -0.0645,
+      "log_bad": -0.0102,
+      "log_good": -0.0372
+    },
+    "halstead.mean_length": {
+      "bad": 410.0,
+      "good": 466.0,
+      "ratio": 1.1366,
+      "suggested_scalar": 0.3056,
+      "log_bad": 6.0162,
+      "log_good": 6.1442
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.375,
+      "good": 4.2,
+      "ratio": 0.7814,
+      "suggested_scalar": -0.5888,
+      "log_bad": 1.6818,
+      "log_good": 1.4351
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7944,
+      "good": 7.0334,
+      "ratio": 1.0352,
+      "suggested_scalar": 0.0825,
+      "log_bad": 1.9161,
+      "log_good": 1.9507
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1019,
+      "good": 0.0896,
+      "ratio": 0.8793,
+      "suggested_scalar": -0.3071,
+      "log_bad": -2.2838,
+      "log_good": -2.4124
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.3418,
+      "good": 26.9579,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0338,
+      "log_bad": 3.3084,
+      "log_good": 3.2943
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.4352,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 63.0,
+      "good": 83.0,
+      "ratio": 1.3175,
+      "suggested_scalar": 0.6581,
+      "log_bad": 4.1431,
+      "log_good": 4.4188
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7116,
+      "good": 0.6677,
+      "ratio": 0.9383,
+      "suggested_scalar": -0.152,
+      "log_bad": -0.3402,
+      "log_good": -0.4039
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 77.0,
+      "good": 94.0,
+      "ratio": 1.2208,
+      "suggested_scalar": 0.4762,
+      "log_bad": 4.3438,
+      "log_good": 4.5433
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 23.0,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.2172,
+      "log_bad": 3.0445,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.does_not_box_collections_unnecessarily": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.3893,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.8,
+      "good": 1.6667,
+      "ratio": 0.9259,
+      "suggested_scalar": -0.1643,
+      "log_bad": 0.5878,
+      "log_good": 0.5108
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8462,
+      "good": 0.8113,
+      "ratio": 0.9588,
+      "suggested_scalar": -0.0899,
+      "log_bad": -0.167,
+      "log_good": -0.2091
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7592,
+      "good": 4.6793,
+      "ratio": 0.9832,
+      "suggested_scalar": -0.0361,
+      "log_bad": 1.5601,
+      "log_good": 1.5431
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 112.0,
+      "good": 89.0,
+      "ratio": 0.7946,
+      "suggested_scalar": -0.4908,
+      "log_bad": 4.7185,
+      "log_good": 4.4886
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4888,
+      "good": 0.4484,
+      "ratio": 0.9173,
+      "suggested_scalar": -0.1842,
+      "log_bad": -0.7158,
+      "log_good": -0.8021
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6495,
+      "good": 0.6572,
+      "ratio": 1.0119,
+      "suggested_scalar": 0.0252,
+      "log_bad": -0.4316,
+      "log_good": -0.4198
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.0769,
+      "good": 4.9811,
+      "ratio": 0.9811,
+      "suggested_scalar": -0.0407,
+      "log_bad": 1.6247,
+      "log_good": 1.6057
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 503.0,
+      "good": 419.0,
+      "ratio": 0.833,
+      "suggested_scalar": -0.3901,
+      "log_bad": 6.2206,
+      "log_good": 6.0379
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0962,
+      "good": 0.0377,
+      "ratio": 0.3919,
+      "suggested_scalar": -2.0,
+      "log_bad": -2.3413,
+      "log_good": -3.2781
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0606,
+      "good": 1.0659,
+      "ratio": 1.005,
+      "suggested_scalar": 0.0106,
+      "log_bad": 0.0588,
+      "log_good": 0.0638
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 158.0,
+      "good": 118.0,
+      "ratio": 0.7468,
+      "suggested_scalar": -0.6232,
+      "log_bad": 5.0626,
+      "log_good": 4.7707
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.8886,
+      "good": 100.8964,
+      "ratio": 0.9903,
+      "suggested_scalar": -0.0209,
+      "log_bad": 4.6239,
+      "log_good": 4.6141
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6315,
+      "good": 0.6411,
+      "ratio": 1.0152,
+      "suggested_scalar": 0.0322,
+      "log_bad": -0.4597,
+      "log_good": -0.4446
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.7619,
+      "good": 12.9288,
+      "ratio": 1.2013,
+      "suggested_scalar": 0.3917,
+      "log_bad": 2.376,
+      "log_good": 2.5595
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1777.0,
+      "good": 1528.0,
+      "ratio": 0.8599,
+      "suggested_scalar": -0.3223,
+      "log_bad": 7.4827,
+      "log_good": 7.3317
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1154,
+      "good": 0.0755,
+      "ratio": 0.6542,
+      "suggested_scalar": -0.9058,
+      "log_bad": -2.1594,
+      "log_good": -2.5836
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8077,
+      "good": 0.7736,
+      "ratio": 0.9578,
+      "suggested_scalar": -0.0921,
+      "log_bad": -0.2136,
+      "log_good": -0.2567
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.8627,
+      "good": 8.0577,
+      "ratio": 0.817,
+      "suggested_scalar": -0.4316,
+      "log_bad": 2.2888,
+      "log_good": 2.0866
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 14.8402,
+      "good": 15.6412,
+      "ratio": 1.054,
+      "suggested_scalar": 0.1122,
+      "log_bad": 2.6973,
+      "log_good": 2.7499
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 91.0,
+      "good": 69.0,
+      "ratio": 0.7582,
+      "suggested_scalar": -0.5909,
+      "log_bad": 4.5109,
+      "log_good": 4.2341
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9576,
+      "good": 0.9444,
+      "ratio": 0.9862,
+      "suggested_scalar": -0.0296,
+      "log_bad": -0.0433,
+      "log_good": -0.0572
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 33.0,
+      "good": 28.0,
+      "ratio": 0.8485,
+      "suggested_scalar": -0.3508,
+      "log_bad": 3.4965,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5729,
+      "good": 0.5864,
+      "ratio": 1.0236,
+      "suggested_scalar": 0.0497,
+      "log_bad": -0.557,
+      "log_good": -0.5338
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3573,
+      "good": 0.3237,
+      "ratio": 0.906,
+      "suggested_scalar": -0.2108,
+      "log_bad": -1.0292,
+      "log_good": -1.1279
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3412,
+      "good": 2.4177,
+      "ratio": 1.0327,
+      "suggested_scalar": 0.0686,
+      "log_bad": 0.8507,
+      "log_good": 0.8828
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 501.0,
+      "good": 417.0,
+      "ratio": 0.8323,
+      "suggested_scalar": -0.3918,
+      "log_bad": 6.2166,
+      "log_good": 6.0331
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 9.0,
+      "good": 16.0,
+      "ratio": 1.7778,
+      "suggested_scalar": 1.2284,
+      "log_bad": 2.1972,
+      "log_good": 2.7726
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0676,
+      "good": 0.0573,
+      "ratio": 0.8476,
+      "suggested_scalar": -0.3529,
+      "log_bad": -2.6941,
+      "log_good": -2.8595
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0224,
+      "good": 6.0,
+      "ratio": 0.9963,
+      "suggested_scalar": -0.008,
+      "log_bad": 1.7955,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 67.0,
+      "good": 49.0,
+      "ratio": 0.7313,
+      "suggested_scalar": -0.668,
+      "log_bad": 4.2047,
+      "log_good": 3.8918
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9833,
+      "good": 0.9792,
+      "ratio": 0.9958,
+      "suggested_scalar": -0.0089,
+      "log_bad": -0.0168,
+      "log_good": -0.021
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.705,
+      "good": 5.507,
+      "ratio": 0.9653,
+      "suggested_scalar": -0.0754,
+      "log_bad": 1.7413,
+      "log_good": 1.706
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7903,
+      "good": 0.7799,
+      "ratio": 0.9868,
+      "suggested_scalar": -0.0283,
+      "log_bad": -0.2353,
+      "log_good": -0.2486
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1186,
+      "good": 0.1311,
+      "ratio": 1.1054,
+      "suggested_scalar": 0.2139,
+      "log_bad": -2.132,
+      "log_good": -2.0318
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.2805,
+      "good": 3.5957,
+      "ratio": 1.0961,
+      "suggested_scalar": 0.1959,
+      "log_bad": 1.188,
+      "log_good": 1.2797
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 395.0,
+      "good": 335.0,
+      "ratio": 0.8481,
+      "suggested_scalar": -0.3518,
+      "log_bad": 5.9789,
+      "log_good": 5.8141
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.1473,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.1096,
+      "good": 0.8893,
+      "ratio": 0.8015,
+      "suggested_scalar": -0.4725,
+      "log_bad": 0.104,
+      "log_good": -0.1173
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 112.0,
+      "good": 90.0,
+      "ratio": 0.8036,
+      "suggested_scalar": -0.4669,
+      "log_bad": 4.7185,
+      "log_good": 4.4998
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 806.0,
+      "good": 634.0,
+      "ratio": 0.7866,
+      "suggested_scalar": -0.5125,
+      "log_bad": 6.6921,
+      "log_good": 6.452
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 189.0,
+      "good": 152.0,
+      "ratio": 0.8042,
+      "suggested_scalar": -0.4651,
+      "log_bad": 5.2417,
+      "log_good": 5.0239
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.006,
+      "good": 0.0095,
+      "ratio": 1.5833,
+      "suggested_scalar": 0.9811,
+      "log_bad": -5.116,
+      "log_good": -4.6565
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2883,
+      "good": 0.3126,
+      "ratio": 1.0843,
+      "suggested_scalar": 0.1728,
+      "log_bad": -1.2438,
+      "log_good": -1.1628
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 102.0,
+      "good": 86.0,
+      "ratio": 0.8431,
+      "suggested_scalar": -0.3643,
+      "log_bad": 4.625,
+      "log_good": 4.4543
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.3893,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 112.0,
+      "good": 90.0,
+      "ratio": 0.8036,
+      "suggested_scalar": -0.4669,
+      "log_bad": 4.7185,
+      "log_good": 4.4998
+    },
+    "brevity.mean_sample_size": {
+      "bad": 112.0,
+      "good": 90.0,
+      "ratio": 0.8036,
+      "suggested_scalar": -0.4669,
+      "log_bad": 4.7185,
+      "log_good": 4.4998
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 503.0,
+      "good": 419.0,
+      "ratio": 0.833,
+      "suggested_scalar": -0.3901,
+      "log_bad": 6.2206,
+      "log_good": 6.0379
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 281.0,
+      "good": 238.0,
+      "ratio": 0.847,
+      "suggested_scalar": -0.3546,
+      "log_bad": 5.6384,
+      "log_good": 5.4723
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 287.0,
+      "good": 236.0,
+      "ratio": 0.8223,
+      "suggested_scalar": -0.4177,
+      "log_bad": 5.6595,
+      "log_good": 5.4638
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.1492,
+      "good": 1.897,
+      "ratio": 0.8827,
+      "suggested_scalar": -0.2665,
+      "log_bad": 0.7651,
+      "log_good": 0.6403
+    },
+    "halstead.mean_effort": {
+      "bad": 131403.1907,
+      "good": 93073.9119,
+      "ratio": 0.7083,
+      "suggested_scalar": -0.7363,
+      "log_bad": 11.786,
+      "log_good": 11.4411
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8381,
+      "good": 0.8483,
+      "ratio": 1.0122,
+      "suggested_scalar": 0.0258,
+      "log_bad": -0.1766,
+      "log_good": -0.1645
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 79.0,
+      "good": 61.0,
+      "ratio": 0.7722,
+      "suggested_scalar": -0.5521,
+      "log_bad": 4.3694,
+      "log_good": 4.1109
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 300.0,
+      "good": 260.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.3055,
+      "log_bad": 5.7038,
+      "log_good": 5.5607
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.443,
+      "good": 0.4322,
+      "ratio": 0.9756,
+      "suggested_scalar": -0.0527,
+      "log_bad": -0.8142,
+      "log_good": -0.8389
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.1013,
+      "good": 5.3729,
+      "ratio": 1.0532,
+      "suggested_scalar": 0.1107,
+      "log_bad": 1.6295,
+      "log_good": 1.6814
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1186,
+      "good": 0.1311,
+      "ratio": 1.1054,
+      "suggested_scalar": 0.2139,
+      "log_bad": -2.132,
+      "log_good": -2.0318
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.9451,
+      "good": 3.2231,
+      "ratio": 0.817,
+      "suggested_scalar": -0.4315,
+      "log_bad": 1.3725,
+      "log_good": 1.1703
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 502.0,
+      "good": 418.0,
+      "ratio": 0.8327,
+      "suggested_scalar": -0.391,
+      "log_bad": 6.2186,
+      "log_good": 6.0355
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 73.0,
+      "good": 53.0,
+      "ratio": 0.726,
+      "suggested_scalar": -0.6836,
+      "log_bad": 4.2905,
+      "log_good": 3.9703
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 7300.1773,
+      "good": 5170.7729,
+      "ratio": 0.7083,
+      "suggested_scalar": -0.7363,
+      "log_bad": 8.8957,
+      "log_good": 8.5508
+    },
+    "readability.mean_total_lines": {
+      "bad": 51.0,
+      "good": 52.0,
+      "ratio": 1.0196,
+      "suggested_scalar": 0.0415,
+      "log_bad": 3.9318,
+      "log_good": 3.9512
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 3328.7966,
+      "good": 2668.0022,
+      "ratio": 0.8015,
+      "suggested_scalar": -0.4724,
+      "log_bad": 8.1104,
+      "log_good": 7.8891
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 759.0,
+      "good": 632.0,
+      "ratio": 0.8327,
+      "suggested_scalar": -0.3909,
+      "log_bad": 6.632,
+      "log_good": 6.4489
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 33.1176,
+      "good": 27.7308,
+      "ratio": 0.8373,
+      "suggested_scalar": -0.379,
+      "log_bad": 3.5001,
+      "log_good": 3.3225
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1222,
+      "good": 1.1556,
+      "ratio": 1.0298,
+      "suggested_scalar": 0.0626,
+      "log_bad": 0.1153,
+      "log_good": 0.1446
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 36.0,
+      "good": 27.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.6142,
+      "log_bad": 3.5835,
+      "log_good": 3.2958
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 2.0,
+      "ratio": 0.4,
+      "suggested_scalar": -1.9563,
+      "log_bad": 1.6094,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8152,
+      "good": 0.8418,
+      "ratio": 1.0326,
+      "suggested_scalar": 0.0686,
+      "log_bad": -0.2043,
+      "log_good": -0.1722
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9569,
+      "good": 0.9506,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0141,
+      "log_bad": -0.0441,
+      "log_good": -0.0507
+    },
+    "halstead.mean_length": {
+      "bad": 489.0,
+      "good": 412.0,
+      "ratio": 0.8425,
+      "suggested_scalar": -0.3658,
+      "log_bad": 6.1924,
+      "log_good": 6.021
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.0,
+      "good": 8.3333,
+      "ratio": 1.1905,
+      "suggested_scalar": 0.3722,
+      "log_bad": 1.9459,
+      "log_good": 2.1203
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8074,
+      "good": 6.4919,
+      "ratio": 0.9537,
+      "suggested_scalar": -0.1013,
+      "log_bad": 1.918,
+      "log_good": 1.8706
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1587,
+      "good": 0.156,
+      "ratio": 0.983,
+      "suggested_scalar": -0.0366,
+      "log_bad": -1.8407,
+      "log_good": -1.8579
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 39.4747,
+      "good": 34.8852,
+      "ratio": 0.8837,
+      "suggested_scalar": -0.2639,
+      "log_bad": 3.6757,
+      "log_good": 3.5521
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 4.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.8657,
+      "log_bad": 1.7918,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 70.0,
+      "good": 51.0,
+      "ratio": 0.7286,
+      "suggested_scalar": -0.6761,
+      "log_bad": 4.2485,
+      "log_good": 3.9318
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6446,
+      "good": 0.6356,
+      "ratio": 0.986,
+      "suggested_scalar": -0.03,
+      "log_bad": -0.4391,
+      "log_good": -0.4532
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 52.0,
+      "good": 53.0,
+      "ratio": 1.0192,
+      "suggested_scalar": 0.0407,
+      "log_bad": 3.9512,
+      "log_good": 3.9703
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.rescue_most_specific_first": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 22.0,
+      "good": 24.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.3407,
+      "log_bad": 3.091,
+      "log_good": 3.1781
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.008,
+      "good": 0.0114,
+      "ratio": 1.425,
+      "suggested_scalar": 1.3867,
+      "log_bad": -4.8283,
+      "log_good": -4.4741
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.75,
+      "good": 1.75,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.5596,
+      "log_good": 0.5596
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8542,
+      "good": 0.9,
+      "ratio": 1.0536,
+      "suggested_scalar": 0.2045,
+      "log_bad": -0.1576,
+      "log_good": -0.1054
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.008,
+      "good": 0.0114,
+      "ratio": 1.425,
+      "suggested_scalar": 1.3867,
+      "log_bad": -4.8283,
+      "log_good": -4.4741
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6722,
+      "good": 4.6993,
+      "ratio": 1.0058,
+      "suggested_scalar": 0.0226,
+      "log_bad": 1.5416,
+      "log_good": 1.5474
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 84.0,
+      "good": 92.0,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.3562,
+      "log_bad": 4.4308,
+      "log_good": 4.5218
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.436,
+      "good": 0.4692,
+      "ratio": 1.0761,
+      "suggested_scalar": 0.2873,
+      "log_bad": -0.8301,
+      "log_good": -0.7567
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 21.0,
+      "ratio": 1.1053,
+      "suggested_scalar": 0.3918,
+      "log_bad": 2.9444,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.656,
+      "good": 0.6575,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0089,
+      "log_bad": -0.4216,
+      "log_good": -0.4193
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.2917,
+      "good": 4.36,
+      "ratio": 1.0159,
+      "suggested_scalar": 0.0618,
+      "log_bad": 1.4567,
+      "log_good": 1.4725
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 377.0,
+      "good": 437.0,
+      "ratio": 1.1592,
+      "suggested_scalar": 0.5782,
+      "log_bad": 5.9322,
+      "log_good": 6.0799
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0006,
+      "good": 0.0005,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.7138,
+      "log_bad": -7.4186,
+      "log_good": -7.6009
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1042,
+      "good": 0.1,
+      "ratio": 0.9597,
+      "suggested_scalar": -0.1611,
+      "log_bad": -2.2614,
+      "log_good": -2.3026
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9943,
+      "good": 1.0535,
+      "ratio": 1.0595,
+      "suggested_scalar": 0.2264,
+      "log_bad": -0.0057,
+      "log_good": 0.0521
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 144.0,
+      "good": 163.0,
+      "ratio": 1.1319,
+      "suggested_scalar": 0.4852,
+      "log_bad": 4.9698,
+      "log_good": 5.0938
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 97.6875,
+      "good": 98.3513,
+      "ratio": 1.0068,
+      "suggested_scalar": 0.0265,
+      "log_bad": 4.5818,
+      "log_good": 4.5885
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6649,
+      "good": 0.6193,
+      "ratio": 0.9314,
+      "suggested_scalar": -0.2782,
+      "log_bad": -0.4081,
+      "log_good": -0.4792
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.1173,
+      "good": 12.6898,
+      "ratio": 0.9674,
+      "suggested_scalar": -0.1297,
+      "log_bad": 2.5739,
+      "log_good": 2.5408
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1686.0,
+      "good": 1857.0,
+      "ratio": 1.1014,
+      "suggested_scalar": 0.3782,
+      "log_bad": 7.4301,
+      "log_good": 7.5267
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1875,
+      "good": 0.22,
+      "ratio": 1.1733,
+      "suggested_scalar": 0.6258,
+      "log_bad": -1.674,
+      "log_good": -1.5141
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8125,
+      "good": 0.86,
+      "ratio": 1.0585,
+      "suggested_scalar": 0.2224,
+      "log_bad": -0.2076,
+      "log_good": -0.1508
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.7674,
+      "good": 9.7111,
+      "ratio": 1.1076,
+      "suggested_scalar": 0.4003,
+      "log_bad": 2.171,
+      "log_good": 2.2733
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.9983,
+      "good": 2.9904,
+      "ratio": 0.9974,
+      "suggested_scalar": -0.0103,
+      "log_bad": 1.098,
+      "log_good": 1.0954
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 121.0,
+      "good": 138.0,
+      "ratio": 1.1405,
+      "suggested_scalar": 0.5147,
+      "log_bad": 4.7958,
+      "log_good": 4.9273
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9044,
+      "good": 0.9129,
+      "ratio": 1.0094,
+      "suggested_scalar": 0.0366,
+      "log_bad": -0.1005,
+      "log_good": -0.0911
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 27.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.3013,
+      "log_bad": 3.2189,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6572,
+      "good": 0.6446,
+      "ratio": 0.9808,
+      "suggested_scalar": -0.0758,
+      "log_bad": -0.4198,
+      "log_good": -0.4391
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.552,
+      "good": 0.5011,
+      "ratio": 0.9078,
+      "suggested_scalar": -0.3788,
+      "log_bad": -0.5942,
+      "log_good": -0.6909
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.917,
+      "good": 2.8136,
+      "ratio": 0.9646,
+      "suggested_scalar": -0.1413,
+      "log_bad": 1.0706,
+      "log_good": 1.0345
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 375.0,
+      "good": 435.0,
+      "ratio": 1.16,
+      "suggested_scalar": 0.5811,
+      "log_bad": 5.9269,
+      "log_good": 6.0753
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 27.0,
+      "good": 29.0,
+      "ratio": 1.0741,
+      "suggested_scalar": 0.2798,
+      "log_bad": 3.2958,
+      "log_good": 3.3673
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0451,
+      "good": 0.0435,
+      "ratio": 0.9645,
+      "suggested_scalar": -0.1414,
+      "log_bad": -3.0989,
+      "log_good": -3.135
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 6.0661,
+      "ratio": 1.0228,
+      "suggested_scalar": 0.0884,
+      "log_bad": 1.7801,
+      "log_good": 1.8027
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 23.0,
+      "good": 25.0,
+      "ratio": 1.087,
+      "suggested_scalar": 0.3265,
+      "log_bad": 3.1355,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6336,
+      "good": 0.6182,
+      "ratio": 0.9757,
+      "suggested_scalar": -0.0963,
+      "log_bad": -0.4563,
+      "log_good": -0.4809
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6881,
+      "good": 5.7095,
+      "ratio": 1.0038,
+      "suggested_scalar": 0.0147,
+      "log_bad": 1.7384,
+      "log_good": 1.7421
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7878,
+      "good": 0.7747,
+      "ratio": 0.9834,
+      "suggested_scalar": -0.0657,
+      "log_bad": -0.2385,
+      "log_good": -0.2553
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1273,
+      "good": 0.1228,
+      "ratio": 0.9647,
+      "suggested_scalar": -0.1409,
+      "log_bad": -2.0612,
+      "log_good": -2.0972
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6218,
+      "good": 3.5623,
+      "ratio": 0.9836,
+      "suggested_scalar": -0.0649,
+      "log_bad": 1.287,
+      "log_good": 1.2704
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 233.0,
+      "good": 276.0,
+      "ratio": 1.1845,
+      "suggested_scalar": 0.6631,
+      "log_bad": 5.451,
+      "log_good": 5.6204
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 11.0,
+      "good": 14.0,
+      "ratio": 1.2727,
+      "suggested_scalar": 0.9442,
+      "log_bad": 2.3979,
+      "log_good": 2.6391
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6989,
+      "good": 0.8002,
+      "ratio": 1.1449,
+      "suggested_scalar": 0.5299,
+      "log_bad": -0.3582,
+      "log_good": -0.2229
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 89.0,
+      "good": 101.0,
+      "ratio": 1.1348,
+      "suggested_scalar": 0.4952,
+      "log_bad": 4.4886,
+      "log_good": 4.6151
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 968.0,
+      "good": 1086.0,
+      "ratio": 1.1219,
+      "suggested_scalar": 0.4503,
+      "log_bad": 6.8752,
+      "log_good": 6.9903
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 137.0,
+      "good": 141.0,
+      "ratio": 1.0292,
+      "suggested_scalar": 0.1127,
+      "log_bad": 4.92,
+      "log_good": 4.9488
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.008,
+      "good": 0.0114,
+      "ratio": 1.425,
+      "suggested_scalar": 1.3867,
+      "log_bad": -4.8283,
+      "log_good": -4.4741
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2255,
+      "good": 0.2311,
+      "ratio": 1.0248,
+      "suggested_scalar": 0.096,
+      "log_bad": -1.4894,
+      "log_good": -1.4649
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 72.0,
+      "good": 68.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.2238,
+      "log_bad": 4.2767,
+      "log_good": 4.2195
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 89.0,
+      "good": 101.0,
+      "ratio": 1.1348,
+      "suggested_scalar": 0.4952,
+      "log_bad": 4.4886,
+      "log_good": 4.6151
+    },
+    "brevity.mean_sample_size": {
+      "bad": 89.0,
+      "good": 101.0,
+      "ratio": 1.1348,
+      "suggested_scalar": 0.4952,
+      "log_bad": 4.4886,
+      "log_good": 4.6151
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 377.0,
+      "good": 437.0,
+      "ratio": 1.1592,
+      "suggested_scalar": 0.5782,
+      "log_bad": 5.9322,
+      "log_good": 6.0799
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 199.0,
+      "good": 239.0,
+      "ratio": 1.201,
+      "suggested_scalar": 0.7171,
+      "log_bad": 5.2933,
+      "log_good": 5.4765
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 198.0,
+      "good": 234.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.6541,
+      "log_bad": 5.2883,
+      "log_good": 5.4553
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.0619,
+      "good": 2.0238,
+      "ratio": 0.9815,
+      "suggested_scalar": -0.073,
+      "log_bad": 0.7236,
+      "log_good": 0.705
+    },
+    "halstead.mean_effort": {
+      "bad": 60857.0288,
+      "good": 70302.721,
+      "ratio": 1.1552,
+      "suggested_scalar": 0.5649,
+      "log_bad": 11.0163,
+      "log_good": 11.1606
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8784,
+      "good": 0.8575,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0943,
+      "log_bad": -0.1297,
+      "log_good": -0.1537
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 59.0,
+      "good": 65.0,
+      "ratio": 1.1017,
+      "suggested_scalar": 0.3792,
+      "log_bad": 4.0775,
+      "log_good": 4.1744
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 191.0,
+      "good": 227.0,
+      "ratio": 1.1885,
+      "suggested_scalar": 0.6761,
+      "log_bad": 5.2523,
+      "log_good": 5.425
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3819,
+      "good": 0.3988,
+      "ratio": 1.0443,
+      "suggested_scalar": 0.1695,
+      "log_bad": -0.9626,
+      "log_good": -0.9193
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.7222,
+      "good": 6.6626,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.0349,
+      "log_bad": 1.9054,
+      "log_good": 1.8965
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1273,
+      "good": 0.1228,
+      "ratio": 0.9647,
+      "suggested_scalar": -0.1409,
+      "log_bad": -2.0612,
+      "log_good": -2.0972
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.2006,
+      "good": 4.5062,
+      "ratio": 1.0728,
+      "suggested_scalar": 0.275,
+      "log_bad": 1.4352,
+      "log_good": 1.5055
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 376.0,
+      "good": 436.0,
+      "ratio": 1.1596,
+      "suggested_scalar": 0.5797,
+      "log_bad": 5.9296,
+      "log_good": 6.0776
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 7.0,
+      "good": 10.0,
+      "ratio": 1.4286,
+      "suggested_scalar": 1.3965,
+      "log_bad": 1.9459,
+      "log_good": 2.3026
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 65.0,
+      "good": 59.0,
+      "ratio": 0.9077,
+      "suggested_scalar": -0.3792,
+      "log_bad": 4.1744,
+      "log_good": 4.0775
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3380.946,
+      "good": 3905.7067,
+      "ratio": 1.1552,
+      "suggested_scalar": 0.5649,
+      "log_bad": 8.1259,
+      "log_good": 8.2702
+    },
+    "readability.mean_total_lines": {
+      "bad": 43.0,
+      "good": 45.0,
+      "ratio": 1.0465,
+      "suggested_scalar": 0.178,
+      "log_bad": 3.7612,
+      "log_good": 3.8067
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2096.6801,
+      "good": 2400.6708,
+      "ratio": 1.145,
+      "suggested_scalar": 0.5301,
+      "log_bad": 7.6481,
+      "log_good": 7.7835
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 578.0,
+      "good": 660.0,
+      "ratio": 1.1419,
+      "suggested_scalar": 0.5194,
+      "log_bad": 6.3596,
+      "log_good": 6.4922
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.9302,
+      "good": 33.5556,
+      "ratio": 1.0849,
+      "suggested_scalar": 0.319,
+      "log_bad": 3.4317,
+      "log_good": 3.5132
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.185,
+      "good": 1.1658,
+      "ratio": 0.9838,
+      "suggested_scalar": -0.064,
+      "log_bad": 0.1697,
+      "log_good": 0.1534
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 9.0,
+      "good": 15.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 2.0,
+      "log_bad": 2.1972,
+      "log_good": 2.7081
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.721,
+      "good": 0.7862,
+      "ratio": 1.0904,
+      "suggested_scalar": 0.3389,
+      "log_bad": -0.3271,
+      "log_good": -0.2405
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9662,
+      "good": 0.9808,
+      "ratio": 1.0151,
+      "suggested_scalar": 0.0587,
+      "log_bad": -0.0344,
+      "log_good": -0.0194
+    },
+    "halstead.mean_length": {
+      "bad": 328.0,
+      "good": 368.0,
+      "ratio": 1.122,
+      "suggested_scalar": 0.4505,
+      "log_bad": 5.793,
+      "log_good": 5.9081
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 13.5,
+      "good": 14.0,
+      "ratio": 1.037,
+      "suggested_scalar": 0.1424,
+      "log_bad": 2.6027,
+      "log_good": 2.6391
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4757,
+      "good": 6.6582,
+      "ratio": 1.0282,
+      "suggested_scalar": 0.1088,
+      "log_bad": 1.8681,
+      "log_good": 1.8958
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1187,
+      "good": 0.1288,
+      "ratio": 1.0851,
+      "suggested_scalar": 0.3197,
+      "log_bad": -2.1312,
+      "log_good": -2.0495
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.0254,
+      "good": 29.2846,
+      "ratio": 1.0089,
+      "suggested_scalar": 0.0348,
+      "log_bad": 3.3682,
+      "log_good": 3.3771
+    },
+    "branching.mean_branch_count": {
+      "bad": 9.0,
+      "good": 11.0,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.7857,
+      "log_bad": 2.1972,
+      "log_good": 2.3979
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 55.0,
+      "good": 65.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.6541,
+      "log_bad": 4.0073,
+      "log_good": 4.1744
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6364,
+      "good": 0.7094,
+      "ratio": 1.1147,
+      "suggested_scalar": 0.4252,
+      "log_bad": -0.4519,
+      "log_good": -0.3433
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 48.0,
+      "good": 50.0,
+      "ratio": 1.0417,
+      "suggested_scalar": 0.1598,
+      "log_bad": 3.8712,
+      "log_good": 3.912
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.no_floating_promises": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 39.0,
+      "good": 39.5,
+      "ratio": 1.0128,
+      "suggested_scalar": 0.0071,
+      "log_bad": 3.6636,
+      "log_good": 3.6763
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 12.5,
+      "good": 12.0,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0227,
+      "log_bad": 2.5257,
+      "log_good": 2.4849
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0263,
+      "good": 0.0294,
+      "ratio": 1.1179,
+      "suggested_scalar": 0.0618,
+      "log_bad": -3.6382,
+      "log_good": -3.5268
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3,
+      "good": 1.35,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0209,
+      "log_bad": 0.2624,
+      "log_good": 0.3001
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8012,
+      "good": 0.852,
+      "ratio": 1.0634,
+      "suggested_scalar": 0.0341,
+      "log_bad": -0.2216,
+      "log_good": -0.1602
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0263,
+      "good": 0.0294,
+      "ratio": 1.1179,
+      "suggested_scalar": 0.0618,
+      "log_bad": -3.6382,
+      "log_good": -3.5268
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8274,
+      "good": 4.8055,
+      "ratio": 0.9955,
+      "suggested_scalar": -0.0025,
+      "log_bad": 1.5743,
+      "log_good": 1.5698
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 76.5,
+      "good": 94.0,
+      "ratio": 1.2288,
+      "suggested_scalar": 0.1143,
+      "log_bad": 4.3373,
+      "log_good": 4.5433
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4591,
+      "good": 0.513,
+      "ratio": 1.1174,
+      "suggested_scalar": 0.0616,
+      "log_bad": -0.7785,
+      "log_good": -0.6675
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.5,
+      "good": 16.5,
+      "ratio": 1.0645,
+      "suggested_scalar": 0.0347,
+      "log_bad": 2.7408,
+      "log_good": 2.8034
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5855,
+      "good": 0.5728,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.0122,
+      "log_bad": -0.5353,
+      "log_good": -0.5572
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.7552,
+      "good": 2.1541,
+      "ratio": 1.2273,
+      "suggested_scalar": 0.1136,
+      "log_bad": 0.5626,
+      "log_good": 0.7674
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 421.0,
+      "good": 523.0,
+      "ratio": 1.2423,
+      "suggested_scalar": 0.1204,
+      "log_bad": 6.0426,
+      "log_good": 6.2596
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.5,
+      "good": 6.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1596,
+      "log_bad": 1.5041,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0008,
+      "good": 0.0007,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0741,
+      "log_bad": -7.1309,
+      "log_good": -7.2644
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0272,
+      "good": 1.0,
+      "ratio": 36.7647,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.6045,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0237,
+      "good": 1.0591,
+      "ratio": 1.0346,
+      "suggested_scalar": 0.0189,
+      "log_bad": 0.0234,
+      "log_good": 0.0574
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 132.5,
+      "good": 164.5,
+      "ratio": 1.2415,
+      "suggested_scalar": 0.12,
+      "log_bad": 4.8866,
+      "log_good": 5.1029
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 85.1504,
+      "good": 91.8416,
+      "ratio": 1.0786,
+      "suggested_scalar": 0.042,
+      "log_bad": 4.4444,
+      "log_good": 4.5201
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7248,
+      "good": 0.6894,
+      "ratio": 0.9512,
+      "suggested_scalar": -0.0278,
+      "log_bad": -0.3219,
+      "log_good": -0.3719
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 16.7854,
+      "good": 13.091,
+      "ratio": 0.7799,
+      "suggested_scalar": -0.1379,
+      "log_bad": 2.8205,
+      "log_good": 2.5719
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1708.5,
+      "good": 2047.5,
+      "ratio": 1.1984,
+      "suggested_scalar": 0.1004,
+      "log_bad": 7.4434,
+      "log_good": 7.6244
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0785,
+      "good": 0.0851,
+      "ratio": 1.0841,
+      "suggested_scalar": 0.0448,
+      "log_bad": -2.5447,
+      "log_good": -2.4639
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7884,
+      "good": 0.8109,
+      "ratio": 1.0285,
+      "suggested_scalar": 0.0156,
+      "log_bad": -0.2377,
+      "log_good": -0.2096
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.8853,
+      "good": 9.7027,
+      "ratio": 1.092,
+      "suggested_scalar": 0.0488,
+      "log_bad": 2.1844,
+      "log_good": 2.2724
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.9436,
+      "good": 2.8779,
+      "ratio": 1.4807,
+      "suggested_scalar": 0.2178,
+      "log_bad": 0.6645,
+      "log_good": 1.0571
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 73.5,
+      "good": 102.5,
+      "ratio": 1.3946,
+      "suggested_scalar": 0.1845,
+      "log_bad": 4.2973,
+      "log_good": 4.6299
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.934,
+      "good": 0.9452,
+      "ratio": 1.012,
+      "suggested_scalar": 0.0066,
+      "log_bad": -0.0683,
+      "log_good": -0.0564
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.5,
+      "good": 28.5,
+      "ratio": 1.1176,
+      "suggested_scalar": 0.0617,
+      "log_bad": 3.2387,
+      "log_good": 3.3499
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6422,
+      "good": 0.647,
+      "ratio": 1.0075,
+      "suggested_scalar": 0.0041,
+      "log_bad": -0.4429,
+      "log_good": -0.4354
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5509,
+      "good": 0.5066,
+      "ratio": 0.9196,
+      "suggested_scalar": -0.0465,
+      "log_bad": -0.5962,
+      "log_good": -0.68
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.804,
+      "good": 2.8394,
+      "ratio": 1.0126,
+      "suggested_scalar": 0.007,
+      "log_bad": 1.031,
+      "log_good": 1.0436
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 419.0,
+      "good": 521.0,
+      "ratio": 1.2434,
+      "suggested_scalar": 0.1209,
+      "log_bad": 6.0379,
+      "log_good": 6.2558
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 16.0,
+      "good": 21.0,
+      "ratio": 1.3125,
+      "suggested_scalar": 0.1509,
+      "log_bad": 2.7726,
+      "log_good": 3.0445
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0418,
+      "good": 0.0346,
+      "ratio": 0.8278,
+      "suggested_scalar": -0.1049,
+      "log_bad": -3.1749,
+      "log_good": -3.3639
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8273,
+      "good": 5.8156,
+      "ratio": 0.998,
+      "suggested_scalar": -0.0011,
+      "log_bad": 1.7626,
+      "log_good": 1.7605
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 20.0,
+      "good": 22.5,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0654,
+      "log_bad": 2.9957,
+      "log_good": 3.1135
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2759,
+      "good": 1.2433,
+      "ratio": 0.9744,
+      "suggested_scalar": -0.0144,
+      "log_bad": 0.2437,
+      "log_good": 0.2178
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4093,
+      "good": 5.5694,
+      "ratio": 1.0296,
+      "suggested_scalar": 0.0162,
+      "log_bad": 1.6881,
+      "log_good": 1.7173
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8284,
+      "good": 0.8263,
+      "ratio": 0.9975,
+      "suggested_scalar": -0.0014,
+      "log_bad": -0.1883,
+      "log_good": -0.1908
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.241,
+      "good": 0.2514,
+      "ratio": 1.0432,
+      "suggested_scalar": 0.0234,
+      "log_bad": -1.423,
+      "log_good": -1.3807
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.9219,
+      "good": 3.528,
+      "ratio": 0.8996,
+      "suggested_scalar": -0.0587,
+      "log_bad": 1.3666,
+      "log_good": 1.2607
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 268.0,
+      "good": 349.0,
+      "ratio": 1.3022,
+      "suggested_scalar": 0.1465,
+      "log_bad": 5.591,
+      "log_good": 5.8551
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 26.5,
+      "good": 30.0,
+      "ratio": 1.1321,
+      "suggested_scalar": 0.0688,
+      "log_bad": 3.2771,
+      "log_good": 3.4012
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7972,
+      "good": 1.0267,
+      "ratio": 1.2879,
+      "suggested_scalar": 0.1404,
+      "log_bad": -0.2266,
+      "log_good": 0.0263
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 82.0,
+      "good": 98.5,
+      "ratio": 1.2012,
+      "suggested_scalar": 0.1017,
+      "log_bad": 4.4067,
+      "log_good": 4.5901
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 967.5,
+      "good": 1120.0,
+      "ratio": 1.1576,
+      "suggested_scalar": 0.0812,
+      "log_bad": 6.8747,
+      "log_good": 7.0211
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 138.5,
+      "good": 171.5,
+      "ratio": 1.2383,
+      "suggested_scalar": 0.1186,
+      "log_bad": 4.9309,
+      "log_good": 5.1446
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0046,
+      "good": 0.0095,
+      "ratio": 2.0652,
+      "suggested_scalar": 0.4024,
+      "log_bad": -5.3817,
+      "log_good": -4.6565
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2765,
+      "good": 0.2705,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.0122,
+      "log_bad": -1.2855,
+      "log_good": -1.3075
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 94.0,
+      "good": 109.0,
+      "ratio": 1.1596,
+      "suggested_scalar": 0.0821,
+      "log_bad": 4.5433,
+      "log_good": 4.6913
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 4.5,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0585,
+      "log_bad": 1.6094,
+      "log_good": 1.5041
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 82.0,
+      "good": 98.5,
+      "ratio": 1.2012,
+      "suggested_scalar": 0.1017,
+      "log_bad": 4.4067,
+      "log_good": 4.5901
+    },
+    "brevity.mean_sample_size": {
+      "bad": 82.0,
+      "good": 98.5,
+      "ratio": 1.2012,
+      "suggested_scalar": 0.1017,
+      "log_bad": 4.4067,
+      "log_good": 4.5901
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 421.0,
+      "good": 523.0,
+      "ratio": 1.2423,
+      "suggested_scalar": 0.1204,
+      "log_bad": 6.0426,
+      "log_good": 6.2596
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 245.0,
+      "good": 306.5,
+      "ratio": 1.251,
+      "suggested_scalar": 0.1243,
+      "log_bad": 5.5013,
+      "log_good": 5.7252
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 202.0,
+      "good": 264.5,
+      "ratio": 1.3094,
+      "suggested_scalar": 0.1496,
+      "log_bad": 5.3083,
+      "log_good": 5.5778
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.646,
+      "good": 2.9439,
+      "ratio": 1.1126,
+      "suggested_scalar": 0.0592,
+      "log_bad": 0.973,
+      "log_good": 1.0797
+    },
+    "halstead.mean_effort": {
+      "bad": 84325.7581,
+      "good": 119264.5381,
+      "ratio": 1.4143,
+      "suggested_scalar": 0.1923,
+      "log_bad": 11.3424,
+      "log_good": 11.6891
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8513,
+      "good": 0.8411,
+      "ratio": 0.988,
+      "suggested_scalar": -0.0067,
+      "log_bad": -0.161,
+      "log_good": -0.173
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 51.0,
+      "good": 65.5,
+      "ratio": 1.2843,
+      "suggested_scalar": 0.1388,
+      "log_bad": 3.9318,
+      "log_good": 4.1821
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 242.5,
+      "good": 297.5,
+      "ratio": 1.2268,
+      "suggested_scalar": 0.1134,
+      "log_bad": 5.491,
+      "log_good": 5.6954
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3887,
+      "good": 0.4042,
+      "ratio": 1.0399,
+      "suggested_scalar": 0.0217,
+      "log_bad": -0.9449,
+      "log_good": -0.9058
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.519,
+      "good": 6.9107,
+      "ratio": 0.9191,
+      "suggested_scalar": -0.0468,
+      "log_bad": 2.0174,
+      "log_good": 1.9331
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.241,
+      "good": 0.2514,
+      "ratio": 1.0432,
+      "suggested_scalar": 0.0234,
+      "log_bad": -1.423,
+      "log_good": -1.3807
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.2784,
+      "good": 5.3654,
+      "ratio": 0.8546,
+      "suggested_scalar": -0.0872,
+      "log_bad": 1.8371,
+      "log_good": 1.68
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 420.0,
+      "good": 522.0,
+      "ratio": 1.2429,
+      "suggested_scalar": 0.1206,
+      "log_bad": 6.0403,
+      "log_good": 6.2577
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 3.5,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.0855,
+      "log_bad": 1.0986,
+      "log_good": 1.2528
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 92.5,
+      "good": 103.0,
+      "ratio": 1.1135,
+      "suggested_scalar": 0.0597,
+      "log_bad": 4.5272,
+      "log_good": 4.6347
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4684.7643,
+      "good": 6625.8077,
+      "ratio": 1.4143,
+      "suggested_scalar": 0.1923,
+      "log_bad": 8.4521,
+      "log_good": 8.7987
+    },
+    "readability.mean_total_lines": {
+      "bad": 47.0,
+      "good": 55.0,
+      "ratio": 1.1702,
+      "suggested_scalar": 0.0872,
+      "log_bad": 3.8501,
+      "log_good": 4.0073
+    },
+    "indentation.mean_max_depth": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.1012,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2391.6579,
+      "good": 3080.0058,
+      "ratio": 1.2878,
+      "suggested_scalar": 0.1403,
+      "log_bad": 7.7797,
+      "log_good": 8.0327
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 607.5,
+      "good": 719.5,
+      "ratio": 1.1844,
+      "suggested_scalar": 0.0939,
+      "log_bad": 6.4094,
+      "log_good": 6.5786
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.3804,
+      "good": 37.5112,
+      "ratio": 1.0602,
+      "suggested_scalar": 0.0324,
+      "log_bad": 3.5662,
+      "log_good": 3.6246
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3317,
+      "good": 1.2429,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0383,
+      "log_bad": 0.2865,
+      "log_good": 0.2174
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.5,
+      "good": 6.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1596,
+      "log_bad": 1.5041,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 16.5,
+      "good": 27.0,
+      "ratio": 1.6364,
+      "suggested_scalar": 0.2733,
+      "log_bad": 2.8034,
+      "log_good": 3.2958
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.5,
+      "good": 1.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.225,
+      "log_bad": 0.4055,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6628,
+      "good": 0.7097,
+      "ratio": 1.0708,
+      "suggested_scalar": 0.0379,
+      "log_bad": -0.4113,
+      "log_good": -0.3429
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9683,
+      "good": 0.9692,
+      "ratio": 1.0009,
+      "suggested_scalar": 0.0005,
+      "log_bad": -0.0322,
+      "log_good": -0.0313
+    },
+    "halstead.mean_length": {
+      "bad": 381.0,
+      "good": 469.0,
+      "ratio": 1.231,
+      "suggested_scalar": 0.1153,
+      "log_bad": 5.9428,
+      "log_good": 6.1506
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.9,
+      "good": 14.325,
+      "ratio": 1.3142,
+      "suggested_scalar": 0.1516,
+      "log_bad": 2.3888,
+      "log_good": 2.662
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.3523,
+      "good": 6.6205,
+      "ratio": 1.0422,
+      "suggested_scalar": 0.0229,
+      "log_bad": 1.8488,
+      "log_good": 1.8902
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1417,
+      "good": 0.1481,
+      "ratio": 1.0452,
+      "suggested_scalar": 0.0245,
+      "log_bad": -1.954,
+      "log_good": -1.9099
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 34.2471,
+      "good": 37.4407,
+      "ratio": 1.0933,
+      "suggested_scalar": 0.0495,
+      "log_bad": 3.5336,
+      "log_good": 3.6228
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.5,
+      "good": 4.5,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.1394,
+      "log_bad": 1.2528,
+      "log_good": 1.5041
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 50.5,
+      "good": 65.5,
+      "ratio": 1.297,
+      "suggested_scalar": 0.1443,
+      "log_bad": 3.922,
+      "log_good": 4.1821
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5434,
+      "good": 0.5932,
+      "ratio": 1.0916,
+      "suggested_scalar": 0.0487,
+      "log_bad": -0.6099,
+      "log_good": -0.5222
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 47.0,
+      "good": 55.0,
+      "ratio": 1.1702,
+      "suggested_scalar": 0.0872,
+      "log_bad": 3.8501,
+      "log_good": 4.0073
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.5,
+      "good": 18.0,
+      "ratio": 0.9231,
+      "suggested_scalar": -0.0444,
+      "log_bad": 2.9704,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_prototype_modification": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 21.0,
+      "good": 23.0,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.0475,
+      "log_bad": 3.0445,
+      "log_good": 3.1355
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 12.0,
+      "good": 8.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.2118,
+      "log_bad": 2.4849,
+      "log_good": 2.0794
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.5739,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.005,
+      "good": 0.0052,
+      "ratio": 1.04,
+      "suggested_scalar": 0.0205,
+      "log_bad": -5.2983,
+      "log_good": -5.2591
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 2.3333,
+      "ratio": 2.3333,
+      "suggested_scalar": 0.4426,
+      "log_bad": 0.0,
+      "log_good": 0.8473
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7885,
+      "good": 0.7857,
+      "ratio": 0.9964,
+      "suggested_scalar": -0.0019,
+      "log_bad": -0.2376,
+      "log_good": -0.2412
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.005,
+      "good": 0.0052,
+      "ratio": 1.04,
+      "suggested_scalar": 0.0205,
+      "log_bad": -5.2983,
+      "log_good": -5.2591
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7941,
+      "good": 4.7339,
+      "ratio": 0.9874,
+      "suggested_scalar": -0.0066,
+      "log_bad": 1.5674,
+      "log_good": 1.5547
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 77.0,
+      "good": 71.0,
+      "ratio": 0.9221,
+      "suggested_scalar": -0.0424,
+      "log_bad": 4.3438,
+      "log_good": 4.2627
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.44,
+      "good": 0.3933,
+      "ratio": 0.8939,
+      "suggested_scalar": -0.0586,
+      "log_bad": -0.821,
+      "log_good": -0.9332
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 17.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.0581,
+      "log_bad": 2.9444,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.584,
+      "good": 0.56,
+      "ratio": 0.9589,
+      "suggested_scalar": -0.0219,
+      "log_bad": -0.5379,
+      "log_good": -0.5798
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.1538,
+      "good": 2.5357,
+      "ratio": 1.1773,
+      "suggested_scalar": 0.0853,
+      "log_bad": 0.7672,
+      "log_good": 0.9305
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 400.0,
+      "good": 386.0,
+      "ratio": 0.965,
+      "suggested_scalar": -0.0186,
+      "log_bad": 5.9915,
+      "log_good": 5.9558
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0007,
+      "good": 0.0007,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.2644,
+      "log_good": -7.2644
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0022,
+      "good": 0.0022,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.1193,
+      "log_good": -6.1193
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.095,
+      "good": 1.1047,
+      "ratio": 1.0089,
+      "suggested_scalar": 0.0046,
+      "log_bad": 0.0908,
+      "log_good": 0.0996
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 110.0,
+      "good": 105.0,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.0243,
+      "log_bad": 4.7005,
+      "log_good": 4.654
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 100.6038,
+      "good": 99.5513,
+      "ratio": 0.9895,
+      "suggested_scalar": -0.0055,
+      "log_bad": 4.6112,
+      "log_good": 4.6007
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6717,
+      "good": 0.6831,
+      "ratio": 1.017,
+      "suggested_scalar": 0.0088,
+      "log_bad": -0.3979,
+      "log_good": -0.3811
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.4599,
+      "good": 9.4717,
+      "ratio": 1.2697,
+      "suggested_scalar": 0.1247,
+      "log_bad": 2.0095,
+      "log_good": 2.2483
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1352.0,
+      "good": 1385.0,
+      "ratio": 1.0244,
+      "suggested_scalar": 0.0126,
+      "log_bad": 7.2093,
+      "log_good": 7.2335
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0385,
+      "good": 0.0357,
+      "ratio": 0.9273,
+      "suggested_scalar": -0.0394,
+      "log_bad": -3.2571,
+      "log_good": -3.3326
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7692,
+      "good": 0.75,
+      "ratio": 0.975,
+      "suggested_scalar": -0.0132,
+      "log_bad": -0.2624,
+      "log_good": -0.2877
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.6923,
+      "good": 6.8929,
+      "ratio": 0.8961,
+      "suggested_scalar": -0.0573,
+      "log_bad": 2.0402,
+      "log_good": 1.9305
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 6.0,
+      "good": 11.0,
+      "ratio": 1.8333,
+      "suggested_scalar": 0.3166,
+      "log_bad": 1.7918,
+      "log_good": 2.3979
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.284,
+      "good": 2.213,
+      "ratio": 0.9689,
+      "suggested_scalar": -0.0165,
+      "log_bad": 0.8259,
+      "log_good": 0.7943
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 73.0,
+      "good": 66.0,
+      "ratio": 0.9041,
+      "suggested_scalar": -0.0527,
+      "log_bad": 4.2905,
+      "log_good": 4.1897
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.957,
+      "good": 0.9505,
+      "ratio": 0.9932,
+      "suggested_scalar": -0.0036,
+      "log_bad": -0.044,
+      "log_good": -0.0508
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 23.0,
+      "ratio": 0.9583,
+      "suggested_scalar": -0.0222,
+      "log_bad": 3.1781,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6139,
+      "good": 0.6245,
+      "ratio": 1.0173,
+      "suggested_scalar": 0.0089,
+      "log_bad": -0.4879,
+      "log_good": -0.4708
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4171,
+      "good": 0.4115,
+      "ratio": 0.9866,
+      "suggested_scalar": -0.0071,
+      "log_bad": -0.8744,
+      "log_good": -0.8879
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.59,
+      "good": 2.6635,
+      "ratio": 1.0284,
+      "suggested_scalar": 0.0146,
+      "log_bad": 0.9517,
+      "log_good": 0.9796
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 398.0,
+      "good": 384.0,
+      "ratio": 0.9648,
+      "suggested_scalar": -0.0187,
+      "log_bad": 5.9865,
+      "log_good": 5.9506
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 46.0,
+      "ratio": 46.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 3.8286
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.8074,
+      "ratio": 0.9832,
+      "suggested_scalar": -0.0089,
+      "log_bad": 1.7761,
+      "log_good": 1.7591
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 10.0,
+      "good": 5.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.3621,
+      "log_bad": 2.3026,
+      "log_good": 1.6094
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.392,
+      "good": 1.4511,
+      "ratio": 1.0425,
+      "suggested_scalar": 0.0217,
+      "log_bad": 0.3307,
+      "log_good": 0.3723
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.2243,
+      "good": 5.1795,
+      "ratio": 0.9914,
+      "suggested_scalar": -0.0045,
+      "log_bad": 1.6533,
+      "log_good": 1.6447
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8116,
+      "good": 0.8152,
+      "ratio": 1.0044,
+      "suggested_scalar": 0.0023,
+      "log_bad": -0.2087,
+      "log_good": -0.2043
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1746,
+      "good": 0.1642,
+      "ratio": 0.9404,
+      "suggested_scalar": -0.0321,
+      "log_bad": -1.7453,
+      "log_good": -1.8067
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.7313,
+      "good": 3.0776,
+      "ratio": 1.1268,
+      "suggested_scalar": 0.0624,
+      "log_bad": 1.0048,
+      "log_good": 1.1242
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 286.0,
+      "good": 284.0,
+      "ratio": 0.993,
+      "suggested_scalar": -0.0037,
+      "log_bad": 5.656,
+      "log_good": 5.649
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 27.0,
+      "good": 24.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0615,
+      "log_bad": 3.2958,
+      "log_good": 3.1781
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8063,
+      "good": 0.7667,
+      "ratio": 0.9509,
+      "suggested_scalar": -0.0263,
+      "log_bad": -0.2153,
+      "log_good": -0.2657
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 78.0,
+      "good": 71.0,
+      "ratio": 0.9103,
+      "suggested_scalar": -0.0491,
+      "log_bad": 4.3567,
+      "log_good": 4.2627
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 595.0,
+      "good": 602.0,
+      "ratio": 1.0118,
+      "suggested_scalar": 0.0061,
+      "log_bad": 6.3886,
+      "log_good": 6.4003
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 133.0,
+      "good": 133.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.8903,
+      "log_good": 4.8903
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0125,
+      "good": 0.0104,
+      "ratio": 0.832,
+      "suggested_scalar": -0.0961,
+      "log_bad": -4.382,
+      "log_good": -4.5659
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2475,
+      "good": 0.2668,
+      "ratio": 1.078,
+      "suggested_scalar": 0.0392,
+      "log_bad": -1.3963,
+      "log_good": -1.3213
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 75.0,
+      "good": 79.0,
+      "ratio": 1.0533,
+      "suggested_scalar": 0.0271,
+      "log_bad": 4.3175,
+      "log_good": 4.3694
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.5739,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 78.0,
+      "good": 71.0,
+      "ratio": 0.9103,
+      "suggested_scalar": -0.0491,
+      "log_bad": 4.3567,
+      "log_good": 4.2627
+    },
+    "brevity.mean_sample_size": {
+      "bad": 78.0,
+      "good": 71.0,
+      "ratio": 0.9103,
+      "suggested_scalar": -0.0491,
+      "log_bad": 4.3567,
+      "log_good": 4.2627
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 400.0,
+      "good": 386.0,
+      "ratio": 0.965,
+      "suggested_scalar": -0.0186,
+      "log_bad": 5.9915,
+      "log_good": 5.9558
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 244.0,
+      "good": 232.0,
+      "ratio": 0.9508,
+      "suggested_scalar": -0.0263,
+      "log_bad": 5.4972,
+      "log_good": 5.4467
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 206.0,
+      "good": 201.0,
+      "ratio": 0.9757,
+      "suggested_scalar": -0.0128,
+      "log_bad": 5.3279,
+      "log_good": 5.3033
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.2806,
+      "good": 2.6006,
+      "ratio": 1.1403,
+      "suggested_scalar": 0.0686,
+      "log_bad": 0.8244,
+      "log_good": 0.9557
+    },
+    "halstead.mean_effort": {
+      "bad": 72843.2349,
+      "good": 73288.7145,
+      "ratio": 1.0061,
+      "suggested_scalar": 0.0032,
+      "log_bad": 11.1961,
+      "log_good": 11.2022
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8312,
+      "good": 0.8422,
+      "ratio": 1.0132,
+      "suggested_scalar": 0.0069,
+      "log_bad": -0.1849,
+      "log_good": -0.1717
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 53.0,
+      "good": 48.0,
+      "ratio": 0.9057,
+      "suggested_scalar": -0.0518,
+      "log_bad": 3.9703,
+      "log_good": 3.8712
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 253.0,
+      "good": 241.0,
+      "ratio": 0.9526,
+      "suggested_scalar": -0.0254,
+      "log_bad": 5.5334,
+      "log_good": 5.4848
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4182,
+      "good": 0.381,
+      "ratio": 0.911,
+      "suggested_scalar": -0.0487,
+      "log_bad": -0.8718,
+      "log_good": -0.965
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.4091,
+      "good": 5.7333,
+      "ratio": 1.0599,
+      "suggested_scalar": 0.0304,
+      "log_bad": 1.6881,
+      "log_good": 1.7463
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1746,
+      "good": 0.1642,
+      "ratio": 0.9404,
+      "suggested_scalar": -0.0321,
+      "log_bad": -1.7453,
+      "log_good": -1.8067
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.5998,
+      "good": 3.022,
+      "ratio": 0.8395,
+      "suggested_scalar": -0.0914,
+      "log_bad": 1.2809,
+      "log_good": 1.1059
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 399.0,
+      "good": 385.0,
+      "ratio": 0.9649,
+      "suggested_scalar": -0.0187,
+      "log_bad": 5.989,
+      "log_good": 5.9532
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 54.0,
+      "good": 58.0,
+      "ratio": 1.0741,
+      "suggested_scalar": 0.0373,
+      "log_bad": 3.989,
+      "log_good": 4.0604
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4046.8464,
+      "good": 4071.5952,
+      "ratio": 1.0061,
+      "suggested_scalar": 0.0032,
+      "log_bad": 8.3057,
+      "log_good": 8.3118
+    },
+    "readability.mean_total_lines": {
+      "bad": 52.0,
+      "good": 56.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0387,
+      "log_bad": 3.9512,
+      "log_good": 4.0254
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.2118,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2418.9796,
+      "good": 2300.0054,
+      "ratio": 0.9508,
+      "suggested_scalar": -0.0263,
+      "log_bad": 7.7911,
+      "log_good": 7.7407
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 522.0,
+      "good": 520.0,
+      "ratio": 0.9962,
+      "suggested_scalar": -0.002,
+      "log_bad": 6.2577,
+      "log_good": 6.2538
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 24.7885,
+      "good": 23.5357,
+      "ratio": 0.9495,
+      "suggested_scalar": -0.0271,
+      "log_bad": 3.2104,
+      "log_good": 3.1585
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1634,
+      "good": 1.1854,
+      "ratio": 1.0189,
+      "suggested_scalar": 0.0098,
+      "log_bad": 0.1513,
+      "log_good": 0.1701
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 37.0,
+      "good": 29.0,
+      "ratio": 0.7838,
+      "suggested_scalar": -0.1273,
+      "log_bad": 3.6109,
+      "log_good": 3.3673
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8112,
+      "good": 0.7958,
+      "ratio": 0.981,
+      "suggested_scalar": -0.01,
+      "log_bad": -0.2092,
+      "log_good": -0.2284
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9756,
+      "good": 0.9873,
+      "ratio": 1.012,
+      "suggested_scalar": 0.0062,
+      "log_bad": -0.0247,
+      "log_good": -0.0128
+    },
+    "halstead.mean_length": {
+      "bad": 386.0,
+      "good": 374.0,
+      "ratio": 0.9689,
+      "suggested_scalar": -0.0165,
+      "log_bad": 5.9558,
+      "log_good": 5.9243
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 22.3333,
+      "ratio": 22.3333,
+      "suggested_scalar": 1.6225,
+      "log_bad": 0.0,
+      "log_good": 3.1061
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2854,
+      "good": 6.1497,
+      "ratio": 0.9784,
+      "suggested_scalar": -0.0114,
+      "log_bad": 1.8382,
+      "log_good": 1.8164
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1805,
+      "good": 0.1675,
+      "ratio": 0.928,
+      "suggested_scalar": -0.039,
+      "log_bad": -1.712,
+      "log_good": -1.7868
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.1132,
+      "good": 31.8646,
+      "ratio": 1.0582,
+      "suggested_scalar": 0.0295,
+      "log_bad": 3.405,
+      "log_good": 3.4615
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 46.0,
+      "good": 40.0,
+      "ratio": 0.8696,
+      "suggested_scalar": -0.073,
+      "log_bad": 3.8286,
+      "log_good": 3.6889
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6359,
+      "good": 0.607,
+      "ratio": 0.9546,
+      "suggested_scalar": -0.0243,
+      "log_bad": -0.4527,
+      "log_good": -0.4992
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 52.0,
+      "good": 56.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0387,
+      "log_bad": 3.9512,
+      "log_good": 4.0254
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 11.0,
+      "good": 18.0,
+      "ratio": 1.6364,
+      "suggested_scalar": 0.2573,
+      "log_bad": 2.3979,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.error_string_not_capitalized": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0256,
+      "good": 0.0291,
+      "ratio": 1.1367,
+      "suggested_scalar": 0.0954,
+      "log_bad": -3.6652,
+      "log_good": -3.537
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8182,
+      "good": 0.8049,
+      "ratio": 0.9837,
+      "suggested_scalar": -0.0122,
+      "log_bad": -0.2006,
+      "log_good": -0.217
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0256,
+      "good": 0.0291,
+      "ratio": 1.1367,
+      "suggested_scalar": 0.0954,
+      "log_bad": -3.6652,
+      "log_good": -3.537
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.9329,
+      "good": 4.8537,
+      "ratio": 0.9839,
+      "suggested_scalar": -0.0121,
+      "log_bad": 1.5959,
+      "log_good": 1.5797
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 92.0,
+      "good": 67.0,
+      "ratio": 0.7283,
+      "suggested_scalar": -0.2362,
+      "log_bad": 4.5218,
+      "log_good": 4.2047
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5956,
+      "good": 0.417,
+      "ratio": 0.7001,
+      "suggested_scalar": -0.2655,
+      "log_bad": -0.5182,
+      "log_good": -0.8747
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 15.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.0932,
+      "log_bad": 2.8332,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7378,
+      "good": 0.6592,
+      "ratio": 0.8935,
+      "suggested_scalar": -0.0839,
+      "log_bad": -0.3041,
+      "log_good": -0.4167
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.8409,
+      "good": 0.7805,
+      "ratio": 0.9282,
+      "suggested_scalar": -0.0555,
+      "log_bad": -0.1733,
+      "log_good": -0.2478
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 312.0,
+      "good": 275.0,
+      "ratio": 0.8814,
+      "suggested_scalar": -0.094,
+      "log_bad": 5.743,
+      "log_good": 5.6168
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0016,
+      "good": 0.0018,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0877,
+      "log_bad": -6.4378,
+      "log_good": -6.32
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0682,
+      "good": 1.0,
+      "ratio": 14.6628,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.6853,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8604,
+      "good": 0.8896,
+      "ratio": 1.0339,
+      "suggested_scalar": 0.0249,
+      "log_bad": -0.1504,
+      "log_good": -0.117
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 124.0,
+      "good": 109.0,
+      "ratio": 0.879,
+      "suggested_scalar": -0.096,
+      "log_bad": 4.8203,
+      "log_good": 4.6913
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 105.5265,
+      "good": 103.0896,
+      "ratio": 0.9769,
+      "suggested_scalar": -0.0174,
+      "log_bad": 4.659,
+      "log_good": 4.6356
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5048,
+      "good": 0.562,
+      "ratio": 1.1133,
+      "suggested_scalar": 0.0799,
+      "log_bad": -0.6836,
+      "log_good": -0.5763
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 12.0574,
+      "good": 14.5981,
+      "ratio": 1.2107,
+      "suggested_scalar": 0.1424,
+      "log_bad": 2.4897,
+      "log_good": 2.6809
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1285.0,
+      "good": 1083.0,
+      "ratio": 0.8428,
+      "suggested_scalar": -0.1274,
+      "log_bad": 7.1585,
+      "log_good": 6.9875
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2045,
+      "good": 0.122,
+      "ratio": 0.5966,
+      "suggested_scalar": -0.3847,
+      "log_bad": -1.5872,
+      "log_good": -2.1037
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7955,
+      "good": 0.7805,
+      "ratio": 0.9811,
+      "suggested_scalar": -0.0142,
+      "log_bad": -0.2288,
+      "log_good": -0.2478
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.0909,
+      "good": 6.7073,
+      "ratio": 0.9459,
+      "suggested_scalar": -0.0414,
+      "log_bad": 1.9588,
+      "log_good": 1.9032
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.5429,
+      "good": 0.5128,
+      "ratio": 0.9446,
+      "suggested_scalar": -0.0425,
+      "log_bad": -0.6108,
+      "log_good": -0.6679
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 79.0,
+      "good": 73.0,
+      "ratio": 0.9241,
+      "suggested_scalar": -0.0588,
+      "log_bad": 4.3694,
+      "log_good": 4.2905
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9416,
+      "good": 0.9078,
+      "ratio": 0.9641,
+      "suggested_scalar": -0.0272,
+      "log_bad": -0.0602,
+      "log_good": -0.0967
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 24.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1662,
+      "log_bad": 3.4012,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5346,
+      "good": 0.5697,
+      "ratio": 1.0657,
+      "suggested_scalar": 0.0474,
+      "log_bad": -0.6262,
+      "log_good": -0.5626
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3258,
+      "good": 0.37,
+      "ratio": 1.1357,
+      "suggested_scalar": 0.0948,
+      "log_bad": -1.1215,
+      "log_good": -0.9943
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.1488,
+      "good": 2.324,
+      "ratio": 1.0815,
+      "suggested_scalar": 0.0584,
+      "log_bad": 0.7649,
+      "log_good": 0.8433
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 310.0,
+      "good": 273.0,
+      "ratio": 0.8806,
+      "suggested_scalar": -0.0947,
+      "log_bad": 5.7366,
+      "log_good": 5.6095
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 22.0,
+      "good": 20.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.071,
+      "log_bad": 3.091,
+      "log_good": 2.9957
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0096,
+      "good": 0.0255,
+      "ratio": 2.6563,
+      "suggested_scalar": 0.7276,
+      "log_bad": -4.646,
+      "log_good": -3.6691
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.7814,
+      "ratio": 0.971,
+      "suggested_scalar": -0.0219,
+      "log_bad": 1.7841,
+      "log_good": 1.7546
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 38.0,
+      "good": 29.0,
+      "ratio": 0.7632,
+      "suggested_scalar": -0.2013,
+      "log_bad": 3.6376,
+      "log_good": 3.3673
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2048,
+      "good": 1.1879,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0105,
+      "log_bad": 0.1863,
+      "log_good": 0.1722
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9973,
+      "good": 5.654,
+      "ratio": 0.9428,
+      "suggested_scalar": -0.0439,
+      "log_bad": 1.7913,
+      "log_good": 1.7324
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8285,
+      "good": 0.8395,
+      "ratio": 1.0133,
+      "suggested_scalar": 0.0098,
+      "log_bad": -0.1881,
+      "log_good": -0.1749
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1852,
+      "good": 0.1961,
+      "ratio": 1.0589,
+      "suggested_scalar": 0.0426,
+      "log_bad": -1.6863,
+      "log_good": -1.6291
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.4724,
+      "good": 3.8207,
+      "ratio": 1.1003,
+      "suggested_scalar": 0.0712,
+      "log_bad": 1.2448,
+      "log_good": 1.3404
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 253.0,
+      "good": 213.0,
+      "ratio": 0.8419,
+      "suggested_scalar": -0.1282,
+      "log_bad": 5.5334,
+      "log_good": 5.3613
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5762,
+      "good": 0.455,
+      "ratio": 0.7897,
+      "suggested_scalar": -0.1759,
+      "log_bad": -0.5513,
+      "log_good": -0.7875
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 104.0,
+      "good": 76.0,
+      "ratio": 0.7308,
+      "suggested_scalar": -0.2336,
+      "log_bad": 4.6444,
+      "log_good": 4.3307
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 717.0,
+      "good": 602.0,
+      "ratio": 0.8396,
+      "suggested_scalar": -0.1302,
+      "log_bad": 6.5751,
+      "log_good": 6.4003
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 119.0,
+      "good": 99.0,
+      "ratio": 0.8319,
+      "suggested_scalar": -0.137,
+      "log_bad": 4.7791,
+      "log_good": 4.5951
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2051,
+      "good": 0.2364,
+      "ratio": 1.1526,
+      "suggested_scalar": 0.1058,
+      "log_bad": -1.5843,
+      "log_good": -1.4422
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 61.0,
+      "good": 58.0,
+      "ratio": 0.9508,
+      "suggested_scalar": -0.0376,
+      "log_bad": 4.1109,
+      "log_good": 4.0604
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 104.0,
+      "good": 76.0,
+      "ratio": 0.7308,
+      "suggested_scalar": -0.2336,
+      "log_bad": 4.6444,
+      "log_good": 4.3307
+    },
+    "brevity.mean_sample_size": {
+      "bad": 104.0,
+      "good": 76.0,
+      "ratio": 0.7308,
+      "suggested_scalar": -0.2336,
+      "log_bad": 4.6444,
+      "log_good": 4.3307
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 312.0,
+      "good": 275.0,
+      "ratio": 0.8814,
+      "suggested_scalar": -0.094,
+      "log_bad": 5.743,
+      "log_good": 5.6168
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 142.0,
+      "good": 130.0,
+      "ratio": 0.9155,
+      "suggested_scalar": -0.0658,
+      "log_bad": 4.9558,
+      "log_good": 4.8675
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 215.0,
+      "good": 178.0,
+      "ratio": 0.8279,
+      "suggested_scalar": -0.1407,
+      "log_bad": 5.3706,
+      "log_good": 5.1818
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.7107,
+      "good": 2.17,
+      "ratio": 1.2685,
+      "suggested_scalar": 0.1771,
+      "log_bad": 0.5369,
+      "log_good": 0.7747
+    },
+    "halstead.mean_effort": {
+      "bad": 49771.0951,
+      "good": 37708.5033,
+      "ratio": 0.7576,
+      "suggested_scalar": -0.2067,
+      "log_bad": 10.8152,
+      "log_good": 10.5376
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8951,
+      "good": 0.9049,
+      "ratio": 1.0109,
+      "suggested_scalar": 0.0081,
+      "log_bad": -0.1108,
+      "log_good": -0.0999
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 62.0,
+      "good": 43.0,
+      "ratio": 0.6935,
+      "suggested_scalar": -0.2725,
+      "log_bad": 4.1271,
+      "log_good": 3.7612
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 146.0,
+      "good": 126.0,
+      "ratio": 0.863,
+      "suggested_scalar": -0.1097,
+      "log_bad": 4.9836,
+      "log_good": 4.8363
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5242,
+      "good": 0.4037,
+      "ratio": 0.7701,
+      "suggested_scalar": -0.1945,
+      "log_bad": -0.6459,
+      "log_good": -0.9071
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.7823,
+      "good": 5.5229,
+      "ratio": 0.9551,
+      "suggested_scalar": -0.0342,
+      "log_bad": 1.7548,
+      "log_good": 1.7089
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1852,
+      "good": 0.1961,
+      "ratio": 1.0589,
+      "suggested_scalar": 0.0426,
+      "log_bad": -1.6863,
+      "log_good": -1.6291
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.7831,
+      "good": 4.0718,
+      "ratio": 1.0763,
+      "suggested_scalar": 0.0548,
+      "log_bad": 1.3305,
+      "log_good": 1.4041
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 311.0,
+      "good": 274.0,
+      "ratio": 0.881,
+      "suggested_scalar": -0.0943,
+      "log_bad": 5.7398,
+      "log_good": 5.6131
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 44.0,
+      "good": 41.0,
+      "ratio": 0.9318,
+      "suggested_scalar": -0.0526,
+      "log_bad": 3.7842,
+      "log_good": 3.7136
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2765.0608,
+      "good": 2094.9168,
+      "ratio": 0.7576,
+      "suggested_scalar": -0.2067,
+      "log_bad": 7.9248,
+      "log_good": 7.6473
+    },
+    "readability.mean_total_lines": {
+      "bad": 44.0,
+      "good": 41.0,
+      "ratio": 0.9318,
+      "suggested_scalar": -0.0526,
+      "log_bad": 3.7842,
+      "log_good": 3.7136
+    },
+    "indentation.mean_max_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "halstead.mean_volume": {
+      "bad": 1728.7439,
+      "good": 1364.8701,
+      "ratio": 0.7895,
+      "suggested_scalar": -0.176,
+      "log_bad": 7.4552,
+      "log_good": 7.2188
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 598.0,
+      "good": 466.0,
+      "ratio": 0.7793,
+      "suggested_scalar": -0.1858,
+      "log_bad": 6.3936,
+      "log_good": 6.1442
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 27.8864,
+      "good": 25.1707,
+      "ratio": 0.9026,
+      "suggested_scalar": -0.0763,
+      "log_bad": 3.3281,
+      "log_good": 3.2257
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1124,
+      "good": 1.1458,
+      "ratio": 1.03,
+      "suggested_scalar": 0.022,
+      "log_bad": 0.1065,
+      "log_good": 0.1361
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 22.0,
+      "good": 12.0,
+      "ratio": 0.5455,
+      "suggested_scalar": -0.4514,
+      "log_bad": 3.091,
+      "log_good": 2.4849
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.8182,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8261,
+      "good": 0.8075,
+      "ratio": 0.9775,
+      "suggested_scalar": -0.017,
+      "log_bad": -0.191,
+      "log_good": -0.2138
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9891,
+      "good": 0.9768,
+      "ratio": 0.9876,
+      "suggested_scalar": -0.0093,
+      "log_bad": -0.011,
+      "log_good": -0.0235
+    },
+    "halstead.mean_length": {
+      "bad": 265.0,
+      "good": 225.0,
+      "ratio": 0.8491,
+      "suggested_scalar": -0.1219,
+      "log_bad": 5.5797,
+      "log_good": 5.4161
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 16.0,
+      "good": 14.5,
+      "ratio": 0.9063,
+      "suggested_scalar": -0.0733,
+      "log_bad": 2.7726,
+      "log_good": 2.6741
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7004,
+      "good": 6.2479,
+      "ratio": 0.9325,
+      "suggested_scalar": -0.0521,
+      "log_bad": 1.9022,
+      "log_good": 1.8322
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1109,
+      "good": 0.12,
+      "ratio": 1.0821,
+      "suggested_scalar": 0.0587,
+      "log_bad": -2.1991,
+      "log_good": -2.1203
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 28.7903,
+      "good": 27.6279,
+      "ratio": 0.9596,
+      "suggested_scalar": -0.0307,
+      "log_bad": 3.36,
+      "log_good": 3.3188
+    },
+    "branching.mean_branch_count": {
+      "bad": 9.0,
+      "good": 5.0,
+      "ratio": 0.5556,
+      "suggested_scalar": -0.4378,
+      "log_bad": 2.1972,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 65.0,
+      "good": 44.0,
+      "ratio": 0.6769,
+      "suggested_scalar": -0.2906,
+      "log_bad": 4.1744,
+      "log_good": 3.7842
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7163,
+      "good": 0.6742,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0451,
+      "log_bad": -0.3337,
+      "log_good": -0.3942
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 44.0,
+      "good": 41.0,
+      "ratio": 0.9318,
+      "suggested_scalar": -0.0526,
+      "log_bad": 3.7842,
+      "log_good": 3.7136
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "file_structure.line_count_under_300": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 108.0,
+      "good": 63.0,
+      "ratio": 0.5833,
+      "suggested_scalar": -0.1378,
+      "log_bad": 4.6821,
+      "log_good": 4.1431
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1036,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0065,
+      "good": 0.0066,
+      "ratio": 1.0154,
+      "suggested_scalar": 0.0039,
+      "log_bad": -5.036,
+      "log_good": -5.0207
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5833,
+      "good": 1.1,
+      "ratio": 0.6948,
+      "suggested_scalar": -0.0931,
+      "log_bad": 0.4595,
+      "log_good": 0.0953
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.6615,
+      "good": 0.8103,
+      "ratio": 1.2249,
+      "suggested_scalar": 0.0519,
+      "log_bad": -0.4132,
+      "log_good": -0.2104
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0065,
+      "good": 0.0066,
+      "ratio": 1.0154,
+      "suggested_scalar": 0.0039,
+      "log_bad": -5.036,
+      "log_good": -5.0207
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6662,
+      "good": 4.5365,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.0072,
+      "log_bad": 1.5403,
+      "log_good": 1.5122
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 168.0,
+      "good": 70.0,
+      "ratio": 0.4167,
+      "suggested_scalar": -0.2238,
+      "log_bad": 5.124,
+      "log_good": 4.2485
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4978,
+      "good": 0.2949,
+      "ratio": 0.5924,
+      "suggested_scalar": -0.1338,
+      "log_bad": -0.6976,
+      "log_good": -1.2211
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 15.0,
+      "ratio": 0.7895,
+      "suggested_scalar": -0.0604,
+      "log_bad": 2.9444,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5427,
+      "good": 0.4148,
+      "ratio": 0.7643,
+      "suggested_scalar": -0.0687,
+      "log_bad": -0.6112,
+      "log_good": -0.88
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.6769,
+      "good": 3.8448,
+      "ratio": 1.0457,
+      "suggested_scalar": 0.0114,
+      "log_bad": 1.3021,
+      "log_good": 1.3467
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1233.0,
+      "good": 608.0,
+      "ratio": 0.4931,
+      "suggested_scalar": -0.1807,
+      "log_bad": 7.1172,
+      "log_good": 6.4102
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0004,
+      "good": 1.0,
+      "ratio": 2.5e3,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.824,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.2078,
+      "good": 1.2572,
+      "ratio": 1.0409,
+      "suggested_scalar": 0.0102,
+      "log_bad": 0.1888,
+      "log_good": 0.2289
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 366.0,
+      "good": 189.0,
+      "ratio": 0.5164,
+      "suggested_scalar": -0.1689,
+      "log_bad": 5.9026,
+      "log_good": 5.2417
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 87.77,
+      "good": 92.9125,
+      "ratio": 1.0586,
+      "suggested_scalar": 0.0146,
+      "log_bad": 4.4747,
+      "log_good": 4.5317
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7411,
+      "good": 0.832,
+      "ratio": 1.1227,
+      "suggested_scalar": 0.0296,
+      "log_bad": -0.2996,
+      "log_good": -0.1839
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 18.6363,
+      "good": 19.0421,
+      "ratio": 1.0218,
+      "suggested_scalar": 0.0055,
+      "log_bad": 2.9251,
+      "log_good": 2.9467
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 5273.0,
+      "good": 2176.0,
+      "ratio": 0.4127,
+      "suggested_scalar": -0.2263,
+      "log_bad": 8.5704,
+      "log_good": 7.6852
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2692,
+      "good": 0.1034,
+      "ratio": 0.3841,
+      "suggested_scalar": -0.2446,
+      "log_bad": -1.3123,
+      "log_good": -2.2692
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6231,
+      "good": 0.7759,
+      "ratio": 1.2452,
+      "suggested_scalar": 0.0561,
+      "log_bad": -0.473,
+      "log_good": -0.2537
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.4846,
+      "good": 10.4828,
+      "ratio": 1.1052,
+      "suggested_scalar": 0.0256,
+      "log_bad": 2.2497,
+      "log_good": 2.3497
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 21.0,
+      "good": 2.0,
+      "ratio": 0.0952,
+      "suggested_scalar": -0.6011,
+      "log_bad": 3.0445,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.0649,
+      "good": 5.9242,
+      "ratio": 1.9329,
+      "suggested_scalar": 0.1685,
+      "log_bad": 1.12,
+      "log_good": 1.779
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 325.0,
+      "good": 157.0,
+      "ratio": 0.4831,
+      "suggested_scalar": -0.186,
+      "log_bad": 5.7838,
+      "log_good": 5.0562
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9696,
+      "good": 0.9444,
+      "ratio": 0.974,
+      "suggested_scalar": -0.0067,
+      "log_bad": -0.0309,
+      "log_good": -0.0572
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 33.0,
+      "good": 24.0,
+      "ratio": 0.7273,
+      "suggested_scalar": -0.0814,
+      "log_bad": 3.4965,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.7307,
+      "good": 0.7233,
+      "ratio": 0.9899,
+      "suggested_scalar": -0.0026,
+      "log_bad": -0.3138,
+      "log_good": -0.3239
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5443,
+      "good": 0.6634,
+      "ratio": 1.2188,
+      "suggested_scalar": 0.0506,
+      "log_bad": -0.6083,
+      "log_good": -0.4104
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.7134,
+      "good": 3.6146,
+      "ratio": 0.9734,
+      "suggested_scalar": -0.0069,
+      "log_bad": 1.3119,
+      "log_good": 1.285
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1231.0,
+      "good": 606.0,
+      "ratio": 0.4923,
+      "suggested_scalar": -0.1812,
+      "log_bad": 7.1156,
+      "log_good": 6.4069
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 12.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0222,
+      "log_bad": 2.3979,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0365,
+      "good": 0.0164,
+      "ratio": 0.4493,
+      "suggested_scalar": -0.2045,
+      "log_bad": -3.3104,
+      "log_good": -4.1105
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0444,
+      "good": 5.4919,
+      "ratio": 0.9086,
+      "suggested_scalar": -0.0245,
+      "log_bad": 1.7991,
+      "log_good": 1.7033
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 20.0,
+      "good": 30.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1036,
+      "log_bad": 2.9957,
+      "log_good": 3.4012
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.618,
+      "good": 0.7132,
+      "ratio": 1.154,
+      "suggested_scalar": 0.0366,
+      "log_bad": -0.4813,
+      "log_good": -0.338
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6651,
+      "good": 5.109,
+      "ratio": 0.9018,
+      "suggested_scalar": -0.0264,
+      "log_bad": 1.7343,
+      "log_good": 1.631
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.772,
+      "good": 0.826,
+      "ratio": 1.0699,
+      "suggested_scalar": 0.0173,
+      "log_bad": -0.2588,
+      "log_good": -0.1912
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 0.1471,
+      "ratio": 0.1471,
+      "suggested_scalar": -0.4899,
+      "log_bad": 0.0,
+      "log_good": -1.9166
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.317,
+      "good": 4.3637,
+      "ratio": 1.0108,
+      "suggested_scalar": 0.0028,
+      "log_bad": 1.4626,
+      "log_good": 1.4733
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 5.0,
+      "good": 1.0,
+      "ratio": 0.2,
+      "suggested_scalar": -0.4114,
+      "log_bad": 1.6094,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 715.0,
+      "good": 300.0,
+      "ratio": 0.4196,
+      "suggested_scalar": -0.222,
+      "log_bad": 6.5723,
+      "log_good": 5.7038
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 35.0,
+      "good": 9.0,
+      "ratio": 0.2571,
+      "suggested_scalar": -0.3472,
+      "log_bad": 3.5553,
+      "log_good": 2.1972
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 2.8682,
+      "good": 1.183,
+      "ratio": 0.4125,
+      "suggested_scalar": -0.2264,
+      "log_bad": 1.0537,
+      "log_good": 0.1681
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 177.0,
+      "good": 79.0,
+      "ratio": 0.4463,
+      "suggested_scalar": -0.2062,
+      "log_bad": 5.1761,
+      "log_good": 4.3694
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 3020.0,
+      "good": 1.2e3,
+      "ratio": 0.3974,
+      "suggested_scalar": -0.2359,
+      "log_bad": 8.013,
+      "log_good": 7.0901
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 380.0,
+      "good": 183.0,
+      "ratio": 0.4816,
+      "suggested_scalar": -0.1868,
+      "log_bad": 5.9402,
+      "log_good": 5.2095
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0219,
+      "good": 0.0082,
+      "ratio": 0.3744,
+      "suggested_scalar": -0.2511,
+      "log_bad": -3.8213,
+      "log_good": -4.8036
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2936,
+      "good": 0.2796,
+      "ratio": 0.9523,
+      "suggested_scalar": -0.0125,
+      "log_bad": -1.2255,
+      "log_good": -1.2744
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 170.0,
+      "good": 100.0,
+      "ratio": 0.5882,
+      "suggested_scalar": -0.1356,
+      "log_bad": 5.1358,
+      "log_good": 4.6052
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 36.0,
+      "good": 10.0,
+      "ratio": 0.2778,
+      "suggested_scalar": -0.3274,
+      "log_bad": 3.5835,
+      "log_good": 2.3026
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 177.0,
+      "good": 79.0,
+      "ratio": 0.4463,
+      "suggested_scalar": -0.2062,
+      "log_bad": 5.1761,
+      "log_good": 4.3694
+    },
+    "brevity.mean_sample_size": {
+      "bad": 177.0,
+      "good": 79.0,
+      "ratio": 0.4463,
+      "suggested_scalar": -0.2062,
+      "log_bad": 5.1761,
+      "log_good": 4.3694
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1233.0,
+      "good": 608.0,
+      "ratio": 0.4931,
+      "suggested_scalar": -0.1807,
+      "log_bad": 7.1172,
+      "log_good": 6.4102
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 661.0,
+      "good": 367.0,
+      "ratio": 0.5552,
+      "suggested_scalar": -0.1504,
+      "log_bad": 6.4938,
+      "log_good": 5.9054
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 489.0,
+      "good": 202.0,
+      "ratio": 0.4131,
+      "suggested_scalar": -0.226,
+      "log_bad": 6.1924,
+      "log_good": 5.3083
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0041,
+      "good": 1.0,
+      "ratio": 243.9024,
+      "suggested_scalar": 1.4051,
+      "log_bad": -5.4968,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 3.5775,
+      "good": 5.2451,
+      "ratio": 1.4661,
+      "suggested_scalar": 0.0978,
+      "log_bad": 1.2747,
+      "log_good": 1.6573
+    },
+    "halstead.mean_effort": {
+      "bad": 399638.5363,
+      "good": 169419.2454,
+      "ratio": 0.4239,
+      "suggested_scalar": -0.2194,
+      "log_bad": 12.8983,
+      "log_good": 12.0401
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.7586,
+      "good": 0.8105,
+      "ratio": 1.0684,
+      "suggested_scalar": 0.0169,
+      "log_bad": -0.2763,
+      "log_good": -0.2101
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 135.0,
+      "good": 46.0,
+      "ratio": 0.3407,
+      "suggested_scalar": -0.2752,
+      "log_bad": 4.9053,
+      "log_good": 3.8286
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 784.0,
+      "good": 396.0,
+      "ratio": 0.5051,
+      "suggested_scalar": -0.1746,
+      "log_bad": 6.6644,
+      "log_good": 5.9814
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3634,
+      "good": 0.2698,
+      "ratio": 0.7424,
+      "suggested_scalar": -0.0761,
+      "log_bad": -1.0123,
+      "log_good": -1.3101
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.2514,
+      "good": 6.3492,
+      "ratio": 0.7695,
+      "suggested_scalar": -0.067,
+      "log_bad": 2.1104,
+      "log_good": 1.8483
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 0.1471,
+      "ratio": 0.1471,
+      "suggested_scalar": -0.4899,
+      "log_bad": 0.0,
+      "log_good": -1.9166
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.5768,
+      "good": 5.1931,
+      "ratio": 1.1347,
+      "suggested_scalar": 0.0323,
+      "log_bad": 1.521,
+      "log_good": 1.6473
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1232.0,
+      "good": 607.0,
+      "ratio": 0.4927,
+      "suggested_scalar": -0.1809,
+      "log_bad": 7.1164,
+      "log_good": 6.4085
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 10.0,
+      "good": 4.0,
+      "ratio": 0.4,
+      "suggested_scalar": -0.2342,
+      "log_bad": 2.3026,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 154.0,
+      "good": 96.0,
+      "ratio": 0.6234,
+      "suggested_scalar": -0.1208,
+      "log_bad": 5.037,
+      "log_good": 4.5643
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 22202.1409,
+      "good": 9412.1803,
+      "ratio": 0.4239,
+      "suggested_scalar": -0.2194,
+      "log_bad": 10.0079,
+      "log_good": 9.1498
+    },
+    "readability.mean_total_lines": {
+      "bad": 130.0,
+      "good": 58.0,
+      "ratio": 0.4462,
+      "suggested_scalar": -0.2063,
+      "log_bad": 4.8675,
+      "log_good": 4.0604
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 9.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0301,
+      "log_bad": 2.0794,
+      "log_good": 2.1972
+    },
+    "halstead.mean_volume": {
+      "bad": 8604.6575,
+      "good": 3548.8549,
+      "ratio": 0.4124,
+      "suggested_scalar": -0.2264,
+      "log_bad": 9.0601,
+      "log_good": 8.1744
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1420.0,
+      "good": 602.0,
+      "ratio": 0.4239,
+      "suggested_scalar": -0.2194,
+      "log_bad": 7.2584,
+      "log_good": 6.4003
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 39.5615,
+      "good": 36.3448,
+      "ratio": 0.9187,
+      "suggested_scalar": -0.0217,
+      "log_bad": 3.6779,
+      "log_good": 3.5931
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2936,
+      "good": 1.2208,
+      "ratio": 0.9437,
+      "suggested_scalar": -0.0148,
+      "log_bad": 0.2574,
+      "log_good": 0.1995
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 24.0,
+      "good": 21.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0341,
+      "log_bad": 3.1781,
+      "log_good": 3.0445
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7846,
+      "good": 0.68,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.0366,
+      "log_bad": -0.2426,
+      "log_good": -0.3857
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1772,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9844,
+      "good": 0.9489,
+      "ratio": 0.9639,
+      "suggested_scalar": -0.0094,
+      "log_bad": -0.0157,
+      "log_good": -0.0525
+    },
+    "halstead.mean_length": {
+      "bad": 1164.0,
+      "good": 579.0,
+      "ratio": 0.4974,
+      "suggested_scalar": -0.1785,
+      "log_bad": 7.0596,
+      "log_good": 6.3613
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 3.5556,
+      "good": 6.0,
+      "ratio": 1.6875,
+      "suggested_scalar": 0.1338,
+      "log_bad": 1.2685,
+      "log_good": 1.7918
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.4676,
+      "good": 6.3038,
+      "ratio": 0.8442,
+      "suggested_scalar": -0.0433,
+      "log_bad": 2.0106,
+      "log_good": 1.8412
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1254,
+      "good": 0.1687,
+      "ratio": 1.3453,
+      "suggested_scalar": 0.0758,
+      "log_bad": -2.0762,
+      "log_good": -1.7796
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 46.4444,
+      "good": 47.7391,
+      "ratio": 1.0279,
+      "suggested_scalar": 0.007,
+      "log_bad": 3.8383,
+      "log_good": 3.8658
+    },
+    "branching.mean_branch_count": {
+      "bad": 35.0,
+      "good": 6.0,
+      "ratio": 0.1714,
+      "suggested_scalar": -0.4508,
+      "log_bad": 3.5553,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 133.0,
+      "good": 51.0,
+      "ratio": 0.3835,
+      "suggested_scalar": -0.245,
+      "log_bad": 4.8903,
+      "log_good": 3.9318
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6524,
+      "good": 0.505,
+      "ratio": 0.7741,
+      "suggested_scalar": -0.0655,
+      "log_bad": -0.4271,
+      "log_good": -0.6832
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 130.0,
+      "good": 58.0,
+      "ratio": 0.4462,
+      "suggested_scalar": -0.2063,
+      "log_bad": 4.8675,
+      "log_good": 4.0604
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.1772,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 26.0,
+      "good": 20.0,
+      "ratio": 0.7692,
+      "suggested_scalar": -0.0671,
+      "log_bad": 3.2581,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "file_structure.has_consistent_indentation": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 31.0,
+      "good": 31.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.434,
+      "log_good": 3.434
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0084,
+      "good": 0.0084,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.7795,
+      "log_good": -4.7795
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1667,
+      "good": 1.1667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1542,
+      "log_good": 0.1542
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8154,
+      "good": 0.7414,
+      "ratio": 0.9092,
+      "suggested_scalar": -0.1671,
+      "log_bad": -0.2041,
+      "log_good": -0.2992
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0084,
+      "good": 0.0084,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.7795,
+      "log_good": -4.7795
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.2112,
+      "good": 4.4267,
+      "ratio": 1.0512,
+      "suggested_scalar": 0.0876,
+      "log_bad": 1.4377,
+      "log_good": 1.4877
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 69.0,
+      "good": 69.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2341,
+      "log_good": 4.2341
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3767,
+      "good": 0.3767,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.9763,
+      "log_good": -0.9763
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5582,
+      "good": 0.5582,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.583,
+      "log_good": -0.583
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.4462,
+      "good": 3.8276,
+      "ratio": 0.7028,
+      "suggested_scalar": -0.6193,
+      "log_bad": 1.6949,
+      "log_good": 1.3422
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 358.0,
+      "good": 358.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.8805,
+      "log_good": 5.8805
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1157,
+      "good": 1.1157,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1095,
+      "log_good": 0.1095
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 108.0,
+      "good": 108.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.6821,
+      "log_good": 4.6821
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 106.2552,
+      "good": 105.5805,
+      "ratio": 0.9937,
+      "suggested_scalar": -0.0112,
+      "log_bad": 4.6658,
+      "log_good": 4.6595
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7395,
+      "good": 0.7395,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3018,
+      "log_good": -0.3018
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.1914,
+      "good": 10.1914,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3215,
+      "log_good": 2.3215
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1489.0,
+      "good": 1358.0,
+      "ratio": 0.912,
+      "suggested_scalar": -0.1617,
+      "log_bad": 7.3059,
+      "log_good": 7.2138
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1231,
+      "good": 0.1379,
+      "ratio": 1.1202,
+      "suggested_scalar": 0.1994,
+      "log_bad": -2.0948,
+      "log_good": -1.9812
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7231,
+      "good": 0.6897,
+      "ratio": 0.9538,
+      "suggested_scalar": -0.083,
+      "log_bad": -0.3242,
+      "log_good": -0.3715
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.5077,
+      "good": 6.1724,
+      "ratio": 1.1207,
+      "suggested_scalar": 0.2001,
+      "log_bad": 1.7061,
+      "log_good": 1.8201
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 12.6163,
+      "good": 4.0392,
+      "ratio": 0.3202,
+      "suggested_scalar": -2.0,
+      "log_bad": 2.535,
+      "log_good": 1.396
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 95.0,
+      "good": 95.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.5539,
+      "log_good": 4.5539
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9263,
+      "good": 0.9263,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0766,
+      "log_good": -0.0766
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6555,
+      "good": 0.6392,
+      "ratio": 0.9751,
+      "suggested_scalar": -0.0442,
+      "log_bad": -0.4224,
+      "log_good": -0.4475
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4831,
+      "good": 0.4831,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.7275,
+      "log_good": -0.7275
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9025,
+      "good": 2.7714,
+      "ratio": 0.9548,
+      "suggested_scalar": -0.0812,
+      "log_bad": 1.0656,
+      "log_good": 1.0194
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 356.0,
+      "good": 356.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.8749,
+      "log_good": 5.8749
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 11.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.1528,
+      "log_bad": 2.4849,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.014,
+      "good": 0.014,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.2687,
+      "log_good": -4.2687
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.585,
+      "good": 5.585,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7201,
+      "log_good": 1.7201
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6461,
+      "good": 0.6461,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.4368,
+      "log_good": -0.4368
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.2413,
+      "good": 5.2413,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6566,
+      "log_good": 1.6566
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.754,
+      "good": 0.7926,
+      "ratio": 1.0512,
+      "suggested_scalar": 0.0877,
+      "log_bad": -0.2824,
+      "log_good": -0.2324
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1096,
+      "good": 0.1343,
+      "ratio": 1.2254,
+      "suggested_scalar": 0.3569,
+      "log_bad": -2.2109,
+      "log_good": -2.0077
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1924,
+      "good": 3.1924,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.1608,
+      "log_good": 1.1608
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 246.0,
+      "good": 246.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.5053,
+      "log_good": 5.5053
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6842,
+      "good": 0.6842,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3795,
+      "log_good": -0.3795
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 72.0,
+      "good": 72.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2767,
+      "log_good": 4.2767
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 588.0,
+      "good": 588.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.3767,
+      "log_good": 6.3767
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 113.0,
+      "good": 113.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.7274,
+      "log_good": 4.7274
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0363,
+      "good": 0.0363,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.3159,
+      "log_good": -3.3159
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2542,
+      "good": 0.2542,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.3696,
+      "log_good": -1.3696
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 77.0,
+      "good": 77.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3438,
+      "log_good": 4.3438
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 72.0,
+      "good": 72.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2767,
+      "log_good": 4.2767
+    },
+    "brevity.mean_sample_size": {
+      "bad": 72.0,
+      "good": 72.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2767,
+      "log_good": 4.2767
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 358.0,
+      "good": 358.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.8805,
+      "log_good": 5.8805
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 185.0,
+      "good": 185.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.2204,
+      "log_good": 5.2204
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 170.0,
+      "good": 170.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.1358,
+      "log_good": 5.1358
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 3.0449,
+      "good": 3.0449,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.1135,
+      "log_good": 1.1135
+    },
+    "halstead.mean_effort": {
+      "bad": 61847.5884,
+      "good": 61847.5884,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 11.0324,
+      "log_good": 11.0324
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8495,
+      "good": 0.8495,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1631,
+      "log_good": -0.1631
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 45.0,
+      "good": 45.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8067,
+      "log_good": 3.8067
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 223.0,
+      "good": 223.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.4072,
+      "log_good": 5.4072
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3889,
+      "good": 0.3889,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.9444,
+      "log_good": -0.9444
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.4444,
+      "good": 5.4444,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6946,
+      "log_good": 1.6946
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1096,
+      "good": 0.1343,
+      "ratio": 1.2254,
+      "suggested_scalar": 0.3569,
+      "log_bad": -2.2109,
+      "log_good": -2.0077
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.437,
+      "good": 2.7029,
+      "ratio": 1.1091,
+      "suggested_scalar": 0.1818,
+      "log_bad": 0.8908,
+      "log_good": 0.9943
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 357.0,
+      "good": 357.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.8777,
+      "log_good": 5.8777
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 62.0,
+      "good": 62.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.1271,
+      "log_good": 4.1271
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3435.9771,
+      "good": 3435.9771,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 8.1421,
+      "log_good": 8.1421
+    },
+    "readability.mean_total_lines": {
+      "bad": 65.0,
+      "good": 58.0,
+      "ratio": 0.8923,
+      "suggested_scalar": -0.2001,
+      "log_bad": 4.1744,
+      "log_good": 4.0604
+    },
+    "indentation.mean_max_depth": {
+      "bad": 14.0,
+      "good": 8.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -0.9827,
+      "log_bad": 2.6391,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2052.4642,
+      "good": 2052.4642,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 7.6268,
+      "log_good": 7.6268
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 513.0,
+      "good": 490.0,
+      "ratio": 0.9552,
+      "suggested_scalar": -0.0805,
+      "log_bad": 6.2403,
+      "log_good": 6.1944
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 21.7846,
+      "good": 22.2586,
+      "ratio": 1.0218,
+      "suggested_scalar": 0.0378,
+      "log_bad": 3.0812,
+      "log_good": 3.1027
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1228,
+      "good": 1.1228,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1158,
+      "log_good": 0.1158
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.748,
+      "good": 0.748,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2904,
+      "log_good": -0.2904
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9675,
+      "good": 0.9675,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.033,
+      "log_good": -0.033
+    },
+    "halstead.mean_length": {
+      "bad": 336.0,
+      "good": 336.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.8171,
+      "log_good": 5.8171
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.6667,
+      "good": 5.1667,
+      "ratio": 0.9118,
+      "suggested_scalar": -0.1622,
+      "log_bad": 1.7346,
+      "log_good": 1.6422
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.1699,
+      "good": 6.1699,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8197,
+      "log_good": 1.8197
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1242,
+      "good": 0.1362,
+      "ratio": 1.0966,
+      "suggested_scalar": 0.162,
+      "log_bad": -2.0859,
+      "log_good": -1.9936
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.1333,
+      "good": 30.1333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4056,
+      "log_good": 3.4056
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 42.0,
+      "good": 42.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7377,
+      "log_good": 3.7377
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5471,
+      "good": 0.5471,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.6031,
+      "log_good": -0.6031
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 65.0,
+      "good": 58.0,
+      "ratio": 0.8923,
+      "suggested_scalar": -0.2001,
+      "log_bad": 4.1744,
+      "log_good": 4.0604
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.default_parameters_placed_at_end": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 19.0,
+      "good": 17.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.2025,
+      "log_bad": 2.9444,
+      "log_good": 2.8332
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0159,
+      "good": 0.0095,
+      "ratio": 0.5975,
+      "suggested_scalar": -0.9376,
+      "log_bad": -4.1414,
+      "log_good": -4.6565
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9298,
+      "good": 0.9298,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0728,
+      "log_good": -0.0728
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0159,
+      "good": 0.0095,
+      "ratio": 0.5975,
+      "suggested_scalar": -0.9376,
+      "log_bad": -4.1414,
+      "log_good": -4.6565
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.3032,
+      "good": 4.3376,
+      "ratio": 1.008,
+      "suggested_scalar": 0.0145,
+      "log_bad": 1.4594,
+      "log_good": 1.4673
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 84.0,
+      "good": 74.0,
+      "ratio": 0.881,
+      "suggested_scalar": -0.2307,
+      "log_bad": 4.4308,
+      "log_good": 4.3041
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4042,
+      "good": 0.4195,
+      "ratio": 1.0379,
+      "suggested_scalar": 0.0676,
+      "log_bad": -0.9058,
+      "log_good": -0.8687
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 17.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.1041,
+      "log_bad": 2.8904,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6215,
+      "good": 0.63,
+      "ratio": 1.0137,
+      "suggested_scalar": 0.0247,
+      "log_bad": -0.4756,
+      "log_good": -0.462
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.6667,
+      "good": 6.7368,
+      "ratio": 1.0105,
+      "suggested_scalar": 0.019,
+      "log_bad": 1.8971,
+      "log_good": 1.9076
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 378.0,
+      "good": 317.0,
+      "ratio": 0.8386,
+      "suggested_scalar": -0.3204,
+      "log_bad": 5.9349,
+      "log_good": 5.7589
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0014,
+      "good": 0.0018,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.4575,
+      "log_bad": -6.5713,
+      "log_good": -6.32
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0526,
+      "good": 0.0526,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.945,
+      "log_good": -2.945
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.001,
+      "good": 0.0012,
+      "ratio": 1.2,
+      "suggested_scalar": 0.3319,
+      "log_bad": -6.9078,
+      "log_good": -6.7254
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.036,
+      "good": 0.984,
+      "ratio": 0.9498,
+      "suggested_scalar": -0.0937,
+      "log_bad": 0.0354,
+      "log_good": -0.0161
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 142.0,
+      "good": 120.0,
+      "ratio": 0.8451,
+      "suggested_scalar": -0.3065,
+      "log_bad": 4.9558,
+      "log_good": 4.7875
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 100.4639,
+      "good": 100.4759,
+      "ratio": 1.0001,
+      "suggested_scalar": 0.0002,
+      "log_bad": 4.6098,
+      "log_good": 4.6099
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5942,
+      "good": 0.5918,
+      "ratio": 0.996,
+      "suggested_scalar": -0.0074,
+      "log_bad": -0.5205,
+      "log_good": -0.5246
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 16.6945,
+      "good": 16.6067,
+      "ratio": 0.9947,
+      "suggested_scalar": -0.0096,
+      "log_bad": 2.8151,
+      "log_good": 2.8098
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2082.0,
+      "good": 1643.0,
+      "ratio": 0.7891,
+      "suggested_scalar": -0.4311,
+      "log_bad": 7.6411,
+      "log_good": 7.4043
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1053,
+      "good": 0.0351,
+      "ratio": 0.3333,
+      "suggested_scalar": -2.0,
+      "log_bad": -2.2509,
+      "log_good": -3.3496
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8947,
+      "good": 0.8947,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1113,
+      "log_good": -0.1113
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.6316,
+      "good": 5.5614,
+      "ratio": 0.8386,
+      "suggested_scalar": -0.3204,
+      "log_bad": 1.8918,
+      "log_good": 1.7158
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 11.9766,
+      "good": 11.8781,
+      "ratio": 0.9918,
+      "suggested_scalar": -0.015,
+      "log_bad": 2.483,
+      "log_good": 2.4747
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 85.0,
+      "good": 65.0,
+      "ratio": 0.7647,
+      "suggested_scalar": -0.4884,
+      "log_bad": 4.4427,
+      "log_good": 4.1744
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9475,
+      "good": 0.9565,
+      "ratio": 1.0095,
+      "suggested_scalar": 0.0172,
+      "log_bad": -0.0539,
+      "log_good": -0.0445
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 20.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0888,
+      "log_bad": 3.0445,
+      "log_good": 2.9957
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6633,
+      "good": 0.6366,
+      "ratio": 0.9597,
+      "suggested_scalar": -0.0748,
+      "log_bad": -0.4105,
+      "log_good": -0.4516
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4309,
+      "good": 0.419,
+      "ratio": 0.9724,
+      "suggested_scalar": -0.051,
+      "log_bad": -0.8419,
+      "log_good": -0.8699
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.97,
+      "good": 2.7521,
+      "ratio": 0.9266,
+      "suggested_scalar": -0.1387,
+      "log_bad": 1.0886,
+      "log_good": 1.0124
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 376.0,
+      "good": 315.0,
+      "ratio": 0.8378,
+      "suggested_scalar": -0.3223,
+      "log_bad": 5.9296,
+      "log_good": 5.7526
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0979,
+      "good": 0.1167,
+      "ratio": 1.192,
+      "suggested_scalar": 0.3198,
+      "log_bad": -2.3238,
+      "log_good": -2.1481
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0661,
+      "good": 5.9542,
+      "ratio": 0.9816,
+      "suggested_scalar": -0.0339,
+      "log_bad": 1.8027,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 37.0,
+      "good": 37.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6109,
+      "log_good": 3.6109
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3874,
+      "good": 1.4595,
+      "ratio": 1.052,
+      "suggested_scalar": 0.0922,
+      "log_bad": 0.3274,
+      "log_good": 0.3781
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5507,
+      "good": 5.4355,
+      "ratio": 0.9792,
+      "suggested_scalar": -0.0382,
+      "log_bad": 1.7139,
+      "log_good": 1.693
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7094,
+      "good": 0.7285,
+      "ratio": 1.0269,
+      "suggested_scalar": 0.0484,
+      "log_bad": -0.3433,
+      "log_good": -0.3168
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1094,
+      "good": 0.1094,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.2127,
+      "log_good": -2.2127
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.0859,
+      "good": 4.0751,
+      "ratio": 0.9974,
+      "suggested_scalar": -0.0048,
+      "log_bad": 1.4075,
+      "log_good": 1.4049
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 274.0,
+      "good": 235.0,
+      "ratio": 0.8577,
+      "suggested_scalar": -0.2795,
+      "log_bad": 5.6131,
+      "log_good": 5.4596
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7479,
+      "good": 0.6147,
+      "ratio": 0.8219,
+      "suggested_scalar": -0.3571,
+      "log_bad": -0.2905,
+      "log_good": -0.4866
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 90.0,
+      "good": 82.0,
+      "ratio": 0.9111,
+      "suggested_scalar": -0.1695,
+      "log_bad": 4.4998,
+      "log_good": 4.4067
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 980.0,
+      "good": 792.0,
+      "ratio": 0.8082,
+      "suggested_scalar": -0.3877,
+      "log_bad": 6.8876,
+      "log_good": 6.6746
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 161.0,
+      "good": 130.0,
+      "ratio": 0.8075,
+      "suggested_scalar": -0.3893,
+      "log_bad": 5.0814,
+      "log_good": 4.8675
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0053,
+      "good": 0.0063,
+      "ratio": 1.1887,
+      "suggested_scalar": 0.3147,
+      "log_bad": -5.24,
+      "log_good": -5.0672
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2328,
+      "good": 0.2681,
+      "ratio": 1.1516,
+      "suggested_scalar": 0.257,
+      "log_bad": -1.4576,
+      "log_good": -1.3164
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 67.0,
+      "good": 60.0,
+      "ratio": 0.8955,
+      "suggested_scalar": -0.2009,
+      "log_bad": 4.2047,
+      "log_good": 4.0943
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 90.0,
+      "good": 82.0,
+      "ratio": 0.9111,
+      "suggested_scalar": -0.1695,
+      "log_bad": 4.4998,
+      "log_good": 4.4067
+    },
+    "brevity.mean_sample_size": {
+      "bad": 90.0,
+      "good": 82.0,
+      "ratio": 0.9111,
+      "suggested_scalar": -0.1695,
+      "log_bad": 4.4998,
+      "log_good": 4.4067
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 378.0,
+      "good": 317.0,
+      "ratio": 0.8386,
+      "suggested_scalar": -0.3204,
+      "log_bad": 5.9349,
+      "log_good": 5.7589
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 196.0,
+      "good": 168.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.2806,
+      "log_bad": 5.2781,
+      "log_good": 5.124
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 220.0,
+      "good": 189.0,
+      "ratio": 0.8591,
+      "suggested_scalar": -0.2765,
+      "log_bad": 5.3936,
+      "log_good": 5.2417
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0053,
+      "good": 0.0063,
+      "ratio": 1.1887,
+      "suggested_scalar": 0.3147,
+      "log_bad": -5.24,
+      "log_good": -5.0672
+    },
+    "heaps.mean_k": {
+      "bad": 2.269,
+      "good": 2.0623,
+      "ratio": 0.9089,
+      "suggested_scalar": -0.1739,
+      "log_bad": 0.8193,
+      "log_good": 0.7238
+    },
+    "halstead.mean_effort": {
+      "bad": 60206.0416,
+      "good": 44397.5916,
+      "ratio": 0.7374,
+      "suggested_scalar": -0.5545,
+      "log_bad": 11.0055,
+      "log_good": 10.7009
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.855,
+      "good": 0.855,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1567,
+      "log_good": -0.1567
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 63.0,
+      "good": 54.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.2806,
+      "log_bad": 4.1431,
+      "log_good": 3.989
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 190.0,
+      "good": 167.0,
+      "ratio": 0.8789,
+      "suggested_scalar": -0.2349,
+      "log_bad": 5.247,
+      "log_good": 5.118
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3732,
+      "good": 0.4083,
+      "ratio": 1.0941,
+      "suggested_scalar": 0.1636,
+      "log_bad": -0.9856,
+      "log_good": -0.8958
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.9014,
+      "good": 6.6,
+      "ratio": 0.9563,
+      "suggested_scalar": -0.0813,
+      "log_bad": 1.9317,
+      "log_good": 1.8871
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1094,
+      "good": 0.1094,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.2127,
+      "log_good": -2.2127
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.3193,
+      "good": 2.7688,
+      "ratio": 0.8342,
+      "suggested_scalar": -0.3301,
+      "log_bad": 1.1998,
+      "log_good": 1.0184
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 377.0,
+      "good": 316.0,
+      "ratio": 0.8382,
+      "suggested_scalar": -0.3213,
+      "log_bad": 5.9322,
+      "log_good": 5.7557
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 60.0,
+      "good": 52.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.2605,
+      "log_bad": 4.0943,
+      "log_good": 3.9512
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3344.7801,
+      "good": 2466.5329,
+      "ratio": 0.7374,
+      "suggested_scalar": -0.5545,
+      "log_bad": 8.1152,
+      "log_good": 7.8106
+    },
+    "readability.mean_total_lines": {
+      "bad": 57.0,
+      "good": 57.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0431,
+      "log_good": 4.0431
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2243.7034,
+      "good": 1844.2076,
+      "ratio": 0.8219,
+      "suggested_scalar": -0.357,
+      "log_bad": 7.7159,
+      "log_good": 7.5198
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 701.0,
+      "good": 597.0,
+      "ratio": 0.8516,
+      "suggested_scalar": -0.2924,
+      "log_bad": 6.5525,
+      "log_good": 6.3919
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.3684,
+      "good": 27.7018,
+      "ratio": 0.7832,
+      "suggested_scalar": -0.4448,
+      "log_bad": 3.5658,
+      "log_good": 3.3215
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1778,
+      "good": 1.1905,
+      "ratio": 1.0108,
+      "suggested_scalar": 0.0195,
+      "log_bad": 0.1636,
+      "log_good": 0.1744
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.781,
+      "good": 0.7787,
+      "ratio": 0.9971,
+      "suggested_scalar": -0.0054,
+      "log_bad": -0.2472,
+      "log_good": -0.2501
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9787,
+      "good": 0.9781,
+      "ratio": 0.9994,
+      "suggested_scalar": -0.0011,
+      "log_bad": -0.0215,
+      "log_good": -0.0221
+    },
+    "halstead.mean_length": {
+      "bad": 351.0,
+      "good": 297.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.3041,
+      "log_bad": 5.8608,
+      "log_good": 5.6937
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 16.3333,
+      "good": 16.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7932,
+      "log_good": 2.7932
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4919,
+      "good": 6.3576,
+      "ratio": 0.9793,
+      "suggested_scalar": -0.0381,
+      "log_bad": 1.8706,
+      "log_good": 1.8497
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0942,
+      "good": 0.1023,
+      "ratio": 1.086,
+      "suggested_scalar": 0.1502,
+      "log_bad": -2.3623,
+      "log_good": -2.2798
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 26.8333,
+      "good": 24.0741,
+      "ratio": 0.8972,
+      "suggested_scalar": -0.1975,
+      "log_bad": 3.2896,
+      "log_good": 3.1811
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 2.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.7918,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 53.0,
+      "good": 49.0,
+      "ratio": 0.9245,
+      "suggested_scalar": -0.1429,
+      "log_bad": 3.9703,
+      "log_good": 3.8918
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6955,
+      "good": 0.6825,
+      "ratio": 0.9813,
+      "suggested_scalar": -0.0343,
+      "log_bad": -0.3631,
+      "log_good": -0.382
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 57.0,
+      "good": 57.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0431,
+      "log_good": 4.0431
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 26.0,
+      "good": 26.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2581,
+      "log_good": 3.2581
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_fixme_comments": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 35.0,
+      "good": 51.0,
+      "ratio": 1.4571,
+      "suggested_scalar": 0.109,
+      "log_bad": 3.5553,
+      "log_good": 3.9318
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0079,
+      "good": 0.0096,
+      "ratio": 1.2152,
+      "suggested_scalar": 0.0564,
+      "log_bad": -4.8409,
+      "log_good": -4.646
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1667,
+      "good": 1.2308,
+      "ratio": 1.0549,
+      "suggested_scalar": 0.0155,
+      "log_bad": 0.1542,
+      "log_good": 0.2077
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8333,
+      "good": 0.8194,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0049,
+      "log_bad": -0.1824,
+      "log_good": -0.1992
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0098,
+      "good": 0.0096,
+      "ratio": 0.9796,
+      "suggested_scalar": -0.006,
+      "log_bad": -4.6254,
+      "log_good": -4.646
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6974,
+      "good": 4.7299,
+      "ratio": 1.0069,
+      "suggested_scalar": 0.002,
+      "log_bad": 1.547,
+      "log_good": 1.5539
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 149.0,
+      "good": 115.0,
+      "ratio": 0.7718,
+      "suggested_scalar": -0.075,
+      "log_bad": 5.0039,
+      "log_good": 4.7449
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6571,
+      "good": 0.4516,
+      "ratio": 0.6873,
+      "suggested_scalar": -0.1086,
+      "log_bad": -0.4199,
+      "log_good": -0.795
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6616,
+      "good": 0.5258,
+      "ratio": 0.7947,
+      "suggested_scalar": -0.0665,
+      "log_bad": -0.4131,
+      "log_good": -0.6428
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.7273,
+      "good": 4.4028,
+      "ratio": 1.1812,
+      "suggested_scalar": 0.0482,
+      "log_bad": 1.3157,
+      "log_good": 1.4822
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 508.0,
+      "good": 625.0,
+      "ratio": 1.2303,
+      "suggested_scalar": 0.06,
+      "log_bad": 6.2305,
+      "log_good": 6.4378
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.001,
+      "good": 1.0,
+      "ratio": 1.0e3,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.9078,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1515,
+      "good": 1.0,
+      "ratio": 6.6007,
+      "suggested_scalar": 0.5464,
+      "log_bad": -1.8872,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0005,
+      "good": 0.0014,
+      "ratio": 2.8,
+      "suggested_scalar": 0.2981,
+      "log_bad": -7.6009,
+      "log_good": -6.5713
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8812,
+      "good": 1.0781,
+      "ratio": 1.2234,
+      "suggested_scalar": 0.0584,
+      "log_bad": -0.1265,
+      "log_good": 0.0752
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 194.0,
+      "good": 180.0,
+      "ratio": 0.9278,
+      "suggested_scalar": -0.0217,
+      "log_bad": 5.2679,
+      "log_good": 5.193
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.4403,
+      "good": 101.9475,
+      "ratio": 0.9761,
+      "suggested_scalar": -0.007,
+      "log_bad": 4.6486,
+      "log_good": 4.6245
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.499,
+      "good": 0.6458,
+      "ratio": 1.2942,
+      "suggested_scalar": 0.0747,
+      "log_bad": -0.6951,
+      "log_good": -0.4373
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.0023,
+      "good": 11.9591,
+      "ratio": 1.1956,
+      "suggested_scalar": 0.0517,
+      "log_bad": 2.3028,
+      "log_good": 2.4815
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2056.0,
+      "good": 2185.0,
+      "ratio": 1.0627,
+      "suggested_scalar": 0.0176,
+      "log_bad": 7.6285,
+      "log_good": 7.6894
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0909,
+      "good": 0.1528,
+      "ratio": 1.681,
+      "suggested_scalar": 0.1504,
+      "log_bad": -2.398,
+      "log_good": -1.8786
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.803,
+      "good": 0.7917,
+      "ratio": 0.9859,
+      "suggested_scalar": -0.0041,
+      "log_bad": -0.2194,
+      "log_good": -0.2336
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.0714,
+      "good": 8.6806,
+      "ratio": 0.9569,
+      "suggested_scalar": -0.0127,
+      "log_bad": 2.2051,
+      "log_good": 2.1611
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 12.0,
+      "good": 1.0,
+      "ratio": 0.0833,
+      "suggested_scalar": -0.7195,
+      "log_bad": 2.4849,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.3802,
+      "good": 6.4905,
+      "ratio": 1.9202,
+      "suggested_scalar": 0.1889,
+      "log_bad": 1.2179,
+      "log_good": 1.8703
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 159.0,
+      "good": 152.0,
+      "ratio": 0.956,
+      "suggested_scalar": -0.013,
+      "log_bad": 5.0689,
+      "log_good": 5.0239
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9515,
+      "good": 0.9566,
+      "ratio": 1.0054,
+      "suggested_scalar": 0.0015,
+      "log_bad": -0.0497,
+      "log_good": -0.0444
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 36.0,
+      "good": 35.0,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.0082,
+      "log_bad": 3.5835,
+      "log_good": 3.5553
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5569,
+      "good": 0.6124,
+      "ratio": 1.0997,
+      "suggested_scalar": 0.0275,
+      "log_bad": -0.5854,
+      "log_good": -0.4904
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2648,
+      "good": 0.3852,
+      "ratio": 1.4547,
+      "suggested_scalar": 0.1085,
+      "log_bad": -1.3288,
+      "log_good": -0.954
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2569,
+      "good": 2.5797,
+      "ratio": 1.143,
+      "suggested_scalar": 0.0387,
+      "log_bad": 0.814,
+      "log_good": 0.9477
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 506.0,
+      "good": 623.0,
+      "ratio": 1.2312,
+      "suggested_scalar": 0.0602,
+      "log_bad": 6.2265,
+      "log_good": 6.4345
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 19.0,
+      "ratio": 1.5833,
+      "suggested_scalar": 0.133,
+      "log_bad": 2.4849,
+      "log_good": 2.9444
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0354,
+      "good": 0.0208,
+      "ratio": 0.5876,
+      "suggested_scalar": -0.154,
+      "log_bad": -3.341,
+      "log_good": -3.8728
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0661,
+      "good": 5.9542,
+      "ratio": 0.9816,
+      "suggested_scalar": -0.0054,
+      "log_bad": 1.8027,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 30.0,
+      "good": 23.0,
+      "ratio": 0.7667,
+      "suggested_scalar": -0.0769,
+      "log_bad": 3.4012,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7877,
+      "good": 0.7289,
+      "ratio": 0.9254,
+      "suggested_scalar": -0.0225,
+      "log_bad": -0.2386,
+      "log_good": -0.3162
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.3699,
+      "good": 5.8106,
+      "ratio": 0.9122,
+      "suggested_scalar": -0.0266,
+      "log_bad": 1.8516,
+      "log_good": 1.7597
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7744,
+      "good": 0.7944,
+      "ratio": 1.0258,
+      "suggested_scalar": 0.0074,
+      "log_bad": -0.2557,
+      "log_good": -0.2302
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1429,
+      "good": 0.1818,
+      "ratio": 1.2722,
+      "suggested_scalar": 0.0697,
+      "log_bad": -1.9456,
+      "log_good": -1.7048
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1626,
+      "good": 3.4582,
+      "ratio": 1.0935,
+      "suggested_scalar": 0.0259,
+      "log_bad": 1.1514,
+      "log_good": 1.2407
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 424.0,
+      "good": 468.0,
+      "ratio": 1.1038,
+      "suggested_scalar": 0.0286,
+      "log_bad": 6.0497,
+      "log_good": 6.1485
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 6.0,
+      "good": 16.0,
+      "ratio": 2.6667,
+      "suggested_scalar": 0.284,
+      "log_bad": 1.7918,
+      "log_good": 2.7726
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0901,
+      "good": 1.3372,
+      "ratio": 1.2267,
+      "suggested_scalar": 0.0592,
+      "log_bad": 0.0863,
+      "log_good": 0.2906
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 163.0,
+      "good": 120.0,
+      "ratio": 0.7362,
+      "suggested_scalar": -0.0887,
+      "log_bad": 5.0938,
+      "log_good": 4.7875
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1087.0,
+      "good": 1018.0,
+      "ratio": 0.9365,
+      "suggested_scalar": -0.019,
+      "log_bad": 6.9912,
+      "log_good": 6.9256
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 188.0,
+      "good": 191.0,
+      "ratio": 1.016,
+      "suggested_scalar": 0.0046,
+      "log_bad": 5.2364,
+      "log_good": 5.2523
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0138,
+      "good": 0.0144,
+      "ratio": 1.0435,
+      "suggested_scalar": 0.0123,
+      "log_bad": -4.2831,
+      "log_good": -4.2405
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2598,
+      "good": 0.2784,
+      "ratio": 1.0716,
+      "suggested_scalar": 0.02,
+      "log_bad": -1.3478,
+      "log_good": -1.2787
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 87.0,
+      "good": 117.0,
+      "ratio": 1.3448,
+      "suggested_scalar": 0.0858,
+      "log_bad": 4.4659,
+      "log_good": 4.7622
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 12.0,
+      "good": 13.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.0232,
+      "log_bad": 2.4849,
+      "log_good": 2.5649
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 163.0,
+      "good": 120.0,
+      "ratio": 0.7362,
+      "suggested_scalar": -0.0887,
+      "log_bad": 5.0938,
+      "log_good": 4.7875
+    },
+    "brevity.mean_sample_size": {
+      "bad": 163.0,
+      "good": 120.0,
+      "ratio": 0.7362,
+      "suggested_scalar": -0.0887,
+      "log_bad": 5.0938,
+      "log_good": 4.7875
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 508.0,
+      "good": 625.0,
+      "ratio": 1.2303,
+      "suggested_scalar": 0.06,
+      "log_bad": 6.2305,
+      "log_good": 6.4378
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 237.0,
+      "good": 361.0,
+      "ratio": 1.5232,
+      "suggested_scalar": 0.1218,
+      "log_bad": 5.4681,
+      "log_good": 5.8889
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 341.0,
+      "good": 338.0,
+      "ratio": 0.9912,
+      "suggested_scalar": -0.0026,
+      "log_bad": 5.8319,
+      "log_good": 5.823
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.002,
+      "good": 0.0016,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0646,
+      "log_bad": -6.2146,
+      "log_good": -6.4378
+    },
+    "heaps.mean_k": {
+      "bad": 2.8195,
+      "good": 4.1067,
+      "ratio": 1.4565,
+      "suggested_scalar": 0.1089,
+      "log_bad": 1.0366,
+      "log_good": 1.4126
+    },
+    "halstead.mean_effort": {
+      "bad": 97934.8568,
+      "good": 167603.6949,
+      "ratio": 1.7114,
+      "suggested_scalar": 0.1556,
+      "log_bad": 11.4921,
+      "log_good": 12.0294
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8668,
+      "good": 0.8413,
+      "ratio": 0.9706,
+      "suggested_scalar": -0.0086,
+      "log_bad": -0.1429,
+      "log_good": -0.1728
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 113.0,
+      "good": 80.0,
+      "ratio": 0.708,
+      "suggested_scalar": -0.1,
+      "log_bad": 4.7274,
+      "log_good": 4.382
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 265.0,
+      "good": 395.0,
+      "ratio": 1.4906,
+      "suggested_scalar": 0.1156,
+      "log_bad": 5.5797,
+      "log_good": 5.9789
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5979,
+      "good": 0.4222,
+      "ratio": 0.7061,
+      "suggested_scalar": -0.1007,
+      "log_bad": -0.5143,
+      "log_good": -0.8623
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.6031,
+      "good": 5.6556,
+      "ratio": 1.0094,
+      "suggested_scalar": 0.0027,
+      "log_bad": 1.7233,
+      "log_good": 1.7326
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1429,
+      "good": 0.1818,
+      "ratio": 1.2722,
+      "suggested_scalar": 0.0697,
+      "log_bad": -1.9456,
+      "log_good": -1.7048
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.0797,
+      "good": 3.9373,
+      "ratio": 0.9651,
+      "suggested_scalar": -0.0103,
+      "log_bad": 1.406,
+      "log_good": 1.3705
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 507.0,
+      "good": 624.0,
+      "ratio": 1.2308,
+      "suggested_scalar": 0.0601,
+      "log_bad": 6.2285,
+      "log_good": 6.4362
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 6.0,
+      "good": 11.0,
+      "ratio": 1.8333,
+      "suggested_scalar": 0.1755,
+      "log_bad": 1.7918,
+      "log_good": 2.3979
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 52.0,
+      "good": 85.0,
+      "ratio": 1.6346,
+      "suggested_scalar": 0.1423,
+      "log_bad": 3.9512,
+      "log_good": 4.4427
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5440.8254,
+      "good": 9311.3164,
+      "ratio": 1.7114,
+      "suggested_scalar": 0.1556,
+      "log_bad": 8.6017,
+      "log_good": 9.139
+    },
+    "readability.mean_total_lines": {
+      "bad": 56.0,
+      "good": 72.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.0728,
+      "log_bad": 4.0254,
+      "log_good": 4.2767
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 10.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0646,
+      "log_bad": 2.0794,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 3270.2833,
+      "good": 4011.4572,
+      "ratio": 1.2266,
+      "suggested_scalar": 0.0591,
+      "log_bad": 8.0926,
+      "log_good": 8.2969
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 911.0,
+      "good": 847.0,
+      "ratio": 0.9297,
+      "suggested_scalar": -0.0211,
+      "log_bad": 6.8145,
+      "log_good": 6.7417
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 24.5536,
+      "good": 29.125,
+      "ratio": 1.1862,
+      "suggested_scalar": 0.0494,
+      "log_bad": 3.2009,
+      "log_good": 3.3716
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1015,
+      "good": 1.1357,
+      "ratio": 1.031,
+      "suggested_scalar": 0.0089,
+      "log_bad": 0.0967,
+      "log_good": 0.1272
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 15.0,
+      "good": 24.0,
+      "ratio": 1.6,
+      "suggested_scalar": 0.1361,
+      "log_bad": 2.7081,
+      "log_good": 3.1781
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 10.0,
+      "good": 1.0,
+      "ratio": 0.1,
+      "suggested_scalar": -0.6667,
+      "log_bad": 2.3026,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8774,
+      "good": 0.8184,
+      "ratio": 0.9328,
+      "suggested_scalar": -0.0202,
+      "log_bad": -0.1308,
+      "log_good": -0.2004
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9921,
+      "good": 0.9889,
+      "ratio": 0.9968,
+      "suggested_scalar": -0.0009,
+      "log_bad": -0.0079,
+      "log_good": -0.0112
+    },
+    "halstead.mean_length": {
+      "bad": 453.0,
+      "good": 586.0,
+      "ratio": 1.2936,
+      "suggested_scalar": 0.0745,
+      "log_bad": 6.1159,
+      "log_good": 6.3733
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.0833,
+      "good": 6.5385,
+      "ratio": 1.0748,
+      "suggested_scalar": 0.0209,
+      "log_bad": 1.8055,
+      "log_good": 1.8777
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.3487,
+      "good": 6.9069,
+      "ratio": 0.9399,
+      "suggested_scalar": -0.018,
+      "log_bad": 1.9945,
+      "log_good": 1.9325
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1153,
+      "good": 0.1652,
+      "ratio": 1.4328,
+      "suggested_scalar": 0.1041,
+      "log_bad": -2.1602,
+      "log_good": -1.8006
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.9469,
+      "good": 41.7813,
+      "ratio": 1.3952,
+      "suggested_scalar": 0.0964,
+      "log_bad": 3.3994,
+      "log_good": 3.7324
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 11.0,
+      "ratio": 1.8333,
+      "suggested_scalar": 0.1755,
+      "log_bad": 1.7918,
+      "log_good": 2.3979
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 116.0,
+      "good": 76.0,
+      "ratio": 0.6552,
+      "suggested_scalar": -0.1224,
+      "log_bad": 4.7536,
+      "log_good": 4.3307
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7449,
+      "good": 0.6538,
+      "ratio": 0.8777,
+      "suggested_scalar": -0.0378,
+      "log_bad": -0.2945,
+      "log_good": -0.425
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 66.0,
+      "good": 72.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0252,
+      "log_bad": 4.1897,
+      "log_good": 4.2767
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "consistency.process_interactions_centralized": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 25.0,
+      "good": 38.0,
+      "ratio": 1.52,
+      "suggested_scalar": 0.1313,
+      "log_bad": 3.2189,
+      "log_good": 3.6376
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0065,
+      "good": 0.0138,
+      "ratio": 2.1231,
+      "suggested_scalar": 0.2361,
+      "log_bad": -5.036,
+      "log_good": -4.2831
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.0,
+      "good": 1.6154,
+      "ratio": 0.8077,
+      "suggested_scalar": -0.067,
+      "log_bad": 0.6931,
+      "log_good": 0.4796
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7551,
+      "good": 0.8136,
+      "ratio": 1.0775,
+      "suggested_scalar": 0.0234,
+      "log_bad": -0.2809,
+      "log_good": -0.2063
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0065,
+      "good": 0.0138,
+      "ratio": 2.1231,
+      "suggested_scalar": 0.2361,
+      "log_bad": -5.036,
+      "log_good": -4.2831
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7754,
+      "good": 4.8239,
+      "ratio": 1.0102,
+      "suggested_scalar": 0.0032,
+      "log_bad": 1.5635,
+      "log_good": 1.5736
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 108.0,
+      "good": 96.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0369,
+      "log_bad": 4.6821,
+      "log_good": 4.5643
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4863,
+      "good": 0.4189,
+      "ratio": 0.8614,
+      "suggested_scalar": -0.0468,
+      "log_bad": -0.7209,
+      "log_good": -0.8701
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 21.0,
+      "ratio": 1.1053,
+      "suggested_scalar": 0.0314,
+      "log_bad": 2.9444,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6035,
+      "good": 0.5455,
+      "ratio": 0.9039,
+      "suggested_scalar": -0.0317,
+      "log_bad": -0.505,
+      "log_good": -0.6061
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.2449,
+      "good": 2.339,
+      "ratio": 1.0419,
+      "suggested_scalar": 0.0129,
+      "log_bad": 0.8087,
+      "log_good": 0.8497
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 461.0,
+      "good": 581.0,
+      "ratio": 1.2603,
+      "suggested_scalar": 0.0726,
+      "log_bad": 6.1334,
+      "log_good": 6.3648
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1429,
+      "good": 0.0339,
+      "ratio": 0.2372,
+      "suggested_scalar": -0.4512,
+      "log_bad": -1.9456,
+      "log_good": -3.3843
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0117,
+      "good": 1.0882,
+      "ratio": 1.0756,
+      "suggested_scalar": 0.0229,
+      "log_bad": 0.0116,
+      "log_good": 0.0845
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 172.0,
+      "good": 209.0,
+      "ratio": 1.2151,
+      "suggested_scalar": 0.0611,
+      "log_bad": 5.1475,
+      "log_good": 5.3423
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 94.9628,
+      "good": 99.9348,
+      "ratio": 1.0524,
+      "suggested_scalar": 0.016,
+      "log_bad": 4.5535,
+      "log_good": 4.6045
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6217,
+      "good": 0.681,
+      "ratio": 1.0954,
+      "suggested_scalar": 0.0286,
+      "log_bad": -0.4753,
+      "log_good": -0.3842
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.5907,
+      "good": 8.8609,
+      "ratio": 0.9239,
+      "suggested_scalar": -0.0248,
+      "log_bad": 2.2608,
+      "log_good": 2.1816
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1847.0,
+      "good": 2170.0,
+      "ratio": 1.1749,
+      "suggested_scalar": 0.0505,
+      "log_bad": 7.5213,
+      "log_good": 7.6825
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 0.0847,
+      "ratio": 0.0847,
+      "suggested_scalar": -0.7742,
+      "log_bad": 0.0,
+      "log_good": -2.4686
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7347,
+      "good": 0.7966,
+      "ratio": 1.0843,
+      "suggested_scalar": 0.0254,
+      "log_bad": -0.3083,
+      "log_good": -0.2274
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.9762,
+      "good": 10.193,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.0232,
+      "log_bad": 2.3957,
+      "log_good": 2.3217
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 7.0,
+      "good": 13.0,
+      "ratio": 1.8571,
+      "suggested_scalar": 0.1941,
+      "log_bad": 1.9459,
+      "log_good": 2.5649
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.5523,
+      "good": 0.8342,
+      "ratio": 0.3268,
+      "suggested_scalar": -0.3507,
+      "log_bad": 0.937,
+      "log_good": -0.1813
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 121.0,
+      "good": 160.0,
+      "ratio": 1.3223,
+      "suggested_scalar": 0.0876,
+      "log_bad": 4.7958,
+      "log_good": 5.0752
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9618,
+      "good": 0.952,
+      "ratio": 0.9898,
+      "suggested_scalar": -0.0032,
+      "log_bad": -0.0389,
+      "log_good": -0.0492
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 30.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4012,
+      "log_good": 3.4012
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6199,
+      "good": 0.629,
+      "ratio": 1.0147,
+      "suggested_scalar": 0.0046,
+      "log_bad": -0.4782,
+      "log_good": -0.4636
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4118,
+      "good": 0.4819,
+      "ratio": 1.1702,
+      "suggested_scalar": 0.0493,
+      "log_bad": -0.8872,
+      "log_good": -0.73
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6311,
+      "good": 2.6957,
+      "ratio": 1.0246,
+      "suggested_scalar": 0.0076,
+      "log_bad": 0.9674,
+      "log_good": 0.9917
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 459.0,
+      "good": 579.0,
+      "ratio": 1.2614,
+      "suggested_scalar": 0.0728,
+      "log_bad": 6.1291,
+      "log_good": 6.3613
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 9.0,
+      "good": 8.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0369,
+      "log_bad": 2.1972,
+      "log_good": 2.0794
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.026,
+      "good": 0.012,
+      "ratio": 0.4615,
+      "suggested_scalar": -0.2425,
+      "log_bad": -3.6497,
+      "log_good": -4.4228
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 6.1293,
+      "ratio": 1.0335,
+      "suggested_scalar": 0.0103,
+      "log_bad": 1.7801,
+      "log_good": 1.8131
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 44.0,
+      "good": 36.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.0629,
+      "log_bad": 3.7842,
+      "log_good": 3.5835
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0481,
+      "good": 0.9814,
+      "ratio": 0.9364,
+      "suggested_scalar": -0.0206,
+      "log_bad": 0.047,
+      "log_good": -0.0188
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.718,
+      "good": 5.7082,
+      "ratio": 0.9983,
+      "suggested_scalar": -0.0005,
+      "log_bad": 1.7436,
+      "log_good": 1.7419
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8052,
+      "good": 0.787,
+      "ratio": 0.9774,
+      "suggested_scalar": -0.0072,
+      "log_bad": -0.2167,
+      "log_good": -0.2395
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1833,
+      "good": 0.2237,
+      "ratio": 1.2204,
+      "suggested_scalar": 0.0625,
+      "log_bad": -1.6966,
+      "log_good": -1.4974
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.0969,
+      "good": 2.9767,
+      "ratio": 0.9612,
+      "suggested_scalar": -0.0124,
+      "log_bad": 1.1304,
+      "log_good": 1.0908
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 342.0,
+      "good": 398.0,
+      "ratio": 1.1637,
+      "suggested_scalar": 0.0476,
+      "log_bad": 5.8348,
+      "log_good": 5.9865
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0524,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9795,
+      "good": 1.0887,
+      "ratio": 1.1115,
+      "suggested_scalar": 0.0331,
+      "log_bad": -0.0207,
+      "log_good": 0.085
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 109.0,
+      "good": 124.0,
+      "ratio": 1.1376,
+      "suggested_scalar": 0.0404,
+      "log_bad": 4.6913,
+      "log_good": 4.8203
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1070.0,
+      "good": 1239.0,
+      "ratio": 1.1579,
+      "suggested_scalar": 0.046,
+      "log_bad": 6.9754,
+      "log_good": 7.1221
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 179.0,
+      "good": 172.0,
+      "ratio": 0.9609,
+      "suggested_scalar": -0.0125,
+      "log_bad": 5.1874,
+      "log_good": 5.1475
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0043,
+      "good": 1.0,
+      "ratio": 232.5581,
+      "suggested_scalar": 1.709,
+      "log_bad": -5.4491,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2907,
+      "good": 0.2668,
+      "ratio": 0.9178,
+      "suggested_scalar": -0.0269,
+      "log_bad": -1.2355,
+      "log_good": -1.3213
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 91.0,
+      "good": 110.0,
+      "ratio": 1.2088,
+      "suggested_scalar": 0.0595,
+      "log_bad": 4.5109,
+      "log_good": 4.7005
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0524,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 109.0,
+      "good": 124.0,
+      "ratio": 1.1376,
+      "suggested_scalar": 0.0404,
+      "log_bad": 4.6913,
+      "log_good": 4.8203
+    },
+    "brevity.mean_sample_size": {
+      "bad": 109.0,
+      "good": 124.0,
+      "ratio": 1.1376,
+      "suggested_scalar": 0.0404,
+      "log_bad": 4.6913,
+      "log_good": 4.8203
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 461.0,
+      "good": 581.0,
+      "ratio": 1.2603,
+      "suggested_scalar": 0.0726,
+      "log_bad": 6.1334,
+      "log_good": 6.3648
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 224.0,
+      "good": 303.0,
+      "ratio": 1.3527,
+      "suggested_scalar": 0.0947,
+      "log_bad": 5.4116,
+      "log_good": 5.7137
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 265.0,
+      "good": 295.0,
+      "ratio": 1.1132,
+      "suggested_scalar": 0.0336,
+      "log_bad": 5.5797,
+      "log_good": 5.687
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0017,
+      "ratio": 0.0017,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.3771
+    },
+    "heaps.mean_k": {
+      "bad": 2.4313,
+      "good": 3.9245,
+      "ratio": 1.6142,
+      "suggested_scalar": 0.1502,
+      "log_bad": 0.8884,
+      "log_good": 1.3672
+    },
+    "halstead.mean_effort": {
+      "bad": 101147.9453,
+      "good": 127676.4366,
+      "ratio": 1.2623,
+      "suggested_scalar": 0.073,
+      "log_bad": 11.5243,
+      "log_good": 11.7573
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8448,
+      "good": 0.8208,
+      "ratio": 0.9716,
+      "suggested_scalar": -0.009,
+      "log_bad": -0.1687,
+      "log_good": -0.1975
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 78.0,
+      "good": 66.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.0524,
+      "log_bad": 4.3567,
+      "log_good": 4.1897
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 256.0,
+      "good": 324.0,
+      "ratio": 1.2656,
+      "suggested_scalar": 0.0739,
+      "log_bad": 5.5452,
+      "log_good": 5.7807
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4186,
+      "good": 0.3923,
+      "ratio": 0.9372,
+      "suggested_scalar": -0.0204,
+      "log_bad": -0.8708,
+      "log_good": -0.9357
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.2209,
+      "good": 5.9282,
+      "ratio": 0.9529,
+      "suggested_scalar": -0.0151,
+      "log_bad": 1.8279,
+      "log_good": 1.7797
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1833,
+      "good": 0.2237,
+      "ratio": 1.2204,
+      "suggested_scalar": 0.0625,
+      "log_bad": -1.6966,
+      "log_good": -1.4974
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.899,
+      "good": 4.367,
+      "ratio": 0.8914,
+      "suggested_scalar": -0.0361,
+      "log_bad": 1.589,
+      "log_good": 1.4741
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 460.0,
+      "good": 580.0,
+      "ratio": 1.2609,
+      "suggested_scalar": 0.0727,
+      "log_bad": 6.1312,
+      "log_good": 6.363
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 72.0,
+      "good": 98.0,
+      "ratio": 1.3611,
+      "suggested_scalar": 0.0967,
+      "log_bad": 4.2767,
+      "log_good": 4.585
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5619.3303,
+      "good": 7093.1354,
+      "ratio": 1.2623,
+      "suggested_scalar": 0.073,
+      "log_bad": 8.634,
+      "log_good": 8.8669
+    },
+    "readability.mean_total_lines": {
+      "bad": 42.0,
+      "good": 57.0,
+      "ratio": 1.3571,
+      "suggested_scalar": 0.0958,
+      "log_bad": 3.7377,
+      "log_good": 4.0431
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 4.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1272,
+      "log_bad": 1.7918,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2938.3761,
+      "good": 3266.1414,
+      "ratio": 1.1115,
+      "suggested_scalar": 0.0332,
+      "log_bad": 7.9856,
+      "log_good": 8.0914
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 702.0,
+      "good": 805.0,
+      "ratio": 1.1467,
+      "suggested_scalar": 0.0429,
+      "log_bad": 6.5539,
+      "log_good": 6.6908
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.8571,
+      "good": 35.5439,
+      "ratio": 1.0818,
+      "suggested_scalar": 0.0247,
+      "log_bad": 3.4922,
+      "log_good": 3.5708
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1907,
+      "good": 1.1413,
+      "ratio": 0.9585,
+      "suggested_scalar": -0.0133,
+      "log_bad": 0.1745,
+      "log_good": 0.1322
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 28.0,
+      "good": 29.0,
+      "ratio": 1.0357,
+      "suggested_scalar": 0.011,
+      "log_bad": 3.3322,
+      "log_good": 3.3673
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 2.0,
+      "ratio": 0.2857,
+      "suggested_scalar": -0.3929,
+      "log_bad": 1.9459,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7895,
+      "good": 0.7538,
+      "ratio": 0.9548,
+      "suggested_scalar": -0.0145,
+      "log_bad": -0.2364,
+      "log_good": -0.2826
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2174,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9756,
+      "good": 0.962,
+      "ratio": 0.9861,
+      "suggested_scalar": -0.0044,
+      "log_bad": -0.0247,
+      "log_good": -0.0387
+    },
+    "halstead.mean_length": {
+      "bad": 435.0,
+      "good": 496.0,
+      "ratio": 1.1402,
+      "suggested_scalar": 0.0412,
+      "log_bad": 6.0753,
+      "log_good": 6.2066
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.0,
+      "good": 4.8462,
+      "ratio": 0.9692,
+      "suggested_scalar": -0.0098,
+      "log_bad": 1.6094,
+      "log_good": 1.5782
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7682,
+      "good": 6.9542,
+      "ratio": 1.0275,
+      "suggested_scalar": 0.0085,
+      "log_bad": 1.9122,
+      "log_good": 1.9393
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1215,
+      "good": 0.1398,
+      "ratio": 1.1506,
+      "suggested_scalar": 0.044,
+      "log_bad": -2.1078,
+      "log_good": -1.9675
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 34.4231,
+      "good": 39.0909,
+      "ratio": 1.1356,
+      "suggested_scalar": 0.0399,
+      "log_bad": 3.5387,
+      "log_good": 3.6659
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 0.5048,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 72.0,
+      "good": 82.0,
+      "ratio": 1.1389,
+      "suggested_scalar": 0.0408,
+      "log_bad": 4.2767,
+      "log_good": 4.4067
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6566,
+      "good": 0.6271,
+      "ratio": 0.9551,
+      "suggested_scalar": -0.0144,
+      "log_bad": -0.4207,
+      "log_good": -0.4666
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 49.0,
+      "good": 59.0,
+      "ratio": 1.2041,
+      "suggested_scalar": 0.0582,
+      "log_bad": 3.8918,
+      "log_good": 4.0775
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.does_not_use_inband_error_values": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 11.0,
+      "good": 14.0,
+      "ratio": 1.2727,
+      "suggested_scalar": 0.5525,
+      "log_bad": 2.3979,
+      "log_good": 2.6391
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0229,
+      "good": 0.0185,
+      "ratio": 0.8079,
+      "suggested_scalar": -0.4888,
+      "log_bad": -3.7766,
+      "log_good": -3.99
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8667,
+      "good": 0.7234,
+      "ratio": 0.8347,
+      "suggested_scalar": -0.4141,
+      "log_bad": -0.1431,
+      "log_good": -0.3238
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0229,
+      "good": 0.0185,
+      "ratio": 0.8079,
+      "suggested_scalar": -0.4888,
+      "log_bad": -3.7766,
+      "log_good": -3.99
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 5.0617,
+      "good": 5.0762,
+      "ratio": 1.0029,
+      "suggested_scalar": 0.0066,
+      "log_bad": 1.6217,
+      "log_good": 1.6246
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 83.0,
+      "good": 81.0,
+      "ratio": 0.9759,
+      "suggested_scalar": -0.0559,
+      "log_bad": 4.4188,
+      "log_good": 4.3944
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4552,
+      "good": 0.4669,
+      "ratio": 1.0257,
+      "suggested_scalar": 0.0581,
+      "log_bad": -0.787,
+      "log_good": -0.7616
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 17.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.2548,
+      "log_bad": 2.9444,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6872,
+      "good": 0.6306,
+      "ratio": 0.9176,
+      "suggested_scalar": -0.1969,
+      "log_bad": -0.3751,
+      "log_good": -0.4611
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.8889,
+      "good": 0.8723,
+      "ratio": 0.9813,
+      "suggested_scalar": -0.0432,
+      "log_bad": -0.1178,
+      "log_good": -0.1366
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 306.0,
+      "good": 379.0,
+      "ratio": 1.2386,
+      "suggested_scalar": 0.4902,
+      "log_bad": 5.7236,
+      "log_good": 5.9375
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0017,
+      "good": 0.0015,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.2868,
+      "log_bad": -6.3771,
+      "log_good": -6.5023
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1556,
+      "good": 0.0851,
+      "ratio": 0.5469,
+      "suggested_scalar": -1.3826,
+      "log_bad": -1.8605,
+      "log_good": -2.4639
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.7696,
+      "good": 0.8478,
+      "ratio": 1.1016,
+      "suggested_scalar": 0.2217,
+      "log_bad": -0.2619,
+      "log_good": -0.1651
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 128.0,
+      "good": 160.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.5112,
+      "log_bad": 4.852,
+      "log_good": 5.0752
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.758,
+      "good": 100.0211,
+      "ratio": 0.9548,
+      "suggested_scalar": -0.106,
+      "log_bad": 4.6517,
+      "log_good": 4.6054
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5934,
+      "good": 0.791,
+      "ratio": 1.333,
+      "suggested_scalar": 0.6585,
+      "log_bad": -0.5219,
+      "log_good": -0.2345
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.4236,
+      "good": 8.0694,
+      "ratio": 1.087,
+      "suggested_scalar": 0.1911,
+      "log_bad": 2.0047,
+      "log_good": 2.0881
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1168.0,
+      "good": 1.3e3,
+      "ratio": 1.113,
+      "suggested_scalar": 0.2453,
+      "log_bad": 7.063,
+      "log_good": 7.1701
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1556,
+      "good": 0.1702,
+      "ratio": 1.0938,
+      "suggested_scalar": 0.2055,
+      "log_bad": -1.8605,
+      "log_good": -1.7708
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8,
+      "good": 0.6809,
+      "ratio": 0.8511,
+      "suggested_scalar": -0.3693,
+      "log_bad": -0.2231,
+      "log_good": -0.3843
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.8,
+      "good": 8.0638,
+      "ratio": 1.1859,
+      "suggested_scalar": 0.3905,
+      "log_bad": 1.9169,
+      "log_good": 2.0874
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 4.0,
+      "good": 2.0,
+      "ratio": 0.5,
+      "suggested_scalar": -1.5881,
+      "log_bad": 1.3863,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.721,
+      "good": 0.7071,
+      "ratio": 0.9807,
+      "suggested_scalar": -0.0446,
+      "log_bad": -0.3271,
+      "log_good": -0.3466
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 90.0,
+      "good": 105.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.3532,
+      "log_bad": 4.4998,
+      "log_good": 4.654
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.8958,
+      "good": 0.9218,
+      "ratio": 1.029,
+      "suggested_scalar": 0.0656,
+      "log_bad": -0.11,
+      "log_good": -0.0814
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 22.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.1994,
+      "log_bad": 3.1781,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5454,
+      "good": 0.6108,
+      "ratio": 1.1199,
+      "suggested_scalar": 0.2595,
+      "log_bad": -0.6062,
+      "log_good": -0.493
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4079,
+      "good": 0.6737,
+      "ratio": 1.6516,
+      "suggested_scalar": 1.1496,
+      "log_bad": -0.8967,
+      "log_good": -0.395
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.1996,
+      "good": 2.5692,
+      "ratio": 1.168,
+      "suggested_scalar": 0.3559,
+      "log_bad": 0.7883,
+      "log_good": 0.9436
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 304.0,
+      "good": 377.0,
+      "ratio": 1.2401,
+      "suggested_scalar": 0.4931,
+      "log_bad": 5.717,
+      "log_good": 5.9322
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 15.0,
+      "good": 16.0,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.1479,
+      "log_bad": 2.7081,
+      "log_good": 2.7726
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0033,
+      "good": 0.0079,
+      "ratio": 2.3939,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.7138,
+      "log_good": -4.8409
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0875,
+      "good": 6.0,
+      "ratio": 0.9856,
+      "suggested_scalar": -0.0332,
+      "log_bad": 1.8062,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 34.0,
+      "good": 53.0,
+      "ratio": 1.5588,
+      "suggested_scalar": 1.0171,
+      "log_bad": 3.5264,
+      "log_good": 3.9703
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0216,
+      "good": 1.0058,
+      "ratio": 0.9845,
+      "suggested_scalar": -0.0357,
+      "log_bad": 0.0214,
+      "log_good": 0.0058
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9825,
+      "good": 5.8078,
+      "ratio": 0.9708,
+      "suggested_scalar": -0.0679,
+      "log_bad": 1.7888,
+      "log_good": 1.7592
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8315,
+      "good": 0.846,
+      "ratio": 1.0174,
+      "suggested_scalar": 0.0396,
+      "log_bad": -0.1845,
+      "log_good": -0.1672
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1509,
+      "good": 0.1607,
+      "ratio": 1.0649,
+      "suggested_scalar": 0.1442,
+      "log_bad": -1.8911,
+      "log_good": -1.8282
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.7246,
+      "good": 2.8407,
+      "ratio": 1.0426,
+      "suggested_scalar": 0.0956,
+      "log_bad": 1.0023,
+      "log_good": 1.0441
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 242.0,
+      "good": 246.0,
+      "ratio": 1.0165,
+      "suggested_scalar": 0.0376,
+      "log_bad": 5.4889,
+      "log_good": 5.5053
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.4824,
+      "good": 0.7206,
+      "ratio": 1.4938,
+      "suggested_scalar": 0.9194,
+      "log_bad": -0.729,
+      "log_good": -0.3277
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 86.0,
+      "good": 84.0,
+      "ratio": 0.9767,
+      "suggested_scalar": -0.0539,
+      "log_bad": 4.4543,
+      "log_good": 4.4308
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 618.0,
+      "good": 708.0,
+      "ratio": 1.1456,
+      "suggested_scalar": 0.3115,
+      "log_bad": 6.4265,
+      "log_good": 6.5624
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 100.0,
+      "good": 168.0,
+      "ratio": 1.68,
+      "suggested_scalar": 1.1886,
+      "log_bad": 4.6052,
+      "log_good": 5.124
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1634,
+      "good": 0.2401,
+      "ratio": 1.4694,
+      "suggested_scalar": 0.8817,
+      "log_bad": -1.8116,
+      "log_good": -1.4267
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 81.0,
+      "good": 129.0,
+      "ratio": 1.5926,
+      "suggested_scalar": 1.0662,
+      "log_bad": 4.3944,
+      "log_good": 4.8598
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 86.0,
+      "good": 84.0,
+      "ratio": 0.9767,
+      "suggested_scalar": -0.0539,
+      "log_bad": 4.4543,
+      "log_good": 4.4308
+    },
+    "brevity.mean_sample_size": {
+      "bad": 86.0,
+      "good": 84.0,
+      "ratio": 0.9767,
+      "suggested_scalar": -0.0539,
+      "log_bad": 4.4543,
+      "log_good": 4.4308
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 306.0,
+      "good": 379.0,
+      "ratio": 1.2386,
+      "suggested_scalar": 0.4902,
+      "log_bad": 5.7236,
+      "log_good": 5.9375
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 131.0,
+      "good": 178.0,
+      "ratio": 1.3588,
+      "suggested_scalar": 0.7024,
+      "log_bad": 4.8752,
+      "log_good": 5.1818
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 205.0,
+      "good": 208.0,
+      "ratio": 1.0146,
+      "suggested_scalar": 0.0333,
+      "log_bad": 5.323,
+      "log_good": 5.3375
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.0517,
+      "good": 2.4947,
+      "ratio": 1.2159,
+      "suggested_scalar": 0.4479,
+      "log_bad": 0.7187,
+      "log_good": 0.9142
+    },
+    "halstead.mean_effort": {
+      "bad": 29433.2329,
+      "good": 67714.7559,
+      "ratio": 2.3006,
+      "suggested_scalar": 1.9089,
+      "log_bad": 10.2899,
+      "log_good": 11.1231
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.931,
+      "good": 0.9086,
+      "ratio": 0.9759,
+      "suggested_scalar": -0.0558,
+      "log_bad": -0.0715,
+      "log_good": -0.0959
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 59.0,
+      "good": 59.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0775,
+      "log_good": 4.0775
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 127.0,
+      "good": 173.0,
+      "ratio": 1.3622,
+      "suggested_scalar": 0.7082,
+      "log_bad": 4.8442,
+      "log_good": 5.1533
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4063,
+      "good": 0.3375,
+      "ratio": 0.8307,
+      "suggested_scalar": -0.4251,
+      "log_bad": -0.9007,
+      "log_good": -1.0862
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.8281,
+      "good": 4.425,
+      "ratio": 0.9165,
+      "suggested_scalar": -0.1997,
+      "log_bad": 1.5745,
+      "log_good": 1.4873
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1509,
+      "good": 0.1607,
+      "ratio": 1.0649,
+      "suggested_scalar": 0.1442,
+      "log_bad": -1.8911,
+      "log_good": -1.8282
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.6248,
+      "good": 6.0396,
+      "ratio": 1.3059,
+      "suggested_scalar": 0.6115,
+      "log_bad": 1.5314,
+      "log_good": 1.7983
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 305.0,
+      "good": 378.0,
+      "ratio": 1.2393,
+      "suggested_scalar": 0.4916,
+      "log_bad": 5.7203,
+      "log_good": 5.9349
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 62.0,
+      "good": 123.0,
+      "ratio": 1.9839,
+      "suggested_scalar": 1.5695,
+      "log_bad": 4.1271,
+      "log_good": 4.8122
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1635.1796,
+      "good": 3761.9309,
+      "ratio": 2.3006,
+      "suggested_scalar": 1.9089,
+      "log_bad": 7.3995,
+      "log_good": 8.2327
+    },
+    "readability.mean_total_lines": {
+      "bad": 45.0,
+      "good": 47.0,
+      "ratio": 1.0444,
+      "suggested_scalar": 0.0996,
+      "log_bad": 3.8067,
+      "log_good": 3.8501
+    },
+    "indentation.mean_max_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "halstead.mean_volume": {
+      "bad": 1447.134,
+      "good": 2161.8889,
+      "ratio": 1.4939,
+      "suggested_scalar": 0.9196,
+      "log_bad": 7.2773,
+      "log_good": 7.6787
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 531.0,
+      "good": 506.0,
+      "ratio": 0.9529,
+      "suggested_scalar": -0.1105,
+      "log_bad": 6.2748,
+      "log_good": 6.2265
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 24.7333,
+      "good": 26.4681,
+      "ratio": 1.0701,
+      "suggested_scalar": 0.1553,
+      "log_bad": 3.2082,
+      "log_good": 3.2759
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.125,
+      "good": 1.1658,
+      "ratio": 1.0363,
+      "suggested_scalar": 0.0816,
+      "log_bad": 0.1178,
+      "log_good": 0.1534
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 16.0,
+      "good": 27.0,
+      "ratio": 1.6875,
+      "suggested_scalar": 1.1988,
+      "log_bad": 2.7726,
+      "log_good": 3.2958
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 4.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -1.2821,
+      "log_bad": 1.9459,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7438,
+      "good": 0.5,
+      "ratio": 0.6722,
+      "suggested_scalar": -0.9099,
+      "log_bad": -0.296,
+      "log_good": -0.6931
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9714,
+      "good": 0.9446,
+      "ratio": 0.9724,
+      "suggested_scalar": -0.0641,
+      "log_bad": -0.029,
+      "log_good": -0.057
+    },
+    "halstead.mean_length": {
+      "bad": 227.0,
+      "good": 341.0,
+      "ratio": 1.5022,
+      "suggested_scalar": 0.9323,
+      "log_bad": 5.425,
+      "log_good": 5.8319
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.6667,
+      "good": 11.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4567,
+      "log_good": 2.4567
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4263,
+      "good": 6.3923,
+      "ratio": 0.9947,
+      "suggested_scalar": -0.0122,
+      "log_bad": 1.8604,
+      "log_good": 1.8551
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1123,
+      "good": 0.1369,
+      "ratio": 1.2191,
+      "suggested_scalar": 0.4538,
+      "log_bad": -2.1866,
+      "log_good": -1.9885
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 20.339,
+      "good": 31.322,
+      "ratio": 1.54,
+      "suggested_scalar": 0.9893,
+      "log_bad": 3.0125,
+      "log_good": 3.4443
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 8.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.3059,
+      "log_bad": 1.9459,
+      "log_good": 2.0794
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 52.0,
+      "good": 54.0,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0865,
+      "log_bad": 3.9512,
+      "log_good": 3.989
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6049,
+      "good": 0.3798,
+      "ratio": 0.6279,
+      "suggested_scalar": -1.0663,
+      "log_bad": -0.5027,
+      "log_good": -0.9681
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 45.0,
+      "good": 47.0,
+      "ratio": 1.0444,
+      "suggested_scalar": 0.0996,
+      "log_bad": 3.8067,
+      "log_good": 3.8501
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.with_expression_handles_happy_path_only": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 37.0,
+      "good": 47.0,
+      "ratio": 1.2703,
+      "suggested_scalar": 0.2257,
+      "log_bad": 3.6109,
+      "log_good": 3.8501
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0129,
+      "good": 0.0163,
+      "ratio": 1.2636,
+      "suggested_scalar": 0.2207,
+      "log_bad": -4.3505,
+      "log_good": -4.1166
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.4,
+      "good": 1.75,
+      "ratio": 1.25,
+      "suggested_scalar": 0.2105,
+      "log_bad": 0.3365,
+      "log_good": 0.5596
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.98,
+      "good": 0.8302,
+      "ratio": 0.8471,
+      "suggested_scalar": -0.1565,
+      "log_bad": -0.0202,
+      "log_good": -0.1861
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0129,
+      "good": 0.0163,
+      "ratio": 1.2636,
+      "suggested_scalar": 0.2207,
+      "log_bad": -4.3505,
+      "log_good": -4.1166
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6381,
+      "good": 4.7395,
+      "ratio": 1.0219,
+      "suggested_scalar": 0.0204,
+      "log_bad": 1.5343,
+      "log_good": 1.5559
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 103.0,
+      "good": 83.0,
+      "ratio": 0.8058,
+      "suggested_scalar": -0.2036,
+      "log_bad": 4.6347,
+      "log_good": 4.4188
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5602,
+      "good": 0.4506,
+      "ratio": 0.8044,
+      "suggested_scalar": -0.2054,
+      "log_bad": -0.5795,
+      "log_good": -0.7972
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 16.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0572,
+      "log_bad": 2.8332,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6632,
+      "good": 0.5339,
+      "ratio": 0.805,
+      "suggested_scalar": -0.2046,
+      "log_bad": -0.4107,
+      "log_good": -0.6275
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.5,
+      "good": 3.717,
+      "ratio": 0.6758,
+      "suggested_scalar": -0.3696,
+      "log_bad": 1.7047,
+      "log_good": 1.3129
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 465.0,
+      "good": 552.0,
+      "ratio": 1.1871,
+      "suggested_scalar": 0.1618,
+      "log_bad": 6.142,
+      "log_good": 6.3135
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.12,
+      "good": 1.0,
+      "ratio": 8.3333,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.1203,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0131,
+      "good": 1.1077,
+      "ratio": 1.0934,
+      "suggested_scalar": 0.0842,
+      "log_bad": 0.013,
+      "log_good": 0.1023
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 162.0,
+      "good": 179.0,
+      "ratio": 1.1049,
+      "suggested_scalar": 0.0941,
+      "log_bad": 5.0876,
+      "log_good": 5.1874
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 92.8465,
+      "good": 94.6681,
+      "ratio": 1.0196,
+      "suggested_scalar": 0.0183,
+      "log_bad": 4.5309,
+      "log_good": 4.5504
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5539,
+      "good": 0.7114,
+      "ratio": 1.2843,
+      "suggested_scalar": 0.2361,
+      "log_bad": -0.5908,
+      "log_good": -0.3405
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 15.1214,
+      "good": 19.1525,
+      "ratio": 1.2666,
+      "suggested_scalar": 0.2229,
+      "log_bad": 2.7161,
+      "log_good": 2.9524
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2081.0,
+      "good": 2191.0,
+      "ratio": 1.0529,
+      "suggested_scalar": 0.0486,
+      "log_bad": 7.6406,
+      "log_good": 7.6921
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.24,
+      "good": 0.1698,
+      "ratio": 0.7075,
+      "suggested_scalar": -0.3264,
+      "log_bad": -1.4271,
+      "log_good": -1.7731
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.92,
+      "good": 0.7925,
+      "ratio": 0.8614,
+      "suggested_scalar": -0.1407,
+      "log_bad": -0.0834,
+      "log_good": -0.2326
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.5682,
+      "good": 10.4151,
+      "ratio": 0.9855,
+      "suggested_scalar": -0.0138,
+      "log_bad": 2.3578,
+      "log_good": 2.3433
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.2714,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 9.17,
+      "good": 6.3539,
+      "ratio": 0.6929,
+      "suggested_scalar": -0.3461,
+      "log_bad": 2.2159,
+      "log_good": 1.8491
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 126.0,
+      "good": 148.0,
+      "ratio": 1.1746,
+      "suggested_scalar": 0.1518,
+      "log_bad": 4.8363,
+      "log_good": 4.9972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9603,
+      "good": 0.9653,
+      "ratio": 1.0052,
+      "suggested_scalar": 0.0049,
+      "log_bad": -0.0405,
+      "log_good": -0.0353
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 27.0,
+      "ratio": 0.931,
+      "suggested_scalar": -0.0674,
+      "log_bad": 3.3673,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6276,
+      "good": 0.6641,
+      "ratio": 1.0582,
+      "suggested_scalar": 0.0533,
+      "log_bad": -0.4659,
+      "log_good": -0.4093
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3564,
+      "good": 0.5709,
+      "ratio": 1.6019,
+      "suggested_scalar": 0.4444,
+      "log_bad": -1.0317,
+      "log_good": -0.5605
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6852,
+      "good": 2.9769,
+      "ratio": 1.1086,
+      "suggested_scalar": 0.0973,
+      "log_bad": 0.9878,
+      "log_good": 1.0909
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 463.0,
+      "good": 550.0,
+      "ratio": 1.1879,
+      "suggested_scalar": 0.1624,
+      "log_bad": 6.1377,
+      "log_good": 6.3099
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 38.0,
+      "good": 18.0,
+      "ratio": 0.4737,
+      "suggested_scalar": -0.7048,
+      "log_bad": 3.6376,
+      "log_good": 2.8904
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.028,
+      "good": 0.0145,
+      "ratio": 0.5179,
+      "suggested_scalar": -0.6207,
+      "log_bad": -3.5756,
+      "log_good": -4.2336
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.7549,
+      "ratio": 0.9866,
+      "suggested_scalar": -0.0127,
+      "log_bad": 1.7635,
+      "log_good": 1.7501
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 33.0,
+      "good": 27.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.1893,
+      "log_bad": 3.4965,
+      "log_good": 3.2958
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8562,
+      "good": 0.761,
+      "ratio": 0.8888,
+      "suggested_scalar": -0.1112,
+      "log_bad": -0.1553,
+      "log_good": -0.2731
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7015,
+      "good": 5.4627,
+      "ratio": 0.9581,
+      "suggested_scalar": -0.0404,
+      "log_bad": 1.7407,
+      "log_good": 1.6979
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7952,
+      "good": 0.8236,
+      "ratio": 1.0357,
+      "suggested_scalar": 0.0331,
+      "log_bad": -0.2292,
+      "log_good": -0.1941
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1525,
+      "good": 0.1017,
+      "ratio": 0.6669,
+      "suggested_scalar": -0.3822,
+      "log_bad": -1.8806,
+      "log_good": -2.2857
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.8886,
+      "good": 4.3764,
+      "ratio": 1.1254,
+      "suggested_scalar": 0.1115,
+      "log_bad": 1.358,
+      "log_good": 1.4762
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 349.0,
+      "good": 331.0,
+      "ratio": 0.9484,
+      "suggested_scalar": -0.0499,
+      "log_bad": 5.8551,
+      "log_good": 5.8021
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 9.0,
+      "good": 14.0,
+      "ratio": 1.5556,
+      "suggested_scalar": 0.4168,
+      "log_bad": 2.1972,
+      "log_good": 2.6391
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9272,
+      "good": 1.037,
+      "ratio": 1.1184,
+      "suggested_scalar": 0.1056,
+      "log_bad": -0.0756,
+      "log_good": 0.0363
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 115.0,
+      "good": 106.0,
+      "ratio": 0.9217,
+      "suggested_scalar": -0.0769,
+      "log_bad": 4.7449,
+      "log_good": 4.6634
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1187.0,
+      "good": 1282.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.0726,
+      "log_bad": 7.0792,
+      "log_good": 7.1562
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 152.0,
+      "good": 156.0,
+      "ratio": 1.0263,
+      "suggested_scalar": 0.0245,
+      "log_bad": 5.0239,
+      "log_good": 5.0499
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0151,
+      "good": 0.0127,
+      "ratio": 0.8411,
+      "suggested_scalar": -0.1633,
+      "log_bad": -4.1931,
+      "log_good": -4.3662
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2602,
+      "good": 0.2627,
+      "ratio": 1.0096,
+      "suggested_scalar": 0.009,
+      "log_bad": -1.3463,
+      "log_good": -1.3367
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 68.0,
+      "good": 95.0,
+      "ratio": 1.3971,
+      "suggested_scalar": 0.3154,
+      "log_bad": 4.2195,
+      "log_good": 4.5539
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 8.0,
+      "ratio": 1.6,
+      "suggested_scalar": 0.4433,
+      "log_bad": 1.6094,
+      "log_good": 2.0794
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 115.0,
+      "good": 106.0,
+      "ratio": 0.9217,
+      "suggested_scalar": -0.0769,
+      "log_bad": 4.7449,
+      "log_good": 4.6634
+    },
+    "brevity.mean_sample_size": {
+      "bad": 115.0,
+      "good": 106.0,
+      "ratio": 0.9217,
+      "suggested_scalar": -0.0769,
+      "log_bad": 4.7449,
+      "log_good": 4.6634
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 465.0,
+      "good": 552.0,
+      "ratio": 1.1871,
+      "suggested_scalar": 0.1618,
+      "log_bad": 6.142,
+      "log_good": 6.3135
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 257.0,
+      "good": 325.0,
+      "ratio": 1.2646,
+      "suggested_scalar": 0.2214,
+      "log_bad": 5.5491,
+      "log_good": 5.7838
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 275.0,
+      "good": 254.0,
+      "ratio": 0.9236,
+      "suggested_scalar": -0.0749,
+      "log_bad": 5.6168,
+      "log_good": 5.5373
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.0046,
+      "good": 3.8537,
+      "ratio": 1.9224,
+      "suggested_scalar": 0.6165,
+      "log_bad": 0.6954,
+      "log_good": 1.349
+    },
+    "halstead.mean_effort": {
+      "bad": 82846.103,
+      "good": 116996.5451,
+      "ratio": 1.4122,
+      "suggested_scalar": 0.3256,
+      "log_bad": 11.3247,
+      "log_good": 11.6699
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8329,
+      "good": 0.8119,
+      "ratio": 0.9748,
+      "suggested_scalar": -0.0241,
+      "log_bad": -0.1828,
+      "log_good": -0.2084
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 74.0,
+      "good": 56.0,
+      "ratio": 0.7568,
+      "suggested_scalar": -0.2629,
+      "log_bad": 4.3041,
+      "log_good": 4.0254
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 264.0,
+      "good": 332.0,
+      "ratio": 1.2576,
+      "suggested_scalar": 0.2162,
+      "log_bad": 5.5759,
+      "log_good": 5.8051
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4815,
+      "good": 0.4134,
+      "ratio": 0.8586,
+      "suggested_scalar": -0.1438,
+      "log_bad": -0.7308,
+      "log_good": -0.8833
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.3272,
+      "good": 7.162,
+      "ratio": 0.9775,
+      "suggested_scalar": -0.0215,
+      "log_bad": 1.9916,
+      "log_good": 1.9688
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1525,
+      "good": 0.1017,
+      "ratio": 0.6669,
+      "suggested_scalar": -0.3822,
+      "log_bad": -1.8806,
+      "log_good": -2.2857
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.6194,
+      "good": 4.7018,
+      "ratio": 1.0178,
+      "suggested_scalar": 0.0167,
+      "log_bad": 1.5303,
+      "log_good": 1.5479
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 464.0,
+      "good": 551.0,
+      "ratio": 1.1875,
+      "suggested_scalar": 0.1621,
+      "log_bad": 6.1399,
+      "log_good": 6.3117
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 4.0,
+      "good": 2.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.6538,
+      "log_bad": 1.3863,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 51.0,
+      "good": 95.0,
+      "ratio": 1.8627,
+      "suggested_scalar": 0.5868,
+      "log_bad": 3.9318,
+      "log_good": 4.5539
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4602.5613,
+      "good": 6499.8081,
+      "ratio": 1.4122,
+      "suggested_scalar": 0.3256,
+      "log_bad": 8.4344,
+      "log_good": 8.7795
+    },
+    "readability.mean_total_lines": {
+      "bad": 44.0,
+      "good": 53.0,
+      "ratio": 1.2045,
+      "suggested_scalar": 0.1755,
+      "log_bad": 3.7842,
+      "log_good": 3.9703
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 2781.5842,
+      "good": 3111.0192,
+      "ratio": 1.1184,
+      "suggested_scalar": 0.1056,
+      "log_bad": 7.9308,
+      "log_good": 8.0427
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 775.0,
+      "good": 736.0,
+      "ratio": 0.9497,
+      "suggested_scalar": -0.0487,
+      "log_bad": 6.6529,
+      "log_good": 6.6012
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 38.6818,
+      "good": 40.2264,
+      "ratio": 1.0399,
+      "suggested_scalar": 0.0369,
+      "log_bad": 3.6554,
+      "log_good": 3.6945
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2206,
+      "good": 1.2009,
+      "ratio": 0.9839,
+      "suggested_scalar": -0.0153,
+      "log_bad": 0.1993,
+      "log_good": 0.1831
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 18.0,
+      "good": 19.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.051,
+      "log_bad": 2.8904,
+      "log_good": 2.9444
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 1.0,
+      "ratio": 0.1667,
+      "suggested_scalar": -1.6901,
+      "log_bad": 1.7918,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8539,
+      "good": 0.713,
+      "ratio": 0.835,
+      "suggested_scalar": -0.1701,
+      "log_bad": -0.1579,
+      "log_good": -0.3383
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.6538,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9874,
+      "good": 0.9589,
+      "ratio": 0.9711,
+      "suggested_scalar": -0.0276,
+      "log_bad": -0.0127,
+      "log_good": -0.042
+    },
+    "halstead.mean_length": {
+      "bad": 416.0,
+      "good": 488.0,
+      "ratio": 1.1731,
+      "suggested_scalar": 0.1506,
+      "log_bad": 6.0307,
+      "log_good": 6.1903
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.4,
+      "good": 5.375,
+      "ratio": 0.5718,
+      "suggested_scalar": -0.5272,
+      "log_bad": 2.2407,
+      "log_good": 1.6818
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8455,
+      "good": 6.7279,
+      "ratio": 0.9828,
+      "suggested_scalar": -0.0163,
+      "log_bad": 1.9236,
+      "log_good": 1.9063
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1235,
+      "good": 0.1483,
+      "ratio": 1.2008,
+      "suggested_scalar": 0.1726,
+      "log_bad": -2.0915,
+      "log_good": -1.9085
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.7838,
+      "good": 37.6071,
+      "ratio": 1.2627,
+      "suggested_scalar": 0.22,
+      "log_bad": 3.394,
+      "log_good": 3.6272
+    },
+    "branching.mean_branch_count": {
+      "bad": 12.0,
+      "good": 9.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.2714,
+      "log_bad": 2.4849,
+      "log_good": 2.1972
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 78.0,
+      "good": 74.0,
+      "ratio": 0.9487,
+      "suggested_scalar": -0.0497,
+      "log_bad": 4.3567,
+      "log_good": 4.3041
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7527,
+      "good": 0.626,
+      "ratio": 0.8317,
+      "suggested_scalar": -0.1739,
+      "log_bad": -0.2841,
+      "log_good": -0.4684
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 50.0,
+      "good": 53.0,
+      "ratio": 1.06,
+      "suggested_scalar": 0.055,
+      "log_bad": 3.912,
+      "log_good": 3.9703
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 23.0,
+      "ratio": 1.2778,
+      "suggested_scalar": 0.2312,
+      "log_bad": 2.8904,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.uses_assertive_map_access": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 35.0,
+      "good": 33.0,
+      "ratio": 0.9429,
+      "suggested_scalar": -0.1284,
+      "log_bad": 3.5553,
+      "log_good": 3.4965
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0157,
+      "good": 0.0315,
+      "ratio": 2.0064,
+      "suggested_scalar": 1.5199,
+      "log_bad": -4.1541,
+      "log_good": -3.4578
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.8571,
+      "good": 1.8571,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.619,
+      "log_good": 0.619
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.95,
+      "good": 0.8824,
+      "ratio": 0.9288,
+      "suggested_scalar": -0.1611,
+      "log_bad": -0.0513,
+      "log_good": -0.1251
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0157,
+      "good": 0.0315,
+      "ratio": 2.0064,
+      "suggested_scalar": 1.5199,
+      "log_bad": -4.1541,
+      "log_good": -3.4578
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6441,
+      "good": 4.6996,
+      "ratio": 1.012,
+      "suggested_scalar": 0.0259,
+      "log_bad": 1.5356,
+      "log_good": 1.5475
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 134.0,
+      "good": 113.0,
+      "ratio": 0.8433,
+      "suggested_scalar": -0.372,
+      "log_bad": 4.8978,
+      "log_good": 4.7274
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5195,
+      "good": 0.5122,
+      "ratio": 0.9859,
+      "suggested_scalar": -0.0309,
+      "log_bad": -0.6549,
+      "log_good": -0.669
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 22.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.208,
+      "log_bad": 2.9957,
+      "log_good": 3.091
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6706,
+      "good": 0.6171,
+      "ratio": 0.9202,
+      "suggested_scalar": -0.1815,
+      "log_bad": -0.3996,
+      "log_good": -0.4827
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.4333,
+      "good": 3.3529,
+      "ratio": 0.9766,
+      "suggested_scalar": -0.0517,
+      "log_bad": 1.2335,
+      "log_good": 1.2098
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 511.0,
+      "good": 539.0,
+      "ratio": 1.0548,
+      "suggested_scalar": 0.1164,
+      "log_bad": 6.2364,
+      "log_good": 6.2897
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.15,
+      "good": 0.0882,
+      "ratio": 0.588,
+      "suggested_scalar": -1.1591,
+      "log_bad": -1.8971,
+      "log_good": -2.4281
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9506,
+      "good": 0.9713,
+      "ratio": 1.0218,
+      "suggested_scalar": 0.047,
+      "log_bad": -0.0507,
+      "log_good": -0.0291
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 209.0,
+      "good": 212.0,
+      "ratio": 1.0144,
+      "suggested_scalar": 0.0311,
+      "log_bad": 5.3423,
+      "log_good": 5.3566
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.1596,
+      "good": 103.7899,
+      "ratio": 1.026,
+      "suggested_scalar": 0.056,
+      "log_bad": 4.6167,
+      "log_good": 4.6424
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.502,
+      "good": 0.5706,
+      "ratio": 1.1367,
+      "suggested_scalar": 0.2796,
+      "log_bad": -0.6892,
+      "log_good": -0.5611
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.433,
+      "good": 10.7639,
+      "ratio": 1.1411,
+      "suggested_scalar": 0.2881,
+      "log_bad": 2.2442,
+      "log_good": 2.3762
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2258.0,
+      "good": 2418.0,
+      "ratio": 1.0709,
+      "suggested_scalar": 0.1494,
+      "log_bad": 7.7222,
+      "log_good": 7.7907
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1333,
+      "good": 0.1324,
+      "ratio": 0.9932,
+      "suggested_scalar": -0.0148,
+      "log_bad": -2.0152,
+      "log_good": -2.0219
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9167,
+      "good": 0.8529,
+      "ratio": 0.9304,
+      "suggested_scalar": -0.1575,
+      "log_bad": -0.087,
+      "log_good": -0.1591
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.0196,
+      "good": 8.6935,
+      "ratio": 0.8676,
+      "suggested_scalar": -0.3099,
+      "log_bad": 2.3045,
+      "log_good": 2.1626
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 1.5129,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.4122,
+      "good": 2.5225,
+      "ratio": 1.0457,
+      "suggested_scalar": 0.0976,
+      "log_bad": 0.8805,
+      "log_good": 0.9253
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 185.0,
+      "good": 178.0,
+      "ratio": 0.9622,
+      "suggested_scalar": -0.0842,
+      "log_bad": 5.2204,
+      "log_good": 5.1818
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9448,
+      "good": 0.9392,
+      "ratio": 0.9941,
+      "suggested_scalar": -0.013,
+      "log_bad": -0.0568,
+      "log_good": -0.0627
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 33.0,
+      "good": 32.0,
+      "ratio": 0.9697,
+      "suggested_scalar": -0.0672,
+      "log_bad": 3.4965,
+      "log_good": 3.4657
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6112,
+      "good": 0.6435,
+      "ratio": 1.0528,
+      "suggested_scalar": 0.1124,
+      "log_bad": -0.4923,
+      "log_good": -0.4408
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3084,
+      "good": 0.3538,
+      "ratio": 1.1472,
+      "suggested_scalar": 0.2998,
+      "log_bad": -1.1764,
+      "log_good": -1.039
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5718,
+      "good": 2.8051,
+      "ratio": 1.0907,
+      "suggested_scalar": 0.1895,
+      "log_bad": 0.9446,
+      "log_good": 1.0314
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 509.0,
+      "good": 537.0,
+      "ratio": 1.055,
+      "suggested_scalar": 0.1169,
+      "log_bad": 6.2324,
+      "log_good": 6.286
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 23.0,
+      "good": 24.0,
+      "ratio": 1.0435,
+      "suggested_scalar": 0.0929,
+      "log_bad": 3.1355,
+      "log_good": 3.1781
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0274,
+      "good": 0.0204,
+      "ratio": 0.7445,
+      "suggested_scalar": -0.6439,
+      "log_bad": -3.5972,
+      "log_good": -3.8922
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.858,
+      "good": 5.9773,
+      "ratio": 1.0204,
+      "suggested_scalar": 0.044,
+      "log_bad": 1.7678,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 22.0,
+      "good": 30.0,
+      "ratio": 1.3636,
+      "suggested_scalar": 0.677,
+      "log_bad": 3.091,
+      "log_good": 3.4012
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.5618,
+      "good": 0.719,
+      "ratio": 1.2798,
+      "suggested_scalar": 0.5385,
+      "log_bad": -0.5766,
+      "log_good": -0.3299
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.2201,
+      "good": 6.1196,
+      "ratio": 0.9838,
+      "suggested_scalar": -0.0356,
+      "log_bad": 1.8278,
+      "log_good": 1.8115
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7928,
+      "good": 0.7862,
+      "ratio": 0.9917,
+      "suggested_scalar": -0.0182,
+      "log_bad": -0.2322,
+      "log_good": -0.2405
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1549,
+      "good": 0.15,
+      "ratio": 0.9684,
+      "suggested_scalar": -0.0702,
+      "log_bad": -1.865,
+      "log_good": -1.8971
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.0713,
+      "good": 3.2808,
+      "ratio": 1.0682,
+      "suggested_scalar": 0.144,
+      "log_bad": 1.1221,
+      "log_good": 1.1881
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 411.0,
+      "good": 420.0,
+      "ratio": 1.0219,
+      "suggested_scalar": 0.0473,
+      "log_bad": 6.0186,
+      "log_good": 6.0403
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 7.0,
+      "good": 8.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.2915,
+      "log_bad": 1.9459,
+      "log_good": 2.0794
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.107,
+      "good": 0.998,
+      "ratio": 0.9015,
+      "suggested_scalar": -0.2263,
+      "log_bad": 0.1017,
+      "log_good": -0.002
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 134.0,
+      "good": 124.0,
+      "ratio": 0.9254,
+      "suggested_scalar": -0.1693,
+      "log_bad": 4.8978,
+      "log_good": 4.8203
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1346.0,
+      "good": 1469.0,
+      "ratio": 1.0914,
+      "suggested_scalar": 0.1909,
+      "log_bad": 7.2049,
+      "log_good": 7.2923
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 211.0,
+      "good": 176.0,
+      "ratio": 0.8341,
+      "suggested_scalar": -0.3959,
+      "log_bad": 5.3519,
+      "log_good": 5.1705
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0039,
+      "good": 0.0037,
+      "ratio": 0.9487,
+      "suggested_scalar": -0.1149,
+      "log_bad": -5.5468,
+      "log_good": -5.5994
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2114,
+      "good": 0.2189,
+      "ratio": 1.0355,
+      "suggested_scalar": 0.0761,
+      "log_bad": -1.554,
+      "log_good": -1.5191
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 85.0,
+      "good": 107.0,
+      "ratio": 1.2588,
+      "suggested_scalar": 0.5024,
+      "log_bad": 4.4427,
+      "log_good": 4.6728
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 134.0,
+      "good": 124.0,
+      "ratio": 0.9254,
+      "suggested_scalar": -0.1693,
+      "log_bad": 4.8978,
+      "log_good": 4.8203
+    },
+    "brevity.mean_sample_size": {
+      "bad": 134.0,
+      "good": 124.0,
+      "ratio": 0.9254,
+      "suggested_scalar": -0.1693,
+      "log_bad": 4.8978,
+      "log_good": 4.8203
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 511.0,
+      "good": 539.0,
+      "ratio": 1.0548,
+      "suggested_scalar": 0.1164,
+      "log_bad": 6.2364,
+      "log_good": 6.2897
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 252.0,
+      "good": 283.0,
+      "ratio": 1.123,
+      "suggested_scalar": 0.2532,
+      "log_bad": 5.5294,
+      "log_good": 5.6454
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 339.0,
+      "good": 338.0,
+      "ratio": 0.9971,
+      "suggested_scalar": -0.0064,
+      "log_bad": 5.826,
+      "log_good": 5.823
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0039,
+      "good": 0.0037,
+      "ratio": 0.9487,
+      "suggested_scalar": -0.1149,
+      "log_bad": -5.5468,
+      "log_good": -5.5994
+    },
+    "heaps.mean_k": {
+      "bad": 2.2607,
+      "good": 2.7737,
+      "ratio": 1.2269,
+      "suggested_scalar": 0.4464,
+      "log_bad": 0.8157,
+      "log_good": 1.0202
+    },
+    "halstead.mean_effort": {
+      "bad": 114477.9908,
+      "good": 104089.7397,
+      "ratio": 0.9093,
+      "suggested_scalar": -0.2076,
+      "log_bad": 11.6481,
+      "log_good": 11.553
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8803,
+      "good": 0.88,
+      "ratio": 0.9997,
+      "suggested_scalar": -0.0007,
+      "log_bad": -0.1275,
+      "log_good": -0.1278
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 101.0,
+      "good": 81.0,
+      "ratio": 0.802,
+      "suggested_scalar": -0.4817,
+      "log_bad": 4.6151,
+      "log_good": 4.3944
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 259.0,
+      "good": 263.0,
+      "ratio": 1.0154,
+      "suggested_scalar": 0.0335,
+      "log_bad": 5.5568,
+      "log_good": 5.5722
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4306,
+      "good": 0.3821,
+      "ratio": 0.8874,
+      "suggested_scalar": -0.2608,
+      "log_bad": -0.8426,
+      "log_good": -0.9621
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.4402,
+      "good": 6.9292,
+      "ratio": 1.0759,
+      "suggested_scalar": 0.1597,
+      "log_bad": 1.8626,
+      "log_good": 1.9357
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1549,
+      "good": 0.15,
+      "ratio": 0.9684,
+      "suggested_scalar": -0.0702,
+      "log_bad": -1.865,
+      "log_good": -1.8971
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.0078,
+      "good": 3.4774,
+      "ratio": 0.8677,
+      "suggested_scalar": -0.3099,
+      "log_bad": 1.3882,
+      "log_good": 1.2463
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 510.0,
+      "good": 538.0,
+      "ratio": 1.0549,
+      "suggested_scalar": 0.1167,
+      "log_bad": 6.2344,
+      "log_good": 6.2879
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 59.0,
+      "good": 73.0,
+      "ratio": 1.2373,
+      "suggested_scalar": 0.4647,
+      "log_bad": 4.0775,
+      "log_good": 4.2905
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6359.8884,
+      "good": 5782.7633,
+      "ratio": 0.9093,
+      "suggested_scalar": -0.2076,
+      "log_bad": 8.7578,
+      "log_good": 8.6626
+    },
+    "readability.mean_total_lines": {
+      "bad": 51.0,
+      "good": 62.0,
+      "ratio": 1.2157,
+      "suggested_scalar": 0.4263,
+      "log_bad": 3.9318,
+      "log_good": 4.1271
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 3321.0619,
+      "good": 2994.0586,
+      "ratio": 0.9015,
+      "suggested_scalar": -0.2262,
+      "log_bad": 8.108,
+      "log_good": 8.0044
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 878.0,
+      "good": 862.0,
+      "ratio": 0.9818,
+      "suggested_scalar": -0.0401,
+      "log_bad": 6.7776,
+      "log_good": 6.7593
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.9804,
+      "good": 33.5968,
+      "ratio": 1.0505,
+      "suggested_scalar": 0.1076,
+      "log_bad": 3.4651,
+      "log_good": 3.5144
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1289,
+      "good": 1.1137,
+      "ratio": 0.9865,
+      "suggested_scalar": -0.0296,
+      "log_bad": 0.1212,
+      "log_good": 0.1077
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 17.0,
+      "good": 33.0,
+      "ratio": 1.9412,
+      "suggested_scalar": 1.4478,
+      "log_bad": 2.8332,
+      "log_good": 3.4965
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 9.0,
+      "good": 6.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.885,
+      "log_bad": 2.1972,
+      "log_good": 1.7918
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8564,
+      "good": 0.8262,
+      "ratio": 0.9647,
+      "suggested_scalar": -0.0784,
+      "log_bad": -0.155,
+      "log_good": -0.1909
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 5.0,
+      "ratio": 2.5,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.6931,
+      "log_good": 1.6094
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9762,
+      "good": 0.9812,
+      "ratio": 1.0051,
+      "suggested_scalar": 0.0112,
+      "log_bad": -0.0241,
+      "log_good": -0.019
+    },
+    "halstead.mean_length": {
+      "bad": 470.0,
+      "good": 439.0,
+      "ratio": 0.934,
+      "suggested_scalar": -0.1489,
+      "log_bad": 6.1527,
+      "log_good": 6.0845
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 8.7143,
+      "good": 9.4286,
+      "ratio": 1.082,
+      "suggested_scalar": 0.172,
+      "log_bad": 2.165,
+      "log_good": 2.2437
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.0661,
+      "good": 6.9542,
+      "ratio": 0.9842,
+      "suggested_scalar": -0.0348,
+      "log_bad": 1.9553,
+      "log_good": 1.9393
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1118,
+      "good": 0.1174,
+      "ratio": 1.0501,
+      "suggested_scalar": 0.1067,
+      "log_bad": -2.191,
+      "log_good": -2.1422
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 34.4703,
+      "good": 34.7654,
+      "ratio": 1.0086,
+      "suggested_scalar": 0.0186,
+      "log_bad": 3.5401,
+      "log_good": 3.5486
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 9.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.2571,
+      "log_bad": 2.0794,
+      "log_good": 2.1972
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 90.0,
+      "good": 81.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.23,
+      "log_bad": 4.4998,
+      "log_good": 4.3944
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7493,
+      "good": 0.6834,
+      "ratio": 0.9121,
+      "suggested_scalar": -0.2009,
+      "log_bad": -0.2886,
+      "log_good": -0.3807
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 60.0,
+      "good": 68.0,
+      "ratio": 1.1333,
+      "suggested_scalar": 0.2732,
+      "log_bad": 4.0943,
+      "log_good": 4.2195
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 21.0,
+      "ratio": 1.3125,
+      "suggested_scalar": 0.5936,
+      "log_bad": 2.7726,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.predicate_function_ends_with_question_mark": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 28.0,
+      "good": 29.0,
+      "ratio": 1.0357,
+      "suggested_scalar": 0.0248,
+      "log_bad": 3.3322,
+      "log_good": 3.3673
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.4893,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0071,
+      "good": 0.049,
+      "ratio": 6.9014,
+      "suggested_scalar": 1.3636,
+      "log_bad": -4.9477,
+      "log_good": -3.0159
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0909,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0614,
+      "log_bad": 0.0,
+      "log_good": 0.087
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9722,
+      "good": 0.7091,
+      "ratio": 0.7294,
+      "suggested_scalar": -0.2228,
+      "log_bad": -0.0282,
+      "log_good": -0.3438
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0071,
+      "good": 0.049,
+      "ratio": 6.9014,
+      "suggested_scalar": 1.3636,
+      "log_bad": -4.9477,
+      "log_good": -3.0159
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8066,
+      "good": 4.8157,
+      "ratio": 1.0019,
+      "suggested_scalar": 0.0013,
+      "log_bad": 1.57,
+      "log_good": 1.5719
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 81.0,
+      "good": 77.0,
+      "ratio": 0.9506,
+      "suggested_scalar": -0.0358,
+      "log_bad": 4.3944,
+      "log_good": 4.3438
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4285,
+      "good": 0.5253,
+      "ratio": 1.2259,
+      "suggested_scalar": 0.1438,
+      "log_bad": -0.8475,
+      "log_good": -0.6438
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 17.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.0403,
+      "log_bad": 2.8904,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5924,
+      "good": 0.5732,
+      "ratio": 0.9676,
+      "suggested_scalar": -0.0233,
+      "log_bad": -0.5236,
+      "log_good": -0.5565
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.1111,
+      "good": 2.0364,
+      "ratio": 0.9646,
+      "suggested_scalar": -0.0254,
+      "log_bad": 0.7472,
+      "log_good": 0.7112
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 423.0,
+      "good": 551.0,
+      "ratio": 1.3026,
+      "suggested_scalar": 0.1866,
+      "log_bad": 6.0474,
+      "log_good": 6.3117
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0006,
+      "good": 0.0005,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1287,
+      "log_bad": -7.4186,
+      "log_good": -7.6009
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1944,
+      "good": 1.0,
+      "ratio": 5.144,
+      "suggested_scalar": 1.1562,
+      "log_bad": -1.6378,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0024,
+      "good": 0.0083,
+      "ratio": 3.4583,
+      "suggested_scalar": 0.8759,
+      "log_bad": -6.0323,
+      "log_good": -4.7915
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0823,
+      "good": 1.1011,
+      "ratio": 1.0174,
+      "suggested_scalar": 0.0122,
+      "log_bad": 0.0791,
+      "log_good": 0.0963
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 133.0,
+      "good": 182.0,
+      "ratio": 1.3684,
+      "suggested_scalar": 0.2214,
+      "log_bad": 4.8903,
+      "log_good": 5.204
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 94.3102,
+      "good": 102.5913,
+      "ratio": 1.0878,
+      "suggested_scalar": 0.0594,
+      "log_bad": 4.5466,
+      "log_good": 4.6308
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6659,
+      "good": 0.6855,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.0205,
+      "log_bad": -0.4066,
+      "log_good": -0.3776
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 12.1059,
+      "good": 12.633,
+      "ratio": 1.0435,
+      "suggested_scalar": 0.0301,
+      "log_bad": 2.4937,
+      "log_good": 2.5363
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1635.0,
+      "good": 2177.0,
+      "ratio": 1.3315,
+      "suggested_scalar": 0.2021,
+      "log_bad": 7.3994,
+      "log_good": 7.6857
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0833,
+      "good": 0.2364,
+      "ratio": 2.8379,
+      "suggested_scalar": 0.7363,
+      "log_bad": -2.4853,
+      "log_good": -1.4422
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9444,
+      "good": 0.6909,
+      "ratio": 0.7316,
+      "suggested_scalar": -0.2206,
+      "log_bad": -0.0572,
+      "log_good": -0.3698
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 14.5862,
+      "good": 10.0182,
+      "ratio": 0.6868,
+      "suggested_scalar": -0.2652,
+      "log_bad": 2.6801,
+      "log_good": 2.3044
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.4893,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.8765,
+      "good": 0.3623,
+      "ratio": 0.4133,
+      "suggested_scalar": -0.6236,
+      "log_bad": -0.1318,
+      "log_good": -1.0153
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 101.0,
+      "good": 140.0,
+      "ratio": 1.3861,
+      "suggested_scalar": 0.2305,
+      "log_bad": 4.6151,
+      "log_good": 4.9416
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9475,
+      "good": 0.9411,
+      "ratio": 0.9932,
+      "suggested_scalar": -0.0048,
+      "log_bad": -0.0539,
+      "log_good": -0.0607
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 28.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0523,
+      "log_bad": 3.2581,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.652,
+      "good": 0.6798,
+      "ratio": 1.0426,
+      "suggested_scalar": 0.0295,
+      "log_bad": -0.4277,
+      "log_good": -0.386
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4727,
+      "good": 0.5483,
+      "ratio": 1.1599,
+      "suggested_scalar": 0.1047,
+      "log_bad": -0.7493,
+      "log_good": -0.6009
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.8735,
+      "good": 3.1234,
+      "ratio": 1.087,
+      "suggested_scalar": 0.0589,
+      "log_bad": 1.0555,
+      "log_good": 1.1389
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 421.0,
+      "good": 549.0,
+      "ratio": 1.304,
+      "suggested_scalar": 0.1874,
+      "log_bad": 6.0426,
+      "log_good": 6.3081
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 5.0,
+      "good": 9.0,
+      "ratio": 1.8,
+      "suggested_scalar": 0.4149,
+      "log_bad": 1.6094,
+      "log_good": 2.1972
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0615,
+      "good": 0.0309,
+      "ratio": 0.5024,
+      "suggested_scalar": -0.4859,
+      "log_bad": -2.7887,
+      "log_good": -3.477
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.6724,
+      "good": 5.858,
+      "ratio": 1.0327,
+      "suggested_scalar": 0.0227,
+      "log_bad": 1.7356,
+      "log_good": 1.7678
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 30.0,
+      "good": 40.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.2031,
+      "log_bad": 3.4012,
+      "log_good": 3.6889
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8772,
+      "good": 0.8431,
+      "ratio": 0.9611,
+      "suggested_scalar": -0.028,
+      "log_bad": -0.131,
+      "log_good": -0.1707
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4449,
+      "good": 5.7119,
+      "ratio": 1.049,
+      "suggested_scalar": 0.0338,
+      "log_bad": 1.6947,
+      "log_good": 1.7426
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8474,
+      "good": 0.8221,
+      "ratio": 0.9701,
+      "suggested_scalar": -0.0214,
+      "log_bad": -0.1656,
+      "log_good": -0.1959
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2174,
+      "good": 0.1538,
+      "ratio": 0.7075,
+      "suggested_scalar": -0.2443,
+      "log_bad": -1.526,
+      "log_good": -1.8721
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.4794,
+      "good": 3.5543,
+      "ratio": 1.0215,
+      "suggested_scalar": 0.015,
+      "log_bad": 1.2469,
+      "log_good": 1.2682
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.4893,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 271.0,
+      "good": 310.0,
+      "ratio": 1.1439,
+      "suggested_scalar": 0.0949,
+      "log_bad": 5.6021,
+      "log_good": 5.7366
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 9.0,
+      "good": 11.0,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.1417,
+      "log_bad": 2.1972,
+      "log_good": 2.3979
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7946,
+      "good": 0.8168,
+      "ratio": 1.0279,
+      "suggested_scalar": 0.0195,
+      "log_bad": -0.2299,
+      "log_good": -0.2024
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 87.0,
+      "good": 118.0,
+      "ratio": 1.3563,
+      "suggested_scalar": 0.2151,
+      "log_bad": 4.4659,
+      "log_good": 4.7707
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 920.0,
+      "good": 1262.0,
+      "ratio": 1.3717,
+      "suggested_scalar": 0.2231,
+      "log_bad": 6.8244,
+      "log_good": 7.1405
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 148.0,
+      "good": 145.0,
+      "ratio": 0.9797,
+      "suggested_scalar": -0.0145,
+      "log_bad": 4.9972,
+      "log_good": 4.9767
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2435,
+      "good": 0.1996,
+      "ratio": 0.8197,
+      "suggested_scalar": -0.1403,
+      "log_bad": -1.4126,
+      "log_good": -1.6114
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 65.0,
+      "good": 73.0,
+      "ratio": 1.1231,
+      "suggested_scalar": 0.0819,
+      "log_bad": 4.1744,
+      "log_good": 4.2905
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 87.0,
+      "good": 118.0,
+      "ratio": 1.3563,
+      "suggested_scalar": 0.2151,
+      "log_bad": 4.4659,
+      "log_good": 4.7707
+    },
+    "brevity.mean_sample_size": {
+      "bad": 87.0,
+      "good": 118.0,
+      "ratio": 1.3563,
+      "suggested_scalar": 0.2151,
+      "log_bad": 4.4659,
+      "log_good": 4.7707
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 423.0,
+      "good": 551.0,
+      "ratio": 1.3026,
+      "suggested_scalar": 0.1866,
+      "log_bad": 6.0474,
+      "log_good": 6.3117
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 236.0,
+      "good": 299.0,
+      "ratio": 1.2669,
+      "suggested_scalar": 0.167,
+      "log_bad": 5.4638,
+      "log_good": 5.7004
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 206.0,
+      "good": 246.0,
+      "ratio": 1.1942,
+      "suggested_scalar": 0.1253,
+      "log_bad": 5.3279,
+      "log_good": 5.5053
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.6694,
+      "good": 3.1868,
+      "ratio": 1.1938,
+      "suggested_scalar": 0.1251,
+      "log_bad": 0.9819,
+      "log_good": 1.159
+    },
+    "halstead.mean_effort": {
+      "bad": 83389.0845,
+      "good": 101512.9894,
+      "ratio": 1.2173,
+      "suggested_scalar": 0.1388,
+      "log_bad": 11.3313,
+      "log_good": 11.5279
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 6.0,
+      "ratio": 6.0,
+      "suggested_scalar": 1.2648,
+      "log_bad": 0.0,
+      "log_good": 1.7918
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8451,
+      "good": 0.8299,
+      "ratio": 0.982,
+      "suggested_scalar": -0.0128,
+      "log_bad": -0.1683,
+      "log_good": -0.1865
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 55.0,
+      "good": 49.0,
+      "ratio": 0.8909,
+      "suggested_scalar": -0.0815,
+      "log_bad": 4.0073,
+      "log_good": 3.8918
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 228.0,
+      "good": 246.0,
+      "ratio": 1.0789,
+      "suggested_scalar": 0.0536,
+      "log_bad": 5.4293,
+      "log_good": 5.5053
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.406,
+      "good": 0.4396,
+      "ratio": 1.0828,
+      "suggested_scalar": 0.0561,
+      "log_bad": -0.9014,
+      "log_good": -0.8219
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.9173,
+      "good": 6.9341,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.0017,
+      "log_bad": 1.934,
+      "log_good": 1.9365
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2174,
+      "good": 0.1538,
+      "ratio": 0.7075,
+      "suggested_scalar": -0.2443,
+      "log_bad": -1.526,
+      "log_good": -1.8721
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.4762,
+      "good": 4.1673,
+      "ratio": 0.6435,
+      "suggested_scalar": -0.3112,
+      "log_bad": 1.8681,
+      "log_good": 1.4273
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 422.0,
+      "good": 550.0,
+      "ratio": 1.3033,
+      "suggested_scalar": 0.187,
+      "log_bad": 6.045,
+      "log_good": 6.3099
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 17.0,
+      "ratio": 17.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 2.8332
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 49.0,
+      "good": 62.0,
+      "ratio": 1.2653,
+      "suggested_scalar": 0.1661,
+      "log_bad": 3.8918,
+      "log_good": 4.1271
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4632.7269,
+      "good": 5639.6105,
+      "ratio": 1.2173,
+      "suggested_scalar": 0.1388,
+      "log_bad": 8.4409,
+      "log_good": 8.6376
+    },
+    "readability.mean_total_lines": {
+      "bad": 29.0,
+      "good": 55.0,
+      "ratio": 1.8966,
+      "suggested_scalar": 0.4518,
+      "log_bad": 3.3673,
+      "log_good": 4.0073
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 4.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.2862,
+      "log_bad": 1.7918,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2383.7836,
+      "good": 2450.3135,
+      "ratio": 1.0279,
+      "suggested_scalar": 0.0194,
+      "log_bad": 7.7764,
+      "log_good": 7.804
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 569.0,
+      "good": 697.0,
+      "ratio": 1.225,
+      "suggested_scalar": 0.1432,
+      "log_bad": 6.3439,
+      "log_good": 6.5468
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 42.2414,
+      "good": 38.4,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0673,
+      "log_bad": 3.7434,
+      "log_good": 3.6481
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1551,
+      "good": 1.112,
+      "ratio": 0.9627,
+      "suggested_scalar": -0.0268,
+      "log_bad": 0.1442,
+      "log_good": 0.1062
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 7.0,
+      "good": 20.0,
+      "ratio": 2.8571,
+      "suggested_scalar": 0.7411,
+      "log_bad": 1.9459,
+      "log_good": 2.9957
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 1.0,
+      "ratio": 0.1429,
+      "suggested_scalar": -1.3736,
+      "log_bad": 1.9459,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8192,
+      "good": 0.8,
+      "ratio": 0.9766,
+      "suggested_scalar": -0.0167,
+      "log_bad": -0.1994,
+      "log_good": -0.2231
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 10.0,
+      "ratio": 5.0,
+      "suggested_scalar": 1.1361,
+      "log_bad": 0.6931,
+      "log_good": 2.3026
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9807,
+      "good": 0.9752,
+      "ratio": 0.9944,
+      "suggested_scalar": -0.004,
+      "log_bad": -0.0195,
+      "log_good": -0.0251
+    },
+    "halstead.mean_length": {
+      "bad": 376.0,
+      "good": 391.0,
+      "ratio": 1.0399,
+      "suggested_scalar": 0.0276,
+      "log_bad": 5.9296,
+      "log_good": 5.9687
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 3.3636,
+      "good": 4.8182,
+      "ratio": 1.4325,
+      "suggested_scalar": 0.2537,
+      "log_bad": 1.213,
+      "log_good": 1.5724
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4429,
+      "good": 6.8826,
+      "ratio": 1.0682,
+      "suggested_scalar": 0.0466,
+      "log_bad": 1.863,
+      "log_good": 1.929
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1443,
+      "good": 0.1373,
+      "ratio": 0.9515,
+      "suggested_scalar": -0.0351,
+      "log_bad": -1.9359,
+      "log_good": -1.9856
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 34.9818,
+      "good": 41.4286,
+      "ratio": 1.1843,
+      "suggested_scalar": 0.1194,
+      "log_bad": 3.5548,
+      "log_good": 3.724
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 13.0,
+      "ratio": 4.3333,
+      "suggested_scalar": 1.0351,
+      "log_bad": 1.0986,
+      "log_good": 2.5649
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 54.0,
+      "good": 80.0,
+      "ratio": 1.4815,
+      "suggested_scalar": 0.2775,
+      "log_bad": 3.989,
+      "log_good": 4.382
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6845,
+      "good": 0.7033,
+      "ratio": 1.0275,
+      "suggested_scalar": 0.0191,
+      "log_bad": -0.3791,
+      "log_good": -0.352
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 36.0,
+      "good": 55.0,
+      "ratio": 1.5278,
+      "suggested_scalar": 0.2992,
+      "log_bad": 3.5835,
+      "log_good": 4.0073
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 15.0,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.0487,
+      "log_bad": 2.6391,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_duplicate_enum_values": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 5.0,
+      "good": 7.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.2897,
+      "log_bad": 1.6094,
+      "log_good": 1.9459
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 10.0,
+      "good": 12.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.157,
+      "log_bad": 2.3026,
+      "log_good": 2.4849
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0518,
+      "good": 0.0369,
+      "ratio": 0.7124,
+      "suggested_scalar": -0.292,
+      "log_bad": -2.9604,
+      "log_good": -3.2995
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8889,
+      "good": 0.8824,
+      "ratio": 0.9927,
+      "suggested_scalar": -0.0063,
+      "log_bad": -0.1178,
+      "log_good": -0.1251
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0518,
+      "good": 0.0369,
+      "ratio": 0.7124,
+      "suggested_scalar": -0.292,
+      "log_bad": -2.9604,
+      "log_good": -3.2995
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7463,
+      "good": 4.7413,
+      "ratio": 0.9989,
+      "suggested_scalar": -0.0009,
+      "log_bad": 1.5574,
+      "log_good": 1.5563
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 70.0,
+      "good": 64.0,
+      "ratio": 0.9143,
+      "suggested_scalar": -0.0772,
+      "log_bad": 4.2485,
+      "log_good": 4.1589
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5056,
+      "good": 0.5067,
+      "ratio": 1.0022,
+      "suggested_scalar": 0.0019,
+      "log_bad": -0.682,
+      "log_good": -0.6798
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 13.0,
+      "good": 12.0,
+      "ratio": 0.9231,
+      "suggested_scalar": -0.0689,
+      "log_bad": 2.5649,
+      "log_good": 2.4849
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6864,
+      "good": 0.6882,
+      "ratio": 1.0026,
+      "suggested_scalar": 0.0023,
+      "log_bad": -0.3763,
+      "log_good": -0.3737
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.4667,
+      "good": 1.9216,
+      "ratio": 1.3102,
+      "suggested_scalar": 0.2326,
+      "log_bad": 0.383,
+      "log_good": 0.6532
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 251.0,
+      "good": 244.0,
+      "ratio": 0.9721,
+      "suggested_scalar": -0.0244,
+      "log_bad": 5.5255,
+      "log_good": 5.4972
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9457,
+      "good": 0.9727,
+      "ratio": 1.0286,
+      "suggested_scalar": 0.0242,
+      "log_bad": -0.0558,
+      "log_good": -0.0277
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 89.0,
+      "good": 75.0,
+      "ratio": 0.8427,
+      "suggested_scalar": -0.1474,
+      "log_bad": 4.4886,
+      "log_good": 4.3175
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 97.2364,
+      "good": 92.2502,
+      "ratio": 0.9487,
+      "suggested_scalar": -0.0453,
+      "log_bad": 4.5771,
+      "log_good": 4.5245
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.496,
+      "good": 0.4156,
+      "ratio": 0.8379,
+      "suggested_scalar": -0.1523,
+      "log_bad": -0.7012,
+      "log_good": -0.878
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 28.3123,
+      "good": 34.7566,
+      "ratio": 1.2276,
+      "suggested_scalar": 0.1766,
+      "log_bad": 3.3433,
+      "log_good": 3.5484
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1266.0,
+      "good": 1338.0,
+      "ratio": 1.0569,
+      "suggested_scalar": 0.0476,
+      "log_bad": 7.1436,
+      "log_good": 7.1989
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 0.098,
+      "ratio": 0.098,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -2.3228
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8889,
+      "good": 0.8627,
+      "ratio": 0.9705,
+      "suggested_scalar": -0.0258,
+      "log_bad": -0.1178,
+      "log_good": -0.1477
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.5778,
+      "good": 4.7843,
+      "ratio": 0.8577,
+      "suggested_scalar": -0.1321,
+      "log_bad": 1.7188,
+      "log_good": 1.5653
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.1378,
+      "good": 2.9742,
+      "ratio": 2.614,
+      "suggested_scalar": 0.8273,
+      "log_bad": 0.1291,
+      "log_good": 1.09
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 34.0,
+      "good": 27.0,
+      "ratio": 0.7941,
+      "suggested_scalar": -0.1985,
+      "log_bad": 3.5264,
+      "log_good": 3.2958
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9599,
+      "good": 0.9378,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0201,
+      "log_bad": -0.0409,
+      "log_good": -0.0642
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 16.0,
+      "good": 17.0,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.0522,
+      "log_bad": 2.7726,
+      "log_good": 2.8332
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6295,
+      "good": 0.648,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.0249,
+      "log_bad": -0.4628,
+      "log_good": -0.4339
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3414,
+      "good": 0.2025,
+      "ratio": 0.5931,
+      "suggested_scalar": -0.4497,
+      "log_bad": -1.0747,
+      "log_good": -1.597
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6994,
+      "good": 2.8408,
+      "ratio": 1.0524,
+      "suggested_scalar": 0.044,
+      "log_bad": 0.993,
+      "log_good": 1.0441
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 249.0,
+      "good": 242.0,
+      "ratio": 0.9719,
+      "suggested_scalar": -0.0246,
+      "log_bad": 5.5175,
+      "log_good": 5.4889
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 9.0,
+      "good": 13.0,
+      "ratio": 1.4444,
+      "suggested_scalar": 0.3166,
+      "log_bad": 2.1972,
+      "log_good": 2.5649
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0359,
+      "good": 0.0574,
+      "ratio": 1.5989,
+      "suggested_scalar": 0.4041,
+      "log_bad": -3.327,
+      "log_good": -2.8577
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.8826,
+      "ratio": 1.0085,
+      "suggested_scalar": 0.0073,
+      "log_bad": 1.7635,
+      "log_good": 1.772
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 50.0,
+      "good": 41.0,
+      "ratio": 0.82,
+      "suggested_scalar": -0.1709,
+      "log_bad": 3.912,
+      "log_good": 3.7136
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2311,
+      "good": 1.3262,
+      "ratio": 1.0772,
+      "suggested_scalar": 0.0641,
+      "log_bad": 0.2079,
+      "log_good": 0.2823
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.2698,
+      "good": 5.3106,
+      "ratio": 1.0077,
+      "suggested_scalar": 0.0066,
+      "log_bad": 1.662,
+      "log_good": 1.6697
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8137,
+      "good": 0.806,
+      "ratio": 0.9905,
+      "suggested_scalar": -0.0082,
+      "log_bad": -0.2062,
+      "log_good": -0.2157
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1176,
+      "good": 0.1207,
+      "ratio": 1.0264,
+      "suggested_scalar": 0.0224,
+      "log_bad": -2.1405,
+      "log_good": -2.1144
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 5.3209,
+      "good": 5.8955,
+      "ratio": 1.108,
+      "suggested_scalar": 0.0883,
+      "log_bad": 1.6716,
+      "log_good": 1.7742
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.3491,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 199.0,
+      "good": 215.0,
+      "ratio": 1.0804,
+      "suggested_scalar": 0.0666,
+      "log_bad": 5.2933,
+      "log_good": 5.3706
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.157,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.4536,
+      "good": 0.43,
+      "ratio": 0.948,
+      "suggested_scalar": -0.046,
+      "log_bad": -0.7905,
+      "log_good": -0.844
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 70.0,
+      "good": 69.0,
+      "ratio": 0.9857,
+      "suggested_scalar": -0.0124,
+      "log_bad": 4.2485,
+      "log_good": 4.2341
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 787.0,
+      "good": 788.0,
+      "ratio": 1.0013,
+      "suggested_scalar": 0.0011,
+      "log_bad": 6.6682,
+      "log_good": 6.6695
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 105.0,
+      "good": 89.0,
+      "ratio": 0.8476,
+      "suggested_scalar": -0.1423,
+      "log_bad": 4.654,
+      "log_good": 4.4886
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1753,
+      "good": 0.2336,
+      "ratio": 1.3326,
+      "suggested_scalar": 0.2472,
+      "log_bad": -1.7413,
+      "log_good": -1.4541
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 39.0,
+      "good": 33.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.1438,
+      "log_bad": 3.6636,
+      "log_good": 3.4965
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.3491,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 70.0,
+      "good": 69.0,
+      "ratio": 0.9857,
+      "suggested_scalar": -0.0124,
+      "log_bad": 4.2485,
+      "log_good": 4.2341
+    },
+    "brevity.mean_sample_size": {
+      "bad": 70.0,
+      "good": 69.0,
+      "ratio": 0.9857,
+      "suggested_scalar": -0.0124,
+      "log_bad": 4.2485,
+      "log_good": 4.2341
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 251.0,
+      "good": 244.0,
+      "ratio": 0.9721,
+      "suggested_scalar": -0.0244,
+      "log_bad": 5.5255,
+      "log_good": 5.4972
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 140.0,
+      "good": 131.0,
+      "ratio": 0.9357,
+      "suggested_scalar": -0.0572,
+      "log_bad": 4.9416,
+      "log_good": 4.8752
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 165.0,
+      "good": 175.0,
+      "ratio": 1.0606,
+      "suggested_scalar": 0.0507,
+      "log_bad": 5.1059,
+      "log_good": 5.1648
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.012,
+      "good": 0.0082,
+      "ratio": 0.6833,
+      "suggested_scalar": -0.3279,
+      "log_bad": -4.4228,
+      "log_good": -4.8036
+    },
+    "heaps.mean_k": {
+      "bad": 1.5767,
+      "good": 1.7734,
+      "ratio": 1.1248,
+      "suggested_scalar": 0.1012,
+      "log_bad": 0.4553,
+      "log_good": 0.5729
+    },
+    "halstead.mean_effort": {
+      "bad": 21166.4574,
+      "good": 20763.5106,
+      "ratio": 0.981,
+      "suggested_scalar": -0.0165,
+      "log_bad": 9.9602,
+      "log_good": 9.941
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8598,
+      "good": 0.8694,
+      "ratio": 1.0112,
+      "suggested_scalar": 0.0096,
+      "log_bad": -0.1511,
+      "log_good": -0.14
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 54.0,
+      "good": 47.0,
+      "ratio": 0.8704,
+      "suggested_scalar": -0.1195,
+      "log_bad": 3.989,
+      "log_good": 3.8501
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 117.0,
+      "good": 126.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0638,
+      "log_bad": 4.7622,
+      "log_good": 4.8363
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5056,
+      "good": 0.5067,
+      "ratio": 1.0022,
+      "suggested_scalar": 0.0019,
+      "log_bad": -0.682,
+      "log_good": -0.6798
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.8427,
+      "good": 10.5067,
+      "ratio": 1.1882,
+      "suggested_scalar": 0.1485,
+      "log_bad": 2.1796,
+      "log_good": 2.352
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1176,
+      "good": 0.1207,
+      "ratio": 1.0264,
+      "suggested_scalar": 0.0224,
+      "log_bad": -2.1405,
+      "log_good": -2.1144
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.993,
+      "good": 3.4979,
+      "ratio": 1.1687,
+      "suggested_scalar": 0.1342,
+      "log_bad": 1.0963,
+      "log_good": 1.2522
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 250.0,
+      "good": 243.0,
+      "ratio": 0.972,
+      "suggested_scalar": -0.0245,
+      "log_bad": 5.5215,
+      "log_good": 5.4931
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 35.0,
+      "good": 22.0,
+      "ratio": 0.6286,
+      "suggested_scalar": -0.3998,
+      "log_bad": 3.5553,
+      "log_good": 3.091
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1175.9143,
+      "good": 1153.5284,
+      "ratio": 0.981,
+      "suggested_scalar": -0.0165,
+      "log_bad": 7.0698,
+      "log_good": 7.0506
+    },
+    "readability.mean_total_lines": {
+      "bad": 45.0,
+      "good": 51.0,
+      "ratio": 1.1333,
+      "suggested_scalar": 0.1078,
+      "log_bad": 3.8067,
+      "log_good": 3.9318
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.3491,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 1360.7008,
+      "good": 1290.0,
+      "ratio": 0.948,
+      "suggested_scalar": -0.0459,
+      "log_bad": 7.2158,
+      "log_good": 7.1624
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 469.0,
+      "good": 471.0,
+      "ratio": 1.0043,
+      "suggested_scalar": 0.0037,
+      "log_bad": 6.1506,
+      "log_good": 6.1549
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 27.0,
+      "good": 25.098,
+      "ratio": 0.9296,
+      "suggested_scalar": -0.0629,
+      "log_bad": 3.2958,
+      "log_good": 3.2228
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2286,
+      "good": 1.297,
+      "ratio": 1.0557,
+      "suggested_scalar": 0.0466,
+      "log_bad": 0.2059,
+      "log_good": 0.2601
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 6.0,
+      "good": 10.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.4398,
+      "log_bad": 1.7918,
+      "log_good": 2.3026
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8241,
+      "good": 0.8977,
+      "ratio": 1.0893,
+      "suggested_scalar": 0.0737,
+      "log_bad": -0.1935,
+      "log_good": -0.1079
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.985,
+      "good": 0.9901,
+      "ratio": 1.0052,
+      "suggested_scalar": 0.0044,
+      "log_bad": -0.0151,
+      "log_good": -0.0099
+    },
+    "halstead.mean_length": {
+      "bad": 222.0,
+      "good": 215.0,
+      "ratio": 0.9685,
+      "suggested_scalar": -0.0276,
+      "log_bad": 5.4027,
+      "log_good": 5.3706
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.5,
+      "good": 8.6667,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.2477,
+      "log_bad": 1.8718,
+      "log_good": 2.1595
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.1293,
+      "good": 6.1085,
+      "ratio": 0.9966,
+      "suggested_scalar": -0.0029,
+      "log_bad": 1.8131,
+      "log_good": 1.8097
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1106,
+      "good": 0.0979,
+      "ratio": 0.8852,
+      "suggested_scalar": -0.105,
+      "log_bad": -2.2018,
+      "log_good": -2.3238
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 15.5556,
+      "good": 16.0957,
+      "ratio": 1.0347,
+      "suggested_scalar": 0.0294,
+      "log_bad": 2.7444,
+      "log_good": 2.7786
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 1.3858,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 45.0,
+      "good": 38.0,
+      "ratio": 0.8444,
+      "suggested_scalar": -0.1456,
+      "log_bad": 3.8067,
+      "log_good": 3.6376
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7636,
+      "good": 0.8114,
+      "ratio": 1.0626,
+      "suggested_scalar": 0.0523,
+      "log_bad": -0.2697,
+      "log_good": -0.209
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 45.0,
+      "good": 51.0,
+      "ratio": 1.1333,
+      "suggested_scalar": 0.1078,
+      "log_bad": 3.8067,
+      "log_good": 3.9318
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.uses_defer_for_cleanup": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0189,
+      "good": 0.0207,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.3204,
+      "log_bad": -3.9686,
+      "log_good": -3.8776
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8254,
+      "good": 0.8448,
+      "ratio": 1.0235,
+      "suggested_scalar": 0.0818,
+      "log_bad": -0.1919,
+      "log_good": -0.1687
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0189,
+      "good": 0.0207,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.3204,
+      "log_bad": -3.9686,
+      "log_good": -3.8776
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 5.0074,
+      "good": 4.94,
+      "ratio": 0.9865,
+      "suggested_scalar": -0.0477,
+      "log_bad": 1.6109,
+      "log_good": 1.5974
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 133.0,
+      "good": 129.0,
+      "ratio": 0.9699,
+      "suggested_scalar": -0.1075,
+      "log_bad": 4.8903,
+      "log_good": 4.8598
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5475,
+      "good": 0.5486,
+      "ratio": 1.002,
+      "suggested_scalar": 0.0071,
+      "log_bad": -0.6024,
+      "log_good": -0.6004
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.0,
+      "good": 20.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.1718,
+      "log_bad": 3.0445,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6828,
+      "good": 0.7015,
+      "ratio": 1.0274,
+      "suggested_scalar": 0.0952,
+      "log_bad": -0.3816,
+      "log_good": -0.3545
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.9206,
+      "good": 0.8103,
+      "ratio": 0.8802,
+      "suggested_scalar": -0.4494,
+      "log_bad": -0.0827,
+      "log_good": -0.2104
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 528.0,
+      "good": 484.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.3064,
+      "log_bad": 6.2691,
+      "log_good": 6.1821
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0022,
+      "good": 0.0024,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.3064,
+      "log_bad": -6.1193,
+      "log_good": -6.0323
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1429,
+      "good": 0.1207,
+      "ratio": 0.8446,
+      "suggested_scalar": -0.5946,
+      "log_bad": -1.9456,
+      "log_good": -2.1144
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.967,
+      "good": 0.9393,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.1024,
+      "log_bad": -0.0336,
+      "log_good": -0.0626
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 233.0,
+      "good": 205.0,
+      "ratio": 0.8798,
+      "suggested_scalar": -0.4509,
+      "log_bad": 5.451,
+      "log_good": 5.323
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 109.8283,
+      "good": 109.5673,
+      "ratio": 0.9976,
+      "suggested_scalar": -0.0084,
+      "log_bad": 4.6989,
+      "log_good": 4.6965
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5731,
+      "good": 0.5776,
+      "ratio": 1.0079,
+      "suggested_scalar": 0.0275,
+      "log_bad": -0.5567,
+      "log_good": -0.5489
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 5.5449,
+      "good": 5.7452,
+      "ratio": 1.0361,
+      "suggested_scalar": 0.125,
+      "log_bad": 1.7129,
+      "log_good": 1.7484
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1795.0,
+      "good": 1672.0,
+      "ratio": 0.9315,
+      "suggested_scalar": -0.25,
+      "log_bad": 7.4928,
+      "log_good": 7.4218
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.127,
+      "good": 0.2241,
+      "ratio": 1.7646,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.0636,
+      "log_good": -1.4957
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7778,
+      "good": 0.8103,
+      "ratio": 1.0418,
+      "suggested_scalar": 0.1442,
+      "log_bad": -0.2513,
+      "log_good": -0.2104
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.381,
+      "good": 8.3448,
+      "ratio": 0.9957,
+      "suggested_scalar": -0.0152,
+      "log_bad": 2.126,
+      "log_good": 2.1216
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.6127,
+      "good": 0.4985,
+      "ratio": 0.8136,
+      "suggested_scalar": -0.7264,
+      "log_bad": -0.4899,
+      "log_good": -0.6962
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 178.0,
+      "good": 157.0,
+      "ratio": 0.882,
+      "suggested_scalar": -0.4421,
+      "log_bad": 5.1818,
+      "log_good": 5.0562
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9526,
+      "good": 0.9493,
+      "ratio": 0.9965,
+      "suggested_scalar": -0.0122,
+      "log_bad": -0.0486,
+      "log_good": -0.052
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 32.0,
+      "ratio": 1.1034,
+      "suggested_scalar": 0.3467,
+      "log_bad": 3.3673,
+      "log_good": 3.4657
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.556,
+      "good": 0.5562,
+      "ratio": 1.0004,
+      "suggested_scalar": 0.0013,
+      "log_bad": -0.587,
+      "log_good": -0.5866
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4202,
+      "good": 0.4149,
+      "ratio": 0.9874,
+      "suggested_scalar": -0.0447,
+      "log_bad": -0.867,
+      "log_good": -0.8797
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2522,
+      "good": 2.2534,
+      "ratio": 1.0005,
+      "suggested_scalar": 0.0019,
+      "log_bad": 0.8119,
+      "log_good": 0.8124
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 526.0,
+      "good": 482.0,
+      "ratio": 0.9163,
+      "suggested_scalar": -0.3076,
+      "log_bad": 6.2653,
+      "log_good": 6.1779
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 24.0,
+      "good": 21.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.4703,
+      "log_bad": 3.1781,
+      "log_good": 3.0445
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0208,
+      "good": 0.0227,
+      "ratio": 1.0913,
+      "suggested_scalar": 0.3078,
+      "log_bad": -3.8728,
+      "log_good": -3.7854
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.2095,
+      "good": 6.1293,
+      "ratio": 0.9871,
+      "suggested_scalar": -0.0458,
+      "log_bad": 1.8261,
+      "log_good": 1.8131
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 52.0,
+      "good": 45.0,
+      "ratio": 0.8654,
+      "suggested_scalar": -0.5092,
+      "log_bad": 3.9512,
+      "log_good": 3.8067
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8605,
+      "good": 0.8641,
+      "ratio": 1.0042,
+      "suggested_scalar": 0.0147,
+      "log_bad": -0.1502,
+      "log_good": -0.1461
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0129,
+      "good": 0.0146,
+      "ratio": 1.1318,
+      "suggested_scalar": 0.436,
+      "log_bad": -4.3505,
+      "log_good": -4.2267
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.1263,
+      "good": 6.1598,
+      "ratio": 1.0055,
+      "suggested_scalar": 0.0192,
+      "log_bad": 1.8126,
+      "log_good": 1.818
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8064,
+      "good": 0.806,
+      "ratio": 0.9995,
+      "suggested_scalar": -0.0017,
+      "log_bad": -0.2152,
+      "log_good": -0.2157
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.16,
+      "good": 0.1471,
+      "ratio": 0.9194,
+      "suggested_scalar": -0.296,
+      "log_bad": -1.8326,
+      "log_good": -1.9166
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.3548,
+      "good": 2.3969,
+      "ratio": 1.0179,
+      "suggested_scalar": 0.0624,
+      "log_bad": 0.8565,
+      "log_good": 0.8742
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 387.0,
+      "good": 365.0,
+      "ratio": 0.9432,
+      "suggested_scalar": -0.2061,
+      "log_bad": 5.9584,
+      "log_good": 5.8999
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.1171,
+      "good": 1.0143,
+      "ratio": 0.908,
+      "suggested_scalar": -0.34,
+      "log_bad": 0.1107,
+      "log_good": 0.0142
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 131.0,
+      "good": 128.0,
+      "ratio": 0.9771,
+      "suggested_scalar": -0.0816,
+      "log_bad": 4.8752,
+      "log_good": 4.852
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 995.0,
+      "good": 889.0,
+      "ratio": 0.8935,
+      "suggested_scalar": -0.3967,
+      "log_bad": 6.9027,
+      "log_good": 6.7901
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 240.0,
+      "good": 212.0,
+      "ratio": 0.8833,
+      "suggested_scalar": -0.4369,
+      "log_bad": 5.4806,
+      "log_good": 5.3566
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2367,
+      "good": 0.2335,
+      "ratio": 0.9865,
+      "suggested_scalar": -0.0479,
+      "log_bad": -1.441,
+      "log_good": -1.4546
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 97.0,
+      "good": 100.0,
+      "ratio": 1.0309,
+      "suggested_scalar": 0.1073,
+      "log_bad": 4.5747,
+      "log_good": 4.6052
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 131.0,
+      "good": 128.0,
+      "ratio": 0.9771,
+      "suggested_scalar": -0.0816,
+      "log_bad": 4.8752,
+      "log_good": 4.852
+    },
+    "brevity.mean_sample_size": {
+      "bad": 131.0,
+      "good": 128.0,
+      "ratio": 0.9771,
+      "suggested_scalar": -0.0816,
+      "log_bad": 4.8752,
+      "log_good": 4.852
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 528.0,
+      "good": 484.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.3064,
+      "log_bad": 6.2691,
+      "log_good": 6.1821
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 245.0,
+      "good": 221.0,
+      "ratio": 0.902,
+      "suggested_scalar": -0.3631,
+      "log_bad": 5.5013,
+      "log_good": 5.3982
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 322.0,
+      "good": 304.0,
+      "ratio": 0.9441,
+      "suggested_scalar": -0.2026,
+      "log_bad": 5.7746,
+      "log_good": 5.717
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0019,
+      "good": 0.0021,
+      "ratio": 1.1053,
+      "suggested_scalar": 0.3525,
+      "log_bad": -6.2659,
+      "log_good": -6.1658
+    },
+    "heaps.mean_k": {
+      "bad": 2.147,
+      "good": 1.9718,
+      "ratio": 0.9184,
+      "suggested_scalar": -0.2998,
+      "log_bad": 0.7641,
+      "log_good": 0.6789
+    },
+    "halstead.mean_effort": {
+      "bad": 112138.2872,
+      "good": 106406.4325,
+      "ratio": 0.9489,
+      "suggested_scalar": -0.1848,
+      "log_bad": 11.6275,
+      "log_good": 11.575
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.871,
+      "good": 0.88,
+      "ratio": 1.0103,
+      "suggested_scalar": 0.0362,
+      "log_bad": -0.1381,
+      "log_good": -0.1278
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 104.0,
+      "good": 97.0,
+      "ratio": 0.9327,
+      "suggested_scalar": -0.2454,
+      "log_bad": 4.6444,
+      "log_good": 4.5747
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 235.0,
+      "good": 222.0,
+      "ratio": 0.9447,
+      "suggested_scalar": -0.2004,
+      "log_bad": 5.4596,
+      "log_good": 5.4027
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3948,
+      "good": 0.4244,
+      "ratio": 1.075,
+      "suggested_scalar": 0.2546,
+      "log_bad": -0.9294,
+      "log_good": -0.8571
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.2704,
+      "good": 4.3366,
+      "ratio": 1.0155,
+      "suggested_scalar": 0.0542,
+      "log_bad": 1.4517,
+      "log_good": 1.4671
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.16,
+      "good": 0.1471,
+      "ratio": 0.9194,
+      "suggested_scalar": -0.296,
+      "log_bad": -1.8326,
+      "log_good": -1.9166
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.3524,
+      "good": 3.3379,
+      "ratio": 0.9957,
+      "suggested_scalar": -0.0153,
+      "log_bad": 1.2097,
+      "log_good": 1.2053
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 527.0,
+      "good": 483.0,
+      "ratio": 0.9165,
+      "suggested_scalar": -0.307,
+      "log_bad": 6.2672,
+      "log_good": 6.18
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 82.0,
+      "good": 83.0,
+      "ratio": 1.0122,
+      "suggested_scalar": 0.0427,
+      "log_bad": 4.4067,
+      "log_good": 4.4188
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6229.9048,
+      "good": 5911.4685,
+      "ratio": 0.9489,
+      "suggested_scalar": -0.1848,
+      "log_bad": 8.7371,
+      "log_good": 8.6846
+    },
+    "readability.mean_total_lines": {
+      "bad": 63.0,
+      "good": 58.0,
+      "ratio": 0.9206,
+      "suggested_scalar": -0.2912,
+      "log_bad": 4.1431,
+      "log_good": 4.0604
+    },
+    "indentation.mean_max_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "halstead.mean_volume": {
+      "bad": 3351.2592,
+      "good": 3042.8726,
+      "ratio": 0.908,
+      "suggested_scalar": -0.34,
+      "log_bad": 8.1171,
+      "log_good": 8.0206
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 797.0,
+      "good": 742.0,
+      "ratio": 0.931,
+      "suggested_scalar": -0.2518,
+      "log_bad": 6.6809,
+      "log_good": 6.6093
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 27.2063,
+      "good": 27.6552,
+      "ratio": 1.0165,
+      "suggested_scalar": 0.0576,
+      "log_bad": 3.3034,
+      "log_good": 3.3198
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0461,
+      "good": 1.0496,
+      "ratio": 1.0033,
+      "suggested_scalar": 0.0118,
+      "log_bad": 0.0451,
+      "log_good": 0.0484
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 43.0,
+      "good": 35.0,
+      "ratio": 0.814,
+      "suggested_scalar": -0.725,
+      "log_bad": 3.7612,
+      "log_good": 3.5553
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 9.0,
+      "good": 7.0,
+      "ratio": 0.7778,
+      "suggested_scalar": -0.8851,
+      "log_bad": 2.1972,
+      "log_good": 1.9459
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7881,
+      "good": 0.7726,
+      "ratio": 0.9803,
+      "suggested_scalar": -0.07,
+      "log_bad": -0.2381,
+      "log_good": -0.258
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9689,
+      "good": 0.9773,
+      "ratio": 1.0087,
+      "suggested_scalar": 0.0304,
+      "log_bad": -0.0316,
+      "log_good": -0.023
+    },
+    "halstead.mean_length": {
+      "bad": 475.0,
+      "good": 434.0,
+      "ratio": 0.9137,
+      "suggested_scalar": -0.3179,
+      "log_bad": 6.1633,
+      "log_good": 6.073
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 17.6667,
+      "good": 15.3333,
+      "ratio": 0.8679,
+      "suggested_scalar": -0.4989,
+      "log_bad": 2.8717,
+      "log_good": 2.73
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.0334,
+      "good": 7.0,
+      "ratio": 0.9953,
+      "suggested_scalar": -0.0168,
+      "log_bad": 1.9507,
+      "log_good": 1.9459
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1369,
+      "good": 0.1322,
+      "ratio": 0.9657,
+      "suggested_scalar": -0.123,
+      "log_bad": -1.9885,
+      "log_good": -2.0234
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 33.4615,
+      "good": 34.9691,
+      "ratio": 1.0451,
+      "suggested_scalar": 0.1552,
+      "log_bad": 3.5104,
+      "log_good": 3.5545
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 13.0,
+      "ratio": 1.625,
+      "suggested_scalar": 1.7098,
+      "log_bad": 2.0794,
+      "log_good": 2.5649
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 92.0,
+      "good": 87.0,
+      "ratio": 0.9457,
+      "suggested_scalar": -0.1968,
+      "log_bad": 4.5218,
+      "log_good": 4.4659
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6988,
+      "good": 0.6711,
+      "ratio": 0.9604,
+      "suggested_scalar": -0.1424,
+      "log_bad": -0.3584,
+      "log_good": -0.3988
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 63.0,
+      "good": 58.0,
+      "ratio": 0.9206,
+      "suggested_scalar": -0.2912,
+      "log_bad": 4.1431,
+      "log_good": 4.0604
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 10.0,
+      "good": 11.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.3357,
+      "log_bad": 2.3026,
+      "log_good": 2.3979
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    }
+  },
+  "error_handling.does_not_use_exceptions_for_control_flow": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 11.0,
+      "good": 16.0,
+      "ratio": 1.4545,
+      "suggested_scalar": 0.1152,
+      "log_bad": 2.3979,
+      "log_good": 2.7726
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0097,
+      "good": 0.0063,
+      "ratio": 0.6495,
+      "suggested_scalar": -0.1327,
+      "log_bad": -4.6356,
+      "log_good": -5.0672
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6,
+      "good": 2.2,
+      "ratio": 1.375,
+      "suggested_scalar": 0.098,
+      "log_bad": 0.47,
+      "log_good": 0.7885
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.6429,
+      "good": 0.7925,
+      "ratio": 1.2327,
+      "suggested_scalar": 0.0643,
+      "log_bad": -0.4418,
+      "log_good": -0.2326
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0097,
+      "good": 0.0063,
+      "ratio": 0.6495,
+      "suggested_scalar": -0.1327,
+      "log_bad": -4.6356,
+      "log_good": -5.0672
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.0606,
+      "good": 4.3216,
+      "ratio": 1.0643,
+      "suggested_scalar": 0.0192,
+      "log_bad": 1.4013,
+      "log_good": 1.4636
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 125.0,
+      "good": 80.0,
+      "ratio": 0.64,
+      "suggested_scalar": -0.1373,
+      "log_bad": 4.8283,
+      "log_good": 4.382
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6261,
+      "good": 0.5,
+      "ratio": 0.7986,
+      "suggested_scalar": -0.0692,
+      "log_bad": -0.4682,
+      "log_good": -0.6931
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6785,
+      "good": 0.6281,
+      "ratio": 0.9257,
+      "suggested_scalar": -0.0237,
+      "log_bad": -0.3879,
+      "log_good": -0.4651
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 11.0952,
+      "good": 9.5849,
+      "ratio": 0.8639,
+      "suggested_scalar": -0.045,
+      "log_bad": 2.4065,
+      "log_good": 2.2602
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 412.0,
+      "good": 320.0,
+      "ratio": 0.7767,
+      "suggested_scalar": -0.0777,
+      "log_bad": 6.021,
+      "log_good": 5.7683
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 7.0,
+      "good": 6.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0474,
+      "log_bad": 1.9459,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 0.0015,
+      "ratio": 0.0015,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.5023
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0595,
+      "good": 1.0,
+      "ratio": 16.8067,
+      "suggested_scalar": 0.8679,
+      "log_bad": -2.8218,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9014,
+      "good": 0.9337,
+      "ratio": 1.0358,
+      "suggested_scalar": 0.0108,
+      "log_bad": -0.1038,
+      "log_good": -0.0686
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 122.0,
+      "good": 84.0,
+      "ratio": 0.6885,
+      "suggested_scalar": -0.1148,
+      "log_bad": 4.804,
+      "log_good": 4.4308
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 97.4479,
+      "good": 88.0863,
+      "ratio": 0.9039,
+      "suggested_scalar": -0.0311,
+      "log_bad": 4.5793,
+      "log_good": 4.4783
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4623,
+      "good": 0.5705,
+      "ratio": 1.234,
+      "suggested_scalar": 0.0647,
+      "log_bad": -0.7715,
+      "log_good": -0.5612
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 21.4499,
+      "good": 14.7647,
+      "ratio": 0.6883,
+      "suggested_scalar": -0.1149,
+      "log_bad": 3.0657,
+      "log_good": 2.6922
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2835.0,
+      "good": 2004.0,
+      "ratio": 0.7069,
+      "suggested_scalar": -0.1067,
+      "log_bad": 7.9498,
+      "log_good": 7.6029
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2024,
+      "good": 0.1321,
+      "ratio": 0.6527,
+      "suggested_scalar": -0.1312,
+      "log_bad": -1.5975,
+      "log_good": -2.0242
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.5476,
+      "good": 0.6792,
+      "ratio": 1.2403,
+      "suggested_scalar": 0.0662,
+      "log_bad": -0.6022,
+      "log_good": -0.3868
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 4.9048,
+      "good": 6.0377,
+      "ratio": 1.231,
+      "suggested_scalar": 0.0639,
+      "log_bad": 1.5902,
+      "log_good": 1.798
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 22.229,
+      "good": 20.1296,
+      "ratio": 0.9056,
+      "suggested_scalar": -0.0305,
+      "log_bad": 3.1014,
+      "log_good": 3.0022
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 60.0,
+      "good": 27.0,
+      "ratio": 0.45,
+      "suggested_scalar": -0.2456,
+      "log_bad": 4.0943,
+      "log_good": 3.2958
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9519,
+      "good": 0.9487,
+      "ratio": 0.9966,
+      "suggested_scalar": -0.001,
+      "log_bad": -0.0493,
+      "log_good": -0.0527
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 36.0,
+      "good": 24.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1247,
+      "log_bad": 3.5835,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6797,
+      "good": 0.6796,
+      "ratio": 0.9999,
+      "suggested_scalar": -0.0,
+      "log_bad": -0.3861,
+      "log_good": -0.3863
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2463,
+      "good": 0.2642,
+      "ratio": 1.0727,
+      "suggested_scalar": 0.0216,
+      "log_bad": -1.4012,
+      "log_good": -1.331
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.1222,
+      "good": 3.1215,
+      "ratio": 0.9998,
+      "suggested_scalar": -0.0001,
+      "log_bad": 1.1385,
+      "log_good": 1.1383
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 410.0,
+      "good": 318.0,
+      "ratio": 0.7756,
+      "suggested_scalar": -0.0782,
+      "log_bad": 6.0162,
+      "log_good": 5.7621
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 29.0,
+      "good": 18.0,
+      "ratio": 0.6207,
+      "suggested_scalar": -0.1467,
+      "log_bad": 3.3673,
+      "log_good": 2.8904
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.1293,
+      "good": 6.0224,
+      "ratio": 0.9826,
+      "suggested_scalar": -0.0054,
+      "log_bad": 1.8131,
+      "log_good": 1.7955
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 46.0,
+      "good": 36.0,
+      "ratio": 0.7826,
+      "suggested_scalar": -0.0754,
+      "log_bad": 3.8286,
+      "log_good": 3.5835
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.536,
+      "good": 1.7482,
+      "ratio": 1.1382,
+      "suggested_scalar": 0.0398,
+      "log_bad": 0.4292,
+      "log_good": 0.5586
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.1208,
+      "good": 5.6289,
+      "ratio": 0.9196,
+      "suggested_scalar": -0.0258,
+      "log_bad": 1.8117,
+      "log_good": 1.7279
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.6625,
+      "good": 0.7176,
+      "ratio": 1.0832,
+      "suggested_scalar": 0.0246,
+      "log_bad": -0.4117,
+      "log_good": -0.3318
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1064,
+      "good": 0.209,
+      "ratio": 1.9643,
+      "suggested_scalar": 0.2077,
+      "log_bad": -2.2405,
+      "log_good": -1.5654
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.6314,
+      "good": 3.8425,
+      "ratio": 0.8297,
+      "suggested_scalar": -0.0574,
+      "log_bad": 1.5329,
+      "log_good": 1.3461
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1247,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 350.0,
+      "good": 270.0,
+      "ratio": 0.7714,
+      "suggested_scalar": -0.0798,
+      "log_bad": 5.8579,
+      "log_good": 5.5984
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 13.0,
+      "good": 7.0,
+      "ratio": 0.5385,
+      "suggested_scalar": -0.1904,
+      "log_bad": 2.5649,
+      "log_good": 1.9459
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9125,
+      "good": 0.6575,
+      "ratio": 0.7205,
+      "suggested_scalar": -0.1008,
+      "log_bad": -0.0916,
+      "log_good": -0.4193
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 126.0,
+      "good": 83.0,
+      "ratio": 0.6587,
+      "suggested_scalar": -0.1284,
+      "log_bad": 4.8363,
+      "log_good": 4.4188
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1023.0,
+      "good": 790.0,
+      "ratio": 0.7722,
+      "suggested_scalar": -0.0795,
+      "log_bad": 6.9305,
+      "log_good": 6.672
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 167.0,
+      "good": 136.0,
+      "ratio": 0.8144,
+      "suggested_scalar": -0.0632,
+      "log_bad": 5.118,
+      "log_good": 4.9127
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1893,
+      "good": 0.2656,
+      "ratio": 1.4031,
+      "suggested_scalar": 0.1042,
+      "log_bad": -1.6644,
+      "log_good": -1.3258
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 63.0,
+      "good": 64.0,
+      "ratio": 1.0159,
+      "suggested_scalar": 0.0048,
+      "log_bad": 4.1431,
+      "log_good": 4.1589
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 126.0,
+      "good": 83.0,
+      "ratio": 0.6587,
+      "suggested_scalar": -0.1284,
+      "log_bad": 4.8363,
+      "log_good": 4.4188
+    },
+    "brevity.mean_sample_size": {
+      "bad": 126.0,
+      "good": 83.0,
+      "ratio": 0.6587,
+      "suggested_scalar": -0.1284,
+      "log_bad": 4.8363,
+      "log_good": 4.4188
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 412.0,
+      "good": 320.0,
+      "ratio": 0.7767,
+      "suggested_scalar": -0.0777,
+      "log_bad": 6.021,
+      "log_good": 5.7683
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 196.0,
+      "good": 155.0,
+      "ratio": 0.7908,
+      "suggested_scalar": -0.0722,
+      "log_bad": 5.2781,
+      "log_good": 5.0434
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 284.0,
+      "good": 201.0,
+      "ratio": 0.7077,
+      "suggested_scalar": -0.1063,
+      "log_bad": 5.649,
+      "log_good": 5.3033
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0073,
+      "good": 0.0063,
+      "ratio": 0.863,
+      "suggested_scalar": -0.0453,
+      "log_bad": -4.9199,
+      "log_good": -5.0672
+    },
+    "heaps.mean_k": {
+      "bad": 2.2345,
+      "good": 2.3012,
+      "ratio": 1.0299,
+      "suggested_scalar": 0.009,
+      "log_bad": 0.804,
+      "log_good": 0.8334
+    },
+    "halstead.mean_effort": {
+      "bad": 92461.6291,
+      "good": 57482.5828,
+      "ratio": 0.6217,
+      "suggested_scalar": -0.1462,
+      "log_bad": 11.4345,
+      "log_good": 10.9592
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8772,
+      "good": 0.883,
+      "ratio": 1.0066,
+      "suggested_scalar": 0.002,
+      "log_bad": -0.131,
+      "log_good": -0.1244
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 89.0,
+      "good": 56.0,
+      "ratio": 0.6292,
+      "suggested_scalar": -0.1425,
+      "log_bad": 4.4886,
+      "log_good": 4.0254
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 226.0,
+      "good": 176.0,
+      "ratio": 0.7788,
+      "suggested_scalar": -0.0769,
+      "log_bad": 5.4205,
+      "log_good": 5.1705
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.6148,
+      "good": 0.5,
+      "ratio": 0.8133,
+      "suggested_scalar": -0.0636,
+      "log_bad": -0.4865,
+      "log_good": -0.6931
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.3852,
+      "good": 9.4048,
+      "ratio": 1.1216,
+      "suggested_scalar": 0.0353,
+      "log_bad": 2.1265,
+      "log_good": 2.2412
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1064,
+      "good": 0.209,
+      "ratio": 1.9643,
+      "suggested_scalar": 0.2077,
+      "log_bad": -2.2405,
+      "log_good": -1.5654
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.9131,
+      "good": 5.982,
+      "ratio": 1.5287,
+      "suggested_scalar": 0.1305,
+      "log_bad": 1.3643,
+      "log_good": 1.7888
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 411.0,
+      "good": 319.0,
+      "ratio": 0.7762,
+      "suggested_scalar": -0.0779,
+      "log_bad": 6.0186,
+      "log_good": 5.7652
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 41.0,
+      "good": 36.0,
+      "ratio": 0.878,
+      "suggested_scalar": -0.04,
+      "log_bad": 3.7136,
+      "log_good": 3.5835
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5136.7572,
+      "good": 3193.4768,
+      "ratio": 0.6217,
+      "suggested_scalar": -0.1462,
+      "log_bad": 8.5442,
+      "log_good": 8.0689
+    },
+    "readability.mean_total_lines": {
+      "bad": 84.0,
+      "good": 53.0,
+      "ratio": 0.631,
+      "suggested_scalar": -0.1417,
+      "log_bad": 4.4308,
+      "log_good": 3.9703
+    },
+    "indentation.mean_max_depth": {
+      "bad": 24.0,
+      "good": 20.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0561,
+      "log_bad": 3.1781,
+      "log_good": 2.9957
+    },
+    "halstead.mean_volume": {
+      "bad": 2737.5532,
+      "good": 1972.4416,
+      "ratio": 0.7205,
+      "suggested_scalar": -0.1008,
+      "log_bad": 7.9148,
+      "log_good": 7.587
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 908.0,
+      "good": 642.0,
+      "ratio": 0.707,
+      "suggested_scalar": -0.1066,
+      "log_bad": 6.8112,
+      "log_good": 6.4646
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.5595,
+      "good": 36.5472,
+      "ratio": 1.1225,
+      "suggested_scalar": 0.0355,
+      "log_bad": 3.4831,
+      "log_good": 3.5986
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2341,
+      "good": 1.3312,
+      "ratio": 1.0787,
+      "suggested_scalar": 0.0233,
+      "log_bad": 0.2103,
+      "log_good": 0.2861
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 7.0,
+      "good": 6.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0474,
+      "log_bad": 1.9459,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 13.0,
+      "good": 15.0,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.044,
+      "log_bad": 2.5649,
+      "log_good": 2.7081
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 1.0,
+      "ratio": 0.2,
+      "suggested_scalar": -0.495,
+      "log_bad": 1.6094,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8829,
+      "good": 0.8667,
+      "ratio": 0.9817,
+      "suggested_scalar": -0.0057,
+      "log_bad": -0.1245,
+      "log_good": -0.1431
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9592,
+      "good": 0.9504,
+      "ratio": 0.9908,
+      "suggested_scalar": -0.0028,
+      "log_bad": -0.0417,
+      "log_good": -0.0509
+    },
+    "halstead.mean_length": {
+      "bad": 393.0,
+      "good": 312.0,
+      "ratio": 0.7939,
+      "suggested_scalar": -0.071,
+      "log_bad": 5.9738,
+      "log_good": 5.743
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 16.8,
+      "good": 11.6,
+      "ratio": 0.6905,
+      "suggested_scalar": -0.1139,
+      "log_bad": 2.8214,
+      "log_good": 2.451
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9773,
+      "good": 6.375,
+      "ratio": 0.9137,
+      "suggested_scalar": -0.0278,
+      "log_bad": 1.9427,
+      "log_good": 1.8524
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0693,
+      "good": 0.0773,
+      "ratio": 1.1154,
+      "suggested_scalar": 0.0336,
+      "log_bad": -2.6693,
+      "log_good": -2.5601
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 33.7753,
+      "good": 29.1429,
+      "ratio": 0.8628,
+      "suggested_scalar": -0.0454,
+      "log_bad": 3.5197,
+      "log_good": 3.3722
+    },
+    "branching.mean_branch_count": {
+      "bad": 17.0,
+      "good": 7.0,
+      "ratio": 0.4118,
+      "suggested_scalar": -0.2729,
+      "log_bad": 2.8332,
+      "log_good": 1.9459
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 75.0,
+      "good": 42.0,
+      "ratio": 0.56,
+      "suggested_scalar": -0.1783,
+      "log_bad": 4.3175,
+      "log_good": 3.7377
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7782,
+      "good": 0.6816,
+      "ratio": 0.8759,
+      "suggested_scalar": -0.0408,
+      "log_bad": -0.2508,
+      "log_good": -0.3833
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 84.0,
+      "good": 53.0,
+      "ratio": 0.631,
+      "suggested_scalar": -0.1417,
+      "log_bad": 4.4308,
+      "log_good": 3.9703
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 25.0,
+      "good": 19.0,
+      "ratio": 0.76,
+      "suggested_scalar": -0.0844,
+      "log_bad": 3.2189,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.arrow_functions_as_callbacks": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 28.0,
+      "good": 28.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3322,
+      "log_good": 3.3322
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0066,
+      "good": 0.007,
+      "ratio": 1.0606,
+      "suggested_scalar": 0.0264,
+      "log_bad": -5.0207,
+      "log_good": -4.9618
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7069,
+      "good": 0.7451,
+      "ratio": 1.054,
+      "suggested_scalar": 0.0236,
+      "log_bad": -0.3469,
+      "log_good": -0.2942
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0066,
+      "good": 0.007,
+      "ratio": 1.0606,
+      "suggested_scalar": 0.0264,
+      "log_bad": -5.0207,
+      "log_good": -4.9618
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7358,
+      "good": 4.7621,
+      "ratio": 1.0056,
+      "suggested_scalar": 0.0025,
+      "log_bad": 1.5552,
+      "log_good": 1.5607
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 85.0,
+      "good": 76.0,
+      "ratio": 0.8941,
+      "suggested_scalar": -0.0502,
+      "log_bad": 4.4427,
+      "log_good": 4.3307
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4329,
+      "good": 0.3786,
+      "ratio": 0.8746,
+      "suggested_scalar": -0.0601,
+      "log_bad": -0.8372,
+      "log_good": -0.9713
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 22.0,
+      "good": 21.0,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.0209,
+      "log_bad": 3.091,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5934,
+      "good": 0.5508,
+      "ratio": 0.9282,
+      "suggested_scalar": -0.0334,
+      "log_bad": -0.5219,
+      "log_good": -0.5964
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.0,
+      "good": 2.7451,
+      "ratio": 0.915,
+      "suggested_scalar": -0.0398,
+      "log_bad": 1.0986,
+      "log_good": 1.0098
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 456.0,
+      "good": 430.0,
+      "ratio": 0.943,
+      "suggested_scalar": -0.0263,
+      "log_bad": 6.1225,
+      "log_good": 6.0638
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0818,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0172,
+      "good": 1.0,
+      "ratio": 58.1395,
+      "suggested_scalar": 1.8232,
+      "log_bad": -4.0628,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1211,
+      "good": 1.1306,
+      "ratio": 1.0085,
+      "suggested_scalar": 0.0038,
+      "log_bad": 0.1143,
+      "log_good": 0.1227
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 120.0,
+      "good": 113.0,
+      "ratio": 0.9417,
+      "suggested_scalar": -0.027,
+      "log_bad": 4.7875,
+      "log_good": 4.7274
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 95.5035,
+      "good": 92.8897,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.0125,
+      "log_bad": 4.5592,
+      "log_good": 4.5314
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6396,
+      "good": 0.648,
+      "ratio": 1.0131,
+      "suggested_scalar": 0.0059,
+      "log_bad": -0.4469,
+      "log_good": -0.4339
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.761,
+      "good": 12.2672,
+      "ratio": 1.043,
+      "suggested_scalar": 0.0189,
+      "log_bad": 2.4648,
+      "log_good": 2.5069
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1820.0,
+      "good": 1637.0,
+      "ratio": 0.8995,
+      "suggested_scalar": -0.0476,
+      "log_bad": 7.5066,
+      "log_good": 7.4006
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6897,
+      "good": 0.7255,
+      "ratio": 1.0519,
+      "suggested_scalar": 0.0227,
+      "log_bad": -0.3715,
+      "log_good": -0.3209
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.8621,
+      "good": 8.4314,
+      "ratio": 1.0724,
+      "suggested_scalar": 0.0314,
+      "log_bad": 2.0621,
+      "log_good": 2.132
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.6552,
+      "good": 2.3468,
+      "ratio": 0.8839,
+      "suggested_scalar": -0.0554,
+      "log_bad": 0.9765,
+      "log_good": 0.8531
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 69.0,
+      "good": 63.0,
+      "ratio": 0.913,
+      "suggested_scalar": -0.0408,
+      "log_bad": 4.2341,
+      "log_good": 4.1431
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.915,
+      "good": 0.9064,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.0042,
+      "log_bad": -0.0888,
+      "log_good": -0.0983
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 27.0,
+      "ratio": 0.931,
+      "suggested_scalar": -0.0321,
+      "log_bad": 3.3673,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6637,
+      "good": 0.6622,
+      "ratio": 0.9977,
+      "suggested_scalar": -0.001,
+      "log_bad": -0.4099,
+      "log_good": -0.4122
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4736,
+      "good": 0.4766,
+      "ratio": 1.0063,
+      "suggested_scalar": 0.0028,
+      "log_bad": -0.7474,
+      "log_good": -0.7411
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9739,
+      "good": 2.9602,
+      "ratio": 0.9954,
+      "suggested_scalar": -0.0021,
+      "log_bad": 1.0899,
+      "log_good": 1.0853
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 454.0,
+      "good": 428.0,
+      "ratio": 0.9427,
+      "suggested_scalar": -0.0265,
+      "log_bad": 6.1181,
+      "log_good": 6.0591
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0219,
+      "good": 0.0233,
+      "ratio": 1.0639,
+      "suggested_scalar": 0.0278,
+      "log_bad": -3.8213,
+      "log_good": -3.7593
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0661,
+      "good": 5.9773,
+      "ratio": 0.9854,
+      "suggested_scalar": -0.0066,
+      "log_bad": 1.8027,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 23.0,
+      "good": 22.0,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.0199,
+      "log_bad": 3.1355,
+      "log_good": 3.091
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4058,
+      "good": 1.4283,
+      "ratio": 1.016,
+      "suggested_scalar": 0.0071,
+      "log_bad": 0.3406,
+      "log_good": 0.3565
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5031,
+      "good": 5.3714,
+      "ratio": 0.9761,
+      "suggested_scalar": -0.0109,
+      "log_bad": 1.7053,
+      "log_good": 1.6811
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7807,
+      "good": 0.7967,
+      "ratio": 1.0205,
+      "suggested_scalar": 0.0091,
+      "log_bad": -0.2476,
+      "log_good": -0.2273
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1471,
+      "good": 0.1639,
+      "ratio": 1.1142,
+      "suggested_scalar": 0.0485,
+      "log_bad": -1.9166,
+      "log_good": -1.8085
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.4294,
+      "good": 3.5025,
+      "ratio": 1.0213,
+      "suggested_scalar": 0.0095,
+      "log_bad": 1.2324,
+      "log_good": 1.2535
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 290.0,
+      "good": 272.0,
+      "ratio": 0.9379,
+      "suggested_scalar": -0.0288,
+      "log_bad": 5.6699,
+      "log_good": 5.6058
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 35.0,
+      "good": 34.0,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.013,
+      "log_bad": 3.5553,
+      "log_good": 3.5264
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9422,
+      "good": 0.8705,
+      "ratio": 0.9239,
+      "suggested_scalar": -0.0355,
+      "log_bad": -0.0595,
+      "log_good": -0.1387
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 87.0,
+      "good": 77.0,
+      "ratio": 0.8851,
+      "suggested_scalar": -0.0548,
+      "log_bad": 4.4659,
+      "log_good": 4.3438
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 771.0,
+      "good": 732.0,
+      "ratio": 0.9494,
+      "suggested_scalar": -0.0233,
+      "log_bad": 6.6477,
+      "log_good": 6.5958
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 158.0,
+      "good": 150.0,
+      "ratio": 0.9494,
+      "suggested_scalar": -0.0233,
+      "log_bad": 5.0626,
+      "log_good": 5.0106
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 0.0116,
+      "ratio": 0.0116,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -4.4568
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2544,
+      "good": 0.2674,
+      "ratio": 1.0511,
+      "suggested_scalar": 0.0224,
+      "log_bad": -1.3688,
+      "log_good": -1.319
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 63.0,
+      "good": 60.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0219,
+      "log_bad": 4.1431,
+      "log_good": 4.0943
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 87.0,
+      "good": 77.0,
+      "ratio": 0.8851,
+      "suggested_scalar": -0.0548,
+      "log_bad": 4.4659,
+      "log_good": 4.3438
+    },
+    "brevity.mean_sample_size": {
+      "bad": 87.0,
+      "good": 77.0,
+      "ratio": 0.8851,
+      "suggested_scalar": -0.0548,
+      "log_bad": 4.4659,
+      "log_good": 4.3438
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 456.0,
+      "good": 430.0,
+      "ratio": 0.943,
+      "suggested_scalar": -0.0263,
+      "log_bad": 6.1225,
+      "log_good": 6.0638
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 260.0,
+      "good": 253.0,
+      "ratio": 0.9731,
+      "suggested_scalar": -0.0122,
+      "log_bad": 5.5607,
+      "log_good": 5.5334
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 227.0,
+      "good": 211.0,
+      "ratio": 0.9295,
+      "suggested_scalar": -0.0328,
+      "log_bad": 5.425,
+      "log_good": 5.3519
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0022,
+      "good": 0.0023,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.0199,
+      "log_bad": -6.1193,
+      "log_good": -6.0748
+    },
+    "heaps.mean_k": {
+      "bad": 2.5795,
+      "good": 2.9842,
+      "ratio": 1.1569,
+      "suggested_scalar": 0.0654,
+      "log_bad": 0.9476,
+      "log_good": 1.0933
+    },
+    "halstead.mean_effort": {
+      "bad": 115635.8277,
+      "good": 107929.7601,
+      "ratio": 0.9334,
+      "suggested_scalar": -0.0309,
+      "log_bad": 11.6582,
+      "log_good": 11.5892
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8541,
+      "good": 0.8571,
+      "ratio": 1.0035,
+      "suggested_scalar": 0.0016,
+      "log_bad": -0.1577,
+      "log_good": -0.1542
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 56.0,
+      "good": 49.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0599,
+      "log_bad": 4.0254,
+      "log_good": 3.8918
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 283.0,
+      "good": 268.0,
+      "ratio": 0.947,
+      "suggested_scalar": -0.0244,
+      "log_bad": 5.6454,
+      "log_good": 5.591
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3833,
+      "good": 0.3451,
+      "ratio": 0.9003,
+      "suggested_scalar": -0.0471,
+      "log_bad": -0.9589,
+      "log_good": -1.0639
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.425,
+      "good": 6.4779,
+      "ratio": 1.0082,
+      "suggested_scalar": 0.0037,
+      "log_bad": 1.8602,
+      "log_good": 1.8684
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1471,
+      "good": 0.1639,
+      "ratio": 1.1142,
+      "suggested_scalar": 0.0485,
+      "log_bad": -1.9166,
+      "log_good": -1.8085
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.6191,
+      "good": 6.1154,
+      "ratio": 1.0883,
+      "suggested_scalar": 0.038,
+      "log_bad": 1.7262,
+      "log_good": 1.8108
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 455.0,
+      "good": 429.0,
+      "ratio": 0.9429,
+      "suggested_scalar": -0.0264,
+      "log_bad": 6.1203,
+      "log_good": 6.0615
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 51.0,
+      "good": 48.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0272,
+      "log_bad": 3.9318,
+      "log_good": 3.8712
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6424.2127,
+      "good": 5996.0978,
+      "ratio": 0.9334,
+      "suggested_scalar": -0.0309,
+      "log_bad": 8.7678,
+      "log_good": 8.6989
+    },
+    "readability.mean_total_lines": {
+      "bad": 58.0,
+      "good": 51.0,
+      "ratio": 0.8793,
+      "suggested_scalar": -0.0577,
+      "log_bad": 4.0604,
+      "log_good": 3.9318
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2826.5414,
+      "good": 2611.6337,
+      "ratio": 0.924,
+      "suggested_scalar": -0.0355,
+      "log_bad": 7.9468,
+      "log_good": 7.8677
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 612.0,
+      "good": 553.0,
+      "ratio": 0.9036,
+      "suggested_scalar": -0.0455,
+      "log_bad": 6.4167,
+      "log_good": 6.3154
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.1724,
+      "good": 30.902,
+      "ratio": 1.0242,
+      "suggested_scalar": 0.0107,
+      "log_bad": 3.4069,
+      "log_good": 3.4308
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2216,
+      "good": 1.2457,
+      "ratio": 1.0197,
+      "suggested_scalar": 0.0088,
+      "log_bad": 0.2002,
+      "log_good": 0.2197
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0818,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 31.0,
+      "good": 31.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.434,
+      "log_good": 3.434
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8241,
+      "good": 0.8235,
+      "ratio": 0.9993,
+      "suggested_scalar": -0.0003,
+      "log_bad": -0.1935,
+      "log_good": -0.1942
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9646,
+      "good": 0.9568,
+      "ratio": 0.9919,
+      "suggested_scalar": -0.0036,
+      "log_bad": -0.036,
+      "log_good": -0.0442
+    },
+    "halstead.mean_length": {
+      "bad": 441.0,
+      "good": 418.0,
+      "ratio": 0.9478,
+      "suggested_scalar": -0.024,
+      "log_bad": 6.089,
+      "log_good": 6.0355
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4429,
+      "good": 6.2668,
+      "ratio": 0.9727,
+      "suggested_scalar": -0.0124,
+      "log_bad": 1.863,
+      "log_good": 1.8353
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.143,
+      "good": 0.1546,
+      "ratio": 1.0811,
+      "suggested_scalar": 0.035,
+      "log_bad": -1.9449,
+      "log_good": -1.8669
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 40.9107,
+      "good": 41.3265,
+      "ratio": 1.0102,
+      "suggested_scalar": 0.0045,
+      "log_bad": 3.7114,
+      "log_good": 3.7215
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 46.0,
+      "good": 39.0,
+      "ratio": 0.8478,
+      "suggested_scalar": -0.0741,
+      "log_bad": 3.8286,
+      "log_good": 3.6636
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7225,
+      "good": 0.7156,
+      "ratio": 0.9904,
+      "suggested_scalar": -0.0043,
+      "log_bad": -0.325,
+      "log_good": -0.3346
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 58.0,
+      "good": 51.0,
+      "ratio": 0.8793,
+      "suggested_scalar": -0.0577,
+      "log_bad": 4.0604,
+      "log_good": 3.9318
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "dependencies.no_default_exports": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 13.0,
+      "good": 14.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0362,
+      "log_bad": 2.5649,
+      "log_good": 2.6391
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0342,
+      "good": 0.0344,
+      "ratio": 1.0058,
+      "suggested_scalar": 0.0028,
+      "log_bad": -3.3755,
+      "log_good": -3.3697
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7167,
+      "good": 0.6909,
+      "ratio": 0.964,
+      "suggested_scalar": -0.0179,
+      "log_bad": -0.3331,
+      "log_good": -0.3698
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0342,
+      "good": 0.0344,
+      "ratio": 1.0058,
+      "suggested_scalar": 0.0028,
+      "log_bad": -3.3755,
+      "log_good": -3.3697
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.9051,
+      "good": 4.9172,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0012,
+      "log_bad": 1.5903,
+      "log_good": 1.5927
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 91.0,
+      "good": 81.0,
+      "ratio": 0.8901,
+      "suggested_scalar": -0.0569,
+      "log_bad": 4.5109,
+      "log_good": 4.3944
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4455,
+      "good": 0.4262,
+      "ratio": 0.9567,
+      "suggested_scalar": -0.0216,
+      "log_bad": -0.8086,
+      "log_good": -0.8528
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6466,
+      "good": 0.642,
+      "ratio": 0.9929,
+      "suggested_scalar": -0.0035,
+      "log_bad": -0.436,
+      "log_good": -0.4432
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.6333,
+      "good": 1.6364,
+      "ratio": 1.0019,
+      "suggested_scalar": 0.0009,
+      "log_bad": 0.4906,
+      "log_good": 0.4925
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 439.0,
+      "good": 436.0,
+      "ratio": 0.9932,
+      "suggested_scalar": -0.0034,
+      "log_bad": 6.0845,
+      "log_good": 6.0776
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0017,
+      "good": 0.0017,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.3771,
+      "log_good": -6.3771
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0167,
+      "good": 1.0,
+      "ratio": 59.8802,
+      "suggested_scalar": 2.0,
+      "log_bad": -4.0923,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0011,
+      "good": 0.0011,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.8124,
+      "log_good": -6.8124
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.972,
+      "good": 0.9549,
+      "ratio": 0.9824,
+      "suggested_scalar": -0.0087,
+      "log_bad": -0.0284,
+      "log_good": -0.0461
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 139.0,
+      "good": 133.0,
+      "ratio": 0.9568,
+      "suggested_scalar": -0.0216,
+      "log_bad": 4.9345,
+      "log_good": 4.8903
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 100.0372,
+      "good": 97.0839,
+      "ratio": 0.9705,
+      "suggested_scalar": -0.0146,
+      "log_bad": 4.6055,
+      "log_good": 4.5756
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7671,
+      "good": 0.7747,
+      "ratio": 1.0099,
+      "suggested_scalar": 0.0048,
+      "log_bad": -0.2651,
+      "log_good": -0.2553
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.2328,
+      "good": 10.6108,
+      "ratio": 1.0369,
+      "suggested_scalar": 0.0177,
+      "log_bad": 2.3256,
+      "log_good": 2.3619
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1812.0,
+      "good": 1794.0,
+      "ratio": 0.9901,
+      "suggested_scalar": -0.0049,
+      "log_bad": 7.5022,
+      "log_good": 7.4922
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.05,
+      "good": 0.0545,
+      "ratio": 1.09,
+      "suggested_scalar": 0.0421,
+      "log_bad": -2.9957,
+      "log_good": -2.9096
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7167,
+      "good": 0.6909,
+      "ratio": 0.964,
+      "suggested_scalar": -0.0179,
+      "log_bad": -0.3331,
+      "log_good": -0.3698
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.3167,
+      "good": 7.9273,
+      "ratio": 1.0835,
+      "suggested_scalar": 0.0392,
+      "log_bad": 1.9902,
+      "log_good": 2.0703
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.6656,
+      "good": 1.7587,
+      "ratio": 1.0559,
+      "suggested_scalar": 0.0266,
+      "log_bad": 0.5102,
+      "log_good": 0.5646
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 86.0,
+      "good": 77.0,
+      "ratio": 0.8953,
+      "suggested_scalar": -0.054,
+      "log_bad": 4.4543,
+      "log_good": 4.3438
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.946,
+      "good": 0.9369,
+      "ratio": 0.9904,
+      "suggested_scalar": -0.0047,
+      "log_bad": -0.0555,
+      "log_good": -0.0652
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6694,
+      "good": 0.6851,
+      "ratio": 1.0235,
+      "suggested_scalar": 0.0113,
+      "log_bad": -0.4014,
+      "log_good": -0.3782
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.643,
+      "good": 0.6475,
+      "ratio": 1.007,
+      "suggested_scalar": 0.0034,
+      "log_bad": -0.4416,
+      "log_good": -0.4346
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.025,
+      "good": 3.1752,
+      "ratio": 1.0497,
+      "suggested_scalar": 0.0237,
+      "log_bad": 1.1069,
+      "log_good": 1.1554
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 437.0,
+      "good": 434.0,
+      "ratio": 0.9931,
+      "suggested_scalar": -0.0034,
+      "log_bad": 6.0799,
+      "log_good": 6.073
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 14.0,
+      "good": 10.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.1644,
+      "log_bad": 2.6391,
+      "log_good": 2.3026
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0661,
+      "good": 0.0665,
+      "ratio": 1.0061,
+      "suggested_scalar": 0.0029,
+      "log_bad": -2.7166,
+      "log_good": -2.7106
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.9307,
+      "ratio": 0.9961,
+      "suggested_scalar": -0.0019,
+      "log_bad": 1.7841,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 37.0,
+      "good": 40.0,
+      "ratio": 1.0811,
+      "suggested_scalar": 0.0381,
+      "log_bad": 3.6109,
+      "log_good": 3.6889
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2959,
+      "good": 1.3454,
+      "ratio": 1.0382,
+      "suggested_scalar": 0.0183,
+      "log_bad": 0.2592,
+      "log_good": 0.2967
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.706,
+      "good": 5.6027,
+      "ratio": 0.9819,
+      "suggested_scalar": -0.0089,
+      "log_bad": 1.7415,
+      "log_good": 1.7232
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8238,
+      "good": 0.8291,
+      "ratio": 1.0064,
+      "suggested_scalar": 0.0031,
+      "log_bad": -0.1938,
+      "log_good": -0.1874
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1176,
+      "good": 0.127,
+      "ratio": 1.0799,
+      "suggested_scalar": 0.0376,
+      "log_bad": -2.1405,
+      "log_good": -2.0636
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1989,
+      "good": 3.2574,
+      "ratio": 1.0183,
+      "suggested_scalar": 0.0089,
+      "log_bad": 1.1628,
+      "log_good": 1.1809
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 267.0,
+      "good": 264.0,
+      "ratio": 0.9888,
+      "suggested_scalar": -0.0055,
+      "log_bad": 5.5872,
+      "log_good": 5.5759
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 21.0,
+      "good": 22.0,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.0227,
+      "log_bad": 3.0445,
+      "log_good": 3.091
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8417,
+      "good": 0.8136,
+      "ratio": 0.9666,
+      "suggested_scalar": -0.0166,
+      "log_bad": -0.1723,
+      "log_good": -0.2063
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 94.0,
+      "good": 84.0,
+      "ratio": 0.8936,
+      "suggested_scalar": -0.055,
+      "log_bad": 4.5433,
+      "log_good": 4.4308
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1001.0,
+      "good": 996.0,
+      "ratio": 0.995,
+      "suggested_scalar": -0.0024,
+      "log_bad": 6.9088,
+      "log_good": 6.9037
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 153.0,
+      "good": 147.0,
+      "ratio": 0.9608,
+      "suggested_scalar": -0.0196,
+      "log_bad": 5.0304,
+      "log_good": 4.9904
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2938,
+      "good": 0.3005,
+      "ratio": 1.0228,
+      "suggested_scalar": 0.011,
+      "log_bad": -1.2249,
+      "log_good": -1.2023
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 112.0,
+      "good": 113.0,
+      "ratio": 1.0089,
+      "suggested_scalar": 0.0043,
+      "log_bad": 4.7185,
+      "log_good": 4.7274
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 94.0,
+      "good": 84.0,
+      "ratio": 0.8936,
+      "suggested_scalar": -0.055,
+      "log_bad": 4.5433,
+      "log_good": 4.4308
+    },
+    "brevity.mean_sample_size": {
+      "bad": 94.0,
+      "good": 84.0,
+      "ratio": 0.8936,
+      "suggested_scalar": -0.055,
+      "log_bad": 4.5433,
+      "log_good": 4.4308
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 439.0,
+      "good": 436.0,
+      "ratio": 0.9932,
+      "suggested_scalar": -0.0034,
+      "log_bad": 6.0845,
+      "log_good": 6.0776
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 249.0,
+      "good": 252.0,
+      "ratio": 1.012,
+      "suggested_scalar": 0.0059,
+      "log_bad": 5.5175,
+      "log_good": 5.5294
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 214.0,
+      "good": 211.0,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0069,
+      "log_bad": 5.366,
+      "log_good": 5.3519
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0023,
+      "good": 0.0023,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.0748,
+      "log_good": -6.0748
+    },
+    "heaps.mean_k": {
+      "bad": 1.8195,
+      "good": 1.8551,
+      "ratio": 1.0196,
+      "suggested_scalar": 0.0095,
+      "log_bad": 0.5986,
+      "log_good": 0.6179
+    },
+    "halstead.mean_effort": {
+      "bad": 73168.3184,
+      "good": 80090.1364,
+      "ratio": 1.0946,
+      "suggested_scalar": 0.0442,
+      "log_bad": 11.2005,
+      "log_good": 11.2909
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8705,
+      "good": 0.8765,
+      "ratio": 1.0069,
+      "suggested_scalar": 0.0034,
+      "log_bad": -0.1387,
+      "log_good": -0.1318
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 66.0,
+      "good": 56.0,
+      "ratio": 0.8485,
+      "suggested_scalar": -0.0803,
+      "log_bad": 4.1897,
+      "log_good": 4.0254
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 235.0,
+      "good": 238.0,
+      "ratio": 1.0128,
+      "suggested_scalar": 0.0062,
+      "log_bad": 5.4596,
+      "log_good": 5.4723
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4317,
+      "good": 0.3759,
+      "ratio": 0.8707,
+      "suggested_scalar": -0.0676,
+      "log_bad": -0.84,
+      "log_good": -0.9784
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.2014,
+      "good": 7.4887,
+      "ratio": 1.0399,
+      "suggested_scalar": 0.0191,
+      "log_bad": 1.9743,
+      "log_good": 2.0134
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1176,
+      "good": 0.127,
+      "ratio": 1.0799,
+      "suggested_scalar": 0.0376,
+      "log_bad": -2.1405,
+      "log_good": -2.0636
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.5616,
+      "good": 3.8266,
+      "ratio": 1.0744,
+      "suggested_scalar": 0.0351,
+      "log_bad": 1.2702,
+      "log_good": 1.342
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 438.0,
+      "good": 435.0,
+      "ratio": 0.9932,
+      "suggested_scalar": -0.0034,
+      "log_bad": 6.0822,
+      "log_good": 6.0753
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 111.0,
+      "good": 111.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.7095,
+      "log_good": 4.7095
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4064.9066,
+      "good": 4449.452,
+      "ratio": 1.0946,
+      "suggested_scalar": 0.0442,
+      "log_bad": 8.3101,
+      "log_good": 8.4005
+    },
+    "readability.mean_total_lines": {
+      "bad": 60.0,
+      "good": 55.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0425,
+      "log_bad": 4.0943,
+      "log_good": 4.0073
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2525.0243,
+      "good": 2440.8423,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0166,
+      "log_bad": 7.834,
+      "log_good": 7.8001
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 599.0,
+      "good": 565.0,
+      "ratio": 0.9432,
+      "suggested_scalar": -0.0286,
+      "log_bad": 6.3953,
+      "log_good": 6.3368
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 29.0667,
+      "good": 31.4727,
+      "ratio": 1.0828,
+      "suggested_scalar": 0.0389,
+      "log_bad": 3.3696,
+      "log_good": 3.4491
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1746,
+      "good": 1.2022,
+      "ratio": 1.0235,
+      "suggested_scalar": 0.0114,
+      "log_bad": 0.1609,
+      "log_good": 0.1842
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.5843,
+      "good": 0.5795,
+      "ratio": 0.9918,
+      "suggested_scalar": -0.004,
+      "log_bad": -0.5373,
+      "log_good": -0.5456
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9583,
+      "good": 0.957,
+      "ratio": 0.9986,
+      "suggested_scalar": -0.0007,
+      "log_bad": -0.0426,
+      "log_good": -0.044
+    },
+    "halstead.mean_length": {
+      "bad": 388.0,
+      "good": 385.0,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.0038,
+      "log_bad": 5.961,
+      "log_good": 5.9532
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.0,
+      "good": 8.75,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0653,
+      "log_bad": 2.3026,
+      "log_good": 2.1691
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5546,
+      "good": 6.3923,
+      "ratio": 0.9752,
+      "suggested_scalar": -0.0123,
+      "log_bad": 1.8802,
+      "log_good": 1.8551
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1374,
+      "good": 0.1405,
+      "ratio": 1.0226,
+      "suggested_scalar": 0.0109,
+      "log_bad": -1.9849,
+      "log_good": -1.9625
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 28.9773,
+      "good": 32.8125,
+      "ratio": 1.1324,
+      "suggested_scalar": 0.0607,
+      "log_bad": 3.3665,
+      "log_good": 3.4908
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 60.0,
+      "good": 50.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0891,
+      "log_bad": 4.0943,
+      "log_good": 3.912
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.4766,
+      "good": 0.4645,
+      "ratio": 0.9746,
+      "suggested_scalar": -0.0126,
+      "log_bad": -0.7411,
+      "log_good": -0.7668
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 60.0,
+      "good": 55.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0425,
+      "log_bad": 4.0943,
+      "log_good": 4.0073
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.switch_has_default_case": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 19.0,
+      "good": 18.0,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.2117,
+      "log_bad": 2.9444,
+      "log_good": 2.8904
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -1.3174,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0806,
+      "good": 0.0593,
+      "ratio": 0.7357,
+      "suggested_scalar": -1.2015,
+      "log_bad": -2.5183,
+      "log_good": -2.8251
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3333,
+      "good": 1.5,
+      "ratio": 1.125,
+      "suggested_scalar": 0.4612,
+      "log_bad": 0.2877,
+      "log_good": 0.4055
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.6111,
+      "good": 0.6875,
+      "ratio": 1.125,
+      "suggested_scalar": 0.4612,
+      "log_bad": -0.4925,
+      "log_good": -0.3747
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0806,
+      "good": 0.0653,
+      "ratio": 0.8102,
+      "suggested_scalar": -0.8242,
+      "log_bad": -2.5183,
+      "log_good": -2.7288
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5397,
+      "good": 4.5944,
+      "ratio": 1.012,
+      "suggested_scalar": 0.0469,
+      "log_bad": 1.5129,
+      "log_good": 1.5248
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 69.0,
+      "good": 81.0,
+      "ratio": 1.1739,
+      "suggested_scalar": 0.6278,
+      "log_bad": 4.2341,
+      "log_good": 4.3944
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5275,
+      "good": 0.5376,
+      "ratio": 1.0191,
+      "suggested_scalar": 0.0743,
+      "log_bad": -0.6396,
+      "log_good": -0.6206
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 17.0,
+      "ratio": 1.1333,
+      "suggested_scalar": 0.49,
+      "log_bad": 2.7081,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6372,
+      "good": 0.6278,
+      "ratio": 0.9852,
+      "suggested_scalar": -0.0582,
+      "log_bad": -0.4507,
+      "log_good": -0.4655
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.4815,
+      "good": 4.6667,
+      "ratio": 1.0413,
+      "suggested_scalar": 0.1585,
+      "log_bad": 1.5,
+      "log_good": 1.5405
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 335.0,
+      "good": 337.0,
+      "ratio": 1.006,
+      "suggested_scalar": 0.0233,
+      "log_bad": 5.8141,
+      "log_good": 5.8201
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0006,
+      "good": 0.0006,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.4186,
+      "log_good": -7.4186
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0018,
+      "good": 0.0019,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.2117,
+      "log_bad": -6.32,
+      "log_good": -6.2659
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0421,
+      "good": 1.0054,
+      "ratio": 0.9648,
+      "suggested_scalar": -0.1404,
+      "log_bad": 0.0412,
+      "log_good": 0.0054
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 91.0,
+      "good": 93.0,
+      "ratio": 1.022,
+      "suggested_scalar": 0.0851,
+      "log_bad": 4.5109,
+      "log_good": 4.5326
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 93.8946,
+      "good": 97.022,
+      "ratio": 1.0333,
+      "suggested_scalar": 0.1283,
+      "log_bad": 4.5422,
+      "log_good": 4.5749
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7455,
+      "good": 0.6815,
+      "ratio": 0.9142,
+      "suggested_scalar": -0.3514,
+      "log_bad": -0.2937,
+      "log_good": -0.3835
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 32.2497,
+      "good": 28.0437,
+      "ratio": 0.8696,
+      "suggested_scalar": -0.5471,
+      "log_bad": 3.4735,
+      "log_good": 3.3338
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1662.0,
+      "good": 1608.0,
+      "ratio": 0.9675,
+      "suggested_scalar": -0.1293,
+      "log_bad": 7.4158,
+      "log_good": 7.3827
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.3148,
+      "good": 0.2708,
+      "ratio": 0.8602,
+      "suggested_scalar": -0.5895,
+      "log_bad": -1.1558,
+      "log_good": -1.3064
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.5926,
+      "good": 0.6667,
+      "ratio": 1.125,
+      "suggested_scalar": 0.4613,
+      "log_bad": -0.5232,
+      "log_good": -0.4054
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.2037,
+      "good": 7.0208,
+      "ratio": 1.1317,
+      "suggested_scalar": 0.4844,
+      "log_bad": 1.8251,
+      "log_good": 1.9489
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 6.0645,
+      "good": 6.0556,
+      "ratio": 0.9985,
+      "suggested_scalar": -0.0058,
+      "log_bad": 1.8025,
+      "log_good": 1.801
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 62.0,
+      "good": 62.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.1271,
+      "log_good": 4.1271
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9576,
+      "good": 0.9573,
+      "ratio": 0.9997,
+      "suggested_scalar": -0.0012,
+      "log_bad": -0.0433,
+      "log_good": -0.0436
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 18.0,
+      "good": 24.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 1.1263,
+      "log_bad": 2.8904,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.7094,
+      "good": 0.6716,
+      "ratio": 0.9467,
+      "suggested_scalar": -0.2144,
+      "log_bad": -0.3433,
+      "log_good": -0.3981
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.6697,
+      "good": 0.5672,
+      "ratio": 0.8469,
+      "suggested_scalar": -0.6504,
+      "log_bad": -0.4009,
+      "log_good": -0.567
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.441,
+      "good": 3.0455,
+      "ratio": 0.8851,
+      "suggested_scalar": -0.478,
+      "log_bad": 1.2358,
+      "log_good": 1.1137
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 333.0,
+      "good": 335.0,
+      "ratio": 1.006,
+      "suggested_scalar": 0.0234,
+      "log_bad": 5.8081,
+      "log_good": 5.8141
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 27.0,
+      "good": 30.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.4125,
+      "log_bad": 3.2958,
+      "log_good": 3.4012
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0269,
+      "good": 0.0386,
+      "ratio": 1.4349,
+      "suggested_scalar": 1.4139,
+      "log_bad": -3.6156,
+      "log_good": -3.2545
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.6724,
+      "good": 5.7549,
+      "ratio": 1.0145,
+      "suggested_scalar": 0.0565,
+      "log_bad": 1.7356,
+      "log_good": 1.7501
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 10.0,
+      "good": 13.0,
+      "ratio": 1.3,
+      "suggested_scalar": 1.0272,
+      "log_bad": 2.3026,
+      "log_good": 2.5649
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1991,
+      "good": 1.2453,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.148,
+      "log_bad": 0.1816,
+      "log_good": 0.2194
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.1882,
+      "good": 5.4552,
+      "ratio": 1.0515,
+      "suggested_scalar": 0.1965,
+      "log_bad": 1.6464,
+      "log_good": 1.6966
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8003,
+      "good": 0.7984,
+      "ratio": 0.9976,
+      "suggested_scalar": -0.0093,
+      "log_bad": -0.2228,
+      "log_good": -0.2251
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.069,
+      "good": 0.0769,
+      "ratio": 1.1145,
+      "suggested_scalar": 0.4244,
+      "log_bad": -2.6736,
+      "log_good": -2.5652
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 5.6789,
+      "good": 5.2956,
+      "ratio": 0.9325,
+      "suggested_scalar": -0.2736,
+      "log_bad": 1.7368,
+      "log_good": 1.6669
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 179.0,
+      "good": 210.0,
+      "ratio": 1.1732,
+      "suggested_scalar": 0.6253,
+      "log_bad": 5.1874,
+      "log_good": 5.3471
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 6.0,
+      "good": 10.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 2.0,
+      "log_bad": 1.7918,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5192,
+      "good": 0.5495,
+      "ratio": 1.0584,
+      "suggested_scalar": 0.2221,
+      "log_bad": -0.6555,
+      "log_good": -0.5987
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 75.0,
+      "good": 86.0,
+      "ratio": 1.1467,
+      "suggested_scalar": 0.5358,
+      "log_bad": 4.3175,
+      "log_good": 4.4543
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 814.0,
+      "good": 780.0,
+      "ratio": 0.9582,
+      "suggested_scalar": -0.167,
+      "log_bad": 6.702,
+      "log_good": 6.6593
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 102.0,
+      "good": 108.0,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.2238,
+      "log_bad": 4.625,
+      "log_good": 4.6821
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2149,
+      "good": 0.2136,
+      "ratio": 0.994,
+      "suggested_scalar": -0.0238,
+      "log_bad": -1.5376,
+      "log_good": -1.5437
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 60.0,
+      "good": 66.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.3732,
+      "log_bad": 4.0943,
+      "log_good": 4.1897
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -1.5875,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 75.0,
+      "good": 86.0,
+      "ratio": 1.1467,
+      "suggested_scalar": 0.5358,
+      "log_bad": 4.3175,
+      "log_good": 4.4543
+    },
+    "brevity.mean_sample_size": {
+      "bad": 75.0,
+      "good": 86.0,
+      "ratio": 1.1467,
+      "suggested_scalar": 0.5358,
+      "log_bad": 4.3175,
+      "log_good": 4.4543
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 335.0,
+      "good": 337.0,
+      "ratio": 1.006,
+      "suggested_scalar": 0.0233,
+      "log_bad": 5.8141,
+      "log_good": 5.8201
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 193.0,
+      "good": 192.0,
+      "ratio": 0.9948,
+      "suggested_scalar": -0.0203,
+      "log_bad": 5.2627,
+      "log_good": 5.2575
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 145.0,
+      "good": 173.0,
+      "ratio": 1.1931,
+      "suggested_scalar": 0.6913,
+      "log_bad": 4.9767,
+      "log_good": 5.1533
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.8298,
+      "good": 2.0562,
+      "ratio": 1.1237,
+      "suggested_scalar": 0.4567,
+      "log_bad": 0.6042,
+      "log_good": 0.7209
+    },
+    "halstead.mean_effort": {
+      "bad": 28038.1273,
+      "good": 37478.5238,
+      "ratio": 1.3367,
+      "suggested_scalar": 1.1362,
+      "log_bad": 10.2413,
+      "log_good": 10.5315
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8329,
+      "good": 0.8489,
+      "ratio": 1.0192,
+      "suggested_scalar": 0.0745,
+      "log_bad": -0.1828,
+      "log_good": -0.1638
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 51.0,
+      "good": 57.0,
+      "ratio": 1.1176,
+      "suggested_scalar": 0.4355,
+      "log_bad": 3.9318,
+      "log_good": 4.0431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 153.0,
+      "good": 152.0,
+      "ratio": 0.9935,
+      "suggested_scalar": -0.0257,
+      "log_bad": 5.0304,
+      "log_good": 5.0239
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5275,
+      "good": 0.5376,
+      "ratio": 1.0191,
+      "suggested_scalar": 0.0743,
+      "log_bad": -0.6396,
+      "log_good": -0.6206
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.9451,
+      "good": 8.3871,
+      "ratio": 0.9376,
+      "suggested_scalar": -0.2522,
+      "log_bad": 2.1911,
+      "log_good": 2.1267
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.069,
+      "good": 0.0769,
+      "ratio": 1.1145,
+      "suggested_scalar": 0.4244,
+      "log_bad": -2.6736,
+      "log_good": -2.5652
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.1716,
+      "good": 3.9118,
+      "ratio": 0.9377,
+      "suggested_scalar": -0.2518,
+      "log_bad": 1.4283,
+      "log_good": 1.364
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 334.0,
+      "good": 336.0,
+      "ratio": 1.006,
+      "suggested_scalar": 0.0234,
+      "log_bad": 5.8111,
+      "log_good": 5.8171
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 7.0,
+      "ratio": 1.4,
+      "suggested_scalar": 1.3174,
+      "log_bad": 1.6094,
+      "log_good": 1.9459
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 69.0,
+      "good": 65.0,
+      "ratio": 0.942,
+      "suggested_scalar": -0.2338,
+      "log_bad": 4.2341,
+      "log_good": 4.1744
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1557.6737,
+      "good": 2082.1402,
+      "ratio": 1.3367,
+      "suggested_scalar": 1.1362,
+      "log_bad": 7.3509,
+      "log_good": 7.6412
+    },
+    "readability.mean_total_lines": {
+      "bad": 54.0,
+      "good": 48.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.4611,
+      "log_bad": 3.989,
+      "log_good": 3.8712
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 1557.6737,
+      "good": 1648.361,
+      "ratio": 1.0582,
+      "suggested_scalar": 0.2216,
+      "log_bad": 7.3509,
+      "log_good": 7.4075
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 483.0,
+      "good": 528.0,
+      "ratio": 1.0932,
+      "suggested_scalar": 0.3488,
+      "log_bad": 6.18,
+      "log_good": 6.2691
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 29.7037,
+      "good": 32.4167,
+      "ratio": 1.0913,
+      "suggested_scalar": 0.3422,
+      "log_bad": 3.3913,
+      "log_good": 3.4787
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2606,
+      "good": 1.2138,
+      "ratio": 0.9629,
+      "suggested_scalar": -0.1481,
+      "log_bad": 0.2316,
+      "log_good": 0.1938
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 12.0,
+      "good": 15.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.8737,
+      "log_bad": 2.4849,
+      "log_good": 2.7081
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6145,
+      "good": 0.6905,
+      "ratio": 1.1237,
+      "suggested_scalar": 0.4565,
+      "log_bad": -0.4869,
+      "log_good": -0.3703
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9732,
+      "good": 0.9747,
+      "ratio": 1.0015,
+      "suggested_scalar": 0.006,
+      "log_bad": -0.0272,
+      "log_good": -0.0256
+    },
+    "halstead.mean_length": {
+      "bad": 255.0,
+      "good": 260.0,
+      "ratio": 1.0196,
+      "suggested_scalar": 0.076,
+      "log_bad": 5.5413,
+      "log_good": 5.5607
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 19.3333,
+      "good": 25.0,
+      "ratio": 1.2931,
+      "suggested_scalar": 1.0064,
+      "log_bad": 2.9618,
+      "log_good": 3.2189
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2288,
+      "good": 6.4263,
+      "ratio": 1.0317,
+      "suggested_scalar": 0.1222,
+      "log_bad": 1.8292,
+      "log_good": 1.8604
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1161,
+      "good": 0.1194,
+      "ratio": 1.0284,
+      "suggested_scalar": 0.1097,
+      "log_bad": -2.1533,
+      "log_good": -2.1253
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 18.0,
+      "good": 22.7368,
+      "ratio": 1.2632,
+      "suggested_scalar": 0.9146,
+      "log_bad": 2.8904,
+      "log_good": 3.124
+    },
+    "branching.mean_branch_count": {
+      "bad": 17.0,
+      "good": 13.0,
+      "ratio": 0.7647,
+      "suggested_scalar": -1.0503,
+      "log_bad": 2.8332,
+      "log_good": 2.5649
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 48.0,
+      "good": 50.0,
+      "ratio": 1.0417,
+      "suggested_scalar": 0.1598,
+      "log_bad": 3.8712,
+      "log_good": 3.912
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5862,
+      "good": 0.6185,
+      "ratio": 1.0551,
+      "suggested_scalar": 0.21,
+      "log_bad": -0.5341,
+      "log_good": -0.4805
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 54.0,
+      "good": 48.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.4611,
+      "log_bad": 3.989,
+      "log_good": 3.8712
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.nullable_boolean_compared_explicitly": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 29.0,
+      "good": 36.0,
+      "ratio": 1.2414,
+      "suggested_scalar": 0.0678,
+      "log_bad": 3.3673,
+      "log_good": 3.5835
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.006,
+      "good": 1.0,
+      "ratio": 166.6667,
+      "suggested_scalar": 1.6045,
+      "log_bad": -5.116,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.3333,
+      "good": 2.0,
+      "ratio": 0.8572,
+      "suggested_scalar": -0.0483,
+      "log_bad": 0.8473,
+      "log_good": 0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8605,
+      "good": 0.8,
+      "ratio": 0.9297,
+      "suggested_scalar": -0.0229,
+      "log_bad": -0.1502,
+      "log_good": -0.2231
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.006,
+      "good": 1.0,
+      "ratio": 166.6667,
+      "suggested_scalar": 1.6045,
+      "log_bad": -5.116,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4996,
+      "good": 4.441,
+      "ratio": 0.987,
+      "suggested_scalar": -0.0041,
+      "log_bad": 1.504,
+      "log_good": 1.4909
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 98.0,
+      "good": 71.0,
+      "ratio": 0.7245,
+      "suggested_scalar": -0.1011,
+      "log_bad": 4.585,
+      "log_good": 4.2627
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5664,
+      "good": 0.4086,
+      "ratio": 0.7214,
+      "suggested_scalar": -0.1024,
+      "log_bad": -0.5685,
+      "log_good": -0.895
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0216,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7237,
+      "good": 0.6027,
+      "ratio": 0.8328,
+      "suggested_scalar": -0.0574,
+      "log_bad": -0.3234,
+      "log_good": -0.5063
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.4186,
+      "good": 6.8444,
+      "ratio": 1.0663,
+      "suggested_scalar": 0.0201,
+      "log_bad": 1.8592,
+      "log_good": 1.9234
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 336.0,
+      "good": 318.0,
+      "ratio": 0.9464,
+      "suggested_scalar": -0.0173,
+      "log_bad": 5.8171,
+      "log_good": 5.7621
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0017,
+      "good": 1.0,
+      "ratio": 588.2353,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.3771,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.186,
+      "good": 0.0667,
+      "ratio": 0.3586,
+      "suggested_scalar": -0.3216,
+      "log_bad": -1.682,
+      "log_good": -2.7076
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0123,
+      "good": 0.0091,
+      "ratio": 0.7398,
+      "suggested_scalar": -0.0945,
+      "log_bad": -4.3982,
+      "log_good": -4.6995
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9383,
+      "good": 1.0648,
+      "ratio": 1.1348,
+      "suggested_scalar": 0.0397,
+      "log_bad": -0.0637,
+      "log_good": 0.0628
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 127.0,
+      "good": 106.0,
+      "ratio": 0.8346,
+      "suggested_scalar": -0.0567,
+      "log_bad": 4.8442,
+      "log_good": 4.6634
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 93.7513,
+      "good": 86.6804,
+      "ratio": 0.9246,
+      "suggested_scalar": -0.0246,
+      "log_bad": 4.5406,
+      "log_good": 4.4622
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5373,
+      "good": 0.6909,
+      "ratio": 1.2859,
+      "suggested_scalar": 0.0789,
+      "log_bad": -0.6212,
+      "log_good": -0.3698
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 19.3455,
+      "good": 22.3543,
+      "ratio": 1.1555,
+      "suggested_scalar": 0.0453,
+      "log_bad": 2.9625,
+      "log_good": 3.107
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1801.0,
+      "good": 1754.0,
+      "ratio": 0.9739,
+      "suggested_scalar": -0.0083,
+      "log_bad": 7.4961,
+      "log_good": 7.4697
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1163,
+      "good": 0.1333,
+      "ratio": 1.1462,
+      "suggested_scalar": 0.0428,
+      "log_bad": -2.1516,
+      "log_good": -2.0152
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.814,
+      "good": 0.7556,
+      "ratio": 0.9283,
+      "suggested_scalar": -0.0233,
+      "log_bad": -0.2058,
+      "log_good": -0.2802
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.814,
+      "good": 7.0667,
+      "ratio": 0.9044,
+      "suggested_scalar": -0.0315,
+      "log_bad": 2.0559,
+      "log_good": 1.9554
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 15.7317,
+      "good": 20.3536,
+      "ratio": 1.2938,
+      "suggested_scalar": 0.0808,
+      "log_bad": 2.7557,
+      "log_good": 3.0133
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 72.0,
+      "good": 49.0,
+      "ratio": 0.6806,
+      "suggested_scalar": -0.1207,
+      "log_bad": 4.2767,
+      "log_good": 3.8918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9266,
+      "good": 0.8982,
+      "ratio": 0.9694,
+      "suggested_scalar": -0.0098,
+      "log_bad": -0.0762,
+      "log_good": -0.1074
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 22.0,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.0139,
+      "log_bad": 3.1355,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6435,
+      "good": 0.7001,
+      "ratio": 1.088,
+      "suggested_scalar": 0.0264,
+      "log_bad": -0.4408,
+      "log_good": -0.3565
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4042,
+      "good": 0.5981,
+      "ratio": 1.4797,
+      "suggested_scalar": 0.1229,
+      "log_bad": -0.9058,
+      "log_good": -0.514
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.8053,
+      "good": 3.3346,
+      "ratio": 1.1887,
+      "suggested_scalar": 0.0542,
+      "log_bad": 1.0315,
+      "log_good": 1.2044
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 334.0,
+      "good": 316.0,
+      "ratio": 0.9461,
+      "suggested_scalar": -0.0174,
+      "log_bad": 5.8111,
+      "log_good": 5.7557
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 18.0,
+      "good": 15.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0572,
+      "log_bad": 2.8904,
+      "log_good": 2.7081
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0446,
+      "good": 0.0503,
+      "ratio": 1.1278,
+      "suggested_scalar": 0.0377,
+      "log_bad": -3.11,
+      "log_good": -2.9898
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8074,
+      "good": 5.7279,
+      "ratio": 0.9863,
+      "suggested_scalar": -0.0043,
+      "log_bad": 1.7591,
+      "log_good": 1.7453
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 26.0,
+      "good": 21.0,
+      "ratio": 0.8077,
+      "suggested_scalar": -0.067,
+      "log_bad": 3.2581,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4192,
+      "good": 1.5064,
+      "ratio": 1.0614,
+      "suggested_scalar": 0.0187,
+      "log_bad": 0.3501,
+      "log_good": 0.4097
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8372,
+      "good": 5.3658,
+      "ratio": 0.9192,
+      "suggested_scalar": -0.0264,
+      "log_bad": 1.7643,
+      "log_good": 1.68
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7748,
+      "good": 0.7753,
+      "ratio": 1.0006,
+      "suggested_scalar": 0.0002,
+      "log_bad": -0.2552,
+      "log_good": -0.2545
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.14,
+      "good": 0.1509,
+      "ratio": 1.0779,
+      "suggested_scalar": 0.0235,
+      "log_bad": -1.9661,
+      "log_good": -1.8911
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.3984,
+      "good": 4.728,
+      "ratio": 1.0749,
+      "suggested_scalar": 0.0227,
+      "log_bad": 1.4812,
+      "log_good": 1.5535
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 250.0,
+      "good": 193.0,
+      "ratio": 0.772,
+      "suggested_scalar": -0.0812,
+      "log_bad": 5.5215,
+      "log_good": 5.2627
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2174,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6681,
+      "good": 0.5904,
+      "ratio": 0.8837,
+      "suggested_scalar": -0.0388,
+      "log_bad": -0.4033,
+      "log_good": -0.527
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 100.0,
+      "good": 72.0,
+      "ratio": 0.72,
+      "suggested_scalar": -0.103,
+      "log_bad": 4.6052,
+      "log_good": 4.2767
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 963.0,
+      "good": 911.0,
+      "ratio": 0.946,
+      "suggested_scalar": -0.0174,
+      "log_bad": 6.8701,
+      "log_good": 6.8145
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 156.0,
+      "good": 137.0,
+      "ratio": 0.8782,
+      "suggested_scalar": -0.0407,
+      "log_bad": 5.0499,
+      "log_good": 4.92
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2113,
+      "good": 0.2484,
+      "ratio": 1.1756,
+      "suggested_scalar": 0.0507,
+      "log_bad": -1.5545,
+      "log_good": -1.3927
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 53.0,
+      "good": 58.0,
+      "ratio": 1.0943,
+      "suggested_scalar": 0.0283,
+      "log_bad": 3.9703,
+      "log_good": 4.0604
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0902,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 100.0,
+      "good": 72.0,
+      "ratio": 0.72,
+      "suggested_scalar": -0.103,
+      "log_bad": 4.6052,
+      "log_good": 4.2767
+    },
+    "brevity.mean_sample_size": {
+      "bad": 100.0,
+      "good": 72.0,
+      "ratio": 0.72,
+      "suggested_scalar": -0.103,
+      "log_bad": 4.6052,
+      "log_good": 4.2767
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 336.0,
+      "good": 318.0,
+      "ratio": 0.9464,
+      "suggested_scalar": -0.0173,
+      "log_bad": 5.8171,
+      "log_good": 5.7621
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 159.0,
+      "good": 163.0,
+      "ratio": 1.0252,
+      "suggested_scalar": 0.0078,
+      "log_bad": 5.0689,
+      "log_good": 5.0938
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 208.0,
+      "good": 156.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0902,
+      "log_bad": 5.3375,
+      "log_good": 5.0499
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.6661,
+      "good": 2.5083,
+      "ratio": 1.5055,
+      "suggested_scalar": 0.1283,
+      "log_bad": 0.5105,
+      "log_good": 0.9196
+    },
+    "halstead.mean_effort": {
+      "bad": 47941.8294,
+      "good": 54471.1969,
+      "ratio": 1.1362,
+      "suggested_scalar": 0.04,
+      "log_bad": 10.7777,
+      "log_good": 10.9054
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8786,
+      "good": 0.8697,
+      "ratio": 0.9899,
+      "suggested_scalar": -0.0032,
+      "log_bad": -0.1294,
+      "log_good": -0.1396
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 75.0,
+      "good": 49.0,
+      "ratio": 0.6533,
+      "suggested_scalar": -0.1335,
+      "log_bad": 4.3175,
+      "log_good": 3.8918
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 147.0,
+      "good": 151.0,
+      "ratio": 1.0272,
+      "suggested_scalar": 0.0084,
+      "log_bad": 4.9904,
+      "log_good": 5.0173
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5039,
+      "good": 0.4057,
+      "ratio": 0.8051,
+      "suggested_scalar": -0.068,
+      "log_bad": -0.6854,
+      "log_good": -0.9021
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.5827,
+      "good": 8.5943,
+      "ratio": 1.1334,
+      "suggested_scalar": 0.0393,
+      "log_bad": 2.0259,
+      "log_good": 2.1511
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.14,
+      "good": 0.1509,
+      "ratio": 1.0779,
+      "suggested_scalar": 0.0235,
+      "log_bad": -1.9661,
+      "log_good": -1.8911
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.0295,
+      "good": 4.117,
+      "ratio": 1.0217,
+      "suggested_scalar": 0.0067,
+      "log_bad": 1.3936,
+      "log_good": 1.4151
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 335.0,
+      "good": 317.0,
+      "ratio": 0.9463,
+      "suggested_scalar": -0.0173,
+      "log_bad": 5.8141,
+      "log_good": 5.7589
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 51.0,
+      "good": 66.0,
+      "ratio": 1.2941,
+      "suggested_scalar": 0.0809,
+      "log_bad": 3.9318,
+      "log_good": 4.1897
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2663.435,
+      "good": 3026.1776,
+      "ratio": 1.1362,
+      "suggested_scalar": 0.04,
+      "log_bad": 7.8874,
+      "log_good": 8.0151
+    },
+    "readability.mean_total_lines": {
+      "bad": 43.0,
+      "good": 45.0,
+      "ratio": 1.0465,
+      "suggested_scalar": 0.0143,
+      "log_bad": 3.7612,
+      "log_good": 3.8067
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2004.2571,
+      "good": 1771.1272,
+      "ratio": 0.8837,
+      "suggested_scalar": -0.0388,
+      "log_bad": 7.603,
+      "log_good": 7.4794
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 642.0,
+      "good": 526.0,
+      "ratio": 0.8193,
+      "suggested_scalar": -0.0625,
+      "log_bad": 6.4646,
+      "log_good": 6.2653
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 40.4884,
+      "good": 37.7556,
+      "ratio": 0.9325,
+      "suggested_scalar": -0.0219,
+      "log_bad": 3.701,
+      "log_good": 3.6311
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2429,
+      "good": 1.3355,
+      "ratio": 1.0745,
+      "suggested_scalar": 0.0225,
+      "log_bad": 0.2174,
+      "log_good": 0.2893
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 14.0,
+      "good": 18.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.0788,
+      "log_bad": 2.6391,
+      "log_good": 2.8904
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 8.0,
+      "good": 3.0,
+      "ratio": 0.375,
+      "suggested_scalar": -0.3076,
+      "log_bad": 2.0794,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.796,
+      "good": 0.658,
+      "ratio": 0.8266,
+      "suggested_scalar": -0.0597,
+      "log_bad": -0.2282,
+      "log_good": -0.4186
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9868,
+      "good": 0.9632,
+      "ratio": 0.9761,
+      "suggested_scalar": -0.0076,
+      "log_bad": -0.0133,
+      "log_good": -0.0375
+    },
+    "halstead.mean_length": {
+      "bad": 303.0,
+      "good": 288.0,
+      "ratio": 0.9505,
+      "suggested_scalar": -0.0159,
+      "log_bad": 5.7137,
+      "log_good": 5.663
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.6667,
+      "good": 9.5,
+      "ratio": 0.8143,
+      "suggested_scalar": -0.0644,
+      "log_bad": 2.4567,
+      "log_good": 2.2513
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6439,
+      "good": 6.1699,
+      "ratio": 0.9287,
+      "suggested_scalar": -0.0232,
+      "log_bad": 1.8937,
+      "log_good": 1.8197
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0888,
+      "good": 0.093,
+      "ratio": 1.0473,
+      "suggested_scalar": 0.0145,
+      "log_bad": -2.4214,
+      "log_good": -2.3752
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 23.92,
+      "good": 30.7551,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.0788,
+      "log_bad": 3.1747,
+      "log_good": 3.4261
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0572,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 64.0,
+      "good": 43.0,
+      "ratio": 0.6719,
+      "suggested_scalar": -0.1247,
+      "log_bad": 4.1589,
+      "log_good": 3.7612
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7452,
+      "good": 0.6282,
+      "ratio": 0.843,
+      "suggested_scalar": -0.0536,
+      "log_bad": -0.2941,
+      "log_good": -0.4649
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 43.0,
+      "good": 45.0,
+      "ratio": 1.0465,
+      "suggested_scalar": 0.0143,
+      "log_bad": 3.7612,
+      "log_good": 3.8067
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.uses_generator_over_list_comprehension": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 46.0,
+      "good": 42.0,
+      "ratio": 0.913,
+      "suggested_scalar": -0.1312,
+      "log_bad": 3.8286,
+      "log_good": 3.7377
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0729,
+      "good": 0.0771,
+      "ratio": 1.0576,
+      "suggested_scalar": 0.0808,
+      "log_bad": -2.6187,
+      "log_good": -2.5627
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1667,
+      "good": 1.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.2224,
+      "log_bad": 0.1542,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9474,
+      "good": 0.9556,
+      "ratio": 1.0087,
+      "suggested_scalar": 0.0124,
+      "log_bad": -0.054,
+      "log_good": -0.0454
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0729,
+      "good": 0.0771,
+      "ratio": 1.0576,
+      "suggested_scalar": 0.0808,
+      "log_bad": -2.6187,
+      "log_good": -2.5627
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5828,
+      "good": 4.5867,
+      "ratio": 1.0009,
+      "suggested_scalar": 0.0012,
+      "log_bad": 1.5223,
+      "log_good": 1.5232
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 100.0,
+      "good": 95.0,
+      "ratio": 0.95,
+      "suggested_scalar": -0.074,
+      "log_bad": 4.6052,
+      "log_good": 4.5539
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5737,
+      "good": 0.5232,
+      "ratio": 0.912,
+      "suggested_scalar": -0.1329,
+      "log_bad": -0.5556,
+      "log_good": -0.6478
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 18.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.263,
+      "log_bad": 2.7081,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.63,
+      "good": 0.6331,
+      "ratio": 1.0049,
+      "suggested_scalar": 0.0071,
+      "log_bad": -0.462,
+      "log_good": -0.4571
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.6842,
+      "good": 3.8222,
+      "ratio": 1.0375,
+      "suggested_scalar": 0.0531,
+      "log_bad": 1.3041,
+      "log_good": 1.3408
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 521.0,
+      "good": 532.0,
+      "ratio": 1.0211,
+      "suggested_scalar": 0.0301,
+      "log_bad": 6.2558,
+      "log_good": 6.2766
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0031,
+      "good": 0.9993,
+      "ratio": 0.9962,
+      "suggested_scalar": -0.0055,
+      "log_bad": 0.0031,
+      "log_good": -0.0007
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 180.0,
+      "good": 184.0,
+      "ratio": 1.0222,
+      "suggested_scalar": 0.0317,
+      "log_bad": 5.193,
+      "log_good": 5.2149
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 100.1646,
+      "good": 102.1138,
+      "ratio": 1.0195,
+      "suggested_scalar": 0.0278,
+      "log_bad": 4.6068,
+      "log_good": 4.6261
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5538,
+      "good": 0.5857,
+      "ratio": 1.0576,
+      "suggested_scalar": 0.0808,
+      "log_bad": -0.591,
+      "log_good": -0.5349
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.5369,
+      "good": 10.9659,
+      "ratio": 0.9505,
+      "suggested_scalar": -0.0732,
+      "log_bad": 2.4456,
+      "log_good": 2.3948
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1951.0,
+      "good": 1990.0,
+      "ratio": 1.02,
+      "suggested_scalar": 0.0286,
+      "log_bad": 7.5761,
+      "log_good": 7.5959
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2895,
+      "good": 0.1556,
+      "ratio": 0.5375,
+      "suggested_scalar": -0.8957,
+      "log_bad": -1.2396,
+      "log_good": -1.8605
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9474,
+      "good": 0.9556,
+      "ratio": 1.0087,
+      "suggested_scalar": 0.0124,
+      "log_bad": -0.054,
+      "log_good": -0.0454
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 13.7105,
+      "good": 11.8222,
+      "ratio": 0.8623,
+      "suggested_scalar": -0.2138,
+      "log_bad": 2.6182,
+      "log_good": 2.47
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 7.0582,
+      "good": 7.7906,
+      "ratio": 1.1038,
+      "suggested_scalar": 0.1424,
+      "log_bad": 1.9542,
+      "log_good": 2.0529
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 168.0,
+      "good": 164.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0348,
+      "log_bad": 5.124,
+      "log_good": 5.0999
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 1.0,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9527,
+      "good": 0.9676,
+      "ratio": 1.0156,
+      "suggested_scalar": 0.0224,
+      "log_bad": -0.0485,
+      "log_good": -0.0329
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 31.0,
+      "ratio": 1.1481,
+      "suggested_scalar": 0.1993,
+      "log_bad": 3.2958,
+      "log_good": 3.434
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5741,
+      "good": 0.5809,
+      "ratio": 1.0118,
+      "suggested_scalar": 0.017,
+      "log_bad": -0.555,
+      "log_good": -0.5432
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3834,
+      "good": 0.3943,
+      "ratio": 1.0284,
+      "suggested_scalar": 0.0404,
+      "log_bad": -0.9587,
+      "log_good": -0.9306
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3478,
+      "good": 2.3861,
+      "ratio": 1.0163,
+      "suggested_scalar": 0.0233,
+      "log_bad": 0.8535,
+      "log_good": 0.8697
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 519.0,
+      "good": 530.0,
+      "ratio": 1.0212,
+      "suggested_scalar": 0.0303,
+      "log_bad": 6.2519,
+      "log_good": 6.2729
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.241,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0211,
+      "good": 0.0188,
+      "ratio": 0.891,
+      "suggested_scalar": -0.1665,
+      "log_bad": -3.8585,
+      "log_good": -3.9739
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.9307,
+      "ratio": 1.004,
+      "suggested_scalar": 0.0058,
+      "log_bad": 1.7761,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 11.0,
+      "good": 19.0,
+      "ratio": 1.7273,
+      "suggested_scalar": 0.7885,
+      "log_bad": 2.3979,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.3809,
+      "good": 0.5271,
+      "ratio": 1.3838,
+      "suggested_scalar": 0.4687,
+      "log_bad": -0.9652,
+      "log_good": -0.6404
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8028,
+      "good": 5.7337,
+      "ratio": 0.9881,
+      "suggested_scalar": -0.0173,
+      "log_bad": 1.7583,
+      "log_good": 1.7464
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7758,
+      "good": 0.7734,
+      "ratio": 0.9969,
+      "suggested_scalar": -0.0045,
+      "log_bad": -0.2539,
+      "log_good": -0.257
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 4.0,
+      "good": 1.0,
+      "ratio": 0.25,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.3863,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2692,
+      "good": 0.25,
+      "ratio": 0.9287,
+      "suggested_scalar": -0.1068,
+      "log_bad": -1.3123,
+      "log_good": -1.3863
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.3966,
+      "good": 3.3115,
+      "ratio": 0.9749,
+      "suggested_scalar": -0.0366,
+      "log_bad": 1.2228,
+      "log_good": 1.1974
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 1.0,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 388.0,
+      "good": 394.0,
+      "ratio": 1.0155,
+      "suggested_scalar": 0.0221,
+      "log_bad": 5.961,
+      "log_good": 5.9764
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 15.0,
+      "good": 19.0,
+      "ratio": 1.2667,
+      "suggested_scalar": 0.341,
+      "log_bad": 2.7081,
+      "log_good": 2.9444
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8615,
+      "good": 0.8519,
+      "ratio": 0.9889,
+      "suggested_scalar": -0.0162,
+      "log_bad": -0.1491,
+      "log_good": -0.1603
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 131.0,
+      "good": 128.0,
+      "ratio": 0.9771,
+      "suggested_scalar": -0.0334,
+      "log_bad": 4.8752,
+      "log_good": 4.852
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 998.0,
+      "good": 1019.0,
+      "ratio": 1.021,
+      "suggested_scalar": 0.03,
+      "log_bad": 6.9058,
+      "log_good": 6.9266
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 178.0,
+      "good": 164.0,
+      "ratio": 0.9213,
+      "suggested_scalar": -0.1182,
+      "log_bad": 5.1818,
+      "log_good": 5.0999
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0115,
+      "good": 0.0113,
+      "ratio": 0.9826,
+      "suggested_scalar": -0.0253,
+      "log_bad": -4.4654,
+      "log_good": -4.483
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.215,
+      "good": 0.2293,
+      "ratio": 1.0665,
+      "suggested_scalar": 0.0929,
+      "log_bad": -1.5371,
+      "log_good": -1.4727
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 79.0,
+      "good": 87.0,
+      "ratio": 1.1013,
+      "suggested_scalar": 0.1392,
+      "log_bad": 4.3694,
+      "log_good": 4.4659
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 131.0,
+      "good": 128.0,
+      "ratio": 0.9771,
+      "suggested_scalar": -0.0334,
+      "log_bad": 4.8752,
+      "log_good": 4.852
+    },
+    "brevity.mean_sample_size": {
+      "bad": 131.0,
+      "good": 128.0,
+      "ratio": 0.9771,
+      "suggested_scalar": -0.0334,
+      "log_bad": 4.8752,
+      "log_good": 4.852
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 521.0,
+      "good": 532.0,
+      "ratio": 1.0211,
+      "suggested_scalar": 0.0301,
+      "log_bad": 6.2558,
+      "log_good": 6.2766
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 265.0,
+      "good": 277.0,
+      "ratio": 1.0453,
+      "suggested_scalar": 0.0639,
+      "log_bad": 5.5797,
+      "log_good": 5.624
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 311.0,
+      "good": 307.0,
+      "ratio": 0.9871,
+      "suggested_scalar": -0.0187,
+      "log_bad": 5.7398,
+      "log_good": 5.7268
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0019,
+      "good": 0.0019,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.2659,
+      "log_good": -6.2659
+    },
+    "heaps.mean_k": {
+      "bad": 2.6276,
+      "good": 2.5272,
+      "ratio": 0.9618,
+      "suggested_scalar": -0.0562,
+      "log_bad": 0.9661,
+      "log_good": 0.9271
+    },
+    "halstead.mean_effort": {
+      "bad": 85074.7605,
+      "good": 101508.17,
+      "ratio": 1.1932,
+      "suggested_scalar": 0.2548,
+      "log_bad": 11.3513,
+      "log_good": 11.5279
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.825,
+      "good": 0.8191,
+      "ratio": 0.9928,
+      "suggested_scalar": -0.0104,
+      "log_bad": -0.1924,
+      "log_good": -0.1995
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 73.0,
+      "good": 64.0,
+      "ratio": 0.8767,
+      "suggested_scalar": -0.1898,
+      "log_bad": 4.2905,
+      "log_good": 4.1589
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 211.0,
+      "good": 225.0,
+      "ratio": 1.0664,
+      "suggested_scalar": 0.0927,
+      "log_bad": 5.3519,
+      "log_good": 5.4161
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5,
+      "good": 0.4511,
+      "ratio": 0.9022,
+      "suggested_scalar": -0.1485,
+      "log_bad": -0.6931,
+      "log_good": -0.7961
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.5444,
+      "good": 5.538,
+      "ratio": 0.9988,
+      "suggested_scalar": -0.0017,
+      "log_bad": 1.7128,
+      "log_good": 1.7116
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2692,
+      "good": 0.25,
+      "ratio": 0.9287,
+      "suggested_scalar": -0.1068,
+      "log_bad": -1.3123,
+      "log_good": -1.3863
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.8055,
+      "good": 5.0489,
+      "ratio": 0.8697,
+      "suggested_scalar": -0.2015,
+      "log_bad": 1.7588,
+      "log_good": 1.6192
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -1.0,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 520.0,
+      "good": 531.0,
+      "ratio": 1.0212,
+      "suggested_scalar": 0.0302,
+      "log_bad": 6.2538,
+      "log_good": 6.2748
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 68.0,
+      "good": 73.0,
+      "ratio": 1.0735,
+      "suggested_scalar": 0.1024,
+      "log_bad": 4.2195,
+      "log_good": 4.2905
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4726.3756,
+      "good": 5639.3428,
+      "ratio": 1.1932,
+      "suggested_scalar": 0.2548,
+      "log_bad": 8.4609,
+      "log_good": 8.6375
+    },
+    "readability.mean_total_lines": {
+      "bad": 38.0,
+      "good": 45.0,
+      "ratio": 1.1842,
+      "suggested_scalar": 0.2439,
+      "log_bad": 3.6376,
+      "log_good": 3.8067
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2584.4601,
+      "good": 2555.6738,
+      "ratio": 0.9889,
+      "suggested_scalar": -0.0162,
+      "log_bad": 7.8573,
+      "log_good": 7.8461
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 831.0,
+      "good": 834.0,
+      "ratio": 1.0036,
+      "suggested_scalar": 0.0052,
+      "log_bad": 6.7226,
+      "log_good": 6.7262
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 49.7632,
+      "good": 42.8,
+      "ratio": 0.8601,
+      "suggested_scalar": -0.2175,
+      "log_bad": 3.9073,
+      "log_good": 3.7565
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0964,
+      "good": 1.096,
+      "ratio": 0.9996,
+      "suggested_scalar": -0.0005,
+      "log_bad": 0.092,
+      "log_good": 0.0917
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 18.0,
+      "good": 20.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.152,
+      "log_bad": 2.8904,
+      "log_good": 2.9957
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8247,
+      "good": 0.8147,
+      "ratio": 0.9879,
+      "suggested_scalar": -0.0176,
+      "log_bad": -0.1927,
+      "log_good": -0.2049
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 13.0,
+      "good": 15.0,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.2065,
+      "log_bad": 2.5649,
+      "log_good": 2.7081
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9774,
+      "good": 0.9801,
+      "ratio": 1.0028,
+      "suggested_scalar": 0.004,
+      "log_bad": -0.0229,
+      "log_good": -0.0201
+    },
+    "halstead.mean_length": {
+      "bad": 389.0,
+      "good": 389.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.9636,
+      "log_good": 5.9636
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.5,
+      "good": 8.6667,
+      "ratio": 1.1556,
+      "suggested_scalar": 0.2086,
+      "log_bad": 2.0149,
+      "log_good": 2.1595
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.0334,
+      "good": 7.0,
+      "ratio": 0.9953,
+      "suggested_scalar": -0.0069,
+      "log_bad": 1.9507,
+      "log_good": 1.9459
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1364,
+      "good": 0.1395,
+      "ratio": 1.0227,
+      "suggested_scalar": 0.0324,
+      "log_bad": -1.9922,
+      "log_good": -1.9697
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 32.9178,
+      "good": 39.7188,
+      "ratio": 1.2066,
+      "suggested_scalar": 0.271,
+      "log_bad": 3.494,
+      "log_good": 3.6818
+    },
+    "branching.mean_branch_count": {
+      "bad": 11.0,
+      "good": 7.0,
+      "ratio": 0.6364,
+      "suggested_scalar": -0.6521,
+      "log_bad": 2.3979,
+      "log_good": 1.9459
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 90.0,
+      "good": 83.0,
+      "ratio": 0.9222,
+      "suggested_scalar": -0.1168,
+      "log_bad": 4.4998,
+      "log_good": 4.4188
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.746,
+      "good": 0.7166,
+      "ratio": 0.9606,
+      "suggested_scalar": -0.058,
+      "log_bad": -0.293,
+      "log_good": -0.3332
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 38.0,
+      "good": 45.0,
+      "ratio": 1.1842,
+      "suggested_scalar": 0.2439,
+      "log_bad": 3.6376,
+      "log_good": 3.8067
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_double_negation": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 4.0,
+      "good": 2.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.3838,
+      "log_bad": 1.3863,
+      "log_good": 0.6931
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.25,
+      "good": 0.25,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.3863,
+      "log_good": -1.3863
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8108,
+      "good": 0.8056,
+      "ratio": 0.9936,
+      "suggested_scalar": -0.0036,
+      "log_bad": -0.2097,
+      "log_good": -0.2162
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4282,
+      "good": 4.3334,
+      "ratio": 0.9786,
+      "suggested_scalar": -0.012,
+      "log_bad": 1.488,
+      "log_good": 1.4664
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 43.0,
+      "good": 38.0,
+      "ratio": 0.8837,
+      "suggested_scalar": -0.0684,
+      "log_bad": 3.7612,
+      "log_good": 3.6376
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4706,
+      "good": 0.4375,
+      "ratio": 0.9297,
+      "suggested_scalar": -0.0404,
+      "log_bad": -0.7537,
+      "log_good": -0.8267
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 13.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.0792,
+      "log_bad": 2.7081,
+      "log_good": 2.5649
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6491,
+      "good": 0.6453,
+      "ratio": 0.9941,
+      "suggested_scalar": -0.0033,
+      "log_bad": -0.4322,
+      "log_good": -0.438
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.1892,
+      "good": 3.2222,
+      "ratio": 1.0103,
+      "suggested_scalar": 0.0057,
+      "log_bad": 1.1598,
+      "log_good": 1.1701
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 161.0,
+      "good": 130.0,
+      "ratio": 0.8075,
+      "suggested_scalar": -0.1184,
+      "log_bad": 5.0814,
+      "log_good": 4.8675
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0294,
+      "good": 0.0013,
+      "ratio": 0.0442,
+      "suggested_scalar": -1.7269,
+      "log_bad": -3.5268,
+      "log_good": -6.6454
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.027,
+      "good": 1.0,
+      "ratio": 37.037,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.6119,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0208,
+      "good": 0.024,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.0792,
+      "log_bad": -3.8728,
+      "log_good": -3.7297
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0046,
+      "good": 0.9857,
+      "ratio": 0.9812,
+      "suggested_scalar": -0.0105,
+      "log_bad": 0.0046,
+      "log_good": -0.0144
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 51.0,
+      "good": 48.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0336,
+      "log_bad": 3.9318,
+      "log_good": 3.8712
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 85.6849,
+      "good": 84.2393,
+      "ratio": 0.9831,
+      "suggested_scalar": -0.0094,
+      "log_bad": 4.4507,
+      "log_good": 4.4337
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4938,
+      "good": 0.4341,
+      "ratio": 0.8791,
+      "suggested_scalar": -0.0714,
+      "log_bad": -0.7056,
+      "log_good": -0.8345
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 24.3629,
+      "good": 24.3919,
+      "ratio": 1.0012,
+      "suggested_scalar": 0.0007,
+      "log_bad": 3.1931,
+      "log_good": 3.1943
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 818.0,
+      "good": 750.0,
+      "ratio": 0.9169,
+      "suggested_scalar": -0.0481,
+      "log_bad": 6.7069,
+      "log_good": 6.6201
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7838,
+      "good": 0.7778,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.0043,
+      "log_bad": -0.2436,
+      "log_good": -0.2513
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 4.4722,
+      "good": 3.6111,
+      "ratio": 0.8075,
+      "suggested_scalar": -0.1184,
+      "log_bad": 1.4979,
+      "log_good": 1.284
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.9102,
+      "good": 2.9506,
+      "ratio": 1.0139,
+      "suggested_scalar": 0.0076,
+      "log_bad": 1.0682,
+      "log_good": 1.082
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 50.0,
+      "good": 47.0,
+      "ratio": 0.94,
+      "suggested_scalar": -0.0343,
+      "log_bad": 3.912,
+      "log_good": 3.8501
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.93,
+      "good": 0.9155,
+      "ratio": 0.9844,
+      "suggested_scalar": -0.0087,
+      "log_bad": -0.0726,
+      "log_good": -0.0883
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0382,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5856,
+      "good": 0.6093,
+      "ratio": 1.0405,
+      "suggested_scalar": 0.022,
+      "log_bad": -0.5351,
+      "log_good": -0.4954
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2075,
+      "good": 0.1641,
+      "ratio": 0.7908,
+      "suggested_scalar": -0.1299,
+      "log_bad": -1.5726,
+      "log_good": -1.8073
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.413,
+      "good": 2.5597,
+      "ratio": 1.0608,
+      "suggested_scalar": 0.0327,
+      "log_bad": 0.8809,
+      "log_good": 0.9399
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 159.0,
+      "good": 128.0,
+      "ratio": 0.805,
+      "suggested_scalar": -0.1201,
+      "log_bad": 5.0689,
+      "log_good": 4.852
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0435,
+      "good": 0.0538,
+      "ratio": 1.2368,
+      "suggested_scalar": 0.1177,
+      "log_bad": -3.135,
+      "log_good": -2.9225
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.4919,
+      "good": 5.3576,
+      "ratio": 0.9755,
+      "suggested_scalar": -0.0137,
+      "log_bad": 1.7033,
+      "log_good": 1.6785
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.1392,
+      "good": 0.1461,
+      "ratio": 1.0496,
+      "suggested_scalar": 0.0268,
+      "log_bad": -1.9718,
+      "log_good": -1.9235
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 4.7537,
+      "good": 4.6341,
+      "ratio": 0.9748,
+      "suggested_scalar": -0.0141,
+      "log_bad": 1.5589,
+      "log_good": 1.5334
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8063,
+      "good": 0.8088,
+      "ratio": 1.0031,
+      "suggested_scalar": 0.0017,
+      "log_bad": -0.2153,
+      "log_good": -0.2122
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1778,
+      "good": 0.1818,
+      "ratio": 1.0225,
+      "suggested_scalar": 0.0123,
+      "log_bad": -1.7271,
+      "log_good": -1.7048
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.9359,
+      "good": 4.9388,
+      "ratio": 1.0006,
+      "suggested_scalar": 0.0003,
+      "log_bad": 1.5965,
+      "log_good": 1.5971
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 139.0,
+      "good": 116.0,
+      "ratio": 0.8345,
+      "suggested_scalar": -0.1002,
+      "log_bad": 4.9345,
+      "log_good": 4.7536
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.2532,
+      "good": 0.1924,
+      "ratio": 0.7599,
+      "suggested_scalar": -0.1521,
+      "log_bad": -1.3736,
+      "log_good": -1.6482
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 47.0,
+      "good": 40.0,
+      "ratio": 0.8511,
+      "suggested_scalar": -0.0893,
+      "log_bad": 3.8501,
+      "log_good": 3.6889
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 454.0,
+      "good": 435.0,
+      "ratio": 0.9581,
+      "suggested_scalar": -0.0237,
+      "log_bad": 6.1181,
+      "log_good": 6.0753
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 56.0,
+      "good": 52.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.041,
+      "log_bad": 4.0254,
+      "log_good": 3.9512
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.236,
+      "good": 0.3154,
+      "ratio": 1.3364,
+      "suggested_scalar": 0.1606,
+      "log_bad": -1.4439,
+      "log_good": -1.1539
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 24.0,
+      "good": 19.0,
+      "ratio": 0.7917,
+      "suggested_scalar": -0.1294,
+      "log_bad": 3.1781,
+      "log_good": 2.9444
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 47.0,
+      "good": 40.0,
+      "ratio": 0.8511,
+      "suggested_scalar": -0.0893,
+      "log_bad": 3.8501,
+      "log_good": 3.6889
+    },
+    "brevity.mean_sample_size": {
+      "bad": 47.0,
+      "good": 40.0,
+      "ratio": 0.8511,
+      "suggested_scalar": -0.0893,
+      "log_bad": 3.8501,
+      "log_good": 3.6889
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 161.0,
+      "good": 130.0,
+      "ratio": 0.8075,
+      "suggested_scalar": -0.1184,
+      "log_bad": 5.0814,
+      "log_good": 4.8675
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 86.0,
+      "good": 60.0,
+      "ratio": 0.6977,
+      "suggested_scalar": -0.1993,
+      "log_bad": 4.4543,
+      "log_good": 4.0943
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 105.0,
+      "good": 92.0,
+      "ratio": 0.8762,
+      "suggested_scalar": -0.0732,
+      "log_bad": 4.654,
+      "log_good": 4.5218
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.8967,
+      "good": 1.8301,
+      "ratio": 0.9649,
+      "suggested_scalar": -0.0198,
+      "log_bad": 0.6401,
+      "log_good": 0.6044
+    },
+    "halstead.mean_effort": {
+      "bad": 11395.156,
+      "good": 8755.2924,
+      "ratio": 0.7683,
+      "suggested_scalar": -0.1459,
+      "log_bad": 9.3409,
+      "log_good": 9.0774
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8558,
+      "good": 0.8708,
+      "ratio": 1.0175,
+      "suggested_scalar": 0.0096,
+      "log_bad": -0.1557,
+      "log_good": -0.1383
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 28.0,
+      "good": 24.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0854,
+      "log_bad": 3.3322,
+      "log_good": 3.1781
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 84.0,
+      "good": 58.0,
+      "ratio": 0.6905,
+      "suggested_scalar": -0.2051,
+      "log_bad": 4.4308,
+      "log_good": 4.0604
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4706,
+      "good": 0.4375,
+      "ratio": 0.9297,
+      "suggested_scalar": -0.0404,
+      "log_bad": -0.7537,
+      "log_good": -0.8267
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.902,
+      "good": 9.0625,
+      "ratio": 1.018,
+      "suggested_scalar": 0.0099,
+      "log_bad": 2.1863,
+      "log_good": 2.2041
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1778,
+      "good": 0.1818,
+      "ratio": 1.0225,
+      "suggested_scalar": 0.0123,
+      "log_bad": -1.7271,
+      "log_good": -1.7048
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.3294,
+      "good": 2.0242,
+      "ratio": 0.869,
+      "suggested_scalar": -0.0778,
+      "log_bad": 0.8456,
+      "log_good": 0.7052
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 160.0,
+      "good": 129.0,
+      "ratio": 0.8063,
+      "suggested_scalar": -0.1193,
+      "log_bad": 5.0752,
+      "log_good": 4.8598
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.3838,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 13.0,
+      "good": 9.0,
+      "ratio": 0.6923,
+      "suggested_scalar": -0.2036,
+      "log_bad": 2.5649,
+      "log_good": 2.1972
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 633.0642,
+      "good": 486.4051,
+      "ratio": 0.7683,
+      "suggested_scalar": -0.1459,
+      "log_bad": 6.4506,
+      "log_good": 6.187
+    },
+    "readability.mean_total_lines": {
+      "bad": 36.0,
+      "good": 36.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5835,
+      "log_good": 3.5835
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 759.6771,
+      "good": 577.272,
+      "ratio": 0.7599,
+      "suggested_scalar": -0.152,
+      "log_bad": 6.6329,
+      "log_good": 6.3583
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 339.0,
+      "good": 293.0,
+      "ratio": 0.8643,
+      "suggested_scalar": -0.0807,
+      "log_bad": 5.826,
+      "log_good": 5.6802
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 19.9167,
+      "good": 19.6111,
+      "ratio": 0.9847,
+      "suggested_scalar": -0.0086,
+      "log_bad": 2.9916,
+      "log_good": 2.9761
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3784,
+      "good": 1.4058,
+      "ratio": 1.0199,
+      "suggested_scalar": 0.0109,
+      "log_bad": 0.3209,
+      "log_good": 0.3406
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 9.0,
+      "good": 11.0,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.1111,
+      "log_bad": 2.1972,
+      "log_good": 2.3979
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9065,
+      "good": 0.9224,
+      "ratio": 1.0175,
+      "suggested_scalar": 0.0096,
+      "log_bad": -0.0982,
+      "log_good": -0.0808
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.983,
+      "good": 0.9859,
+      "ratio": 1.003,
+      "suggested_scalar": 0.0016,
+      "log_bad": -0.0171,
+      "log_good": -0.0142
+    },
+    "halstead.mean_length": {
+      "bad": 140.0,
+      "good": 110.0,
+      "ratio": 0.7857,
+      "suggested_scalar": -0.1335,
+      "log_bad": 4.9416,
+      "log_good": 4.7005
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.25,
+      "good": 5.125,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0133,
+      "log_bad": 1.6582,
+      "log_good": 1.6341
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.5546,
+      "good": 5.3219,
+      "ratio": 0.9581,
+      "suggested_scalar": -0.0237,
+      "log_bad": 1.7146,
+      "log_good": 1.6718
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1054,
+      "good": 0.08,
+      "ratio": 0.759,
+      "suggested_scalar": -0.1527,
+      "log_bad": -2.25,
+      "log_good": -2.5257
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 15.0,
+      "good": 15.1667,
+      "ratio": 1.0111,
+      "suggested_scalar": 0.0061,
+      "log_bad": 2.7081,
+      "log_good": 2.7191
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 24.0,
+      "good": 21.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0739,
+      "log_bad": 3.1781,
+      "log_good": 3.0445
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7714,
+      "good": 0.7935,
+      "ratio": 1.0286,
+      "suggested_scalar": 0.0156,
+      "log_bad": -0.2595,
+      "log_good": -0.2313
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 37.0,
+      "good": 36.0,
+      "ratio": 0.973,
+      "suggested_scalar": -0.0152,
+      "log_bad": 3.6109,
+      "log_good": 3.5835
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.does_not_return_error_codes": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.2019,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0189,
+      "good": 0.0237,
+      "ratio": 1.254,
+      "suggested_scalar": 0.1358,
+      "log_bad": -3.9686,
+      "log_good": -3.7423
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.25,
+      "good": 1.2,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0245,
+      "log_bad": 0.2231,
+      "log_good": 0.1823
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7024,
+      "good": 0.7778,
+      "ratio": 1.1073,
+      "suggested_scalar": 0.0612,
+      "log_bad": -0.3533,
+      "log_good": -0.2513
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0172,
+      "good": 0.0237,
+      "ratio": 1.3779,
+      "suggested_scalar": 0.1924,
+      "log_bad": -4.0628,
+      "log_good": -3.7423
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.2148,
+      "good": 4.5367,
+      "ratio": 1.0764,
+      "suggested_scalar": 0.0442,
+      "log_bad": 1.4386,
+      "log_good": 1.5122
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 109.0,
+      "good": 95.0,
+      "ratio": 0.8716,
+      "suggested_scalar": -0.0825,
+      "log_bad": 4.6913,
+      "log_good": 4.5539
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5418,
+      "good": 0.4771,
+      "ratio": 0.8806,
+      "suggested_scalar": -0.0763,
+      "log_bad": -0.6129,
+      "log_good": -0.74
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 16.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0707,
+      "log_bad": 2.8904,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6662,
+      "good": 0.6405,
+      "ratio": 0.9614,
+      "suggested_scalar": -0.0236,
+      "log_bad": -0.4062,
+      "log_good": -0.4455
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 11.9048,
+      "good": 9.8413,
+      "ratio": 0.8267,
+      "suggested_scalar": -0.1142,
+      "log_bad": 2.4769,
+      "log_good": 2.2866
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 581.0,
+      "good": 548.0,
+      "ratio": 0.9432,
+      "suggested_scalar": -0.0351,
+      "log_bad": 6.3648,
+      "log_good": 6.3063
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1094,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0003,
+      "good": 0.0004,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1726,
+      "log_bad": -8.1117,
+      "log_good": -7.824
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0357,
+      "good": 1.0,
+      "ratio": 28.0112,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.3326,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0257,
+      "good": 1.0891,
+      "ratio": 1.0618,
+      "suggested_scalar": 0.036,
+      "log_bad": 0.0254,
+      "log_good": 0.0854
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 195.0,
+      "good": 182.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0414,
+      "log_bad": 5.273,
+      "log_good": 5.204
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 96.7178,
+      "good": 89.5191,
+      "ratio": 0.9256,
+      "suggested_scalar": -0.0464,
+      "log_bad": 4.5718,
+      "log_good": 4.4945
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6862,
+      "good": 0.7002,
+      "ratio": 1.0204,
+      "suggested_scalar": 0.0121,
+      "log_bad": -0.3766,
+      "log_good": -0.3564
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.5996,
+      "good": 17.6769,
+      "ratio": 1.2998,
+      "suggested_scalar": 0.1574,
+      "log_bad": 2.61,
+      "log_good": 2.8723
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 3342.0,
+      "good": 2852.0,
+      "ratio": 0.8534,
+      "suggested_scalar": -0.0952,
+      "log_bad": 8.1143,
+      "log_good": 7.9558
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1429,
+      "good": 0.1111,
+      "ratio": 0.7775,
+      "suggested_scalar": -0.1511,
+      "log_bad": -1.9456,
+      "log_good": -2.1973
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.631,
+      "good": 0.7143,
+      "ratio": 1.132,
+      "suggested_scalar": 0.0744,
+      "log_bad": -0.4604,
+      "log_good": -0.3365
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.9167,
+      "good": 8.6984,
+      "ratio": 1.2576,
+      "suggested_scalar": 0.1376,
+      "log_bad": 1.9339,
+      "log_good": 2.1631
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 25.1338,
+      "good": 18.197,
+      "ratio": 0.724,
+      "suggested_scalar": -0.1938,
+      "log_bad": 3.2242,
+      "log_good": 2.9013
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 94.0,
+      "good": 74.0,
+      "ratio": 0.7872,
+      "suggested_scalar": -0.1436,
+      "log_bad": 4.5433,
+      "log_good": 4.3041
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9579,
+      "good": 0.9653,
+      "ratio": 1.0077,
+      "suggested_scalar": 0.0046,
+      "log_bad": -0.043,
+      "log_good": -0.0353
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 24.0,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0245,
+      "log_bad": 3.2189,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.716,
+      "good": 0.7086,
+      "ratio": 0.9897,
+      "suggested_scalar": -0.0062,
+      "log_bad": -0.3341,
+      "log_good": -0.3445
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5078,
+      "good": 0.5385,
+      "ratio": 1.0605,
+      "suggested_scalar": 0.0352,
+      "log_bad": -0.6777,
+      "log_good": -0.619
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.5216,
+      "good": 3.432,
+      "ratio": 0.9746,
+      "suggested_scalar": -0.0155,
+      "log_bad": 1.2589,
+      "log_good": 1.2331
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 579.0,
+      "good": 546.0,
+      "ratio": 0.943,
+      "suggested_scalar": -0.0352,
+      "log_bad": 6.3613,
+      "log_good": 6.3026
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 30.0,
+      "good": 19.0,
+      "ratio": 0.6333,
+      "suggested_scalar": -0.2741,
+      "log_bad": 3.4012,
+      "log_good": 2.9444
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.1699,
+      "good": 6.0661,
+      "ratio": 0.9832,
+      "suggested_scalar": -0.0102,
+      "log_bad": 1.8197,
+      "log_good": 1.8027
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 89.0,
+      "good": 98.0,
+      "ratio": 1.1011,
+      "suggested_scalar": 0.0578,
+      "log_bad": 4.4886,
+      "log_good": 4.585
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3318,
+      "good": 1.2937,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.0174,
+      "log_bad": 0.2865,
+      "log_good": 0.2575
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9048,
+      "good": 5.5487,
+      "ratio": 0.9397,
+      "suggested_scalar": -0.0373,
+      "log_bad": 1.7758,
+      "log_good": 1.7136
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.6831,
+      "good": 0.7479,
+      "ratio": 1.0949,
+      "suggested_scalar": 0.0544,
+      "log_bad": -0.3811,
+      "log_good": -0.2905
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1429,
+      "good": 0.1923,
+      "ratio": 1.3457,
+      "suggested_scalar": 0.1782,
+      "log_bad": -1.9456,
+      "log_good": -1.6487
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6878,
+      "good": 4.2044,
+      "ratio": 1.1401,
+      "suggested_scalar": 0.0787,
+      "log_bad": 1.305,
+      "log_good": 1.4361
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 390.0,
+      "good": 354.0,
+      "ratio": 0.9077,
+      "suggested_scalar": -0.0581,
+      "log_bad": 5.9661,
+      "log_good": 5.8693
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 25.0,
+      "good": 32.0,
+      "ratio": 1.28,
+      "suggested_scalar": 0.1481,
+      "log_bad": 3.2189,
+      "log_good": 3.4657
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0694,
+      "good": 1.0315,
+      "ratio": 0.9646,
+      "suggested_scalar": -0.0217,
+      "log_bad": 0.0671,
+      "log_good": 0.031
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 127.0,
+      "good": 107.0,
+      "ratio": 0.8425,
+      "suggested_scalar": -0.1028,
+      "log_bad": 4.8442,
+      "log_good": 4.6728
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1369.0,
+      "good": 1393.0,
+      "ratio": 1.0175,
+      "suggested_scalar": 0.0104,
+      "log_bad": 7.2218,
+      "log_good": 7.2392
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 177.0,
+      "good": 181.0,
+      "ratio": 1.0226,
+      "suggested_scalar": 0.0134,
+      "log_bad": 5.1761,
+      "log_good": 5.1985
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0017,
+      "good": 0.0018,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.0343,
+      "log_bad": -6.3771,
+      "log_good": -6.32
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2255,
+      "good": 0.2536,
+      "ratio": 1.1246,
+      "suggested_scalar": 0.0705,
+      "log_bad": -1.4894,
+      "log_good": -1.372
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 115.0,
+      "good": 104.0,
+      "ratio": 0.9043,
+      "suggested_scalar": -0.0603,
+      "log_bad": 4.7449,
+      "log_good": 4.6444
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.1339,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 127.0,
+      "good": 107.0,
+      "ratio": 0.8425,
+      "suggested_scalar": -0.1028,
+      "log_bad": 4.8442,
+      "log_good": 4.6728
+    },
+    "brevity.mean_sample_size": {
+      "bad": 127.0,
+      "good": 107.0,
+      "ratio": 0.8425,
+      "suggested_scalar": -0.1028,
+      "log_bad": 4.8442,
+      "log_good": 4.6728
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 581.0,
+      "good": 548.0,
+      "ratio": 0.9432,
+      "suggested_scalar": -0.0351,
+      "log_bad": 6.3648,
+      "log_good": 6.3063
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 293.0,
+      "good": 288.0,
+      "ratio": 0.9829,
+      "suggested_scalar": -0.0103,
+      "log_bad": 5.6802,
+      "log_good": 5.663
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 297.0,
+      "good": 268.0,
+      "ratio": 0.9024,
+      "suggested_scalar": -0.0617,
+      "log_bad": 5.6937,
+      "log_good": 5.591
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.1174,
+      "good": 2.1511,
+      "ratio": 1.0159,
+      "suggested_scalar": 0.0095,
+      "log_bad": 0.7502,
+      "log_good": 0.766
+    },
+    "halstead.mean_effort": {
+      "bad": 84499.5727,
+      "good": 94662.5511,
+      "ratio": 1.1203,
+      "suggested_scalar": 0.0682,
+      "log_bad": 11.3445,
+      "log_good": 11.4581
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8449,
+      "good": 0.8231,
+      "ratio": 0.9742,
+      "suggested_scalar": -0.0157,
+      "log_bad": -0.1685,
+      "log_good": -0.1947
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 84.0,
+      "good": 71.0,
+      "ratio": 0.8452,
+      "suggested_scalar": -0.1009,
+      "log_bad": 4.4308,
+      "log_good": 4.2627
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 297.0,
+      "good": 290.0,
+      "ratio": 0.9764,
+      "suggested_scalar": -0.0143,
+      "log_bad": 5.6937,
+      "log_good": 5.6699
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4308,
+      "good": 0.3736,
+      "ratio": 0.8672,
+      "suggested_scalar": -0.0855,
+      "log_bad": -0.8421,
+      "log_good": -0.9846
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.0205,
+      "good": 7.6538,
+      "ratio": 1.0902,
+      "suggested_scalar": 0.0518,
+      "log_bad": 1.9488,
+      "log_good": 2.0352
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1429,
+      "good": 0.1923,
+      "ratio": 1.3457,
+      "suggested_scalar": 0.1782,
+      "log_bad": -1.9456,
+      "log_good": -1.6487
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.3437,
+      "good": 5.9892,
+      "ratio": 1.3788,
+      "suggested_scalar": 0.1928,
+      "log_bad": 1.4687,
+      "log_good": 1.79
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 580.0,
+      "good": 547.0,
+      "ratio": 0.9431,
+      "suggested_scalar": -0.0352,
+      "log_bad": 6.363,
+      "log_good": 6.3044
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.416,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 105.0,
+      "good": 102.0,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.0174,
+      "log_bad": 4.654,
+      "log_good": 4.625
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4694.4207,
+      "good": 5259.0306,
+      "ratio": 1.1203,
+      "suggested_scalar": 0.0682,
+      "log_bad": 8.4541,
+      "log_good": 8.5677
+    },
+    "readability.mean_total_lines": {
+      "bad": 84.0,
+      "good": 63.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1726,
+      "log_bad": 4.4308,
+      "log_good": 4.1431
+    },
+    "indentation.mean_max_depth": {
+      "bad": 20.0,
+      "good": 16.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1339,
+      "log_bad": 2.9957,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 3208.1194,
+      "good": 3094.402,
+      "ratio": 0.9646,
+      "suggested_scalar": -0.0217,
+      "log_bad": 8.0734,
+      "log_good": 8.0373
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 949.0,
+      "good": 831.0,
+      "ratio": 0.8757,
+      "suggested_scalar": -0.0797,
+      "log_bad": 6.8554,
+      "log_good": 6.7226
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 38.5476,
+      "good": 44.0317,
+      "ratio": 1.1423,
+      "suggested_scalar": 0.0798,
+      "log_bad": 3.6519,
+      "log_good": 3.7849
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2186,
+      "good": 1.2824,
+      "ratio": 1.0524,
+      "suggested_scalar": 0.0306,
+      "log_bad": 0.1977,
+      "log_good": 0.2487
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1094,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 33.0,
+      "good": 39.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.1003,
+      "log_bad": 3.4965,
+      "log_good": 3.6636
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.6593,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7308,
+      "good": 0.7119,
+      "ratio": 0.9741,
+      "suggested_scalar": -0.0157,
+      "log_bad": -0.3136,
+      "log_good": -0.3398
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9498,
+      "good": 0.9577,
+      "ratio": 1.0083,
+      "suggested_scalar": 0.005,
+      "log_bad": -0.0515,
+      "log_good": -0.0432
+    },
+    "halstead.mean_length": {
+      "bad": 474.0,
+      "good": 471.0,
+      "ratio": 0.9937,
+      "suggested_scalar": -0.0038,
+      "log_bad": 6.1612,
+      "log_good": 6.1549
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 20.5,
+      "good": 12.6,
+      "ratio": 0.6146,
+      "suggested_scalar": -0.2921,
+      "log_bad": 3.0204,
+      "log_good": 2.5337
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9887,
+      "good": 6.7415,
+      "ratio": 0.9646,
+      "suggested_scalar": -0.0216,
+      "log_bad": 1.9443,
+      "log_good": 1.9083
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0878,
+      "good": 0.101,
+      "ratio": 1.1503,
+      "suggested_scalar": 0.0841,
+      "log_bad": -2.4327,
+      "log_good": -2.2926
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 26.3393,
+      "good": 30.5915,
+      "ratio": 1.1614,
+      "suggested_scalar": 0.0898,
+      "log_bad": 3.2711,
+      "log_good": 3.4207
+    },
+    "branching.mean_branch_count": {
+      "bad": 12.0,
+      "good": 7.0,
+      "ratio": 0.5833,
+      "suggested_scalar": -0.3235,
+      "log_bad": 2.4849,
+      "log_good": 1.9459
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 84.0,
+      "good": 68.0,
+      "ratio": 0.8095,
+      "suggested_scalar": -0.1268,
+      "log_bad": 4.4308,
+      "log_good": 4.2195
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6128,
+      "good": 0.6119,
+      "ratio": 0.9985,
+      "suggested_scalar": -0.0009,
+      "log_bad": -0.4897,
+      "log_good": -0.4912
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 84.0,
+      "good": 63.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1726,
+      "log_bad": 4.4308,
+      "log_good": 4.1431
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 23.0,
+      "ratio": 1.2778,
+      "suggested_scalar": 0.1471,
+      "log_bad": 2.8904,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.uses_string_builder_for_loop_concatenation": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0568,
+      "good": 0.0571,
+      "ratio": 1.0053,
+      "suggested_scalar": 0.0017,
+      "log_bad": -2.8682,
+      "log_good": -2.863
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.25,
+      "good": 1.25,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2231,
+      "log_good": 0.2231
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8039,
+      "good": 0.8167,
+      "ratio": 1.0159,
+      "suggested_scalar": 0.005,
+      "log_bad": -0.2183,
+      "log_good": -0.2025
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0589,
+      "good": 0.0589,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.8319,
+      "log_good": -2.8319
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.1815,
+      "good": 4.2681,
+      "ratio": 1.0207,
+      "suggested_scalar": 0.0065,
+      "log_bad": 1.4307,
+      "log_good": 1.4512
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 105.0,
+      "good": 95.0,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.0317,
+      "log_bad": 4.654,
+      "log_good": 4.5539
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4628,
+      "good": 0.3529,
+      "ratio": 0.7625,
+      "suggested_scalar": -0.0858,
+      "log_bad": -0.7705,
+      "log_good": -1.0416
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 18.0,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.0181,
+      "log_bad": 2.8332,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.4953,
+      "good": 0.5099,
+      "ratio": 1.0295,
+      "suggested_scalar": 0.0092,
+      "log_bad": -0.7026,
+      "log_good": -0.6735
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 10.7451,
+      "good": 11.1,
+      "ratio": 1.033,
+      "suggested_scalar": 0.0103,
+      "log_bad": 2.3744,
+      "log_good": 2.4069
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 475.0,
+      "good": 543.0,
+      "ratio": 1.1432,
+      "suggested_scalar": 0.0423,
+      "log_bad": 6.1633,
+      "log_good": 6.2971
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 7.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.0488,
+      "log_bad": 1.7918,
+      "log_good": 1.9459
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.001,
+      "good": 0.0009,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0333,
+      "log_bad": -6.9078,
+      "log_good": -7.0131
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0392,
+      "good": 1.0,
+      "ratio": 25.5102,
+      "suggested_scalar": 1.025,
+      "log_bad": -3.2391,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0016,
+      "good": 0.0014,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0423,
+      "log_bad": -6.4378,
+      "log_good": -6.5713
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.124,
+      "good": 1.2005,
+      "ratio": 1.0681,
+      "suggested_scalar": 0.0208,
+      "log_bad": 0.1169,
+      "log_good": 0.1827
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 131.0,
+      "good": 141.0,
+      "ratio": 1.0763,
+      "suggested_scalar": 0.0233,
+      "log_bad": 4.8752,
+      "log_good": 4.9488
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 107.0782,
+      "good": 97.3312,
+      "ratio": 0.909,
+      "suggested_scalar": -0.0302,
+      "log_bad": 4.6736,
+      "log_good": 4.5781
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6709,
+      "good": 0.7546,
+      "ratio": 1.1248,
+      "suggested_scalar": 0.0372,
+      "log_bad": -0.3991,
+      "log_good": -0.2816
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.8257,
+      "good": 10.1721,
+      "ratio": 1.1526,
+      "suggested_scalar": 0.0449,
+      "log_bad": 2.1777,
+      "log_good": 2.3196
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1907.0,
+      "good": 2180.0,
+      "ratio": 1.1432,
+      "suggested_scalar": 0.0423,
+      "log_bad": 7.5533,
+      "log_good": 7.6871
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1176,
+      "good": 0.0833,
+      "ratio": 0.7083,
+      "suggested_scalar": -0.1091,
+      "log_bad": -2.1405,
+      "log_good": -2.4853
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6471,
+      "good": 0.6833,
+      "ratio": 1.0559,
+      "suggested_scalar": 0.0172,
+      "log_bad": -0.4353,
+      "log_good": -0.3808
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.3137,
+      "good": 9.05,
+      "ratio": 0.9717,
+      "suggested_scalar": -0.0091,
+      "log_bad": 2.2315,
+      "log_good": 2.2028
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0706,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 21.0135,
+      "good": 24.0567,
+      "ratio": 1.1448,
+      "suggested_scalar": 0.0428,
+      "log_bad": 3.0452,
+      "log_good": 3.1804
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 90.0,
+      "good": 64.0,
+      "ratio": 0.7111,
+      "suggested_scalar": -0.1079,
+      "log_bad": 4.4998,
+      "log_good": 4.1589
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9324,
+      "good": 0.9606,
+      "ratio": 1.0302,
+      "suggested_scalar": 0.0094,
+      "log_bad": -0.07,
+      "log_good": -0.0402
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 22.0,
+      "ratio": 0.88,
+      "suggested_scalar": -0.0405,
+      "log_bad": 3.2189,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6618,
+      "good": 0.722,
+      "ratio": 1.091,
+      "suggested_scalar": 0.0276,
+      "log_bad": -0.4128,
+      "log_good": -0.3257
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4884,
+      "good": 0.6396,
+      "ratio": 1.3096,
+      "suggested_scalar": 0.0854,
+      "log_bad": -0.7166,
+      "log_good": -0.4469
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9566,
+      "good": 3.5974,
+      "ratio": 1.2167,
+      "suggested_scalar": 0.0621,
+      "log_bad": 1.084,
+      "log_good": 1.2802
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 473.0,
+      "good": 541.0,
+      "ratio": 1.1438,
+      "suggested_scalar": 0.0425,
+      "log_bad": 6.1591,
+      "log_good": 6.2934
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 19.0,
+      "good": 23.0,
+      "ratio": 1.2105,
+      "suggested_scalar": 0.0605,
+      "log_bad": 2.9444,
+      "log_good": 3.1355
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 0.0018,
+      "ratio": 0.0018,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.32
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 6.0,
+      "ratio": 1.0117,
+      "suggested_scalar": 0.0037,
+      "log_bad": 1.7801,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 33.0,
+      "good": 70.0,
+      "ratio": 2.1212,
+      "suggested_scalar": 0.238,
+      "log_bad": 3.4965,
+      "log_good": 4.2485
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1777,
+      "good": 1.2828,
+      "ratio": 1.0892,
+      "suggested_scalar": 0.0271,
+      "log_bad": 0.1636,
+      "log_good": 0.249
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.3662,
+      "good": 4.9473,
+      "ratio": 0.9219,
+      "suggested_scalar": -0.0257,
+      "log_bad": 1.6801,
+      "log_good": 1.5988
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7051,
+      "good": 0.7114,
+      "ratio": 1.0089,
+      "suggested_scalar": 0.0028,
+      "log_bad": -0.3494,
+      "log_good": -0.3405
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1639,
+      "good": 0.1667,
+      "ratio": 1.0171,
+      "suggested_scalar": 0.0054,
+      "log_bad": -1.8085,
+      "log_good": -1.7916
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.9708,
+      "good": 3.1894,
+      "ratio": 1.0736,
+      "suggested_scalar": 0.0225,
+      "log_bad": 1.0888,
+      "log_good": 1.1598
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 300.0,
+      "good": 262.0,
+      "ratio": 0.8733,
+      "suggested_scalar": -0.0429,
+      "log_bad": 5.7038,
+      "log_good": 5.5683
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 35.0,
+      "ratio": 17.5,
+      "suggested_scalar": 0.9058,
+      "log_bad": 0.6931,
+      "log_good": 3.5553
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8236,
+      "good": 1.038,
+      "ratio": 1.2603,
+      "suggested_scalar": 0.0732,
+      "log_bad": -0.1941,
+      "log_good": 0.0373
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 94.0,
+      "good": 83.0,
+      "ratio": 0.883,
+      "suggested_scalar": -0.0394,
+      "log_bad": 4.5433,
+      "log_good": 4.4188
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 614.0,
+      "good": 802.0,
+      "ratio": 1.3062,
+      "suggested_scalar": 0.0845,
+      "log_bad": 6.42,
+      "log_good": 6.6871
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 139.0,
+      "good": 165.0,
+      "ratio": 1.1871,
+      "suggested_scalar": 0.0543,
+      "log_bad": 4.9345,
+      "log_good": 5.1059
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0021,
+      "good": 0.0018,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0488,
+      "log_bad": -6.1658,
+      "log_good": -6.32
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1958,
+      "good": 0.2468,
+      "ratio": 1.2605,
+      "suggested_scalar": 0.0733,
+      "log_bad": -1.6307,
+      "log_good": -1.3992
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 69.0,
+      "good": 65.0,
+      "ratio": 0.942,
+      "suggested_scalar": -0.0189,
+      "log_bad": 4.2341,
+      "log_good": 4.1744
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 94.0,
+      "good": 83.0,
+      "ratio": 0.883,
+      "suggested_scalar": -0.0394,
+      "log_bad": 4.5433,
+      "log_good": 4.4188
+    },
+    "brevity.mean_sample_size": {
+      "bad": 94.0,
+      "good": 83.0,
+      "ratio": 0.883,
+      "suggested_scalar": -0.0394,
+      "log_bad": 4.5433,
+      "log_good": 4.4188
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 475.0,
+      "good": 543.0,
+      "ratio": 1.1432,
+      "suggested_scalar": 0.0423,
+      "log_bad": 6.1633,
+      "log_good": 6.2971
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 297.0,
+      "good": 359.0,
+      "ratio": 1.2088,
+      "suggested_scalar": 0.06,
+      "log_bad": 5.6937,
+      "log_good": 5.8833
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 225.0,
+      "good": 198.0,
+      "ratio": 0.88,
+      "suggested_scalar": -0.0405,
+      "log_bad": 5.4161,
+      "log_good": 5.2883
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0018,
+      "ratio": 0.0018,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.32
+    },
+    "heaps.mean_k": {
+      "bad": 4.5185,
+      "good": 3.3348,
+      "ratio": 0.738,
+      "suggested_scalar": -0.0961,
+      "log_bad": 1.5082,
+      "log_good": 1.2044
+    },
+    "halstead.mean_effort": {
+      "bad": 53663.6073,
+      "good": 77426.1983,
+      "ratio": 1.4428,
+      "suggested_scalar": 0.116,
+      "log_bad": 10.8905,
+      "log_good": 11.2571
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8187,
+      "good": 0.776,
+      "ratio": 0.9478,
+      "suggested_scalar": -0.017,
+      "log_bad": -0.2,
+      "log_good": -0.2536
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 80.0,
+      "good": 73.0,
+      "ratio": 0.9125,
+      "suggested_scalar": -0.029,
+      "log_bad": 4.382,
+      "log_good": 4.2905
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 229.0,
+      "good": 309.0,
+      "ratio": 1.3493,
+      "suggested_scalar": 0.0948,
+      "log_bad": 5.4337,
+      "log_good": 5.7333
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4733,
+      "good": 0.3617,
+      "ratio": 0.7642,
+      "suggested_scalar": -0.0851,
+      "log_bad": -0.748,
+      "log_good": -1.0169
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.687,
+      "good": 5.6879,
+      "ratio": 1.2135,
+      "suggested_scalar": 0.0612,
+      "log_bad": 1.5448,
+      "log_good": 1.7383
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1639,
+      "good": 0.1667,
+      "ratio": 1.0171,
+      "suggested_scalar": 0.0054,
+      "log_bad": -1.8085,
+      "log_good": -1.7916
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.9502,
+      "good": 3.8386,
+      "ratio": 0.9717,
+      "suggested_scalar": -0.0091,
+      "log_bad": 1.3738,
+      "log_good": 1.3451
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 474.0,
+      "good": 542.0,
+      "ratio": 1.1435,
+      "suggested_scalar": 0.0424,
+      "log_bad": 6.1612,
+      "log_good": 6.2953
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 58.0,
+      "good": 67.0,
+      "ratio": 1.1552,
+      "suggested_scalar": 0.0456,
+      "log_bad": 4.0604,
+      "log_good": 4.2047
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2981.3115,
+      "good": 4301.4555,
+      "ratio": 1.4428,
+      "suggested_scalar": 0.116,
+      "log_bad": 8.0001,
+      "log_good": 8.3667
+    },
+    "readability.mean_total_lines": {
+      "bad": 51.0,
+      "good": 60.0,
+      "ratio": 1.1765,
+      "suggested_scalar": 0.0514,
+      "log_bad": 3.9318,
+      "log_good": 4.0943
+    },
+    "indentation.mean_max_depth": {
+      "bad": 20.0,
+      "good": 22.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0302,
+      "log_bad": 2.9957,
+      "log_good": 3.091
+    },
+    "halstead.mean_volume": {
+      "bad": 2470.8424,
+      "good": 3114.1116,
+      "ratio": 1.2603,
+      "suggested_scalar": 0.0732,
+      "log_bad": 7.8123,
+      "log_good": 8.0437
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 645.0,
+      "good": 606.0,
+      "ratio": 0.9395,
+      "suggested_scalar": -0.0197,
+      "log_bad": 6.4693,
+      "log_good": 6.4069
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 36.1765,
+      "good": 35.1333,
+      "ratio": 0.9712,
+      "suggested_scalar": -0.0093,
+      "log_bad": 3.5884,
+      "log_good": 3.5591
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0674,
+      "good": 1.1858,
+      "ratio": 1.1109,
+      "suggested_scalar": 0.0333,
+      "log_bad": 0.0652,
+      "log_good": 0.1704
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 7.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.0488,
+      "log_bad": 1.7918,
+      "log_good": 1.9459
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 12.0,
+      "good": 48.0,
+      "ratio": 4.0,
+      "suggested_scalar": 0.4387,
+      "log_bad": 2.4849,
+      "log_good": 3.8712
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2194,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8067,
+      "good": 0.7443,
+      "ratio": 0.9226,
+      "suggested_scalar": -0.0255,
+      "log_bad": -0.2148,
+      "log_good": -0.2953
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9398,
+      "good": 0.9456,
+      "ratio": 1.0062,
+      "suggested_scalar": 0.0019,
+      "log_bad": -0.0621,
+      "log_good": -0.0559
+    },
+    "halstead.mean_length": {
+      "bad": 368.0,
+      "good": 474.0,
+      "ratio": 1.288,
+      "suggested_scalar": 0.0801,
+      "log_bad": 5.9081,
+      "log_good": 6.1612
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 13.75,
+      "good": 16.25,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0529,
+      "log_bad": 2.621,
+      "log_good": 2.7881
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5546,
+      "good": 6.375,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.0088,
+      "log_bad": 1.8802,
+      "log_good": 1.8524
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1558,
+      "good": 0.1647,
+      "ratio": 1.0571,
+      "suggested_scalar": 0.0176,
+      "log_bad": -1.8592,
+      "log_good": -1.8036
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 21.7188,
+      "good": 24.863,
+      "ratio": 1.1448,
+      "suggested_scalar": 0.0428,
+      "log_bad": 3.0782,
+      "log_good": 3.2134
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0577,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 62.0,
+      "good": 51.0,
+      "ratio": 0.8226,
+      "suggested_scalar": -0.0618,
+      "log_bad": 4.1271,
+      "log_good": 3.9318
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6933,
+      "good": 0.6717,
+      "ratio": 0.9688,
+      "suggested_scalar": -0.01,
+      "log_bad": -0.3663,
+      "log_good": -0.3979
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 51.0,
+      "good": 60.0,
+      "ratio": 1.1765,
+      "suggested_scalar": 0.0514,
+      "log_bad": 3.9318,
+      "log_good": 4.0943
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.uses_arc_only_with_send_sync_types": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 5.0,
+      "good": 7.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.1013,
+      "log_bad": 1.6094,
+      "log_good": 1.9459
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0024,
+      "good": 1.0,
+      "ratio": 416.6667,
+      "suggested_scalar": 1.8155,
+      "log_bad": -6.0323,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.2,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0549,
+      "log_bad": 0.0,
+      "log_good": 0.1823
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8444,
+      "good": 0.8298,
+      "ratio": 0.9827,
+      "suggested_scalar": -0.0052,
+      "log_bad": -0.1691,
+      "log_good": -0.1866
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0024,
+      "good": 1.0,
+      "ratio": 416.6667,
+      "suggested_scalar": 1.8155,
+      "log_bad": -6.0323,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7191,
+      "good": 4.7134,
+      "ratio": 0.9988,
+      "suggested_scalar": -0.0004,
+      "log_bad": 1.5516,
+      "log_good": 1.5504
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 111.0,
+      "good": 109.0,
+      "ratio": 0.982,
+      "suggested_scalar": -0.0055,
+      "log_bad": 4.7095,
+      "log_good": 4.6913
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.58,
+      "good": 0.5169,
+      "ratio": 0.8912,
+      "suggested_scalar": -0.0347,
+      "log_bad": -0.5447,
+      "log_good": -0.6599
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 20.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0154,
+      "log_bad": 2.9444,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.8279,
+      "good": 0.6382,
+      "ratio": 0.7709,
+      "suggested_scalar": -0.0783,
+      "log_bad": -0.1889,
+      "log_good": -0.4491
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.3778,
+      "good": 4.766,
+      "ratio": 1.411,
+      "suggested_scalar": 0.1036,
+      "log_bad": 1.2172,
+      "log_good": 1.5615
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 410.0,
+      "good": 439.0,
+      "ratio": 1.0707,
+      "suggested_scalar": 0.0206,
+      "log_bad": 6.0162,
+      "log_good": 6.0845
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0013,
+      "good": 1.0,
+      "ratio": 769.2308,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.6454,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2,
+      "good": 0.1489,
+      "ratio": 0.7445,
+      "suggested_scalar": -0.0888,
+      "log_bad": -1.6094,
+      "log_good": -1.9045
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.961,
+      "good": 1.0238,
+      "ratio": 1.0653,
+      "suggested_scalar": 0.0191,
+      "log_bad": -0.0398,
+      "log_good": 0.0235
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 151.0,
+      "good": 154.0,
+      "ratio": 1.0199,
+      "suggested_scalar": 0.0059,
+      "log_bad": 5.0173,
+      "log_good": 5.037
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 108.1298,
+      "good": 107.9641,
+      "ratio": 0.9985,
+      "suggested_scalar": -0.0005,
+      "log_bad": 4.6833,
+      "log_good": 4.6818
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6112,
+      "good": 0.6073,
+      "ratio": 0.9936,
+      "suggested_scalar": -0.0019,
+      "log_bad": -0.4923,
+      "log_good": -0.4987
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.0899,
+      "good": 8.5,
+      "ratio": 1.0507,
+      "suggested_scalar": 0.0149,
+      "log_bad": 2.0906,
+      "log_good": 2.1401
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1523.0,
+      "good": 1588.0,
+      "ratio": 1.0427,
+      "suggested_scalar": 0.0126,
+      "log_bad": 7.3284,
+      "log_good": 7.3702
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0444,
+      "good": 1.0,
+      "ratio": 22.5225,
+      "suggested_scalar": 0.9373,
+      "log_bad": -3.1145,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8222,
+      "good": 0.8085,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0051,
+      "log_bad": -0.1958,
+      "log_good": -0.2126
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.1111,
+      "good": 9.5435,
+      "ratio": 1.0475,
+      "suggested_scalar": 0.014,
+      "log_bad": 2.2095,
+      "log_good": 2.2559
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.122,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 13.4795,
+      "good": 19.4984,
+      "ratio": 1.4465,
+      "suggested_scalar": 0.1111,
+      "log_bad": 2.6012,
+      "log_good": 2.9703
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 85.0,
+      "good": 94.0,
+      "ratio": 1.1059,
+      "suggested_scalar": 0.0303,
+      "log_bad": 4.4427,
+      "log_good": 4.5433
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9457,
+      "good": 0.9425,
+      "ratio": 0.9966,
+      "suggested_scalar": -0.001,
+      "log_bad": -0.0558,
+      "log_good": -0.0592
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 29.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3673,
+      "log_good": 3.3673
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5732,
+      "good": 0.5806,
+      "ratio": 1.0129,
+      "suggested_scalar": 0.0039,
+      "log_bad": -0.5565,
+      "log_good": -0.5437
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3603,
+      "good": 0.3616,
+      "ratio": 1.0036,
+      "suggested_scalar": 0.0011,
+      "log_bad": -1.0208,
+      "log_good": -1.0172
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3431,
+      "good": 2.3844,
+      "ratio": 1.0176,
+      "suggested_scalar": 0.0053,
+      "log_bad": 0.8515,
+      "log_good": 0.8689
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 408.0,
+      "good": 437.0,
+      "ratio": 1.0711,
+      "suggested_scalar": 0.0207,
+      "log_bad": 6.0113,
+      "log_good": 6.0799
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 18.0,
+      "good": 11.0,
+      "ratio": 0.6111,
+      "suggested_scalar": -0.1482,
+      "log_bad": 2.8904,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0683,
+      "good": 0.0501,
+      "ratio": 0.7335,
+      "suggested_scalar": -0.0933,
+      "log_bad": -2.6838,
+      "log_good": -2.9937
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9773,
+      "good": 5.9542,
+      "ratio": 0.9961,
+      "suggested_scalar": -0.0012,
+      "log_bad": 1.788,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 64.0,
+      "good": 57.0,
+      "ratio": 0.8906,
+      "suggested_scalar": -0.0349,
+      "log_bad": 4.1589,
+      "log_good": 4.0431
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0742,
+      "good": 1.0761,
+      "ratio": 1.0018,
+      "suggested_scalar": 0.0005,
+      "log_bad": 0.0716,
+      "log_good": 0.0733
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9141,
+      "good": 5.7962,
+      "ratio": 0.9801,
+      "suggested_scalar": -0.0061,
+      "log_bad": 1.7773,
+      "log_good": 1.7572
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7895,
+      "good": 0.7916,
+      "ratio": 1.0027,
+      "suggested_scalar": 0.0008,
+      "log_bad": -0.2364,
+      "log_good": -0.2337
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1346,
+      "good": 0.1455,
+      "ratio": 1.081,
+      "suggested_scalar": 0.0234,
+      "log_bad": -2.0054,
+      "log_good": -1.9276
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.8443,
+      "good": 2.9155,
+      "ratio": 1.025,
+      "suggested_scalar": 0.0074,
+      "log_bad": 1.0453,
+      "log_good": 1.07
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 322.0,
+      "good": 337.0,
+      "ratio": 1.0466,
+      "suggested_scalar": 0.0137,
+      "log_bad": 5.7746,
+      "log_good": 5.8201
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 9.0,
+      "ratio": 2.25,
+      "suggested_scalar": 0.2441,
+      "log_bad": 1.3863,
+      "log_good": 2.1972
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9037,
+      "good": 0.9656,
+      "ratio": 1.0685,
+      "suggested_scalar": 0.0199,
+      "log_bad": -0.1013,
+      "log_good": -0.035
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 108.0,
+      "ratio": 0.9558,
+      "suggested_scalar": -0.0136,
+      "log_bad": 4.7274,
+      "log_good": 4.6821
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 763.0,
+      "good": 769.0,
+      "ratio": 1.0079,
+      "suggested_scalar": 0.0024,
+      "log_bad": 6.6373,
+      "log_good": 6.6451
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 167.0,
+      "good": 172.0,
+      "ratio": 1.0299,
+      "suggested_scalar": 0.0089,
+      "log_bad": 5.118,
+      "log_good": 5.1475
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0098,
+      "good": 0.0114,
+      "ratio": 1.1633,
+      "suggested_scalar": 0.0455,
+      "log_bad": -4.6254,
+      "log_good": -4.4741
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2415,
+      "good": 0.2528,
+      "ratio": 1.0468,
+      "suggested_scalar": 0.0138,
+      "log_bad": -1.4209,
+      "log_good": -1.3752
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 84.0,
+      "good": 81.0,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.0109,
+      "log_bad": 4.4308,
+      "log_good": 4.3944
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0672,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 108.0,
+      "ratio": 0.9558,
+      "suggested_scalar": -0.0136,
+      "log_bad": 4.7274,
+      "log_good": 4.6821
+    },
+    "brevity.mean_sample_size": {
+      "bad": 113.0,
+      "good": 108.0,
+      "ratio": 0.9558,
+      "suggested_scalar": -0.0136,
+      "log_bad": 4.7274,
+      "log_good": 4.6821
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 410.0,
+      "good": 439.0,
+      "ratio": 1.0707,
+      "suggested_scalar": 0.0206,
+      "log_bad": 6.0162,
+      "log_good": 6.0845
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 201.0,
+      "good": 236.0,
+      "ratio": 1.1741,
+      "suggested_scalar": 0.0483,
+      "log_bad": 5.3033,
+      "log_good": 5.4638
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 243.0,
+      "good": 253.0,
+      "ratio": 1.0412,
+      "suggested_scalar": 0.0121,
+      "log_bad": 5.4931,
+      "log_good": 5.5334
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 0.968,
+      "good": 2.5665,
+      "ratio": 2.6513,
+      "suggested_scalar": 0.2935,
+      "log_bad": -0.0325,
+      "log_good": 0.9425
+    },
+    "halstead.mean_effort": {
+      "bad": 80056.3235,
+      "good": 90307.2066,
+      "ratio": 1.128,
+      "suggested_scalar": 0.0363,
+      "log_bad": 11.2905,
+      "log_good": 11.411
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8671,
+      "good": 0.8581,
+      "ratio": 0.9896,
+      "suggested_scalar": -0.0031,
+      "log_bad": -0.1426,
+      "log_good": -0.153
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 82.0,
+      "good": 80.0,
+      "ratio": 0.9756,
+      "suggested_scalar": -0.0074,
+      "log_bad": 4.4067,
+      "log_good": 4.382
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 232.0,
+      "good": 256.0,
+      "ratio": 1.1034,
+      "suggested_scalar": 0.0296,
+      "log_bad": 5.4467,
+      "log_good": 5.5452
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4967,
+      "good": 0.461,
+      "ratio": 0.9281,
+      "suggested_scalar": -0.0224,
+      "log_bad": -0.6998,
+      "log_good": -0.7744
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.053,
+      "good": 4.9935,
+      "ratio": 0.9882,
+      "suggested_scalar": -0.0036,
+      "log_bad": 1.62,
+      "log_good": 1.6081
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1346,
+      "good": 0.1455,
+      "ratio": 1.081,
+      "suggested_scalar": 0.0234,
+      "log_bad": -2.0054,
+      "log_good": -1.9276
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.0272,
+      "good": 4.0144,
+      "ratio": 0.9968,
+      "suggested_scalar": -0.001,
+      "log_bad": 1.3931,
+      "log_good": 1.3899
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 409.0,
+      "good": 438.0,
+      "ratio": 1.0709,
+      "suggested_scalar": 0.0206,
+      "log_bad": 6.0137,
+      "log_good": 6.0822
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2086,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 61.0,
+      "good": 58.0,
+      "ratio": 0.9508,
+      "suggested_scalar": -0.0152,
+      "log_bad": 4.1109,
+      "log_good": 4.0604
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4447.5735,
+      "good": 5017.067,
+      "ratio": 1.128,
+      "suggested_scalar": 0.0363,
+      "log_bad": 8.4001,
+      "log_good": 8.5206
+    },
+    "readability.mean_total_lines": {
+      "bad": 45.0,
+      "good": 46.0,
+      "ratio": 1.0222,
+      "suggested_scalar": 0.0066,
+      "log_bad": 3.8067,
+      "log_good": 3.8286
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2710.9719,
+      "good": 2896.7829,
+      "ratio": 1.0685,
+      "suggested_scalar": 0.02,
+      "log_bad": 7.9051,
+      "log_good": 7.9714
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 650.0,
+      "good": 666.0,
+      "ratio": 1.0246,
+      "suggested_scalar": 0.0073,
+      "log_bad": 6.477,
+      "log_good": 6.5013
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.5111,
+      "good": 32.8913,
+      "ratio": 1.0117,
+      "suggested_scalar": 0.0035,
+      "log_bad": 3.4816,
+      "log_good": 3.4932
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0574,
+      "good": 1.0542,
+      "ratio": 0.997,
+      "suggested_scalar": -0.0009,
+      "log_bad": 0.0558,
+      "log_good": 0.0528
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 15.0,
+      "good": 26.0,
+      "ratio": 1.7333,
+      "suggested_scalar": 0.1655,
+      "log_bad": 2.7081,
+      "log_good": 3.2581
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 9.0,
+      "good": 7.0,
+      "ratio": 0.7778,
+      "suggested_scalar": -0.0756,
+      "log_bad": 2.1972,
+      "log_good": 1.9459
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8106,
+      "good": 0.8279,
+      "ratio": 1.0213,
+      "suggested_scalar": 0.0064,
+      "log_bad": -0.21,
+      "log_good": -0.1889
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9639,
+      "good": 0.9421,
+      "ratio": 0.9774,
+      "suggested_scalar": -0.0069,
+      "log_bad": -0.0368,
+      "log_good": -0.0596
+    },
+    "halstead.mean_length": {
+      "bad": 399.0,
+      "good": 428.0,
+      "ratio": 1.0727,
+      "suggested_scalar": 0.0211,
+      "log_bad": 5.989,
+      "log_good": 6.0591
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.5,
+      "good": 7.2,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0123,
+      "log_bad": 2.0149,
+      "log_good": 1.9741
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8202,
+      "good": 6.7549,
+      "ratio": 0.9904,
+      "suggested_scalar": -0.0029,
+      "log_bad": 1.9199,
+      "log_good": 1.9103
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1327,
+      "good": 0.149,
+      "ratio": 1.1228,
+      "suggested_scalar": 0.0349,
+      "log_bad": -2.0197,
+      "log_good": -1.9038
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.5305,
+      "good": 31.175,
+      "ratio": 1.0557,
+      "suggested_scalar": 0.0163,
+      "log_bad": 3.3854,
+      "log_good": 3.4396
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2086,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 75.0,
+      "good": 71.0,
+      "ratio": 0.9467,
+      "suggested_scalar": -0.0165,
+      "log_bad": 4.3175,
+      "log_good": 4.2627
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6543,
+      "good": 0.6798,
+      "ratio": 1.039,
+      "suggested_scalar": 0.0115,
+      "log_bad": -0.4242,
+      "log_good": -0.386
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 45.0,
+      "good": 47.0,
+      "ratio": 1.0444,
+      "suggested_scalar": 0.0131,
+      "log_bad": 3.8067,
+      "log_good": 3.8501
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 17.0,
+      "ratio": 1.1333,
+      "suggested_scalar": 0.0377,
+      "log_bad": 2.7081,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "file_structure.one_top_level_class_per_file": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 28.0,
+      "good": 29.0,
+      "ratio": 1.0357,
+      "suggested_scalar": 0.011,
+      "log_bad": 3.3322,
+      "log_good": 3.3673
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1272,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.3333,
+      "good": 0.6667,
+      "ratio": 2.0003,
+      "suggested_scalar": 0.2174,
+      "log_bad": -1.0987,
+      "log_good": -0.4054
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8636,
+      "good": 0.9231,
+      "ratio": 1.0689,
+      "suggested_scalar": 0.0209,
+      "log_bad": -0.1466,
+      "log_good": -0.08
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6526,
+      "good": 4.5631,
+      "ratio": 0.9808,
+      "suggested_scalar": -0.0061,
+      "log_bad": 1.5374,
+      "log_good": 1.518
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 89.0,
+      "good": 99.0,
+      "ratio": 1.1124,
+      "suggested_scalar": 0.0334,
+      "log_bad": 4.4886,
+      "log_good": 4.5951
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4877,
+      "good": 0.5172,
+      "ratio": 1.0605,
+      "suggested_scalar": 0.0184,
+      "log_bad": -0.7181,
+      "log_good": -0.6593
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0216,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6901,
+      "good": 0.7123,
+      "ratio": 1.0322,
+      "suggested_scalar": 0.0099,
+      "log_bad": -0.3709,
+      "log_good": -0.3393
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.3636,
+      "good": 6.4423,
+      "ratio": 1.4764,
+      "suggested_scalar": 0.1222,
+      "log_bad": 1.4733,
+      "log_good": 1.8629
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 334.0,
+      "good": 349.0,
+      "ratio": 1.0449,
+      "suggested_scalar": 0.0138,
+      "log_bad": 5.8111,
+      "log_good": 5.8551
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0017,
+      "good": 1.0,
+      "ratio": 588.2353,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.3771,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0682,
+      "good": 0.0769,
+      "ratio": 1.1276,
+      "suggested_scalar": 0.0377,
+      "log_bad": -2.6853,
+      "log_good": -2.5652
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9411,
+      "good": 0.9378,
+      "ratio": 0.9965,
+      "suggested_scalar": -0.0011,
+      "log_bad": -0.0607,
+      "log_good": -0.0642
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 121.0,
+      "good": 135.0,
+      "ratio": 1.1157,
+      "suggested_scalar": 0.0343,
+      "log_bad": 4.7958,
+      "log_good": 4.9053
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 88.1233,
+      "good": 81.4783,
+      "ratio": 0.9246,
+      "suggested_scalar": -0.0246,
+      "log_bad": 4.4787,
+      "log_good": 4.4003
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5195,
+      "good": 0.477,
+      "ratio": 0.9182,
+      "suggested_scalar": -0.0268,
+      "log_bad": -0.6549,
+      "log_good": -0.7402
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.9059,
+      "good": 17.8533,
+      "ratio": 1.2839,
+      "suggested_scalar": 0.0784,
+      "log_bad": 2.6323,
+      "log_good": 2.8822
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1752.0,
+      "good": 1970.0,
+      "ratio": 1.1244,
+      "suggested_scalar": 0.0368,
+      "log_bad": 7.4685,
+      "log_good": 7.5858
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 0.0192,
+      "ratio": 0.0192,
+      "suggested_scalar": -1.2397,
+      "log_bad": 0.0,
+      "log_good": -3.9528
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8409,
+      "good": 0.9038,
+      "ratio": 1.0748,
+      "suggested_scalar": 0.0226,
+      "log_bad": -0.1733,
+      "log_good": -0.1011
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.5909,
+      "good": 6.7115,
+      "ratio": 0.8842,
+      "suggested_scalar": -0.0386,
+      "log_bad": 2.027,
+      "log_good": 1.9038
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 13.686,
+      "good": 16.0928,
+      "ratio": 1.1759,
+      "suggested_scalar": 0.0508,
+      "log_bad": 2.6164,
+      "log_good": 2.7784
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 62.0,
+      "good": 70.0,
+      "ratio": 1.129,
+      "suggested_scalar": 0.0381,
+      "log_bad": 4.1271,
+      "log_good": 4.2485
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9394,
+      "good": 0.9565,
+      "ratio": 1.0182,
+      "suggested_scalar": 0.0057,
+      "log_bad": -0.0625,
+      "log_good": -0.0445
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 23.0,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.0139,
+      "log_bad": 3.091,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.641,
+      "good": 0.6355,
+      "ratio": 0.9914,
+      "suggested_scalar": -0.0027,
+      "log_bad": -0.4447,
+      "log_good": -0.4533
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2801,
+      "good": 0.2392,
+      "ratio": 0.854,
+      "suggested_scalar": -0.0495,
+      "log_bad": -1.2726,
+      "log_good": -1.4305
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7854,
+      "good": 2.7437,
+      "ratio": 0.985,
+      "suggested_scalar": -0.0047,
+      "log_bad": 1.0244,
+      "log_good": 1.0093
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 332.0,
+      "good": 347.0,
+      "ratio": 1.0452,
+      "suggested_scalar": 0.0139,
+      "log_bad": 5.8051,
+      "log_good": 5.8493
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 20.0,
+      "good": 24.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0572,
+      "log_bad": 2.9957,
+      "log_good": 3.1781
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 0.0057,
+      "ratio": 0.0057,
+      "suggested_scalar": -1.6206,
+      "log_bad": 0.0,
+      "log_good": -5.1673
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 5.858,
+      "ratio": 0.9877,
+      "suggested_scalar": -0.0039,
+      "log_bad": 1.7801,
+      "log_good": 1.7678
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 31.0,
+      "good": 36.0,
+      "ratio": 1.1613,
+      "suggested_scalar": 0.0469,
+      "log_bad": 3.434,
+      "log_good": 3.5835
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4863,
+      "good": 1.4765,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0021,
+      "log_bad": 0.3963,
+      "log_good": 0.3897
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6684,
+      "good": 5.4767,
+      "ratio": 0.9662,
+      "suggested_scalar": -0.0108,
+      "log_bad": 1.7349,
+      "log_good": 1.7005
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7845,
+      "good": 0.779,
+      "ratio": 0.993,
+      "suggested_scalar": -0.0022,
+      "log_bad": -0.2427,
+      "log_good": -0.2497
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2,
+      "good": 0.1746,
+      "ratio": 0.873,
+      "suggested_scalar": -0.0426,
+      "log_bad": -1.6094,
+      "log_good": -1.7453
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.7291,
+      "good": 4.2253,
+      "ratio": 1.1331,
+      "suggested_scalar": 0.0392,
+      "log_bad": 1.3162,
+      "log_good": 1.4411
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 276.0,
+      "good": 298.0,
+      "ratio": 1.0797,
+      "suggested_scalar": 0.0241,
+      "log_bad": 5.6204,
+      "log_good": 5.6971
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 10.0,
+      "good": 18.0,
+      "ratio": 1.8,
+      "suggested_scalar": 0.1843,
+      "log_bad": 2.3026,
+      "log_good": 2.8904
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7123,
+      "good": 0.7646,
+      "ratio": 1.0734,
+      "suggested_scalar": 0.0222,
+      "log_bad": -0.3393,
+      "log_good": -0.2684
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 88.0,
+      "good": 98.0,
+      "ratio": 1.1136,
+      "suggested_scalar": 0.0338,
+      "log_bad": 4.4773,
+      "log_good": 4.585
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 951.0,
+      "good": 1162.0,
+      "ratio": 1.2219,
+      "suggested_scalar": 0.0628,
+      "log_bad": 6.8575,
+      "log_good": 7.0579
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 152.0,
+      "good": 151.0,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0021,
+      "log_bad": 5.0239,
+      "log_good": 5.0173
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.003,
+      "good": 0.0057,
+      "ratio": 1.9,
+      "suggested_scalar": 0.2013,
+      "log_bad": -5.8091,
+      "log_good": -5.1673
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2455,
+      "good": 0.298,
+      "ratio": 1.2138,
+      "suggested_scalar": 0.0608,
+      "log_bad": -1.4045,
+      "log_good": -1.2107
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 57.0,
+      "good": 55.0,
+      "ratio": 0.9649,
+      "suggested_scalar": -0.0112,
+      "log_bad": 4.0431,
+      "log_good": 4.0073
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 3.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2174,
+      "log_bad": 1.7918,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 88.0,
+      "good": 98.0,
+      "ratio": 1.1136,
+      "suggested_scalar": 0.0338,
+      "log_bad": 4.4773,
+      "log_good": 4.585
+    },
+    "brevity.mean_sample_size": {
+      "bad": 88.0,
+      "good": 98.0,
+      "ratio": 1.1136,
+      "suggested_scalar": 0.0338,
+      "log_bad": 4.4773,
+      "log_good": 4.585
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 334.0,
+      "good": 349.0,
+      "ratio": 1.0449,
+      "suggested_scalar": 0.0138,
+      "log_bad": 5.8111,
+      "log_good": 5.8551
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 160.0,
+      "good": 186.0,
+      "ratio": 1.1625,
+      "suggested_scalar": 0.0472,
+      "log_bad": 5.0752,
+      "log_good": 5.2257
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 217.0,
+      "good": 237.0,
+      "ratio": 1.0922,
+      "suggested_scalar": 0.0276,
+      "log_bad": 5.3799,
+      "log_good": 5.4681
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.003,
+      "good": 0.0029,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0106,
+      "log_bad": -5.8091,
+      "log_good": -5.843
+    },
+    "heaps.mean_k": {
+      "bad": 1.8128,
+      "good": 1.7025,
+      "ratio": 0.9392,
+      "suggested_scalar": -0.0197,
+      "log_bad": 0.5949,
+      "log_good": 0.5321
+    },
+    "halstead.mean_effort": {
+      "bad": 53329.1146,
+      "good": 52409.3383,
+      "ratio": 0.9828,
+      "suggested_scalar": -0.0055,
+      "log_bad": 10.8842,
+      "log_good": 10.8668
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8775,
+      "good": 0.828,
+      "ratio": 0.9436,
+      "suggested_scalar": -0.0182,
+      "log_bad": -0.1307,
+      "log_good": -0.1887
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 67.0,
+      "good": 76.0,
+      "ratio": 1.1343,
+      "suggested_scalar": 0.0395,
+      "log_bad": 4.2047,
+      "log_good": 4.3307
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 178.0,
+      "good": 195.0,
+      "ratio": 1.0955,
+      "suggested_scalar": 0.0286,
+      "log_bad": 5.1818,
+      "log_good": 5.273
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4876,
+      "good": 0.5185,
+      "ratio": 1.0634,
+      "suggested_scalar": 0.0193,
+      "log_bad": -0.7183,
+      "log_good": -0.6568
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.8595,
+      "good": 8.6074,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.0285,
+      "log_bad": 2.0617,
+      "log_good": 2.1526
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2,
+      "good": 0.1746,
+      "ratio": 0.873,
+      "suggested_scalar": -0.0426,
+      "log_bad": -1.6094,
+      "log_good": -1.7453
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.6549,
+      "good": 5.1538,
+      "ratio": 1.1072,
+      "suggested_scalar": 0.0319,
+      "log_bad": 1.5379,
+      "log_good": 1.6397
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 333.0,
+      "good": 348.0,
+      "ratio": 1.045,
+      "suggested_scalar": 0.0138,
+      "log_bad": 5.8081,
+      "log_good": 5.8522
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 37.0,
+      "good": 34.0,
+      "ratio": 0.9189,
+      "suggested_scalar": -0.0265,
+      "log_bad": 3.6109,
+      "log_good": 3.5264
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2962.7286,
+      "good": 2911.6299,
+      "ratio": 0.9828,
+      "suggested_scalar": -0.0055,
+      "log_bad": 7.9939,
+      "log_good": 7.9765
+    },
+    "readability.mean_total_lines": {
+      "bad": 44.0,
+      "good": 52.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0524,
+      "log_bad": 3.7842,
+      "log_good": 3.9512
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2136.992,
+      "good": 2293.7574,
+      "ratio": 1.0734,
+      "suggested_scalar": 0.0222,
+      "log_bad": 7.6672,
+      "log_good": 7.7379
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 629.0,
+      "good": 718.0,
+      "ratio": 1.1415,
+      "suggested_scalar": 0.0415,
+      "log_bad": 6.4441,
+      "log_good": 6.5765
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 38.5227,
+      "good": 36.6731,
+      "ratio": 0.952,
+      "suggested_scalar": -0.0154,
+      "log_bad": 3.6512,
+      "log_good": 3.602
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3121,
+      "good": 1.4012,
+      "ratio": 1.0679,
+      "suggested_scalar": 0.0206,
+      "log_bad": 0.2716,
+      "log_good": 0.3373
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 28.0,
+      "good": 43.0,
+      "ratio": 1.5357,
+      "suggested_scalar": 0.1345,
+      "log_bad": 3.3322,
+      "log_good": 3.7612
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0902,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8659,
+      "good": 0.8859,
+      "ratio": 1.0231,
+      "suggested_scalar": 0.0072,
+      "log_bad": -0.144,
+      "log_good": -0.1212
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.964,
+      "good": 0.9703,
+      "ratio": 1.0065,
+      "suggested_scalar": 0.002,
+      "log_bad": -0.0367,
+      "log_good": -0.0301
+    },
+    "halstead.mean_length": {
+      "bad": 330.0,
+      "good": 346.0,
+      "ratio": 1.0485,
+      "suggested_scalar": 0.0148,
+      "log_bad": 5.7991,
+      "log_good": 5.8464
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.1667,
+      "good": 12.3333,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2174,
+      "log_bad": 1.8192,
+      "log_good": 2.5123
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4594,
+      "good": 6.6147,
+      "ratio": 1.024,
+      "suggested_scalar": 0.0075,
+      "log_bad": 1.8655,
+      "log_good": 1.8893
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0914,
+      "good": 0.0944,
+      "ratio": 1.0328,
+      "suggested_scalar": 0.0101,
+      "log_bad": -2.3925,
+      "log_good": -2.3602
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 24.9552,
+      "good": 22.8487,
+      "ratio": 0.9156,
+      "suggested_scalar": -0.0277,
+      "log_bad": 3.2171,
+      "log_good": 3.1289
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 59.0,
+      "good": 70.0,
+      "ratio": 1.1864,
+      "suggested_scalar": 0.0536,
+      "log_bad": 4.0775,
+      "log_good": 4.2485
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7373,
+      "good": 0.7679,
+      "ratio": 1.0415,
+      "suggested_scalar": 0.0128,
+      "log_bad": -0.3048,
+      "log_good": -0.2641
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 44.0,
+      "good": 52.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0524,
+      "log_bad": 3.7842,
+      "log_good": 3.9512
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 23.0,
+      "ratio": 1.3529,
+      "suggested_scalar": 0.0948,
+      "log_bad": 2.8332,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.no_underscore_visibility_prefix": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_side_effects_in_declaration_file": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.no_boolean_parameter": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 17.0,
+      "good": 24.0,
+      "ratio": 1.4118,
+      "suggested_scalar": 0.2775,
+      "log_bad": 2.8332,
+      "log_good": 3.1781
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0424,
+      "good": 0.0435,
+      "ratio": 1.0259,
+      "suggested_scalar": 0.0206,
+      "log_bad": -3.1606,
+      "log_good": -3.135
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 3.0,
+      "good": 2.0833,
+      "ratio": 0.6944,
+      "suggested_scalar": -0.2935,
+      "log_bad": 1.0986,
+      "log_good": 0.734
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7674,
+      "good": 0.7073,
+      "ratio": 0.9217,
+      "suggested_scalar": -0.0656,
+      "log_bad": -0.2647,
+      "log_good": -0.3463
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0424,
+      "good": 0.0435,
+      "ratio": 1.0259,
+      "suggested_scalar": 0.0206,
+      "log_bad": -3.1606,
+      "log_good": -3.135
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6014,
+      "good": 4.6894,
+      "ratio": 1.0191,
+      "suggested_scalar": 0.0152,
+      "log_bad": 1.5264,
+      "log_good": 1.5453
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 66.0,
+      "good": 63.0,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.0374,
+      "log_bad": 4.1897,
+      "log_good": 4.1431
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5212,
+      "good": 0.4831,
+      "ratio": 0.9269,
+      "suggested_scalar": -0.0611,
+      "log_bad": -0.6516,
+      "log_good": -0.7275
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6377,
+      "good": 0.6133,
+      "ratio": 0.9617,
+      "suggested_scalar": -0.0314,
+      "log_bad": -0.4499,
+      "log_good": -0.4889
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.7674,
+      "good": 2.6341,
+      "ratio": 0.6992,
+      "suggested_scalar": -0.288,
+      "log_bad": 1.3264,
+      "log_good": 0.9685
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 401.0,
+      "good": 437.0,
+      "ratio": 1.0898,
+      "suggested_scalar": 0.0692,
+      "log_bad": 5.994,
+      "log_good": 6.0799
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.3263,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0019,
+      "good": 0.0018,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.0435,
+      "log_bad": -6.2659,
+      "log_good": -6.32
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0399,
+      "good": 1.0894,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.0374,
+      "log_bad": 0.0391,
+      "log_good": 0.0856
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 151.0,
+      "good": 167.0,
+      "ratio": 1.106,
+      "suggested_scalar": 0.0811,
+      "log_bad": 5.0173,
+      "log_good": 5.118
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 103.9745,
+      "good": 100.7428,
+      "ratio": 0.9689,
+      "suggested_scalar": -0.0254,
+      "log_bad": 4.6441,
+      "log_good": 4.6126
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.645,
+      "good": 0.7775,
+      "ratio": 1.2054,
+      "suggested_scalar": 0.1504,
+      "log_bad": -0.4385,
+      "log_good": -0.2517
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.5775,
+      "good": 20.679,
+      "ratio": 1.523,
+      "suggested_scalar": 0.3386,
+      "log_bad": 2.6084,
+      "log_good": 3.0291
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1585.0,
+      "good": 1673.0,
+      "ratio": 1.0555,
+      "suggested_scalar": 0.0435,
+      "log_bad": 7.3683,
+      "log_good": 7.4224
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2791,
+      "good": 1.0,
+      "ratio": 3.5829,
+      "suggested_scalar": 1.0271,
+      "log_bad": -1.2762,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6744,
+      "good": 0.6829,
+      "ratio": 1.0126,
+      "suggested_scalar": 0.0101,
+      "log_bad": -0.3939,
+      "log_good": -0.3814
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.3256,
+      "good": 10.6585,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.1075,
+      "log_bad": 2.2328,
+      "log_good": 2.3664
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.5738,
+      "good": 1.2564,
+      "ratio": 0.3516,
+      "suggested_scalar": -0.8414,
+      "log_bad": 1.2736,
+      "log_good": 0.2283
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 131.0,
+      "good": 144.0,
+      "ratio": 1.0992,
+      "suggested_scalar": 0.0762,
+      "log_bad": 4.8752,
+      "log_good": 4.9698
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9425,
+      "good": 0.9418,
+      "ratio": 0.9993,
+      "suggested_scalar": -0.0006,
+      "log_bad": -0.0592,
+      "log_good": -0.06
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 19.0,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.0806,
+      "log_bad": 3.0445,
+      "log_good": 2.9444
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6252,
+      "good": 0.6886,
+      "ratio": 1.1014,
+      "suggested_scalar": 0.0777,
+      "log_bad": -0.4697,
+      "log_good": -0.3731
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4461,
+      "good": 0.6598,
+      "ratio": 1.479,
+      "suggested_scalar": 0.315,
+      "log_bad": -0.8072,
+      "log_good": -0.4158
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6684,
+      "good": 3.2111,
+      "ratio": 1.2034,
+      "suggested_scalar": 0.149,
+      "log_bad": 0.9815,
+      "log_good": 1.1666
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 399.0,
+      "good": 435.0,
+      "ratio": 1.0902,
+      "suggested_scalar": 0.0695,
+      "log_bad": 5.989,
+      "log_good": 6.0753
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 10.0,
+      "good": 5.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.5579,
+      "log_bad": 2.3026,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0324,
+      "good": 0.0229,
+      "ratio": 0.7068,
+      "suggested_scalar": -0.2793,
+      "log_bad": -3.4296,
+      "log_good": -3.7766
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8074,
+      "good": 5.8074,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7591,
+      "log_good": 1.7591
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 19.0,
+      "good": 22.0,
+      "ratio": 1.1579,
+      "suggested_scalar": 0.118,
+      "log_bad": 2.9444,
+      "log_good": 3.091
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6021,
+      "good": 0.6138,
+      "ratio": 1.0194,
+      "suggested_scalar": 0.0155,
+      "log_bad": -0.5073,
+      "log_good": -0.4881
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5396,
+      "good": 5.4513,
+      "ratio": 0.9841,
+      "suggested_scalar": -0.0129,
+      "log_bad": 1.7119,
+      "log_good": 1.6959
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7923,
+      "good": 0.8075,
+      "ratio": 1.0192,
+      "suggested_scalar": 0.0153,
+      "log_bad": -0.2328,
+      "log_good": -0.2138
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1224,
+      "good": 0.2115,
+      "ratio": 1.7279,
+      "suggested_scalar": 0.4402,
+      "log_bad": -2.1005,
+      "log_good": -1.5535
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6848,
+      "good": 4.5474,
+      "ratio": 1.2341,
+      "suggested_scalar": 0.1693,
+      "log_bad": 1.3042,
+      "log_good": 1.5146
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 286.0,
+      "good": 252.0,
+      "ratio": 0.8811,
+      "suggested_scalar": -0.1019,
+      "log_bad": 5.656,
+      "log_good": 5.5294
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 7.0,
+      "good": 8.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.1075,
+      "log_bad": 1.9459,
+      "log_good": 2.0794
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6065,
+      "good": 0.6416,
+      "ratio": 1.0579,
+      "suggested_scalar": 0.0453,
+      "log_bad": -0.5001,
+      "log_good": -0.4438
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 97.0,
+      "good": 94.0,
+      "ratio": 0.9691,
+      "suggested_scalar": -0.0253,
+      "log_bad": 4.5747,
+      "log_good": 4.5433
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 895.0,
+      "good": 1012.0,
+      "ratio": 1.1307,
+      "suggested_scalar": 0.0989,
+      "log_bad": 6.7968,
+      "log_good": 6.9197
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 101.0,
+      "good": 112.0,
+      "ratio": 1.1089,
+      "suggested_scalar": 0.0832,
+      "log_bad": 4.6151,
+      "log_good": 4.7185
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2868,
+      "good": 0.2998,
+      "ratio": 1.0453,
+      "suggested_scalar": 0.0357,
+      "log_bad": -1.249,
+      "log_good": -1.2046
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 80.0,
+      "good": 96.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.1467,
+      "log_bad": 4.382,
+      "log_good": 4.5643
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 12.0,
+      "ratio": 1.7143,
+      "suggested_scalar": 0.4338,
+      "log_bad": 1.9459,
+      "log_good": 2.4849
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 97.0,
+      "good": 94.0,
+      "ratio": 0.9691,
+      "suggested_scalar": -0.0253,
+      "log_bad": 4.5747,
+      "log_good": 4.5433
+    },
+    "brevity.mean_sample_size": {
+      "bad": 97.0,
+      "good": 94.0,
+      "ratio": 0.9691,
+      "suggested_scalar": -0.0253,
+      "log_bad": 4.5747,
+      "log_good": 4.5433
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 401.0,
+      "good": 437.0,
+      "ratio": 1.0898,
+      "suggested_scalar": 0.0692,
+      "log_bad": 5.994,
+      "log_good": 6.0799
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 199.0,
+      "good": 223.0,
+      "ratio": 1.1206,
+      "suggested_scalar": 0.0916,
+      "log_bad": 5.2933,
+      "log_good": 5.4072
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 222.0,
+      "good": 193.0,
+      "ratio": 0.8694,
+      "suggested_scalar": -0.1127,
+      "log_bad": 5.4027,
+      "log_good": 5.2627
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.1901,
+      "good": 2.3655,
+      "ratio": 1.0801,
+      "suggested_scalar": 0.062,
+      "log_bad": 0.7839,
+      "log_good": 0.861
+    },
+    "halstead.mean_effort": {
+      "bad": 42876.3126,
+      "good": 46542.3618,
+      "ratio": 1.0855,
+      "suggested_scalar": 0.066,
+      "log_bad": 10.6661,
+      "log_good": 10.7481
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8393,
+      "good": 0.8317,
+      "ratio": 0.9909,
+      "suggested_scalar": -0.0073,
+      "log_bad": -0.1752,
+      "log_good": -0.1843
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 45.0,
+      "good": 44.0,
+      "ratio": 0.9778,
+      "suggested_scalar": -0.0181,
+      "log_bad": 3.8067,
+      "log_good": 3.7842
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 200.0,
+      "good": 210.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0393,
+      "log_bad": 5.2983,
+      "log_good": 5.3471
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4702,
+      "good": 0.4192,
+      "ratio": 0.8915,
+      "suggested_scalar": -0.0924,
+      "log_bad": -0.7546,
+      "log_good": -0.8694
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.9272,
+      "good": 6.0599,
+      "ratio": 1.0224,
+      "suggested_scalar": 0.0178,
+      "log_bad": 1.7796,
+      "log_good": 1.8017
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1224,
+      "good": 0.2115,
+      "ratio": 1.7279,
+      "suggested_scalar": 0.4402,
+      "log_bad": -2.1005,
+      "log_good": -1.5535
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.5223,
+      "good": 6.5064,
+      "ratio": 1.4387,
+      "suggested_scalar": 0.2928,
+      "log_bad": 1.509,
+      "log_good": 1.8728
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 400.0,
+      "good": 436.0,
+      "ratio": 1.09,
+      "suggested_scalar": 0.0694,
+      "log_bad": 5.9915,
+      "log_good": 6.0776
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 13.0,
+      "good": 15.0,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.1152,
+      "log_bad": 2.5649,
+      "log_good": 2.7081
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 65.0,
+      "good": 104.0,
+      "ratio": 1.6,
+      "suggested_scalar": 0.3783,
+      "log_bad": 4.1744,
+      "log_good": 4.6444
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2382.0174,
+      "good": 2585.6868,
+      "ratio": 1.0855,
+      "suggested_scalar": 0.066,
+      "log_bad": 7.7757,
+      "log_good": 7.8577
+    },
+    "readability.mean_total_lines": {
+      "bad": 43.0,
+      "good": 41.0,
+      "ratio": 0.9535,
+      "suggested_scalar": -0.0383,
+      "log_bad": 3.7612,
+      "log_good": 3.7136
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 4.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.5579,
+      "log_bad": 2.0794,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1819.3626,
+      "good": 1924.6841,
+      "ratio": 1.0579,
+      "suggested_scalar": 0.0453,
+      "log_bad": 7.5062,
+      "log_good": 7.5625
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 594.0,
+      "good": 521.0,
+      "ratio": 0.8771,
+      "suggested_scalar": -0.1055,
+      "log_bad": 6.3869,
+      "log_good": 6.2558
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.7209,
+      "good": 39.5366,
+      "ratio": 1.1068,
+      "suggested_scalar": 0.0817,
+      "log_bad": 3.5757,
+      "log_good": 3.6772
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.104,
+      "good": 1.1262,
+      "ratio": 1.0201,
+      "suggested_scalar": 0.016,
+      "log_bad": 0.0989,
+      "log_good": 0.1188
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.3263,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 19.0,
+      "good": 23.0,
+      "ratio": 1.2105,
+      "suggested_scalar": 0.1538,
+      "log_bad": 2.9444,
+      "log_good": 3.1355
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7727,
+      "good": 0.5873,
+      "ratio": 0.7601,
+      "suggested_scalar": -0.2208,
+      "log_bad": -0.2579,
+      "log_good": -0.5322
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9942,
+      "good": 0.9938,
+      "ratio": 0.9996,
+      "suggested_scalar": -0.0003,
+      "log_bad": -0.0058,
+      "log_good": -0.0062
+    },
+    "halstead.mean_length": {
+      "bad": 301.0,
+      "good": 322.0,
+      "ratio": 1.0698,
+      "suggested_scalar": 0.0543,
+      "log_bad": 5.7071,
+      "log_good": 5.7746
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.8571,
+      "good": 4.25,
+      "ratio": 0.6198,
+      "suggested_scalar": -0.385,
+      "log_bad": 1.9253,
+      "log_good": 1.4469
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5999,
+      "good": 6.5546,
+      "ratio": 0.9931,
+      "suggested_scalar": -0.0055,
+      "log_bad": 1.8871,
+      "log_good": 1.8802
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1256,
+      "good": 0.1333,
+      "ratio": 1.0613,
+      "suggested_scalar": 0.0479,
+      "log_bad": -2.0747,
+      "log_good": -2.0152
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 23.5667,
+      "good": 24.1818,
+      "ratio": 1.0261,
+      "suggested_scalar": 0.0207,
+      "log_bad": 3.1598,
+      "log_good": 3.1856
+    },
+    "branching.mean_branch_count": {
+      "bad": 12.0,
+      "good": 1.0,
+      "ratio": 0.0833,
+      "suggested_scalar": -2.0,
+      "log_bad": 2.4849,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 71.0,
+      "good": 70.0,
+      "ratio": 0.9859,
+      "suggested_scalar": -0.0114,
+      "log_bad": 4.2627,
+      "log_good": 4.2485
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6396,
+      "good": 0.5026,
+      "ratio": 0.7858,
+      "suggested_scalar": -0.194,
+      "log_bad": -0.4469,
+      "log_good": -0.688
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 43.0,
+      "good": 41.0,
+      "ratio": 0.9535,
+      "suggested_scalar": -0.0383,
+      "log_bad": 3.7612,
+      "log_good": 3.7136
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.uses_structured_concurrency": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 28.0,
+      "good": 29.0,
+      "ratio": 1.0357,
+      "suggested_scalar": 0.1968,
+      "log_bad": 3.3322,
+      "log_good": 3.3673
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9,
+      "good": 0.9024,
+      "ratio": 1.0027,
+      "suggested_scalar": 0.0149,
+      "log_bad": -0.1054,
+      "log_good": -0.1027
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5692,
+      "good": 4.4857,
+      "ratio": 0.9817,
+      "suggested_scalar": -0.1034,
+      "log_bad": 1.5193,
+      "log_good": 1.5009
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 107.0,
+      "good": 96.0,
+      "ratio": 0.8972,
+      "suggested_scalar": -0.6083,
+      "log_bad": 4.6728,
+      "log_good": 4.5643
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6825,
+      "good": 0.6677,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.1229,
+      "log_bad": -0.382,
+      "log_good": -0.4039
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 12.0,
+      "good": 13.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.4488,
+      "log_bad": 2.4849,
+      "log_good": 2.5649
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7686,
+      "good": 0.7521,
+      "ratio": 0.9785,
+      "suggested_scalar": -0.1217,
+      "log_bad": -0.2632,
+      "log_good": -0.2849
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.5,
+      "good": 5.5122,
+      "ratio": 1.0022,
+      "suggested_scalar": 0.0124,
+      "log_bad": 1.7047,
+      "log_good": 1.707
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 291.0,
+      "good": 280.0,
+      "ratio": 0.9622,
+      "suggested_scalar": -0.2161,
+      "log_bad": 5.6733,
+      "log_good": 5.6348
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.275,
+      "good": 0.2439,
+      "ratio": 0.8869,
+      "suggested_scalar": -0.673,
+      "log_bad": -1.291,
+      "log_good": -1.411
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8283,
+      "good": 0.8583,
+      "ratio": 1.0362,
+      "suggested_scalar": 0.1995,
+      "log_bad": -0.1884,
+      "log_good": -0.1528
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 111.0,
+      "good": 112.0,
+      "ratio": 1.009,
+      "suggested_scalar": 0.0503,
+      "log_bad": 4.7095,
+      "log_good": 4.7185
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 90.6025,
+      "good": 91.4563,
+      "ratio": 1.0094,
+      "suggested_scalar": 0.0526,
+      "log_bad": 4.5065,
+      "log_good": 4.5159
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.431,
+      "good": 0.4086,
+      "ratio": 0.948,
+      "suggested_scalar": -0.2993,
+      "log_bad": -0.8416,
+      "log_good": -0.895
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 17.1592,
+      "good": 17.558,
+      "ratio": 1.0232,
+      "suggested_scalar": 0.1288,
+      "log_bad": 2.8425,
+      "log_good": 2.8655
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1595.0,
+      "good": 1577.0,
+      "ratio": 0.9887,
+      "suggested_scalar": -0.0636,
+      "log_bad": 7.3746,
+      "log_good": 7.3633
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.025,
+      "good": 0.0244,
+      "ratio": 0.976,
+      "suggested_scalar": -0.1362,
+      "log_bad": -3.6889,
+      "log_good": -3.7132
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.85,
+      "good": 0.8537,
+      "ratio": 1.0044,
+      "suggested_scalar": 0.0244,
+      "log_bad": -0.1625,
+      "log_good": -0.1582
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.275,
+      "good": 6.8293,
+      "ratio": 0.9387,
+      "suggested_scalar": -0.3545,
+      "log_bad": 1.9844,
+      "log_good": 1.9212
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 11.15,
+      "good": 11.1279,
+      "ratio": 0.998,
+      "suggested_scalar": -0.0111,
+      "log_bad": 2.4114,
+      "log_good": 2.4095
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 53.0,
+      "good": 62.0,
+      "ratio": 1.1698,
+      "suggested_scalar": 0.8795,
+      "log_bad": 3.9703,
+      "log_good": 4.1271
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9275,
+      "good": 0.9378,
+      "ratio": 1.0111,
+      "suggested_scalar": 0.0619,
+      "log_bad": -0.0753,
+      "log_good": -0.0642
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 21.0,
+      "ratio": 0.75,
+      "suggested_scalar": -1.6131,
+      "log_bad": 3.3322,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6,
+      "good": 0.5973,
+      "ratio": 0.9955,
+      "suggested_scalar": -0.0253,
+      "log_bad": -0.5108,
+      "log_good": -0.5153
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2872,
+      "good": 0.2518,
+      "ratio": 0.8767,
+      "suggested_scalar": -0.7376,
+      "log_bad": -1.2476,
+      "log_good": -1.3791
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5,
+      "good": 2.4835,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0371,
+      "log_bad": 0.9163,
+      "log_good": 0.9097
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 289.0,
+      "good": 278.0,
+      "ratio": 0.9619,
+      "suggested_scalar": -0.2176,
+      "log_bad": 5.6664,
+      "log_good": 5.6276
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 28.0,
+      "good": 27.0,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.2039,
+      "log_bad": 3.3322,
+      "log_good": 3.2958
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0103,
+      "good": 0.0107,
+      "ratio": 1.0388,
+      "suggested_scalar": 0.2136,
+      "log_bad": -4.5756,
+      "log_good": -4.5375
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.8074,
+      "ratio": 0.9956,
+      "suggested_scalar": -0.0246,
+      "log_bad": 1.7635,
+      "log_good": 1.7591
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 30.0,
+      "good": 21.0,
+      "ratio": 0.7,
+      "suggested_scalar": -2.0,
+      "log_bad": 3.4012,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.5206,
+      "good": 1.4299,
+      "ratio": 0.9404,
+      "suggested_scalar": -0.3449,
+      "log_bad": 0.4191,
+      "log_good": 0.3576
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9048,
+      "good": 5.7956,
+      "ratio": 0.9815,
+      "suggested_scalar": -0.1047,
+      "log_bad": 1.7758,
+      "log_good": 1.7571
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7833,
+      "good": 0.7724,
+      "ratio": 0.9861,
+      "suggested_scalar": -0.0786,
+      "log_bad": -0.2442,
+      "log_good": -0.2583
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1489,
+      "good": 0.1633,
+      "ratio": 1.0967,
+      "suggested_scalar": 0.5176,
+      "log_bad": -1.9045,
+      "log_good": -1.8122
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.1424,
+      "good": 4.1902,
+      "ratio": 1.0115,
+      "suggested_scalar": 0.0643,
+      "log_bad": 1.4213,
+      "log_good": 1.4327
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 236.0,
+      "good": 237.0,
+      "ratio": 1.0042,
+      "suggested_scalar": 0.0237,
+      "log_bad": 5.4638,
+      "log_good": 5.4681
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 7.0,
+      "good": 8.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.7488,
+      "log_bad": 1.9459,
+      "log_good": 2.0794
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6449,
+      "good": 0.6058,
+      "ratio": 0.9394,
+      "suggested_scalar": -0.3507,
+      "log_bad": -0.4387,
+      "log_good": -0.5012
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 110.0,
+      "good": 100.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.5344,
+      "log_bad": 4.7005,
+      "log_good": 4.6052
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 851.0,
+      "good": 853.0,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.0132,
+      "log_bad": 6.7464,
+      "log_good": 6.7488
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 124.0,
+      "good": 127.0,
+      "ratio": 1.0242,
+      "suggested_scalar": 0.134,
+      "log_bad": 4.8203,
+      "log_good": 4.8442
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2027,
+      "good": 0.1786,
+      "ratio": 0.8811,
+      "suggested_scalar": -0.7098,
+      "log_bad": -1.596,
+      "log_good": -1.7226
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 36.0,
+      "good": 34.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.3205,
+      "log_bad": 3.5835,
+      "log_good": 3.5264
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 110.0,
+      "good": 100.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.5344,
+      "log_bad": 4.7005,
+      "log_good": 4.6052
+    },
+    "brevity.mean_sample_size": {
+      "bad": 110.0,
+      "good": 100.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.5344,
+      "log_bad": 4.7005,
+      "log_good": 4.6052
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 291.0,
+      "good": 280.0,
+      "ratio": 0.9622,
+      "suggested_scalar": -0.2161,
+      "log_bad": 5.6733,
+      "log_good": 5.6348
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 132.0,
+      "good": 129.0,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.1289,
+      "log_bad": 4.8828,
+      "log_good": 4.8598
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 201.0,
+      "good": 199.0,
+      "ratio": 0.99,
+      "suggested_scalar": -0.0561,
+      "log_bad": 5.3033,
+      "log_good": 5.2933
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.6615,
+      "good": 1.6735,
+      "ratio": 1.0072,
+      "suggested_scalar": 0.0404,
+      "log_bad": 0.5077,
+      "log_good": 0.5149
+    },
+    "halstead.mean_effort": {
+      "bad": 42516.6402,
+      "good": 32314.2548,
+      "ratio": 0.76,
+      "suggested_scalar": -1.5386,
+      "log_bad": 10.6577,
+      "log_good": 10.3833
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8707,
+      "good": 0.8723,
+      "ratio": 1.0018,
+      "suggested_scalar": 0.0103,
+      "log_bad": -0.1385,
+      "log_good": -0.1366
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 79.0,
+      "good": 75.0,
+      "ratio": 0.9494,
+      "suggested_scalar": -0.2914,
+      "log_bad": 4.3694,
+      "log_good": 4.3175
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 163.0,
+      "good": 149.0,
+      "ratio": 0.9141,
+      "suggested_scalar": -0.5036,
+      "log_bad": 5.0938,
+      "log_good": 5.0039
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.6847,
+      "good": 0.6429,
+      "ratio": 0.939,
+      "suggested_scalar": -0.3532,
+      "log_bad": -0.3788,
+      "log_good": -0.4418
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.6667,
+      "good": 7.6161,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0371,
+      "log_bad": 2.0369,
+      "log_good": 2.0303
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1489,
+      "good": 0.1633,
+      "ratio": 1.0967,
+      "suggested_scalar": 0.5176,
+      "log_bad": -1.9045,
+      "log_good": -1.8122
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.9291,
+      "good": 3.8055,
+      "ratio": 0.9685,
+      "suggested_scalar": -0.1792,
+      "log_bad": 1.3684,
+      "log_good": 1.3364
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 290.0,
+      "good": 279.0,
+      "ratio": 0.9621,
+      "suggested_scalar": -0.2168,
+      "log_bad": 5.6699,
+      "log_good": 5.6312
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 30.0,
+      "good": 29.0,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.1901,
+      "log_bad": 3.4012,
+      "log_good": 3.3673
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2362.0356,
+      "good": 1795.2364,
+      "ratio": 0.76,
+      "suggested_scalar": -1.5386,
+      "log_bad": 7.7673,
+      "log_good": 7.4929
+    },
+    "readability.mean_total_lines": {
+      "bad": 40.0,
+      "good": 41.0,
+      "ratio": 1.025,
+      "suggested_scalar": 0.1385,
+      "log_bad": 3.6889,
+      "log_good": 3.7136
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 1934.801,
+      "good": 1817.4497,
+      "ratio": 0.9393,
+      "suggested_scalar": -0.3509,
+      "log_bad": 7.5678,
+      "log_good": 7.5052
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 638.0,
+      "good": 635.0,
+      "ratio": 0.9953,
+      "suggested_scalar": -0.0264,
+      "log_bad": 6.4583,
+      "log_good": 6.4536
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 38.6,
+      "good": 37.2195,
+      "ratio": 0.9642,
+      "suggested_scalar": -0.2042,
+      "log_bad": 3.6533,
+      "log_good": 3.6168
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2866,
+      "good": 1.2819,
+      "ratio": 0.9963,
+      "suggested_scalar": -0.0205,
+      "log_bad": 0.252,
+      "log_good": 0.2483
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 22.0,
+      "good": 18.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -1.1252,
+      "log_bad": 3.091,
+      "log_good": 2.8904
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 11.0,
+      "good": 10.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.5344,
+      "log_bad": 2.3979,
+      "log_good": 2.3026
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8729,
+      "good": 0.8776,
+      "ratio": 1.0054,
+      "suggested_scalar": 0.0301,
+      "log_bad": -0.1359,
+      "log_good": -0.1306
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9691,
+      "good": 0.9824,
+      "ratio": 1.0137,
+      "suggested_scalar": 0.0764,
+      "log_bad": -0.0314,
+      "log_good": -0.0178
+    },
+    "halstead.mean_length": {
+      "bad": 287.0,
+      "good": 276.0,
+      "ratio": 0.9617,
+      "suggested_scalar": -0.2191,
+      "log_bad": 5.6595,
+      "log_good": 5.6204
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7814,
+      "good": 6.6439,
+      "ratio": 0.9797,
+      "suggested_scalar": -0.1149,
+      "log_bad": 1.9142,
+      "log_good": 1.8937
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.083,
+      "good": 0.0819,
+      "ratio": 0.9867,
+      "suggested_scalar": -0.0748,
+      "log_bad": -2.4889,
+      "log_good": -2.5023
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 21.9747,
+      "good": 17.78,
+      "ratio": 0.8091,
+      "suggested_scalar": -1.1877,
+      "log_bad": 3.0899,
+      "log_good": 2.8781
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 76.0,
+      "good": 72.0,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.3032,
+      "log_bad": 4.3307,
+      "log_good": 4.2767
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8209,
+      "good": 0.8291,
+      "ratio": 1.01,
+      "suggested_scalar": 0.0557,
+      "log_bad": -0.1974,
+      "log_good": -0.1874
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 40.0,
+      "good": 41.0,
+      "ratio": 1.025,
+      "suggested_scalar": 0.1385,
+      "log_bad": 3.6889,
+      "log_good": 3.7136
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.does_not_use_unwrap_in_production": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 4.0,
+      "good": 7.0,
+      "ratio": 1.75,
+      "suggested_scalar": 0.1472,
+      "log_bad": 1.3863,
+      "log_good": 1.9459
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0203,
+      "good": 0.0214,
+      "ratio": 1.0542,
+      "suggested_scalar": 0.0139,
+      "log_bad": -3.8971,
+      "log_good": -3.8444
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8537,
+      "good": 0.8246,
+      "ratio": 0.9659,
+      "suggested_scalar": -0.0091,
+      "log_bad": -0.1582,
+      "log_good": -0.1929
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0203,
+      "good": 0.0214,
+      "ratio": 1.0542,
+      "suggested_scalar": 0.0139,
+      "log_bad": -3.8971,
+      "log_good": -3.8444
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6478,
+      "good": 4.6956,
+      "ratio": 1.0103,
+      "suggested_scalar": 0.0027,
+      "log_bad": 1.5364,
+      "log_good": 1.5466
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 106.0,
+      "good": 99.0,
+      "ratio": 0.934,
+      "suggested_scalar": -0.018,
+      "log_bad": 4.6634,
+      "log_good": 4.5951
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6006,
+      "good": 0.5014,
+      "ratio": 0.8348,
+      "suggested_scalar": -0.0475,
+      "log_bad": -0.5098,
+      "log_good": -0.6904
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 22.0,
+      "ratio": 1.2941,
+      "suggested_scalar": 0.0678,
+      "log_bad": 2.8332,
+      "log_good": 3.091
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7629,
+      "good": 0.6037,
+      "ratio": 0.7913,
+      "suggested_scalar": -0.0616,
+      "log_bad": -0.2706,
+      "log_good": -0.5047
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.4634,
+      "good": 6.1754,
+      "ratio": 1.1303,
+      "suggested_scalar": 0.0322,
+      "log_bad": 1.6981,
+      "log_good": 1.8206
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 395.0,
+      "good": 513.0,
+      "ratio": 1.2987,
+      "suggested_scalar": 0.0688,
+      "log_bad": 5.9789,
+      "log_good": 6.2403
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 7.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.0406,
+      "log_bad": 1.7918,
+      "log_good": 1.9459
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0032,
+      "good": 0.0049,
+      "ratio": 1.5312,
+      "suggested_scalar": 0.1121,
+      "log_bad": -5.7446,
+      "log_good": -5.3185
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0976,
+      "good": 0.0351,
+      "ratio": 0.3596,
+      "suggested_scalar": -0.2691,
+      "log_bad": -2.3269,
+      "log_good": -3.3496
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 0.0005,
+      "ratio": 0.0005,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -7.6009
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9714,
+      "good": 1.0748,
+      "ratio": 1.1064,
+      "suggested_scalar": 0.0266,
+      "log_bad": -0.029,
+      "log_good": 0.0721
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 132.0,
+      "good": 155.0,
+      "ratio": 1.1742,
+      "suggested_scalar": 0.0423,
+      "log_bad": 4.8828,
+      "log_good": 5.0434
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 100.9852,
+      "good": 94.5999,
+      "ratio": 0.9368,
+      "suggested_scalar": -0.0172,
+      "log_bad": 4.615,
+      "log_good": 4.5497
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5178,
+      "good": 0.6035,
+      "ratio": 1.1655,
+      "suggested_scalar": 0.0403,
+      "log_bad": -0.6582,
+      "log_good": -0.505
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.1393,
+      "good": 12.3532,
+      "ratio": 1.5177,
+      "suggested_scalar": 0.1098,
+      "log_bad": 2.0967,
+      "log_good": 2.5139
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1572.0,
+      "good": 2037.0,
+      "ratio": 1.2958,
+      "suggested_scalar": 0.0682,
+      "log_bad": 7.3601,
+      "log_good": 7.6192
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0732,
+      "good": 0.1053,
+      "ratio": 1.4385,
+      "suggested_scalar": 0.0957,
+      "log_bad": -2.6146,
+      "log_good": -2.2509
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8049,
+      "good": 0.7719,
+      "ratio": 0.959,
+      "suggested_scalar": -0.011,
+      "log_bad": -0.217,
+      "log_good": -0.2589
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.6341,
+      "good": 9.1607,
+      "ratio": 0.9509,
+      "suggested_scalar": -0.0133,
+      "log_bad": 2.2653,
+      "log_good": 2.2149
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0757,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 13.0779,
+      "good": 20.2499,
+      "ratio": 1.5484,
+      "suggested_scalar": 0.115,
+      "log_bad": 2.5709,
+      "log_good": 3.0081
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 104.0,
+      "good": 93.0,
+      "ratio": 0.8942,
+      "suggested_scalar": -0.0294,
+      "log_bad": 4.6444,
+      "log_good": 4.5326
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9452,
+      "good": 0.9519,
+      "ratio": 1.0071,
+      "suggested_scalar": 0.0019,
+      "log_bad": -0.0564,
+      "log_good": -0.0493
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 29.0,
+      "ratio": 1.1154,
+      "suggested_scalar": 0.0287,
+      "log_bad": 3.2581,
+      "log_good": 3.3673
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.542,
+      "good": 0.6161,
+      "ratio": 1.1367,
+      "suggested_scalar": 0.0337,
+      "log_bad": -0.6125,
+      "log_good": -0.4843
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2952,
+      "good": 0.3933,
+      "ratio": 1.3323,
+      "suggested_scalar": 0.0755,
+      "log_bad": -1.2201,
+      "log_good": -0.9332
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.1833,
+      "good": 2.6049,
+      "ratio": 1.1931,
+      "suggested_scalar": 0.0465,
+      "log_bad": 0.7808,
+      "log_good": 0.9574
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 393.0,
+      "good": 511.0,
+      "ratio": 1.3003,
+      "suggested_scalar": 0.0691,
+      "log_bad": 5.9738,
+      "log_good": 6.2364
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 18.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1067,
+      "log_bad": 2.4849,
+      "log_good": 2.8904
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0532,
+      "good": 0.0643,
+      "ratio": 1.2086,
+      "suggested_scalar": 0.0499,
+      "log_bad": -2.9337,
+      "log_good": -2.7442
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 6.1497,
+      "ratio": 1.0411,
+      "suggested_scalar": 0.0106,
+      "log_bad": 1.7761,
+      "log_good": 1.8164
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 25.0,
+      "good": 58.0,
+      "ratio": 2.32,
+      "suggested_scalar": 0.2214,
+      "log_bad": 3.2189,
+      "log_good": 4.0604
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8497,
+      "good": 1.109,
+      "ratio": 1.3052,
+      "suggested_scalar": 0.0701,
+      "log_bad": -0.1629,
+      "log_good": 0.1035
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8468,
+      "good": 5.6682,
+      "ratio": 0.9695,
+      "suggested_scalar": -0.0082,
+      "log_bad": 1.7659,
+      "log_good": 1.7349
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7869,
+      "good": 0.7635,
+      "ratio": 0.9703,
+      "suggested_scalar": -0.0079,
+      "log_bad": -0.2397,
+      "log_good": -0.2698
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1458,
+      "good": 0.1094,
+      "ratio": 0.7503,
+      "suggested_scalar": -0.0756,
+      "log_bad": -1.9255,
+      "log_good": -2.2127
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.8529,
+      "good": 3.5147,
+      "ratio": 1.232,
+      "suggested_scalar": 0.0549,
+      "log_bad": 1.0483,
+      "log_good": 1.257
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 324.0,
+      "good": 384.0,
+      "ratio": 1.1852,
+      "suggested_scalar": 0.0447,
+      "log_bad": 5.7807,
+      "log_good": 5.9506
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 18.0,
+      "good": 23.0,
+      "ratio": 1.2778,
+      "suggested_scalar": 0.0645,
+      "log_bad": 2.8904,
+      "log_good": 3.1355
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.823,
+      "good": 1.0342,
+      "ratio": 1.2566,
+      "suggested_scalar": 0.0601,
+      "log_bad": -0.1948,
+      "log_good": 0.0336
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 108.0,
+      "good": 110.0,
+      "ratio": 1.0185,
+      "suggested_scalar": 0.0048,
+      "log_bad": 4.6821,
+      "log_good": 4.7005
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 801.0,
+      "good": 1007.0,
+      "ratio": 1.2572,
+      "suggested_scalar": 0.0602,
+      "log_bad": 6.6859,
+      "log_good": 6.9147
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 148.0,
+      "good": 162.0,
+      "ratio": 1.0946,
+      "suggested_scalar": 0.0238,
+      "log_bad": 4.9972,
+      "log_good": 5.0876
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0101,
+      "good": 0.0175,
+      "ratio": 1.7327,
+      "suggested_scalar": 0.1446,
+      "log_bad": -4.5952,
+      "log_good": -4.0456
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2354,
+      "good": 0.2612,
+      "ratio": 1.1096,
+      "suggested_scalar": 0.0274,
+      "log_bad": -1.4465,
+      "log_good": -1.3425
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 67.0,
+      "good": 92.0,
+      "ratio": 1.3731,
+      "suggested_scalar": 0.0834,
+      "log_bad": 4.2047,
+      "log_good": 4.5218
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 108.0,
+      "good": 110.0,
+      "ratio": 1.0185,
+      "suggested_scalar": 0.0048,
+      "log_bad": 4.6821,
+      "log_good": 4.7005
+    },
+    "brevity.mean_sample_size": {
+      "bad": 108.0,
+      "good": 110.0,
+      "ratio": 1.0185,
+      "suggested_scalar": 0.0048,
+      "log_bad": 4.6821,
+      "log_good": 4.7005
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 395.0,
+      "good": 513.0,
+      "ratio": 1.2987,
+      "suggested_scalar": 0.0688,
+      "log_bad": 5.9789,
+      "log_good": 6.2403
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 218.0,
+      "good": 308.0,
+      "ratio": 1.4128,
+      "suggested_scalar": 0.0909,
+      "log_bad": 5.3845,
+      "log_good": 5.7301
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 257.0,
+      "good": 295.0,
+      "ratio": 1.1479,
+      "suggested_scalar": 0.0363,
+      "log_bad": 5.5491,
+      "log_good": 5.687
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0019,
+      "ratio": 0.0019,
+      "suggested_scalar": -1.6487,
+      "log_bad": 0.0,
+      "log_good": -6.2659
+    },
+    "heaps.mean_k": {
+      "bad": 1.2538,
+      "good": 2.6178,
+      "ratio": 2.0879,
+      "suggested_scalar": 0.1937,
+      "log_bad": 0.2262,
+      "log_good": 0.9623
+    },
+    "halstead.mean_effort": {
+      "bad": 59382.9807,
+      "good": 104112.341,
+      "ratio": 1.7532,
+      "suggested_scalar": 0.1477,
+      "log_bad": 10.9918,
+      "log_good": 11.5532
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8656,
+      "good": 0.8358,
+      "ratio": 0.9656,
+      "suggested_scalar": -0.0092,
+      "log_bad": -0.1443,
+      "log_good": -0.1794
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 80.0,
+      "good": 70.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0351,
+      "log_bad": 4.382,
+      "log_good": 4.2485
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 219.0,
+      "good": 306.0,
+      "ratio": 1.3973,
+      "suggested_scalar": 0.088,
+      "log_bad": 5.3891,
+      "log_good": 5.7236
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5379,
+      "good": 0.4258,
+      "ratio": 0.7916,
+      "suggested_scalar": -0.0615,
+      "log_bad": -0.6201,
+      "log_good": -0.8538
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0682,
+      "good": 6.4968,
+      "ratio": 1.0706,
+      "suggested_scalar": 0.018,
+      "log_bad": 1.8031,
+      "log_good": 1.8713
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1458,
+      "good": 0.1094,
+      "ratio": 0.7503,
+      "suggested_scalar": -0.0756,
+      "log_bad": -1.9255,
+      "log_good": -2.2127
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.3056,
+      "good": 3.8613,
+      "ratio": 0.8968,
+      "suggested_scalar": -0.0287,
+      "log_bad": 1.4599,
+      "log_good": 1.351
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 394.0,
+      "good": 512.0,
+      "ratio": 1.2995,
+      "suggested_scalar": 0.0689,
+      "log_bad": 5.9764,
+      "log_good": 6.2383
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 8.0,
+      "good": 12.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1067,
+      "log_bad": 2.0794,
+      "log_good": 2.4849
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 47.0,
+      "good": 74.0,
+      "ratio": 1.5745,
+      "suggested_scalar": 0.1194,
+      "log_bad": 3.8501,
+      "log_good": 4.3041
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3299.0545,
+      "good": 5784.0189,
+      "ratio": 1.7532,
+      "suggested_scalar": 0.1477,
+      "log_bad": 8.1014,
+      "log_good": 8.6629
+    },
+    "readability.mean_total_lines": {
+      "bad": 41.0,
+      "good": 56.0,
+      "ratio": 1.3659,
+      "suggested_scalar": 0.082,
+      "log_bad": 3.7136,
+      "log_good": 4.0254
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 16.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0757,
+      "log_bad": 2.4849,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2469.1468,
+      "good": 3102.5389,
+      "ratio": 1.2565,
+      "suggested_scalar": 0.0601,
+      "log_bad": 7.8116,
+      "log_good": 8.04
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 720.0,
+      "good": 782.0,
+      "ratio": 1.0861,
+      "suggested_scalar": 0.0217,
+      "log_bad": 6.5793,
+      "log_good": 6.6619
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 37.0244,
+      "good": 34.9107,
+      "ratio": 0.9429,
+      "suggested_scalar": -0.0155,
+      "log_bad": 3.6116,
+      "log_good": 3.5528
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1356,
+      "good": 1.2167,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.0182,
+      "log_bad": 0.1272,
+      "log_good": 0.1961
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 7.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.0406,
+      "log_bad": 1.7918,
+      "log_good": 1.9459
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 12.0,
+      "good": 8.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1067,
+      "log_bad": 2.4849,
+      "log_good": 2.0794
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 2.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.1824,
+      "log_bad": 1.3863,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8549,
+      "good": 0.8073,
+      "ratio": 0.9443,
+      "suggested_scalar": -0.0151,
+      "log_bad": -0.1568,
+      "log_good": -0.2141
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9724,
+      "good": 0.9806,
+      "ratio": 1.0084,
+      "suggested_scalar": 0.0022,
+      "log_bad": -0.028,
+      "log_good": -0.0196
+    },
+    "halstead.mean_length": {
+      "bad": 367.0,
+      "good": 468.0,
+      "ratio": 1.2752,
+      "suggested_scalar": 0.064,
+      "log_bad": 5.9054,
+      "log_good": 6.1485
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.6,
+      "good": 10.6,
+      "ratio": 1.3947,
+      "suggested_scalar": 0.0875,
+      "log_bad": 2.0281,
+      "log_good": 2.3609
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7549,
+      "good": 6.7814,
+      "ratio": 1.0039,
+      "suggested_scalar": 0.001,
+      "log_bad": 1.9103,
+      "log_good": 1.9142
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1392,
+      "good": 0.1514,
+      "ratio": 1.0876,
+      "suggested_scalar": 0.0221,
+      "log_bad": -1.9718,
+      "log_good": -1.8878
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 24.05,
+      "good": 33.5571,
+      "ratio": 1.3953,
+      "suggested_scalar": 0.0877,
+      "log_bad": 3.1801,
+      "log_good": 3.5132
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 6.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1824,
+      "log_bad": 1.0986,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 71.0,
+      "good": 66.0,
+      "ratio": 0.9296,
+      "suggested_scalar": -0.0192,
+      "log_bad": 4.2627,
+      "log_good": 4.1897
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7393,
+      "good": 0.6881,
+      "ratio": 0.9307,
+      "suggested_scalar": -0.0189,
+      "log_bad": -0.3021,
+      "log_good": -0.3738
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 41.0,
+      "good": 57.0,
+      "ratio": 1.3902,
+      "suggested_scalar": 0.0867,
+      "log_bad": 3.7136,
+      "log_good": 4.0431
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.sealed_class_when_is_exhaustive": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 14.0,
+      "good": 20.0,
+      "ratio": 1.4286,
+      "suggested_scalar": 0.4432,
+      "log_bad": 2.6391,
+      "log_good": 2.9957
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0294,
+      "good": 0.0383,
+      "ratio": 1.3027,
+      "suggested_scalar": 0.3286,
+      "log_bad": -3.5268,
+      "log_good": -3.2623
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8293,
+      "good": 0.9118,
+      "ratio": 1.0995,
+      "suggested_scalar": 0.1179,
+      "log_bad": -0.1872,
+      "log_good": -0.0923
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0294,
+      "good": 0.0383,
+      "ratio": 1.3027,
+      "suggested_scalar": 0.3286,
+      "log_bad": -3.5268,
+      "log_good": -3.2623
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.557,
+      "good": 4.6766,
+      "ratio": 1.0262,
+      "suggested_scalar": 0.0322,
+      "log_bad": 1.5167,
+      "log_good": 1.5426
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 96.0,
+      "good": 78.0,
+      "ratio": 0.8125,
+      "suggested_scalar": -0.258,
+      "log_bad": 4.5643,
+      "log_good": 4.3567
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5338,
+      "good": 0.4186,
+      "ratio": 0.7842,
+      "suggested_scalar": -0.3021,
+      "log_bad": -0.6277,
+      "log_good": -0.8708
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 12.0,
+      "good": 14.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.1916,
+      "log_bad": 2.4849,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6956,
+      "good": 0.6073,
+      "ratio": 0.8731,
+      "suggested_scalar": -0.1687,
+      "log_bad": -0.363,
+      "log_good": -0.4987
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.5366,
+      "good": 4.9412,
+      "ratio": 0.7559,
+      "suggested_scalar": -0.3477,
+      "log_bad": 1.8774,
+      "log_good": 1.5976
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 374.0,
+      "good": 392.0,
+      "ratio": 1.0481,
+      "suggested_scalar": 0.0584,
+      "log_bad": 5.9243,
+      "log_good": 5.9713
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.2266,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.122,
+      "good": 0.0294,
+      "ratio": 0.241,
+      "suggested_scalar": -1.7684,
+      "log_bad": -2.1037,
+      "log_good": -3.5268
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0023,
+      "good": 1.126,
+      "ratio": 1.1234,
+      "suggested_scalar": 0.1446,
+      "log_bad": 0.0023,
+      "log_good": 0.1187
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 138.0,
+      "good": 142.0,
+      "ratio": 1.029,
+      "suggested_scalar": 0.0355,
+      "log_bad": 4.9273,
+      "log_good": 4.9558
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 94.2225,
+      "good": 84.7074,
+      "ratio": 0.899,
+      "suggested_scalar": -0.1323,
+      "log_bad": 4.5457,
+      "log_good": 4.4392
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5979,
+      "good": 0.6854,
+      "ratio": 1.1463,
+      "suggested_scalar": 0.1697,
+      "log_bad": -0.5143,
+      "log_good": -0.3778
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.8742,
+      "good": 11.3858,
+      "ratio": 1.047,
+      "suggested_scalar": 0.0571,
+      "log_bad": 2.3864,
+      "log_good": 2.4324
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2023.0,
+      "good": 1884.0,
+      "ratio": 0.9313,
+      "suggested_scalar": -0.0885,
+      "log_bad": 7.6123,
+      "log_good": 7.5412
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1707,
+      "good": 0.1176,
+      "ratio": 0.6889,
+      "suggested_scalar": -0.463,
+      "log_bad": -1.7678,
+      "log_good": -2.1405
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7805,
+      "good": 0.8824,
+      "ratio": 1.1306,
+      "suggested_scalar": 0.1525,
+      "log_bad": -0.2478,
+      "log_good": -0.1251
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.122,
+      "good": 11.5294,
+      "ratio": 1.2639,
+      "suggested_scalar": 0.291,
+      "log_bad": 2.2107,
+      "log_good": 2.4449
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 17.7609,
+      "good": 9.4671,
+      "ratio": 0.533,
+      "suggested_scalar": -0.7819,
+      "log_bad": 2.877,
+      "log_good": 2.2478
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 61.0,
+      "good": 54.0,
+      "ratio": 0.8852,
+      "suggested_scalar": -0.1515,
+      "log_bad": 4.1109,
+      "log_good": 3.989
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9336,
+      "good": 0.9315,
+      "ratio": 0.9978,
+      "suggested_scalar": -0.0028,
+      "log_bad": -0.0687,
+      "log_good": -0.071
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 18.0,
+      "ratio": 0.7826,
+      "suggested_scalar": -0.3046,
+      "log_bad": 3.1355,
+      "log_good": 2.8904
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6822,
+      "good": 0.7017,
+      "ratio": 1.0286,
+      "suggested_scalar": 0.035,
+      "log_bad": -0.3824,
+      "log_good": -0.3542
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4543,
+      "good": 0.5538,
+      "ratio": 1.219,
+      "suggested_scalar": 0.2461,
+      "log_bad": -0.789,
+      "log_good": -0.591
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.1462,
+      "good": 3.3523,
+      "ratio": 1.0655,
+      "suggested_scalar": 0.0788,
+      "log_bad": 1.1462,
+      "log_good": 1.2096
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 372.0,
+      "good": 390.0,
+      "ratio": 1.0484,
+      "suggested_scalar": 0.0587,
+      "log_bad": 5.9189,
+      "log_good": 5.9661
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 8.0,
+      "ratio": 0.7273,
+      "suggested_scalar": -0.3957,
+      "log_bad": 2.3979,
+      "log_good": 2.0794
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0294,
+      "good": 0.0306,
+      "ratio": 1.0408,
+      "suggested_scalar": 0.0497,
+      "log_bad": -3.5268,
+      "log_good": -3.4868
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8074,
+      "good": 5.8074,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7591,
+      "log_good": 1.7591
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 63.0,
+      "good": 68.0,
+      "ratio": 1.0794,
+      "suggested_scalar": 0.0949,
+      "log_bad": 4.1431,
+      "log_good": 4.2195
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.372,
+      "good": 1.4374,
+      "ratio": 1.0477,
+      "suggested_scalar": 0.0579,
+      "log_bad": 0.3163,
+      "log_good": 0.3628
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7165,
+      "good": 5.2851,
+      "ratio": 0.9245,
+      "suggested_scalar": -0.0975,
+      "log_bad": 1.7434,
+      "log_good": 1.6649
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7847,
+      "good": 0.8053,
+      "ratio": 1.0263,
+      "suggested_scalar": 0.0322,
+      "log_bad": -0.2425,
+      "log_good": -0.2165
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1277,
+      "good": 0.15,
+      "ratio": 1.1746,
+      "suggested_scalar": 0.2,
+      "log_bad": -2.0581,
+      "log_good": -1.8971
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.2976,
+      "good": 3.3743,
+      "ratio": 1.0233,
+      "suggested_scalar": 0.0286,
+      "log_bad": 1.1932,
+      "log_good": 1.2162
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 259.0,
+      "good": 240.0,
+      "ratio": 0.9266,
+      "suggested_scalar": -0.0947,
+      "log_bad": 5.5568,
+      "log_good": 5.4806
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.6348,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7331,
+      "good": 0.7061,
+      "ratio": 0.9632,
+      "suggested_scalar": -0.0466,
+      "log_bad": -0.3105,
+      "log_good": -0.348
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 96.0,
+      "good": 79.0,
+      "ratio": 0.8229,
+      "suggested_scalar": -0.2422,
+      "log_bad": 4.5643,
+      "log_good": 4.3694
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1097.0,
+      "good": 1168.0,
+      "ratio": 1.0647,
+      "suggested_scalar": 0.0779,
+      "log_bad": 7.0003,
+      "log_good": 7.063
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 151.0,
+      "good": 147.0,
+      "ratio": 0.9735,
+      "suggested_scalar": -0.0334,
+      "log_bad": 5.0173,
+      "log_good": 4.9904
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0241,
+      "good": 0.0306,
+      "ratio": 1.2697,
+      "suggested_scalar": 0.2967,
+      "log_bad": -3.7255,
+      "log_good": -3.4868
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2246,
+      "good": 0.273,
+      "ratio": 1.2155,
+      "suggested_scalar": 0.2425,
+      "log_bad": -1.4934,
+      "log_good": -1.2983
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 61.0,
+      "good": 66.0,
+      "ratio": 1.082,
+      "suggested_scalar": 0.0979,
+      "log_bad": 4.1109,
+      "log_good": 4.1897
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 96.0,
+      "good": 79.0,
+      "ratio": 0.8229,
+      "suggested_scalar": -0.2422,
+      "log_bad": 4.5643,
+      "log_good": 4.3694
+    },
+    "brevity.mean_sample_size": {
+      "bad": 96.0,
+      "good": 79.0,
+      "ratio": 0.8229,
+      "suggested_scalar": -0.2422,
+      "log_bad": 4.5643,
+      "log_good": 4.3694
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 374.0,
+      "good": 392.0,
+      "ratio": 1.0481,
+      "suggested_scalar": 0.0584,
+      "log_bad": 5.9243,
+      "log_good": 5.9713
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 171.0,
+      "good": 202.0,
+      "ratio": 1.1813,
+      "suggested_scalar": 0.207,
+      "log_bad": 5.1417,
+      "log_good": 5.3083
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 211.0,
+      "good": 189.0,
+      "ratio": 0.8957,
+      "suggested_scalar": -0.1368,
+      "log_bad": 5.3519,
+      "log_good": 5.2417
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.7104,
+      "good": 2.4037,
+      "ratio": 1.4053,
+      "suggested_scalar": 0.4229,
+      "log_bad": 0.5367,
+      "log_good": 0.877
+    },
+    "halstead.mean_effort": {
+      "bad": 52318.0683,
+      "good": 46705.8811,
+      "ratio": 0.8927,
+      "suggested_scalar": -0.141,
+      "log_bad": 10.8651,
+      "log_good": 10.7516
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8681,
+      "good": 0.8384,
+      "ratio": 0.9658,
+      "suggested_scalar": -0.0433,
+      "log_bad": -0.1414,
+      "log_good": -0.1763
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 73.0,
+      "good": 60.0,
+      "ratio": 0.8219,
+      "suggested_scalar": -0.2437,
+      "log_bad": 4.2905,
+      "log_good": 4.0943
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 183.0,
+      "good": 190.0,
+      "ratio": 1.0383,
+      "suggested_scalar": 0.0466,
+      "log_bad": 5.2095,
+      "log_good": 5.247
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4783,
+      "good": 0.3662,
+      "ratio": 0.7656,
+      "suggested_scalar": -0.3319,
+      "log_bad": -0.7375,
+      "log_good": -1.0046
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.9493,
+      "good": 8.2254,
+      "ratio": 1.0347,
+      "suggested_scalar": 0.0424,
+      "log_bad": 2.0731,
+      "log_good": 2.1072
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1277,
+      "good": 0.15,
+      "ratio": 1.1746,
+      "suggested_scalar": 0.2,
+      "log_bad": -2.0581,
+      "log_good": -1.8971
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.437,
+      "good": 5.4539,
+      "ratio": 1.2292,
+      "suggested_scalar": 0.2564,
+      "log_bad": 1.49,
+      "log_good": 1.6963
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 373.0,
+      "good": 391.0,
+      "ratio": 1.0483,
+      "suggested_scalar": 0.0586,
+      "log_bad": 5.9216,
+      "log_good": 5.9687
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.8614,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 56.0,
+      "good": 66.0,
+      "ratio": 1.1786,
+      "suggested_scalar": 0.2042,
+      "log_bad": 4.0254,
+      "log_good": 4.1897
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2906.5593,
+      "good": 2594.7712,
+      "ratio": 0.8927,
+      "suggested_scalar": -0.141,
+      "log_bad": 7.9747,
+      "log_good": 7.8613
+    },
+    "readability.mean_total_lines": {
+      "bad": 41.0,
+      "good": 34.0,
+      "ratio": 0.8293,
+      "suggested_scalar": -0.2326,
+      "log_bad": 3.7136,
+      "log_good": 3.5264
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 8.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.5039,
+      "log_bad": 2.4849,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2199.3775,
+      "good": 2118.1805,
+      "ratio": 0.9631,
+      "suggested_scalar": -0.0467,
+      "log_bad": 7.6959,
+      "log_good": 7.6583
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 643.0,
+      "good": 562.0,
+      "ratio": 0.874,
+      "suggested_scalar": -0.1673,
+      "log_bad": 6.4661,
+      "log_good": 6.3315
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 48.0,
+      "good": 54.1765,
+      "ratio": 1.1287,
+      "suggested_scalar": 0.1504,
+      "log_bad": 3.8712,
+      "log_good": 3.9922
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2217,
+      "good": 1.3053,
+      "ratio": 1.0684,
+      "suggested_scalar": 0.0823,
+      "log_bad": 0.2002,
+      "log_good": 0.2664
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.2266,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 22.0,
+      "good": 35.0,
+      "ratio": 1.5909,
+      "suggested_scalar": 0.577,
+      "log_bad": 3.091,
+      "log_good": 3.5553
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 1.0,
+      "ratio": 0.2,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.6094,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7838,
+      "good": 0.725,
+      "ratio": 0.925,
+      "suggested_scalar": -0.0969,
+      "log_bad": -0.2436,
+      "log_good": -0.3216
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.987,
+      "good": 0.9662,
+      "ratio": 0.9789,
+      "suggested_scalar": -0.0265,
+      "log_bad": -0.0131,
+      "log_good": -0.0344
+    },
+    "halstead.mean_length": {
+      "bad": 334.0,
+      "good": 337.0,
+      "ratio": 1.009,
+      "suggested_scalar": 0.0111,
+      "log_bad": 5.8111,
+      "log_good": 5.8201
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.3333,
+      "good": 8.0,
+      "ratio": 0.7742,
+      "suggested_scalar": -0.318,
+      "log_bad": 2.3354,
+      "log_good": 2.0794
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.585,
+      "good": 6.3038,
+      "ratio": 0.9573,
+      "suggested_scalar": -0.0542,
+      "log_bad": 1.8848,
+      "log_good": 1.8412
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0849,
+      "good": 0.1073,
+      "ratio": 1.2638,
+      "suggested_scalar": 0.291,
+      "log_bad": -2.4663,
+      "log_good": -2.2321
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 23.7877,
+      "good": 22.05,
+      "ratio": 0.9269,
+      "suggested_scalar": -0.0943,
+      "log_bad": 3.1692,
+      "log_good": 3.0933
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 4.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -0.6954,
+      "log_bad": 1.9459,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 66.0,
+      "good": 52.0,
+      "ratio": 0.7879,
+      "suggested_scalar": -0.2963,
+      "log_bad": 4.1897,
+      "log_good": 3.9512
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7109,
+      "good": 0.6508,
+      "ratio": 0.9155,
+      "suggested_scalar": -0.1098,
+      "log_bad": -0.3412,
+      "log_good": -0.4296
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 41.0,
+      "good": 34.0,
+      "ratio": 0.8293,
+      "suggested_scalar": -0.2326,
+      "log_bad": 3.7136,
+      "log_good": 3.5264
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.consistent_string_quote_style": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 16.0,
+      "good": 13.0,
+      "ratio": 0.8125,
+      "suggested_scalar": -0.1804,
+      "log_bad": 2.7726,
+      "log_good": 2.5649
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0349,
+      "good": 0.0494,
+      "ratio": 1.4155,
+      "suggested_scalar": 0.3018,
+      "log_bad": -3.3553,
+      "log_good": -3.0078
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.7143,
+      "good": 1.7143,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.539,
+      "log_good": 0.539
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.6479,
+      "good": 0.6232,
+      "ratio": 0.9619,
+      "suggested_scalar": -0.0338,
+      "log_bad": -0.434,
+      "log_good": -0.4729
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0595,
+      "good": 0.0494,
+      "ratio": 0.8303,
+      "suggested_scalar": -0.1616,
+      "log_bad": -2.8218,
+      "log_good": -3.0078
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6258,
+      "good": 4.6074,
+      "ratio": 0.996,
+      "suggested_scalar": -0.0035,
+      "log_bad": 1.5316,
+      "log_good": 1.5277
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 89.0,
+      "good": 73.0,
+      "ratio": 0.8202,
+      "suggested_scalar": -0.1721,
+      "log_bad": 4.4886,
+      "log_good": 4.2905
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4682,
+      "good": 0.4521,
+      "ratio": 0.9656,
+      "suggested_scalar": -0.0304,
+      "log_bad": -0.7589,
+      "log_good": -0.7939
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 17.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.0966,
+      "log_bad": 2.9444,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5588,
+      "good": 0.5598,
+      "ratio": 1.0018,
+      "suggested_scalar": 0.0016,
+      "log_bad": -0.582,
+      "log_good": -0.5802
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.1408,
+      "good": 4.1449,
+      "ratio": 1.001,
+      "suggested_scalar": 0.0009,
+      "log_bad": 1.4209,
+      "log_good": 1.4219
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 487.0,
+      "good": 445.0,
+      "ratio": 0.9138,
+      "suggested_scalar": -0.0783,
+      "log_bad": 6.1883,
+      "log_good": 6.0981
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.002,
+      "good": 0.0021,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0424,
+      "log_bad": -6.2146,
+      "log_good": -6.1658
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.072,
+      "good": 1.0707,
+      "ratio": 0.9988,
+      "suggested_scalar": -0.0011,
+      "log_bad": 0.0695,
+      "log_good": 0.0683
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 183.0,
+      "good": 171.0,
+      "ratio": 0.9344,
+      "suggested_scalar": -0.0589,
+      "log_bad": 5.2095,
+      "log_good": 5.1417
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.5057,
+      "good": 105.0629,
+      "ratio": 1.0053,
+      "suggested_scalar": 0.0046,
+      "log_bad": 4.6492,
+      "log_good": 4.6546
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6152,
+      "good": 0.6351,
+      "ratio": 1.0323,
+      "suggested_scalar": 0.0277,
+      "log_bad": -0.4858,
+      "log_good": -0.454
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.2838,
+      "good": 13.7758,
+      "ratio": 1.037,
+      "suggested_scalar": 0.0316,
+      "log_bad": 2.5865,
+      "log_good": 2.6229
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2041.0,
+      "good": 1889.0,
+      "ratio": 0.9255,
+      "suggested_scalar": -0.0672,
+      "log_bad": 7.6212,
+      "log_good": 7.5438
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0282,
+      "good": 0.029,
+      "ratio": 1.0284,
+      "suggested_scalar": 0.0243,
+      "log_bad": -3.5684,
+      "log_good": -3.5405
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6197,
+      "good": 0.5942,
+      "ratio": 0.9589,
+      "suggested_scalar": -0.0365,
+      "log_bad": -0.4785,
+      "log_good": -0.5205
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.8592,
+      "good": 6.4493,
+      "ratio": 0.9402,
+      "suggested_scalar": -0.0535,
+      "log_bad": 1.9256,
+      "log_good": 1.864
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.8534,
+      "good": 2.9355,
+      "ratio": 1.0288,
+      "suggested_scalar": 0.0246,
+      "log_bad": 1.0485,
+      "log_good": 1.0769
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 158.0,
+      "good": 150.0,
+      "ratio": 0.9494,
+      "suggested_scalar": -0.0451,
+      "log_bad": 5.0626,
+      "log_good": 5.0106
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9321,
+      "good": 0.9351,
+      "ratio": 1.0032,
+      "suggested_scalar": 0.0028,
+      "log_bad": -0.0703,
+      "log_good": -0.0671
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 21.0,
+      "ratio": 0.913,
+      "suggested_scalar": -0.079,
+      "log_bad": 3.1355,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.658,
+      "good": 0.6739,
+      "ratio": 1.0242,
+      "suggested_scalar": 0.0207,
+      "log_bad": -0.4186,
+      "log_good": -0.3947
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4412,
+      "good": 0.4673,
+      "ratio": 1.0592,
+      "suggested_scalar": 0.0499,
+      "log_bad": -0.8183,
+      "log_good": -0.7608
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9241,
+      "good": 3.0666,
+      "ratio": 1.0487,
+      "suggested_scalar": 0.0413,
+      "log_bad": 1.073,
+      "log_good": 1.1206
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 485.0,
+      "good": 443.0,
+      "ratio": 0.9134,
+      "suggested_scalar": -0.0787,
+      "log_bad": 6.1841,
+      "log_good": 6.0936
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 14.0,
+      "good": 13.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.0644,
+      "log_bad": 2.6391,
+      "log_good": 2.5649
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0554,
+      "good": 0.0584,
+      "ratio": 1.0542,
+      "suggested_scalar": 0.0458,
+      "log_bad": -2.8932,
+      "log_good": -2.8404
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.7814,
+      "ratio": 0.9912,
+      "suggested_scalar": -0.0077,
+      "log_bad": 1.7635,
+      "log_good": 1.7546
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 22.0,
+      "good": 18.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.1743,
+      "log_bad": 3.091,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6627,
+      "good": 0.6261,
+      "ratio": 0.9448,
+      "suggested_scalar": -0.0493,
+      "log_bad": -0.4114,
+      "log_good": -0.4682
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7736,
+      "good": 5.6565,
+      "ratio": 0.9797,
+      "suggested_scalar": -0.0178,
+      "log_bad": 1.7533,
+      "log_good": 1.7328
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7931,
+      "good": 0.7969,
+      "ratio": 1.0048,
+      "suggested_scalar": 0.0042,
+      "log_bad": -0.2318,
+      "log_good": -0.227
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1548,
+      "good": 0.1585,
+      "ratio": 1.0239,
+      "suggested_scalar": 0.0205,
+      "log_bad": -1.8656,
+      "log_good": -1.842
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6447,
+      "good": 3.7116,
+      "ratio": 1.0184,
+      "suggested_scalar": 0.0158,
+      "log_bad": 1.2933,
+      "log_good": 1.3115
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 338.0,
+      "good": 295.0,
+      "ratio": 0.8728,
+      "suggested_scalar": -0.1182,
+      "log_bad": 5.823,
+      "log_good": 5.687
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 10.0,
+      "ratio": 10.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7836,
+      "good": 0.6272,
+      "ratio": 0.8004,
+      "suggested_scalar": -0.1934,
+      "log_bad": -0.2439,
+      "log_good": -0.4665
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 110.0,
+      "good": 102.0,
+      "ratio": 0.9273,
+      "suggested_scalar": -0.0656,
+      "log_bad": 4.7005,
+      "log_good": 4.625
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1112.0,
+      "good": 1046.0,
+      "ratio": 0.9406,
+      "suggested_scalar": -0.0531,
+      "log_bad": 7.0139,
+      "log_good": 6.9527
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 142.0,
+      "good": 109.0,
+      "ratio": 0.7676,
+      "suggested_scalar": -0.2297,
+      "log_bad": 4.9558,
+      "log_good": 4.6913
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0062,
+      "good": 0.0067,
+      "ratio": 1.0806,
+      "suggested_scalar": 0.0674,
+      "log_bad": -5.0832,
+      "log_good": -5.0056
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2608,
+      "good": 0.2854,
+      "ratio": 1.0943,
+      "suggested_scalar": 0.0783,
+      "log_bad": -1.344,
+      "log_good": -1.2539
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 80.0,
+      "good": 72.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0915,
+      "log_bad": 4.382,
+      "log_good": 4.2767
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 110.0,
+      "good": 102.0,
+      "ratio": 0.9273,
+      "suggested_scalar": -0.0656,
+      "log_bad": 4.7005,
+      "log_good": 4.625
+    },
+    "brevity.mean_sample_size": {
+      "bad": 110.0,
+      "good": 102.0,
+      "ratio": 0.9273,
+      "suggested_scalar": -0.0656,
+      "log_bad": 4.7005,
+      "log_good": 4.625
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 487.0,
+      "good": 445.0,
+      "ratio": 0.9138,
+      "suggested_scalar": -0.0783,
+      "log_bad": 6.1883,
+      "log_good": 6.0981
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 267.0,
+      "good": 238.0,
+      "ratio": 0.8914,
+      "suggested_scalar": -0.0999,
+      "log_bad": 5.5872,
+      "log_good": 5.4723
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 267.0,
+      "good": 234.0,
+      "ratio": 0.8764,
+      "suggested_scalar": -0.1146,
+      "log_bad": 5.5872,
+      "log_good": 5.4553
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 3.4605,
+      "good": 3.3171,
+      "ratio": 0.9586,
+      "suggested_scalar": -0.0368,
+      "log_bad": 1.2414,
+      "log_good": 1.1991
+    },
+    "halstead.mean_effort": {
+      "bad": 58161.7998,
+      "good": 41415.64,
+      "ratio": 0.7121,
+      "suggested_scalar": -0.2949,
+      "log_bad": 10.971,
+      "log_good": 10.6314
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8514,
+      "good": 0.8477,
+      "ratio": 0.9957,
+      "suggested_scalar": -0.0038,
+      "log_bad": -0.1609,
+      "log_good": -0.1652
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 66.0,
+      "good": 52.0,
+      "ratio": 0.7879,
+      "suggested_scalar": -0.2071,
+      "log_bad": 4.1897,
+      "log_good": 3.9512
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 221.0,
+      "good": 195.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.1087,
+      "log_bad": 5.3982,
+      "log_good": 5.273
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4426,
+      "good": 0.4386,
+      "ratio": 0.991,
+      "suggested_scalar": -0.0079,
+      "log_bad": -0.8151,
+      "log_good": -0.8242
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0765,
+      "good": 6.117,
+      "ratio": 1.0067,
+      "suggested_scalar": 0.0058,
+      "log_bad": 1.8044,
+      "log_good": 1.8111
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1548,
+      "good": 0.1585,
+      "ratio": 1.0239,
+      "suggested_scalar": 0.0205,
+      "log_bad": -1.8656,
+      "log_good": -1.842
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.4709,
+      "good": 3.3527,
+      "ratio": 0.9659,
+      "suggested_scalar": -0.0301,
+      "log_bad": 1.2444,
+      "log_good": 1.2098
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 486.0,
+      "good": 444.0,
+      "ratio": 0.9136,
+      "suggested_scalar": -0.0785,
+      "log_bad": 6.1862,
+      "log_good": 6.0958
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 16.0,
+      "ratio": 3.2,
+      "suggested_scalar": 1.0103,
+      "log_bad": 1.6094,
+      "log_good": 2.7726
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 67.0,
+      "good": 59.0,
+      "ratio": 0.8806,
+      "suggested_scalar": -0.1104,
+      "log_bad": 4.2047,
+      "log_good": 4.0775
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3231.2111,
+      "good": 2300.8689,
+      "ratio": 0.7121,
+      "suggested_scalar": -0.2949,
+      "log_bad": 8.0806,
+      "log_good": 7.741
+    },
+    "readability.mean_total_lines": {
+      "bad": 71.0,
+      "good": 69.0,
+      "ratio": 0.9718,
+      "suggested_scalar": -0.0248,
+      "log_bad": 4.2627,
+      "log_good": 4.2341
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2350.6912,
+      "good": 1881.7067,
+      "ratio": 0.8005,
+      "suggested_scalar": -0.1933,
+      "log_bad": 7.7625,
+      "log_good": 7.5399
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 698.0,
+      "good": 616.0,
+      "ratio": 0.8825,
+      "suggested_scalar": -0.1085,
+      "log_bad": 6.5482,
+      "log_good": 6.4232
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 27.5634,
+      "good": 26.1884,
+      "ratio": 0.9501,
+      "suggested_scalar": -0.0444,
+      "log_bad": 3.3165,
+      "log_good": 3.2653
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1273,
+      "good": 1.1256,
+      "ratio": 0.9985,
+      "suggested_scalar": -0.0013,
+      "log_bad": 0.1198,
+      "log_good": 0.1183
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 22.0,
+      "good": 18.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.1743,
+      "log_bad": 3.091,
+      "log_good": 2.8904
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8018,
+      "good": 0.8,
+      "ratio": 0.9978,
+      "suggested_scalar": -0.002,
+      "log_bad": -0.2209,
+      "log_good": -0.2231
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9805,
+      "good": 0.9715,
+      "ratio": 0.9908,
+      "suggested_scalar": -0.008,
+      "log_bad": -0.0197,
+      "log_good": -0.0289
+    },
+    "halstead.mean_length": {
+      "bad": 363.0,
+      "good": 304.0,
+      "ratio": 0.8375,
+      "suggested_scalar": -0.1541,
+      "log_bad": 5.8944,
+      "log_good": 5.717
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.1429,
+      "good": 10.8571,
+      "ratio": 0.9744,
+      "suggested_scalar": -0.0226,
+      "log_bad": 2.4108,
+      "log_good": 2.3848
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7814,
+      "good": 6.6724,
+      "ratio": 0.9839,
+      "suggested_scalar": -0.0141,
+      "log_bad": 1.9142,
+      "log_good": 1.898
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1308,
+      "good": 0.126,
+      "ratio": 0.9633,
+      "suggested_scalar": -0.0325,
+      "log_bad": -2.0341,
+      "log_good": -2.0715
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 24.7424,
+      "good": 22.0096,
+      "ratio": 0.8895,
+      "suggested_scalar": -0.1017,
+      "log_bad": 3.2085,
+      "log_good": 3.0915
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 81.0,
+      "good": 75.0,
+      "ratio": 0.9259,
+      "suggested_scalar": -0.0668,
+      "log_bad": 4.3944,
+      "log_good": 4.3175
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7004,
+      "good": 0.6923,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0101,
+      "log_bad": -0.3561,
+      "log_good": -0.3677
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 71.0,
+      "good": 69.0,
+      "ratio": 0.9718,
+      "suggested_scalar": -0.0248,
+      "log_bad": 4.2627,
+      "log_good": 4.2341
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_unsafe_return": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 12.0,
+      "good": 13.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.0411,
+      "log_bad": 2.4849,
+      "log_good": 2.5649
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0359,
+      "good": 0.0413,
+      "ratio": 1.1504,
+      "suggested_scalar": 0.072,
+      "log_bad": -3.327,
+      "log_good": -3.1869
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.898,
+      "good": 0.7705,
+      "ratio": 0.858,
+      "suggested_scalar": -0.0787,
+      "log_bad": -0.1076,
+      "log_good": -0.2607
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0359,
+      "good": 0.0413,
+      "ratio": 1.1504,
+      "suggested_scalar": 0.072,
+      "log_bad": -3.327,
+      "log_good": -3.1869
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.905,
+      "good": 4.9446,
+      "ratio": 1.0081,
+      "suggested_scalar": 0.0041,
+      "log_bad": 1.5903,
+      "log_good": 1.5983
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 87.0,
+      "good": 86.0,
+      "ratio": 0.9885,
+      "suggested_scalar": -0.0059,
+      "log_bad": 4.4659,
+      "log_good": 4.4543
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.534,
+      "good": 0.4442,
+      "ratio": 0.8318,
+      "suggested_scalar": -0.0946,
+      "log_bad": -0.6274,
+      "log_good": -0.8115
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 20.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0264,
+      "log_bad": 2.9444,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6911,
+      "good": 0.6068,
+      "ratio": 0.878,
+      "suggested_scalar": -0.0668,
+      "log_bad": -0.3695,
+      "log_good": -0.4996
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.7551,
+      "good": 1.7377,
+      "ratio": 0.9901,
+      "suggested_scalar": -0.0051,
+      "log_bad": 0.5625,
+      "log_good": 0.5526
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 362.0,
+      "good": 509.0,
+      "ratio": 1.4061,
+      "suggested_scalar": 0.1751,
+      "log_bad": 5.8916,
+      "log_good": 6.2324
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0013,
+      "good": 0.0015,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.0735,
+      "log_bad": -6.6454,
+      "log_good": -6.5023
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0204,
+      "good": 1.0,
+      "ratio": 49.0196,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.8922,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0013,
+      "good": 0.0025,
+      "ratio": 1.9231,
+      "suggested_scalar": 0.336,
+      "log_bad": -6.6454,
+      "log_good": -5.9915
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9482,
+      "good": 0.9959,
+      "ratio": 1.0503,
+      "suggested_scalar": 0.0252,
+      "log_bad": -0.0532,
+      "log_good": -0.0041
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 104.0,
+      "good": 147.0,
+      "ratio": 1.4135,
+      "suggested_scalar": 0.1778,
+      "log_bad": 4.6444,
+      "log_good": 4.9904
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 94.26,
+      "good": 96.517,
+      "ratio": 1.0239,
+      "suggested_scalar": 0.0122,
+      "log_bad": 4.5461,
+      "log_good": 4.5697
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5845,
+      "good": 0.7421,
+      "ratio": 1.2696,
+      "suggested_scalar": 0.1227,
+      "log_bad": -0.537,
+      "log_good": -0.2983
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 18.9275,
+      "good": 17.1815,
+      "ratio": 0.9078,
+      "suggested_scalar": -0.0497,
+      "log_bad": 2.9406,
+      "log_good": 2.8438
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1537.0,
+      "good": 2019.0,
+      "ratio": 1.3136,
+      "suggested_scalar": 0.1402,
+      "log_bad": 7.3376,
+      "log_good": 7.6104
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0408,
+      "good": 0.082,
+      "ratio": 2.0098,
+      "suggested_scalar": 0.3587,
+      "log_bad": -3.1991,
+      "log_good": -2.501
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.898,
+      "good": 0.7541,
+      "ratio": 0.8398,
+      "suggested_scalar": -0.0897,
+      "log_bad": -0.1076,
+      "log_good": -0.2822
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.3878,
+      "good": 8.3443,
+      "ratio": 1.1295,
+      "suggested_scalar": 0.0626,
+      "log_bad": 1.9998,
+      "log_good": 2.1216
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.5645,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.8992,
+      "good": 1.6361,
+      "ratio": 0.8615,
+      "suggested_scalar": -0.0766,
+      "log_bad": 0.6414,
+      "log_good": 0.4923
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 65.0,
+      "good": 93.0,
+      "ratio": 1.4308,
+      "suggested_scalar": 0.1841,
+      "log_bad": 4.1744,
+      "log_good": 4.5326
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9548,
+      "good": 0.9437,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.006,
+      "log_bad": -0.0463,
+      "log_good": -0.0579
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6025,
+      "good": 0.6731,
+      "ratio": 1.1172,
+      "suggested_scalar": 0.0569,
+      "log_bad": -0.5067,
+      "log_good": -0.3959
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.375,
+      "good": 0.572,
+      "ratio": 1.5253,
+      "suggested_scalar": 0.217,
+      "log_bad": -0.9808,
+      "log_good": -0.5586
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5155,
+      "good": 3.0591,
+      "ratio": 1.2161,
+      "suggested_scalar": 0.1005,
+      "log_bad": 0.9225,
+      "log_good": 1.1181
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 360.0,
+      "good": 507.0,
+      "ratio": 1.4083,
+      "suggested_scalar": 0.1759,
+      "log_bad": 5.8861,
+      "log_good": 6.2285
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 17.0,
+      "good": 19.0,
+      "ratio": 1.1176,
+      "suggested_scalar": 0.0572,
+      "log_bad": 2.8332,
+      "log_good": 2.9444
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0718,
+      "good": 0.0609,
+      "ratio": 0.8482,
+      "suggested_scalar": -0.0846,
+      "log_bad": -2.6339,
+      "log_good": -2.7985
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.9307,
+      "ratio": 0.9961,
+      "suggested_scalar": -0.002,
+      "log_bad": 1.7841,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 21.0,
+      "good": 34.0,
+      "ratio": 1.619,
+      "suggested_scalar": 0.2476,
+      "log_bad": 3.0445,
+      "log_good": 3.5264
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3814,
+      "good": 1.3809,
+      "ratio": 0.9996,
+      "suggested_scalar": -0.0002,
+      "log_bad": 0.3231,
+      "log_good": 0.3227
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6647,
+      "good": 5.6213,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.004,
+      "log_bad": 1.7343,
+      "log_good": 1.7266
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8238,
+      "good": 0.8337,
+      "ratio": 1.012,
+      "suggested_scalar": 0.0061,
+      "log_bad": -0.1938,
+      "log_good": -0.1819
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1552,
+      "good": 0.1644,
+      "ratio": 1.0593,
+      "suggested_scalar": 0.0296,
+      "log_bad": -1.863,
+      "log_good": -1.8055
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.3506,
+      "good": 4.1451,
+      "ratio": 0.9528,
+      "suggested_scalar": -0.0249,
+      "log_bad": 1.4703,
+      "log_good": 1.4219
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 288.0,
+      "good": 338.0,
+      "ratio": 1.1736,
+      "suggested_scalar": 0.0823,
+      "log_bad": 5.663,
+      "log_good": 5.823
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 19.0,
+      "good": 24.0,
+      "ratio": 1.2632,
+      "suggested_scalar": 0.12,
+      "log_bad": 2.9444,
+      "log_good": 3.1781
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6915,
+      "good": 0.9361,
+      "ratio": 1.3537,
+      "suggested_scalar": 0.1556,
+      "log_bad": -0.3689,
+      "log_good": -0.066
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 91.0,
+      "good": 90.0,
+      "ratio": 0.989,
+      "suggested_scalar": -0.0057,
+      "log_bad": 4.5109,
+      "log_good": 4.4998
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 804.0,
+      "good": 1066.0,
+      "ratio": 1.3259,
+      "suggested_scalar": 0.1449,
+      "log_bad": 6.6896,
+      "log_good": 6.9717
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 127.0,
+      "good": 165.0,
+      "ratio": 1.2992,
+      "suggested_scalar": 0.1345,
+      "log_bad": 4.8442,
+      "log_good": 5.1059
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2873,
+      "good": 0.2711,
+      "ratio": 0.9436,
+      "suggested_scalar": -0.0298,
+      "log_bad": -1.2472,
+      "log_good": -1.3053
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 78.0,
+      "good": 125.0,
+      "ratio": 1.6026,
+      "suggested_scalar": 0.2423,
+      "log_bad": 4.3567,
+      "log_good": 4.8283
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 91.0,
+      "good": 90.0,
+      "ratio": 0.989,
+      "suggested_scalar": -0.0057,
+      "log_bad": 4.5109,
+      "log_good": 4.4998
+    },
+    "brevity.mean_sample_size": {
+      "bad": 91.0,
+      "good": 90.0,
+      "ratio": 0.989,
+      "suggested_scalar": -0.0057,
+      "log_bad": 4.5109,
+      "log_good": 4.4998
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 362.0,
+      "good": 509.0,
+      "ratio": 1.4061,
+      "suggested_scalar": 0.1751,
+      "log_bad": 5.8916,
+      "log_good": 6.2324
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 205.0,
+      "good": 303.0,
+      "ratio": 1.478,
+      "suggested_scalar": 0.2008,
+      "log_bad": 5.323,
+      "log_good": 5.7137
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 228.0,
+      "good": 256.0,
+      "ratio": 1.1228,
+      "suggested_scalar": 0.0595,
+      "log_bad": 5.4293,
+      "log_good": 5.5452
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.7698,
+      "good": 2.3239,
+      "ratio": 1.3131,
+      "suggested_scalar": 0.14,
+      "log_bad": 0.5709,
+      "log_good": 0.8432
+    },
+    "halstead.mean_effort": {
+      "bad": 59282.4895,
+      "good": 106024.3826,
+      "ratio": 1.7885,
+      "suggested_scalar": 0.2987,
+      "log_bad": 10.9901,
+      "log_good": 11.5714
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8704,
+      "good": 0.8659,
+      "ratio": 0.9948,
+      "suggested_scalar": -0.0027,
+      "log_bad": -0.1388,
+      "log_good": -0.144
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 60.0,
+      "good": 59.0,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0086,
+      "log_bad": 4.0943,
+      "log_good": 4.0775
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 195.0,
+      "good": 272.0,
+      "ratio": 1.3949,
+      "suggested_scalar": 0.171,
+      "log_bad": 5.273,
+      "log_good": 5.6058
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5192,
+      "good": 0.381,
+      "ratio": 0.7338,
+      "suggested_scalar": -0.159,
+      "log_bad": -0.6555,
+      "log_good": -0.965
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.7308,
+      "good": 7.2517,
+      "ratio": 0.938,
+      "suggested_scalar": -0.0329,
+      "log_bad": 2.0452,
+      "log_good": 1.9812
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1552,
+      "good": 0.1644,
+      "ratio": 1.0593,
+      "suggested_scalar": 0.0296,
+      "log_bad": -1.863,
+      "log_good": -1.8055
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.0124,
+      "good": 4.8911,
+      "ratio": 0.8135,
+      "suggested_scalar": -0.1061,
+      "log_bad": 1.7938,
+      "log_good": 1.5874
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 361.0,
+      "good": 508.0,
+      "ratio": 1.4072,
+      "suggested_scalar": 0.1755,
+      "log_bad": 5.8889,
+      "log_good": 6.2305
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 6.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3562,
+      "log_bad": 1.0986,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 63.0,
+      "good": 121.0,
+      "ratio": 1.9206,
+      "suggested_scalar": 0.3354,
+      "log_bad": 4.1431,
+      "log_good": 4.7958
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3293.4716,
+      "good": 5890.2435,
+      "ratio": 1.7885,
+      "suggested_scalar": 0.2987,
+      "log_bad": 8.0997,
+      "log_good": 8.6811
+    },
+    "readability.mean_total_lines": {
+      "bad": 49.0,
+      "good": 61.0,
+      "ratio": 1.2449,
+      "suggested_scalar": 0.1126,
+      "log_bad": 3.8918,
+      "log_good": 4.1109
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2074.6278,
+      "good": 2808.2777,
+      "ratio": 1.3536,
+      "suggested_scalar": 0.1556,
+      "log_bad": 7.6375,
+      "log_good": 7.9403
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 611.0,
+      "good": 660.0,
+      "ratio": 1.0802,
+      "suggested_scalar": 0.0396,
+      "log_bad": 6.4151,
+      "log_good": 6.4922
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.1837,
+      "good": 31.9016,
+      "ratio": 1.0569,
+      "suggested_scalar": 0.0284,
+      "log_bad": 3.4073,
+      "log_good": 3.4627
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.242,
+      "good": 1.2039,
+      "ratio": 0.9693,
+      "suggested_scalar": -0.016,
+      "log_bad": 0.2167,
+      "log_good": 0.1856
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 12.0,
+      "good": 18.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.2083,
+      "log_bad": 2.4849,
+      "log_good": 2.8904
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7813,
+      "good": 0.642,
+      "ratio": 0.8217,
+      "suggested_scalar": -0.1009,
+      "log_bad": -0.2468,
+      "log_good": -0.4432
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9707,
+      "good": 0.9524,
+      "ratio": 0.9811,
+      "suggested_scalar": -0.0098,
+      "log_bad": -0.0297,
+      "log_good": -0.0488
+    },
+    "halstead.mean_length": {
+      "bad": 322.0,
+      "good": 437.0,
+      "ratio": 1.3571,
+      "suggested_scalar": 0.1569,
+      "log_bad": 5.7746,
+      "log_good": 6.0799
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0858,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5078,
+      "good": 6.4919,
+      "ratio": 0.9976,
+      "suggested_scalar": -0.0013,
+      "log_bad": 1.873,
+      "log_good": 1.8706
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1334,
+      "good": 0.1501,
+      "ratio": 1.1252,
+      "suggested_scalar": 0.0606,
+      "log_bad": -2.0144,
+      "log_good": -1.8965
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 28.575,
+      "good": 37.7542,
+      "ratio": 1.3212,
+      "suggested_scalar": 0.1431,
+      "log_bad": 3.3525,
+      "log_good": 3.6311
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 5.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.4708,
+      "log_bad": 0.6931,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 54.0,
+      "good": 56.0,
+      "ratio": 1.037,
+      "suggested_scalar": 0.0187,
+      "log_bad": 3.989,
+      "log_good": 4.0254
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6579,
+      "good": 0.5117,
+      "ratio": 0.7778,
+      "suggested_scalar": -0.1291,
+      "log_bad": -0.4187,
+      "log_good": -0.67
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 49.0,
+      "good": 61.0,
+      "ratio": 1.2449,
+      "suggested_scalar": 0.1126,
+      "log_bad": 3.8918,
+      "log_good": 4.1109
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 24.0,
+      "ratio": 1.2632,
+      "suggested_scalar": 0.12,
+      "log_bad": 2.9444,
+      "log_good": 3.1781
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_double_type_assertion": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 12.0,
+      "good": 18.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1093,
+      "log_bad": 2.4849,
+      "log_good": 2.8904
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 15.0,
+      "good": 13.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.0386,
+      "log_bad": 2.7081,
+      "log_good": 2.5649
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.009,
+      "good": 0.0676,
+      "ratio": 7.5111,
+      "suggested_scalar": 0.5436,
+      "log_bad": -4.7105,
+      "log_good": -2.6941
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8333,
+      "good": 0.8036,
+      "ratio": 0.9644,
+      "suggested_scalar": -0.0098,
+      "log_bad": -0.1824,
+      "log_good": -0.2187
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.009,
+      "good": 0.0676,
+      "ratio": 7.5111,
+      "suggested_scalar": 0.5436,
+      "log_bad": -4.7105,
+      "log_good": -2.6941
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6433,
+      "good": 4.7422,
+      "ratio": 1.0213,
+      "suggested_scalar": 0.0057,
+      "log_bad": 1.5354,
+      "log_good": 1.5565
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 60.0,
+      "good": 72.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0492,
+      "log_bad": 4.0943,
+      "log_good": 4.2767
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4118,
+      "good": 0.3071,
+      "ratio": 0.7458,
+      "suggested_scalar": -0.0791,
+      "log_bad": -0.8872,
+      "log_good": -1.1806
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 19.0,
+      "ratio": 1.1875,
+      "suggested_scalar": 0.0463,
+      "log_bad": 2.7726,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6774,
+      "good": 0.5189,
+      "ratio": 0.766,
+      "suggested_scalar": -0.0719,
+      "log_bad": -0.3895,
+      "log_good": -0.656
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0556,
+      "good": 2.6786,
+      "ratio": 2.5375,
+      "suggested_scalar": 0.251,
+      "log_bad": 0.0541,
+      "log_good": 0.9853
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 222.0,
+      "good": 444.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1869,
+      "log_bad": 5.4027,
+      "log_good": 6.0958
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 5.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.247,
+      "log_bad": 0.6931,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 0.0037,
+      "ratio": 0.0037,
+      "suggested_scalar": -1.5096,
+      "log_bad": 0.0,
+      "log_good": -5.5994
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1389,
+      "good": 1.0,
+      "ratio": 7.1994,
+      "suggested_scalar": 0.5322,
+      "log_bad": -1.974,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 0.0006,
+      "ratio": 0.0006,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -7.4186
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8575,
+      "good": 1.0935,
+      "ratio": 1.2752,
+      "suggested_scalar": 0.0655,
+      "log_bad": -0.1537,
+      "log_good": 0.0894
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 85.0,
+      "good": 116.0,
+      "ratio": 1.3647,
+      "suggested_scalar": 0.0838,
+      "log_bad": 4.4427,
+      "log_good": 4.7536
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 86.1966,
+      "good": 92.0538,
+      "ratio": 1.068,
+      "suggested_scalar": 0.0177,
+      "log_bad": 4.4566,
+      "log_good": 4.5224
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4615,
+      "good": 0.7359,
+      "ratio": 1.5946,
+      "suggested_scalar": 0.1258,
+      "log_bad": -0.7733,
+      "log_good": -0.3067
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 14.0352,
+      "good": 11.6096,
+      "ratio": 0.8272,
+      "suggested_scalar": -0.0512,
+      "log_bad": 2.6416,
+      "log_good": 2.4518
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1154.0,
+      "good": 1626.0,
+      "ratio": 1.409,
+      "suggested_scalar": 0.0924,
+      "log_bad": 7.051,
+      "log_good": 7.3939
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 0.1071,
+      "ratio": 0.1071,
+      "suggested_scalar": -0.6023,
+      "log_bad": 0.0,
+      "log_good": -2.234
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8333,
+      "good": 0.7679,
+      "ratio": 0.9215,
+      "suggested_scalar": -0.022,
+      "log_bad": -0.1824,
+      "log_good": -0.2641
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.1667,
+      "good": 7.9286,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.0678,
+      "log_bad": 1.8192,
+      "log_good": 2.0705
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.9969,
+      "good": 5.1824,
+      "ratio": 5.1985,
+      "suggested_scalar": 0.4444,
+      "log_bad": -0.0031,
+      "log_good": 1.6453
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 47.0,
+      "good": 72.0,
+      "ratio": 1.5319,
+      "suggested_scalar": 0.115,
+      "log_bad": 3.8501,
+      "log_good": 4.2767
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.8993,
+      "good": 0.9057,
+      "ratio": 1.0071,
+      "suggested_scalar": 0.0019,
+      "log_bad": -0.1061,
+      "log_good": -0.099
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 19.0,
+      "good": 28.0,
+      "ratio": 1.4737,
+      "suggested_scalar": 0.1045,
+      "log_bad": 2.9444,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6222,
+      "good": 0.6605,
+      "ratio": 1.0616,
+      "suggested_scalar": 0.0161,
+      "log_bad": -0.4745,
+      "log_good": -0.4148
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2409,
+      "good": 0.5792,
+      "ratio": 2.4043,
+      "suggested_scalar": 0.2365,
+      "log_bad": -1.4234,
+      "log_good": -0.5461
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6468,
+      "good": 2.9457,
+      "ratio": 1.1129,
+      "suggested_scalar": 0.0288,
+      "log_bad": 0.9734,
+      "log_good": 1.0803
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 220.0,
+      "good": 442.0,
+      "ratio": 2.0091,
+      "suggested_scalar": 0.1881,
+      "log_bad": 5.3936,
+      "log_good": 6.0913
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 7.0,
+      "good": 37.0,
+      "ratio": 5.2857,
+      "suggested_scalar": 0.4489,
+      "log_bad": 1.9459,
+      "log_good": 3.6109
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0586,
+      "good": 0.0428,
+      "ratio": 0.7304,
+      "suggested_scalar": -0.0847,
+      "log_bad": -2.837,
+      "log_good": -3.1512
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.6147,
+      "good": 5.7279,
+      "ratio": 1.0202,
+      "suggested_scalar": 0.0054,
+      "log_bad": 1.7254,
+      "log_good": 1.7453
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 26.0,
+      "good": 26.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2581,
+      "log_good": 3.2581
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3941,
+      "good": 1.3278,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0131,
+      "log_bad": 0.3322,
+      "log_good": 0.2835
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4041,
+      "good": 5.2069,
+      "ratio": 0.9635,
+      "suggested_scalar": -0.01,
+      "log_bad": 1.6872,
+      "log_good": 1.65
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.827,
+      "good": 0.8279,
+      "ratio": 1.0011,
+      "suggested_scalar": 0.0003,
+      "log_bad": -0.19,
+      "log_good": -0.1889
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1818,
+      "good": 0.1642,
+      "ratio": 0.9032,
+      "suggested_scalar": -0.0275,
+      "log_bad": -1.7048,
+      "log_good": -1.8067
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.7464,
+      "good": 3.4073,
+      "ratio": 0.9095,
+      "suggested_scalar": -0.0256,
+      "log_bad": 1.3208,
+      "log_good": 1.2259
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 186.0,
+      "good": 276.0,
+      "ratio": 1.4839,
+      "suggested_scalar": 0.1064,
+      "log_bad": 5.2257,
+      "log_good": 5.6204
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 8.0,
+      "good": 20.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.247,
+      "log_bad": 2.0794,
+      "log_good": 2.9957
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.4253,
+      "good": 0.7445,
+      "ratio": 1.7505,
+      "suggested_scalar": 0.151,
+      "log_bad": -0.855,
+      "log_good": -0.295
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 61.0,
+      "good": 66.0,
+      "ratio": 1.082,
+      "suggested_scalar": 0.0212,
+      "log_bad": 4.1109,
+      "log_good": 4.1897
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 664.0,
+      "good": 723.0,
+      "ratio": 1.0889,
+      "suggested_scalar": 0.0229,
+      "log_bad": 6.4983,
+      "log_good": 6.5834
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 102.0,
+      "good": 124.0,
+      "ratio": 1.2157,
+      "suggested_scalar": 0.0527,
+      "log_bad": 4.625,
+      "log_good": 4.8203
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.009,
+      "good": 1.0,
+      "ratio": 111.1111,
+      "suggested_scalar": 1.2699,
+      "log_bad": -4.7105,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2117,
+      "good": 0.2252,
+      "ratio": 1.0638,
+      "suggested_scalar": 0.0167,
+      "log_bad": -1.5526,
+      "log_good": -1.4908
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 34.0,
+      "good": 87.0,
+      "ratio": 2.5588,
+      "suggested_scalar": 0.2533,
+      "log_bad": 3.5264,
+      "log_good": 4.4659
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0602,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 61.0,
+      "good": 66.0,
+      "ratio": 1.082,
+      "suggested_scalar": 0.0212,
+      "log_bad": 4.1109,
+      "log_good": 4.1897
+    },
+    "brevity.mean_sample_size": {
+      "bad": 61.0,
+      "good": 66.0,
+      "ratio": 1.082,
+      "suggested_scalar": 0.0212,
+      "log_bad": 4.1109,
+      "log_good": 4.1897
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 222.0,
+      "good": 444.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1869,
+      "log_bad": 5.4027,
+      "log_good": 6.0958
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 97.0,
+      "good": 272.0,
+      "ratio": 2.8041,
+      "suggested_scalar": 0.278,
+      "log_bad": 4.5747,
+      "log_good": 5.6058
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 153.0,
+      "good": 204.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0776,
+      "log_bad": 5.0304,
+      "log_good": 5.3181
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.7504,
+      "good": 3.1566,
+      "ratio": 1.8034,
+      "suggested_scalar": 0.159,
+      "log_bad": 0.5598,
+      "log_good": 1.1495
+    },
+    "halstead.mean_effort": {
+      "bad": 30154.5324,
+      "good": 88122.2343,
+      "ratio": 2.9224,
+      "suggested_scalar": 0.2891,
+      "log_bad": 10.3141,
+      "log_good": 11.3865
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.9112,
+      "good": 0.8614,
+      "ratio": 0.9453,
+      "suggested_scalar": -0.0152,
+      "log_bad": -0.093,
+      "log_good": -0.1492
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 41.0,
+      "good": 44.0,
+      "ratio": 1.0732,
+      "suggested_scalar": 0.019,
+      "log_bad": 3.7136,
+      "log_good": 3.7842
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 114.0,
+      "good": 238.0,
+      "ratio": 2.0877,
+      "suggested_scalar": 0.1984,
+      "log_bad": 4.7362,
+      "log_good": 5.4723
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4118,
+      "good": 0.2672,
+      "ratio": 0.6489,
+      "suggested_scalar": -0.1166,
+      "log_bad": -0.8872,
+      "log_good": -1.3198
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.8118,
+      "good": 6.2328,
+      "ratio": 0.7979,
+      "suggested_scalar": -0.0609,
+      "log_bad": 2.0556,
+      "log_good": 1.8298
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1818,
+      "good": 0.1642,
+      "ratio": 0.9032,
+      "suggested_scalar": -0.0275,
+      "log_bad": -1.7048,
+      "log_good": -1.8067
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.6667,
+      "good": 5.2645,
+      "ratio": 0.929,
+      "suggested_scalar": -0.0198,
+      "log_bad": 1.7346,
+      "log_good": 1.661
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 221.0,
+      "good": 443.0,
+      "ratio": 2.0045,
+      "suggested_scalar": 0.1875,
+      "log_bad": 5.3982,
+      "log_good": 6.0936
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 19.0,
+      "good": 90.0,
+      "ratio": 4.7368,
+      "suggested_scalar": 0.4193,
+      "log_bad": 2.9444,
+      "log_good": 4.4998
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1675.2518,
+      "good": 4895.6797,
+      "ratio": 2.9224,
+      "suggested_scalar": 0.2891,
+      "log_bad": 7.4237,
+      "log_good": 8.4961
+    },
+    "readability.mean_total_lines": {
+      "bad": 36.0,
+      "good": 56.0,
+      "ratio": 1.5556,
+      "suggested_scalar": 0.1191,
+      "log_bad": 3.5835,
+      "log_good": 4.0254
+    },
+    "indentation.mean_max_depth": {
+      "bad": 2.0,
+      "good": 8.0,
+      "ratio": 4.0,
+      "suggested_scalar": 0.3737,
+      "log_bad": 0.6931,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 1275.8884,
+      "good": 2233.5129,
+      "ratio": 1.7506,
+      "suggested_scalar": 0.151,
+      "log_bad": 7.1514,
+      "log_good": 7.7113
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 436.0,
+      "good": 552.0,
+      "ratio": 1.2661,
+      "suggested_scalar": 0.0636,
+      "log_bad": 6.0776,
+      "log_good": 6.3135
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.8333,
+      "good": 27.8393,
+      "ratio": 0.9029,
+      "suggested_scalar": -0.0275,
+      "log_bad": 3.4286,
+      "log_good": 3.3264
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.352,
+      "good": 1.2616,
+      "ratio": 0.9331,
+      "suggested_scalar": -0.0187,
+      "log_bad": 0.3016,
+      "log_good": 0.2324
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 5.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.247,
+      "log_bad": 0.6931,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1869,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 1.0,
+      "ratio": 0.2,
+      "suggested_scalar": -0.4339,
+      "log_bad": 1.6094,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8978,
+      "good": 0.6739,
+      "ratio": 0.7506,
+      "suggested_scalar": -0.0773,
+      "log_bad": -0.1078,
+      "log_good": -0.3947
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9912,
+      "good": 0.9649,
+      "ratio": 0.9735,
+      "suggested_scalar": -0.0072,
+      "log_bad": -0.0088,
+      "log_good": -0.0357
+    },
+    "halstead.mean_length": {
+      "bad": 216.0,
+      "good": 362.0,
+      "ratio": 1.6759,
+      "suggested_scalar": 0.1392,
+      "log_bad": 5.3753,
+      "log_good": 5.8916
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.8,
+      "good": 13.0,
+      "ratio": 2.2414,
+      "suggested_scalar": 0.2176,
+      "log_bad": 1.7579,
+      "log_good": 2.5649
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.9307,
+      "good": 6.0444,
+      "ratio": 1.0192,
+      "suggested_scalar": 0.0051,
+      "log_bad": 1.7801,
+      "log_good": 1.7991
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0841,
+      "good": 0.1673,
+      "ratio": 1.9893,
+      "suggested_scalar": 0.1854,
+      "log_bad": -2.4757,
+      "log_good": -1.788
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 23.6341,
+      "good": 39.4545,
+      "ratio": 1.6694,
+      "suggested_scalar": 0.1382,
+      "log_bad": 3.1627,
+      "log_good": 3.6751
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 6.0,
+      "ratio": 6.0,
+      "suggested_scalar": 0.483,
+      "log_bad": 0.0,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 35.0,
+      "good": 31.0,
+      "ratio": 0.8857,
+      "suggested_scalar": -0.0327,
+      "log_bad": 3.5553,
+      "log_good": 3.434
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7778,
+      "good": 0.5735,
+      "ratio": 0.7373,
+      "suggested_scalar": -0.0821,
+      "log_bad": -0.2513,
+      "log_good": -0.556
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 36.0,
+      "good": 56.0,
+      "ratio": 1.5556,
+      "suggested_scalar": 0.1191,
+      "log_bad": 3.5835,
+      "log_good": 4.0254
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.call_site_forms_grammatical_phrase": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 39.0,
+      "good": 30.0,
+      "ratio": 0.7692,
+      "suggested_scalar": -0.5491,
+      "log_bad": 3.6636,
+      "log_good": 3.4012
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0099,
+      "good": 0.0098,
+      "ratio": 0.9899,
+      "suggested_scalar": -0.0212,
+      "log_bad": -4.6152,
+      "log_good": -4.6254
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8222,
+      "good": 0.8222,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1958,
+      "log_good": -0.1958
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0099,
+      "good": 0.0098,
+      "ratio": 0.9899,
+      "suggested_scalar": -0.0212,
+      "log_bad": -4.6152,
+      "log_good": -4.6254
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.802,
+      "good": 4.7271,
+      "ratio": 0.9844,
+      "suggested_scalar": -0.0329,
+      "log_bad": 1.569,
+      "log_good": 1.5533
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 89.0,
+      "good": 93.0,
+      "ratio": 1.0449,
+      "suggested_scalar": 0.092,
+      "log_bad": 4.4886,
+      "log_good": 4.5326
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3882,
+      "good": 0.4039,
+      "ratio": 1.0404,
+      "suggested_scalar": 0.083,
+      "log_bad": -0.9462,
+      "log_good": -0.9066
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5662,
+      "good": 0.5748,
+      "ratio": 1.0152,
+      "suggested_scalar": 0.0315,
+      "log_bad": -0.5688,
+      "log_good": -0.5537
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.1778,
+      "good": 4.1778,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.4298,
+      "log_good": 1.4298
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 405.0,
+      "good": 410.0,
+      "ratio": 1.0123,
+      "suggested_scalar": 0.0257,
+      "log_bad": 6.0039,
+      "log_good": 6.0162
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1333,
+      "good": 0.1333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.0152,
+      "log_good": -2.0152
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0016,
+      "good": 0.0016,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.4378,
+      "log_good": -6.4378
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0077,
+      "good": 0.9936,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0295,
+      "log_bad": 0.0077,
+      "log_good": -0.0064
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 137.0,
+      "good": 132.0,
+      "ratio": 0.9635,
+      "suggested_scalar": -0.0778,
+      "log_bad": 4.92,
+      "log_good": 4.8828
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 88.2458,
+      "good": 93.1085,
+      "ratio": 1.0551,
+      "suggested_scalar": 0.1123,
+      "log_bad": 4.4801,
+      "log_good": 4.5338
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5866,
+      "good": 0.5721,
+      "ratio": 0.9753,
+      "suggested_scalar": -0.0524,
+      "log_bad": -0.5334,
+      "log_good": -0.5584
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.2847,
+      "good": 7.996,
+      "ratio": 0.6019,
+      "suggested_scalar": -1.0625,
+      "log_bad": 2.5866,
+      "log_good": 2.0789
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1919.0,
+      "good": 1837.0,
+      "ratio": 0.9573,
+      "suggested_scalar": -0.0914,
+      "log_bad": 7.5596,
+      "log_good": 7.5159
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1111,
+      "good": 0.2889,
+      "ratio": 2.6004,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.1973,
+      "log_good": -1.2417
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8,
+      "good": 0.8,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2231,
+      "log_good": -0.2231
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.0,
+      "good": 9.1111,
+      "ratio": 1.0123,
+      "suggested_scalar": 0.0257,
+      "log_bad": 2.1972,
+      "log_good": 2.2095
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 6.3684,
+      "good": 6.3684,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8513,
+      "log_good": 1.8513
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 55.0,
+      "good": 59.0,
+      "ratio": 1.0727,
+      "suggested_scalar": 0.1469,
+      "log_bad": 4.0073,
+      "log_good": 4.0775
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9271,
+      "good": 0.9271,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0757,
+      "log_good": -0.0757
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 25.0,
+      "ratio": 1.1364,
+      "suggested_scalar": 0.2675,
+      "log_bad": 3.091,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.654,
+      "good": 0.6462,
+      "ratio": 0.9881,
+      "suggested_scalar": -0.0251,
+      "log_bad": -0.4246,
+      "log_good": -0.4366
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3821,
+      "good": 0.3701,
+      "ratio": 0.9686,
+      "suggested_scalar": -0.0668,
+      "log_bad": -0.9621,
+      "log_good": -0.994
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.8901,
+      "good": 2.8262,
+      "ratio": 0.9779,
+      "suggested_scalar": -0.0468,
+      "log_bad": 1.0613,
+      "log_good": 1.0389
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 403.0,
+      "good": 408.0,
+      "ratio": 1.0124,
+      "suggested_scalar": 0.0258,
+      "log_bad": 5.9989,
+      "log_good": 6.0113
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0864,
+      "good": 0.0829,
+      "ratio": 0.9595,
+      "suggested_scalar": -0.0865,
+      "log_bad": -2.4488,
+      "log_good": -2.4901
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 5.9069,
+      "ratio": 0.996,
+      "suggested_scalar": -0.0084,
+      "log_bad": 1.7801,
+      "log_good": 1.7761
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 40.0,
+      "good": 40.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6889,
+      "log_good": 3.6889
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.6839,
+      "good": 1.6511,
+      "ratio": 0.9805,
+      "suggested_scalar": -0.0412,
+      "log_bad": 0.5211,
+      "log_good": 0.5014
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7163,
+      "good": 5.787,
+      "ratio": 1.0124,
+      "suggested_scalar": 0.0257,
+      "log_bad": 1.7433,
+      "log_good": 1.7556
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8097,
+      "good": 0.8003,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0244,
+      "log_bad": -0.2111,
+      "log_good": -0.2228
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1964,
+      "good": 0.1964,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.6276,
+      "log_good": -1.6276
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6448,
+      "good": 2.8277,
+      "ratio": 0.7758,
+      "suggested_scalar": -0.5312,
+      "log_bad": 1.2933,
+      "log_good": 1.0395
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 299.0,
+      "good": 307.0,
+      "ratio": 1.0268,
+      "suggested_scalar": 0.0553,
+      "log_bad": 5.7004,
+      "log_good": 5.7268
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8224,
+      "good": 0.8414,
+      "ratio": 1.0231,
+      "suggested_scalar": 0.0478,
+      "log_bad": -0.1955,
+      "log_good": -0.1727
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 91.0,
+      "good": 95.0,
+      "ratio": 1.044,
+      "suggested_scalar": 0.09,
+      "log_bad": 4.5109,
+      "log_good": 4.5539
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1096.0,
+      "good": 963.0,
+      "ratio": 0.8786,
+      "suggested_scalar": -0.2707,
+      "log_bad": 6.9994,
+      "log_good": 6.8701
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 165.0,
+      "good": 162.0,
+      "ratio": 0.9818,
+      "suggested_scalar": -0.0384,
+      "log_bad": 5.1059,
+      "log_good": 5.0876
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0148,
+      "good": 0.0146,
+      "ratio": 0.9865,
+      "suggested_scalar": -0.0285,
+      "log_bad": -4.2131,
+      "log_good": -4.2267
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2568,
+      "good": 0.2512,
+      "ratio": 0.9782,
+      "suggested_scalar": -0.0461,
+      "log_bad": -1.3595,
+      "log_good": -1.3815
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 72.0,
+      "good": 72.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2767,
+      "log_good": 4.2767
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 91.0,
+      "good": 95.0,
+      "ratio": 1.044,
+      "suggested_scalar": 0.09,
+      "log_bad": 4.5109,
+      "log_good": 4.5539
+    },
+    "brevity.mean_sample_size": {
+      "bad": 91.0,
+      "good": 95.0,
+      "ratio": 1.044,
+      "suggested_scalar": 0.09,
+      "log_bad": 4.5109,
+      "log_good": 4.5539
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 405.0,
+      "good": 410.0,
+      "ratio": 1.0123,
+      "suggested_scalar": 0.0257,
+      "log_bad": 6.0039,
+      "log_good": 6.0162
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 221.0,
+      "good": 220.0,
+      "ratio": 0.9955,
+      "suggested_scalar": -0.0095,
+      "log_bad": 5.3982,
+      "log_good": 5.3936
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 239.0,
+      "good": 247.0,
+      "ratio": 1.0335,
+      "suggested_scalar": 0.0689,
+      "log_bad": 5.4765,
+      "log_good": 5.5094
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0049,
+      "good": 0.0049,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.3185,
+      "log_good": -5.3185
+    },
+    "heaps.mean_k": {
+      "bad": 3.449,
+      "good": 3.3438,
+      "ratio": 0.9695,
+      "suggested_scalar": -0.0648,
+      "log_bad": 1.2381,
+      "log_good": 1.2071
+    },
+    "halstead.mean_effort": {
+      "bad": 66836.818,
+      "good": 75166.6689,
+      "ratio": 1.1246,
+      "suggested_scalar": 0.2458,
+      "log_bad": 11.11,
+      "log_good": 11.2275
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8784,
+      "good": 0.8808,
+      "ratio": 1.0027,
+      "suggested_scalar": 0.0057,
+      "log_bad": -0.1297,
+      "log_good": -0.1269
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 67.0,
+      "good": 68.0,
+      "ratio": 1.0149,
+      "suggested_scalar": 0.031,
+      "log_bad": 4.2047,
+      "log_good": 4.2195
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 216.0,
+      "good": 224.0,
+      "ratio": 1.037,
+      "suggested_scalar": 0.0761,
+      "log_bad": 5.3753,
+      "log_good": 5.4116
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3796,
+      "good": 0.3939,
+      "ratio": 1.0377,
+      "suggested_scalar": 0.0774,
+      "log_bad": -0.9686,
+      "log_good": -0.9317
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.0,
+      "good": 7.2955,
+      "ratio": 0.9119,
+      "suggested_scalar": -0.1929,
+      "log_bad": 2.0794,
+      "log_good": 1.9873
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1964,
+      "good": 0.1964,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.6276,
+      "log_good": -1.6276
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.6,
+      "good": 3.6444,
+      "ratio": 1.0123,
+      "suggested_scalar": 0.0257,
+      "log_bad": 1.2809,
+      "log_good": 1.2932
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 404.0,
+      "good": 409.0,
+      "ratio": 1.0124,
+      "suggested_scalar": 0.0257,
+      "log_bad": 6.0014,
+      "log_good": 6.0137
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 50.0,
+      "good": 50.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.912,
+      "log_good": 3.912
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3713.1566,
+      "good": 4175.926,
+      "ratio": 1.1246,
+      "suggested_scalar": 0.2458,
+      "log_bad": 8.2196,
+      "log_good": 8.3371
+    },
+    "readability.mean_total_lines": {
+      "bad": 45.0,
+      "good": 45.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8067,
+      "log_good": 3.8067
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2467.2544,
+      "good": 2524.1153,
+      "ratio": 1.023,
+      "suggested_scalar": 0.0477,
+      "log_bad": 7.8109,
+      "log_good": 7.8336
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 664.0,
+      "good": 650.0,
+      "ratio": 0.9789,
+      "suggested_scalar": -0.0446,
+      "log_bad": 6.4983,
+      "log_good": 6.477
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 41.4,
+      "good": 39.5778,
+      "ratio": 0.956,
+      "suggested_scalar": -0.0942,
+      "log_bad": 3.7233,
+      "log_good": 3.6783
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2938,
+      "good": 1.235,
+      "ratio": 0.9546,
+      "suggested_scalar": -0.0973,
+      "log_bad": 0.2576,
+      "log_good": 0.2111
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8328,
+      "good": 0.8371,
+      "ratio": 1.0052,
+      "suggested_scalar": 0.0108,
+      "log_bad": -0.183,
+      "log_good": -0.1778
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9635,
+      "good": 0.9684,
+      "ratio": 1.0051,
+      "suggested_scalar": 0.0106,
+      "log_bad": -0.0372,
+      "log_good": -0.0321
+    },
+    "halstead.mean_length": {
+      "bad": 381.0,
+      "good": 386.0,
+      "ratio": 1.0131,
+      "suggested_scalar": 0.0273,
+      "log_bad": 5.9428,
+      "log_good": 5.9558
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.3333,
+      "good": 5.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.674,
+      "log_good": 1.674
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5078,
+      "good": 6.5699,
+      "ratio": 1.0095,
+      "suggested_scalar": 0.0199,
+      "log_bad": 1.873,
+      "log_good": 1.8825
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1152,
+      "good": 0.1198,
+      "ratio": 1.0399,
+      "suggested_scalar": 0.0819,
+      "log_bad": -2.1611,
+      "log_good": -2.1219
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.0896,
+      "good": 29.7794,
+      "ratio": 1.0993,
+      "suggested_scalar": 0.1981,
+      "log_bad": 3.2991,
+      "log_good": 3.3938
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 13.0,
+      "ratio": 2.6,
+      "suggested_scalar": 1.9997,
+      "log_bad": 1.6094,
+      "log_good": 2.5649
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 52.0,
+      "good": 52.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9512,
+      "log_good": 3.9512
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6987,
+      "good": 0.7085,
+      "ratio": 1.014,
+      "suggested_scalar": 0.0291,
+      "log_bad": -0.3585,
+      "log_good": -0.3446
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 45.0,
+      "good": 45.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8067,
+      "log_good": 3.8067
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 14.0,
+      "ratio": 0.7368,
+      "suggested_scalar": -0.6391,
+      "log_bad": 2.9444,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.no_magic_numbers": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 15.0,
+      "good": 21.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.2708,
+      "log_bad": 2.7081,
+      "log_good": 3.0445
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0123,
+      "good": 0.0086,
+      "ratio": 0.6992,
+      "suggested_scalar": -0.288,
+      "log_bad": -4.3982,
+      "log_good": -4.756
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.72,
+      "good": 0.9545,
+      "ratio": 1.3257,
+      "suggested_scalar": 0.2269,
+      "log_bad": -0.3285,
+      "log_good": -0.0466
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0123,
+      "good": 0.0086,
+      "ratio": 0.6992,
+      "suggested_scalar": -0.288,
+      "log_bad": -4.3982,
+      "log_good": -4.756
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4371,
+      "good": 4.8169,
+      "ratio": 1.0856,
+      "suggested_scalar": 0.0661,
+      "log_bad": 1.49,
+      "log_good": 1.5721
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 66.0,
+      "good": 79.0,
+      "ratio": 1.197,
+      "suggested_scalar": 0.1447,
+      "log_bad": 4.1897,
+      "log_good": 4.3694
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3692,
+      "good": 0.3717,
+      "ratio": 1.0068,
+      "suggested_scalar": 0.0054,
+      "log_bad": -0.9964,
+      "log_good": -0.9897
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 12.0,
+      "good": 13.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.0644,
+      "log_bad": 2.4849,
+      "log_good": 2.5649
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6459,
+      "good": 0.5614,
+      "ratio": 0.8692,
+      "suggested_scalar": -0.1129,
+      "log_bad": -0.4371,
+      "log_good": -0.5773
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.8,
+      "good": 2.4545,
+      "ratio": 0.6459,
+      "suggested_scalar": -0.3518,
+      "log_bad": 1.335,
+      "log_good": 0.8979
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 244.0,
+      "good": 347.0,
+      "ratio": 1.4221,
+      "suggested_scalar": 0.2834,
+      "log_bad": 5.4972,
+      "log_good": 5.8493
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.032,
+      "good": 1.0532,
+      "ratio": 1.0205,
+      "suggested_scalar": 0.0164,
+      "log_bad": 0.0315,
+      "log_good": 0.0518
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 65.0,
+      "good": 105.0,
+      "ratio": 1.6154,
+      "suggested_scalar": 0.386,
+      "log_bad": 4.1744,
+      "log_good": 4.654
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 107.5491,
+      "good": 66.9211,
+      "ratio": 0.6222,
+      "suggested_scalar": -0.3819,
+      "log_bad": 4.6779,
+      "log_good": 4.2035
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5844,
+      "good": 0.7081,
+      "ratio": 1.2117,
+      "suggested_scalar": 0.1545,
+      "log_bad": -0.5372,
+      "log_good": -0.3452
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 18.7233,
+      "good": 49.5615,
+      "ratio": 2.647,
+      "suggested_scalar": 0.7835,
+      "log_bad": 2.9298,
+      "log_good": 3.9032
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1120.0,
+      "good": 1801.0,
+      "ratio": 1.608,
+      "suggested_scalar": 0.3823,
+      "log_bad": 7.0211,
+      "log_good": 7.4961
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.14,
+      "good": 0.1136,
+      "ratio": 0.8114,
+      "suggested_scalar": -0.1682,
+      "log_bad": -1.9661,
+      "log_good": -2.1751
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.68,
+      "good": 0.9091,
+      "ratio": 1.3369,
+      "suggested_scalar": 0.2337,
+      "log_bad": -0.3857,
+      "log_good": -0.0953
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 4.88,
+      "good": 7.8864,
+      "ratio": 1.6161,
+      "suggested_scalar": 0.3863,
+      "log_bad": 1.5851,
+      "log_good": 2.0651
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.24,
+      "good": 1.7934,
+      "ratio": 0.5535,
+      "suggested_scalar": -0.476,
+      "log_bad": 1.1756,
+      "log_good": 0.5841
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 58.0,
+      "good": 98.0,
+      "ratio": 1.6897,
+      "suggested_scalar": 0.4222,
+      "log_bad": 4.0604,
+      "log_good": 4.585
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9025,
+      "good": 0.9392,
+      "ratio": 1.0407,
+      "suggested_scalar": 0.0321,
+      "log_bad": -0.1026,
+      "log_good": -0.0627
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 20.0,
+      "good": 19.0,
+      "ratio": 0.95,
+      "suggested_scalar": -0.0413,
+      "log_bad": 2.9957,
+      "log_good": 2.9444
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6723,
+      "good": 0.7229,
+      "ratio": 1.0753,
+      "suggested_scalar": 0.0584,
+      "log_bad": -0.3971,
+      "log_good": -0.3245
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4132,
+      "good": 0.4957,
+      "ratio": 1.1997,
+      "suggested_scalar": 0.1465,
+      "log_bad": -0.8838,
+      "log_good": -0.7018
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0518,
+      "good": 3.6092,
+      "ratio": 1.1826,
+      "suggested_scalar": 0.135,
+      "log_bad": 1.1157,
+      "log_good": 1.2835
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 242.0,
+      "good": 345.0,
+      "ratio": 1.4256,
+      "suggested_scalar": 0.2854,
+      "log_bad": 5.4889,
+      "log_good": 5.8435
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0041,
+      "good": 0.0461,
+      "ratio": 11.2439,
+      "suggested_scalar": 1.9476,
+      "log_bad": -5.4968,
+      "log_good": -3.0769
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7549,
+      "good": 5.7814,
+      "ratio": 1.0046,
+      "suggested_scalar": 0.0037,
+      "log_bad": 1.7501,
+      "log_good": 1.7546
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.599,
+      "good": 0.419,
+      "ratio": 0.6995,
+      "suggested_scalar": -0.2876,
+      "log_bad": -0.5125,
+      "log_good": -0.8699
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.0569,
+      "good": 5.1507,
+      "ratio": 1.0185,
+      "suggested_scalar": 0.0148,
+      "log_bad": 1.6208,
+      "log_good": 1.6391
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.771,
+      "good": 0.8332,
+      "ratio": 1.0807,
+      "suggested_scalar": 0.0624,
+      "log_bad": -0.2601,
+      "log_good": -0.1825
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1379,
+      "good": 0.1852,
+      "ratio": 1.343,
+      "suggested_scalar": 0.2374,
+      "log_bad": -1.9812,
+      "log_good": -1.6863
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.327,
+      "good": 7.04,
+      "ratio": 1.627,
+      "suggested_scalar": 0.3918,
+      "log_bad": 1.4649,
+      "log_good": 1.9516
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 171.0,
+      "good": 215.0,
+      "ratio": 1.2573,
+      "suggested_scalar": 0.1843,
+      "log_bad": 5.1417,
+      "log_good": 5.3706
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 12.0,
+      "ratio": 12.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 2.4849
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.4674,
+      "good": 0.6535,
+      "ratio": 1.3982,
+      "suggested_scalar": 0.2698,
+      "log_bad": -0.7606,
+      "log_good": -0.4254
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 67.0,
+      "good": 81.0,
+      "ratio": 1.209,
+      "suggested_scalar": 0.1527,
+      "log_bad": 4.2047,
+      "log_good": 4.3944
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 437.0,
+      "good": 1118.0,
+      "ratio": 2.5584,
+      "suggested_scalar": 0.7561,
+      "log_bad": 6.0799,
+      "log_good": 7.0193
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 90.0,
+      "good": 130.0,
+      "ratio": 1.4444,
+      "suggested_scalar": 0.296,
+      "log_bad": 4.4998,
+      "log_good": 4.8675
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0492,
+      "good": 0.0115,
+      "ratio": 0.2337,
+      "suggested_scalar": -1.1699,
+      "log_bad": -3.0119,
+      "log_good": -4.4654
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1352,
+      "good": 0.2075,
+      "ratio": 1.5348,
+      "suggested_scalar": 0.3448,
+      "log_bad": -2.001,
+      "log_good": -1.5726
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 32.0,
+      "good": 58.0,
+      "ratio": 1.8125,
+      "suggested_scalar": 0.4787,
+      "log_bad": 3.4657,
+      "log_good": 4.0604
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 9.0,
+      "good": 15.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.4111,
+      "log_bad": 2.1972,
+      "log_good": 2.7081
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 67.0,
+      "good": 81.0,
+      "ratio": 1.209,
+      "suggested_scalar": 0.1527,
+      "log_bad": 4.2047,
+      "log_good": 4.3944
+    },
+    "brevity.mean_sample_size": {
+      "bad": 67.0,
+      "good": 81.0,
+      "ratio": 1.209,
+      "suggested_scalar": 0.1527,
+      "log_bad": 4.2047,
+      "log_good": 4.3944
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 244.0,
+      "good": 347.0,
+      "ratio": 1.4221,
+      "suggested_scalar": 0.2834,
+      "log_bad": 5.4972,
+      "log_good": 5.8493
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 117.0,
+      "good": 181.0,
+      "ratio": 1.547,
+      "suggested_scalar": 0.3512,
+      "log_bad": 4.7622,
+      "log_good": 5.1985
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 133.0,
+      "good": 159.0,
+      "ratio": 1.1955,
+      "suggested_scalar": 0.1437,
+      "log_bad": 4.8903,
+      "log_good": 5.0689
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0779,
+      "good": 0.0548,
+      "ratio": 0.7035,
+      "suggested_scalar": -0.2831,
+      "log_bad": -2.5523,
+      "log_good": -2.9041
+    },
+    "heaps.mean_k": {
+      "bad": 1.7617,
+      "good": 3.3766,
+      "ratio": 1.9167,
+      "suggested_scalar": 0.5236,
+      "log_bad": 0.5663,
+      "log_good": 1.2169
+    },
+    "halstead.mean_effort": {
+      "bad": 27436.2933,
+      "good": 40353.1271,
+      "ratio": 1.4708,
+      "suggested_scalar": 0.3105,
+      "log_bad": 10.2196,
+      "log_good": 10.6054
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8336,
+      "good": 0.8124,
+      "ratio": 0.9746,
+      "suggested_scalar": -0.0207,
+      "log_bad": -0.182,
+      "log_good": -0.2078
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 46.0,
+      "good": 60.0,
+      "ratio": 1.3043,
+      "suggested_scalar": 0.2139,
+      "log_bad": 3.8286,
+      "log_good": 4.0943
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 142.0,
+      "good": 181.0,
+      "ratio": 1.2746,
+      "suggested_scalar": 0.1953,
+      "log_bad": 4.9558,
+      "log_good": 5.1985
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3692,
+      "good": 0.3619,
+      "ratio": 0.9802,
+      "suggested_scalar": -0.0161,
+      "log_bad": -0.9964,
+      "log_good": -1.0164
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.7231,
+      "good": 10.6476,
+      "ratio": 1.5837,
+      "suggested_scalar": 0.3701,
+      "log_bad": 1.9055,
+      "log_good": 2.3653
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1379,
+      "good": 0.1852,
+      "ratio": 1.343,
+      "suggested_scalar": 0.2374,
+      "log_bad": -1.9812,
+      "log_good": -1.6863
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.66,
+      "good": 9.9967,
+      "ratio": 3.7582,
+      "suggested_scalar": 1.0656,
+      "log_bad": 0.9783,
+      "log_good": 2.3023
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 243.0,
+      "good": 346.0,
+      "ratio": 1.4239,
+      "suggested_scalar": 0.2844,
+      "log_bad": 5.4931,
+      "log_good": 5.8464
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 29.0,
+      "good": 41.0,
+      "ratio": 1.4138,
+      "suggested_scalar": 0.2787,
+      "log_bad": 3.3673,
+      "log_good": 3.7136
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1524.2385,
+      "good": 2241.8404,
+      "ratio": 1.4708,
+      "suggested_scalar": 0.3105,
+      "log_bad": 7.3293,
+      "log_good": 7.7151
+    },
+    "readability.mean_total_lines": {
+      "bad": 50.0,
+      "good": 44.0,
+      "ratio": 0.88,
+      "suggested_scalar": -0.1029,
+      "log_bad": 3.912,
+      "log_good": 3.7842
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 1402.2994,
+      "good": 1960.4758,
+      "ratio": 1.398,
+      "suggested_scalar": 0.2697,
+      "log_bad": 7.2459,
+      "log_good": 7.5809
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 367.0,
+      "good": 499.0,
+      "ratio": 1.3597,
+      "suggested_scalar": 0.2473,
+      "log_bad": 5.9054,
+      "log_good": 6.2126
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 21.24,
+      "good": 39.7045,
+      "ratio": 1.8693,
+      "suggested_scalar": 0.5035,
+      "log_bad": 3.0559,
+      "log_good": 3.6815
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.115,
+      "good": 1.5592,
+      "ratio": 1.3984,
+      "suggested_scalar": 0.2699,
+      "log_bad": 0.1089,
+      "log_good": 0.4442
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8304,
+      "good": 0.8093,
+      "ratio": 0.9746,
+      "suggested_scalar": -0.0207,
+      "log_bad": -0.1858,
+      "log_good": -0.2116
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9649,
+      "good": 0.9347,
+      "ratio": 0.9687,
+      "suggested_scalar": -0.0256,
+      "log_bad": -0.0357,
+      "log_good": -0.0675
+    },
+    "halstead.mean_length": {
+      "bad": 232.0,
+      "good": 311.0,
+      "ratio": 1.3405,
+      "suggested_scalar": 0.2359,
+      "log_bad": 5.4467,
+      "log_good": 5.7398
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.3333,
+      "good": 2.1333,
+      "ratio": 0.3368,
+      "suggested_scalar": -0.8758,
+      "log_bad": 1.8458,
+      "log_good": 0.7577
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.0661,
+      "good": 6.3399,
+      "ratio": 1.0451,
+      "suggested_scalar": 0.0355,
+      "log_bad": 1.8027,
+      "log_good": 1.8469
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1045,
+      "good": 0.1005,
+      "ratio": 0.9617,
+      "suggested_scalar": -0.0314,
+      "log_bad": -2.2586,
+      "log_good": -2.2976
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 19.5652,
+      "good": 20.5833,
+      "ratio": 1.052,
+      "suggested_scalar": 0.0408,
+      "log_bad": 2.9738,
+      "log_good": 3.0245
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.2708,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 24.0,
+      "good": 38.0,
+      "ratio": 1.5833,
+      "suggested_scalar": 0.3699,
+      "log_bad": 3.1781,
+      "log_good": 3.6376
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7594,
+      "good": 0.6352,
+      "ratio": 0.8364,
+      "suggested_scalar": -0.1437,
+      "log_bad": -0.2752,
+      "log_good": -0.4538
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 50.0,
+      "good": 44.0,
+      "ratio": 0.88,
+      "suggested_scalar": -0.1029,
+      "log_bad": 3.912,
+      "log_good": 3.7842
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 23.0,
+      "good": 26.0,
+      "ratio": 1.1304,
+      "suggested_scalar": 0.0987,
+      "log_bad": 3.1355,
+      "log_good": 3.2581
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_nested_method_definition": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 16.0,
+      "good": 21.0,
+      "ratio": 1.3125,
+      "suggested_scalar": 0.0998,
+      "log_bad": 2.7726,
+      "log_good": 3.0445
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 0.0043,
+      "ratio": 0.0043,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.4491
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.4,
+      "good": 1.2857,
+      "ratio": 0.9184,
+      "suggested_scalar": -0.0313,
+      "log_bad": 0.3365,
+      "log_good": 0.2513
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9063,
+      "good": 0.8421,
+      "ratio": 0.9292,
+      "suggested_scalar": -0.027,
+      "log_bad": -0.0984,
+      "log_good": -0.1719
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 0.0043,
+      "ratio": 0.0043,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.4491
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5907,
+      "good": 4.6342,
+      "ratio": 1.0095,
+      "suggested_scalar": 0.0035,
+      "log_bad": 1.524,
+      "log_good": 1.5335
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 80.0,
+      "good": 66.0,
+      "ratio": 0.825,
+      "suggested_scalar": -0.0706,
+      "log_bad": 4.382,
+      "log_good": 4.1897
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5977,
+      "good": 0.4944,
+      "ratio": 0.8272,
+      "suggested_scalar": -0.0696,
+      "log_bad": -0.5147,
+      "log_good": -0.7044
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7956,
+      "good": 0.7154,
+      "ratio": 0.8992,
+      "suggested_scalar": -0.039,
+      "log_bad": -0.2287,
+      "log_good": -0.3349
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.125,
+      "good": 3.0526,
+      "ratio": 0.74,
+      "suggested_scalar": -0.1105,
+      "log_bad": 1.4171,
+      "log_good": 1.116
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 208.0,
+      "good": 231.0,
+      "ratio": 1.1106,
+      "suggested_scalar": 0.0385,
+      "log_bad": 5.3375,
+      "log_good": 5.4424
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2544,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0009,
+      "good": 0.0008,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0432,
+      "log_bad": -7.0131,
+      "log_good": -7.1309
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0625,
+      "good": 1.0,
+      "ratio": 16.0,
+      "suggested_scalar": 1.0176,
+      "log_bad": -2.7726,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0034,
+      "good": 0.003,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.0459,
+      "log_bad": -5.684,
+      "log_good": -5.8091
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8047,
+      "good": 0.9092,
+      "ratio": 1.1299,
+      "suggested_scalar": 0.0448,
+      "log_bad": -0.2173,
+      "log_good": -0.0952
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 87.0,
+      "good": 89.0,
+      "ratio": 1.023,
+      "suggested_scalar": 0.0083,
+      "log_bad": 4.4659,
+      "log_good": 4.4886
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 96.4809,
+      "good": 94.1856,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0088,
+      "log_bad": 4.5693,
+      "log_good": 4.5453
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.2995,
+      "good": 0.387,
+      "ratio": 1.2922,
+      "suggested_scalar": 0.0941,
+      "log_bad": -1.2056,
+      "log_good": -0.9493
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 23.9929,
+      "good": 21.0607,
+      "ratio": 0.8778,
+      "suggested_scalar": -0.0478,
+      "log_bad": 3.1778,
+      "log_good": 3.0474
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1163.0,
+      "good": 1312.0,
+      "ratio": 1.1281,
+      "suggested_scalar": 0.0442,
+      "log_bad": 7.0588,
+      "log_good": 7.1793
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0938,
+      "good": 0.1053,
+      "ratio": 1.1226,
+      "suggested_scalar": 0.0424,
+      "log_bad": -2.3666,
+      "log_good": -2.2509
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8438,
+      "good": 0.8158,
+      "ratio": 0.9668,
+      "suggested_scalar": -0.0124,
+      "log_bad": -0.1698,
+      "log_good": -0.2036
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.9333,
+      "good": 6.0789,
+      "ratio": 0.8768,
+      "suggested_scalar": -0.0483,
+      "log_bad": 1.9363,
+      "log_good": 1.8048
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.2344,
+      "good": 1.8393,
+      "ratio": 0.5687,
+      "suggested_scalar": -0.2072,
+      "log_bad": 1.1738,
+      "log_good": 0.6094
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 79.0,
+      "good": 84.0,
+      "ratio": 1.0633,
+      "suggested_scalar": 0.0225,
+      "log_bad": 4.3694,
+      "log_good": 4.4308
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.934,
+      "good": 0.9432,
+      "ratio": 1.0099,
+      "suggested_scalar": 0.0036,
+      "log_bad": -0.0683,
+      "log_good": -0.0585
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 21.0,
+      "ratio": 0.84,
+      "suggested_scalar": -0.064,
+      "log_bad": 3.2189,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5469,
+      "good": 0.6098,
+      "ratio": 1.115,
+      "suggested_scalar": 0.04,
+      "log_bad": -0.6035,
+      "log_good": -0.4946
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.0874,
+      "good": 0.1878,
+      "ratio": 2.1487,
+      "suggested_scalar": 0.2807,
+      "log_bad": -2.4373,
+      "log_good": -1.6724
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2068,
+      "good": 2.5625,
+      "ratio": 1.1612,
+      "suggested_scalar": 0.0548,
+      "log_bad": 0.7915,
+      "log_good": 0.941
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 206.0,
+      "good": 229.0,
+      "ratio": 1.1117,
+      "suggested_scalar": 0.0388,
+      "log_bad": 5.3279,
+      "log_good": 5.4337
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 16.0,
+      "good": 14.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.049,
+      "log_bad": 2.7726,
+      "log_good": 2.6391
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0433,
+      "good": 0.0433,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.1396,
+      "log_good": -3.1396
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.7279,
+      "ratio": 0.982,
+      "suggested_scalar": -0.0067,
+      "log_bad": 1.7635,
+      "log_good": 1.7453
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 8.0,
+      "good": 5.0,
+      "ratio": 0.625,
+      "suggested_scalar": -0.1725,
+      "log_bad": 2.0794,
+      "log_good": 1.6094
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.443,
+      "good": 0.3121,
+      "ratio": 0.7045,
+      "suggested_scalar": -0.1286,
+      "log_bad": -0.8142,
+      "log_good": -1.1644
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7311,
+      "good": 5.412,
+      "ratio": 0.9443,
+      "suggested_scalar": -0.021,
+      "log_bad": 1.7459,
+      "log_good": 1.6886
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.787,
+      "good": 0.8091,
+      "ratio": 1.0281,
+      "suggested_scalar": 0.0102,
+      "log_bad": -0.2395,
+      "log_good": -0.2118
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1795,
+      "good": 0.2083,
+      "ratio": 1.1604,
+      "suggested_scalar": 0.0546,
+      "log_bad": -1.7176,
+      "log_good": -1.5688
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.8983,
+      "good": 4.5892,
+      "ratio": 0.9369,
+      "suggested_scalar": -0.0239,
+      "log_bad": 1.5889,
+      "log_good": 1.5237
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 195.0,
+      "good": 203.0,
+      "ratio": 1.041,
+      "suggested_scalar": 0.0148,
+      "log_bad": 5.273,
+      "log_good": 5.3132
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.4032,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.4151,
+      "good": 0.4251,
+      "ratio": 1.0241,
+      "suggested_scalar": 0.0087,
+      "log_bad": -0.8792,
+      "log_good": -0.8554
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 83.0,
+      "good": 73.0,
+      "ratio": 0.8795,
+      "suggested_scalar": -0.0471,
+      "log_bad": 4.4188,
+      "log_good": 4.2905
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 720.0,
+      "good": 864.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0669,
+      "log_bad": 6.5793,
+      "log_good": 6.7616
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 92.0,
+      "good": 89.0,
+      "ratio": 0.9674,
+      "suggested_scalar": -0.0122,
+      "log_bad": 4.5218,
+      "log_good": 4.4886
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0048,
+      "good": 0.0043,
+      "ratio": 0.8958,
+      "suggested_scalar": -0.0404,
+      "log_bad": -5.3391,
+      "log_good": -5.4491
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2885,
+      "good": 0.3117,
+      "ratio": 1.0804,
+      "suggested_scalar": 0.0284,
+      "log_bad": -1.2431,
+      "log_good": -1.1657
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 22.0,
+      "good": 28.0,
+      "ratio": 1.2727,
+      "suggested_scalar": 0.0885,
+      "log_bad": 3.091,
+      "log_good": 3.3322
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 7.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.1235,
+      "log_bad": 1.6094,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 83.0,
+      "good": 73.0,
+      "ratio": 0.8795,
+      "suggested_scalar": -0.0471,
+      "log_bad": 4.4188,
+      "log_good": 4.2905
+    },
+    "brevity.mean_sample_size": {
+      "bad": 83.0,
+      "good": 73.0,
+      "ratio": 0.8795,
+      "suggested_scalar": -0.0471,
+      "log_bad": 4.4188,
+      "log_good": 4.2905
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 208.0,
+      "good": 231.0,
+      "ratio": 1.1106,
+      "suggested_scalar": 0.0385,
+      "log_bad": 5.3375,
+      "log_good": 5.4424
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 94.0,
+      "good": 114.0,
+      "ratio": 1.2128,
+      "suggested_scalar": 0.0708,
+      "log_bad": 4.5433,
+      "log_good": 4.7362
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 167.0,
+      "good": 169.0,
+      "ratio": 1.012,
+      "suggested_scalar": 0.0044,
+      "log_bad": 5.118,
+      "log_good": 5.1299
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0048,
+      "good": 0.0043,
+      "ratio": 0.8958,
+      "suggested_scalar": -0.0404,
+      "log_bad": -5.3391,
+      "log_good": -5.4491
+    },
+    "heaps.mean_k": {
+      "bad": 1.3531,
+      "good": 1.5475,
+      "ratio": 1.1437,
+      "suggested_scalar": 0.0493,
+      "log_bad": 0.3024,
+      "log_good": 0.4366
+    },
+    "halstead.mean_effort": {
+      "bad": 26040.5965,
+      "good": 26485.1247,
+      "ratio": 1.0171,
+      "suggested_scalar": 0.0062,
+      "log_bad": 10.1674,
+      "log_good": 10.1843
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.899,
+      "good": 0.8743,
+      "ratio": 0.9725,
+      "suggested_scalar": -0.0102,
+      "log_bad": -0.1065,
+      "log_good": -0.1343
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 55.0,
+      "good": 45.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.0737,
+      "log_bad": 4.0073,
+      "log_good": 3.8067
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 105.0,
+      "good": 122.0,
+      "ratio": 1.1619,
+      "suggested_scalar": 0.0551,
+      "log_bad": 4.654,
+      "log_good": 4.804
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5977,
+      "good": 0.4944,
+      "ratio": 0.8272,
+      "suggested_scalar": -0.0696,
+      "log_bad": -0.5147,
+      "log_good": -0.7044
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.2759,
+      "good": 9.7079,
+      "ratio": 1.173,
+      "suggested_scalar": 0.0586,
+      "log_bad": 2.1133,
+      "log_good": 2.2729
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1795,
+      "good": 0.2083,
+      "ratio": 1.1604,
+      "suggested_scalar": 0.0546,
+      "log_bad": -1.7176,
+      "log_good": -1.5688
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.5432,
+      "good": 4.1557,
+      "ratio": 0.9147,
+      "suggested_scalar": -0.0327,
+      "log_bad": 1.5136,
+      "log_good": 1.4245
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 207.0,
+      "good": 230.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0387,
+      "log_bad": 5.3327,
+      "log_good": 5.4381
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.1875,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 7.0,
+      "good": 17.0,
+      "ratio": 2.4286,
+      "suggested_scalar": 0.3257,
+      "log_bad": 1.9459,
+      "log_good": 2.8332
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1446.6998,
+      "good": 1471.3958,
+      "ratio": 1.0171,
+      "suggested_scalar": 0.0062,
+      "log_bad": 7.277,
+      "log_good": 7.294
+    },
+    "readability.mean_total_lines": {
+      "bad": 30.0,
+      "good": 38.0,
+      "ratio": 1.2667,
+      "suggested_scalar": 0.0868,
+      "log_bad": 3.4012,
+      "log_good": 3.6376
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 6.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1056,
+      "log_bad": 2.0794,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 1245.4198,
+      "good": 1275.3672,
+      "ratio": 1.024,
+      "suggested_scalar": 0.0087,
+      "log_bad": 7.1272,
+      "log_good": 7.151
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 527.0,
+      "good": 512.0,
+      "ratio": 0.9715,
+      "suggested_scalar": -0.0106,
+      "log_bad": 6.2672,
+      "log_good": 6.2383
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.5333,
+      "good": 33.2632,
+      "ratio": 1.0224,
+      "suggested_scalar": 0.0081,
+      "log_bad": 3.4823,
+      "log_good": 3.5045
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2212,
+      "good": 1.2586,
+      "ratio": 1.0306,
+      "suggested_scalar": 0.0111,
+      "log_bad": 0.1998,
+      "log_good": 0.23
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2544,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 16.0,
+      "good": 17.0,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.0223,
+      "log_bad": 2.7726,
+      "log_good": 2.8332
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2544,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9641,
+      "good": 0.9163,
+      "ratio": 0.9504,
+      "suggested_scalar": -0.0187,
+      "log_bad": -0.0366,
+      "log_good": -0.0874
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9837,
+      "good": 0.993,
+      "ratio": 1.0095,
+      "suggested_scalar": 0.0035,
+      "log_bad": -0.0164,
+      "log_good": -0.007
+    },
+    "halstead.mean_length": {
+      "bad": 197.0,
+      "good": 211.0,
+      "ratio": 1.0711,
+      "suggested_scalar": 0.0252,
+      "log_bad": 5.2832,
+      "log_good": 5.3519
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.6,
+      "good": 6.7143,
+      "ratio": 0.8835,
+      "suggested_scalar": -0.0455,
+      "log_bad": 2.0281,
+      "log_good": 1.9042
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.375,
+      "good": 6.1898,
+      "ratio": 0.9709,
+      "suggested_scalar": -0.0108,
+      "log_bad": 1.8524,
+      "log_good": 1.8229
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0808,
+      "good": 0.0869,
+      "ratio": 1.0755,
+      "suggested_scalar": 0.0267,
+      "log_bad": -2.5158,
+      "log_good": -2.443
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 20.9091,
+      "good": 20.7667,
+      "ratio": 0.9932,
+      "suggested_scalar": -0.0025,
+      "log_bad": 3.0402,
+      "log_good": 3.0334
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1056,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 52.0,
+      "good": 44.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.0613,
+      "log_bad": 3.9512,
+      "log_good": 3.7842
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8683,
+      "good": 0.8343,
+      "ratio": 0.9608,
+      "suggested_scalar": -0.0147,
+      "log_bad": -0.1412,
+      "log_good": -0.1812
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 32.0,
+      "good": 38.0,
+      "ratio": 1.1875,
+      "suggested_scalar": 0.0631,
+      "log_bad": 3.4657,
+      "log_good": 3.6376
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 26.0,
+      "good": 26.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2581,
+      "log_good": 3.2581
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.exported_name_not_redundant_with_package": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 12.0,
+      "good": 16.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.5871,
+      "log_bad": 2.4849,
+      "log_good": 2.7726
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0241,
+      "good": 0.0188,
+      "ratio": 0.7801,
+      "suggested_scalar": -0.5069,
+      "log_bad": -3.7255,
+      "log_good": -3.9739
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8718,
+      "good": 0.8636,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.0193,
+      "log_bad": -0.1372,
+      "log_good": -0.1466
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0241,
+      "good": 0.0188,
+      "ratio": 0.7801,
+      "suggested_scalar": -0.5069,
+      "log_bad": -3.7255,
+      "log_good": -3.9739
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7217,
+      "good": 4.7719,
+      "ratio": 1.0106,
+      "suggested_scalar": 0.0216,
+      "log_bad": 1.5522,
+      "log_good": 1.5627
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 76.0,
+      "good": 106.0,
+      "ratio": 1.3947,
+      "suggested_scalar": 0.679,
+      "log_bad": 4.3307,
+      "log_good": 4.6634
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4607,
+      "good": 0.5347,
+      "ratio": 1.1606,
+      "suggested_scalar": 0.304,
+      "log_bad": -0.775,
+      "log_good": -0.626
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 16.0,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.1317,
+      "log_bad": 2.7081,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7099,
+      "good": 0.7361,
+      "ratio": 1.0369,
+      "suggested_scalar": 0.074,
+      "log_bad": -0.3426,
+      "log_good": -0.3064
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.359,
+      "good": 0.3409,
+      "ratio": 0.9496,
+      "suggested_scalar": -0.1056,
+      "log_bad": -1.0244,
+      "log_good": -1.0762
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 249.0,
+      "good": 319.0,
+      "ratio": 1.2811,
+      "suggested_scalar": 0.5056,
+      "log_bad": 5.5175,
+      "log_good": 5.7652
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2051,
+      "good": 0.2273,
+      "ratio": 1.1082,
+      "suggested_scalar": 0.2098,
+      "log_bad": -1.5843,
+      "log_good": -1.4815
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9009,
+      "good": 0.8821,
+      "ratio": 0.9791,
+      "suggested_scalar": -0.043,
+      "log_bad": -0.1044,
+      "log_good": -0.1254
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 114.0,
+      "good": 157.0,
+      "ratio": 1.3772,
+      "suggested_scalar": 0.6532,
+      "log_bad": 4.7362,
+      "log_good": 5.0562
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 82.6245,
+      "good": 109.5331,
+      "ratio": 1.3257,
+      "suggested_scalar": 0.5754,
+      "log_bad": 4.4143,
+      "log_good": 4.6962
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4556,
+      "good": 0.456,
+      "ratio": 1.0009,
+      "suggested_scalar": 0.0018,
+      "log_bad": -0.7861,
+      "log_good": -0.7853
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 24.4759,
+      "good": 9.1867,
+      "ratio": 0.3753,
+      "suggested_scalar": -2.0,
+      "log_bad": 3.1977,
+      "log_good": 2.2178
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1439.0,
+      "good": 1412.0,
+      "ratio": 0.9812,
+      "suggested_scalar": -0.0387,
+      "log_bad": 7.2717,
+      "log_good": 7.2528
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0256,
+      "good": 0.0455,
+      "ratio": 1.7773,
+      "suggested_scalar": 1.1738,
+      "log_bad": -3.6652,
+      "log_good": -3.09
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8718,
+      "good": 0.8636,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.0193,
+      "log_bad": -0.1372,
+      "log_good": -0.1466
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.3846,
+      "good": 7.25,
+      "ratio": 1.1355,
+      "suggested_scalar": 0.2594,
+      "log_bad": 1.8539,
+      "log_good": 1.981
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.2301,
+      "good": 0.2247,
+      "ratio": 0.9765,
+      "suggested_scalar": -0.0485,
+      "log_bad": -1.4692,
+      "log_good": -1.493
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 64.0,
+      "good": 98.0,
+      "ratio": 1.5313,
+      "suggested_scalar": 0.8696,
+      "log_bad": 4.1589,
+      "log_good": 4.585
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9128,
+      "good": 0.9379,
+      "ratio": 1.0275,
+      "suggested_scalar": 0.0554,
+      "log_bad": -0.0912,
+      "log_good": -0.0641
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 19.0,
+      "good": 24.0,
+      "ratio": 1.2632,
+      "suggested_scalar": 0.4768,
+      "log_bad": 2.9444,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6525,
+      "good": 0.5602,
+      "ratio": 0.8585,
+      "suggested_scalar": -0.3113,
+      "log_bad": -0.4269,
+      "log_good": -0.5795
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2713,
+      "good": 0.2871,
+      "ratio": 1.0582,
+      "suggested_scalar": 0.1155,
+      "log_bad": -1.3045,
+      "log_good": -1.2479
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.878,
+      "good": 2.2738,
+      "ratio": 0.7901,
+      "suggested_scalar": -0.4809,
+      "log_bad": 1.0571,
+      "log_good": 0.8215
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 247.0,
+      "good": 317.0,
+      "ratio": 1.2834,
+      "suggested_scalar": 0.5092,
+      "log_bad": 5.5094,
+      "log_good": 5.7589
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.004,
+      "good": 0.0063,
+      "ratio": 1.575,
+      "suggested_scalar": 0.9271,
+      "log_bad": -5.5215,
+      "log_good": -5.0672
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8074,
+      "good": 5.858,
+      "ratio": 1.0087,
+      "suggested_scalar": 0.0177,
+      "log_bad": 1.7591,
+      "log_good": 1.7678
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 49.0,
+      "good": 58.0,
+      "ratio": 1.1837,
+      "suggested_scalar": 0.3442,
+      "log_bad": 3.8918,
+      "log_good": 4.0604
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0511,
+      "good": 1.0016,
+      "ratio": 0.9529,
+      "suggested_scalar": -0.0985,
+      "log_bad": 0.0498,
+      "log_good": 0.0016
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6365,
+      "good": 5.9669,
+      "ratio": 1.0586,
+      "suggested_scalar": 0.1163,
+      "log_bad": 1.7293,
+      "log_good": 1.7862
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8131,
+      "good": 0.8146,
+      "ratio": 1.0018,
+      "suggested_scalar": 0.0038,
+      "log_bad": -0.2069,
+      "log_good": -0.2051
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1875,
+      "good": 0.1852,
+      "ratio": 0.9877,
+      "suggested_scalar": -0.0252,
+      "log_bad": -1.674,
+      "log_good": -1.6863
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.9473,
+      "good": 3.031,
+      "ratio": 0.6127,
+      "suggested_scalar": -1.0,
+      "log_bad": 1.5988,
+      "log_good": 1.1089
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 203.0,
+      "good": 263.0,
+      "ratio": 1.2956,
+      "suggested_scalar": 0.5285,
+      "log_bad": 5.3132,
+      "log_good": 5.5722
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.479,
+      "good": 0.6818,
+      "ratio": 1.4234,
+      "suggested_scalar": 0.7205,
+      "log_bad": -0.7361,
+      "log_good": -0.383
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 77.0,
+      "good": 106.0,
+      "ratio": 1.3766,
+      "suggested_scalar": 0.6524,
+      "log_bad": 4.3438,
+      "log_good": 4.6634
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 991.0,
+      "good": 885.0,
+      "ratio": 0.893,
+      "suggested_scalar": -0.2309,
+      "log_bad": 6.8987,
+      "log_good": 6.7856
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 128.0,
+      "good": 171.0,
+      "ratio": 1.3359,
+      "suggested_scalar": 0.5911,
+      "log_bad": 4.852,
+      "log_good": 5.1417
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2008,
+      "good": 0.2069,
+      "ratio": 1.0304,
+      "suggested_scalar": 0.0611,
+      "log_bad": -1.6054,
+      "log_good": -1.5755
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 38.0,
+      "good": 51.0,
+      "ratio": 1.3421,
+      "suggested_scalar": 0.6005,
+      "log_bad": 3.6376,
+      "log_good": 3.9318
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.8275,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 77.0,
+      "good": 106.0,
+      "ratio": 1.3766,
+      "suggested_scalar": 0.6524,
+      "log_bad": 4.3438,
+      "log_good": 4.6634
+    },
+    "brevity.mean_sample_size": {
+      "bad": 77.0,
+      "good": 106.0,
+      "ratio": 1.3766,
+      "suggested_scalar": 0.6524,
+      "log_bad": 4.3438,
+      "log_good": 4.6634
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 249.0,
+      "good": 319.0,
+      "ratio": 1.2811,
+      "suggested_scalar": 0.5056,
+      "log_bad": 5.5175,
+      "log_good": 5.7652
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 106.0,
+      "good": 129.0,
+      "ratio": 1.217,
+      "suggested_scalar": 0.4008,
+      "log_bad": 4.6634,
+      "log_good": 4.8598
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 173.0,
+      "good": 224.0,
+      "ratio": 1.2948,
+      "suggested_scalar": 0.5273,
+      "log_bad": 5.1533,
+      "log_good": 5.4116
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.6159,
+      "good": 1.7616,
+      "ratio": 1.0902,
+      "suggested_scalar": 0.1762,
+      "log_bad": 0.4799,
+      "log_good": 0.5662
+    },
+    "halstead.mean_effort": {
+      "bad": 30656.4977,
+      "good": 51182.0805,
+      "ratio": 1.6695,
+      "suggested_scalar": 1.0461,
+      "log_bad": 10.3306,
+      "log_good": 10.8431
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8994,
+      "good": 0.8869,
+      "ratio": 0.9861,
+      "suggested_scalar": -0.0286,
+      "log_bad": -0.106,
+      "log_good": -0.12
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 57.0,
+      "good": 82.0,
+      "ratio": 1.4386,
+      "suggested_scalar": 0.7422,
+      "log_bad": 4.0431,
+      "log_good": 4.4067
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 102.0,
+      "good": 133.0,
+      "ratio": 1.3039,
+      "suggested_scalar": 0.5416,
+      "log_bad": 4.625,
+      "log_good": 4.8903
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4211,
+      "good": 0.4586,
+      "ratio": 1.0891,
+      "suggested_scalar": 0.1741,
+      "log_bad": -0.8649,
+      "log_good": -0.7796
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.693,
+      "good": 5.6369,
+      "ratio": 0.6484,
+      "suggested_scalar": -0.8841,
+      "log_bad": 2.1625,
+      "log_good": 1.7293
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1875,
+      "good": 0.1852,
+      "ratio": 0.9877,
+      "suggested_scalar": -0.0252,
+      "log_bad": -1.674,
+      "log_good": -1.6863
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.5119,
+      "good": 3.3211,
+      "ratio": 0.7361,
+      "suggested_scalar": -0.6254,
+      "log_bad": 1.5067,
+      "log_good": 1.2003
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 248.0,
+      "good": 318.0,
+      "ratio": 1.2823,
+      "suggested_scalar": 0.5074,
+      "log_bad": 5.5134,
+      "log_good": 5.7621
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 23.0,
+      "good": 37.0,
+      "ratio": 1.6087,
+      "suggested_scalar": 0.9703,
+      "log_bad": 3.1355,
+      "log_good": 3.6109
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1703.1388,
+      "good": 2843.4489,
+      "ratio": 1.6695,
+      "suggested_scalar": 1.0461,
+      "log_bad": 7.4402,
+      "log_good": 7.9528
+    },
+    "readability.mean_total_lines": {
+      "bad": 39.0,
+      "good": 44.0,
+      "ratio": 1.1282,
+      "suggested_scalar": 0.2462,
+      "log_bad": 3.6636,
+      "log_good": 3.7842
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1437.0233,
+      "good": 2045.2878,
+      "ratio": 1.4233,
+      "suggested_scalar": 0.7204,
+      "log_bad": 7.2703,
+      "log_good": 7.6233
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 500.0,
+      "good": 621.0,
+      "ratio": 1.242,
+      "suggested_scalar": 0.4423,
+      "log_bad": 6.2146,
+      "log_good": 6.4313
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.4103,
+      "good": 30.8182,
+      "ratio": 0.8703,
+      "suggested_scalar": -0.2835,
+      "log_bad": 3.567,
+      "log_good": 3.4281
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3916,
+      "good": 1.0632,
+      "ratio": 0.764,
+      "suggested_scalar": -0.5494,
+      "log_bad": 0.3305,
+      "log_good": 0.0613
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 19.0,
+      "good": 21.0,
+      "ratio": 1.1053,
+      "suggested_scalar": 0.2043,
+      "log_bad": 2.9444,
+      "log_good": 3.0445
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 8.0,
+      "good": 10.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.4554,
+      "log_bad": 2.0794,
+      "log_good": 2.3026
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8867,
+      "good": 0.8593,
+      "ratio": 0.9691,
+      "suggested_scalar": -0.0641,
+      "log_bad": -0.1202,
+      "log_good": -0.1516
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9948,
+      "good": 0.9903,
+      "ratio": 0.9955,
+      "suggested_scalar": -0.0093,
+      "log_bad": -0.0052,
+      "log_good": -0.0097
+    },
+    "halstead.mean_length": {
+      "bad": 230.0,
+      "good": 304.0,
+      "ratio": 1.3217,
+      "suggested_scalar": 0.5693,
+      "log_bad": 5.4381,
+      "log_good": 5.717
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.0,
+      "good": 4.3333,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.1633,
+      "log_bad": 1.3863,
+      "log_good": 1.4663
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2668,
+      "good": 6.7279,
+      "ratio": 1.0736,
+      "suggested_scalar": 0.1449,
+      "log_bad": 1.8353,
+      "log_good": 1.9063
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0742,
+      "good": 0.0915,
+      "ratio": 1.2332,
+      "suggested_scalar": 0.4277,
+      "log_bad": -2.601,
+      "log_good": -2.3914
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 21.3333,
+      "good": 25.0244,
+      "ratio": 1.173,
+      "suggested_scalar": 0.3257,
+      "log_bad": 3.0603,
+      "log_good": 3.2199
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 1.4147,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 48.0,
+      "good": 72.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.8275,
+      "log_bad": 3.8712,
+      "log_good": 4.2767
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7803,
+      "good": 0.7723,
+      "ratio": 0.9897,
+      "suggested_scalar": -0.021,
+      "log_bad": -0.2481,
+      "log_good": -0.2584
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 39.0,
+      "good": 44.0,
+      "ratio": 1.1282,
+      "suggested_scalar": 0.2462,
+      "log_bad": 3.6636,
+      "log_good": 3.7842
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 26.0,
+      "good": 19.0,
+      "ratio": 0.7308,
+      "suggested_scalar": -0.6402,
+      "log_bad": 3.2581,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_mutable_exported_variables": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 23.0,
+      "good": 13.0,
+      "ratio": 0.5652,
+      "suggested_scalar": -0.1652,
+      "log_bad": 3.1355,
+      "log_good": 2.5649
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0052,
+      "good": 0.0043,
+      "ratio": 0.8269,
+      "suggested_scalar": -0.055,
+      "log_bad": -5.2591,
+      "log_good": -5.4491
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.878,
+      "good": 0.8611,
+      "ratio": 0.9808,
+      "suggested_scalar": -0.0056,
+      "log_bad": -0.1301,
+      "log_good": -0.1495
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0052,
+      "good": 0.0085,
+      "ratio": 1.6346,
+      "suggested_scalar": 0.1423,
+      "log_bad": -5.2591,
+      "log_good": -4.7677
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7402,
+      "good": 5.0845,
+      "ratio": 1.0726,
+      "suggested_scalar": 0.0203,
+      "log_bad": 1.5561,
+      "log_good": 1.6262
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 51.0,
+      "good": 66.0,
+      "ratio": 1.2941,
+      "suggested_scalar": 0.0746,
+      "log_bad": 3.9318,
+      "log_good": 4.1897
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5116,
+      "good": 0.5862,
+      "ratio": 1.1458,
+      "suggested_scalar": 0.0394,
+      "log_bad": -0.6702,
+      "log_good": -0.5341
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 18.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0528,
+      "log_bad": 2.7081,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6632,
+      "good": 0.6862,
+      "ratio": 1.0347,
+      "suggested_scalar": 0.0099,
+      "log_bad": -0.4107,
+      "log_good": -0.3766
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.5122,
+      "good": 1.4444,
+      "ratio": 0.9552,
+      "suggested_scalar": -0.0133,
+      "log_bad": 0.4136,
+      "log_good": 0.3677
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 193.0,
+      "good": 235.0,
+      "ratio": 1.2176,
+      "suggested_scalar": 0.057,
+      "log_bad": 5.2627,
+      "log_good": 5.4596
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0833,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 0.001,
+      "ratio": 0.001,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.9078
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0244,
+      "good": 0.0278,
+      "ratio": 1.1393,
+      "suggested_scalar": 0.0378,
+      "log_bad": -3.7132,
+      "log_good": -3.5827
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9245,
+      "good": 0.9821,
+      "ratio": 1.0623,
+      "suggested_scalar": 0.0175,
+      "log_bad": -0.0785,
+      "log_good": -0.0181
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 43.0,
+      "good": 58.0,
+      "ratio": 1.3488,
+      "suggested_scalar": 0.0866,
+      "log_bad": 3.7612,
+      "log_good": 4.0604
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 92.864,
+      "good": 97.1031,
+      "ratio": 1.0456,
+      "suggested_scalar": 0.0129,
+      "log_bad": 4.5311,
+      "log_good": 4.5758
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5573,
+      "good": 0.4701,
+      "ratio": 0.8435,
+      "suggested_scalar": -0.0493,
+      "log_bad": -0.5847,
+      "log_good": -0.7548
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.9329,
+      "good": 10.9242,
+      "ratio": 0.7841,
+      "suggested_scalar": -0.0704,
+      "log_bad": 2.6343,
+      "log_good": 2.391
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 898.0,
+      "good": 974.0,
+      "ratio": 1.0846,
+      "suggested_scalar": 0.0235,
+      "log_bad": 6.8002,
+      "log_good": 6.8814
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0732,
+      "good": 0.1111,
+      "ratio": 1.5178,
+      "suggested_scalar": 0.1208,
+      "log_bad": -2.6146,
+      "log_good": -2.1973
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7317,
+      "good": 0.8056,
+      "ratio": 1.101,
+      "suggested_scalar": 0.0279,
+      "log_bad": -0.3124,
+      "log_good": -0.2162
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 4.7073,
+      "good": 6.5278,
+      "ratio": 1.3867,
+      "suggested_scalar": 0.0947,
+      "log_bad": 1.5491,
+      "log_good": 1.8761
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 12.0,
+      "ratio": 12.0,
+      "suggested_scalar": 0.7195,
+      "log_bad": 0.0,
+      "log_good": 2.4849
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.1035,
+      "good": 1.9136,
+      "ratio": 0.9097,
+      "suggested_scalar": -0.0274,
+      "log_bad": 0.7436,
+      "log_good": 0.649
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.896,
+      "good": 0.9346,
+      "ratio": 1.0431,
+      "suggested_scalar": 0.0122,
+      "log_bad": -0.1098,
+      "log_good": -0.0676
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 26.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0484,
+      "log_bad": 3.091,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5813,
+      "good": 0.5411,
+      "ratio": 0.9308,
+      "suggested_scalar": -0.0207,
+      "log_bad": -0.5425,
+      "log_good": -0.6142
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3665,
+      "good": 0.3047,
+      "ratio": 0.8314,
+      "suggested_scalar": -0.0535,
+      "log_bad": -1.0038,
+      "log_good": -1.1884
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3883,
+      "good": 2.179,
+      "ratio": 0.9124,
+      "suggested_scalar": -0.0266,
+      "log_bad": 0.8706,
+      "log_good": 0.7789
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 191.0,
+      "good": 233.0,
+      "ratio": 1.2199,
+      "suggested_scalar": 0.0575,
+      "log_bad": 5.2523,
+      "log_good": 5.451
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0415,
+      "good": 0.0213,
+      "ratio": 0.5133,
+      "suggested_scalar": -0.1931,
+      "log_bad": -3.1821,
+      "log_good": -3.849
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7279,
+      "good": 5.9542,
+      "ratio": 1.0395,
+      "suggested_scalar": 0.0112,
+      "log_bad": 1.7453,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 0.466,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9965,
+      "good": 2.1826,
+      "ratio": 2.1903,
+      "suggested_scalar": 0.227,
+      "log_bad": -0.0035,
+      "log_good": 0.7805
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 0.1379,
+      "ratio": 0.1379,
+      "suggested_scalar": -0.5736,
+      "log_bad": 0.0,
+      "log_good": -1.9812
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.12,
+      "good": 5.2502,
+      "ratio": 1.0254,
+      "suggested_scalar": 0.0073,
+      "log_bad": 1.6332,
+      "log_good": 1.6583
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8276,
+      "good": 0.8539,
+      "ratio": 1.0318,
+      "suggested_scalar": 0.0091,
+      "log_bad": -0.1892,
+      "log_good": -0.1579
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.18,
+      "good": 0.1628,
+      "ratio": 0.9044,
+      "suggested_scalar": -0.0291,
+      "log_bad": -1.7148,
+      "log_good": -1.8152
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.7327,
+      "good": 3.3052,
+      "ratio": 0.8855,
+      "suggested_scalar": -0.0352,
+      "log_bad": 1.3171,
+      "log_good": 1.1955
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 150.0,
+      "good": 184.0,
+      "ratio": 1.2267,
+      "suggested_scalar": 0.0592,
+      "log_bad": 5.0106,
+      "log_good": 5.2149
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 12.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.3181,
+      "log_bad": 1.3863,
+      "log_good": 2.4849
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.3479,
+      "good": 0.4251,
+      "ratio": 1.2219,
+      "suggested_scalar": 0.058,
+      "log_bad": -1.0558,
+      "log_good": -0.8554
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 52.0,
+      "good": 68.0,
+      "ratio": 1.3077,
+      "suggested_scalar": 0.0777,
+      "log_bad": 3.9512,
+      "log_good": 4.2195
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 378.0,
+      "good": 455.0,
+      "ratio": 1.2037,
+      "suggested_scalar": 0.0537,
+      "log_bad": 5.9349,
+      "log_good": 6.1203
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 64.0,
+      "good": 72.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0341,
+      "log_bad": 4.1589,
+      "log_good": 4.2767
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2383,
+      "good": 0.1787,
+      "ratio": 0.7499,
+      "suggested_scalar": -0.0833,
+      "log_bad": -1.4342,
+      "log_good": -1.722
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 37.0,
+      "good": 30.0,
+      "ratio": 0.8108,
+      "suggested_scalar": -0.0607,
+      "log_bad": 3.6109,
+      "log_good": 3.4012
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 52.0,
+      "good": 68.0,
+      "ratio": 1.3077,
+      "suggested_scalar": 0.0777,
+      "log_bad": 3.9512,
+      "log_good": 4.2195
+    },
+    "brevity.mean_sample_size": {
+      "bad": 52.0,
+      "good": 68.0,
+      "ratio": 1.3077,
+      "suggested_scalar": 0.0777,
+      "log_bad": 3.9512,
+      "log_good": 4.2195
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 193.0,
+      "good": 235.0,
+      "ratio": 1.2176,
+      "suggested_scalar": 0.057,
+      "log_bad": 5.2627,
+      "log_good": 5.4596
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 105.0,
+      "good": 139.0,
+      "ratio": 1.3238,
+      "suggested_scalar": 0.0812,
+      "log_bad": 4.654,
+      "log_good": 4.9345
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 122.0,
+      "good": 154.0,
+      "ratio": 1.2623,
+      "suggested_scalar": 0.0674,
+      "log_bad": 4.804,
+      "log_good": 5.037
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.8483,
+      "good": 1.7286,
+      "ratio": 0.9352,
+      "suggested_scalar": -0.0194,
+      "log_bad": 0.6143,
+      "log_good": 0.5473
+    },
+    "halstead.mean_effort": {
+      "bad": 25337.3548,
+      "good": 29843.5915,
+      "ratio": 1.1778,
+      "suggested_scalar": 0.0474,
+      "log_bad": 10.14,
+      "log_good": 10.3037
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8982,
+      "good": 0.8625,
+      "ratio": 0.9603,
+      "suggested_scalar": -0.0117,
+      "log_bad": -0.1074,
+      "log_good": -0.1479
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 29.0,
+      "good": 40.0,
+      "ratio": 1.3793,
+      "suggested_scalar": 0.0931,
+      "log_bad": 3.3673,
+      "log_good": 3.6889
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 120.0,
+      "good": 139.0,
+      "ratio": 1.1583,
+      "suggested_scalar": 0.0426,
+      "log_bad": 4.7875,
+      "log_good": 4.9345
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5116,
+      "good": 0.5862,
+      "ratio": 1.1458,
+      "suggested_scalar": 0.0394,
+      "log_bad": -0.6702,
+      "log_good": -0.5341
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.7907,
+      "good": 7.8448,
+      "ratio": 0.8924,
+      "suggested_scalar": -0.033,
+      "log_bad": 2.1737,
+      "log_good": 2.0599
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.18,
+      "good": 0.1628,
+      "ratio": 0.9044,
+      "suggested_scalar": -0.0291,
+      "log_bad": -1.7148,
+      "log_good": -1.8152
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.8132,
+      "good": 2.6111,
+      "ratio": 0.9282,
+      "suggested_scalar": -0.0216,
+      "log_bad": 1.0343,
+      "log_good": 0.9598
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 192.0,
+      "good": 234.0,
+      "ratio": 1.2188,
+      "suggested_scalar": 0.0573,
+      "log_bad": 5.2575,
+      "log_good": 5.4553
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2007,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 29.0,
+      "good": 22.0,
+      "ratio": 0.7586,
+      "suggested_scalar": -0.08,
+      "log_bad": 3.3673,
+      "log_good": 3.091
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1407.6308,
+      "good": 1657.9773,
+      "ratio": 1.1778,
+      "suggested_scalar": 0.0474,
+      "log_bad": 7.2497,
+      "log_good": 7.4134
+    },
+    "readability.mean_total_lines": {
+      "bad": 41.0,
+      "good": 36.0,
+      "ratio": 0.878,
+      "suggested_scalar": -0.0377,
+      "log_bad": 3.7136,
+      "log_good": 3.5835
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1043.7263,
+      "good": 1275.3672,
+      "ratio": 1.2219,
+      "suggested_scalar": 0.058,
+      "log_bad": 6.9506,
+      "log_good": 7.151
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 376.0,
+      "good": 447.0,
+      "ratio": 1.1888,
+      "suggested_scalar": 0.0501,
+      "log_bad": 5.9296,
+      "log_good": 6.1026
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 20.6829,
+      "good": 25.8611,
+      "ratio": 1.2504,
+      "suggested_scalar": 0.0647,
+      "log_bad": 3.0293,
+      "log_good": 3.2527
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2907,
+      "good": 1.2188,
+      "ratio": 0.9443,
+      "suggested_scalar": -0.0166,
+      "log_bad": 0.2552,
+      "log_good": 0.1979
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0833,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 6.0,
+      "good": 23.0,
+      "ratio": 3.8333,
+      "suggested_scalar": 0.3891,
+      "log_bad": 1.7918,
+      "log_good": 3.1355
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8067,
+      "good": 0.8804,
+      "ratio": 1.0914,
+      "suggested_scalar": 0.0253,
+      "log_bad": -0.2148,
+      "log_good": -0.1274
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9801,
+      "good": 0.9888,
+      "ratio": 1.0089,
+      "suggested_scalar": 0.0026,
+      "log_bad": -0.0201,
+      "log_good": -0.0113
+    },
+    "halstead.mean_length": {
+      "bad": 184.0,
+      "good": 211.0,
+      "ratio": 1.1467,
+      "suggested_scalar": 0.0396,
+      "log_bad": 5.2149,
+      "log_good": 5.3519
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.7004,
+      "good": 6.0875,
+      "ratio": 1.0679,
+      "suggested_scalar": 0.019,
+      "log_bad": 1.7405,
+      "log_good": 1.8062
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1169,
+      "good": 0.1427,
+      "ratio": 1.2207,
+      "suggested_scalar": 0.0577,
+      "log_bad": -2.1464,
+      "log_good": -1.947
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 24.2759,
+      "good": 23.4,
+      "ratio": 0.9639,
+      "suggested_scalar": -0.0106,
+      "log_bad": 3.1895,
+      "log_good": 3.1527
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0833,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 22.0,
+      "good": 34.0,
+      "ratio": 1.5455,
+      "suggested_scalar": 0.126,
+      "log_bad": 3.091,
+      "log_good": 3.5264
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6967,
+      "good": 0.8052,
+      "ratio": 1.1557,
+      "suggested_scalar": 0.0419,
+      "log_bad": -0.3614,
+      "log_good": -0.2167
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 41.0,
+      "good": 36.0,
+      "ratio": 0.878,
+      "suggested_scalar": -0.0377,
+      "log_bad": 3.7136,
+      "log_good": 3.5835
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 15.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.0974,
+      "log_bad": 3.0445,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 8.0,
+      "ratio": 8.0,
+      "suggested_scalar": 0.6021,
+      "log_bad": 0.0,
+      "log_good": 2.0794
+    }
+  },
+  "naming_conventions.constants_are_screaming_snake_or_caps_words": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 6.0,
+      "good": 1.0,
+      "ratio": 0.1667,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.7918,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 9.0,
+      "good": 10.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.1176,
+      "log_bad": 2.1972,
+      "log_good": 2.3026
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0159,
+      "good": 0.0165,
+      "ratio": 1.0377,
+      "suggested_scalar": 0.0413,
+      "log_bad": -4.1414,
+      "log_good": -4.1044
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.4,
+      "good": 1.4,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.3365,
+      "log_good": 0.3365
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8667,
+      "good": 0.8667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1431,
+      "log_good": -0.1431
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0159,
+      "good": 0.0165,
+      "ratio": 1.0377,
+      "suggested_scalar": 0.0413,
+      "log_bad": -4.1414,
+      "log_good": -4.1044
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.9241,
+      "good": 5.1261,
+      "ratio": 1.041,
+      "suggested_scalar": 0.0449,
+      "log_bad": 1.5941,
+      "log_good": 1.6343
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 103.0,
+      "good": 99.0,
+      "ratio": 0.9612,
+      "suggested_scalar": -0.0442,
+      "log_bad": 4.6347,
+      "log_good": 4.5951
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6495,
+      "good": 0.6703,
+      "ratio": 1.032,
+      "suggested_scalar": 0.0352,
+      "log_bad": -0.4316,
+      "log_good": -0.4
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7187,
+      "good": 0.7337,
+      "ratio": 1.0209,
+      "suggested_scalar": 0.0231,
+      "log_bad": -0.3303,
+      "log_good": -0.3097
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.8667,
+      "good": 3.8667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3524,
+      "log_good": 1.3524
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 251.0,
+      "good": 242.0,
+      "ratio": 0.9641,
+      "suggested_scalar": -0.0408,
+      "log_bad": 5.5255,
+      "log_good": 5.4889
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0014,
+      "good": 0.0014,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.5713,
+      "log_good": -6.5713
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0667,
+      "good": 0.0667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.7076,
+      "log_good": -2.7076
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0035,
+      "good": 0.0036,
+      "ratio": 1.0286,
+      "suggested_scalar": 0.0314,
+      "log_bad": -5.655,
+      "log_good": -5.6268
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.7364,
+      "good": 0.7475,
+      "ratio": 1.0151,
+      "suggested_scalar": 0.0167,
+      "log_bad": -0.306,
+      "log_good": -0.291
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 97.0,
+      "good": 91.0,
+      "ratio": 0.9381,
+      "suggested_scalar": -0.0713,
+      "log_bad": 4.5747,
+      "log_good": 4.5109
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 88.1812,
+      "good": 87.2843,
+      "ratio": 0.9898,
+      "suggested_scalar": -0.0114,
+      "log_bad": 4.4794,
+      "log_good": 4.4692
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.24,
+      "good": 0.2324,
+      "ratio": 0.9683,
+      "suggested_scalar": -0.0359,
+      "log_bad": -1.4271,
+      "log_good": -1.4593
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 25.2074,
+      "good": 25.5278,
+      "ratio": 1.0127,
+      "suggested_scalar": 0.0141,
+      "log_bad": 3.2271,
+      "log_good": 3.2398
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1430.0,
+      "good": 1380.0,
+      "ratio": 0.965,
+      "suggested_scalar": -0.0397,
+      "log_bad": 7.2654,
+      "log_good": 7.2298
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0222,
+      "good": 0.0222,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.8077,
+      "log_good": -3.8077
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8,
+      "good": 0.8,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2231,
+      "log_good": -0.2231
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.9762,
+      "good": 5.7619,
+      "ratio": 0.9641,
+      "suggested_scalar": -0.0408,
+      "log_bad": 1.7878,
+      "log_good": 1.7513
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.6267,
+      "good": 3.6267,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.2883,
+      "log_good": 1.2883
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 62.0,
+      "good": 52.0,
+      "ratio": 0.8387,
+      "suggested_scalar": -0.1963,
+      "log_bad": 4.1271,
+      "log_good": 3.9512
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9352,
+      "good": 0.932,
+      "ratio": 0.9966,
+      "suggested_scalar": -0.0038,
+      "log_bad": -0.067,
+      "log_good": -0.0704
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 27.0,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.0406,
+      "log_bad": 3.3322,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5154,
+      "good": 0.492,
+      "ratio": 0.9546,
+      "suggested_scalar": -0.0519,
+      "log_bad": -0.6628,
+      "log_good": -0.7093
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.0643,
+      "good": 0.0667,
+      "ratio": 1.0373,
+      "suggested_scalar": 0.0409,
+      "log_bad": -2.7442,
+      "log_good": -2.7076
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.0635,
+      "good": 1.9686,
+      "ratio": 0.954,
+      "suggested_scalar": -0.0526,
+      "log_bad": 0.7244,
+      "log_good": 0.6773
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 249.0,
+      "good": 240.0,
+      "ratio": 0.9639,
+      "suggested_scalar": -0.0411,
+      "log_bad": 5.5175,
+      "log_good": 5.4806
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0199,
+      "good": 0.0207,
+      "ratio": 1.0402,
+      "suggested_scalar": 0.044,
+      "log_bad": -3.917,
+      "log_good": -3.8776
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.2095,
+      "good": 6.2854,
+      "ratio": 1.0122,
+      "suggested_scalar": 0.0136,
+      "log_bad": 1.8261,
+      "log_good": 1.8382
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4825,
+      "good": 1.5063,
+      "ratio": 1.0161,
+      "suggested_scalar": 0.0178,
+      "log_bad": 0.3937,
+      "log_good": 0.4097
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0515,
+      "good": 0.1648,
+      "ratio": 3.2,
+      "suggested_scalar": 1.2983,
+      "log_bad": -2.9662,
+      "log_good": -1.803
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.1753,
+      "good": 6.1084,
+      "ratio": 0.9892,
+      "suggested_scalar": -0.0122,
+      "log_bad": 1.8206,
+      "log_good": 1.8097
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.793,
+      "good": 0.8156,
+      "ratio": 1.0285,
+      "suggested_scalar": 0.0314,
+      "log_bad": -0.2319,
+      "log_good": -0.2038
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1667,
+      "good": 0.1667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.7916,
+      "log_good": -1.7916
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 5.0207,
+      "good": 5.0525,
+      "ratio": 1.0063,
+      "suggested_scalar": 0.007,
+      "log_bad": 1.6136,
+      "log_good": 1.6199
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 241.0,
+      "good": 232.0,
+      "ratio": 0.9627,
+      "suggested_scalar": -0.0425,
+      "log_bad": 5.4848,
+      "log_good": 5.4467
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.4926,
+      "good": 0.4685,
+      "ratio": 0.9511,
+      "suggested_scalar": -0.056,
+      "log_bad": -0.7081,
+      "log_good": -0.7582
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 103.0,
+      "ratio": 0.9626,
+      "suggested_scalar": -0.0425,
+      "log_bad": 4.6728,
+      "log_good": 4.6347
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 835.0,
+      "good": 800.0,
+      "ratio": 0.9581,
+      "suggested_scalar": -0.0478,
+      "log_bad": 6.7274,
+      "log_good": 6.6846
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 106.0,
+      "good": 99.0,
+      "ratio": 0.934,
+      "suggested_scalar": -0.0763,
+      "log_bad": 4.6634,
+      "log_good": 4.5951
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2151,
+      "good": 0.2149,
+      "ratio": 0.9991,
+      "suggested_scalar": -0.001,
+      "log_bad": -1.5367,
+      "log_good": -1.5376
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 26.0,
+      "good": 24.0,
+      "ratio": 0.9231,
+      "suggested_scalar": -0.0893,
+      "log_bad": 3.2581,
+      "log_good": 3.1781
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 103.0,
+      "ratio": 0.9626,
+      "suggested_scalar": -0.0425,
+      "log_bad": 4.6728,
+      "log_good": 4.6347
+    },
+    "brevity.mean_sample_size": {
+      "bad": 107.0,
+      "good": 103.0,
+      "ratio": 0.9626,
+      "suggested_scalar": -0.0425,
+      "log_bad": 4.6728,
+      "log_good": 4.6347
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 251.0,
+      "good": 242.0,
+      "ratio": 0.9641,
+      "suggested_scalar": -0.0408,
+      "log_bad": 5.5255,
+      "log_good": 5.4889
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 108.0,
+      "good": 107.0,
+      "ratio": 0.9907,
+      "suggested_scalar": -0.0104,
+      "log_bad": 4.6821,
+      "log_good": 4.6728
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 216.0,
+      "good": 209.0,
+      "ratio": 0.9676,
+      "suggested_scalar": -0.0368,
+      "log_bad": 5.3753,
+      "log_good": 5.3423
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0239,
+      "good": 0.0248,
+      "ratio": 1.0377,
+      "suggested_scalar": 0.0413,
+      "log_bad": -3.7339,
+      "log_good": -3.6969
+    },
+    "heaps.mean_k": {
+      "bad": 2.1667,
+      "good": 1.9963,
+      "ratio": 0.9214,
+      "suggested_scalar": -0.0914,
+      "log_bad": 0.7732,
+      "log_good": 0.6913
+    },
+    "halstead.mean_effort": {
+      "bad": 29239.0861,
+      "good": 26088.1756,
+      "ratio": 0.8922,
+      "suggested_scalar": -0.1273,
+      "log_bad": 10.2833,
+      "log_good": 10.1692
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.916,
+      "good": 0.9135,
+      "ratio": 0.9973,
+      "suggested_scalar": -0.0031,
+      "log_bad": -0.0877,
+      "log_good": -0.0905
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 75.0,
+      "good": 72.0,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0456,
+      "log_bad": 4.3175,
+      "log_good": 4.2767
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 115.0,
+      "good": 113.0,
+      "ratio": 0.9826,
+      "suggested_scalar": -0.0196,
+      "log_bad": 4.7449,
+      "log_good": 4.7274
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.6495,
+      "good": 0.6703,
+      "ratio": 1.032,
+      "suggested_scalar": 0.0352,
+      "log_bad": -0.4316,
+      "log_good": -0.4
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.6082,
+      "good": 8.7912,
+      "ratio": 1.0213,
+      "suggested_scalar": 0.0235,
+      "log_bad": 2.1527,
+      "log_good": 2.1738
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1667,
+      "good": 0.1667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.7916,
+      "log_good": -1.7916
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.398,
+      "good": 5.1848,
+      "ratio": 0.9605,
+      "suggested_scalar": -0.045,
+      "log_bad": 1.686,
+      "log_good": 1.6457
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 250.0,
+      "good": 241.0,
+      "ratio": 0.964,
+      "suggested_scalar": -0.0409,
+      "log_bad": 5.5215,
+      "log_good": 5.4848
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1624.3937,
+      "good": 1449.3431,
+      "ratio": 0.8922,
+      "suggested_scalar": -0.1273,
+      "log_bad": 7.3929,
+      "log_good": 7.2789
+    },
+    "readability.mean_total_lines": {
+      "bad": 42.0,
+      "good": 42.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7377,
+      "log_good": 3.7377
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 1477.7166,
+      "good": 1405.4236,
+      "ratio": 0.9511,
+      "suggested_scalar": -0.056,
+      "log_bad": 7.2983,
+      "log_good": 7.2481
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 693.0,
+      "good": 701.0,
+      "ratio": 1.0115,
+      "suggested_scalar": 0.0128,
+      "log_bad": 6.541,
+      "log_good": 6.5525
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 28.381,
+      "good": 28.5952,
+      "ratio": 1.0075,
+      "suggested_scalar": 0.0084,
+      "log_bad": 3.3457,
+      "log_good": 3.3532
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3308,
+      "good": 1.344,
+      "ratio": 1.0099,
+      "suggested_scalar": 0.011,
+      "log_bad": 0.2858,
+      "log_good": 0.2957
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9668,
+      "good": 0.9655,
+      "ratio": 0.9987,
+      "suggested_scalar": -0.0015,
+      "log_bad": -0.0338,
+      "log_good": -0.0351
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9862,
+      "good": 0.9844,
+      "ratio": 0.9982,
+      "suggested_scalar": -0.002,
+      "log_bad": -0.0139,
+      "log_good": -0.0157
+    },
+    "halstead.mean_length": {
+      "bad": 221.0,
+      "good": 212.0,
+      "ratio": 0.9593,
+      "suggested_scalar": -0.0464,
+      "log_bad": 5.3982,
+      "log_good": 5.3566
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.2,
+      "good": 7.2,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9741,
+      "log_good": 1.9741
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7415,
+      "good": 6.6865,
+      "ratio": 0.9918,
+      "suggested_scalar": -0.0091,
+      "log_bad": 1.9083,
+      "log_good": 1.9001
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0755,
+      "good": 0.0775,
+      "ratio": 1.0265,
+      "suggested_scalar": 0.0292,
+      "log_bad": -2.5836,
+      "log_good": -2.5575
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 19.7867,
+      "good": 18.5625,
+      "ratio": 0.9381,
+      "suggested_scalar": -0.0713,
+      "log_bad": 2.985,
+      "log_good": 2.9211
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 63.0,
+      "good": 61.0,
+      "ratio": 0.9683,
+      "suggested_scalar": -0.036,
+      "log_bad": 4.1431,
+      "log_good": 4.1109
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8796,
+      "good": 0.8852,
+      "ratio": 1.0064,
+      "suggested_scalar": 0.0071,
+      "log_bad": -0.1283,
+      "log_good": -0.1219
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 45.0,
+      "good": 45.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8067,
+      "log_good": 3.8067
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 20.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0545,
+      "log_bad": 3.0445,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 5.0,
+      "good": 15.0,
+      "ratio": 3.0,
+      "suggested_scalar": 1.2263,
+      "log_bad": 1.6094,
+      "log_good": 2.7081
+    }
+  },
+  "consistency.all_methods_declare_visibility": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.uses_errors_as_for_type_assertion": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0275,
+      "good": 0.0282,
+      "ratio": 1.0255,
+      "suggested_scalar": 0.0725,
+      "log_bad": -3.5936,
+      "log_good": -3.5684
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8286,
+      "good": 0.8378,
+      "ratio": 1.0111,
+      "suggested_scalar": 0.0319,
+      "log_bad": -0.188,
+      "log_good": -0.177
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0275,
+      "good": 0.0282,
+      "ratio": 1.0255,
+      "suggested_scalar": 0.0725,
+      "log_bad": -3.5936,
+      "log_good": -3.5684
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.848,
+      "good": 4.809,
+      "ratio": 0.992,
+      "suggested_scalar": -0.0233,
+      "log_bad": 1.5786,
+      "log_good": 1.5705
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 89.0,
+      "good": 87.0,
+      "ratio": 0.9775,
+      "suggested_scalar": -0.0656,
+      "log_bad": 4.4886,
+      "log_good": 4.4659
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5117,
+      "good": 0.4988,
+      "ratio": 0.9748,
+      "suggested_scalar": -0.0737,
+      "log_bad": -0.67,
+      "log_good": -0.6956
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.1991,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6972,
+      "good": 0.7281,
+      "ratio": 1.0443,
+      "suggested_scalar": 0.1251,
+      "log_bad": -0.3607,
+      "log_good": -0.3173
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.6571,
+      "good": 0.6757,
+      "ratio": 1.0283,
+      "suggested_scalar": 0.0805,
+      "log_bad": -0.4199,
+      "log_good": -0.392
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 255.0,
+      "good": 248.0,
+      "ratio": 0.9725,
+      "suggested_scalar": -0.0803,
+      "log_bad": 5.5413,
+      "log_good": 5.5134
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1143,
+      "good": 0.1081,
+      "ratio": 0.9458,
+      "suggested_scalar": -0.1609,
+      "log_bad": -2.1689,
+      "log_good": -2.2247
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8526,
+      "good": 0.8547,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0071,
+      "log_bad": -0.1595,
+      "log_good": -0.157
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 105.0,
+      "good": 107.0,
+      "ratio": 1.019,
+      "suggested_scalar": 0.0544,
+      "log_bad": 4.654,
+      "log_good": 4.6728
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 102.2131,
+      "good": 101.9727,
+      "ratio": 0.9976,
+      "suggested_scalar": -0.0068,
+      "log_bad": 4.6271,
+      "log_good": 4.6247
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.3543,
+      "good": 0.336,
+      "ratio": 0.9483,
+      "suggested_scalar": -0.153,
+      "log_bad": -1.0376,
+      "log_good": -1.0906
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 19.7003,
+      "good": 20.1408,
+      "ratio": 1.0224,
+      "suggested_scalar": 0.0638,
+      "log_bad": 2.9806,
+      "log_good": 3.0027
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1072.0,
+      "good": 1065.0,
+      "ratio": 0.9935,
+      "suggested_scalar": -0.0189,
+      "log_bad": 6.9773,
+      "log_good": 6.9707
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1429,
+      "good": 0.0811,
+      "ratio": 0.5675,
+      "suggested_scalar": -1.6345,
+      "log_bad": -1.9456,
+      "log_good": -2.5121
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8,
+      "good": 0.8108,
+      "ratio": 1.0135,
+      "suggested_scalar": 0.0387,
+      "log_bad": -0.2231,
+      "log_good": -0.2097
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.2857,
+      "good": 6.7027,
+      "ratio": 0.92,
+      "suggested_scalar": -0.2407,
+      "log_bad": 1.9859,
+      "log_good": 1.9025
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.4539,
+      "good": 0.4354,
+      "ratio": 0.9592,
+      "suggested_scalar": -0.1201,
+      "log_bad": -0.7899,
+      "log_good": -0.8315
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 72.0,
+      "good": 72.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2767,
+      "log_good": 4.2767
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.944,
+      "good": 0.9372,
+      "ratio": 0.9928,
+      "suggested_scalar": -0.0209,
+      "log_bad": -0.0576,
+      "log_good": -0.0649
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 22.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.2511,
+      "log_bad": 3.1781,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5103,
+      "good": 0.5089,
+      "ratio": 0.9973,
+      "suggested_scalar": -0.0079,
+      "log_bad": -0.6728,
+      "log_good": -0.6755
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.1621,
+      "good": 0.1463,
+      "ratio": 0.9025,
+      "suggested_scalar": -0.2959,
+      "log_bad": -1.8195,
+      "log_good": -1.9221
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.0419,
+      "good": 2.0363,
+      "ratio": 0.9973,
+      "suggested_scalar": -0.0079,
+      "log_bad": 0.7139,
+      "log_good": 0.7111
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 253.0,
+      "good": 246.0,
+      "ratio": 0.9723,
+      "suggested_scalar": -0.081,
+      "log_bad": 5.5334,
+      "log_good": 5.5053
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 18.0,
+      "good": 19.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.156,
+      "log_bad": 2.8904,
+      "log_good": 2.9444
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0039,
+      "good": 0.004,
+      "ratio": 1.0256,
+      "suggested_scalar": 0.0731,
+      "log_bad": -5.5468,
+      "log_good": -5.5215
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8074,
+      "good": 5.7814,
+      "ratio": 0.9955,
+      "suggested_scalar": -0.0129,
+      "log_bad": 1.7591,
+      "log_good": 1.7546
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 32.0,
+      "good": 34.0,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.1749,
+      "log_bad": 3.4657,
+      "log_good": 3.5264
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9596,
+      "good": 0.9732,
+      "ratio": 1.0142,
+      "suggested_scalar": 0.0406,
+      "log_bad": -0.0412,
+      "log_good": -0.0272
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7853,
+      "good": 5.7595,
+      "ratio": 0.9955,
+      "suggested_scalar": -0.0129,
+      "log_bad": 1.7553,
+      "log_good": 1.7509
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8348,
+      "good": 0.8318,
+      "ratio": 0.9964,
+      "suggested_scalar": -0.0104,
+      "log_bad": -0.1806,
+      "log_good": -0.1842
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2045,
+      "good": 0.1957,
+      "ratio": 0.957,
+      "suggested_scalar": -0.1269,
+      "log_bad": -1.5872,
+      "log_good": -1.6312
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.4385,
+      "good": 4.4879,
+      "ratio": 1.0111,
+      "suggested_scalar": 0.0319,
+      "log_bad": 1.4903,
+      "log_good": 1.5014
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 232.0,
+      "good": 227.0,
+      "ratio": 0.9784,
+      "suggested_scalar": -0.0629,
+      "log_bad": 5.4467,
+      "log_good": 5.425
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5073,
+      "good": 0.4918,
+      "ratio": 0.9694,
+      "suggested_scalar": -0.0895,
+      "log_bad": -0.6787,
+      "log_good": -0.7097
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 86.0,
+      "good": 84.0,
+      "ratio": 0.9767,
+      "suggested_scalar": -0.0679,
+      "log_bad": 4.4543,
+      "log_good": 4.4308
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 637.0,
+      "good": 652.0,
+      "ratio": 1.0235,
+      "suggested_scalar": 0.0672,
+      "log_bad": 6.4568,
+      "log_good": 6.48
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 119.0,
+      "good": 120.0,
+      "ratio": 1.0084,
+      "suggested_scalar": 0.0241,
+      "log_bad": 4.7791,
+      "log_good": 4.7875
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2118,
+      "good": 0.2177,
+      "ratio": 1.0279,
+      "suggested_scalar": 0.0793,
+      "log_bad": -1.5521,
+      "log_good": -1.5246
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 38.0,
+      "good": 34.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.3209,
+      "log_bad": 3.6376,
+      "log_good": 3.5264
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 86.0,
+      "good": 84.0,
+      "ratio": 0.9767,
+      "suggested_scalar": -0.0679,
+      "log_bad": 4.4543,
+      "log_good": 4.4308
+    },
+    "brevity.mean_sample_size": {
+      "bad": 86.0,
+      "good": 84.0,
+      "ratio": 0.9767,
+      "suggested_scalar": -0.0679,
+      "log_bad": 4.4543,
+      "log_good": 4.4308
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 255.0,
+      "good": 248.0,
+      "ratio": 0.9725,
+      "suggested_scalar": -0.0803,
+      "log_bad": 5.5413,
+      "log_good": 5.5134
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 120.0,
+      "good": 115.0,
+      "ratio": 0.9583,
+      "suggested_scalar": -0.1228,
+      "log_bad": 4.7875,
+      "log_good": 4.7449
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 202.0,
+      "good": 198.0,
+      "ratio": 0.9802,
+      "suggested_scalar": -0.0577,
+      "log_bad": 5.3083,
+      "log_good": 5.2883
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0039,
+      "good": 0.004,
+      "ratio": 1.0256,
+      "suggested_scalar": 0.0731,
+      "log_bad": -5.5468,
+      "log_good": -5.5215
+    },
+    "heaps.mean_k": {
+      "bad": 2.0617,
+      "good": 1.7368,
+      "ratio": 0.8424,
+      "suggested_scalar": -0.4948,
+      "log_bad": 0.7235,
+      "log_good": 0.552
+    },
+    "halstead.mean_effort": {
+      "bad": 33432.7173,
+      "good": 29962.6609,
+      "ratio": 0.8962,
+      "suggested_scalar": -0.3162,
+      "log_bad": 10.4173,
+      "log_good": 10.3077
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.9003,
+      "good": 0.901,
+      "ratio": 1.0008,
+      "suggested_scalar": 0.0022,
+      "log_bad": -0.105,
+      "log_good": -0.1043
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 65.0,
+      "good": 65.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.1744,
+      "log_good": 4.1744
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 116.0,
+      "good": 109.0,
+      "ratio": 0.9397,
+      "suggested_scalar": -0.1796,
+      "log_bad": 4.7536,
+      "log_good": 4.6913
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5143,
+      "good": 0.4953,
+      "ratio": 0.9631,
+      "suggested_scalar": -0.1086,
+      "log_bad": -0.6649,
+      "log_good": -0.7026
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0667,
+      "good": 6.0935,
+      "ratio": 1.0044,
+      "suggested_scalar": 0.0127,
+      "log_bad": 1.8028,
+      "log_good": 1.8072
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2045,
+      "good": 0.1957,
+      "ratio": 0.957,
+      "suggested_scalar": -0.1269,
+      "log_bad": -1.5872,
+      "log_good": -1.6312
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.5113,
+      "good": 3.2871,
+      "ratio": 0.9361,
+      "suggested_scalar": -0.1904,
+      "log_bad": 1.256,
+      "log_good": 1.19
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 254.0,
+      "good": 247.0,
+      "ratio": 0.9724,
+      "suggested_scalar": -0.0806,
+      "log_bad": 5.5373,
+      "log_good": 5.5094
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 20.0,
+      "good": 17.0,
+      "ratio": 0.85,
+      "suggested_scalar": -0.4689,
+      "log_bad": 2.9957,
+      "log_good": 2.8332
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1857.3732,
+      "good": 1664.5923,
+      "ratio": 0.8962,
+      "suggested_scalar": -0.3162,
+      "log_bad": 7.5269,
+      "log_good": 7.4173
+    },
+    "readability.mean_total_lines": {
+      "bad": 35.0,
+      "good": 37.0,
+      "ratio": 1.0571,
+      "suggested_scalar": 0.1603,
+      "log_bad": 3.5553,
+      "log_good": 3.6109
+    },
+    "indentation.mean_max_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_volume": {
+      "bad": 1521.7974,
+      "good": 1475.4341,
+      "ratio": 0.9695,
+      "suggested_scalar": -0.0893,
+      "log_bad": 7.3276,
+      "log_good": 7.2967
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 525.0,
+      "good": 523.0,
+      "ratio": 0.9962,
+      "suggested_scalar": -0.011,
+      "log_bad": 6.2634,
+      "log_good": 6.2596
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 29.3714,
+      "good": 27.5405,
+      "ratio": 0.9377,
+      "suggested_scalar": -0.1857,
+      "log_bad": 3.38,
+      "log_good": 3.3157
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1493,
+      "good": 1.1591,
+      "ratio": 1.0085,
+      "suggested_scalar": 0.0245,
+      "log_bad": 0.1392,
+      "log_good": 0.1476
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 22.0,
+      "good": 23.0,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.1283,
+      "log_bad": 3.091,
+      "log_good": 3.1355
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9138,
+      "good": 0.9251,
+      "ratio": 1.0124,
+      "suggested_scalar": 0.0355,
+      "log_bad": -0.0901,
+      "log_good": -0.0779
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9803,
+      "good": 0.9799,
+      "ratio": 0.9996,
+      "suggested_scalar": -0.0012,
+      "log_bad": -0.0199,
+      "log_good": -0.0203
+    },
+    "halstead.mean_length": {
+      "bad": 235.0,
+      "good": 229.0,
+      "ratio": 0.9745,
+      "suggested_scalar": -0.0746,
+      "log_bad": 5.4596,
+      "log_good": 5.4337
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 16.0,
+      "good": 16.5,
+      "ratio": 1.0313,
+      "suggested_scalar": 0.0888,
+      "log_bad": 2.7726,
+      "log_good": 2.8034
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4263,
+      "good": 6.3923,
+      "ratio": 0.9947,
+      "suggested_scalar": -0.0153,
+      "log_bad": 1.8604,
+      "log_good": 1.8551
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1119,
+      "good": 0.108,
+      "ratio": 0.9651,
+      "suggested_scalar": -0.1024,
+      "log_bad": -2.1901,
+      "log_good": -2.2256
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 21.9692,
+      "good": 20.3077,
+      "ratio": 0.9244,
+      "suggested_scalar": -0.2269,
+      "log_bad": 3.0896,
+      "log_good": 3.011
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 3.0,
+      "ratio": 0.6,
+      "suggested_scalar": -1.4739,
+      "log_bad": 1.6094,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 54.0,
+      "good": 53.0,
+      "ratio": 0.9815,
+      "suggested_scalar": -0.0539,
+      "log_bad": 3.989,
+      "log_good": 3.9703
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8119,
+      "good": 0.8283,
+      "ratio": 1.0202,
+      "suggested_scalar": 0.0577,
+      "log_bad": -0.2084,
+      "log_good": -0.1884
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 35.0,
+      "good": 37.0,
+      "ratio": 1.0571,
+      "suggested_scalar": 0.1603,
+      "log_bad": 3.5553,
+      "log_good": 3.6109
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "variable_naming.name_is_number_like": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 32.0,
+      "good": 92.0,
+      "ratio": 2.875,
+      "suggested_scalar": 0.6902,
+      "log_bad": 3.4657,
+      "log_good": 4.5218
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 56.0,
+      "good": 56.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0254,
+      "log_good": 4.0254
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.6667,
+      "good": 2.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9808,
+      "log_good": 0.9808
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0021,
+      "good": 0.0021,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.1658,
+      "log_good": -6.1658
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.2157,
+      "good": 1.2157,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1953,
+      "log_good": 0.1953
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9198,
+      "good": 0.9198,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0836,
+      "log_good": -0.0836
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0032,
+      "good": 0.0033,
+      "ratio": 1.0313,
+      "suggested_scalar": 0.0201,
+      "log_bad": -5.7446,
+      "log_good": -5.7138
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6833,
+      "good": 4.6306,
+      "ratio": 0.9887,
+      "suggested_scalar": -0.0074,
+      "log_bad": 1.544,
+      "log_good": 1.5327
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 128.3333,
+      "good": 124.0,
+      "ratio": 0.9662,
+      "suggested_scalar": -0.0224,
+      "log_bad": 4.8546,
+      "log_good": 4.8203
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5871,
+      "good": 0.5781,
+      "ratio": 0.9847,
+      "suggested_scalar": -0.0101,
+      "log_bad": -0.5326,
+      "log_good": -0.548
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.3333,
+      "good": 15.6667,
+      "ratio": 0.9592,
+      "suggested_scalar": -0.0272,
+      "log_bad": 2.7932,
+      "log_good": 2.7515
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5826,
+      "good": 0.603,
+      "ratio": 1.035,
+      "suggested_scalar": 0.0225,
+      "log_bad": -0.5403,
+      "log_good": -0.5058
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.5272,
+      "good": 2.5272,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9271,
+      "log_good": 0.9271
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 617.0,
+      "good": 610.0,
+      "ratio": 0.9887,
+      "suggested_scalar": -0.0075,
+      "log_bad": 6.4249,
+      "log_good": 6.4135
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0002,
+      "good": 0.0002,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -8.5172,
+      "log_good": -8.5172
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0182,
+      "good": 0.0182,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.0063,
+      "log_good": -4.0063
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0007,
+      "good": 0.0006,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.1007,
+      "log_bad": -7.2644,
+      "log_good": -7.4186
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9498,
+      "good": 0.9585,
+      "ratio": 1.0092,
+      "suggested_scalar": 0.006,
+      "log_bad": -0.0515,
+      "log_good": -0.0424
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 208.6667,
+      "good": 203.6667,
+      "ratio": 0.976,
+      "suggested_scalar": -0.0159,
+      "log_bad": 5.3407,
+      "log_good": 5.3165
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 105.3094,
+      "good": 88.2612,
+      "ratio": 0.8381,
+      "suggested_scalar": -0.1154,
+      "log_bad": 4.6569,
+      "log_good": 4.4803
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5358,
+      "good": 0.5411,
+      "ratio": 1.0099,
+      "suggested_scalar": 0.0064,
+      "log_bad": -0.624,
+      "log_good": -0.6142
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.1941,
+      "good": 21.2578,
+      "ratio": 2.0853,
+      "suggested_scalar": 0.4803,
+      "log_bad": 2.3218,
+      "log_good": 3.0567
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2477.3333,
+      "good": 2930.3333,
+      "ratio": 1.1829,
+      "suggested_scalar": 0.1098,
+      "log_bad": 7.8149,
+      "log_good": 7.9829
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.107,
+      "good": 0.107,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.2349,
+      "log_good": -2.2349
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8891,
+      "good": 0.8891,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1175,
+      "log_good": -0.1175
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.3088,
+      "good": 8.2145,
+      "ratio": 0.9887,
+      "suggested_scalar": -0.0075,
+      "log_bad": 2.1173,
+      "log_good": 2.1059
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 64.0,
+      "good": 3.0,
+      "ratio": 0.0469,
+      "suggested_scalar": -2.0,
+      "log_bad": 4.1589,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.1051,
+      "good": 2.1051,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.7444,
+      "log_good": 0.7444
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 123.3333,
+      "good": 161.3333,
+      "ratio": 1.3081,
+      "suggested_scalar": 0.1755,
+      "log_bad": 4.8149,
+      "log_good": 5.0835
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9494,
+      "good": 0.949,
+      "ratio": 0.9996,
+      "suggested_scalar": -0.0003,
+      "log_bad": -0.0519,
+      "log_good": -0.0523
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.3333,
+      "good": 25.3333,
+      "ratio": 0.962,
+      "suggested_scalar": -0.0253,
+      "log_bad": 3.2708,
+      "log_good": 3.2321
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6299,
+      "good": 0.6675,
+      "ratio": 1.0597,
+      "suggested_scalar": 0.0379,
+      "log_bad": -0.4622,
+      "log_good": -0.4042
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3347,
+      "good": 0.3365,
+      "ratio": 1.0054,
+      "suggested_scalar": 0.0035,
+      "log_bad": -1.0945,
+      "log_good": -1.0892
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7038,
+      "good": 3.0076,
+      "ratio": 1.1124,
+      "suggested_scalar": 0.0696,
+      "log_bad": 0.9947,
+      "log_good": 1.1011
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 615.0,
+      "good": 608.0,
+      "ratio": 0.9886,
+      "suggested_scalar": -0.0075,
+      "log_bad": 6.4216,
+      "log_good": 6.4102
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 14.3333,
+      "good": 14.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6626,
+      "log_good": 2.6626
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0225,
+      "good": 0.0228,
+      "ratio": 1.0133,
+      "suggested_scalar": 0.0087,
+      "log_bad": -3.7942,
+      "log_good": -3.781
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8544,
+      "good": 5.7921,
+      "ratio": 0.9894,
+      "suggested_scalar": -0.007,
+      "log_bad": 1.7672,
+      "log_good": 1.7565
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 10.6667,
+      "good": 10.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3671,
+      "log_good": 2.3671
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3042,
+      "good": 0.6345,
+      "ratio": 0.4865,
+      "suggested_scalar": -0.4709,
+      "log_bad": 0.2656,
+      "log_good": -0.4549
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7761,
+      "good": 5.727,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0056,
+      "log_bad": 1.7537,
+      "log_good": 1.7452
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8,
+      "good": 0.7996,
+      "ratio": 0.9995,
+      "suggested_scalar": -0.0003,
+      "log_bad": -0.2231,
+      "log_good": -0.2236
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1246,
+      "good": 0.1246,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.0826,
+      "log_good": -2.0826
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1927,
+      "good": 4.6085,
+      "ratio": 1.4434,
+      "suggested_scalar": 0.2399,
+      "log_bad": 1.1609,
+      "log_good": 1.5279
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 0.6667,
+      "good": 0.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.4054,
+      "log_good": -0.4054
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 469.3333,
+      "good": 462.6667,
+      "ratio": 0.9858,
+      "suggested_scalar": -0.0093,
+      "log_bad": 6.1513,
+      "log_good": 6.137
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 20.3333,
+      "good": 20.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0123,
+      "log_good": 3.0123
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.3931,
+      "good": 1.3714,
+      "ratio": 0.9844,
+      "suggested_scalar": -0.0103,
+      "log_bad": 0.3315,
+      "log_good": 0.3158
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 135.6667,
+      "good": 130.3333,
+      "ratio": 0.9607,
+      "suggested_scalar": -0.0262,
+      "log_bad": 4.9102,
+      "log_good": 4.8701
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1259.6667,
+      "good": 1718.6667,
+      "ratio": 1.3644,
+      "suggested_scalar": 0.2031,
+      "log_bad": 7.1386,
+      "log_good": 7.4493
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 229.3333,
+      "good": 226.0,
+      "ratio": 0.9855,
+      "suggested_scalar": -0.0096,
+      "log_bad": 5.4352,
+      "log_good": 5.4205
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0036,
+      "good": 0.0036,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.6268,
+      "log_good": -5.6268
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2903,
+      "good": 0.2904,
+      "ratio": 1.0003,
+      "suggested_scalar": 0.0002,
+      "log_bad": -1.2368,
+      "log_good": -1.2365
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 91.6667,
+      "good": 90.6667,
+      "ratio": 0.9891,
+      "suggested_scalar": -0.0072,
+      "log_bad": 4.5182,
+      "log_good": 4.5072
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 21.6667,
+      "good": 21.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0758,
+      "log_good": 3.0758
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 135.6667,
+      "good": 130.3333,
+      "ratio": 0.9607,
+      "suggested_scalar": -0.0262,
+      "log_bad": 4.9102,
+      "log_good": 4.8701
+    },
+    "brevity.mean_sample_size": {
+      "bad": 135.6667,
+      "good": 130.3333,
+      "ratio": 0.9607,
+      "suggested_scalar": -0.0262,
+      "log_bad": 4.9102,
+      "log_good": 4.8701
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 617.0,
+      "good": 610.0,
+      "ratio": 0.9887,
+      "suggested_scalar": -0.0075,
+      "log_bad": 6.4249,
+      "log_good": 6.4135
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 313.3333,
+      "good": 311.3333,
+      "ratio": 0.9936,
+      "suggested_scalar": -0.0042,
+      "log_bad": 5.7473,
+      "log_good": 5.7409
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 371.6667,
+      "good": 364.6667,
+      "ratio": 0.9812,
+      "suggested_scalar": -0.0124,
+      "log_bad": 5.918,
+      "log_good": 5.899
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.001,
+      "good": 0.001,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.9078,
+      "log_good": -6.9078
+    },
+    "heaps.mean_k": {
+      "bad": 3.5358,
+      "good": 2.9947,
+      "ratio": 0.847,
+      "suggested_scalar": -0.1085,
+      "log_bad": 1.2629,
+      "log_good": 1.0968
+    },
+    "halstead.mean_effort": {
+      "bad": 127376.4,
+      "good": 122707.6615,
+      "ratio": 0.9633,
+      "suggested_scalar": -0.0244,
+      "log_bad": 11.7549,
+      "log_good": 11.7176
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8157,
+      "good": 0.8156,
+      "ratio": 0.9999,
+      "suggested_scalar": -0.0001,
+      "log_bad": -0.2037,
+      "log_good": -0.2038
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 102.0,
+      "good": 98.6667,
+      "ratio": 0.9673,
+      "suggested_scalar": -0.0217,
+      "log_bad": 4.625,
+      "log_good": 4.5917
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 366.6667,
+      "good": 364.6667,
+      "ratio": 0.9945,
+      "suggested_scalar": -0.0036,
+      "log_bad": 5.9045,
+      "log_good": 5.899
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.488,
+      "good": 0.4768,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0152,
+      "log_bad": -0.7174,
+      "log_good": -0.7407
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0449,
+      "good": 8.4656,
+      "ratio": 1.4005,
+      "suggested_scalar": 0.2201,
+      "log_bad": 1.7992,
+      "log_good": 2.136
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1246,
+      "good": 0.1246,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.0826,
+      "log_good": -2.0826
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.3235,
+      "good": 3.5593,
+      "ratio": 1.0709,
+      "suggested_scalar": 0.0448,
+      "log_bad": 1.201,
+      "log_good": 1.2696
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 616.0,
+      "good": 609.0,
+      "ratio": 0.9886,
+      "suggested_scalar": -0.0075,
+      "log_bad": 6.4232,
+      "log_good": 6.4118
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 65.0,
+      "good": 63.6667,
+      "ratio": 0.9795,
+      "suggested_scalar": -0.0135,
+      "log_bad": 4.1744,
+      "log_good": 4.1537
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 7076.4667,
+      "good": 6817.0923,
+      "ratio": 0.9633,
+      "suggested_scalar": -0.0244,
+      "log_bad": 8.8645,
+      "log_good": 8.8272
+    },
+    "readability.mean_total_lines": {
+      "bad": 74.3333,
+      "good": 74.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3086,
+      "log_good": 4.3086
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 4179.208,
+      "good": 4114.2293,
+      "ratio": 0.9845,
+      "suggested_scalar": -0.0102,
+      "log_bad": 8.3379,
+      "log_good": 8.3222
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 914.3333,
+      "good": 974.3333,
+      "ratio": 1.0656,
+      "suggested_scalar": 0.0415,
+      "log_bad": 6.8182,
+      "log_good": 6.8818
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.6319,
+      "good": 37.702,
+      "ratio": 1.1919,
+      "suggested_scalar": 0.1147,
+      "log_bad": 3.4542,
+      "log_good": 3.6297
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1004,
+      "good": 1.303,
+      "ratio": 1.1841,
+      "suggested_scalar": 0.1104,
+      "log_bad": 0.0957,
+      "log_good": 0.2647
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 26.3333,
+      "good": 26.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2708,
+      "log_good": 3.2708
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8627,
+      "good": 0.8632,
+      "ratio": 1.0006,
+      "suggested_scalar": 0.0004,
+      "log_bad": -0.1477,
+      "log_good": -0.1471
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.98,
+      "good": 0.9869,
+      "ratio": 1.007,
+      "suggested_scalar": 0.0046,
+      "log_bad": -0.0202,
+      "log_good": -0.0132
+    },
+    "halstead.mean_length": {
+      "bad": 596.0,
+      "good": 590.6667,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.0059,
+      "log_bad": 6.3902,
+      "log_good": 6.3813
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 3.7417,
+      "good": 3.7417,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3195,
+      "log_good": 1.3195
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.0824,
+      "good": 7.0239,
+      "ratio": 0.9917,
+      "suggested_scalar": -0.0054,
+      "log_bad": 1.9576,
+      "log_good": 1.9493
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1248,
+      "good": 0.1049,
+      "ratio": 0.8405,
+      "suggested_scalar": -0.1135,
+      "log_bad": -2.081,
+      "log_good": -2.2547
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.6888,
+      "good": 29.0645,
+      "ratio": 0.979,
+      "suggested_scalar": -0.0139,
+      "log_bad": 3.3908,
+      "log_good": 3.3695
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 101.6667,
+      "good": 97.0,
+      "ratio": 0.9541,
+      "suggested_scalar": -0.0307,
+      "log_bad": 4.6217,
+      "log_good": 4.5747
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7534,
+      "good": 0.7509,
+      "ratio": 0.9967,
+      "suggested_scalar": -0.0022,
+      "log_bad": -0.2832,
+      "log_good": -0.2865
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 75.0,
+      "good": 75.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3175,
+      "log_good": 4.3175
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 0.3333,
+      "good": 0.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.0987,
+      "log_good": -1.0987
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.6667,
+      "good": 18.3333,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0623,
+      "log_bad": 2.8134,
+      "log_good": 2.9087
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "scope_and_assignment.mutated_after_initial_assignment": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 31.0,
+      "good": 16.0,
+      "ratio": 0.5161,
+      "suggested_scalar": -0.1967,
+      "log_bad": 3.434,
+      "log_good": 2.7726
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0056,
+      "good": 0.0064,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.0397,
+      "log_bad": -5.185,
+      "log_good": -5.0515
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9434,
+      "good": 0.9091,
+      "ratio": 0.9636,
+      "suggested_scalar": -0.011,
+      "log_bad": -0.0583,
+      "log_good": -0.0953
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0056,
+      "good": 0.0064,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.0397,
+      "log_bad": -5.185,
+      "log_good": -5.0515
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6313,
+      "good": 4.578,
+      "ratio": 0.9885,
+      "suggested_scalar": -0.0034,
+      "log_bad": 1.5328,
+      "log_good": 1.5213
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 78.0,
+      "good": 82.0,
+      "ratio": 1.0513,
+      "suggested_scalar": 0.0149,
+      "log_bad": 4.3567,
+      "log_good": 4.4067
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.2883,
+      "good": 0.37,
+      "ratio": 1.2834,
+      "suggested_scalar": 0.0742,
+      "log_bad": -1.2438,
+      "log_good": -0.9943
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 22.0,
+      "ratio": 1.1579,
+      "suggested_scalar": 0.0436,
+      "log_bad": 2.9444,
+      "log_good": 3.091
+    },
+    "heaps.mean_beta": {
+      "bad": 0.4877,
+      "good": 0.5394,
+      "ratio": 1.106,
+      "suggested_scalar": 0.03,
+      "log_bad": -0.7181,
+      "log_good": -0.6173
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.434,
+      "good": 4.7727,
+      "ratio": 1.3898,
+      "suggested_scalar": 0.0979,
+      "log_bad": 1.2337,
+      "log_good": 1.5629
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 534.0,
+      "good": 468.0,
+      "ratio": 0.8764,
+      "suggested_scalar": -0.0392,
+      "log_bad": 6.2804,
+      "log_good": 6.1485
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0856,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 0.0012,
+      "ratio": 0.0012,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.7254
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1509,
+      "good": 1.0387,
+      "ratio": 0.9025,
+      "suggested_scalar": -0.0305,
+      "log_bad": 0.1405,
+      "log_good": 0.038
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 198.0,
+      "good": 160.0,
+      "ratio": 0.8081,
+      "suggested_scalar": -0.0634,
+      "log_bad": 5.2883,
+      "log_good": 5.0752
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 105.9924,
+      "good": 105.9674,
+      "ratio": 0.9998,
+      "suggested_scalar": -0.0001,
+      "log_bad": 4.6634,
+      "log_good": 4.6631
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6829,
+      "good": 0.6188,
+      "ratio": 0.9061,
+      "suggested_scalar": -0.0293,
+      "log_bad": -0.3814,
+      "log_good": -0.48
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 5.9935,
+      "good": 7.1498,
+      "ratio": 1.1929,
+      "suggested_scalar": 0.0525,
+      "log_bad": 1.7907,
+      "log_good": 1.9671
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2013.0,
+      "good": 1704.0,
+      "ratio": 0.8465,
+      "suggested_scalar": -0.0496,
+      "log_bad": 7.6074,
+      "log_good": 7.4407
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1132,
+      "good": 0.2273,
+      "ratio": 2.008,
+      "suggested_scalar": 0.2073,
+      "log_bad": -2.1786,
+      "log_good": -1.4815
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9245,
+      "good": 0.8636,
+      "ratio": 0.9341,
+      "suggested_scalar": -0.0203,
+      "log_bad": -0.0785,
+      "log_good": -0.1466
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.0755,
+      "good": 10.6364,
+      "ratio": 1.0557,
+      "suggested_scalar": 0.0161,
+      "log_bad": 2.3101,
+      "log_good": 2.3643
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.1136,
+      "good": 8.0393,
+      "ratio": 7.2192,
+      "suggested_scalar": 0.5878,
+      "log_bad": 0.1076,
+      "log_good": 2.0843
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 172.0,
+      "good": 147.0,
+      "ratio": 0.8547,
+      "suggested_scalar": -0.0467,
+      "log_bad": 5.1475,
+      "log_good": 4.9904
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9207,
+      "good": 0.9333,
+      "ratio": 1.0137,
+      "suggested_scalar": 0.004,
+      "log_bad": -0.0826,
+      "log_good": -0.069
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 28.0,
+      "ratio": 1.12,
+      "suggested_scalar": 0.0337,
+      "log_bad": 3.2189,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6706,
+      "good": 0.608,
+      "ratio": 0.9067,
+      "suggested_scalar": -0.0291,
+      "log_bad": -0.3996,
+      "log_good": -0.4976
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4718,
+      "good": 0.3927,
+      "ratio": 0.8323,
+      "suggested_scalar": -0.0546,
+      "log_bad": -0.7512,
+      "log_good": -0.9347
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0362,
+      "good": 2.5509,
+      "ratio": 0.8402,
+      "suggested_scalar": -0.0518,
+      "log_bad": 1.1106,
+      "log_good": 0.9364
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 532.0,
+      "good": 466.0,
+      "ratio": 0.8759,
+      "suggested_scalar": -0.0394,
+      "log_bad": 6.2766,
+      "log_good": 6.1442
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 19.0,
+      "good": 16.0,
+      "ratio": 0.8421,
+      "suggested_scalar": -0.0511,
+      "log_bad": 2.9444,
+      "log_good": 2.7726
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.03,
+      "good": 0.0983,
+      "ratio": 3.2767,
+      "suggested_scalar": 0.3529,
+      "log_bad": -3.5066,
+      "log_good": -2.3197
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7814,
+      "good": 5.858,
+      "ratio": 1.0132,
+      "suggested_scalar": 0.0039,
+      "log_bad": 1.7546,
+      "log_good": 1.7678
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 26.0,
+      "good": 13.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2061,
+      "log_bad": 3.2581,
+      "log_good": 2.5649
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.561,
+      "good": 0.4066,
+      "ratio": 0.7248,
+      "suggested_scalar": -0.0957,
+      "log_bad": -0.578,
+      "log_good": -0.8999
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.3693,
+      "good": 5.5194,
+      "ratio": 1.028,
+      "suggested_scalar": 0.0082,
+      "log_bad": 1.6807,
+      "log_good": 1.7083
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8011,
+      "good": 0.7815,
+      "ratio": 0.9755,
+      "suggested_scalar": -0.0074,
+      "log_bad": -0.2218,
+      "log_good": -0.2465
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2933,
+      "good": 0.2,
+      "ratio": 0.6819,
+      "suggested_scalar": -0.1139,
+      "log_bad": -1.2266,
+      "log_good": -1.6094
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.4482,
+      "good": 2.6739,
+      "ratio": 1.0922,
+      "suggested_scalar": 0.0262,
+      "log_bad": 0.8954,
+      "log_good": 0.9835
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 11.0,
+      "good": 1.0,
+      "ratio": 0.0909,
+      "suggested_scalar": -0.7131,
+      "log_bad": 2.3979,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 351.0,
+      "good": 351.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.8608,
+      "log_good": 5.8608
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 9.0,
+      "ratio": 4.5,
+      "suggested_scalar": 0.4473,
+      "log_bad": 0.6931,
+      "log_good": 2.1972
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0769,
+      "good": 0.9579,
+      "ratio": 0.8895,
+      "suggested_scalar": -0.0348,
+      "log_bad": 0.0741,
+      "log_good": -0.043
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 86.0,
+      "good": 88.0,
+      "ratio": 1.0233,
+      "suggested_scalar": 0.0068,
+      "log_bad": 4.4543,
+      "log_good": 4.4773
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1172.0,
+      "good": 878.0,
+      "ratio": 0.7491,
+      "suggested_scalar": -0.0859,
+      "log_bad": 7.0665,
+      "log_good": 6.7776
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 217.0,
+      "good": 176.0,
+      "ratio": 0.8111,
+      "suggested_scalar": -0.0623,
+      "log_bad": 5.3799,
+      "log_good": 5.1705
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 0.0064,
+      "ratio": 0.0064,
+      "suggested_scalar": -1.5022,
+      "log_bad": 0.0,
+      "log_good": -5.0515
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2547,
+      "good": 0.3056,
+      "ratio": 1.1998,
+      "suggested_scalar": 0.0542,
+      "log_bad": -1.3677,
+      "log_good": -1.1855
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 91.0,
+      "good": 88.0,
+      "ratio": 0.967,
+      "suggested_scalar": -0.01,
+      "log_bad": 4.5109,
+      "log_good": 4.4773
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 86.0,
+      "good": 88.0,
+      "ratio": 1.0233,
+      "suggested_scalar": 0.0068,
+      "log_bad": 4.4543,
+      "log_good": 4.4773
+    },
+    "brevity.mean_sample_size": {
+      "bad": 86.0,
+      "good": 88.0,
+      "ratio": 1.0233,
+      "suggested_scalar": 0.0068,
+      "log_bad": 4.4543,
+      "log_good": 4.4773
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 534.0,
+      "good": 468.0,
+      "ratio": 0.8764,
+      "suggested_scalar": -0.0392,
+      "log_bad": 6.2804,
+      "log_good": 6.1485
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 285.0,
+      "good": 249.0,
+      "ratio": 0.8737,
+      "suggested_scalar": -0.0402,
+      "log_bad": 5.6525,
+      "log_good": 5.5175
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 260.0,
+      "good": 266.0,
+      "ratio": 1.0231,
+      "suggested_scalar": 0.0068,
+      "log_bad": 5.5607,
+      "log_good": 5.5835
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0206,
+      "good": 0.0021,
+      "ratio": 0.1019,
+      "suggested_scalar": -0.679,
+      "log_bad": -3.8825,
+      "log_good": -6.1658
+    },
+    "heaps.mean_k": {
+      "bad": 4.2816,
+      "good": 3.2998,
+      "ratio": 0.7707,
+      "suggested_scalar": -0.0775,
+      "log_bad": 1.4543,
+      "log_good": 1.1939
+    },
+    "halstead.mean_effort": {
+      "bad": 165344.6209,
+      "good": 131121.92,
+      "ratio": 0.793,
+      "suggested_scalar": -0.069,
+      "log_bad": 12.0158,
+      "log_good": 11.7839
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8355,
+      "good": 0.8545,
+      "ratio": 1.0227,
+      "suggested_scalar": 0.0067,
+      "log_bad": -0.1797,
+      "log_good": -0.1572
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 53.0,
+      "good": 54.0,
+      "ratio": 1.0189,
+      "suggested_scalar": 0.0056,
+      "log_bad": 3.9703,
+      "log_good": 3.989
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 297.0,
+      "good": 276.0,
+      "ratio": 0.9293,
+      "suggested_scalar": -0.0218,
+      "log_bad": 5.6937,
+      "log_good": 5.6204
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.2727,
+      "good": 0.3187,
+      "ratio": 1.1687,
+      "suggested_scalar": 0.0464,
+      "log_bad": -1.2994,
+      "log_good": -1.1435
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.9192,
+      "good": 5.4875,
+      "ratio": 0.9271,
+      "suggested_scalar": -0.0225,
+      "log_bad": 1.7782,
+      "log_good": 1.7025
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2933,
+      "good": 0.2,
+      "ratio": 0.6819,
+      "suggested_scalar": -0.1139,
+      "log_bad": -1.2266,
+      "log_good": -1.6094
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.208,
+      "good": 4.4536,
+      "ratio": 1.0584,
+      "suggested_scalar": 0.0169,
+      "log_bad": 1.437,
+      "log_good": 1.4937
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 533.0,
+      "good": 467.0,
+      "ratio": 0.8762,
+      "suggested_scalar": -0.0393,
+      "log_bad": 6.2785,
+      "log_good": 6.1463
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0497,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 70.0,
+      "good": 68.0,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.0086,
+      "log_bad": 4.2485,
+      "log_good": 4.2195
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 9185.8123,
+      "good": 7284.5511,
+      "ratio": 0.793,
+      "suggested_scalar": -0.069,
+      "log_bad": 9.1254,
+      "log_good": 8.8935
+    },
+    "readability.mean_total_lines": {
+      "bad": 53.0,
+      "good": 44.0,
+      "ratio": 0.8302,
+      "suggested_scalar": -0.0553,
+      "log_bad": 3.9703,
+      "log_good": 3.7842
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 10.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.2725,
+      "log_bad": 1.3863,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 3230.6967,
+      "good": 2873.6135,
+      "ratio": 0.8895,
+      "suggested_scalar": -0.0348,
+      "log_bad": 8.0805,
+      "log_good": 7.9633
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 663.0,
+      "good": 668.0,
+      "ratio": 1.0075,
+      "suggested_scalar": 0.0022,
+      "log_bad": 6.4968,
+      "log_good": 6.5043
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 36.5283,
+      "good": 37.4318,
+      "ratio": 1.0247,
+      "suggested_scalar": 0.0073,
+      "log_bad": 3.5981,
+      "log_good": 3.6225
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0711,
+      "good": 1.0647,
+      "ratio": 0.994,
+      "suggested_scalar": -0.0018,
+      "log_bad": 0.0687,
+      "log_good": 0.0627
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0856,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 36.0,
+      "good": 23.0,
+      "ratio": 0.6389,
+      "suggested_scalar": -0.1332,
+      "log_bad": 3.5835,
+      "log_good": 3.1355
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8006,
+      "good": 0.8063,
+      "ratio": 1.0071,
+      "suggested_scalar": 0.0021,
+      "log_bad": -0.2224,
+      "log_good": -0.2153
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.956,
+      "good": 0.9766,
+      "ratio": 1.0215,
+      "suggested_scalar": 0.0063,
+      "log_bad": -0.045,
+      "log_good": -0.0237
+    },
+    "halstead.mean_length": {
+      "bad": 514.0,
+      "good": 452.0,
+      "ratio": 0.8794,
+      "suggested_scalar": -0.0382,
+      "log_bad": 6.2422,
+      "log_good": 6.1137
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 17.5,
+      "good": 12.5,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.1001,
+      "log_bad": 2.8622,
+      "log_good": 2.5257
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4263,
+      "good": 6.4594,
+      "ratio": 1.0052,
+      "suggested_scalar": 0.0015,
+      "log_bad": 1.8604,
+      "log_good": 1.8655
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1417,
+      "good": 0.1463,
+      "ratio": 1.0325,
+      "suggested_scalar": 0.0095,
+      "log_bad": -1.954,
+      "log_good": -1.9221
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 51.1792,
+      "good": 45.6296,
+      "ratio": 0.8916,
+      "suggested_scalar": -0.0341,
+      "log_bad": 3.9353,
+      "log_good": 3.8206
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 10.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.1519,
+      "log_bad": 1.7918,
+      "log_good": 2.3026
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 54.0,
+      "good": 51.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.017,
+      "log_bad": 3.989,
+      "log_good": 3.9318
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.65,
+      "good": 0.6692,
+      "ratio": 1.0295,
+      "suggested_scalar": 0.0087,
+      "log_bad": -0.4308,
+      "log_good": -0.4017
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 53.0,
+      "good": 44.0,
+      "ratio": 0.8302,
+      "suggested_scalar": -0.0553,
+      "log_bad": 3.9703,
+      "log_good": 3.7842
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.uses_standard_library_constants": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 10.0,
+      "good": 11.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.1324,
+      "log_bad": 2.3026,
+      "log_good": 2.3979
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.125,
+      "good": 1.1111,
+      "ratio": 0.9876,
+      "suggested_scalar": -0.0173,
+      "log_bad": 0.1178,
+      "log_good": 0.1054
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.6905,
+      "good": 0.6818,
+      "ratio": 0.9874,
+      "suggested_scalar": -0.0176,
+      "log_bad": -0.3703,
+      "log_good": -0.383
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8261,
+      "good": 4.754,
+      "ratio": 0.9851,
+      "suggested_scalar": -0.0209,
+      "log_bad": 1.574,
+      "log_good": 1.559
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 73.0,
+      "good": 64.0,
+      "ratio": 0.8767,
+      "suggested_scalar": -0.1828,
+      "log_bad": 4.2905,
+      "log_good": 4.1589
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4348,
+      "good": 0.3793,
+      "ratio": 0.8724,
+      "suggested_scalar": -0.1897,
+      "log_bad": -0.8329,
+      "log_good": -0.9694
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 17.0,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.0842,
+      "log_bad": 2.7726,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5992,
+      "good": 0.6091,
+      "ratio": 1.0165,
+      "suggested_scalar": 0.0228,
+      "log_bad": -0.5122,
+      "log_good": -0.4958
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.619,
+      "good": 3.4545,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.0646,
+      "log_bad": 1.2862,
+      "log_good": 1.2397
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 301.0,
+      "good": 302.0,
+      "ratio": 1.0033,
+      "suggested_scalar": 0.0046,
+      "log_bad": 5.7071,
+      "log_good": 5.7104
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1667,
+      "good": 0.1136,
+      "ratio": 0.6815,
+      "suggested_scalar": -0.5327,
+      "log_bad": -1.7916,
+      "log_good": -2.1751
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9745,
+      "good": 1.0213,
+      "ratio": 1.048,
+      "suggested_scalar": 0.0652,
+      "log_bad": -0.0258,
+      "log_good": 0.0211
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 92.0,
+      "good": 87.0,
+      "ratio": 0.9457,
+      "suggested_scalar": -0.0776,
+      "log_bad": 4.5218,
+      "log_good": 4.4659
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 109.6928,
+      "good": 107.5264,
+      "ratio": 0.9803,
+      "suggested_scalar": -0.0277,
+      "log_bad": 4.6977,
+      "log_good": 4.6777
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6733,
+      "good": 0.6811,
+      "ratio": 1.0116,
+      "suggested_scalar": 0.016,
+      "log_bad": -0.3956,
+      "log_good": -0.384
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 12.4228,
+      "good": 12.7272,
+      "ratio": 1.0245,
+      "suggested_scalar": 0.0336,
+      "log_bad": 2.5195,
+      "log_good": 2.5437
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1247.0,
+      "good": 1192.0,
+      "ratio": 0.9559,
+      "suggested_scalar": -0.0627,
+      "log_bad": 7.1285,
+      "log_good": 7.0834
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6667,
+      "good": 0.6591,
+      "ratio": 0.9886,
+      "suggested_scalar": -0.0159,
+      "log_bad": -0.4054,
+      "log_good": -0.4169
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.525,
+      "good": 7.1905,
+      "ratio": 0.9555,
+      "suggested_scalar": -0.0632,
+      "log_bad": 2.0182,
+      "log_good": 1.9728
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 8.9977,
+      "good": 8.4298,
+      "ratio": 0.9369,
+      "suggested_scalar": -0.0906,
+      "log_bad": 2.197,
+      "log_good": 2.1318
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 55.0,
+      "good": 47.0,
+      "ratio": 0.8545,
+      "suggested_scalar": -0.2183,
+      "log_bad": 4.0073,
+      "log_good": 3.8501
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9153,
+      "good": 0.8598,
+      "ratio": 0.9394,
+      "suggested_scalar": -0.0869,
+      "log_bad": -0.0885,
+      "log_good": -0.1511
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 20.0,
+      "good": 23.0,
+      "ratio": 1.15,
+      "suggested_scalar": 0.1941,
+      "log_bad": 2.9957,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.599,
+      "good": 0.6258,
+      "ratio": 1.0447,
+      "suggested_scalar": 0.0608,
+      "log_bad": -0.5125,
+      "log_good": -0.4687
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5552,
+      "good": 0.52,
+      "ratio": 0.9366,
+      "suggested_scalar": -0.091,
+      "log_bad": -0.5884,
+      "log_good": -0.6539
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.494,
+      "good": 2.6726,
+      "ratio": 1.0716,
+      "suggested_scalar": 0.0961,
+      "log_bad": 0.9139,
+      "log_good": 0.9831
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 299.0,
+      "good": 300.0,
+      "ratio": 1.0033,
+      "suggested_scalar": 0.0046,
+      "log_bad": 5.7004,
+      "log_good": 5.7038
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 13.0,
+      "good": 14.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.1029,
+      "log_bad": 2.5649,
+      "log_good": 2.6391
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0664,
+      "good": 0.0397,
+      "ratio": 0.5979,
+      "suggested_scalar": -0.7144,
+      "log_bad": -2.7121,
+      "log_good": -3.2264
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0,
+      "good": 5.9542,
+      "ratio": 0.9924,
+      "suggested_scalar": -0.0106,
+      "log_bad": 1.7918,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4321,
+      "good": 1.6211,
+      "ratio": 1.132,
+      "suggested_scalar": 0.1722,
+      "log_bad": 0.3591,
+      "log_good": 0.4831
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0109,
+      "good": 0.046,
+      "ratio": 4.2202,
+      "suggested_scalar": 2.0,
+      "log_bad": -4.519,
+      "log_good": -3.0791
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5144,
+      "good": 5.3324,
+      "ratio": 0.967,
+      "suggested_scalar": -0.0466,
+      "log_bad": 1.7074,
+      "log_good": 1.6738
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8044,
+      "good": 0.7984,
+      "ratio": 0.9925,
+      "suggested_scalar": -0.0104,
+      "log_bad": -0.2177,
+      "log_good": -0.2251
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1765,
+      "good": 0.2,
+      "ratio": 1.1331,
+      "suggested_scalar": 0.1736,
+      "log_bad": -1.7344,
+      "log_good": -1.6094
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.5246,
+      "good": 3.5675,
+      "ratio": 1.0122,
+      "suggested_scalar": 0.0168,
+      "log_bad": 1.2598,
+      "log_good": 1.2719
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 11.0,
+      "good": 7.0,
+      "ratio": 0.6364,
+      "suggested_scalar": -0.6278,
+      "log_bad": 2.3979,
+      "log_good": 1.9459
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 189.0,
+      "good": 195.0,
+      "ratio": 1.0317,
+      "suggested_scalar": 0.0434,
+      "log_bad": 5.2417,
+      "log_good": 5.273
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6149,
+      "good": 0.596,
+      "ratio": 0.9693,
+      "suggested_scalar": -0.0434,
+      "log_bad": -0.4863,
+      "log_good": -0.5175
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 78.0,
+      "good": 66.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.232,
+      "log_bad": 4.3567,
+      "log_good": 4.1897
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 509.0,
+      "good": 485.0,
+      "ratio": 0.9528,
+      "suggested_scalar": -0.0671,
+      "log_bad": 6.2324,
+      "log_good": 6.1841
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 124.0,
+      "good": 117.0,
+      "ratio": 0.9435,
+      "suggested_scalar": -0.0807,
+      "log_bad": 4.8203,
+      "log_good": 4.7622
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0266,
+      "good": 0.0298,
+      "ratio": 1.1203,
+      "suggested_scalar": 0.1578,
+      "log_bad": -3.6268,
+      "log_good": -3.5132
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1894,
+      "good": 0.1954,
+      "ratio": 1.0317,
+      "suggested_scalar": 0.0433,
+      "log_bad": -1.6639,
+      "log_good": -1.6327
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 57.0,
+      "good": 58.0,
+      "ratio": 1.0175,
+      "suggested_scalar": 0.0242,
+      "log_bad": 4.0431,
+      "log_good": 4.0604
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 8.0,
+      "good": 9.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.1636,
+      "log_bad": 2.0794,
+      "log_good": 2.1972
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 78.0,
+      "good": 66.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.232,
+      "log_bad": 4.3567,
+      "log_good": 4.1897
+    },
+    "brevity.mean_sample_size": {
+      "bad": 78.0,
+      "good": 66.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.232,
+      "log_bad": 4.3567,
+      "log_good": 4.1897
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 301.0,
+      "good": 302.0,
+      "ratio": 1.0033,
+      "suggested_scalar": 0.0046,
+      "log_bad": 5.7071,
+      "log_good": 5.7104
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 159.0,
+      "good": 163.0,
+      "ratio": 1.0252,
+      "suggested_scalar": 0.0345,
+      "log_bad": 5.0689,
+      "log_good": 5.0938
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 155.0,
+      "good": 154.0,
+      "ratio": 0.9935,
+      "suggested_scalar": -0.009,
+      "log_bad": 5.0434,
+      "log_good": 5.037
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0365,
+      "good": 0.0232,
+      "ratio": 0.6356,
+      "suggested_scalar": -0.6294,
+      "log_bad": -3.3104,
+      "log_good": -3.7636
+    },
+    "heaps.mean_k": {
+      "bad": 2.6986,
+      "good": 2.2302,
+      "ratio": 0.8264,
+      "suggested_scalar": -0.2648,
+      "log_bad": 0.9927,
+      "log_good": 0.8021
+    },
+    "halstead.mean_effort": {
+      "bad": 43155.924,
+      "good": 58676.9268,
+      "ratio": 1.3596,
+      "suggested_scalar": 0.4267,
+      "log_bad": 10.6726,
+      "log_good": 10.9798
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8773,
+      "good": 0.8822,
+      "ratio": 1.0056,
+      "suggested_scalar": 0.0077,
+      "log_bad": -0.1309,
+      "log_good": -0.1253
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 53.0,
+      "good": 41.0,
+      "ratio": 0.7736,
+      "suggested_scalar": -0.3566,
+      "log_bad": 3.9703,
+      "log_good": 3.7136
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 174.0,
+      "good": 181.0,
+      "ratio": 1.0402,
+      "suggested_scalar": 0.0548,
+      "log_bad": 5.1591,
+      "log_good": 5.1985
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4348,
+      "good": 0.3793,
+      "ratio": 0.8724,
+      "suggested_scalar": -0.1897,
+      "log_bad": -0.8329,
+      "log_good": -0.9694
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.5326,
+      "good": 5.5747,
+      "ratio": 1.0076,
+      "suggested_scalar": 0.0105,
+      "log_bad": 1.7107,
+      "log_good": 1.7182
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1765,
+      "good": 0.2,
+      "ratio": 1.1331,
+      "suggested_scalar": 0.1736,
+      "log_bad": -1.7344,
+      "log_good": -1.6094
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.8796,
+      "good": 3.7521,
+      "ratio": 0.9671,
+      "suggested_scalar": -0.0464,
+      "log_bad": 1.3557,
+      "log_good": 1.3223
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 300.0,
+      "good": 301.0,
+      "ratio": 1.0033,
+      "suggested_scalar": 0.0046,
+      "log_bad": 5.7038,
+      "log_good": 5.7071
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.5632,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 56.0,
+      "good": 51.0,
+      "ratio": 0.9107,
+      "suggested_scalar": -0.1299,
+      "log_bad": 4.0254,
+      "log_good": 3.9318
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2397.5513,
+      "good": 3259.8293,
+      "ratio": 1.3596,
+      "suggested_scalar": 0.4267,
+      "log_bad": 7.7822,
+      "log_good": 8.0894
+    },
+    "readability.mean_total_lines": {
+      "bad": 40.0,
+      "good": 42.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0678,
+      "log_bad": 3.6889,
+      "log_good": 3.7377
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 1844.5677,
+      "good": 1788.0,
+      "ratio": 0.9693,
+      "suggested_scalar": -0.0433,
+      "log_bad": 7.52,
+      "log_good": 7.4889
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 500.0,
+      "good": 446.0,
+      "ratio": 0.892,
+      "suggested_scalar": -0.1587,
+      "log_bad": 6.2146,
+      "log_good": 6.1003
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 28.3,
+      "good": 25.6905,
+      "ratio": 0.9078,
+      "suggested_scalar": -0.1344,
+      "log_bad": 3.3429,
+      "log_good": 3.2461
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.058,
+      "good": 1.0876,
+      "ratio": 1.028,
+      "suggested_scalar": 0.0383,
+      "log_bad": 0.0564,
+      "log_good": 0.084
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 19.0,
+      "good": 17.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.1545,
+      "log_bad": 2.9444,
+      "log_good": 2.8332
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.4674,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7037,
+      "good": 0.7385,
+      "ratio": 1.0495,
+      "suggested_scalar": 0.067,
+      "log_bad": -0.3514,
+      "log_good": -0.3031
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9795,
+      "good": 0.9451,
+      "ratio": 0.9649,
+      "suggested_scalar": -0.0497,
+      "log_bad": -0.0207,
+      "log_good": -0.0565
+    },
+    "halstead.mean_length": {
+      "bad": 298.0,
+      "good": 298.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.6971,
+      "log_good": 5.6971
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.625,
+      "good": 5.2222,
+      "ratio": 0.9284,
+      "suggested_scalar": -0.1032,
+      "log_bad": 1.7272,
+      "log_good": 1.6529
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2854,
+      "good": 6.0444,
+      "ratio": 0.9617,
+      "suggested_scalar": -0.0543,
+      "log_bad": 1.8382,
+      "log_good": 1.7991
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1281,
+      "good": 0.1367,
+      "ratio": 1.0671,
+      "suggested_scalar": 0.0903,
+      "log_bad": -2.0549,
+      "log_good": -1.99
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 23.3962,
+      "good": 32.8171,
+      "ratio": 1.4027,
+      "suggested_scalar": 0.47,
+      "log_bad": 3.1526,
+      "log_good": 3.4909
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 40.0,
+      "good": 33.0,
+      "ratio": 0.825,
+      "suggested_scalar": -0.2672,
+      "log_bad": 3.6889,
+      "log_good": 3.4965
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6323,
+      "good": 0.6234,
+      "ratio": 0.9859,
+      "suggested_scalar": -0.0197,
+      "log_bad": -0.4584,
+      "log_good": -0.4726
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 42.0,
+      "good": 44.0,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.0646,
+      "log_bad": 3.7377,
+      "log_good": 3.7842
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.9628,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 25.0,
+      "ratio": 1.1905,
+      "suggested_scalar": 0.2422,
+      "log_bad": 3.0445,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 1.9256,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    }
+  },
+  "type_and_value.no_rtti": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.3406,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.6861,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0056,
+      "good": 0.0073,
+      "ratio": 1.3036,
+      "suggested_scalar": 0.5406,
+      "log_bad": -5.185,
+      "log_good": -4.9199
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7797,
+      "good": 0.7414,
+      "ratio": 0.9509,
+      "suggested_scalar": -0.1027,
+      "log_bad": -0.2488,
+      "log_good": -0.2992
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0056,
+      "good": 0.0073,
+      "ratio": 1.3036,
+      "suggested_scalar": 0.5406,
+      "log_bad": -5.185,
+      "log_good": -4.9199
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6689,
+      "good": 4.663,
+      "ratio": 0.9987,
+      "suggested_scalar": -0.0026,
+      "log_bad": 1.5409,
+      "log_good": 1.5397
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 111.0,
+      "good": 97.0,
+      "ratio": 0.8739,
+      "suggested_scalar": -0.2749,
+      "log_bad": 4.7095,
+      "log_good": 4.5747
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4813,
+      "good": 0.3626,
+      "ratio": 0.7534,
+      "suggested_scalar": -0.5775,
+      "log_bad": -0.7313,
+      "log_good": -1.0145
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6386,
+      "good": 0.5367,
+      "ratio": 0.8404,
+      "suggested_scalar": -0.3545,
+      "log_bad": -0.4485,
+      "log_good": -0.6223
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.6271,
+      "good": 3.4828,
+      "ratio": 0.9602,
+      "suggested_scalar": -0.0828,
+      "log_bad": 1.2884,
+      "log_good": 1.2478
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 534.0,
+      "good": 545.0,
+      "ratio": 1.0206,
+      "suggested_scalar": 0.0416,
+      "log_bad": 6.2804,
+      "log_good": 6.3008
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.455,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0004,
+      "good": 0.0004,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.824,
+      "log_good": -7.824
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1356,
+      "good": 0.1034,
+      "ratio": 0.7625,
+      "suggested_scalar": -0.5528,
+      "log_bad": -1.998,
+      "log_good": -2.2692
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.024,
+      "good": 1.0847,
+      "ratio": 1.0593,
+      "suggested_scalar": 0.1174,
+      "log_bad": 0.0237,
+      "log_good": 0.0813
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 153.0,
+      "good": 134.0,
+      "ratio": 0.8758,
+      "suggested_scalar": -0.2704,
+      "log_bad": 5.0304,
+      "log_good": 4.8978
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.2142,
+      "good": 104.2769,
+      "ratio": 1.0006,
+      "suggested_scalar": 0.0012,
+      "log_bad": 4.6464,
+      "log_good": 4.647
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7036,
+      "good": 0.796,
+      "ratio": 1.1313,
+      "suggested_scalar": 0.2516,
+      "log_bad": -0.3515,
+      "log_good": -0.2282
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.2659,
+      "good": 8.7454,
+      "ratio": 0.8519,
+      "suggested_scalar": -0.3269,
+      "log_bad": 2.3288,
+      "log_good": 2.1685
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2240.0,
+      "good": 2276.0,
+      "ratio": 1.0161,
+      "suggested_scalar": 0.0325,
+      "log_bad": 7.7142,
+      "log_good": 7.7302
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1356,
+      "good": 0.0517,
+      "ratio": 0.3813,
+      "suggested_scalar": -1.9662,
+      "log_bad": -1.998,
+      "log_good": -2.9623
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7458,
+      "good": 0.7241,
+      "ratio": 0.9709,
+      "suggested_scalar": -0.0602,
+      "log_bad": -0.2933,
+      "log_good": -0.3228
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.7091,
+      "good": 9.9091,
+      "ratio": 1.0206,
+      "suggested_scalar": 0.0416,
+      "log_bad": 2.2731,
+      "log_good": 2.2935
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 14.0,
+      "good": 18.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.5125,
+      "log_bad": 2.6391,
+      "log_good": 2.8904
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 15.1152,
+      "good": 12.4911,
+      "ratio": 0.8264,
+      "suggested_scalar": -0.3888,
+      "log_bad": 2.7157,
+      "log_good": 2.525
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 108.0,
+      "good": 86.0,
+      "ratio": 0.7963,
+      "suggested_scalar": -0.4645,
+      "log_bad": 4.6821,
+      "log_good": 4.4543
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9417,
+      "good": 0.9412,
+      "ratio": 0.9995,
+      "suggested_scalar": -0.0011,
+      "log_bad": -0.0601,
+      "log_good": -0.0606
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 26.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.2918,
+      "log_bad": 3.4012,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6585,
+      "good": 0.696,
+      "ratio": 1.0569,
+      "suggested_scalar": 0.1129,
+      "log_bad": -0.4178,
+      "log_good": -0.3624
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5695,
+      "good": 0.6924,
+      "ratio": 1.2158,
+      "suggested_scalar": 0.3984,
+      "log_bad": -0.563,
+      "log_good": -0.3676
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9281,
+      "good": 3.289,
+      "ratio": 1.1233,
+      "suggested_scalar": 0.237,
+      "log_bad": 1.0744,
+      "log_good": 1.1906
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 532.0,
+      "good": 543.0,
+      "ratio": 1.0207,
+      "suggested_scalar": 0.0417,
+      "log_bad": 6.2766,
+      "log_good": 6.2971
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0449,
+      "good": 0.055,
+      "ratio": 1.2249,
+      "suggested_scalar": 0.4137,
+      "log_bad": -3.1033,
+      "log_good": -2.9004
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.9542,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7841,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 20.0,
+      "good": 17.0,
+      "ratio": 0.85,
+      "suggested_scalar": -0.3314,
+      "log_bad": 2.9957,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3272,
+      "good": 1.5041,
+      "ratio": 1.1333,
+      "suggested_scalar": 0.2551,
+      "log_bad": 0.2831,
+      "log_good": 0.4082
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8245,
+      "good": 5.5769,
+      "ratio": 0.9575,
+      "suggested_scalar": -0.0886,
+      "log_bad": 1.7621,
+      "log_good": 1.7186
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7841,
+      "good": 0.7831,
+      "ratio": 0.9987,
+      "suggested_scalar": -0.0026,
+      "log_bad": -0.2432,
+      "log_good": -0.2445
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1449,
+      "good": 0.1594,
+      "ratio": 1.1001,
+      "suggested_scalar": 0.1945,
+      "log_bad": -1.9317,
+      "log_good": -1.8363
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.204,
+      "good": 2.9573,
+      "ratio": 0.923,
+      "suggested_scalar": -0.1634,
+      "log_bad": 1.1644,
+      "log_good": 1.0843
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 344.0,
+      "good": 299.0,
+      "ratio": 0.8692,
+      "suggested_scalar": -0.2859,
+      "log_bad": 5.8406,
+      "log_good": 5.7004
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.3406,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.1573,
+      "good": 1.1638,
+      "ratio": 1.0056,
+      "suggested_scalar": 0.0114,
+      "log_bad": 0.1461,
+      "log_good": 0.1517
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 97.0,
+      "ratio": 0.8584,
+      "suggested_scalar": -0.3113,
+      "log_bad": 4.7274,
+      "log_good": 4.5747
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 925.0,
+      "good": 800.0,
+      "ratio": 0.8649,
+      "suggested_scalar": -0.296,
+      "log_bad": 6.8298,
+      "log_good": 6.6846
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 233.0,
+      "good": 246.0,
+      "ratio": 1.0558,
+      "suggested_scalar": 0.1107,
+      "log_bad": 5.451,
+      "log_good": 5.5053
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0056,
+      "good": 0.0055,
+      "ratio": 0.9821,
+      "suggested_scalar": -0.0367,
+      "log_bad": -5.185,
+      "log_good": -5.203
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2341,
+      "good": 0.222,
+      "ratio": 0.9483,
+      "suggested_scalar": -0.1082,
+      "log_bad": -1.452,
+      "log_good": -1.5051
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 113.0,
+      "good": 121.0,
+      "ratio": 1.0708,
+      "suggested_scalar": 0.1395,
+      "log_bad": 4.7274,
+      "log_good": 4.7958
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 97.0,
+      "ratio": 0.8584,
+      "suggested_scalar": -0.3113,
+      "log_bad": 4.7274,
+      "log_good": 4.5747
+    },
+    "brevity.mean_sample_size": {
+      "bad": 113.0,
+      "good": 97.0,
+      "ratio": 0.8584,
+      "suggested_scalar": -0.3113,
+      "log_bad": 4.7274,
+      "log_good": 4.5747
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 534.0,
+      "good": 545.0,
+      "ratio": 1.0206,
+      "suggested_scalar": 0.0416,
+      "log_bad": 6.2804,
+      "log_good": 6.3008
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 272.0,
+      "good": 283.0,
+      "ratio": 1.0404,
+      "suggested_scalar": 0.0808,
+      "log_bad": 5.6058,
+      "log_good": 5.6454
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 271.0,
+      "good": 232.0,
+      "ratio": 0.8561,
+      "suggested_scalar": -0.3168,
+      "log_bad": 5.6021,
+      "log_good": 5.4467
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.7753,
+      "good": 3.4891,
+      "ratio": 1.9654,
+      "suggested_scalar": 1.3778,
+      "log_bad": 0.574,
+      "log_good": 1.2496
+    },
+    "halstead.mean_effort": {
+      "bad": 149808.0623,
+      "good": 157258.4472,
+      "ratio": 1.0497,
+      "suggested_scalar": 0.099,
+      "log_bad": 11.9171,
+      "log_good": 11.9656
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.854,
+      "good": 0.845,
+      "ratio": 0.9895,
+      "suggested_scalar": -0.0216,
+      "log_bad": -0.1578,
+      "log_good": -0.1684
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 81.0,
+      "good": 71.0,
+      "ratio": 0.8765,
+      "suggested_scalar": -0.2687,
+      "log_bad": 4.3944,
+      "log_good": 4.2627
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 278.0,
+      "good": 283.0,
+      "ratio": 1.018,
+      "suggested_scalar": 0.0363,
+      "log_bad": 5.6276,
+      "log_good": 5.6454
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4118,
+      "good": 0.3582,
+      "ratio": 0.8698,
+      "suggested_scalar": -0.2843,
+      "log_bad": -0.8872,
+      "log_good": -1.0267
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0458,
+      "good": 5.9701,
+      "ratio": 0.9875,
+      "suggested_scalar": -0.0257,
+      "log_bad": 1.7994,
+      "log_good": 1.7868
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1449,
+      "good": 0.1594,
+      "ratio": 1.1001,
+      "suggested_scalar": 0.1945,
+      "log_bad": -1.9317,
+      "log_good": -1.8363
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.8836,
+      "good": 3.9636,
+      "ratio": 1.0206,
+      "suggested_scalar": 0.0416,
+      "log_bad": 1.3568,
+      "log_good": 1.3772
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 533.0,
+      "good": 544.0,
+      "ratio": 1.0206,
+      "suggested_scalar": 0.0417,
+      "log_bad": 6.2785,
+      "log_good": 6.2989
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 115.0,
+      "good": 132.0,
+      "ratio": 1.1478,
+      "suggested_scalar": 0.2811,
+      "log_bad": 4.7449,
+      "log_good": 4.8828
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 8322.6701,
+      "good": 8736.5804,
+      "ratio": 1.0497,
+      "suggested_scalar": 0.099,
+      "log_bad": 9.0267,
+      "log_good": 9.0753
+    },
+    "readability.mean_total_lines": {
+      "bad": 55.0,
+      "good": 55.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0073,
+      "log_good": 4.0073
+    },
+    "indentation.mean_max_depth": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "halstead.mean_volume": {
+      "bad": 3471.9465,
+      "good": 3491.3539,
+      "ratio": 1.0056,
+      "suggested_scalar": 0.0114,
+      "log_bad": 8.1525,
+      "log_good": 8.158
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 765.0,
+      "good": 692.0,
+      "ratio": 0.9046,
+      "suggested_scalar": -0.2045,
+      "log_bad": 6.6399,
+      "log_good": 6.5396
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 38.0909,
+      "good": 39.0545,
+      "ratio": 1.0253,
+      "suggested_scalar": 0.0509,
+      "log_bad": 3.64,
+      "log_good": 3.665
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0965,
+      "good": 1.0934,
+      "ratio": 0.9972,
+      "suggested_scalar": -0.0058,
+      "log_bad": 0.0921,
+      "log_good": 0.0893
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.455,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 8.0,
+      "good": 6.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.5866,
+      "log_bad": 2.0794,
+      "log_good": 1.7918
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6657,
+      "good": 0.5585,
+      "ratio": 0.839,
+      "suggested_scalar": -0.358,
+      "log_bad": -0.4069,
+      "log_good": -0.5825
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9248,
+      "good": 0.8937,
+      "ratio": 0.9664,
+      "suggested_scalar": -0.0698,
+      "log_bad": -0.0782,
+      "log_good": -0.1124
+    },
+    "halstead.mean_length": {
+      "bad": 511.0,
+      "good": 529.0,
+      "ratio": 1.0352,
+      "suggested_scalar": 0.0706,
+      "log_bad": 6.2364,
+      "log_good": 6.271
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8202,
+      "good": 6.5999,
+      "ratio": 0.9677,
+      "suggested_scalar": -0.067,
+      "log_bad": 1.9199,
+      "log_good": 1.8871
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1218,
+      "good": 0.1248,
+      "ratio": 1.0246,
+      "suggested_scalar": 0.0496,
+      "log_bad": -2.1054,
+      "log_good": -2.081
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 43.1481,
+      "good": 45.0423,
+      "ratio": 1.0439,
+      "suggested_scalar": 0.0876,
+      "log_bad": 3.7646,
+      "log_good": 3.8076
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 3.0,
+      "ratio": 0.375,
+      "suggested_scalar": -2.0,
+      "log_bad": 2.0794,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 63.0,
+      "good": 48.0,
+      "ratio": 0.7619,
+      "suggested_scalar": -0.5545,
+      "log_bad": 4.1431,
+      "log_good": 3.8712
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.583,
+      "good": 0.4784,
+      "ratio": 0.8206,
+      "suggested_scalar": -0.4032,
+      "log_bad": -0.5396,
+      "log_good": -0.7373
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 59.0,
+      "good": 58.0,
+      "ratio": 0.9831,
+      "suggested_scalar": -0.0349,
+      "log_bad": 4.0775,
+      "log_good": 4.0604
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 16.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.2402,
+      "log_bad": 2.8904,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "variable_naming.loop_var_is_single_letter": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 89.0,
+      "good": 21.0,
+      "ratio": 0.236,
+      "suggested_scalar": -2.0,
+      "log_bad": 4.4886,
+      "log_good": 3.0445
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 36.3333,
+      "good": 36.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5927,
+      "log_good": 3.5927
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0016,
+      "good": 0.0016,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.4378,
+      "log_good": -6.4378
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.4286,
+      "good": 1.4286,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.3567,
+      "log_good": 0.3567
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7162,
+      "good": 0.7062,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0195,
+      "log_bad": -0.3338,
+      "log_good": -0.3479
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0016,
+      "good": 0.0016,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.4378,
+      "log_good": -6.4378
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5915,
+      "good": 4.5726,
+      "ratio": 0.9959,
+      "suggested_scalar": -0.0057,
+      "log_bad": 1.5242,
+      "log_good": 1.5201
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 74.0,
+      "good": 70.0,
+      "ratio": 0.9459,
+      "suggested_scalar": -0.077,
+      "log_bad": 4.3041,
+      "log_good": 4.2485
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.2628,
+      "good": 0.2436,
+      "ratio": 0.9269,
+      "suggested_scalar": -0.1051,
+      "log_bad": -1.3364,
+      "log_good": -1.4122
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 17.6667,
+      "ratio": 1.0392,
+      "suggested_scalar": 0.0533,
+      "log_bad": 2.8332,
+      "log_good": 2.8717
+    },
+    "heaps.mean_beta": {
+      "bad": 0.4146,
+      "good": 0.3882,
+      "ratio": 0.9363,
+      "suggested_scalar": -0.0911,
+      "log_bad": -0.8804,
+      "log_good": -0.9462
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.7179,
+      "good": 3.6842,
+      "ratio": 0.9909,
+      "suggested_scalar": -0.0126,
+      "log_bad": 1.3132,
+      "log_good": 1.3041
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 586.6667,
+      "good": 588.6667,
+      "ratio": 1.0034,
+      "suggested_scalar": 0.0047,
+      "log_bad": 6.3745,
+      "log_good": 6.3779
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0173,
+      "good": 0.0174,
+      "ratio": 1.0058,
+      "suggested_scalar": 0.008,
+      "log_bad": -4.057,
+      "log_good": -4.0513
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.2398,
+      "good": 1.2499,
+      "ratio": 1.0081,
+      "suggested_scalar": 0.0112,
+      "log_bad": 0.215,
+      "log_good": 0.2231
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 176.6667,
+      "good": 176.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.1743,
+      "log_good": 5.1743
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 77.6117,
+      "good": 104.3671,
+      "ratio": 1.3447,
+      "suggested_scalar": 0.4102,
+      "log_bad": 4.3517,
+      "log_good": 4.6479
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7747,
+      "good": 0.7845,
+      "ratio": 1.0127,
+      "suggested_scalar": 0.0174,
+      "log_bad": -0.2553,
+      "log_good": -0.2427
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 32.6444,
+      "good": 8.5854,
+      "ratio": 0.263,
+      "suggested_scalar": -1.8497,
+      "log_bad": 3.4857,
+      "log_good": 2.1501
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2696.6667,
+      "good": 1976.6667,
+      "ratio": 0.733,
+      "suggested_scalar": -0.4302,
+      "log_bad": 7.8998,
+      "log_good": 7.5892
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1387,
+      "good": 0.1388,
+      "ratio": 1.0007,
+      "suggested_scalar": 0.001,
+      "log_bad": -1.9754,
+      "log_good": -1.9747
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6352,
+      "good": 0.6248,
+      "ratio": 0.9836,
+      "suggested_scalar": -0.0229,
+      "log_bad": -0.4538,
+      "log_good": -0.4703
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.9476,
+      "good": 8.0052,
+      "ratio": 1.0072,
+      "suggested_scalar": 0.01,
+      "log_bad": 2.0729,
+      "log_good": 2.0801
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 4.8048,
+      "good": 4.5687,
+      "ratio": 0.9509,
+      "suggested_scalar": -0.0698,
+      "log_bad": 1.5696,
+      "log_good": 1.5192
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 136.3333,
+      "good": 159.0,
+      "ratio": 1.1663,
+      "suggested_scalar": 0.213,
+      "log_bad": 4.9151,
+      "log_good": 5.0689
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9211,
+      "good": 0.9122,
+      "ratio": 0.9903,
+      "suggested_scalar": -0.0134,
+      "log_bad": -0.0822,
+      "log_good": -0.0919
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.6667,
+      "good": 27.3333,
+      "ratio": 1.025,
+      "suggested_scalar": 0.0342,
+      "log_bad": 3.2834,
+      "log_good": 3.3081
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.7602,
+      "good": 0.6983,
+      "ratio": 0.9186,
+      "suggested_scalar": -0.1176,
+      "log_bad": -0.2742,
+      "log_good": -0.3591
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.6283,
+      "good": 0.6453,
+      "ratio": 1.0271,
+      "suggested_scalar": 0.037,
+      "log_bad": -0.4647,
+      "log_good": -0.438
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 4.1844,
+      "good": 3.3168,
+      "ratio": 0.7927,
+      "suggested_scalar": -0.3218,
+      "log_bad": 1.4314,
+      "log_good": 1.199
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 584.6667,
+      "good": 586.6667,
+      "ratio": 1.0034,
+      "suggested_scalar": 0.0047,
+      "log_bad": 6.371,
+      "log_good": 6.3745
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 18.3333,
+      "good": 18.0,
+      "ratio": 0.9818,
+      "suggested_scalar": -0.0254,
+      "log_bad": 2.9087,
+      "log_good": 2.8904
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0028,
+      "good": 0.0028,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.8781,
+      "log_good": -5.8781
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7452,
+      "good": 5.7724,
+      "ratio": 1.0047,
+      "suggested_scalar": 0.0065,
+      "log_bad": 1.7484,
+      "log_good": 1.7531
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6475,
+      "good": 0.4903,
+      "ratio": 0.7572,
+      "suggested_scalar": -0.3852,
+      "log_bad": -0.4346,
+      "log_good": -0.7127
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.1734,
+      "good": 5.1064,
+      "ratio": 0.987,
+      "suggested_scalar": -0.0181,
+      "log_bad": 1.6435,
+      "log_good": 1.6305
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7992,
+      "good": 0.7922,
+      "ratio": 0.9912,
+      "suggested_scalar": -0.0122,
+      "log_bad": -0.2241,
+      "log_good": -0.2329
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1447,
+      "good": 0.1452,
+      "ratio": 1.0035,
+      "suggested_scalar": 0.0048,
+      "log_bad": -1.9331,
+      "log_good": -1.9296
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 5.7028,
+      "good": 2.9299,
+      "ratio": 0.5138,
+      "suggested_scalar": -0.9223,
+      "log_bad": 1.741,
+      "log_good": 1.075
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 303.3333,
+      "good": 294.0,
+      "ratio": 0.9692,
+      "suggested_scalar": -0.0433,
+      "log_bad": 5.7148,
+      "log_good": 5.6836
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 21.3333,
+      "good": 21.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0603,
+      "log_good": 3.0603
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.1722,
+      "good": 1.1622,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0119,
+      "log_bad": 0.1589,
+      "log_good": 0.1503
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 77.6667,
+      "good": 72.0,
+      "ratio": 0.927,
+      "suggested_scalar": -0.1049,
+      "log_bad": 4.3524,
+      "log_good": 4.2767
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1552.3333,
+      "good": 835.0,
+      "ratio": 0.5379,
+      "suggested_scalar": -0.8588,
+      "log_bad": 7.3475,
+      "log_good": 6.7274
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 213.6667,
+      "good": 213.0,
+      "ratio": 0.9969,
+      "suggested_scalar": -0.0043,
+      "log_bad": 5.3644,
+      "log_good": 5.3613
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0031,
+      "good": 0.0031,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.7764,
+      "log_good": -5.7764
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2186,
+      "good": 0.2213,
+      "ratio": 1.0124,
+      "suggested_scalar": 0.017,
+      "log_bad": -1.5205,
+      "log_good": -1.5082
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 87.0,
+      "good": 84.6667,
+      "ratio": 0.9732,
+      "suggested_scalar": -0.0377,
+      "log_bad": 4.4659,
+      "log_good": 4.4387
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 77.6667,
+      "good": 72.0,
+      "ratio": 0.927,
+      "suggested_scalar": -0.1049,
+      "log_bad": 4.3524,
+      "log_good": 4.2767
+    },
+    "brevity.mean_sample_size": {
+      "bad": 77.6667,
+      "good": 72.0,
+      "ratio": 0.927,
+      "suggested_scalar": -0.1049,
+      "log_bad": 4.3524,
+      "log_good": 4.2767
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 586.6667,
+      "good": 588.6667,
+      "ratio": 1.0034,
+      "suggested_scalar": 0.0047,
+      "log_bad": 6.3745,
+      "log_good": 6.3779
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 317.3333,
+      "good": 319.3333,
+      "ratio": 1.0063,
+      "suggested_scalar": 0.0087,
+      "log_bad": 5.76,
+      "log_good": 5.7662
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 218.6667,
+      "good": 211.0,
+      "ratio": 0.9649,
+      "suggested_scalar": -0.0494,
+      "log_bad": 5.3875,
+      "log_good": 5.3519
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 5.9684,
+      "good": 6.5242,
+      "ratio": 1.0931,
+      "suggested_scalar": 0.1233,
+      "log_bad": 1.7865,
+      "log_good": 1.8755
+    },
+    "halstead.mean_effort": {
+      "bad": 215195.1929,
+      "good": 240174.1347,
+      "ratio": 1.1161,
+      "suggested_scalar": 0.1521,
+      "log_bad": 12.2793,
+      "log_good": 12.3891
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8243,
+      "good": 0.8281,
+      "ratio": 1.0046,
+      "suggested_scalar": 0.0064,
+      "log_bad": -0.1932,
+      "log_good": -0.1886
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 47.3333,
+      "good": 42.6667,
+      "ratio": 0.9014,
+      "suggested_scalar": -0.1437,
+      "log_bad": 3.8572,
+      "log_good": 3.7534
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 352.6667,
+      "good": 355.6667,
+      "ratio": 1.0085,
+      "suggested_scalar": 0.0117,
+      "log_bad": 5.8655,
+      "log_good": 5.874
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.2607,
+      "good": 0.2324,
+      "ratio": 0.8914,
+      "suggested_scalar": -0.1591,
+      "log_bad": -1.3444,
+      "log_good": -1.4593
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.7704,
+      "good": 4.7358,
+      "ratio": 0.54,
+      "suggested_scalar": -0.8534,
+      "log_bad": 2.1714,
+      "log_good": 1.5552
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1447,
+      "good": 0.1452,
+      "ratio": 1.0035,
+      "suggested_scalar": 0.0048,
+      "log_bad": -1.9331,
+      "log_good": -1.9296
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 9.2628,
+      "good": 3.4664,
+      "ratio": 0.3742,
+      "suggested_scalar": -1.3612,
+      "log_bad": 2.226,
+      "log_good": 1.2431
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 585.6667,
+      "good": 587.6667,
+      "ratio": 1.0034,
+      "suggested_scalar": 0.0047,
+      "log_bad": 6.3728,
+      "log_good": 6.3762
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 8.6667,
+      "good": 8.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1595,
+      "log_good": 2.1595
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 86.6667,
+      "good": 86.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.4621,
+      "log_good": 4.4621
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 11955.2885,
+      "good": 13343.0075,
+      "ratio": 1.1161,
+      "suggested_scalar": 0.1521,
+      "log_bad": 9.3889,
+      "log_good": 9.4987
+    },
+    "readability.mean_total_lines": {
+      "bad": 74.0,
+      "good": 73.6667,
+      "ratio": 0.9955,
+      "suggested_scalar": -0.0063,
+      "log_bad": 4.3041,
+      "log_good": 4.2996
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 9.3333,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0956,
+      "log_bad": 2.3026,
+      "log_good": 2.2336
+    },
+    "halstead.mean_volume": {
+      "bad": 3516.4652,
+      "good": 3486.5369,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0118,
+      "log_bad": 8.1652,
+      "log_good": 8.1567
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 643.0,
+      "good": 595.3333,
+      "ratio": 0.9259,
+      "suggested_scalar": -0.1067,
+      "log_bad": 6.4661,
+      "log_good": 6.3891
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 34.6228,
+      "good": 25.1102,
+      "ratio": 0.7253,
+      "suggested_scalar": -0.4449,
+      "log_bad": 3.5445,
+      "log_good": 3.2233
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.4321,
+      "good": 1.1151,
+      "ratio": 0.7786,
+      "suggested_scalar": -0.3465,
+      "log_bad": 0.3591,
+      "log_good": 0.1089
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 40.6667,
+      "good": 40.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7054,
+      "log_good": 3.7054
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7132,
+      "good": 0.7047,
+      "ratio": 0.9881,
+      "suggested_scalar": -0.0166,
+      "log_bad": -0.338,
+      "log_good": -0.35
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9099,
+      "good": 0.8958,
+      "ratio": 0.9845,
+      "suggested_scalar": -0.0216,
+      "log_bad": -0.0944,
+      "log_good": -0.11
+    },
+    "halstead.mean_length": {
+      "bad": 566.3333,
+      "good": 568.6667,
+      "ratio": 1.0041,
+      "suggested_scalar": 0.0057,
+      "log_bad": 6.3392,
+      "log_good": 6.3433
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.8095,
+      "good": 11.7619,
+      "ratio": 0.996,
+      "suggested_scalar": -0.0056,
+      "log_bad": 2.4689,
+      "log_good": 2.4649
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2769,
+      "good": 6.1675,
+      "ratio": 0.9826,
+      "suggested_scalar": -0.0244,
+      "log_bad": 1.8369,
+      "log_good": 1.8193
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1177,
+      "good": 0.1609,
+      "ratio": 1.367,
+      "suggested_scalar": 0.433,
+      "log_bad": -2.1396,
+      "log_good": -1.827
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 60.3931,
+      "good": 68.1721,
+      "ratio": 1.1288,
+      "suggested_scalar": 0.1678,
+      "log_bad": 4.1009,
+      "log_good": 4.222
+    },
+    "branching.mean_branch_count": {
+      "bad": 10.3333,
+      "good": 10.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3354,
+      "log_good": 2.3354
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 46.0,
+      "good": 41.0,
+      "ratio": 0.8913,
+      "suggested_scalar": -0.1594,
+      "log_bad": 3.8286,
+      "log_good": 3.7136
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6002,
+      "good": 0.5974,
+      "ratio": 0.9953,
+      "suggested_scalar": -0.0065,
+      "log_bad": -0.5105,
+      "log_good": -0.5152
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 74.6667,
+      "good": 74.3333,
+      "ratio": 0.9955,
+      "suggested_scalar": -0.0062,
+      "log_bad": 4.313,
+      "log_good": 4.3086
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.3333,
+      "good": 14.0,
+      "ratio": 0.6563,
+      "suggested_scalar": -0.5833,
+      "log_bad": 3.0603,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.factory_method_starts_with_make": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 23.0,
+      "good": 19.0,
+      "ratio": 0.8261,
+      "suggested_scalar": -0.1378,
+      "log_bad": 3.1355,
+      "log_good": 2.9444
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0302,
+      "good": 0.0236,
+      "ratio": 0.7815,
+      "suggested_scalar": -0.1779,
+      "log_bad": -3.4999,
+      "log_good": -3.7465
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8438,
+      "good": 0.8333,
+      "ratio": 0.9876,
+      "suggested_scalar": -0.009,
+      "log_bad": -0.1698,
+      "log_good": -0.1824
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0302,
+      "good": 0.0236,
+      "ratio": 0.7815,
+      "suggested_scalar": -0.1779,
+      "log_bad": -3.4999,
+      "log_good": -3.7465
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5462,
+      "good": 4.4865,
+      "ratio": 0.9869,
+      "suggested_scalar": -0.0095,
+      "log_bad": 1.5143,
+      "log_good": 1.5011
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 93.0,
+      "good": 74.0,
+      "ratio": 0.7957,
+      "suggested_scalar": -0.1649,
+      "log_bad": 4.5326,
+      "log_good": 4.3041
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5112,
+      "good": 0.4057,
+      "ratio": 0.7936,
+      "suggested_scalar": -0.1667,
+      "log_bad": -0.671,
+      "log_good": -0.9021
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 16.0,
+      "ratio": 0.8421,
+      "suggested_scalar": -0.124,
+      "log_bad": 2.9444,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6275,
+      "good": 0.568,
+      "ratio": 0.9052,
+      "suggested_scalar": -0.0719,
+      "log_bad": -0.466,
+      "log_good": -0.5656
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.5625,
+      "good": 5.6667,
+      "ratio": 1.0187,
+      "suggested_scalar": 0.0134,
+      "log_bad": 1.716,
+      "log_good": 1.7346
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 430.0,
+      "good": 381.0,
+      "ratio": 0.886,
+      "suggested_scalar": -0.0873,
+      "log_bad": 6.0638,
+      "log_good": 5.9428
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0625,
+      "good": 1.0,
+      "ratio": 16.0,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.7726,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0009,
+      "good": 0.001,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.076,
+      "log_bad": -7.0131,
+      "log_good": -6.9078
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9994,
+      "good": 1.0185,
+      "ratio": 1.0191,
+      "suggested_scalar": 0.0137,
+      "log_bad": -0.0006,
+      "log_good": 0.0183
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 141.0,
+      "good": 113.0,
+      "ratio": 0.8014,
+      "suggested_scalar": -0.1597,
+      "log_bad": 4.9488,
+      "log_good": 4.7274
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 95.0094,
+      "good": 95.5055,
+      "ratio": 1.0052,
+      "suggested_scalar": 0.0038,
+      "log_bad": 4.554,
+      "log_good": 4.5592
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6247,
+      "good": 0.6421,
+      "ratio": 1.0279,
+      "suggested_scalar": 0.0198,
+      "log_bad": -0.4705,
+      "log_good": -0.443
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 22.4536,
+      "good": 18.8154,
+      "ratio": 0.838,
+      "suggested_scalar": -0.1275,
+      "log_bad": 3.1115,
+      "log_good": 2.9347
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2245.0,
+      "good": 1937.0,
+      "ratio": 0.8628,
+      "suggested_scalar": -0.1064,
+      "log_bad": 7.7165,
+      "log_good": 7.5689
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0469,
+      "good": 0.05,
+      "ratio": 1.0661,
+      "suggested_scalar": 0.0462,
+      "log_bad": -3.0597,
+      "log_good": -2.9957
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8125,
+      "good": 0.8,
+      "ratio": 0.9846,
+      "suggested_scalar": -0.0112,
+      "log_bad": -0.2076,
+      "log_good": -0.2231
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.7188,
+      "good": 6.35,
+      "ratio": 0.9451,
+      "suggested_scalar": -0.0407,
+      "log_bad": 1.9049,
+      "log_good": 1.8485
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 14.3086,
+      "good": 15.0889,
+      "ratio": 1.0545,
+      "suggested_scalar": 0.0383,
+      "log_bad": 2.6609,
+      "log_good": 2.714
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 71.0,
+      "good": 52.0,
+      "ratio": 0.7324,
+      "suggested_scalar": -0.2247,
+      "log_bad": 4.2627,
+      "log_good": 3.9512
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9442,
+      "good": 0.9343,
+      "ratio": 0.9895,
+      "suggested_scalar": -0.0076,
+      "log_bad": -0.0574,
+      "log_good": -0.068
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 21.0,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.0336,
+      "log_bad": 3.091,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6913,
+      "good": 0.6954,
+      "ratio": 1.0059,
+      "suggested_scalar": 0.0043,
+      "log_bad": -0.3692,
+      "log_good": -0.3633
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4299,
+      "good": 0.438,
+      "ratio": 1.0188,
+      "suggested_scalar": 0.0135,
+      "log_bad": -0.8442,
+      "log_good": -0.8255
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.2395,
+      "good": 3.2831,
+      "ratio": 1.0135,
+      "suggested_scalar": 0.0096,
+      "log_bad": 1.1754,
+      "log_good": 1.1888
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 428.0,
+      "good": 379.0,
+      "ratio": 0.8855,
+      "suggested_scalar": -0.0877,
+      "log_bad": 6.0591,
+      "log_good": 5.9375
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 22.0,
+      "good": 21.0,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.0336,
+      "log_bad": 3.091,
+      "log_good": 3.0445
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0953,
+      "good": 0.1076,
+      "ratio": 1.1291,
+      "suggested_scalar": 0.0876,
+      "log_bad": -2.3507,
+      "log_good": -2.2293
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.7004,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.0166,
+      "log_bad": 1.7635,
+      "log_good": 1.7405
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 47.0,
+      "good": 42.0,
+      "ratio": 0.8936,
+      "suggested_scalar": -0.0811,
+      "log_bad": 3.8501,
+      "log_good": 3.7377
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4535,
+      "good": 1.4785,
+      "ratio": 1.0172,
+      "suggested_scalar": 0.0123,
+      "log_bad": 0.374,
+      "log_good": 0.391
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7766,
+      "good": 5.4946,
+      "ratio": 0.9512,
+      "suggested_scalar": -0.0361,
+      "log_bad": 1.7538,
+      "log_good": 1.7038
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7794,
+      "good": 0.787,
+      "ratio": 1.0098,
+      "suggested_scalar": 0.007,
+      "log_bad": -0.2492,
+      "log_good": -0.2395
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1899,
+      "good": 0.2,
+      "ratio": 1.0532,
+      "suggested_scalar": 0.0374,
+      "log_bad": -1.6613,
+      "log_good": -1.6094
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.7385,
+      "good": 4.3377,
+      "ratio": 0.9154,
+      "suggested_scalar": -0.0638,
+      "log_bad": 1.5557,
+      "log_good": 1.4673
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 311.0,
+      "good": 275.0,
+      "ratio": 0.8842,
+      "suggested_scalar": -0.0887,
+      "log_bad": 5.7398,
+      "log_good": 5.6168
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8327,
+      "good": 0.7162,
+      "ratio": 0.8601,
+      "suggested_scalar": -0.1087,
+      "log_bad": -0.1831,
+      "log_good": -0.3338
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 100.0,
+      "good": 79.0,
+      "ratio": 0.79,
+      "suggested_scalar": -0.17,
+      "log_bad": 4.6052,
+      "log_good": 4.3694
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1185.0,
+      "good": 957.0,
+      "ratio": 0.8076,
+      "suggested_scalar": -0.1541,
+      "log_bad": 7.0775,
+      "log_good": 6.8638
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 175.0,
+      "good": 147.0,
+      "ratio": 0.84,
+      "suggested_scalar": -0.1258,
+      "log_bad": 5.1648,
+      "log_good": 4.9904
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0093,
+      "good": 0.0105,
+      "ratio": 1.129,
+      "suggested_scalar": 0.0875,
+      "log_bad": -4.6777,
+      "log_good": -4.5564
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2395,
+      "good": 0.2572,
+      "ratio": 1.0739,
+      "suggested_scalar": 0.0514,
+      "log_bad": -1.4292,
+      "log_good": -1.3579
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 88.0,
+      "good": 81.0,
+      "ratio": 0.9205,
+      "suggested_scalar": -0.0598,
+      "log_bad": 4.4773,
+      "log_good": 4.3944
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 100.0,
+      "good": 79.0,
+      "ratio": 0.79,
+      "suggested_scalar": -0.17,
+      "log_bad": 4.6052,
+      "log_good": 4.3694
+    },
+    "brevity.mean_sample_size": {
+      "bad": 100.0,
+      "good": 79.0,
+      "ratio": 0.79,
+      "suggested_scalar": -0.17,
+      "log_bad": 4.6052,
+      "log_good": 4.3694
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 430.0,
+      "good": 381.0,
+      "ratio": 0.886,
+      "suggested_scalar": -0.0873,
+      "log_bad": 6.0638,
+      "log_good": 5.9428
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 228.0,
+      "good": 207.0,
+      "ratio": 0.9079,
+      "suggested_scalar": -0.0697,
+      "log_bad": 5.4293,
+      "log_good": 5.3327
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 249.0,
+      "good": 217.0,
+      "ratio": 0.8715,
+      "suggested_scalar": -0.0992,
+      "log_bad": 5.5175,
+      "log_good": 5.3799
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0047,
+      "good": 0.0052,
+      "ratio": 1.1064,
+      "suggested_scalar": 0.0729,
+      "log_bad": -5.3602,
+      "log_good": -5.2591
+    },
+    "heaps.mean_k": {
+      "bad": 2.4762,
+      "good": 2.9265,
+      "ratio": 1.1819,
+      "suggested_scalar": 0.1205,
+      "log_bad": 0.9067,
+      "log_good": 1.0738
+    },
+    "halstead.mean_effort": {
+      "bad": 67726.3441,
+      "good": 62569.1468,
+      "ratio": 0.9239,
+      "suggested_scalar": -0.0571,
+      "log_bad": 11.1232,
+      "log_good": 11.044
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8695,
+      "good": 0.8716,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.0017,
+      "log_bad": -0.1398,
+      "log_good": -0.1374
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 71.0,
+      "good": 53.0,
+      "ratio": 0.7465,
+      "suggested_scalar": -0.2109,
+      "log_bad": 4.2627,
+      "log_good": 3.9703
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 207.0,
+      "good": 199.0,
+      "ratio": 0.9614,
+      "suggested_scalar": -0.0284,
+      "log_bad": 5.3327,
+      "log_good": 5.2933
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4326,
+      "good": 0.3805,
+      "ratio": 0.8796,
+      "suggested_scalar": -0.0926,
+      "log_bad": -0.8379,
+      "log_good": -0.9663
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.4043,
+      "good": 8.469,
+      "ratio": 1.0077,
+      "suggested_scalar": 0.0055,
+      "log_bad": 2.1287,
+      "log_good": 2.1364
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1899,
+      "good": 0.2,
+      "ratio": 1.0532,
+      "suggested_scalar": 0.0374,
+      "log_bad": -1.6613,
+      "log_good": -1.6094
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.4965,
+      "good": 3.9435,
+      "ratio": 0.877,
+      "suggested_scalar": -0.0947,
+      "log_bad": 1.5033,
+      "log_good": 1.3721
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 429.0,
+      "good": 380.0,
+      "ratio": 0.8858,
+      "suggested_scalar": -0.0875,
+      "log_bad": 6.0615,
+      "log_good": 5.9402
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 67.0,
+      "good": 62.0,
+      "ratio": 0.9254,
+      "suggested_scalar": -0.0559,
+      "log_bad": 4.2047,
+      "log_good": 4.1271
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3762.5747,
+      "good": 3476.0637,
+      "ratio": 0.9239,
+      "suggested_scalar": -0.0571,
+      "log_bad": 8.2329,
+      "log_good": 8.1537
+    },
+    "readability.mean_total_lines": {
+      "bad": 64.0,
+      "good": 60.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0466,
+      "log_bad": 4.1589,
+      "log_good": 4.0943
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2497.9587,
+      "good": 2148.4709,
+      "ratio": 0.8601,
+      "suggested_scalar": -0.1087,
+      "log_bad": 7.8232,
+      "log_good": 7.6725
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 693.0,
+      "good": 590.0,
+      "ratio": 0.8514,
+      "suggested_scalar": -0.1161,
+      "log_bad": 6.541,
+      "log_good": 6.3801
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 33.7188,
+      "good": 31.0333,
+      "ratio": 0.9204,
+      "suggested_scalar": -0.0599,
+      "log_bad": 3.5181,
+      "log_good": 3.4351
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2412,
+      "good": 1.2398,
+      "ratio": 0.9989,
+      "suggested_scalar": -0.0008,
+      "log_bad": 0.2161,
+      "log_good": 0.215
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 1.0,
+      "ratio": 0.25,
+      "suggested_scalar": -1.0,
+      "log_bad": 1.3863,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7846,
+      "good": 0.7745,
+      "ratio": 0.9871,
+      "suggested_scalar": -0.0093,
+      "log_bad": -0.2426,
+      "log_good": -0.2555
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9729,
+      "good": 0.974,
+      "ratio": 1.0011,
+      "suggested_scalar": 0.0008,
+      "log_bad": -0.0275,
+      "log_good": -0.0263
+    },
+    "halstead.mean_length": {
+      "bad": 382.0,
+      "good": 346.0,
+      "ratio": 0.9058,
+      "suggested_scalar": -0.0714,
+      "log_bad": 5.9454,
+      "log_good": 5.8464
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.25,
+      "good": 10.5,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0498,
+      "log_bad": 2.4204,
+      "log_good": 2.3514
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6439,
+      "good": 6.3038,
+      "ratio": 0.9488,
+      "suggested_scalar": -0.0379,
+      "log_bad": 1.8937,
+      "log_good": 1.8412
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1019,
+      "good": 0.1069,
+      "ratio": 1.0491,
+      "suggested_scalar": 0.0346,
+      "log_bad": -2.2838,
+      "log_good": -2.2359
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.1127,
+      "good": 29.1226,
+      "ratio": 1.0741,
+      "suggested_scalar": 0.0516,
+      "log_bad": 3.3,
+      "log_good": 3.3715
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 61.0,
+      "good": 43.0,
+      "ratio": 0.7049,
+      "suggested_scalar": -0.2522,
+      "log_bad": 4.1109,
+      "log_good": 3.7612
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6466,
+      "good": 0.6267,
+      "ratio": 0.9692,
+      "suggested_scalar": -0.0225,
+      "log_bad": -0.436,
+      "log_good": -0.4673
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 64.0,
+      "good": 60.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0466,
+      "log_bad": 4.1589,
+      "log_good": 4.0943
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 19.0,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.0722,
+      "log_bad": 3.0445,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_nested_ternary": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 4.0,
+      "good": 32.0,
+      "ratio": 8.0,
+      "suggested_scalar": 0.5472,
+      "log_bad": 1.3863,
+      "log_good": 3.4657
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.014,
+      "good": 0.0148,
+      "ratio": 1.0571,
+      "suggested_scalar": 0.0146,
+      "log_bad": -4.2687,
+      "log_good": -4.2131
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.6667,
+      "good": 2.4,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0277,
+      "log_bad": 0.9808,
+      "log_good": 0.8755
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.57,
+      "good": 0.8837,
+      "ratio": 1.5504,
+      "suggested_scalar": 0.1154,
+      "log_bad": -0.5621,
+      "log_good": -0.1236
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.014,
+      "good": 0.0148,
+      "ratio": 1.0571,
+      "suggested_scalar": 0.0146,
+      "log_bad": -4.2687,
+      "log_good": -4.2131
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 3.6712,
+      "good": 4.7705,
+      "ratio": 1.2994,
+      "suggested_scalar": 0.0689,
+      "log_bad": 1.3005,
+      "log_good": 1.5625
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 70.0,
+      "good": 84.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.048,
+      "log_bad": 4.2485,
+      "log_good": 4.4308
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4133,
+      "good": 0.3479,
+      "ratio": 0.8418,
+      "suggested_scalar": -0.0453,
+      "log_bad": -0.8836,
+      "log_good": -1.0558
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 13.0,
+      "good": 15.0,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.0377,
+      "log_bad": 2.5649,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.561,
+      "good": 0.4941,
+      "ratio": 0.8807,
+      "suggested_scalar": -0.0334,
+      "log_bad": -0.578,
+      "log_good": -0.705
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 7.06,
+      "good": 2.3256,
+      "ratio": 0.3294,
+      "suggested_scalar": -0.2922,
+      "log_bad": 1.9544,
+      "log_good": 0.844
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 286.0,
+      "good": 473.0,
+      "ratio": 1.6538,
+      "suggested_scalar": 0.1324,
+      "log_bad": 5.656,
+      "log_good": 6.1591
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1824,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0005,
+      "good": 1.0,
+      "ratio": 2.0e3,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.6009,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0215,
+      "good": 1.1189,
+      "ratio": 1.0953,
+      "suggested_scalar": 0.024,
+      "log_bad": 0.0213,
+      "log_good": 0.1123
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 75.0,
+      "good": 123.0,
+      "ratio": 1.64,
+      "suggested_scalar": 0.1302,
+      "log_bad": 4.3175,
+      "log_good": 4.8122
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 111.7701,
+      "good": 97.2336,
+      "ratio": 0.8699,
+      "suggested_scalar": -0.0367,
+      "log_bad": 4.7164,
+      "log_good": 4.5771
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6035,
+      "good": 0.7479,
+      "ratio": 1.2393,
+      "suggested_scalar": 0.0564,
+      "log_bad": -0.505,
+      "log_good": -0.2905
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.2793,
+      "good": 11.0058,
+      "ratio": 0.9758,
+      "suggested_scalar": -0.0065,
+      "log_bad": 2.423,
+      "log_good": 2.3984
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1911.0,
+      "good": 1811.0,
+      "ratio": 0.9477,
+      "suggested_scalar": -0.0141,
+      "log_bad": 7.5554,
+      "log_good": 7.5016
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.43,
+      "good": 0.1163,
+      "ratio": 0.2705,
+      "suggested_scalar": -0.3441,
+      "log_bad": -0.844,
+      "log_good": -2.1516
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.47,
+      "good": 0.8605,
+      "ratio": 1.8309,
+      "suggested_scalar": 0.1591,
+      "log_bad": -0.755,
+      "log_good": -0.1502
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 2.86,
+      "good": 11.0,
+      "ratio": 3.8462,
+      "suggested_scalar": 0.3545,
+      "log_bad": 1.0508,
+      "log_good": 2.3979
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 17.0,
+      "ratio": 17.0,
+      "suggested_scalar": 0.7455,
+      "log_bad": 0.0,
+      "log_good": 2.8332
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 6.7564,
+      "good": 0.9173,
+      "ratio": 0.1358,
+      "suggested_scalar": -0.5254,
+      "log_bad": 1.9105,
+      "log_good": -0.0863
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 70.0,
+      "good": 98.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.0885,
+      "log_bad": 4.2485,
+      "log_good": 4.585
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9266,
+      "good": 0.9667,
+      "ratio": 1.0433,
+      "suggested_scalar": 0.0111,
+      "log_bad": -0.0762,
+      "log_good": -0.0339
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 20.0,
+      "good": 21.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0128,
+      "log_bad": 2.9957,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.742,
+      "good": 0.7096,
+      "ratio": 0.9563,
+      "suggested_scalar": -0.0117,
+      "log_bad": -0.2984,
+      "log_good": -0.3431
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3944,
+      "good": 0.5775,
+      "ratio": 1.4642,
+      "suggested_scalar": 0.1003,
+      "log_bad": -0.9304,
+      "log_good": -0.549
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.8763,
+      "good": 3.443,
+      "ratio": 0.8882,
+      "suggested_scalar": -0.0312,
+      "log_bad": 1.3549,
+      "log_good": 1.2363
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 284.0,
+      "good": 471.0,
+      "ratio": 1.6585,
+      "suggested_scalar": 0.1331,
+      "log_bad": 5.649,
+      "log_good": 6.1549
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 46.0,
+      "good": 7.0,
+      "ratio": 0.1522,
+      "suggested_scalar": -0.4954,
+      "log_bad": 3.8286,
+      "log_good": 1.9459
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 0.074,
+      "ratio": 0.074,
+      "suggested_scalar": -0.6851,
+      "log_bad": 0.0,
+      "log_good": -2.6037
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7279,
+      "good": 5.7814,
+      "ratio": 1.0093,
+      "suggested_scalar": 0.0024,
+      "log_bad": 1.7453,
+      "log_good": 1.7546
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 5.0,
+      "good": 8.0,
+      "ratio": 1.6,
+      "suggested_scalar": 0.1237,
+      "log_bad": 1.6094,
+      "log_good": 2.0794
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.3534,
+      "good": 0.9122,
+      "ratio": 2.5812,
+      "suggested_scalar": 0.2495,
+      "log_bad": -1.0402,
+      "log_good": -0.0919
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.274,
+      "good": 5.2466,
+      "ratio": 0.9948,
+      "suggested_scalar": -0.0014,
+      "log_bad": 1.6628,
+      "log_good": 1.6576
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.6409,
+      "good": 0.8252,
+      "ratio": 1.2876,
+      "suggested_scalar": 0.0665,
+      "log_bad": -0.4449,
+      "log_good": -0.1921
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.0476,
+      "good": 0.2037,
+      "ratio": 4.2794,
+      "suggested_scalar": 0.3825,
+      "log_bad": -3.0449,
+      "log_good": -1.5911
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.3585,
+      "good": 3.3175,
+      "ratio": 0.9878,
+      "suggested_scalar": -0.0032,
+      "log_bad": 1.2115,
+      "log_good": 1.1992
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 18.0,
+      "good": 16.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.031,
+      "log_bad": 2.8904,
+      "log_good": 2.7726
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 215.0,
+      "good": 281.0,
+      "ratio": 1.307,
+      "suggested_scalar": 0.0704,
+      "log_bad": 5.3706,
+      "log_good": 5.6384
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 16.0,
+      "ratio": 16.0,
+      "suggested_scalar": 0.7295,
+      "log_bad": 0.0,
+      "log_good": 2.7726
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5782,
+      "good": 1.0015,
+      "ratio": 1.7321,
+      "suggested_scalar": 0.1445,
+      "log_bad": -0.5478,
+      "log_good": 0.0015
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 74.0,
+      "good": 89.0,
+      "ratio": 1.2027,
+      "suggested_scalar": 0.0486,
+      "log_bad": 4.3041,
+      "log_good": 4.4886
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 523.0,
+      "good": 855.0,
+      "ratio": 1.6348,
+      "suggested_scalar": 0.1293,
+      "log_bad": 6.2596,
+      "log_good": 6.7511
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 105.0,
+      "good": 169.0,
+      "ratio": 1.6095,
+      "suggested_scalar": 0.1252,
+      "log_bad": 4.654,
+      "log_good": 5.1299
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1154,
+      "good": 0.3087,
+      "ratio": 2.675,
+      "suggested_scalar": 0.2589,
+      "log_bad": -2.1594,
+      "log_good": -1.1754
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 51.0,
+      "good": 87.0,
+      "ratio": 1.7059,
+      "suggested_scalar": 0.1405,
+      "log_bad": 3.9318,
+      "log_good": 4.4659
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 25.0,
+      "ratio": 8.3333,
+      "suggested_scalar": 0.5579,
+      "log_bad": 1.0986,
+      "log_good": 3.2189
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 74.0,
+      "good": 89.0,
+      "ratio": 1.2027,
+      "suggested_scalar": 0.0486,
+      "log_bad": 4.3041,
+      "log_good": 4.4886
+    },
+    "brevity.mean_sample_size": {
+      "bad": 74.0,
+      "good": 89.0,
+      "ratio": 1.2027,
+      "suggested_scalar": 0.0486,
+      "log_bad": 4.3041,
+      "log_good": 4.4886
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 286.0,
+      "good": 473.0,
+      "ratio": 1.6538,
+      "suggested_scalar": 0.1324,
+      "log_bad": 5.656,
+      "log_good": 6.1591
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 98.0,
+      "good": 251.0,
+      "ratio": 2.5612,
+      "suggested_scalar": 0.2475,
+      "log_bad": 4.585,
+      "log_good": 5.5255
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 164.0,
+      "good": 206.0,
+      "ratio": 1.2561,
+      "suggested_scalar": 0.06,
+      "log_bad": 5.0999,
+      "log_good": 5.3279
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0629,
+      "good": 0.0338,
+      "ratio": 0.5374,
+      "suggested_scalar": -0.1634,
+      "log_bad": -2.7662,
+      "log_good": -3.3873
+    },
+    "heaps.mean_k": {
+      "bad": 3.2086,
+      "good": 3.9747,
+      "ratio": 1.2388,
+      "suggested_scalar": 0.0563,
+      "log_bad": 1.1658,
+      "log_good": 1.3799
+    },
+    "halstead.mean_effort": {
+      "bad": 36426.329,
+      "good": 84623.6288,
+      "ratio": 2.3231,
+      "suggested_scalar": 0.2218,
+      "log_bad": 10.503,
+      "log_good": 11.346
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8493,
+      "good": 0.8102,
+      "ratio": 0.954,
+      "suggested_scalar": -0.0124,
+      "log_bad": -0.1633,
+      "log_good": -0.2105
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 50.0,
+      "good": 63.0,
+      "ratio": 1.26,
+      "suggested_scalar": 0.0608,
+      "log_bad": 3.912,
+      "log_good": 4.1431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 178.0,
+      "good": 301.0,
+      "ratio": 1.691,
+      "suggested_scalar": 0.1382,
+      "log_bad": 5.1818,
+      "log_good": 5.7071
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4133,
+      "good": 0.3577,
+      "ratio": 0.8655,
+      "suggested_scalar": -0.038,
+      "log_bad": -0.8836,
+      "log_good": -1.0281
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.9733,
+      "good": 6.9512,
+      "ratio": 0.9968,
+      "suggested_scalar": -0.0008,
+      "log_bad": 1.9421,
+      "log_good": 1.9389
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.0476,
+      "good": 0.2037,
+      "ratio": 4.2794,
+      "suggested_scalar": 0.3825,
+      "log_bad": -3.0449,
+      "log_good": -1.5911
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.144,
+      "good": 4.4,
+      "ratio": 3.8462,
+      "suggested_scalar": 0.3545,
+      "log_bad": 0.1345,
+      "log_good": 1.4816
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 285.0,
+      "good": 472.0,
+      "ratio": 1.6561,
+      "suggested_scalar": 0.1327,
+      "log_bad": 5.6525,
+      "log_good": 6.157
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 9.0,
+      "ratio": 9.0,
+      "suggested_scalar": 0.5781,
+      "log_bad": 0.0,
+      "log_good": 2.1972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 43.0,
+      "good": 82.0,
+      "ratio": 1.907,
+      "suggested_scalar": 0.1699,
+      "log_bad": 3.7612,
+      "log_good": 4.4067
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2023.6849,
+      "good": 4701.3127,
+      "ratio": 2.3231,
+      "suggested_scalar": 0.2218,
+      "log_bad": 7.6127,
+      "log_good": 8.4556
+    },
+    "readability.mean_total_lines": {
+      "bad": 100.0,
+      "good": 43.0,
+      "ratio": 0.43,
+      "suggested_scalar": -0.2221,
+      "log_bad": 4.6052,
+      "log_good": 3.7612
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 4.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.2891,
+      "log_bad": 2.4849,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1734.5871,
+      "good": 3004.3892,
+      "ratio": 1.732,
+      "suggested_scalar": 0.1445,
+      "log_bad": 7.4585,
+      "log_good": 8.0078
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 493.0,
+      "good": 526.0,
+      "ratio": 1.0669,
+      "suggested_scalar": 0.017,
+      "log_bad": 6.2005,
+      "log_good": 6.2653
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 18.06,
+      "good": 40.8605,
+      "ratio": 2.2625,
+      "suggested_scalar": 0.2148,
+      "log_bad": 2.8937,
+      "log_good": 3.7102
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0894,
+      "good": 1.1636,
+      "ratio": 1.0681,
+      "suggested_scalar": 0.0173,
+      "log_bad": 0.0856,
+      "log_good": 0.1515
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1824,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 36.0,
+      "good": 18.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.1824,
+      "log_bad": 3.5835,
+      "log_good": 2.8904
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8,
+      "good": 0.7082,
+      "ratio": 0.8852,
+      "suggested_scalar": -0.0321,
+      "log_bad": -0.2231,
+      "log_good": -0.345
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9688,
+      "good": 0.9672,
+      "ratio": 0.9983,
+      "suggested_scalar": -0.0004,
+      "log_bad": -0.0317,
+      "log_good": -0.0333
+    },
+    "halstead.mean_length": {
+      "bad": 283.0,
+      "good": 470.0,
+      "ratio": 1.6608,
+      "suggested_scalar": 0.1335,
+      "log_bad": 5.6454,
+      "log_good": 6.1527
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 34.0,
+      "good": 2.04,
+      "ratio": 0.06,
+      "suggested_scalar": -0.7403,
+      "log_bad": 3.5264,
+      "log_good": 0.7129
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2095,
+      "good": 6.4757,
+      "ratio": 1.0429,
+      "suggested_scalar": 0.011,
+      "log_bad": 1.8261,
+      "log_good": 1.8681
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0513,
+      "good": 0.1386,
+      "ratio": 2.7018,
+      "suggested_scalar": 0.2615,
+      "log_bad": -2.9701,
+      "log_good": -1.9762
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 21.0,
+      "good": 28.1667,
+      "ratio": 1.3413,
+      "suggested_scalar": 0.0773,
+      "log_bad": 3.0445,
+      "log_good": 3.3381
+    },
+    "branching.mean_branch_count": {
+      "bad": 43.0,
+      "good": 5.0,
+      "ratio": 0.1163,
+      "suggested_scalar": -0.5662,
+      "log_bad": 3.7612,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 31.0,
+      "good": 44.0,
+      "ratio": 1.4194,
+      "suggested_scalar": 0.0921,
+      "log_bad": 3.434,
+      "log_good": 3.7842
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.689,
+      "good": 0.5777,
+      "ratio": 0.8385,
+      "suggested_scalar": -0.0464,
+      "log_bad": -0.3725,
+      "log_good": -0.5487
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 100.0,
+      "good": 43.0,
+      "ratio": 0.43,
+      "suggested_scalar": -0.2221,
+      "log_bad": 4.6052,
+      "log_good": 3.7612
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 16.0,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.017,
+      "log_bad": 2.7081,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.predicate_prefixed_with_is": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0223,
+      "good": 1.0,
+      "ratio": 44.843,
+      "suggested_scalar": 1.9344,
+      "log_bad": -3.8032,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.2857,
+      "good": 1.2857,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2513,
+      "log_good": 0.2513
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8431,
+      "good": 0.8298,
+      "ratio": 0.9842,
+      "suggested_scalar": -0.0081,
+      "log_bad": -0.1707,
+      "log_good": -0.1866
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0223,
+      "good": 1.0,
+      "ratio": 44.843,
+      "suggested_scalar": 1.9344,
+      "log_bad": -3.8032,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.597,
+      "good": 4.5147,
+      "ratio": 0.9821,
+      "suggested_scalar": -0.0092,
+      "log_bad": 1.5254,
+      "log_good": 1.5073
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 91.0,
+      "good": 61.0,
+      "ratio": 0.6703,
+      "suggested_scalar": -0.2034,
+      "log_bad": 4.5109,
+      "log_good": 4.1109
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.54,
+      "good": 0.4844,
+      "ratio": 0.897,
+      "suggested_scalar": -0.0553,
+      "log_bad": -0.6162,
+      "log_good": -0.7248
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 17.0,
+      "ratio": 0.85,
+      "suggested_scalar": -0.0827,
+      "log_bad": 2.9957,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6618,
+      "good": 0.6117,
+      "ratio": 0.9243,
+      "suggested_scalar": -0.04,
+      "log_bad": -0.4128,
+      "log_good": -0.4915
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.7843,
+      "good": 4.8511,
+      "ratio": 1.014,
+      "suggested_scalar": 0.0071,
+      "log_bad": 1.5653,
+      "log_good": 1.5792
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 314.0,
+      "good": 246.0,
+      "ratio": 0.7834,
+      "suggested_scalar": -0.1241,
+      "log_bad": 5.7494,
+      "log_good": 5.5053
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0007,
+      "good": 0.0008,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.0679,
+      "log_bad": -7.2644,
+      "log_good": -7.1309
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1373,
+      "good": 0.0638,
+      "ratio": 0.4647,
+      "suggested_scalar": -0.3898,
+      "log_bad": -1.9856,
+      "log_good": -2.752
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9301,
+      "good": 1.0004,
+      "ratio": 1.0756,
+      "suggested_scalar": 0.0371,
+      "log_bad": -0.0725,
+      "log_good": 0.0004
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 102.0,
+      "good": 64.0,
+      "ratio": 0.6275,
+      "suggested_scalar": -0.2371,
+      "log_bad": 4.625,
+      "log_good": 4.1589
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.3423,
+      "good": 97.3916,
+      "ratio": 0.9334,
+      "suggested_scalar": -0.0351,
+      "log_bad": 4.6477,
+      "log_good": 4.5787
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5335,
+      "good": 0.6041,
+      "ratio": 1.1323,
+      "suggested_scalar": 0.0632,
+      "log_bad": -0.6283,
+      "log_good": -0.504
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.942,
+      "good": 12.4958,
+      "ratio": 1.142,
+      "suggested_scalar": 0.0675,
+      "log_bad": 2.3926,
+      "log_good": 2.5254
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1455.0,
+      "good": 1182.0,
+      "ratio": 0.8124,
+      "suggested_scalar": -0.1057,
+      "log_bad": 7.2828,
+      "log_good": 7.075
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0196,
+      "good": 1.0,
+      "ratio": 51.0204,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.9322,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8039,
+      "good": 0.7872,
+      "ratio": 0.9792,
+      "suggested_scalar": -0.0107,
+      "log_bad": -0.2183,
+      "log_good": -0.2393
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.4082,
+      "good": 5.4667,
+      "ratio": 0.8531,
+      "suggested_scalar": -0.0808,
+      "log_bad": 1.8576,
+      "log_good": 1.6987
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 11.0,
+      "good": 8.0,
+      "ratio": 0.7273,
+      "suggested_scalar": -0.162,
+      "log_bad": 2.3979,
+      "log_good": 2.0794
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 10.679,
+      "good": 11.531,
+      "ratio": 1.0798,
+      "suggested_scalar": 0.039,
+      "log_bad": 2.3683,
+      "log_good": 2.445
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 65.0,
+      "good": 30.0,
+      "ratio": 0.4615,
+      "suggested_scalar": -0.3933,
+      "log_bad": 4.1744,
+      "log_good": 3.4012
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9316,
+      "good": 0.9184,
+      "ratio": 0.9858,
+      "suggested_scalar": -0.0073,
+      "log_bad": -0.0709,
+      "log_good": -0.0851
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 22.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0443,
+      "log_bad": 3.1781,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6213,
+      "good": 0.6523,
+      "ratio": 1.0499,
+      "suggested_scalar": 0.0248,
+      "log_bad": -0.4759,
+      "log_good": -0.4273
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3429,
+      "good": 0.4016,
+      "ratio": 1.1712,
+      "suggested_scalar": 0.0804,
+      "log_bad": -1.0703,
+      "log_good": -0.9123
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6407,
+      "good": 2.8759,
+      "ratio": 1.0891,
+      "suggested_scalar": 0.0434,
+      "log_bad": 0.971,
+      "log_good": 1.0564
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 312.0,
+      "good": 244.0,
+      "ratio": 0.7821,
+      "suggested_scalar": -0.125,
+      "log_bad": 5.743,
+      "log_good": 5.4972
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.051,
+      "good": 0.065,
+      "ratio": 1.2745,
+      "suggested_scalar": 0.1234,
+      "log_bad": -2.9759,
+      "log_good": -2.7334
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0,
+      "good": 5.8329,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.0144,
+      "log_bad": 1.7918,
+      "log_good": 1.7635
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 26.0,
+      "good": 26.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2581,
+      "log_good": 3.2581
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2634,
+      "good": 1.4153,
+      "ratio": 1.1202,
+      "suggested_scalar": 0.0577,
+      "log_bad": 0.2338,
+      "log_good": 0.3473
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7779,
+      "good": 5.2662,
+      "ratio": 0.9114,
+      "suggested_scalar": -0.0472,
+      "log_bad": 1.754,
+      "log_good": 1.6613
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7662,
+      "good": 0.774,
+      "ratio": 1.0102,
+      "suggested_scalar": 0.0052,
+      "log_bad": -0.2663,
+      "log_good": -0.2562
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1356,
+      "good": 0.1455,
+      "ratio": 1.073,
+      "suggested_scalar": 0.0358,
+      "log_bad": -1.998,
+      "log_good": -1.9276
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.3079,
+      "good": 3.5349,
+      "ratio": 1.0686,
+      "suggested_scalar": 0.0338,
+      "log_bad": 1.1963,
+      "log_good": 1.2627
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 237.0,
+      "good": 175.0,
+      "ratio": 0.7384,
+      "suggested_scalar": -0.1543,
+      "log_bad": 5.4681,
+      "log_good": 5.1648
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6117,
+      "good": 0.4567,
+      "ratio": 0.7466,
+      "suggested_scalar": -0.1486,
+      "log_bad": -0.4915,
+      "log_good": -0.7837
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 91.0,
+      "good": 64.0,
+      "ratio": 0.7033,
+      "suggested_scalar": -0.179,
+      "log_bad": 4.5109,
+      "log_good": 4.1589
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 675.0,
+      "good": 503.0,
+      "ratio": 0.7452,
+      "suggested_scalar": -0.1496,
+      "log_bad": 6.5147,
+      "log_good": 6.2206
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 128.0,
+      "good": 90.0,
+      "ratio": 0.7031,
+      "suggested_scalar": -0.1791,
+      "log_bad": 4.852,
+      "log_good": 4.4998
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0223,
+      "good": 0.0285,
+      "ratio": 1.278,
+      "suggested_scalar": 0.1248,
+      "log_bad": -3.8032,
+      "log_good": -3.5579
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2325,
+      "good": 0.2602,
+      "ratio": 1.1191,
+      "suggested_scalar": 0.0573,
+      "log_bad": -1.4589,
+      "log_good": -1.3463
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 50.0,
+      "good": 44.0,
+      "ratio": 0.88,
+      "suggested_scalar": -0.065,
+      "log_bad": 3.912,
+      "log_good": 3.7842
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 91.0,
+      "good": 64.0,
+      "ratio": 0.7033,
+      "suggested_scalar": -0.179,
+      "log_bad": 4.5109,
+      "log_good": 4.1589
+    },
+    "brevity.mean_sample_size": {
+      "bad": 91.0,
+      "good": 64.0,
+      "ratio": 0.7033,
+      "suggested_scalar": -0.179,
+      "log_bad": 4.5109,
+      "log_good": 4.1589
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 314.0,
+      "good": 246.0,
+      "ratio": 0.7834,
+      "suggested_scalar": -0.1241,
+      "log_bad": 5.7494,
+      "log_good": 5.5053
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 155.0,
+      "good": 129.0,
+      "ratio": 0.8323,
+      "suggested_scalar": -0.0934,
+      "log_bad": 5.0434,
+      "log_good": 4.8598
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 196.0,
+      "good": 141.0,
+      "ratio": 0.7194,
+      "suggested_scalar": -0.1675,
+      "log_bad": 5.2781,
+      "log_good": 4.9488
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.0171,
+      "good": 2.3769,
+      "ratio": 1.1784,
+      "suggested_scalar": 0.0835,
+      "log_bad": 0.7017,
+      "log_good": 0.8658
+    },
+    "halstead.mean_effort": {
+      "bad": 42072.601,
+      "good": 34776.9313,
+      "ratio": 0.8266,
+      "suggested_scalar": -0.0969,
+      "log_bad": 10.6472,
+      "log_good": 10.4567
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8878,
+      "good": 0.8777,
+      "ratio": 0.9886,
+      "suggested_scalar": -0.0058,
+      "log_bad": -0.119,
+      "log_good": -0.1305
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 67.0,
+      "good": 39.0,
+      "ratio": 0.5821,
+      "suggested_scalar": -0.2752,
+      "log_bad": 4.2047,
+      "log_good": 3.6636
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 154.0,
+      "good": 141.0,
+      "ratio": 0.9156,
+      "suggested_scalar": -0.0449,
+      "log_bad": 5.037,
+      "log_good": 4.9488
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5294,
+      "good": 0.4844,
+      "ratio": 0.915,
+      "suggested_scalar": -0.0452,
+      "log_bad": -0.636,
+      "log_good": -0.7248
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.6176,
+      "good": 7.8594,
+      "ratio": 1.1877,
+      "suggested_scalar": 0.0875,
+      "log_bad": 1.8897,
+      "log_good": 2.0617
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1356,
+      "good": 0.1455,
+      "ratio": 1.073,
+      "suggested_scalar": 0.0358,
+      "log_bad": -1.998,
+      "log_good": -1.9276
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.5633,
+      "good": 2.5375,
+      "ratio": 0.9899,
+      "suggested_scalar": -0.0051,
+      "log_bad": 0.9413,
+      "log_good": 0.9312
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 313.0,
+      "good": 245.0,
+      "ratio": 0.7827,
+      "suggested_scalar": -0.1246,
+      "log_bad": 5.7462,
+      "log_good": 5.5013
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 32.0,
+      "good": 29.0,
+      "ratio": 0.9063,
+      "suggested_scalar": -0.0501,
+      "log_bad": 3.4657,
+      "log_good": 3.3673
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2337.3667,
+      "good": 1932.0517,
+      "ratio": 0.8266,
+      "suggested_scalar": -0.0969,
+      "log_bad": 7.7568,
+      "log_good": 7.5663
+    },
+    "readability.mean_total_lines": {
+      "bad": 49.0,
+      "good": 45.0,
+      "ratio": 0.9184,
+      "suggested_scalar": -0.0433,
+      "log_bad": 3.8918,
+      "log_good": 3.8067
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 1835.1981,
+      "good": 1370.0003,
+      "ratio": 0.7465,
+      "suggested_scalar": -0.1487,
+      "log_bad": 7.5149,
+      "log_good": 7.2226
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 551.0,
+      "good": 411.0,
+      "ratio": 0.7459,
+      "suggested_scalar": -0.1491,
+      "log_bad": 6.3117,
+      "log_good": 6.0186
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 27.2449,
+      "good": 23.7778,
+      "ratio": 0.8727,
+      "suggested_scalar": -0.0692,
+      "log_bad": 3.3049,
+      "log_good": 3.1688
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1346,
+      "good": 1.2281,
+      "ratio": 1.0824,
+      "suggested_scalar": 0.0403,
+      "log_bad": 0.1263,
+      "log_good": 0.2055
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 3.0,
+      "ratio": 0.4286,
+      "suggested_scalar": -0.431,
+      "log_bad": 1.9459,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.865,
+      "good": 0.8343,
+      "ratio": 0.9645,
+      "suggested_scalar": -0.0184,
+      "log_bad": -0.145,
+      "log_good": -0.1812
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9908,
+      "good": 0.9812,
+      "ratio": 0.9903,
+      "suggested_scalar": -0.005,
+      "log_bad": -0.0092,
+      "log_good": -0.019
+    },
+    "halstead.mean_length": {
+      "bad": 282.0,
+      "good": 231.0,
+      "ratio": 0.8191,
+      "suggested_scalar": -0.1015,
+      "log_bad": 5.6419,
+      "log_good": 5.4424
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.5714,
+      "good": 5.0,
+      "ratio": 0.8974,
+      "suggested_scalar": -0.055,
+      "log_bad": 1.7176,
+      "log_good": 1.6094
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5078,
+      "good": 6.0,
+      "ratio": 0.922,
+      "suggested_scalar": -0.0413,
+      "log_bad": 1.873,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1068,
+      "good": 0.1091,
+      "ratio": 1.0215,
+      "suggested_scalar": 0.0108,
+      "log_bad": -2.2368,
+      "log_good": -2.2155
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 22.9254,
+      "good": 25.3846,
+      "ratio": 1.1073,
+      "suggested_scalar": 0.0518,
+      "log_bad": 3.1322,
+      "log_good": 3.2341
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 54.0,
+      "good": 31.0,
+      "ratio": 0.5741,
+      "suggested_scalar": -0.2823,
+      "log_bad": 3.989,
+      "log_good": 3.434
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7449,
+      "good": 0.6879,
+      "ratio": 0.9235,
+      "suggested_scalar": -0.0405,
+      "log_bad": -0.2945,
+      "log_good": -0.3741
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 51.0,
+      "good": 47.0,
+      "ratio": 0.9216,
+      "suggested_scalar": -0.0415,
+      "log_bad": 3.9318,
+      "log_good": 3.8501
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.zero_value_is_usable": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0212,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0115,
+      "good": 0.0071,
+      "ratio": 0.6174,
+      "suggested_scalar": -0.1483,
+      "log_bad": -4.4654,
+      "log_good": -4.9477
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.75,
+      "good": 1.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0885,
+      "log_bad": -0.2877,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7755,
+      "good": 0.8108,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.0137,
+      "log_bad": -0.2542,
+      "log_good": -0.2097
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0115,
+      "good": 0.0071,
+      "ratio": 0.6174,
+      "suggested_scalar": -0.1483,
+      "log_bad": -4.4654,
+      "log_good": -4.9477
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8699,
+      "good": 4.8123,
+      "ratio": 0.9882,
+      "suggested_scalar": -0.0037,
+      "log_bad": 1.5831,
+      "log_good": 1.5712
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 92.0,
+      "good": 86.0,
+      "ratio": 0.9348,
+      "suggested_scalar": -0.0207,
+      "log_bad": 4.5218,
+      "log_good": 4.4543
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4107,
+      "good": 0.4431,
+      "ratio": 1.0789,
+      "suggested_scalar": 0.0234,
+      "log_bad": -0.8899,
+      "log_good": -0.814
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 15.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.0385,
+      "log_bad": 2.8332,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6226,
+      "good": 0.6528,
+      "ratio": 1.0485,
+      "suggested_scalar": 0.0146,
+      "log_bad": -0.4739,
+      "log_good": -0.4265
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.6122,
+      "good": 0.3784,
+      "ratio": 0.6181,
+      "suggested_scalar": -0.148,
+      "log_bad": -0.4907,
+      "log_good": -0.9718
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 348.0,
+      "good": 283.0,
+      "ratio": 0.8132,
+      "suggested_scalar": -0.0636,
+      "log_bad": 5.8522,
+      "log_good": 5.6454
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 2.0,
+      "ratio": 0.4,
+      "suggested_scalar": -0.2818,
+      "log_bad": 1.6094,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0015,
+      "good": 1.0,
+      "ratio": 666.6667,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.5023,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2041,
+      "good": 0.3514,
+      "ratio": 1.7217,
+      "suggested_scalar": 0.1671,
+      "log_bad": -1.5891,
+      "log_good": -1.0458
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9254,
+      "good": 0.8484,
+      "ratio": 0.9168,
+      "suggested_scalar": -0.0267,
+      "log_bad": -0.0775,
+      "log_good": -0.1644
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 141.0,
+      "good": 125.0,
+      "ratio": 0.8865,
+      "suggested_scalar": -0.037,
+      "log_bad": 4.9488,
+      "log_good": 4.8283
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 109.238,
+      "good": 110.1881,
+      "ratio": 1.0087,
+      "suggested_scalar": 0.0027,
+      "log_bad": 4.6935,
+      "log_good": 4.7022
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6081,
+      "good": 0.5355,
+      "ratio": 0.8806,
+      "suggested_scalar": -0.0391,
+      "log_bad": -0.4974,
+      "log_good": -0.6246
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.3837,
+      "good": 10.6857,
+      "ratio": 0.7984,
+      "suggested_scalar": -0.0692,
+      "log_bad": 2.594,
+      "log_good": 2.3689
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1376.0,
+      "good": 1078.0,
+      "ratio": 0.7834,
+      "suggested_scalar": -0.0751,
+      "log_bad": 7.2269,
+      "log_good": 6.9829
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0816,
+      "good": 0.027,
+      "ratio": 0.3309,
+      "suggested_scalar": -0.3402,
+      "log_bad": -2.5059,
+      "log_good": -3.6119
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7551,
+      "good": 0.8108,
+      "ratio": 1.0738,
+      "suggested_scalar": 0.0219,
+      "log_bad": -0.2809,
+      "log_good": -0.2097
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.102,
+      "good": 7.6486,
+      "ratio": 1.077,
+      "suggested_scalar": 0.0228,
+      "log_bad": 1.9604,
+      "log_good": 2.0345
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.4007,
+      "good": 0.2352,
+      "ratio": 0.587,
+      "suggested_scalar": -0.1639,
+      "log_bad": -0.9145,
+      "log_good": -1.4473
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 104.0,
+      "good": 97.0,
+      "ratio": 0.9327,
+      "suggested_scalar": -0.0214,
+      "log_bad": 4.6444,
+      "log_good": 4.5747
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9549,
+      "good": 0.9315,
+      "ratio": 0.9755,
+      "suggested_scalar": -0.0076,
+      "log_bad": -0.0461,
+      "log_good": -0.071
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 22.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.0514,
+      "log_bad": 3.2581,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6032,
+      "good": 0.5547,
+      "ratio": 0.9196,
+      "suggested_scalar": -0.0258,
+      "log_bad": -0.5055,
+      "log_good": -0.5893
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4451,
+      "good": 0.3772,
+      "ratio": 0.8475,
+      "suggested_scalar": -0.0509,
+      "log_bad": -0.8095,
+      "log_good": -0.975
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5201,
+      "good": 2.2458,
+      "ratio": 0.8912,
+      "suggested_scalar": -0.0354,
+      "log_bad": 0.9243,
+      "log_good": 0.8091
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 346.0,
+      "good": 281.0,
+      "ratio": 0.8121,
+      "suggested_scalar": -0.064,
+      "log_bad": 5.8464,
+      "log_good": 5.6384
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 11.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0268,
+      "log_bad": 2.4849,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0115,
+      "good": 0.0035,
+      "ratio": 0.3043,
+      "suggested_scalar": -0.3659,
+      "log_bad": -4.4654,
+      "log_good": -5.655
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.7549,
+      "ratio": 0.9743,
+      "suggested_scalar": -0.008,
+      "log_bad": 1.7761,
+      "log_good": 1.7501
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 37.0,
+      "good": 28.0,
+      "ratio": 0.7568,
+      "suggested_scalar": -0.0857,
+      "log_bad": 3.6109,
+      "log_good": 3.3322
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8304,
+      "good": 0.7674,
+      "ratio": 0.9241,
+      "suggested_scalar": -0.0243,
+      "log_bad": -0.1858,
+      "log_good": -0.2647
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7088,
+      "good": 5.6188,
+      "ratio": 0.9842,
+      "suggested_scalar": -0.0049,
+      "log_bad": 1.742,
+      "log_good": 1.7261
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8245,
+      "good": 0.8362,
+      "ratio": 1.0142,
+      "suggested_scalar": 0.0043,
+      "log_bad": -0.193,
+      "log_good": -0.1789
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1091,
+      "good": 0.1395,
+      "ratio": 1.2786,
+      "suggested_scalar": 0.0756,
+      "log_bad": -2.2155,
+      "log_good": -1.9697
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6584,
+      "good": 3.2689,
+      "ratio": 0.8935,
+      "suggested_scalar": -0.0346,
+      "log_bad": 1.297,
+      "log_good": 1.1845
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 251.0,
+      "good": 213.0,
+      "ratio": 0.8486,
+      "suggested_scalar": -0.0505,
+      "log_bad": 5.5255,
+      "log_good": 5.3613
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 1.0,
+      "ratio": 0.25,
+      "suggested_scalar": -0.4264,
+      "log_bad": 1.3863,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7198,
+      "good": 0.5891,
+      "ratio": 0.8184,
+      "suggested_scalar": -0.0616,
+      "log_bad": -0.3288,
+      "log_good": -0.5292
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 91.0,
+      "good": 86.0,
+      "ratio": 0.9451,
+      "suggested_scalar": -0.0174,
+      "log_bad": 4.5109,
+      "log_good": 4.4543
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 771.0,
+      "good": 619.0,
+      "ratio": 0.8029,
+      "suggested_scalar": -0.0675,
+      "log_bad": 6.6477,
+      "log_good": 6.4281
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 158.0,
+      "good": 143.0,
+      "ratio": 0.9051,
+      "suggested_scalar": -0.0307,
+      "log_bad": 5.0626,
+      "log_good": 4.9628
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2011,
+      "good": 0.1979,
+      "ratio": 0.9841,
+      "suggested_scalar": -0.0049,
+      "log_bad": -1.604,
+      "log_good": -1.62
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 68.0,
+      "good": 45.0,
+      "ratio": 0.6618,
+      "suggested_scalar": -0.127,
+      "log_bad": 4.2195,
+      "log_good": 3.8067
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0885,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 91.0,
+      "good": 86.0,
+      "ratio": 0.9451,
+      "suggested_scalar": -0.0174,
+      "log_bad": 4.5109,
+      "log_good": 4.4543
+    },
+    "brevity.mean_sample_size": {
+      "bad": 91.0,
+      "good": 86.0,
+      "ratio": 0.9451,
+      "suggested_scalar": -0.0174,
+      "log_bad": 4.5109,
+      "log_good": 4.4543
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 348.0,
+      "good": 283.0,
+      "ratio": 0.8132,
+      "suggested_scalar": -0.0636,
+      "log_bad": 5.8522,
+      "log_good": 5.6454
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 156.0,
+      "good": 124.0,
+      "ratio": 0.7949,
+      "suggested_scalar": -0.0706,
+      "log_bad": 5.0499,
+      "log_good": 4.8203
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 204.0,
+      "good": 176.0,
+      "ratio": 0.8627,
+      "suggested_scalar": -0.0454,
+      "log_bad": 5.3181,
+      "log_good": 5.1705
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.7866,
+      "good": 2.5059,
+      "ratio": 0.8993,
+      "suggested_scalar": -0.0327,
+      "log_bad": 1.0248,
+      "log_good": 0.9186
+    },
+    "halstead.mean_effort": {
+      "bad": 67200.0024,
+      "good": 43435.0231,
+      "ratio": 0.6464,
+      "suggested_scalar": -0.1342,
+      "log_bad": 11.1154,
+      "log_good": 10.679
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8772,
+      "good": 0.8743,
+      "ratio": 0.9967,
+      "suggested_scalar": -0.001,
+      "log_bad": -0.131,
+      "log_good": -0.1343
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 66.0,
+      "good": 64.0,
+      "ratio": 0.9697,
+      "suggested_scalar": -0.0095,
+      "log_bad": 4.1897,
+      "log_good": 4.1589
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 173.0,
+      "good": 132.0,
+      "ratio": 0.763,
+      "suggested_scalar": -0.0832,
+      "log_bad": 5.1533,
+      "log_good": 4.8828
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3688,
+      "good": 0.432,
+      "ratio": 1.1714,
+      "suggested_scalar": 0.0487,
+      "log_bad": -0.9975,
+      "log_good": -0.8393
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.4681,
+      "good": 4.952,
+      "ratio": 0.9056,
+      "suggested_scalar": -0.0305,
+      "log_bad": 1.6989,
+      "log_good": 1.5998
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1091,
+      "good": 0.1395,
+      "ratio": 1.2786,
+      "suggested_scalar": 0.0756,
+      "log_bad": -2.2155,
+      "log_good": -1.9697
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.8408,
+      "good": 3.0595,
+      "ratio": 1.077,
+      "suggested_scalar": 0.0228,
+      "log_bad": 1.0441,
+      "log_good": 1.1183
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 347.0,
+      "good": 282.0,
+      "ratio": 0.8127,
+      "suggested_scalar": -0.0638,
+      "log_bad": 5.8493,
+      "log_good": 5.6419
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 59.0,
+      "good": 38.0,
+      "ratio": 0.6441,
+      "suggested_scalar": -0.1353,
+      "log_bad": 4.0775,
+      "log_good": 3.6376
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3733.3335,
+      "good": 2413.0568,
+      "ratio": 0.6464,
+      "suggested_scalar": -0.1342,
+      "log_bad": 8.2251,
+      "log_good": 7.7886
+    },
+    "readability.mean_total_lines": {
+      "bad": 49.0,
+      "good": 37.0,
+      "ratio": 0.7551,
+      "suggested_scalar": -0.0864,
+      "log_bad": 3.8918,
+      "log_good": 3.6109
+    },
+    "indentation.mean_max_depth": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2132,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 2159.299,
+      "good": 1767.2228,
+      "ratio": 0.8184,
+      "suggested_scalar": -0.0616,
+      "log_bad": 7.6775,
+      "log_good": 7.4772
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 546.0,
+      "good": 480.0,
+      "ratio": 0.8791,
+      "suggested_scalar": -0.0396,
+      "log_bad": 6.3026,
+      "log_good": 6.1738
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 26.8776,
+      "good": 27.8649,
+      "ratio": 1.0367,
+      "suggested_scalar": 0.0111,
+      "log_bad": 3.2913,
+      "log_good": 3.3274
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0684,
+      "good": 1.0506,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0052,
+      "log_bad": 0.0662,
+      "log_good": 0.0494
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 2.0,
+      "ratio": 0.4,
+      "suggested_scalar": -0.2818,
+      "log_bad": 1.6094,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 30.0,
+      "good": 29.0,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0104,
+      "log_bad": 3.4012,
+      "log_good": 3.3673
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 10.0,
+      "good": 13.0,
+      "ratio": 1.3,
+      "suggested_scalar": 0.0807,
+      "log_bad": 2.3026,
+      "log_good": 2.5649
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7649,
+      "good": 0.8216,
+      "ratio": 1.0741,
+      "suggested_scalar": 0.022,
+      "log_bad": -0.268,
+      "log_good": -0.1965
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9548,
+      "good": 0.9577,
+      "ratio": 1.003,
+      "suggested_scalar": 0.0009,
+      "log_bad": -0.0463,
+      "log_good": -0.0432
+    },
+    "halstead.mean_length": {
+      "bad": 331.0,
+      "good": 275.0,
+      "ratio": 0.8308,
+      "suggested_scalar": -0.057,
+      "log_bad": 5.8021,
+      "log_good": 5.6168
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.25,
+      "good": 9.3333,
+      "ratio": 1.009,
+      "suggested_scalar": 0.0028,
+      "log_bad": 2.2246,
+      "log_good": 2.2336
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5078,
+      "good": 6.4263,
+      "ratio": 0.9875,
+      "suggested_scalar": -0.0039,
+      "log_bad": 1.873,
+      "log_good": 1.8604
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1137,
+      "good": 0.1155,
+      "ratio": 1.0158,
+      "suggested_scalar": 0.0048,
+      "log_bad": -2.1742,
+      "log_good": -2.1585
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 31.1212,
+      "good": 24.5781,
+      "ratio": 0.7898,
+      "suggested_scalar": -0.0726,
+      "log_bad": 3.4379,
+      "log_good": 3.2019
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 1.0,
+      "ratio": 0.25,
+      "suggested_scalar": -0.4264,
+      "log_bad": 1.3863,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 52.0,
+      "good": 54.0,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0116,
+      "log_bad": 3.9512,
+      "log_good": 3.989
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6667,
+      "good": 0.7443,
+      "ratio": 1.1164,
+      "suggested_scalar": 0.0339,
+      "log_bad": -0.4054,
+      "log_good": -0.2953
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 49.0,
+      "good": 37.0,
+      "ratio": 0.7551,
+      "suggested_scalar": -0.0864,
+      "log_bad": 3.8918,
+      "log_good": 3.6109
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_non_null_assertion_operator": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 23.0,
+      "good": 24.0,
+      "ratio": 1.0435,
+      "suggested_scalar": 0.0149,
+      "log_bad": 3.1355,
+      "log_good": 3.1781
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 0.0033,
+      "ratio": 0.0033,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.7138
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.2,
+      "good": 1.2,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1823,
+      "log_good": 0.1823
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.875,
+      "good": 0.9024,
+      "ratio": 1.0313,
+      "suggested_scalar": 0.0108,
+      "log_bad": -0.1335,
+      "log_good": -0.1027
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 0.0033,
+      "ratio": 0.0033,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.7138
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5622,
+      "good": 4.5373,
+      "ratio": 0.9945,
+      "suggested_scalar": -0.0019,
+      "log_bad": 1.5178,
+      "log_good": 1.5123
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 77.0,
+      "good": 86.0,
+      "ratio": 1.1169,
+      "suggested_scalar": 0.0387,
+      "log_bad": 4.3438,
+      "log_good": 4.4543
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5017,
+      "good": 0.5087,
+      "ratio": 1.014,
+      "suggested_scalar": 0.0049,
+      "log_bad": -0.6898,
+      "log_good": -0.6759
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 13.0,
+      "good": 16.0,
+      "ratio": 1.2308,
+      "suggested_scalar": 0.0727,
+      "log_bad": 2.5649,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6878,
+      "good": 0.6951,
+      "ratio": 1.0106,
+      "suggested_scalar": 0.0037,
+      "log_bad": -0.3743,
+      "log_good": -0.3637
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.4,
+      "good": 5.8537,
+      "ratio": 1.084,
+      "suggested_scalar": 0.0282,
+      "log_bad": 1.6864,
+      "log_good": 1.7671
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 273.0,
+      "good": 307.0,
+      "ratio": 1.1245,
+      "suggested_scalar": 0.0411,
+      "log_bad": 5.6095,
+      "log_good": 5.7268
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1007,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.018,
+      "good": 0.0025,
+      "ratio": 0.1389,
+      "suggested_scalar": -0.691,
+      "log_bad": -4.0174,
+      "log_good": -5.9915
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.125,
+      "good": 0.0732,
+      "ratio": 0.5856,
+      "suggested_scalar": -0.1873,
+      "log_bad": -2.0794,
+      "log_good": -2.6146
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0021,
+      "good": 0.0075,
+      "ratio": 3.5714,
+      "suggested_scalar": 0.4456,
+      "log_bad": -6.1658,
+      "log_good": -4.8929
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9473,
+      "good": 0.9534,
+      "ratio": 1.0064,
+      "suggested_scalar": 0.0022,
+      "log_bad": -0.0541,
+      "log_good": -0.0477
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 105.0,
+      "good": 122.0,
+      "ratio": 1.1619,
+      "suggested_scalar": 0.0525,
+      "log_bad": 4.654,
+      "log_good": 4.804
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 88.6852,
+      "good": 92.0398,
+      "ratio": 1.0378,
+      "suggested_scalar": 0.013,
+      "log_bad": 4.4851,
+      "log_good": 4.5222
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5331,
+      "good": 0.5392,
+      "ratio": 1.0114,
+      "suggested_scalar": 0.004,
+      "log_bad": -0.629,
+      "log_good": -0.6177
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 16.478,
+      "good": 13.9828,
+      "ratio": 0.8486,
+      "suggested_scalar": -0.0575,
+      "log_bad": 2.802,
+      "log_good": 2.6378
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1449.0,
+      "good": 1608.0,
+      "ratio": 1.1097,
+      "suggested_scalar": 0.0364,
+      "log_bad": 7.2786,
+      "log_good": 7.3827
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1,
+      "good": 0.0488,
+      "ratio": 0.488,
+      "suggested_scalar": -0.2511,
+      "log_bad": -2.3026,
+      "log_good": -3.02
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.825,
+      "good": 0.8537,
+      "ratio": 1.0348,
+      "suggested_scalar": 0.012,
+      "log_bad": -0.1924,
+      "log_good": -0.1582
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.825,
+      "good": 7.4878,
+      "ratio": 1.0971,
+      "suggested_scalar": 0.0324,
+      "log_bad": 1.9206,
+      "log_good": 2.0133
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 10.84,
+      "good": 16.4664,
+      "ratio": 1.519,
+      "suggested_scalar": 0.1463,
+      "log_bad": 2.3832,
+      "log_good": 2.8013
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 61.0,
+      "good": 70.0,
+      "ratio": 1.1475,
+      "suggested_scalar": 0.0482,
+      "log_bad": 4.1109,
+      "log_good": 4.2485
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9406,
+      "good": 0.942,
+      "ratio": 1.0015,
+      "suggested_scalar": 0.0005,
+      "log_bad": -0.0612,
+      "log_good": -0.0598
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 20.0,
+      "good": 21.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0171,
+      "log_bad": 2.9957,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6239,
+      "good": 0.635,
+      "ratio": 1.0178,
+      "suggested_scalar": 0.0062,
+      "log_bad": -0.4718,
+      "log_good": -0.4541
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.369,
+      "good": 0.3934,
+      "ratio": 1.0661,
+      "suggested_scalar": 0.0224,
+      "log_bad": -0.997,
+      "log_good": -0.9329
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6587,
+      "good": 2.7394,
+      "ratio": 1.0304,
+      "suggested_scalar": 0.0105,
+      "log_bad": 0.9778,
+      "log_good": 1.0077
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 271.0,
+      "good": 305.0,
+      "ratio": 1.1255,
+      "suggested_scalar": 0.0414,
+      "log_bad": 5.6021,
+      "log_good": 5.7203
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0476,
+      "good": 0.0423,
+      "ratio": 0.8887,
+      "suggested_scalar": -0.0413,
+      "log_bad": -3.0449,
+      "log_good": -3.163
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7549,
+      "good": 5.8329,
+      "ratio": 1.0136,
+      "suggested_scalar": 0.0047,
+      "log_bad": 1.7501,
+      "log_good": 1.7635
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 21.0,
+      "good": 28.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1007,
+      "log_bad": 3.0445,
+      "log_good": 3.3322
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3994,
+      "good": 1.4086,
+      "ratio": 1.0066,
+      "suggested_scalar": 0.0023,
+      "log_bad": 0.336,
+      "log_good": 0.3426
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5445,
+      "good": 5.6585,
+      "ratio": 1.0206,
+      "suggested_scalar": 0.0071,
+      "log_bad": 1.7128,
+      "log_good": 1.7332
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7928,
+      "good": 0.7779,
+      "ratio": 0.9812,
+      "suggested_scalar": -0.0066,
+      "log_bad": -0.2322,
+      "log_good": -0.2512
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1667,
+      "good": 0.1633,
+      "ratio": 0.9796,
+      "suggested_scalar": -0.0072,
+      "log_bad": -1.7916,
+      "log_good": -1.8122
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.0593,
+      "good": 3.7394,
+      "ratio": 0.9212,
+      "suggested_scalar": -0.0287,
+      "log_bad": 1.401,
+      "log_good": 1.3189
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 213.0,
+      "good": 241.0,
+      "ratio": 1.1315,
+      "suggested_scalar": 0.0432,
+      "log_bad": 5.3613,
+      "log_good": 5.4848
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 8.0,
+      "good": 6.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1007,
+      "log_bad": 2.0794,
+      "log_good": 1.7918
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5557,
+      "good": 0.6148,
+      "ratio": 1.1064,
+      "suggested_scalar": 0.0354,
+      "log_bad": -0.5875,
+      "log_good": -0.4865
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 79.0,
+      "good": 89.0,
+      "ratio": 1.1266,
+      "suggested_scalar": 0.0417,
+      "log_bad": 4.3694,
+      "log_good": 4.4886
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 790.0,
+      "good": 870.0,
+      "ratio": 1.1013,
+      "suggested_scalar": 0.0338,
+      "log_bad": 6.672,
+      "log_good": 6.7685
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 121.0,
+      "good": 141.0,
+      "ratio": 1.1653,
+      "suggested_scalar": 0.0535,
+      "log_bad": 4.7958,
+      "log_good": 4.9488
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2308,
+      "good": 0.2476,
+      "ratio": 1.0728,
+      "suggested_scalar": 0.0246,
+      "log_bad": -1.4662,
+      "log_good": -1.3959
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 47.0,
+      "good": 60.0,
+      "ratio": 1.2766,
+      "suggested_scalar": 0.0855,
+      "log_bad": 3.8501,
+      "log_good": 4.0943
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 79.0,
+      "good": 89.0,
+      "ratio": 1.1266,
+      "suggested_scalar": 0.0417,
+      "log_bad": 4.3694,
+      "log_good": 4.4886
+    },
+    "brevity.mean_sample_size": {
+      "bad": 79.0,
+      "good": 89.0,
+      "ratio": 1.1266,
+      "suggested_scalar": 0.0417,
+      "log_bad": 4.3694,
+      "log_good": 4.4886
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 273.0,
+      "good": 307.0,
+      "ratio": 1.1245,
+      "suggested_scalar": 0.0411,
+      "log_bad": 5.6095,
+      "log_good": 5.7268
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 130.0,
+      "good": 146.0,
+      "ratio": 1.1231,
+      "suggested_scalar": 0.0406,
+      "log_bad": 4.8675,
+      "log_good": 4.9836
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 174.0,
+      "good": 201.0,
+      "ratio": 1.1552,
+      "suggested_scalar": 0.0505,
+      "log_bad": 5.1591,
+      "log_good": 5.3033
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.8023,
+      "good": 1.7627,
+      "ratio": 0.978,
+      "suggested_scalar": -0.0078,
+      "log_bad": 0.5891,
+      "log_good": 0.5668
+    },
+    "halstead.mean_effort": {
+      "bad": 35386.4547,
+      "good": 42008.3444,
+      "ratio": 1.1871,
+      "suggested_scalar": 0.06,
+      "log_bad": 10.4741,
+      "log_good": 10.6456
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8795,
+      "good": 0.8738,
+      "ratio": 0.9935,
+      "suggested_scalar": -0.0023,
+      "log_bad": -0.1284,
+      "log_good": -0.1349
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 57.0,
+      "good": 65.0,
+      "ratio": 1.1404,
+      "suggested_scalar": 0.046,
+      "log_bad": 4.0431,
+      "log_good": 4.1744
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 145.0,
+      "good": 146.0,
+      "ratio": 1.0069,
+      "suggested_scalar": 0.0024,
+      "log_bad": 4.9767,
+      "log_good": 4.9836
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5048,
+      "good": 0.4836,
+      "ratio": 0.958,
+      "suggested_scalar": -0.015,
+      "log_bad": -0.6836,
+      "log_good": -0.7265
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.5238,
+      "good": 7.1311,
+      "ratio": 0.9478,
+      "suggested_scalar": -0.0188,
+      "log_bad": 2.0181,
+      "log_good": 1.9645
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1667,
+      "good": 0.1633,
+      "ratio": 0.9796,
+      "suggested_scalar": -0.0072,
+      "log_bad": -1.7916,
+      "log_good": -1.8122
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.5272,
+      "good": 5.2311,
+      "ratio": 0.9464,
+      "suggested_scalar": -0.0193,
+      "log_bad": 1.7097,
+      "log_good": 1.6546
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 272.0,
+      "good": 306.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0412,
+      "log_bad": 5.6058,
+      "log_good": 5.7236
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 42.0,
+      "good": 56.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1007,
+      "log_bad": 3.7377,
+      "log_good": 4.0254
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1965.9141,
+      "good": 2333.7969,
+      "ratio": 1.1871,
+      "suggested_scalar": 0.06,
+      "log_bad": 7.5837,
+      "log_good": 7.7553
+    },
+    "readability.mean_total_lines": {
+      "bad": 40.0,
+      "good": 41.0,
+      "ratio": 1.025,
+      "suggested_scalar": 0.0086,
+      "log_bad": 3.6889,
+      "log_good": 3.7136
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 20.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.1788,
+      "log_bad": 2.4849,
+      "log_good": 2.9957
+    },
+    "halstead.mean_volume": {
+      "bad": 1666.9652,
+      "good": 1844.338,
+      "ratio": 1.1064,
+      "suggested_scalar": 0.0354,
+      "log_bad": 7.4188,
+      "log_good": 7.5199
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 545.0,
+      "good": 587.0,
+      "ratio": 1.0771,
+      "suggested_scalar": 0.026,
+      "log_bad": 6.3008,
+      "log_good": 6.375
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 34.825,
+      "good": 37.878,
+      "ratio": 1.0877,
+      "suggested_scalar": 0.0294,
+      "log_bad": 3.5503,
+      "log_good": 3.6344
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3147,
+      "good": 1.2671,
+      "ratio": 0.9638,
+      "suggested_scalar": -0.0129,
+      "log_bad": 0.2736,
+      "log_good": 0.2367
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1007,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 13.0,
+      "good": 21.0,
+      "ratio": 1.6154,
+      "suggested_scalar": 0.1679,
+      "log_bad": 2.5649,
+      "log_good": 3.0445
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 3.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.1788,
+      "log_bad": 1.6094,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8028,
+      "good": 0.7676,
+      "ratio": 0.9562,
+      "suggested_scalar": -0.0157,
+      "log_bad": -0.2196,
+      "log_good": -0.2645
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9837,
+      "good": 0.9894,
+      "ratio": 1.0058,
+      "suggested_scalar": 0.002,
+      "log_bad": -0.0164,
+      "log_good": -0.0107
+    },
+    "halstead.mean_length": {
+      "bad": 266.0,
+      "good": 287.0,
+      "ratio": 1.0789,
+      "suggested_scalar": 0.0266,
+      "log_bad": 5.5835,
+      "log_good": 5.6595
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.6,
+      "good": 6.8,
+      "ratio": 1.0303,
+      "suggested_scalar": 0.0104,
+      "log_bad": 1.8871,
+      "log_good": 1.9169
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.3038,
+      "good": 6.4757,
+      "ratio": 1.0273,
+      "suggested_scalar": 0.0094,
+      "log_bad": 1.8412,
+      "log_good": 1.8681
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0902,
+      "good": 0.0911,
+      "ratio": 1.01,
+      "suggested_scalar": 0.0035,
+      "log_bad": -2.4057,
+      "log_good": -2.3958
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 21.2281,
+      "good": 22.7769,
+      "ratio": 1.073,
+      "suggested_scalar": 0.0246,
+      "log_bad": 3.0553,
+      "log_good": 3.1257
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 2.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2426,
+      "log_bad": 1.3863,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 53.0,
+      "good": 59.0,
+      "ratio": 1.1132,
+      "suggested_scalar": 0.0375,
+      "log_bad": 3.9703,
+      "log_good": 4.0775
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7299,
+      "good": 0.7015,
+      "ratio": 0.9611,
+      "suggested_scalar": -0.0139,
+      "log_bad": -0.3148,
+      "log_good": -0.3545
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 40.0,
+      "good": 41.0,
+      "ratio": 1.025,
+      "suggested_scalar": 0.0086,
+      "log_bad": 3.6889,
+      "log_good": 3.7136
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 26.0,
+      "good": 21.0,
+      "ratio": 0.8077,
+      "suggested_scalar": -0.0748,
+      "log_bad": 3.2581,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.named_return_values_used_for_documentation": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0492,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 13.0,
+      "good": 10.0,
+      "ratio": 0.7692,
+      "suggested_scalar": -0.0707,
+      "log_bad": 2.5649,
+      "log_good": 2.3026
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0214,
+      "good": 0.0256,
+      "ratio": 1.1963,
+      "suggested_scalar": 0.0483,
+      "log_bad": -3.8444,
+      "log_good": -3.6652
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8654,
+      "good": 0.7778,
+      "ratio": 0.8988,
+      "suggested_scalar": -0.0288,
+      "log_bad": -0.1446,
+      "log_good": -0.2513
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0214,
+      "good": 0.0256,
+      "ratio": 1.1963,
+      "suggested_scalar": 0.0483,
+      "log_bad": -3.8444,
+      "log_good": -3.6652
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.9046,
+      "good": 4.8569,
+      "ratio": 0.9903,
+      "suggested_scalar": -0.0026,
+      "log_bad": 1.5902,
+      "log_good": 1.5804
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 120.0,
+      "good": 111.0,
+      "ratio": 0.925,
+      "suggested_scalar": -0.021,
+      "log_bad": 4.7875,
+      "log_good": 4.7095
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5123,
+      "good": 0.4416,
+      "ratio": 0.862,
+      "suggested_scalar": -0.04,
+      "log_bad": -0.6688,
+      "log_good": -0.8174
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 17.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.0154,
+      "log_bad": 2.8904,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6354,
+      "good": 0.645,
+      "ratio": 1.0151,
+      "suggested_scalar": 0.004,
+      "log_bad": -0.4535,
+      "log_good": -0.4385
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.9231,
+      "good": 1.037,
+      "ratio": 1.1234,
+      "suggested_scalar": 0.0314,
+      "log_bad": -0.08,
+      "log_good": 0.0363
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 467.0,
+      "good": 430.0,
+      "ratio": 0.9208,
+      "suggested_scalar": -0.0223,
+      "log_bad": 6.1463,
+      "log_good": 6.0638
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0018,
+      "good": 0.0019,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.0146,
+      "log_bad": -6.32,
+      "log_good": -6.2659
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1538,
+      "good": 0.1111,
+      "ratio": 0.7224,
+      "suggested_scalar": -0.0877,
+      "log_bad": -1.8721,
+      "log_good": -2.1973
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0006,
+      "good": 1.0,
+      "ratio": 1666.6667,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.4186,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9388,
+      "good": 0.9552,
+      "ratio": 1.0175,
+      "suggested_scalar": 0.0047,
+      "log_bad": -0.0632,
+      "log_good": -0.0458
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 174.0,
+      "good": 161.0,
+      "ratio": 0.9253,
+      "suggested_scalar": -0.0209,
+      "log_bad": 5.1591,
+      "log_good": 5.0814
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 107.0512,
+      "good": 107.1992,
+      "ratio": 1.0014,
+      "suggested_scalar": 0.0004,
+      "log_bad": 4.6733,
+      "log_good": 4.6747
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5322,
+      "good": 0.5664,
+      "ratio": 1.0643,
+      "suggested_scalar": 0.0168,
+      "log_bad": -0.6307,
+      "log_good": -0.5685
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 6.5134,
+      "good": 6.3531,
+      "ratio": 0.9754,
+      "suggested_scalar": -0.0067,
+      "log_bad": 1.8739,
+      "log_good": 1.8489
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1682.0,
+      "good": 1543.0,
+      "ratio": 0.9174,
+      "suggested_scalar": -0.0233,
+      "log_bad": 7.4277,
+      "log_good": 7.3415
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1346,
+      "good": 0.1481,
+      "ratio": 1.1003,
+      "suggested_scalar": 0.0258,
+      "log_bad": -2.0054,
+      "log_good": -1.9099
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8269,
+      "good": 0.7222,
+      "ratio": 0.8734,
+      "suggested_scalar": -0.0365,
+      "log_bad": -0.1901,
+      "log_good": -0.3255
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.9808,
+      "good": 7.963,
+      "ratio": 0.8867,
+      "suggested_scalar": -0.0324,
+      "log_bad": 2.1951,
+      "log_good": 2.0748
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.6479,
+      "good": 0.6653,
+      "ratio": 1.0269,
+      "suggested_scalar": 0.0071,
+      "log_bad": -0.434,
+      "log_good": -0.4075
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 140.0,
+      "good": 125.0,
+      "ratio": 0.8929,
+      "suggested_scalar": -0.0306,
+      "log_bad": 4.9416,
+      "log_good": 4.8283
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9373,
+      "good": 0.9408,
+      "ratio": 1.0037,
+      "suggested_scalar": 0.001,
+      "log_bad": -0.0648,
+      "log_good": -0.061
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 32.0,
+      "good": 32.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4657,
+      "log_good": 3.4657
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5577,
+      "good": 0.5703,
+      "ratio": 1.0226,
+      "suggested_scalar": 0.006,
+      "log_bad": -0.5839,
+      "log_good": -0.5616
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3118,
+      "good": 0.3435,
+      "ratio": 1.1017,
+      "suggested_scalar": 0.0261,
+      "log_bad": -1.1654,
+      "log_good": -1.0686
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2608,
+      "good": 2.3273,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.0078,
+      "log_bad": 0.8157,
+      "log_good": 0.8447
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 465.0,
+      "good": 428.0,
+      "ratio": 0.9204,
+      "suggested_scalar": -0.0224,
+      "log_bad": 6.142,
+      "log_good": 6.0591
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 18.0,
+      "good": 24.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0776,
+      "log_bad": 2.8904,
+      "log_good": 3.1781
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0064,
+      "good": 0.007,
+      "ratio": 1.0938,
+      "suggested_scalar": 0.0242,
+      "log_bad": -5.0515,
+      "log_good": -4.9618
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9773,
+      "good": 5.9069,
+      "ratio": 0.9882,
+      "suggested_scalar": -0.0032,
+      "log_bad": 1.788,
+      "log_good": 1.7761
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 29.0,
+      "good": 30.0,
+      "ratio": 1.0345,
+      "suggested_scalar": 0.0091,
+      "log_bad": 3.3673,
+      "log_good": 3.4012
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8304,
+      "good": 0.912,
+      "ratio": 1.0983,
+      "suggested_scalar": 0.0253,
+      "log_bad": -0.1858,
+      "log_good": -0.0921
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.075,
+      "good": 5.9442,
+      "ratio": 0.9785,
+      "suggested_scalar": -0.0059,
+      "log_bad": 1.8042,
+      "log_good": 1.7824
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8205,
+      "good": 0.8222,
+      "ratio": 1.0021,
+      "suggested_scalar": 0.0006,
+      "log_bad": -0.1978,
+      "log_good": -0.1958
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.0714,
+      "good": 0.069,
+      "ratio": 0.9664,
+      "suggested_scalar": -0.0092,
+      "log_bad": -2.6395,
+      "log_good": -2.6736
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.5521,
+      "good": 2.5205,
+      "ratio": 0.9876,
+      "suggested_scalar": -0.0034,
+      "log_bad": 0.9369,
+      "log_good": 0.9245
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 381.0,
+      "good": 340.0,
+      "ratio": 0.8924,
+      "suggested_scalar": -0.0307,
+      "log_bad": 5.9428,
+      "log_good": 5.8289
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9739,
+      "good": 0.8742,
+      "ratio": 0.8976,
+      "suggested_scalar": -0.0291,
+      "log_bad": -0.0264,
+      "log_good": -0.1344
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 117.0,
+      "good": 107.0,
+      "ratio": 0.9145,
+      "suggested_scalar": -0.0241,
+      "log_bad": 4.7622,
+      "log_good": 4.6728
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 887.0,
+      "good": 810.0,
+      "ratio": 0.9132,
+      "suggested_scalar": -0.0245,
+      "log_bad": 6.7878,
+      "log_good": 6.697
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 197.0,
+      "good": 167.0,
+      "ratio": 0.8477,
+      "suggested_scalar": -0.0445,
+      "log_bad": 5.2832,
+      "log_good": 5.118
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2034,
+      "good": 0.214,
+      "ratio": 1.0521,
+      "suggested_scalar": 0.0137,
+      "log_bad": -1.5926,
+      "log_good": -1.5418
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 87.0,
+      "good": 82.0,
+      "ratio": 0.9425,
+      "suggested_scalar": -0.016,
+      "log_bad": 4.4659,
+      "log_good": 4.4067
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 117.0,
+      "good": 107.0,
+      "ratio": 0.9145,
+      "suggested_scalar": -0.0241,
+      "log_bad": 4.7622,
+      "log_good": 4.6728
+    },
+    "brevity.mean_sample_size": {
+      "bad": 117.0,
+      "good": 107.0,
+      "ratio": 0.9145,
+      "suggested_scalar": -0.0241,
+      "log_bad": 4.7622,
+      "log_good": 4.6728
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 467.0,
+      "good": 430.0,
+      "ratio": 0.9208,
+      "suggested_scalar": -0.0223,
+      "log_bad": 6.1463,
+      "log_good": 6.0638
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 219.0,
+      "good": 206.0,
+      "ratio": 0.9406,
+      "suggested_scalar": -0.0165,
+      "log_bad": 5.3891,
+      "log_good": 5.3279
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 305.0,
+      "good": 268.0,
+      "ratio": 0.8787,
+      "suggested_scalar": -0.0349,
+      "log_bad": 5.7203,
+      "log_good": 5.591
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.575,
+      "good": 2.3139,
+      "ratio": 0.8986,
+      "suggested_scalar": -0.0288,
+      "log_bad": 0.9458,
+      "log_good": 0.8389
+    },
+    "halstead.mean_effort": {
+      "bad": 104646.9273,
+      "good": 88705.1414,
+      "ratio": 0.8477,
+      "suggested_scalar": -0.0446,
+      "log_bad": 11.5583,
+      "log_good": 11.3931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8842,
+      "good": 0.8817,
+      "ratio": 0.9972,
+      "suggested_scalar": -0.0008,
+      "log_bad": -0.1231,
+      "log_good": -0.1259
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 88.0,
+      "good": 79.0,
+      "ratio": 0.8977,
+      "suggested_scalar": -0.0291,
+      "log_bad": 4.4773,
+      "log_good": 4.3694
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 226.0,
+      "good": 219.0,
+      "ratio": 0.969,
+      "suggested_scalar": -0.0085,
+      "log_bad": 5.4205,
+      "log_good": 5.3891
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4483,
+      "good": 0.441,
+      "ratio": 0.9837,
+      "suggested_scalar": -0.0044,
+      "log_bad": -0.8023,
+      "log_good": -0.8187
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.0977,
+      "good": 5.0311,
+      "ratio": 0.9869,
+      "suggested_scalar": -0.0035,
+      "log_bad": 1.6288,
+      "log_good": 1.6156
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.0714,
+      "good": 0.069,
+      "ratio": 0.9664,
+      "suggested_scalar": -0.0092,
+      "log_bad": -2.6395,
+      "log_good": -2.6736
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.5923,
+      "good": 3.1852,
+      "ratio": 0.8867,
+      "suggested_scalar": -0.0324,
+      "log_bad": 1.2788,
+      "log_good": 1.1585
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 466.0,
+      "good": 429.0,
+      "ratio": 0.9206,
+      "suggested_scalar": -0.0223,
+      "log_bad": 6.1442,
+      "log_good": 6.0615
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 61.0,
+      "good": 59.0,
+      "ratio": 0.9672,
+      "suggested_scalar": -0.009,
+      "log_bad": 4.1109,
+      "log_good": 4.0775
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5813.7182,
+      "good": 4928.0634,
+      "ratio": 0.8477,
+      "suggested_scalar": -0.0446,
+      "log_bad": 8.668,
+      "log_good": 8.5027
+    },
+    "readability.mean_total_lines": {
+      "bad": 52.0,
+      "good": 54.0,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0102,
+      "log_bad": 3.9512,
+      "log_good": 3.989
+    },
+    "indentation.mean_max_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "halstead.mean_volume": {
+      "bad": 2921.6147,
+      "good": 2622.6445,
+      "ratio": 0.8977,
+      "suggested_scalar": -0.0291,
+      "log_bad": 7.9799,
+      "log_good": 7.8719
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 744.0,
+      "good": 663.0,
+      "ratio": 0.8911,
+      "suggested_scalar": -0.0311,
+      "log_bad": 6.612,
+      "log_good": 6.4968
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.1538,
+      "good": 27.5,
+      "ratio": 0.8827,
+      "suggested_scalar": -0.0336,
+      "log_bad": 3.4389,
+      "log_good": 3.3142
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0717,
+      "good": 1.0822,
+      "ratio": 1.0098,
+      "suggested_scalar": 0.0026,
+      "log_bad": 0.0692,
+      "log_good": 0.079
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 20.0,
+      "good": 22.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0257,
+      "log_bad": 2.9957,
+      "log_good": 3.091
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 8.0,
+      "good": 6.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0776,
+      "log_bad": 2.0794,
+      "log_good": 1.7918
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8399,
+      "good": 0.8265,
+      "ratio": 0.984,
+      "suggested_scalar": -0.0043,
+      "log_bad": -0.1745,
+      "log_good": -0.1906
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9582,
+      "good": 0.9553,
+      "ratio": 0.997,
+      "suggested_scalar": -0.0008,
+      "log_bad": -0.0427,
+      "log_good": -0.0457
+    },
+    "halstead.mean_length": {
+      "bad": 423.0,
+      "good": 386.0,
+      "ratio": 0.9125,
+      "suggested_scalar": -0.0247,
+      "log_bad": 6.0474,
+      "log_good": 5.9558
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 14.6667,
+      "good": 15.6667,
+      "ratio": 1.0682,
+      "suggested_scalar": 0.0178,
+      "log_bad": 2.6856,
+      "log_good": 2.7515
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8704,
+      "good": 6.7415,
+      "ratio": 0.9812,
+      "suggested_scalar": -0.0051,
+      "log_bad": 1.9272,
+      "log_good": 1.9083
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1307,
+      "good": 0.1335,
+      "ratio": 1.0214,
+      "suggested_scalar": 0.0057,
+      "log_bad": -2.0349,
+      "log_good": -2.0137
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 35.8182,
+      "good": 33.8228,
+      "ratio": 0.9443,
+      "suggested_scalar": -0.0155,
+      "log_bad": 3.5785,
+      "log_good": 3.5211
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 8.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.036,
+      "log_bad": 1.9459,
+      "log_good": 2.0794
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 78.0,
+      "good": 71.0,
+      "ratio": 0.9103,
+      "suggested_scalar": -0.0253,
+      "log_bad": 4.3567,
+      "log_good": 4.2627
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7148,
+      "good": 0.694,
+      "ratio": 0.9709,
+      "suggested_scalar": -0.008,
+      "log_bad": -0.3358,
+      "log_good": -0.3653
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 52.0,
+      "good": 54.0,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0102,
+      "log_bad": 3.9512,
+      "log_good": 3.989
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 11.0,
+      "ratio": 0.6471,
+      "suggested_scalar": -0.1174,
+      "log_bad": 2.8332,
+      "log_good": 2.3979
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "documentation.public_api_has_moduledoc_and_doc": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 45.0,
+      "good": 55.0,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.0552,
+      "log_bad": 3.8067,
+      "log_good": 4.0073
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 0.014,
+      "ratio": 0.014,
+      "suggested_scalar": -1.1752,
+      "log_bad": 0.0,
+      "log_good": -4.2687
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.2222,
+      "good": 2.2222,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.7985,
+      "log_good": 0.7985
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8429,
+      "good": 0.8222,
+      "ratio": 0.9754,
+      "suggested_scalar": -0.0068,
+      "log_bad": -0.1709,
+      "log_good": -0.1958
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 0.014,
+      "ratio": 0.014,
+      "suggested_scalar": -1.1752,
+      "log_bad": 0.0,
+      "log_good": -4.2687
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7273,
+      "good": 4.764,
+      "ratio": 1.0078,
+      "suggested_scalar": 0.0021,
+      "log_bad": 1.5534,
+      "log_good": 1.5611
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 137.0,
+      "good": 102.0,
+      "ratio": 0.7445,
+      "suggested_scalar": -0.0812,
+      "log_bad": 4.92,
+      "log_good": 4.625
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5131,
+      "good": 0.5406,
+      "ratio": 1.0536,
+      "suggested_scalar": 0.0144,
+      "log_bad": -0.6673,
+      "log_good": -0.6151
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 24.0,
+      "good": 22.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.024,
+      "log_bad": 3.1781,
+      "log_good": 3.091
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5633,
+      "good": 0.567,
+      "ratio": 1.0066,
+      "suggested_scalar": 0.0018,
+      "log_bad": -0.5739,
+      "log_good": -0.5674
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.9571,
+      "good": 3.6111,
+      "ratio": 0.9126,
+      "suggested_scalar": -0.0252,
+      "log_bad": 1.3755,
+      "log_good": 1.284
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 640.0,
+      "good": 859.0,
+      "ratio": 1.3422,
+      "suggested_scalar": 0.081,
+      "log_bad": 6.4615,
+      "log_good": 6.7558
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1,
+      "good": 0.0111,
+      "ratio": 0.111,
+      "suggested_scalar": -0.6052,
+      "log_bad": -2.3026,
+      "log_good": -4.5008
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0007,
+      "good": 1.0,
+      "ratio": 1428.5714,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.2644,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0069,
+      "good": 1.0599,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0141,
+      "log_bad": 0.0069,
+      "log_good": 0.0582
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 230.0,
+      "good": 324.0,
+      "ratio": 1.4087,
+      "suggested_scalar": 0.0943,
+      "log_bad": 5.4381,
+      "log_good": 5.7807
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 93.6768,
+      "good": 98.1281,
+      "ratio": 1.0475,
+      "suggested_scalar": 0.0128,
+      "log_bad": 4.5399,
+      "log_good": 4.5863
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6557,
+      "good": 0.6946,
+      "ratio": 1.0593,
+      "suggested_scalar": 0.0159,
+      "log_bad": -0.4221,
+      "log_good": -0.3644
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 19.0208,
+      "good": 15.5378,
+      "ratio": 0.8169,
+      "suggested_scalar": -0.0557,
+      "log_bad": 2.9455,
+      "log_good": 2.7433
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2745.0,
+      "good": 3477.0,
+      "ratio": 1.2667,
+      "suggested_scalar": 0.0651,
+      "log_bad": 7.9175,
+      "log_good": 8.1539
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1143,
+      "good": 0.1333,
+      "ratio": 1.1662,
+      "suggested_scalar": 0.0423,
+      "log_bad": -2.1689,
+      "log_good": -2.0152
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8143,
+      "good": 0.8,
+      "ratio": 0.9824,
+      "suggested_scalar": -0.0049,
+      "log_bad": -0.2054,
+      "log_good": -0.2231
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.1587,
+      "good": 9.6517,
+      "ratio": 0.9501,
+      "suggested_scalar": -0.0141,
+      "log_bad": 2.3183,
+      "log_good": 2.2671
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1116,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.241,
+      "good": 4.8154,
+      "ratio": 0.9188,
+      "suggested_scalar": -0.0233,
+      "log_bad": 1.6565,
+      "log_good": 1.5718
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 187.0,
+      "good": 272.0,
+      "ratio": 1.4545,
+      "suggested_scalar": 0.1032,
+      "log_bad": 5.2311,
+      "log_good": 5.6058
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9689,
+      "good": 0.9693,
+      "ratio": 1.0004,
+      "suggested_scalar": 0.0001,
+      "log_bad": -0.0316,
+      "log_good": -0.0312
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 38.0,
+      "good": 35.0,
+      "ratio": 0.9211,
+      "suggested_scalar": -0.0226,
+      "log_bad": 3.6376,
+      "log_good": 3.5553
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6506,
+      "good": 0.6555,
+      "ratio": 1.0075,
+      "suggested_scalar": 0.0021,
+      "log_bad": -0.4299,
+      "log_good": -0.4224
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4639,
+      "good": 0.4842,
+      "ratio": 1.0438,
+      "suggested_scalar": 0.0118,
+      "log_bad": -0.7681,
+      "log_good": -0.7253
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.8624,
+      "good": 2.9023,
+      "ratio": 1.0139,
+      "suggested_scalar": 0.0038,
+      "log_bad": 1.0517,
+      "log_good": 1.0655
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 638.0,
+      "good": 857.0,
+      "ratio": 1.3433,
+      "suggested_scalar": 0.0812,
+      "log_bad": 6.4583,
+      "log_good": 6.7534
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 13.0,
+      "good": 18.0,
+      "ratio": 1.3846,
+      "suggested_scalar": 0.0896,
+      "log_bad": 2.5649,
+      "log_good": 2.8904
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0313,
+      "good": 0.0186,
+      "ratio": 0.5942,
+      "suggested_scalar": -0.1433,
+      "log_bad": -3.4641,
+      "log_good": -3.9846
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0444,
+      "good": 6.0875,
+      "ratio": 1.0071,
+      "suggested_scalar": 0.002,
+      "log_bad": 1.7991,
+      "log_good": 1.8062
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 41.0,
+      "good": 49.0,
+      "ratio": 1.1951,
+      "suggested_scalar": 0.0491,
+      "log_bad": 3.7136,
+      "log_good": 3.8918
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7458,
+      "good": 0.6866,
+      "ratio": 0.9206,
+      "suggested_scalar": -0.0228,
+      "log_bad": -0.2933,
+      "log_good": -0.376
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9863,
+      "good": 6.0599,
+      "ratio": 1.0123,
+      "suggested_scalar": 0.0034,
+      "log_bad": 1.7895,
+      "log_good": 1.8017
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7821,
+      "good": 0.7826,
+      "ratio": 1.0006,
+      "suggested_scalar": 0.0002,
+      "log_bad": -0.2458,
+      "log_good": -0.2451
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1358,
+      "good": 0.1743,
+      "ratio": 1.2835,
+      "suggested_scalar": 0.0687,
+      "log_bad": -1.9966,
+      "log_good": -1.747
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.3613,
+      "good": 3.9418,
+      "ratio": 0.9038,
+      "suggested_scalar": -0.0278,
+      "log_bad": 1.4728,
+      "log_good": 1.3716
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 5.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.2523,
+      "log_bad": 0.6931,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 464.0,
+      "good": 606.0,
+      "ratio": 1.306,
+      "suggested_scalar": 0.0735,
+      "log_bad": 6.1399,
+      "log_good": 6.4069
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 9.0,
+      "good": 17.0,
+      "ratio": 1.8889,
+      "suggested_scalar": 0.1751,
+      "log_bad": 2.1972,
+      "log_good": 2.8332
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.4456,
+      "good": 1.4613,
+      "ratio": 1.0109,
+      "suggested_scalar": 0.003,
+      "log_bad": 0.3685,
+      "log_good": 0.3793
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 142.0,
+      "good": 166.0,
+      "ratio": 1.169,
+      "suggested_scalar": 0.043,
+      "log_bad": 4.9558,
+      "log_good": 5.112
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1557.0,
+      "good": 2024.0,
+      "ratio": 1.2999,
+      "suggested_scalar": 0.0722,
+      "log_bad": 7.3505,
+      "log_good": 7.6128
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 249.0,
+      "good": 212.0,
+      "ratio": 0.8514,
+      "suggested_scalar": -0.0443,
+      "log_bad": 5.5175,
+      "log_good": 5.3566
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0063,
+      "good": 0.0047,
+      "ratio": 0.746,
+      "suggested_scalar": -0.0807,
+      "log_bad": -5.0672,
+      "log_good": -5.3602
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2875,
+      "good": 0.2584,
+      "ratio": 0.8988,
+      "suggested_scalar": -0.0294,
+      "log_bad": -1.2465,
+      "log_good": -1.3532
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 135.0,
+      "good": 184.0,
+      "ratio": 1.363,
+      "suggested_scalar": 0.0853,
+      "log_bad": 4.9053,
+      "log_good": 5.2149
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 142.0,
+      "good": 166.0,
+      "ratio": 1.169,
+      "suggested_scalar": 0.043,
+      "log_bad": 4.9558,
+      "log_good": 5.112
+    },
+    "brevity.mean_sample_size": {
+      "bad": 142.0,
+      "good": 166.0,
+      "ratio": 1.169,
+      "suggested_scalar": 0.043,
+      "log_bad": 4.9558,
+      "log_good": 5.112
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 640.0,
+      "good": 859.0,
+      "ratio": 1.3422,
+      "suggested_scalar": 0.081,
+      "log_bad": 6.4615,
+      "log_good": 6.7558
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 328.0,
+      "good": 448.0,
+      "ratio": 1.3659,
+      "suggested_scalar": 0.0858,
+      "log_bad": 5.793,
+      "log_good": 6.1048
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 355.0,
+      "good": 446.0,
+      "ratio": 1.2563,
+      "suggested_scalar": 0.0628,
+      "log_bad": 5.8721,
+      "log_good": 6.1003
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0031,
+      "good": 0.0058,
+      "ratio": 1.871,
+      "suggested_scalar": 0.1725,
+      "log_bad": -5.7764,
+      "log_good": -5.1499
+    },
+    "heaps.mean_k": {
+      "bad": 4.1361,
+      "good": 3.9529,
+      "ratio": 0.9557,
+      "suggested_scalar": -0.0125,
+      "log_bad": 1.4198,
+      "log_good": 1.3744
+    },
+    "halstead.mean_effort": {
+      "bad": 207251.137,
+      "good": 242743.8298,
+      "ratio": 1.1713,
+      "suggested_scalar": 0.0435,
+      "log_bad": 12.2417,
+      "log_good": 12.3998
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8373,
+      "good": 0.8217,
+      "ratio": 0.9814,
+      "suggested_scalar": -0.0052,
+      "log_bad": -0.1776,
+      "log_good": -0.1964
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 99.0,
+      "good": 67.0,
+      "ratio": 0.6768,
+      "suggested_scalar": -0.1075,
+      "log_bad": 4.5951,
+      "log_good": 4.2047
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 362.0,
+      "good": 445.0,
+      "ratio": 1.2293,
+      "suggested_scalar": 0.0568,
+      "log_bad": 5.8916,
+      "log_good": 6.0981
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3826,
+      "good": 0.3673,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0112,
+      "log_bad": -0.9608,
+      "log_good": -1.0016
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.7696,
+      "good": 6.2469,
+      "ratio": 0.9228,
+      "suggested_scalar": -0.0221,
+      "log_bad": 1.9124,
+      "log_good": 1.8321
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1358,
+      "good": 0.1743,
+      "ratio": 1.2835,
+      "suggested_scalar": 0.0687,
+      "log_bad": -1.9966,
+      "log_good": -1.747
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.9785,
+      "good": 4.5572,
+      "ratio": 0.9154,
+      "suggested_scalar": -0.0243,
+      "log_bad": 1.6051,
+      "log_good": 1.5167
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 639.0,
+      "good": 858.0,
+      "ratio": 1.3427,
+      "suggested_scalar": 0.0811,
+      "log_bad": 6.4599,
+      "log_good": 6.7546
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 7.0,
+      "ratio": 2.3333,
+      "suggested_scalar": 0.2333,
+      "log_bad": 1.0986,
+      "log_good": 1.9459
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 122.0,
+      "good": 164.0,
+      "ratio": 1.3443,
+      "suggested_scalar": 0.0815,
+      "log_bad": 4.804,
+      "log_good": 5.0999
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 11513.9521,
+      "good": 13485.7683,
+      "ratio": 1.1713,
+      "suggested_scalar": 0.0435,
+      "log_bad": 9.3513,
+      "log_good": 9.5094
+    },
+    "readability.mean_total_lines": {
+      "bad": 63.0,
+      "good": 89.0,
+      "ratio": 1.4127,
+      "suggested_scalar": 0.0951,
+      "log_bad": 4.1431,
+      "log_good": 4.4886
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 4336.8976,
+      "good": 4383.7834,
+      "ratio": 1.0108,
+      "suggested_scalar": 0.003,
+      "log_bad": 8.3749,
+      "log_good": 8.3857
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 959.0,
+      "good": 1198.0,
+      "ratio": 1.2492,
+      "suggested_scalar": 0.0613,
+      "log_bad": 6.8659,
+      "log_good": 7.0884
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 34.8413,
+      "good": 37.7303,
+      "ratio": 1.0829,
+      "suggested_scalar": 0.0219,
+      "log_bad": 3.5508,
+      "log_good": 3.6305
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2157,
+      "good": 1.1692,
+      "ratio": 0.9618,
+      "suggested_scalar": -0.0107,
+      "log_bad": 0.1953,
+      "log_good": 0.1563
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 34.0,
+      "good": 51.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1116,
+      "log_bad": 3.5264,
+      "log_good": 3.9318
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 1.0,
+      "ratio": 0.1429,
+      "suggested_scalar": -0.5357,
+      "log_bad": 1.9459,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7371,
+      "good": 0.7294,
+      "ratio": 0.9896,
+      "suggested_scalar": -0.0029,
+      "log_bad": -0.305,
+      "log_good": -0.3155
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 0.4431,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.97,
+      "good": 0.9876,
+      "ratio": 1.0181,
+      "suggested_scalar": 0.005,
+      "log_bad": -0.0305,
+      "log_good": -0.0125
+    },
+    "halstead.mean_length": {
+      "bad": 611.0,
+      "good": 657.0,
+      "ratio": 1.0753,
+      "suggested_scalar": 0.02,
+      "log_bad": 6.4151,
+      "log_good": 6.4877
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.7778,
+      "good": 9.1111,
+      "ratio": 1.1714,
+      "suggested_scalar": 0.0436,
+      "log_bad": 2.0513,
+      "log_good": 2.2095
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.1497,
+      "good": 7.375,
+      "ratio": 1.0315,
+      "suggested_scalar": 0.0085,
+      "log_bad": 1.9671,
+      "log_good": 1.9981
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1196,
+      "good": 0.1288,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0204,
+      "log_bad": -2.1236,
+      "log_good": -2.0495
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 47.7879,
+      "good": 55.3731,
+      "ratio": 1.1587,
+      "suggested_scalar": 0.0406,
+      "log_bad": 3.8668,
+      "log_good": 4.0141
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 12.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1116,
+      "log_bad": 2.0794,
+      "log_good": 2.4849
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 88.0,
+      "good": 119.0,
+      "ratio": 1.3523,
+      "suggested_scalar": 0.0831,
+      "log_bad": 4.4773,
+      "log_good": 4.7791
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6197,
+      "good": 0.5874,
+      "ratio": 0.9479,
+      "suggested_scalar": -0.0147,
+      "log_bad": -0.4785,
+      "log_good": -0.532
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 70.0,
+      "good": 90.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.0692,
+      "log_bad": 4.2485,
+      "log_good": 4.4998
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 28.0,
+      "good": 28.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3322,
+      "log_good": 3.3322
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.does_not_clone_for_comparison": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5714,
+      "good": 1.5714,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.452,
+      "log_good": 0.452
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7826,
+      "good": 0.8095,
+      "ratio": 1.0344,
+      "suggested_scalar": 0.1667,
+      "log_bad": -0.2451,
+      "log_good": -0.2113
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.687,
+      "good": 4.7149,
+      "ratio": 1.006,
+      "suggested_scalar": 0.0293,
+      "log_bad": 1.5448,
+      "log_good": 1.5507
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 89.0,
+      "good": 78.0,
+      "ratio": 0.8764,
+      "suggested_scalar": -0.6507,
+      "log_bad": 4.4886,
+      "log_good": 4.3567
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4789,
+      "good": 0.5,
+      "ratio": 1.0441,
+      "suggested_scalar": 0.2127,
+      "log_bad": -0.7363,
+      "log_good": -0.6931
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6614,
+      "good": 0.6614,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.4134,
+      "log_good": -0.4134
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.9565,
+      "good": 4.4762,
+      "ratio": 0.9031,
+      "suggested_scalar": -0.5028,
+      "log_bad": 1.6007,
+      "log_good": 1.4988
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 378.0,
+      "good": 325.0,
+      "ratio": 0.8598,
+      "suggested_scalar": -0.7452,
+      "log_bad": 5.9349,
+      "log_good": 5.7838
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1304,
+      "good": 0.0952,
+      "ratio": 0.7301,
+      "suggested_scalar": -1.5519,
+      "log_bad": -2.0371,
+      "log_good": -2.3518
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0313,
+      "good": 1.0234,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.0379,
+      "log_bad": 0.0308,
+      "log_good": 0.0231
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 126.0,
+      "good": 96.0,
+      "ratio": 0.7619,
+      "suggested_scalar": -1.3413,
+      "log_bad": 4.8363,
+      "log_good": 4.5643
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 99.4958,
+      "good": 98.235,
+      "ratio": 0.9873,
+      "suggested_scalar": -0.0629,
+      "log_bad": 4.6001,
+      "log_good": 4.5874
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6817,
+      "good": 0.6636,
+      "ratio": 0.9734,
+      "suggested_scalar": -0.1327,
+      "log_bad": -0.3832,
+      "log_good": -0.4101
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.2409,
+      "good": 10.2759,
+      "ratio": 1.112,
+      "suggested_scalar": 0.5237,
+      "log_bad": 2.2236,
+      "log_good": 2.3298
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1549.0,
+      "good": 1293.0,
+      "ratio": 0.8347,
+      "suggested_scalar": -0.891,
+      "log_bad": 7.3454,
+      "log_good": 7.1647
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7609,
+      "good": 0.7857,
+      "ratio": 1.0326,
+      "suggested_scalar": 0.1582,
+      "log_bad": -0.2733,
+      "log_good": -0.2412
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.5909,
+      "good": 8.125,
+      "ratio": 0.9458,
+      "suggested_scalar": -0.275,
+      "log_bad": 2.1507,
+      "log_good": 2.0949
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 14.7372,
+      "good": 12.3447,
+      "ratio": 0.8377,
+      "suggested_scalar": -0.8738,
+      "log_bad": 2.6904,
+      "log_good": 2.5132
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 90.0,
+      "good": 63.0,
+      "ratio": 0.7,
+      "suggested_scalar": -1.7593,
+      "log_bad": 4.4998,
+      "log_good": 4.1431
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9392,
+      "good": 0.9298,
+      "ratio": 0.99,
+      "suggested_scalar": -0.0496,
+      "log_bad": -0.0627,
+      "log_good": -0.0728
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6294,
+      "good": 0.6032,
+      "ratio": 0.9584,
+      "suggested_scalar": -0.2097,
+      "log_bad": -0.463,
+      "log_good": -0.5055
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4335,
+      "good": 0.3808,
+      "ratio": 0.8784,
+      "suggested_scalar": -0.6394,
+      "log_bad": -0.8359,
+      "log_good": -0.9655
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6986,
+      "good": 2.5205,
+      "ratio": 0.934,
+      "suggested_scalar": -0.3368,
+      "log_bad": 0.9927,
+      "log_good": 0.9245
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 376.0,
+      "good": 323.0,
+      "ratio": 0.859,
+      "suggested_scalar": -0.7494,
+      "log_bad": 5.9296,
+      "log_good": 5.7777
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 10.0,
+      "good": 8.0,
+      "ratio": 0.8,
+      "suggested_scalar": -1.1007,
+      "log_bad": 2.3026,
+      "log_good": 2.0794
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0503,
+      "good": 0.0462,
+      "ratio": 0.9185,
+      "suggested_scalar": -0.4194,
+      "log_bad": -2.9898,
+      "log_good": -3.0748
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 5.9069,
+      "ratio": 0.996,
+      "suggested_scalar": -0.0198,
+      "log_bad": 1.7801,
+      "log_good": 1.7761
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 36.0,
+      "good": 33.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.4292,
+      "log_bad": 3.5835,
+      "log_good": 3.4965
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8631,
+      "good": 0.9284,
+      "ratio": 1.0757,
+      "suggested_scalar": 0.3597,
+      "log_bad": -0.1472,
+      "log_good": -0.0743
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6076,
+      "good": 5.4841,
+      "ratio": 0.978,
+      "suggested_scalar": -0.1098,
+      "log_bad": 1.7241,
+      "log_good": 1.7019
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7903,
+      "good": 0.7982,
+      "ratio": 1.01,
+      "suggested_scalar": 0.0491,
+      "log_bad": -0.2353,
+      "log_good": -0.2254
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1786,
+      "good": 0.1923,
+      "ratio": 1.0767,
+      "suggested_scalar": 0.3646,
+      "log_bad": -1.7226,
+      "log_good": -1.6487
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.0399,
+      "good": 3.2056,
+      "ratio": 1.0545,
+      "suggested_scalar": 0.2618,
+      "log_bad": 1.1118,
+      "log_good": 1.1649
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 274.0,
+      "good": 251.0,
+      "ratio": 0.9161,
+      "suggested_scalar": -0.4325,
+      "log_bad": 5.6131,
+      "log_good": 5.5255
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.8993,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7944,
+      "good": 0.66,
+      "ratio": 0.8308,
+      "suggested_scalar": -0.9142,
+      "log_bad": -0.2302,
+      "log_good": -0.4155
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 90.0,
+      "good": 79.0,
+      "ratio": 0.8778,
+      "suggested_scalar": -0.643,
+      "log_bad": 4.4998,
+      "log_good": 4.3694
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 765.0,
+      "good": 601.0,
+      "ratio": 0.7856,
+      "suggested_scalar": -1.1901,
+      "log_bad": 6.6399,
+      "log_good": 6.3986
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 150.0,
+      "good": 120.0,
+      "ratio": 0.8,
+      "suggested_scalar": -1.1007,
+      "log_bad": 5.0106,
+      "log_good": 4.7875
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0132,
+      "good": 0.0154,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.7604,
+      "log_bad": -4.3275,
+      "log_good": -4.1734
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2751,
+      "good": 0.2923,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.2991,
+      "log_bad": -1.2906,
+      "log_good": -1.23
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 85.0,
+      "good": 76.0,
+      "ratio": 0.8941,
+      "suggested_scalar": -0.552,
+      "log_bad": 4.4427,
+      "log_good": 4.3307
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 90.0,
+      "good": 79.0,
+      "ratio": 0.8778,
+      "suggested_scalar": -0.643,
+      "log_bad": 4.4998,
+      "log_good": 4.3694
+    },
+    "brevity.mean_sample_size": {
+      "bad": 90.0,
+      "good": 79.0,
+      "ratio": 0.8778,
+      "suggested_scalar": -0.643,
+      "log_bad": 4.4998,
+      "log_good": 4.3694
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 378.0,
+      "good": 325.0,
+      "ratio": 0.8598,
+      "suggested_scalar": -0.7452,
+      "log_bad": 5.9349,
+      "log_good": 5.7838
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 203.0,
+      "good": 180.0,
+      "ratio": 0.8867,
+      "suggested_scalar": -0.5931,
+      "log_bad": 5.3132,
+      "log_good": 5.193
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 205.0,
+      "good": 185.0,
+      "ratio": 0.9024,
+      "suggested_scalar": -0.5064,
+      "log_bad": 5.323,
+      "log_good": 5.2204
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.8323,
+      "good": 1.8623,
+      "ratio": 1.0164,
+      "suggested_scalar": 0.0801,
+      "log_bad": 0.6056,
+      "log_good": 0.6218
+    },
+    "halstead.mean_effort": {
+      "bad": 62284.7815,
+      "good": 49677.5335,
+      "ratio": 0.7976,
+      "suggested_scalar": -1.1156,
+      "log_bad": 11.0395,
+      "log_good": 10.8133
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8638,
+      "good": 0.87,
+      "ratio": 1.0072,
+      "suggested_scalar": 0.0353,
+      "log_bad": -0.1464,
+      "log_good": -0.1393
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 66.0,
+      "good": 55.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.8993,
+      "log_bad": 4.1897,
+      "log_good": 4.0073
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 218.0,
+      "good": 195.0,
+      "ratio": 0.8945,
+      "suggested_scalar": -0.55,
+      "log_bad": 5.3845,
+      "log_good": 5.273
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4683,
+      "good": 0.5,
+      "ratio": 1.0677,
+      "suggested_scalar": 0.3231,
+      "log_bad": -0.7586,
+      "log_good": -0.6931
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0714,
+      "good": 6.2604,
+      "ratio": 1.0311,
+      "suggested_scalar": 0.1512,
+      "log_bad": 1.8036,
+      "log_good": 1.8342
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1786,
+      "good": 0.1923,
+      "ratio": 1.0767,
+      "suggested_scalar": 0.3646,
+      "log_bad": -1.7226,
+      "log_good": -1.6487
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.6649,
+      "good": 3.5259,
+      "ratio": 0.9621,
+      "suggested_scalar": -0.1907,
+      "log_bad": 1.2988,
+      "log_good": 1.2601
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 377.0,
+      "good": 324.0,
+      "ratio": 0.8594,
+      "suggested_scalar": -0.7473,
+      "log_bad": 5.9322,
+      "log_good": 5.7807
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 61.0,
+      "good": 51.0,
+      "ratio": 0.8361,
+      "suggested_scalar": -0.8832,
+      "log_bad": 4.1109,
+      "log_good": 3.9318
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3460.2656,
+      "good": 2759.863,
+      "ratio": 0.7976,
+      "suggested_scalar": -1.1156,
+      "log_bad": 8.1491,
+      "log_good": 7.9229
+    },
+    "readability.mean_total_lines": {
+      "bad": 44.0,
+      "good": 40.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.4701,
+      "log_bad": 3.7842,
+      "log_good": 3.6889
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2383.0699,
+      "good": 1979.9017,
+      "ratio": 0.8308,
+      "suggested_scalar": -0.9142,
+      "log_bad": 7.7761,
+      "log_good": 7.5908
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 574.0,
+      "good": 513.0,
+      "ratio": 0.8937,
+      "suggested_scalar": -0.5542,
+      "log_bad": 6.3526,
+      "log_good": 6.2403
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.3636,
+      "good": 29.3,
+      "ratio": 0.9053,
+      "suggested_scalar": -0.4905,
+      "log_bad": 3.477,
+      "log_good": 3.3776
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1657,
+      "good": 1.1862,
+      "ratio": 1.0176,
+      "suggested_scalar": 0.086,
+      "log_bad": 0.1533,
+      "log_good": 0.1708
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 25.0,
+      "good": 20.0,
+      "ratio": 0.8,
+      "suggested_scalar": -1.1007,
+      "log_bad": 3.2189,
+      "log_good": 2.9957
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 4.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.7918,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7774,
+      "good": 0.7968,
+      "ratio": 1.025,
+      "suggested_scalar": 0.1216,
+      "log_bad": -0.2518,
+      "log_good": -0.2272
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9783,
+      "good": 0.9825,
+      "ratio": 1.0043,
+      "suggested_scalar": 0.0211,
+      "log_bad": -0.0219,
+      "log_good": -0.0177
+    },
+    "halstead.mean_length": {
+      "bad": 368.0,
+      "good": 315.0,
+      "ratio": 0.856,
+      "suggested_scalar": -0.7671,
+      "log_bad": 5.9081,
+      "log_good": 5.7526
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.4286,
+      "good": 4.8571,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.5487,
+      "log_bad": 1.6917,
+      "log_good": 1.5804
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4919,
+      "good": 6.3038,
+      "ratio": 0.971,
+      "suggested_scalar": -0.145,
+      "log_bad": 1.8706,
+      "log_good": 1.8412
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1312,
+      "good": 0.1394,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.299,
+      "log_bad": -2.031,
+      "log_good": -1.9704
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 26.1364,
+      "good": 25.0909,
+      "ratio": 0.96,
+      "suggested_scalar": -0.2014,
+      "log_bad": 3.2633,
+      "log_good": 3.2225
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 59.0,
+      "good": 48.0,
+      "ratio": 0.8136,
+      "suggested_scalar": -1.0178,
+      "log_bad": 4.0775,
+      "log_good": 3.8712
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5854,
+      "good": 0.5892,
+      "ratio": 1.0065,
+      "suggested_scalar": 0.0319,
+      "log_bad": -0.5355,
+      "log_good": -0.529
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 46.0,
+      "good": 42.0,
+      "ratio": 0.913,
+      "suggested_scalar": -0.4487,
+      "log_bad": 3.8286,
+      "log_good": 3.7377
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.no_eval_or_dynamic_code_execution": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 26.0,
+      "good": 12.0,
+      "ratio": 0.4615,
+      "suggested_scalar": -0.2468,
+      "log_bad": 3.2581,
+      "log_good": 2.4849
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 13.0,
+      "good": 10.0,
+      "ratio": 0.7692,
+      "suggested_scalar": -0.0837,
+      "log_bad": 2.5649,
+      "log_good": 2.3026
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1294,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0114,
+      "good": 0.0077,
+      "ratio": 0.6754,
+      "suggested_scalar": -0.1252,
+      "log_bad": -4.4741,
+      "log_good": -4.8665
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.8333,
+      "good": 2.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0278,
+      "log_bad": 0.6061,
+      "log_good": 0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.878,
+      "good": 0.9149,
+      "ratio": 1.042,
+      "suggested_scalar": 0.0131,
+      "log_bad": -0.1301,
+      "log_good": -0.0889
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0114,
+      "good": 0.0116,
+      "ratio": 1.0175,
+      "suggested_scalar": 0.0056,
+      "log_bad": -4.4741,
+      "log_good": -4.4568
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8545,
+      "good": 5.0274,
+      "ratio": 1.0356,
+      "suggested_scalar": 0.0112,
+      "log_bad": 1.5799,
+      "log_good": 1.6149
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 92.0,
+      "good": 92.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.5218,
+      "log_good": 4.5218
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.62,
+      "good": 0.4757,
+      "ratio": 0.7673,
+      "suggested_scalar": -0.0846,
+      "log_bad": -0.478,
+      "log_good": -0.743
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 27.0,
+      "ratio": 1.6875,
+      "suggested_scalar": 0.167,
+      "log_bad": 2.7726,
+      "log_good": 3.2958
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6753,
+      "good": 0.6498,
+      "ratio": 0.9622,
+      "suggested_scalar": -0.0123,
+      "log_bad": -0.3926,
+      "log_good": -0.4311
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.3659,
+      "good": 2.8085,
+      "ratio": 2.0562,
+      "suggested_scalar": 0.2301,
+      "log_bad": 0.3118,
+      "log_good": 1.0327
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 350.0,
+      "good": 519.0,
+      "ratio": 1.4829,
+      "suggested_scalar": 0.1258,
+      "log_bad": 5.8579,
+      "log_good": 6.2519
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 8.0,
+      "ratio": 1.6,
+      "suggested_scalar": 0.15,
+      "log_bad": 1.6094,
+      "log_good": 2.0794
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0007,
+      "good": 0.0012,
+      "ratio": 1.7143,
+      "suggested_scalar": 0.172,
+      "log_bad": -7.2644,
+      "log_good": -6.7254
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1463,
+      "good": 1.0,
+      "ratio": 6.8353,
+      "suggested_scalar": 0.6135,
+      "log_bad": -1.9221,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 0.0041,
+      "ratio": 0.0041,
+      "suggested_scalar": -1.7545,
+      "log_bad": 0.0,
+      "log_good": -5.4968
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9655,
+      "good": 1.06,
+      "ratio": 1.0979,
+      "suggested_scalar": 0.0298,
+      "log_bad": -0.0351,
+      "log_good": 0.0583
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 105.0,
+      "good": 106.0,
+      "ratio": 1.0095,
+      "suggested_scalar": 0.003,
+      "log_bad": 4.654,
+      "log_good": 4.6634
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 95.6419,
+      "good": 101.8417,
+      "ratio": 1.0648,
+      "suggested_scalar": 0.02,
+      "log_bad": 4.5606,
+      "log_good": 4.6234
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4613,
+      "good": 0.6216,
+      "ratio": 1.3475,
+      "suggested_scalar": 0.0952,
+      "log_bad": -0.7737,
+      "log_good": -0.4755
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 18.7184,
+      "good": 17.5796,
+      "ratio": 0.9392,
+      "suggested_scalar": -0.02,
+      "log_bad": 2.9295,
+      "log_good": 2.8667
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1487.0,
+      "good": 1692.0,
+      "ratio": 1.1379,
+      "suggested_scalar": 0.0412,
+      "log_bad": 7.3045,
+      "log_good": 7.4337
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0244,
+      "good": 0.1702,
+      "ratio": 6.9754,
+      "suggested_scalar": 0.62,
+      "log_bad": -3.7132,
+      "log_good": -1.7708
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.878,
+      "good": 0.8511,
+      "ratio": 0.9694,
+      "suggested_scalar": -0.0099,
+      "log_bad": -0.1301,
+      "log_good": -0.1612
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.5366,
+      "good": 11.0426,
+      "ratio": 1.2936,
+      "suggested_scalar": 0.0822,
+      "log_bad": 2.1444,
+      "log_good": 2.4018
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0613,
+      "good": 4.1974,
+      "ratio": 3.955,
+      "suggested_scalar": 0.4389,
+      "log_bad": 0.0595,
+      "log_good": 1.4345
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 66.0,
+      "good": 77.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.0492,
+      "log_bad": 4.1897,
+      "log_good": 4.3438
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9456,
+      "good": 0.955,
+      "ratio": 1.0099,
+      "suggested_scalar": 0.0032,
+      "log_bad": -0.0559,
+      "log_good": -0.046
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 20.0,
+      "good": 30.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1294,
+      "log_bad": 2.9957,
+      "log_good": 3.4012
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5709,
+      "good": 0.5816,
+      "ratio": 1.0187,
+      "suggested_scalar": 0.0059,
+      "log_bad": -0.5605,
+      "log_good": -0.542
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2644,
+      "good": 0.383,
+      "ratio": 1.4486,
+      "suggested_scalar": 0.1183,
+      "log_bad": -1.3303,
+      "log_good": -0.9597
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3307,
+      "good": 2.3898,
+      "ratio": 1.0254,
+      "suggested_scalar": 0.008,
+      "log_bad": 0.8462,
+      "log_good": 0.8712
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 348.0,
+      "good": 517.0,
+      "ratio": 1.4856,
+      "suggested_scalar": 0.1263,
+      "log_bad": 5.8522,
+      "log_good": 6.248
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 16.0,
+      "good": 20.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0712,
+      "log_bad": 2.7726,
+      "log_good": 2.9957
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 0.0135,
+      "ratio": 0.0135,
+      "suggested_scalar": -1.3741,
+      "log_bad": 0.0,
+      "log_good": -4.3051
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8074,
+      "good": 6.1699,
+      "ratio": 1.0624,
+      "suggested_scalar": 0.0193,
+      "log_bad": 1.7591,
+      "log_good": 1.8197
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 13.0,
+      "good": 12.0,
+      "ratio": 0.9231,
+      "suggested_scalar": -0.0255,
+      "log_bad": 2.5649,
+      "log_good": 2.4849
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2928,
+      "good": 1.2885,
+      "ratio": 0.9967,
+      "suggested_scalar": -0.0011,
+      "log_bad": 0.2568,
+      "log_good": 0.2535
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 0.0377,
+      "ratio": 0.0377,
+      "suggested_scalar": -1.0463,
+      "log_bad": 0.0,
+      "log_good": -3.2781
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6139,
+      "good": 5.5268,
+      "ratio": 0.9845,
+      "suggested_scalar": -0.005,
+      "log_bad": 1.7252,
+      "log_good": 1.7096
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8359,
+      "good": 0.8148,
+      "ratio": 0.9748,
+      "suggested_scalar": -0.0082,
+      "log_bad": -0.1792,
+      "log_good": -0.2048
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1458,
+      "good": 0.1897,
+      "ratio": 1.3011,
+      "suggested_scalar": 0.084,
+      "log_bad": -1.9255,
+      "log_good": -1.6623
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.3265,
+      "good": 4.1928,
+      "ratio": 0.9691,
+      "suggested_scalar": -0.01,
+      "log_bad": 1.4648,
+      "log_good": 1.4334
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 292.0,
+      "good": 390.0,
+      "ratio": 1.3356,
+      "suggested_scalar": 0.0924,
+      "log_bad": 5.6768,
+      "log_good": 5.9661
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 23.0,
+      "good": 41.0,
+      "ratio": 1.7826,
+      "suggested_scalar": 0.1845,
+      "log_bad": 3.1355,
+      "log_good": 3.7136
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6806,
+      "good": 1.0329,
+      "ratio": 1.5176,
+      "suggested_scalar": 0.1331,
+      "log_bad": -0.3848,
+      "log_good": 0.0324
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 93.0,
+      "good": 91.0,
+      "ratio": 0.9785,
+      "suggested_scalar": -0.0069,
+      "log_bad": 4.5326,
+      "log_good": 4.5109
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 810.0,
+      "good": 658.0,
+      "ratio": 0.8123,
+      "suggested_scalar": -0.0663,
+      "log_bad": 6.697,
+      "log_good": 6.4892
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 123.0,
+      "good": 151.0,
+      "ratio": 1.2276,
+      "suggested_scalar": 0.0655,
+      "log_bad": 4.8122,
+      "log_good": 5.0173
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0057,
+      "good": 0.0154,
+      "ratio": 2.7018,
+      "suggested_scalar": 0.3172,
+      "log_bad": -5.1673,
+      "log_good": -4.1734
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2086,
+      "good": 0.2081,
+      "ratio": 0.9976,
+      "suggested_scalar": -0.0008,
+      "log_bad": -1.5673,
+      "log_good": -1.5697
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 51.0,
+      "good": 98.0,
+      "ratio": 1.9216,
+      "suggested_scalar": 0.2085,
+      "log_bad": 3.9318,
+      "log_good": 4.585
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 4.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1294,
+      "log_bad": 1.7918,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 93.0,
+      "good": 91.0,
+      "ratio": 0.9785,
+      "suggested_scalar": -0.0069,
+      "log_bad": 4.5326,
+      "log_good": 4.5109
+    },
+    "brevity.mean_sample_size": {
+      "bad": 93.0,
+      "good": 91.0,
+      "ratio": 0.9785,
+      "suggested_scalar": -0.0069,
+      "log_bad": 4.5326,
+      "log_good": 4.5109
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 350.0,
+      "good": 519.0,
+      "ratio": 1.4829,
+      "suggested_scalar": 0.1258,
+      "log_bad": 5.8579,
+      "log_good": 6.2519
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 199.0,
+      "good": 334.0,
+      "ratio": 1.6784,
+      "suggested_scalar": 0.1653,
+      "log_bad": 5.2933,
+      "log_good": 5.8111
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 239.0,
+      "good": 294.0,
+      "ratio": 1.2301,
+      "suggested_scalar": 0.0661,
+      "log_bad": 5.4765,
+      "log_good": 5.6836
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0019,
+      "ratio": 0.0019,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.2659
+    },
+    "heaps.mean_k": {
+      "bad": 1.8472,
+      "good": 1.6805,
+      "ratio": 0.9098,
+      "suggested_scalar": -0.0302,
+      "log_bad": 0.6137,
+      "log_good": 0.5191
+    },
+    "halstead.mean_effort": {
+      "bad": 34882.0294,
+      "good": 113202.2132,
+      "ratio": 3.2453,
+      "suggested_scalar": 0.3757,
+      "log_bad": 10.4597,
+      "log_good": 11.6369
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8585,
+      "good": 0.8493,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.0034,
+      "log_bad": -0.1526,
+      "log_good": -0.1633
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 72.0,
+      "good": 62.0,
+      "ratio": 0.8611,
+      "suggested_scalar": -0.0477,
+      "log_bad": 4.2767,
+      "log_good": 4.1271
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 190.0,
+      "good": 324.0,
+      "ratio": 1.7053,
+      "suggested_scalar": 0.1704,
+      "log_bad": 5.247,
+      "log_good": 5.7807
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5905,
+      "good": 0.4623,
+      "ratio": 0.7829,
+      "suggested_scalar": -0.0781,
+      "log_bad": -0.5268,
+      "log_good": -0.7715
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.7143,
+      "good": 6.2075,
+      "ratio": 0.8047,
+      "suggested_scalar": -0.0694,
+      "log_bad": 2.0431,
+      "log_good": 1.8258
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1458,
+      "good": 0.1897,
+      "ratio": 1.3011,
+      "suggested_scalar": 0.084,
+      "log_bad": -1.9255,
+      "log_good": -1.6623
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.004,
+      "good": 5.3313,
+      "ratio": 1.0654,
+      "suggested_scalar": 0.0202,
+      "log_bad": 1.6102,
+      "log_good": 1.6736
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 349.0,
+      "good": 518.0,
+      "ratio": 1.4842,
+      "suggested_scalar": 0.126,
+      "log_bad": 5.8551,
+      "log_good": 6.25
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 13.0,
+      "good": 10.0,
+      "ratio": 0.7692,
+      "suggested_scalar": -0.0837,
+      "log_bad": 2.5649,
+      "log_good": 2.3026
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 36.0,
+      "good": 71.0,
+      "ratio": 1.9722,
+      "suggested_scalar": 0.2168,
+      "log_bad": 3.5835,
+      "log_good": 4.2627
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1937.8905,
+      "good": 6289.0118,
+      "ratio": 3.2453,
+      "suggested_scalar": 0.3757,
+      "log_bad": 7.5694,
+      "log_good": 8.7466
+    },
+    "readability.mean_total_lines": {
+      "bad": 41.0,
+      "good": 47.0,
+      "ratio": 1.1463,
+      "suggested_scalar": 0.0436,
+      "log_bad": 3.7136,
+      "log_good": 3.8501
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 8.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2212,
+      "log_bad": 1.3863,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2041.8749,
+      "good": 3098.6919,
+      "ratio": 1.5176,
+      "suggested_scalar": 0.1331,
+      "log_bad": 7.6216,
+      "log_good": 8.0387
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 638.0,
+      "good": 708.0,
+      "ratio": 1.1097,
+      "suggested_scalar": 0.0332,
+      "log_bad": 6.4583,
+      "log_good": 6.5624
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.0976,
+      "good": 34.766,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.003,
+      "log_bad": 3.5581,
+      "log_good": 3.5486
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2119,
+      "good": 1.1086,
+      "ratio": 0.9148,
+      "suggested_scalar": -0.0284,
+      "log_bad": 0.1922,
+      "log_good": 0.1031
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 8.0,
+      "ratio": 1.6,
+      "suggested_scalar": 0.15,
+      "log_bad": 1.6094,
+      "log_good": 2.0794
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 13.0,
+      "good": 16.0,
+      "ratio": 1.2308,
+      "suggested_scalar": 0.0663,
+      "log_bad": 2.5649,
+      "log_good": 2.7726
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 1.0,
+      "ratio": 0.1667,
+      "suggested_scalar": -0.5719,
+      "log_bad": 1.7918,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8767,
+      "good": 0.8179,
+      "ratio": 0.9329,
+      "suggested_scalar": -0.0222,
+      "log_bad": -0.1316,
+      "log_good": -0.201
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9934,
+      "good": 0.9817,
+      "ratio": 0.9882,
+      "suggested_scalar": -0.0038,
+      "log_bad": -0.0066,
+      "log_good": -0.0185
+    },
+    "halstead.mean_length": {
+      "bad": 313.0,
+      "good": 475.0,
+      "ratio": 1.5176,
+      "suggested_scalar": 0.1331,
+      "log_bad": 5.7462,
+      "log_good": 6.1633
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 8.0,
+      "good": 12.75,
+      "ratio": 1.5938,
+      "suggested_scalar": 0.1488,
+      "log_bad": 2.0794,
+      "log_good": 2.5455
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5392,
+      "good": 6.5078,
+      "ratio": 0.9952,
+      "suggested_scalar": -0.0015,
+      "log_bad": 1.8778,
+      "log_good": 1.873
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1338,
+      "good": 0.1974,
+      "ratio": 1.4753,
+      "suggested_scalar": 0.1241,
+      "log_bad": -2.0114,
+      "log_good": -1.6225
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 17.0833,
+      "good": 36.5323,
+      "ratio": 2.1385,
+      "suggested_scalar": 0.2426,
+      "log_bad": 2.8381,
+      "log_good": 3.5982
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 8.0,
+      "ratio": 8.0,
+      "suggested_scalar": 0.6637,
+      "log_bad": 0.0,
+      "log_good": 2.0794
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 62.0,
+      "good": 49.0,
+      "ratio": 0.7903,
+      "suggested_scalar": -0.0751,
+      "log_bad": 4.1271,
+      "log_good": 3.8918
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7866,
+      "good": 0.6667,
+      "ratio": 0.8476,
+      "suggested_scalar": -0.0528,
+      "log_bad": -0.24,
+      "log_good": -0.4054
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 41.0,
+      "good": 47.0,
+      "ratio": 1.1463,
+      "suggested_scalar": 0.0436,
+      "log_bad": 3.7136,
+      "log_good": 3.8501
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 0.4425,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    }
+  },
+  "naming_conventions.constructor_named_new_or_with": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0081,
+      "good": 0.0065,
+      "ratio": 0.8025,
+      "suggested_scalar": -0.635,
+      "log_bad": -4.8159,
+      "log_good": -5.036
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.8,
+      "good": 2.25,
+      "ratio": 1.25,
+      "suggested_scalar": 0.6439,
+      "log_bad": 0.5878,
+      "log_good": 0.8109
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.6923,
+      "good": 0.7442,
+      "ratio": 1.075,
+      "suggested_scalar": 0.2086,
+      "log_bad": -0.3677,
+      "log_good": -0.2954
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0081,
+      "good": 0.0065,
+      "ratio": 0.8025,
+      "suggested_scalar": -0.635,
+      "log_bad": -4.8159,
+      "log_good": -5.036
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4696,
+      "good": 4.5328,
+      "ratio": 1.0141,
+      "suggested_scalar": 0.0405,
+      "log_bad": 1.4973,
+      "log_good": 1.5113
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 89.0,
+      "good": 85.0,
+      "ratio": 0.9551,
+      "suggested_scalar": -0.1327,
+      "log_bad": 4.4886,
+      "log_good": 4.4427
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4683,
+      "good": 0.5204,
+      "ratio": 1.1113,
+      "suggested_scalar": 0.3044,
+      "log_bad": -0.7586,
+      "log_good": -0.6532
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6391,
+      "good": 0.666,
+      "ratio": 1.0421,
+      "suggested_scalar": 0.119,
+      "log_bad": -0.4477,
+      "log_good": -0.4065
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.9231,
+      "good": 6.5116,
+      "ratio": 0.9406,
+      "suggested_scalar": -0.1768,
+      "log_bad": 1.9349,
+      "log_good": 1.8736
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 370.0,
+      "good": 306.0,
+      "ratio": 0.827,
+      "suggested_scalar": -0.548,
+      "log_bad": 5.9135,
+      "log_good": 5.7236
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0006,
+      "good": 0.0007,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.4448,
+      "log_bad": -7.4186,
+      "log_good": -7.2644
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0962,
+      "good": 0.1163,
+      "ratio": 1.2089,
+      "suggested_scalar": 0.5475,
+      "log_bad": -2.3413,
+      "log_good": -2.1516
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0225,
+      "good": 0.9602,
+      "ratio": 0.9391,
+      "suggested_scalar": -0.1814,
+      "log_bad": 0.0223,
+      "log_good": -0.0406
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 117.0,
+      "good": 98.0,
+      "ratio": 0.8376,
+      "suggested_scalar": -0.5113,
+      "log_bad": 4.7622,
+      "log_good": 4.585
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 94.6296,
+      "good": 99.24,
+      "ratio": 1.0487,
+      "suggested_scalar": 0.1373,
+      "log_bad": 4.55,
+      "log_good": 4.5975
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6016,
+      "good": 0.5508,
+      "ratio": 0.9156,
+      "suggested_scalar": -0.2546,
+      "log_bad": -0.5082,
+      "log_good": -0.5964
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.8521,
+      "good": 7.4415,
+      "ratio": 0.8406,
+      "suggested_scalar": -0.5009,
+      "log_bad": 2.1807,
+      "log_good": 2.0071
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1678.0,
+      "good": 1402.0,
+      "ratio": 0.8355,
+      "suggested_scalar": -0.5185,
+      "log_bad": 7.4254,
+      "log_good": 7.2457
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0577,
+      "good": 0.093,
+      "ratio": 1.6118,
+      "suggested_scalar": 1.3773,
+      "log_bad": -2.8525,
+      "log_good": -2.3752
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6538,
+      "good": 0.6977,
+      "ratio": 1.0671,
+      "suggested_scalar": 0.1875,
+      "log_bad": -0.425,
+      "log_good": -0.36
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.2549,
+      "good": 7.2857,
+      "ratio": 1.0042,
+      "suggested_scalar": 0.0122,
+      "log_bad": 1.9817,
+      "log_good": 1.9859
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.5261,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 17.3018,
+      "good": 17.1336,
+      "ratio": 0.9903,
+      "suggested_scalar": -0.0282,
+      "log_bad": 2.8508,
+      "log_good": 2.841
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 81.0,
+      "good": 62.0,
+      "ratio": 0.7654,
+      "suggested_scalar": -0.7713,
+      "log_bad": 4.3944,
+      "log_good": 4.1271
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9522,
+      "good": 0.9449,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.0222,
+      "log_bad": -0.049,
+      "log_good": -0.0567
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 26.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.2138,
+      "log_bad": 3.3322,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6663,
+      "good": 0.6113,
+      "ratio": 0.9175,
+      "suggested_scalar": -0.2486,
+      "log_bad": -0.406,
+      "log_good": -0.4922
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4402,
+      "good": 0.3783,
+      "ratio": 0.8594,
+      "suggested_scalar": -0.4373,
+      "log_bad": -0.8205,
+      "log_good": -0.9721
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9964,
+      "good": 2.5725,
+      "ratio": 0.8585,
+      "suggested_scalar": -0.4401,
+      "log_bad": 1.0974,
+      "log_good": 0.9449
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 368.0,
+      "good": 304.0,
+      "ratio": 0.8261,
+      "suggested_scalar": -0.5513,
+      "log_bad": 5.9081,
+      "log_good": 5.717
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0973,
+      "good": 0.0817,
+      "ratio": 0.8397,
+      "suggested_scalar": -0.5042,
+      "log_bad": -2.33,
+      "log_good": -2.5047
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 6.0224,
+      "ratio": 1.0115,
+      "suggested_scalar": 0.0329,
+      "log_bad": 1.7841,
+      "log_good": 1.7955
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 30.0,
+      "good": 29.0,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0978,
+      "log_bad": 3.4012,
+      "log_good": 3.3673
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1238,
+      "good": 1.2519,
+      "ratio": 1.114,
+      "suggested_scalar": 0.3115,
+      "log_bad": 0.1167,
+      "log_good": 0.2247
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5275,
+      "good": 5.6016,
+      "ratio": 1.0134,
+      "suggested_scalar": 0.0384,
+      "log_bad": 1.7097,
+      "log_good": 1.7231
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7507,
+      "good": 0.7527,
+      "ratio": 1.0027,
+      "suggested_scalar": 0.0077,
+      "log_bad": -0.2867,
+      "log_good": -0.2841
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1034,
+      "good": 0.1042,
+      "ratio": 1.0077,
+      "suggested_scalar": 0.0222,
+      "log_bad": -2.2692,
+      "log_good": -2.2614
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.9752,
+      "good": 2.7279,
+      "ratio": 0.9169,
+      "suggested_scalar": -0.2504,
+      "log_bad": 1.0903,
+      "log_good": 1.0035
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 267.0,
+      "good": 240.0,
+      "ratio": 0.8989,
+      "suggested_scalar": -0.3076,
+      "log_bad": 5.5872,
+      "log_good": 5.4806
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 8.0,
+      "good": 5.0,
+      "ratio": 0.625,
+      "suggested_scalar": -1.3561,
+      "log_bad": 2.0794,
+      "log_good": 1.6094
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7339,
+      "good": 0.6132,
+      "ratio": 0.8355,
+      "suggested_scalar": -0.5185,
+      "log_bad": -0.3094,
+      "log_good": -0.4891
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 93.0,
+      "good": 89.0,
+      "ratio": 0.957,
+      "suggested_scalar": -0.1269,
+      "log_bad": 4.5326,
+      "log_good": 4.4886
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 774.0,
+      "good": 648.0,
+      "ratio": 0.8372,
+      "suggested_scalar": -0.5127,
+      "log_bad": 6.6516,
+      "log_good": 6.4739
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 135.0,
+      "good": 112.0,
+      "ratio": 0.8296,
+      "suggested_scalar": -0.5389,
+      "log_bad": 4.9053,
+      "log_good": 4.7185
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0135,
+      "good": 0.0131,
+      "ratio": 0.9704,
+      "suggested_scalar": -0.0868,
+      "log_bad": -4.3051,
+      "log_good": -4.3351
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2838,
+      "good": 0.281,
+      "ratio": 0.9901,
+      "suggested_scalar": -0.0286,
+      "log_bad": -1.2595,
+      "log_good": -1.2694
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 69.0,
+      "good": 59.0,
+      "ratio": 0.8551,
+      "suggested_scalar": -0.4518,
+      "log_bad": 4.2341,
+      "log_good": 4.0775
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.6439,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 93.0,
+      "good": 89.0,
+      "ratio": 0.957,
+      "suggested_scalar": -0.1269,
+      "log_bad": 4.5326,
+      "log_good": 4.4886
+    },
+    "brevity.mean_sample_size": {
+      "bad": 93.0,
+      "good": 89.0,
+      "ratio": 0.957,
+      "suggested_scalar": -0.1269,
+      "log_bad": 4.5326,
+      "log_good": 4.4886
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 370.0,
+      "good": 306.0,
+      "ratio": 0.827,
+      "suggested_scalar": -0.548,
+      "log_bad": 5.9135,
+      "log_good": 5.7236
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 204.0,
+      "good": 164.0,
+      "ratio": 0.8039,
+      "suggested_scalar": -0.6297,
+      "log_bad": 5.3181,
+      "log_good": 5.0999
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 216.0,
+      "good": 196.0,
+      "ratio": 0.9074,
+      "suggested_scalar": -0.2804,
+      "log_bad": 5.3753,
+      "log_good": 5.2781
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0054,
+      "good": 0.0033,
+      "ratio": 0.6111,
+      "suggested_scalar": -1.421,
+      "log_bad": -5.2214,
+      "log_good": -5.7138
+    },
+    "heaps.mean_k": {
+      "bad": 2.2127,
+      "good": 2.0381,
+      "ratio": 0.9211,
+      "suggested_scalar": -0.2372,
+      "log_bad": 0.7942,
+      "log_good": 0.712
+    },
+    "halstead.mean_effort": {
+      "bad": 68218.1361,
+      "good": 45395.0002,
+      "ratio": 0.6654,
+      "suggested_scalar": -1.1752,
+      "log_bad": 11.1305,
+      "log_good": 10.7232
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8453,
+      "good": 0.865,
+      "ratio": 1.0233,
+      "suggested_scalar": 0.0665,
+      "log_bad": -0.1681,
+      "log_good": -0.145
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 61.0,
+      "good": 59.0,
+      "ratio": 0.9672,
+      "suggested_scalar": -0.0962,
+      "log_bad": 4.1109,
+      "log_good": 4.0775
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 205.0,
+      "good": 175.0,
+      "ratio": 0.8537,
+      "suggested_scalar": -0.4565,
+      "log_bad": 5.323,
+      "log_good": 5.1648
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.453,
+      "good": 0.5204,
+      "ratio": 1.1488,
+      "suggested_scalar": 0.4002,
+      "log_bad": -0.7919,
+      "log_good": -0.6532
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.6154,
+      "good": 6.6122,
+      "ratio": 0.9995,
+      "suggested_scalar": -0.0014,
+      "log_bad": 1.8894,
+      "log_good": 1.8889
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1034,
+      "good": 0.1042,
+      "ratio": 1.0077,
+      "suggested_scalar": 0.0222,
+      "log_bad": -2.2692,
+      "log_good": -2.2614
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.3928,
+      "good": 2.9143,
+      "ratio": 0.859,
+      "suggested_scalar": -0.4387,
+      "log_bad": 1.2217,
+      "log_good": 1.0696
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 369.0,
+      "good": 305.0,
+      "ratio": 0.8266,
+      "suggested_scalar": -0.5496,
+      "log_bad": 5.9108,
+      "log_good": 5.7203
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 61.0,
+      "good": 51.0,
+      "ratio": 0.8361,
+      "suggested_scalar": -0.5166,
+      "log_bad": 4.1109,
+      "log_good": 3.9318
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3789.8965,
+      "good": 2521.9445,
+      "ratio": 0.6654,
+      "suggested_scalar": -1.1752,
+      "log_bad": 8.2401,
+      "log_good": 7.8328
+    },
+    "readability.mean_total_lines": {
+      "bad": 51.0,
+      "good": 42.0,
+      "ratio": 0.8235,
+      "suggested_scalar": -0.5602,
+      "log_bad": 3.9318,
+      "log_good": 3.7377
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2201.7494,
+      "good": 1839.4952,
+      "ratio": 0.8355,
+      "suggested_scalar": -0.5187,
+      "log_bad": 7.697,
+      "log_good": 7.5172
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 560.0,
+      "good": 545.0,
+      "ratio": 0.9732,
+      "suggested_scalar": -0.0783,
+      "log_bad": 6.3279,
+      "log_good": 6.3008
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.3137,
+      "good": 31.5952,
+      "ratio": 1.009,
+      "suggested_scalar": 0.0258,
+      "log_bad": 3.4441,
+      "log_good": 3.453
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2393,
+      "good": 1.1844,
+      "ratio": 0.9557,
+      "suggested_scalar": -0.1307,
+      "log_bad": 0.2145,
+      "log_good": 0.1692
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 7.0,
+      "good": 9.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.7251,
+      "log_bad": 1.9459,
+      "log_good": 2.1972
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7715,
+      "good": 0.7875,
+      "ratio": 1.0207,
+      "suggested_scalar": 0.0592,
+      "log_bad": -0.2594,
+      "log_good": -0.2389
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9545,
+      "good": 0.9667,
+      "ratio": 1.0128,
+      "suggested_scalar": 0.0366,
+      "log_bad": -0.0466,
+      "log_good": -0.0339
+    },
+    "halstead.mean_length": {
+      "bad": 340.0,
+      "good": 287.0,
+      "ratio": 0.8441,
+      "suggested_scalar": -0.489,
+      "log_bad": 5.8289,
+      "log_good": 5.6595
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.0,
+      "good": 8.75,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.0813,
+      "log_bad": 2.1972,
+      "log_good": 2.1691
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5392,
+      "good": 6.4757,
+      "ratio": 0.9903,
+      "suggested_scalar": -0.0282,
+      "log_bad": 1.8778,
+      "log_good": 1.8681
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1216,
+      "good": 0.1173,
+      "ratio": 0.9646,
+      "suggested_scalar": -0.1039,
+      "log_bad": -2.107,
+      "log_good": -2.143
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.9836,
+      "good": 24.678,
+      "ratio": 0.7965,
+      "suggested_scalar": -0.6566,
+      "log_bad": 3.4335,
+      "log_good": 3.2059
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.8301,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 53.0,
+      "good": 51.0,
+      "ratio": 0.9623,
+      "suggested_scalar": -0.111,
+      "log_bad": 3.9703,
+      "log_good": 3.9318
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6806,
+      "good": 0.699,
+      "ratio": 1.027,
+      "suggested_scalar": 0.077,
+      "log_bad": -0.3848,
+      "log_good": -0.3581
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 52.0,
+      "good": 43.0,
+      "ratio": 0.8269,
+      "suggested_scalar": -0.5483,
+      "log_bad": 3.9512,
+      "log_good": 3.7612
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 13.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.2138,
+      "log_bad": 2.6391,
+      "log_good": 2.5649
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.does_not_discard_errors": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0609,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0417,
+      "good": 0.0418,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.0008,
+      "log_bad": -3.1773,
+      "log_good": -3.1749
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 1.5,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.4055,
+      "log_good": 0.4055
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.875,
+      "good": 0.82,
+      "ratio": 0.9371,
+      "suggested_scalar": -0.0217,
+      "log_bad": -0.1335,
+      "log_good": -0.1985
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0417,
+      "good": 0.0418,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.0008,
+      "log_bad": -3.1773,
+      "log_good": -3.1749
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.9384,
+      "good": 4.9679,
+      "ratio": 1.006,
+      "suggested_scalar": 0.002,
+      "log_bad": 1.597,
+      "log_good": 1.603
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 77.0,
+      "good": 95.0,
+      "ratio": 1.2338,
+      "suggested_scalar": 0.0701,
+      "log_bad": 4.3438,
+      "log_good": 4.5539
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4576,
+      "good": 0.4566,
+      "ratio": 0.9978,
+      "suggested_scalar": -0.0007,
+      "log_bad": -0.7818,
+      "log_good": -0.7839
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 14.0,
+      "good": 17.0,
+      "ratio": 1.2143,
+      "suggested_scalar": 0.0648,
+      "log_bad": 2.6391,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6672,
+      "good": 0.6511,
+      "ratio": 0.9759,
+      "suggested_scalar": -0.0082,
+      "log_bad": -0.4047,
+      "log_good": -0.4291
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.625,
+      "good": 0.88,
+      "ratio": 1.408,
+      "suggested_scalar": 0.1142,
+      "log_bad": -0.47,
+      "log_good": -0.1278
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 288.0,
+      "good": 431.0,
+      "ratio": 1.4965,
+      "suggested_scalar": 0.1346,
+      "log_bad": 5.663,
+      "log_good": 6.0661
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1353,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 0.0025,
+      "ratio": 0.0025,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.9915
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1,
+      "good": 0.02,
+      "ratio": 0.2,
+      "suggested_scalar": -0.5372,
+      "log_bad": -2.3026,
+      "log_good": -3.912
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9433,
+      "good": 1.0044,
+      "ratio": 1.0648,
+      "suggested_scalar": 0.021,
+      "log_bad": -0.0584,
+      "log_good": 0.0044
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 116.0,
+      "good": 175.0,
+      "ratio": 1.5086,
+      "suggested_scalar": 0.1373,
+      "log_bad": 4.7536,
+      "log_good": 5.1648
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 95.6732,
+      "good": 96.1628,
+      "ratio": 1.0051,
+      "suggested_scalar": 0.0017,
+      "log_bad": 4.5609,
+      "log_good": 4.566
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4564,
+      "good": 0.5953,
+      "ratio": 1.3043,
+      "suggested_scalar": 0.0887,
+      "log_bad": -0.7844,
+      "log_good": -0.5187
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.3962,
+      "good": 12.7492,
+      "ratio": 1.1187,
+      "suggested_scalar": 0.0374,
+      "log_bad": 2.4333,
+      "log_good": 2.5455
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1202.0,
+      "good": 1624.0,
+      "ratio": 1.3511,
+      "suggested_scalar": 0.1004,
+      "log_bad": 7.0917,
+      "log_good": 7.3926
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 0.12,
+      "ratio": 0.12,
+      "suggested_scalar": -0.7078,
+      "log_bad": 0.0,
+      "log_good": -2.1203
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.875,
+      "good": 0.8,
+      "ratio": 0.9143,
+      "suggested_scalar": -0.0299,
+      "log_bad": -0.1335,
+      "log_good": -0.2231
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.2,
+      "good": 8.62,
+      "ratio": 1.1972,
+      "suggested_scalar": 0.0601,
+      "log_bad": 1.9741,
+      "log_good": 2.1541
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 5.0,
+      "good": 1.0,
+      "ratio": 0.2,
+      "suggested_scalar": -0.5372,
+      "log_bad": 1.6094,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.2344,
+      "good": 0.4656,
+      "ratio": 1.9863,
+      "suggested_scalar": 0.2291,
+      "log_bad": -1.4507,
+      "log_good": -0.7644
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 62.0,
+      "good": 118.0,
+      "ratio": 1.9032,
+      "suggested_scalar": 0.2148,
+      "log_bad": 4.1271,
+      "log_good": 4.7707
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9222,
+      "good": 0.9438,
+      "ratio": 1.0234,
+      "suggested_scalar": 0.0077,
+      "log_bad": -0.081,
+      "log_good": -0.0578
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 19.0,
+      "good": 23.0,
+      "ratio": 1.2105,
+      "suggested_scalar": 0.0638,
+      "log_bad": 2.9444,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5657,
+      "good": 0.5905,
+      "ratio": 1.0438,
+      "suggested_scalar": 0.0143,
+      "log_bad": -0.5697,
+      "log_good": -0.5268
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2063,
+      "good": 0.3916,
+      "ratio": 1.8982,
+      "suggested_scalar": 0.2139,
+      "log_bad": -1.5784,
+      "log_good": -0.9375
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3027,
+      "good": 2.4421,
+      "ratio": 1.0605,
+      "suggested_scalar": 0.0196,
+      "log_bad": 0.8341,
+      "log_good": 0.8929
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 286.0,
+      "good": 429.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1353,
+      "log_bad": 5.656,
+      "log_good": 6.0615
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 16.0,
+      "good": 26.0,
+      "ratio": 1.625,
+      "suggested_scalar": 0.1621,
+      "log_bad": 2.7726,
+      "log_good": 3.2581
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0347,
+      "good": 0.0325,
+      "ratio": 0.9366,
+      "suggested_scalar": -0.0219,
+      "log_bad": -3.361,
+      "log_good": -3.4265
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8826,
+      "good": 5.9773,
+      "ratio": 1.0161,
+      "suggested_scalar": 0.0053,
+      "log_bad": 1.772,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 44.0,
+      "good": 50.0,
+      "ratio": 1.1364,
+      "suggested_scalar": 0.0427,
+      "log_bad": 3.7842,
+      "log_good": 3.912
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4046,
+      "good": 1.1092,
+      "ratio": 0.7897,
+      "suggested_scalar": -0.0788,
+      "log_bad": 0.3398,
+      "log_good": 0.1036
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6057,
+      "good": 5.8186,
+      "ratio": 1.038,
+      "suggested_scalar": 0.0124,
+      "log_bad": 1.7238,
+      "log_good": 1.7611
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8395,
+      "good": 0.8311,
+      "ratio": 0.99,
+      "suggested_scalar": -0.0034,
+      "log_bad": -0.1749,
+      "log_good": -0.185
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2,
+      "good": 0.1667,
+      "ratio": 0.8335,
+      "suggested_scalar": -0.0608,
+      "log_bad": -1.6094,
+      "log_good": -1.7916
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.3758,
+      "good": 3.5706,
+      "ratio": 1.0577,
+      "suggested_scalar": 0.0187,
+      "log_bad": 1.2166,
+      "log_good": 1.2727
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 248.0,
+      "good": 320.0,
+      "ratio": 1.2903,
+      "suggested_scalar": 0.0851,
+      "log_bad": 5.5134,
+      "log_good": 5.7683
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 3.0,
+      "good": 6.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2314,
+      "log_bad": 1.0986,
+      "log_good": 1.7918
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5139,
+      "good": 0.7533,
+      "ratio": 1.4658,
+      "suggested_scalar": 0.1277,
+      "log_bad": -0.6657,
+      "log_good": -0.2833
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 78.0,
+      "good": 105.0,
+      "ratio": 1.3462,
+      "suggested_scalar": 0.0992,
+      "log_bad": 4.3567,
+      "log_good": 4.654
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 743.0,
+      "good": 991.0,
+      "ratio": 1.3338,
+      "suggested_scalar": 0.0961,
+      "log_bad": 6.6107,
+      "log_good": 6.8987
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 128.0,
+      "good": 165.0,
+      "ratio": 1.2891,
+      "suggested_scalar": 0.0848,
+      "log_bad": 4.852,
+      "log_good": 5.1059
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2569,
+      "good": 0.2715,
+      "ratio": 1.0568,
+      "suggested_scalar": 0.0185,
+      "log_bad": -1.3591,
+      "log_good": -1.3038
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 48.0,
+      "good": 81.0,
+      "ratio": 1.6875,
+      "suggested_scalar": 0.1747,
+      "log_bad": 3.8712,
+      "log_good": 4.3944
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 78.0,
+      "good": 105.0,
+      "ratio": 1.3462,
+      "suggested_scalar": 0.0992,
+      "log_bad": 4.3567,
+      "log_good": 4.654
+    },
+    "brevity.mean_sample_size": {
+      "bad": 78.0,
+      "good": 105.0,
+      "ratio": 1.3462,
+      "suggested_scalar": 0.0992,
+      "log_bad": 4.3567,
+      "log_good": 4.654
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 288.0,
+      "good": 431.0,
+      "ratio": 1.4965,
+      "suggested_scalar": 0.1346,
+      "log_bad": 5.663,
+      "log_good": 6.0661
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 143.0,
+      "good": 221.0,
+      "ratio": 1.5455,
+      "suggested_scalar": 0.1453,
+      "log_bad": 4.9628,
+      "log_good": 5.3982
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 204.0,
+      "good": 255.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0745,
+      "log_bad": 5.3181,
+      "log_good": 5.5413
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.9281,
+      "good": 2.1276,
+      "ratio": 1.1035,
+      "suggested_scalar": 0.0329,
+      "log_bad": 0.6565,
+      "log_good": 0.755
+    },
+    "halstead.mean_effort": {
+      "bad": 32321.0596,
+      "good": 59561.216,
+      "ratio": 1.8428,
+      "suggested_scalar": 0.2041,
+      "log_bad": 10.3835,
+      "log_good": 10.9948
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8919,
+      "good": 0.8666,
+      "ratio": 0.9716,
+      "suggested_scalar": -0.0096,
+      "log_bad": -0.1144,
+      "log_good": -0.1432
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 58.0,
+      "good": 72.0,
+      "ratio": 1.2414,
+      "suggested_scalar": 0.0722,
+      "log_bad": 4.0604,
+      "log_good": 4.2767
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 118.0,
+      "good": 179.0,
+      "ratio": 1.5169,
+      "suggested_scalar": 0.1391,
+      "log_bad": 4.7707,
+      "log_good": 5.1874
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4483,
+      "good": 0.4171,
+      "ratio": 0.9304,
+      "suggested_scalar": -0.0241,
+      "log_bad": -0.8023,
+      "log_good": -0.8744
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.4052,
+      "good": 5.6629,
+      "ratio": 0.8841,
+      "suggested_scalar": -0.0411,
+      "log_bad": 1.8571,
+      "log_good": 1.7339
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2,
+      "good": 0.1667,
+      "ratio": 0.8335,
+      "suggested_scalar": -0.0608,
+      "log_bad": -1.6094,
+      "log_good": -1.7916
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.1559,
+      "good": 4.0194,
+      "ratio": 1.2736,
+      "suggested_scalar": 0.0807,
+      "log_bad": 1.1493,
+      "log_good": 1.3911
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 287.0,
+      "good": 430.0,
+      "ratio": 1.4983,
+      "suggested_scalar": 0.135,
+      "log_bad": 5.6595,
+      "log_good": 6.0638
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 21.0,
+      "good": 59.0,
+      "ratio": 2.8095,
+      "suggested_scalar": 0.3448,
+      "log_bad": 3.0445,
+      "log_good": 4.0775
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1795.6144,
+      "good": 3308.9564,
+      "ratio": 1.8428,
+      "suggested_scalar": 0.2041,
+      "log_bad": 7.4931,
+      "log_good": 8.1044
+    },
+    "readability.mean_total_lines": {
+      "bad": 40.0,
+      "good": 50.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0745,
+      "log_bad": 3.6889,
+      "log_good": 3.912
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2314,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "halstead.mean_volume": {
+      "bad": 1541.6295,
+      "good": 2260.0303,
+      "ratio": 1.466,
+      "suggested_scalar": 0.1277,
+      "log_bad": 7.3406,
+      "log_good": 7.7231
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 522.0,
+      "good": 665.0,
+      "ratio": 1.2739,
+      "suggested_scalar": 0.0808,
+      "log_bad": 6.2577,
+      "log_good": 6.4998
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 28.8,
+      "good": 31.28,
+      "ratio": 1.0861,
+      "suggested_scalar": 0.0276,
+      "log_bad": 3.3604,
+      "log_good": 3.443
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2276,
+      "good": 1.2048,
+      "ratio": 0.9814,
+      "suggested_scalar": -0.0063,
+      "log_bad": 0.2051,
+      "log_good": 0.1863
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1353,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 16.0,
+      "good": 30.0,
+      "ratio": 1.875,
+      "suggested_scalar": 0.2098,
+      "log_bad": 2.7726,
+      "log_good": 3.4012
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 1.0,
+      "ratio": 0.25,
+      "suggested_scalar": -0.4628,
+      "log_bad": 1.3863,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9153,
+      "good": 0.8156,
+      "ratio": 0.8911,
+      "suggested_scalar": -0.0385,
+      "log_bad": -0.0885,
+      "log_good": -0.2038
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9898,
+      "good": 0.9919,
+      "ratio": 1.0021,
+      "suggested_scalar": 0.0007,
+      "log_bad": -0.0103,
+      "log_good": -0.0081
+    },
+    "halstead.mean_length": {
+      "bad": 246.0,
+      "good": 344.0,
+      "ratio": 1.3984,
+      "suggested_scalar": 0.1119,
+      "log_bad": 5.5053,
+      "log_good": 5.8406
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.0,
+      "good": 15.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1353,
+      "log_bad": 2.3026,
+      "log_good": 2.7081
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2854,
+      "good": 6.7142,
+      "ratio": 1.0682,
+      "suggested_scalar": 0.022,
+      "log_bad": 1.8382,
+      "log_good": 1.9042
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.119,
+      "good": 0.1361,
+      "ratio": 1.1437,
+      "suggested_scalar": 0.0448,
+      "log_bad": -2.1286,
+      "log_good": -1.9944
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 20.9655,
+      "good": 26.3542,
+      "ratio": 1.257,
+      "suggested_scalar": 0.0764,
+      "log_bad": 3.0429,
+      "log_good": 3.2716
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 6.0,
+      "ratio": 6.0,
+      "suggested_scalar": 0.5981,
+      "log_bad": 0.0,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 52.0,
+      "good": 73.0,
+      "ratio": 1.4038,
+      "suggested_scalar": 0.1132,
+      "log_bad": 3.9512,
+      "log_good": 4.2905
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7647,
+      "good": 0.6824,
+      "ratio": 0.8924,
+      "suggested_scalar": -0.038,
+      "log_bad": -0.2683,
+      "log_good": -0.3821
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 40.0,
+      "good": 50.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0745,
+      "log_bad": 3.6889,
+      "log_good": 3.912
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 25.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.1705,
+      "log_bad": 2.7081,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.try_block_is_minimal": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 34.0,
+      "good": 32.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0155,
+      "log_bad": 3.5264,
+      "log_good": 3.4657
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0456,
+      "good": 0.0551,
+      "ratio": 1.2083,
+      "suggested_scalar": 0.0484,
+      "log_bad": -3.0878,
+      "log_good": -2.8986
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 1.5,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.4055,
+      "log_good": 0.4055
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8929,
+      "good": 0.9138,
+      "ratio": 1.0234,
+      "suggested_scalar": 0.0059,
+      "log_bad": -0.1133,
+      "log_good": -0.0901
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0456,
+      "good": 0.0551,
+      "ratio": 1.2083,
+      "suggested_scalar": 0.0484,
+      "log_bad": -3.0878,
+      "log_good": -2.8986
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6065,
+      "good": 4.6472,
+      "ratio": 1.0088,
+      "suggested_scalar": 0.0022,
+      "log_bad": 1.5275,
+      "log_good": 1.5363
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 111.0,
+      "good": 101.0,
+      "ratio": 0.9099,
+      "suggested_scalar": -0.0241,
+      "log_bad": 4.7095,
+      "log_good": 4.6151
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5994,
+      "good": 0.5893,
+      "ratio": 0.9831,
+      "suggested_scalar": -0.0043,
+      "log_bad": -0.5118,
+      "log_good": -0.5288
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 20.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0131,
+      "log_bad": 2.9444,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7551,
+      "good": 0.7348,
+      "ratio": 0.9731,
+      "suggested_scalar": -0.007,
+      "log_bad": -0.2809,
+      "log_good": -0.3082
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.9286,
+      "good": 3.931,
+      "ratio": 0.7976,
+      "suggested_scalar": -0.0578,
+      "log_bad": 1.5951,
+      "log_good": 1.3689
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 439.0,
+      "good": 472.0,
+      "ratio": 1.0752,
+      "suggested_scalar": 0.0185,
+      "log_bad": 6.0845,
+      "log_good": 6.157
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 0.0004,
+      "ratio": 0.0004,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -7.824
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0714,
+      "good": 0.0345,
+      "ratio": 0.4832,
+      "suggested_scalar": -0.1859,
+      "log_bad": -2.6395,
+      "log_good": -3.3668
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8781,
+      "good": 0.9096,
+      "ratio": 1.0359,
+      "suggested_scalar": 0.009,
+      "log_bad": -0.13,
+      "log_good": -0.0948
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 194.0,
+      "good": 211.0,
+      "ratio": 1.0876,
+      "suggested_scalar": 0.0215,
+      "log_bad": 5.2679,
+      "log_good": 5.3519
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 99.7319,
+      "good": 100.6168,
+      "ratio": 1.0089,
+      "suggested_scalar": 0.0023,
+      "log_bad": 4.6025,
+      "log_good": 4.6113
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4543,
+      "good": 0.5053,
+      "ratio": 1.1123,
+      "suggested_scalar": 0.0272,
+      "log_bad": -0.789,
+      "log_good": -0.6826
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 16.0606,
+      "good": 14.0199,
+      "ratio": 0.8729,
+      "suggested_scalar": -0.0347,
+      "log_bad": 2.7764,
+      "log_good": 2.6405
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2284.0,
+      "good": 2356.0,
+      "ratio": 1.0315,
+      "suggested_scalar": 0.0079,
+      "log_bad": 7.7337,
+      "log_good": 7.7647
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2679,
+      "good": 0.3103,
+      "ratio": 1.1583,
+      "suggested_scalar": 0.0376,
+      "log_bad": -1.3171,
+      "log_good": -1.1702
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8929,
+      "good": 0.9138,
+      "ratio": 1.0234,
+      "suggested_scalar": 0.0059,
+      "log_bad": -0.1133,
+      "log_good": -0.0901
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.4423,
+      "good": 8.4286,
+      "ratio": 0.9984,
+      "suggested_scalar": -0.0004,
+      "log_bad": 2.1333,
+      "log_good": 2.1316
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 9.0,
+      "good": 8.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0301,
+      "log_bad": 2.1972,
+      "log_good": 2.0794
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 14.2806,
+      "good": 8.547,
+      "ratio": 0.5985,
+      "suggested_scalar": -0.1312,
+      "log_bad": 2.6589,
+      "log_good": 2.1456
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 154.0,
+      "good": 166.0,
+      "ratio": 1.0779,
+      "suggested_scalar": 0.0192,
+      "log_bad": 5.037,
+      "log_good": 5.112
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.1772,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.945,
+      "good": 0.9463,
+      "ratio": 1.0014,
+      "suggested_scalar": 0.0004,
+      "log_bad": -0.0566,
+      "log_good": -0.0552
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 34.0,
+      "ratio": 1.1333,
+      "suggested_scalar": 0.032,
+      "log_bad": 3.4012,
+      "log_good": 3.5264
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.613,
+      "good": 0.6154,
+      "ratio": 1.0039,
+      "suggested_scalar": 0.001,
+      "log_bad": -0.4894,
+      "log_good": -0.4855
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2883,
+      "good": 0.2851,
+      "ratio": 0.9889,
+      "suggested_scalar": -0.0029,
+      "log_bad": -1.2438,
+      "log_good": -1.2549
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5837,
+      "good": 2.6004,
+      "ratio": 1.0065,
+      "suggested_scalar": 0.0016,
+      "log_bad": 0.9492,
+      "log_good": 0.9557
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 437.0,
+      "good": 470.0,
+      "ratio": 1.0755,
+      "suggested_scalar": 0.0186,
+      "log_bad": 6.0799,
+      "log_good": 6.1527
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 22.0,
+      "good": 24.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0222,
+      "log_bad": 3.091,
+      "log_good": 3.1781
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0592,
+      "good": 0.0551,
+      "ratio": 0.9307,
+      "suggested_scalar": -0.0183,
+      "log_bad": -2.8268,
+      "log_good": -2.8986
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0661,
+      "good": 6.0661,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8027,
+      "log_good": 1.8027
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 31.0,
+      "good": 37.0,
+      "ratio": 1.1935,
+      "suggested_scalar": 0.0452,
+      "log_bad": 3.434,
+      "log_good": 3.6109
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8927,
+      "good": 0.8917,
+      "ratio": 0.9989,
+      "suggested_scalar": -0.0003,
+      "log_bad": -0.1135,
+      "log_good": -0.1146
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.2559,
+      "good": 6.1955,
+      "ratio": 0.9903,
+      "suggested_scalar": -0.0025,
+      "log_bad": 1.8335,
+      "log_good": 1.8238
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7594,
+      "good": 0.7661,
+      "ratio": 1.0088,
+      "suggested_scalar": 0.0022,
+      "log_bad": -0.2752,
+      "log_good": -0.2664
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.2808,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2329,
+      "good": 0.2564,
+      "ratio": 1.1009,
+      "suggested_scalar": 0.0246,
+      "log_bad": -1.4571,
+      "log_good": -1.361
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.0076,
+      "good": 3.7443,
+      "ratio": 0.9343,
+      "suggested_scalar": -0.0174,
+      "log_bad": 1.3882,
+      "log_good": 1.3202
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1772,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 360.0,
+      "good": 386.0,
+      "ratio": 1.0722,
+      "suggested_scalar": 0.0178,
+      "log_bad": 5.8861,
+      "log_good": 5.9558
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7655,
+      "good": 0.7391,
+      "ratio": 0.9655,
+      "suggested_scalar": -0.009,
+      "log_bad": -0.2672,
+      "log_good": -0.3023
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 137.0,
+      "good": 142.0,
+      "ratio": 1.0365,
+      "suggested_scalar": 0.0092,
+      "log_bad": 4.92,
+      "log_good": 4.9558
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1318.0,
+      "good": 1414.0,
+      "ratio": 1.0728,
+      "suggested_scalar": 0.018,
+      "log_bad": 7.1839,
+      "log_good": 7.2542
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 159.0,
+      "good": 144.0,
+      "ratio": 0.9057,
+      "suggested_scalar": -0.0253,
+      "log_bad": 5.0689,
+      "log_good": 4.9698
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0091,
+      "good": 0.0085,
+      "ratio": 0.9341,
+      "suggested_scalar": -0.0174,
+      "log_bad": -4.6995,
+      "log_good": -4.7677
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2278,
+      "good": 0.2246,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0036,
+      "log_bad": -1.4793,
+      "log_good": -1.4934
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 67.0,
+      "good": 78.0,
+      "ratio": 1.1642,
+      "suggested_scalar": 0.0389,
+      "log_bad": 4.2047,
+      "log_good": 4.3567
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 137.0,
+      "good": 142.0,
+      "ratio": 1.0365,
+      "suggested_scalar": 0.0092,
+      "log_bad": 4.92,
+      "log_good": 4.9558
+    },
+    "brevity.mean_sample_size": {
+      "bad": 137.0,
+      "good": 142.0,
+      "ratio": 1.0365,
+      "suggested_scalar": 0.0092,
+      "log_bad": 4.92,
+      "log_good": 4.9558
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 439.0,
+      "good": 472.0,
+      "ratio": 1.0752,
+      "suggested_scalar": 0.0185,
+      "log_bad": 6.0845,
+      "log_good": 6.157
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 182.0,
+      "good": 198.0,
+      "ratio": 1.0879,
+      "suggested_scalar": 0.0215,
+      "log_bad": 5.204,
+      "log_good": 5.2883
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 306.0,
+      "good": 311.0,
+      "ratio": 1.0163,
+      "suggested_scalar": 0.0041,
+      "log_bad": 5.7236,
+      "log_good": 5.7398
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0023,
+      "good": 0.0021,
+      "ratio": 0.913,
+      "suggested_scalar": -0.0233,
+      "log_bad": -6.0748,
+      "log_good": -6.1658
+    },
+    "heaps.mean_k": {
+      "bad": 1.5394,
+      "good": 1.7026,
+      "ratio": 1.106,
+      "suggested_scalar": 0.0258,
+      "log_bad": 0.4314,
+      "log_good": 0.5322
+    },
+    "halstead.mean_effort": {
+      "bad": 67619.5366,
+      "good": 81009.9622,
+      "ratio": 1.198,
+      "suggested_scalar": 0.0462,
+      "log_bad": 11.1217,
+      "log_good": 11.3023
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.1772,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8814,
+      "good": 0.8665,
+      "ratio": 0.9831,
+      "suggested_scalar": -0.0044,
+      "log_bad": -0.1262,
+      "log_good": -0.1433
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 81.0,
+      "good": 67.0,
+      "ratio": 0.8272,
+      "suggested_scalar": -0.0485,
+      "log_bad": 4.3944,
+      "log_good": 4.2047
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 179.0,
+      "good": 189.0,
+      "ratio": 1.0559,
+      "suggested_scalar": 0.0139,
+      "log_bad": 5.1874,
+      "log_good": 5.2417
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4742,
+      "good": 0.4597,
+      "ratio": 0.9694,
+      "suggested_scalar": -0.0079,
+      "log_bad": -0.7461,
+      "log_good": -0.7772
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.7938,
+      "good": 6.7014,
+      "ratio": 0.9864,
+      "suggested_scalar": -0.0035,
+      "log_bad": 1.916,
+      "log_good": 1.9023
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2329,
+      "good": 0.2564,
+      "ratio": 1.1009,
+      "suggested_scalar": 0.0246,
+      "log_bad": -1.4571,
+      "log_good": -1.361
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.3181,
+      "good": 4.1067,
+      "ratio": 0.951,
+      "suggested_scalar": -0.0128,
+      "log_bad": 1.4628,
+      "log_good": 1.4126
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1772,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 438.0,
+      "good": 471.0,
+      "ratio": 1.0753,
+      "suggested_scalar": 0.0186,
+      "log_bad": 6.0822,
+      "log_good": 6.1549
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 49.0,
+      "good": 50.0,
+      "ratio": 1.0204,
+      "suggested_scalar": 0.0052,
+      "log_bad": 3.8918,
+      "log_good": 3.912
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3756.6409,
+      "good": 4500.5535,
+      "ratio": 1.198,
+      "suggested_scalar": 0.0462,
+      "log_bad": 8.2313,
+      "log_good": 8.412
+    },
+    "readability.mean_total_lines": {
+      "bad": 52.0,
+      "good": 56.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0189,
+      "log_bad": 3.9512,
+      "log_good": 4.0254
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2296.5126,
+      "good": 2217.1844,
+      "ratio": 0.9655,
+      "suggested_scalar": -0.009,
+      "log_bad": 7.7391,
+      "log_good": 7.704
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 884.0,
+      "good": 906.0,
+      "ratio": 1.0249,
+      "suggested_scalar": 0.0063,
+      "log_bad": 6.7845,
+      "log_good": 6.809
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.8269,
+      "good": 38.5893,
+      "ratio": 1.0771,
+      "suggested_scalar": 0.019,
+      "log_bad": 3.5787,
+      "log_good": 3.653
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1647,
+      "good": 1.1544,
+      "ratio": 0.9912,
+      "suggested_scalar": -0.0023,
+      "log_bad": 0.1525,
+      "log_good": 0.1436
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 14.0,
+      "good": 16.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.0341,
+      "log_bad": 2.6391,
+      "log_good": 2.7726
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 2.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.1772,
+      "log_bad": 1.3863,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8639,
+      "good": 0.8705,
+      "ratio": 1.0076,
+      "suggested_scalar": 0.0019,
+      "log_bad": -0.1463,
+      "log_good": -0.1387
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 9.0,
+      "good": 13.0,
+      "ratio": 1.4444,
+      "suggested_scalar": 0.094,
+      "log_bad": 2.1972,
+      "log_good": 2.5649
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.991,
+      "good": 0.9913,
+      "ratio": 1.0003,
+      "suggested_scalar": 0.0001,
+      "log_bad": -0.009,
+      "log_good": -0.0087
+    },
+    "halstead.mean_length": {
+      "bad": 338.0,
+      "good": 333.0,
+      "ratio": 0.9852,
+      "suggested_scalar": -0.0038,
+      "log_bad": 5.823,
+      "log_good": 5.8081
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.0,
+      "good": 12.25,
+      "ratio": 1.1136,
+      "suggested_scalar": 0.0275,
+      "log_bad": 2.3979,
+      "log_good": 2.5055
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.098,
+      "good": 7.1497,
+      "ratio": 1.0073,
+      "suggested_scalar": 0.0019,
+      "log_bad": 1.9598,
+      "log_good": 1.9671
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0799,
+      "good": 0.0841,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0131,
+      "log_bad": -2.527,
+      "log_good": -2.4757
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.4444,
+      "good": 36.5373,
+      "ratio": 1.2409,
+      "suggested_scalar": 0.0552,
+      "log_bad": 3.3825,
+      "log_good": 3.5983
+    },
+    "branching.mean_branch_count": {
+      "bad": 15.0,
+      "good": 18.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0466,
+      "log_bad": 2.7081,
+      "log_good": 2.8904
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 92.0,
+      "good": 97.0,
+      "ratio": 1.0543,
+      "suggested_scalar": 0.0135,
+      "log_bad": 4.5218,
+      "log_good": 4.5747
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.781,
+      "good": 0.7492,
+      "ratio": 0.9593,
+      "suggested_scalar": -0.0106,
+      "log_bad": -0.2472,
+      "log_good": -0.2887
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 56.0,
+      "good": 58.0,
+      "ratio": 1.0357,
+      "suggested_scalar": 0.009,
+      "log_bad": 4.0254,
+      "log_good": 4.0604
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.uses_snake_case_for_functions": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 57.0,
+      "good": 1.0,
+      "ratio": 0.0175,
+      "suggested_scalar": -2.0,
+      "log_bad": 4.0431,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 44.0,
+      "good": 46.0,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.022,
+      "log_bad": 3.7842,
+      "log_good": 3.8286
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0187,
+      "good": 0.0597,
+      "ratio": 3.1925,
+      "suggested_scalar": 0.5742,
+      "log_bad": -3.9792,
+      "log_good": -2.8184
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.25,
+      "good": 1.25,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2231,
+      "log_good": 0.2231
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9811,
+      "good": 0.9836,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0013,
+      "log_bad": -0.0191,
+      "log_good": -0.0165
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0187,
+      "good": 0.0597,
+      "ratio": 3.1925,
+      "suggested_scalar": 0.5742,
+      "log_bad": -3.9792,
+      "log_good": -2.8184
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7241,
+      "good": 4.6866,
+      "ratio": 0.9921,
+      "suggested_scalar": -0.0039,
+      "log_bad": 1.5527,
+      "log_good": 1.5447
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 102.0,
+      "good": 98.0,
+      "ratio": 0.9608,
+      "suggested_scalar": -0.0198,
+      "log_bad": 4.625,
+      "log_good": 4.585
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4206,
+      "good": 0.4897,
+      "ratio": 1.1643,
+      "suggested_scalar": 0.0752,
+      "log_bad": -0.8661,
+      "log_good": -0.714
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 18.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0521,
+      "log_bad": 2.9957,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6405,
+      "good": 0.6509,
+      "ratio": 1.0162,
+      "suggested_scalar": 0.008,
+      "log_bad": -0.4455,
+      "log_good": -0.4294
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.9434,
+      "good": 3.082,
+      "ratio": 1.0471,
+      "suggested_scalar": 0.0228,
+      "log_bad": 1.0796,
+      "log_good": 1.1256
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 480.0,
+      "good": 553.0,
+      "ratio": 1.1521,
+      "suggested_scalar": 0.07,
+      "log_bad": 6.1738,
+      "log_good": 6.3154
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0129,
+      "good": 1.0042,
+      "ratio": 0.9914,
+      "suggested_scalar": -0.0043,
+      "log_bad": 0.0128,
+      "log_good": 0.0042
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 198.0,
+      "good": 218.0,
+      "ratio": 1.101,
+      "suggested_scalar": 0.0476,
+      "log_bad": 5.2883,
+      "log_good": 5.3845
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 88.2979,
+      "good": 95.396,
+      "ratio": 1.0804,
+      "suggested_scalar": 0.0382,
+      "log_bad": 4.4807,
+      "log_good": 4.558
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5157,
+      "good": 0.5163,
+      "ratio": 1.0012,
+      "suggested_scalar": 0.0006,
+      "log_bad": -0.6622,
+      "log_good": -0.6611
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.6448,
+      "good": 12.5729,
+      "ratio": 1.0797,
+      "suggested_scalar": 0.0379,
+      "log_bad": 2.4549,
+      "log_good": 2.5315
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2454.0,
+      "good": 2525.0,
+      "ratio": 1.0289,
+      "suggested_scalar": 0.0141,
+      "log_bad": 7.8055,
+      "log_good": 7.834
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1132,
+      "good": 0.1475,
+      "ratio": 1.303,
+      "suggested_scalar": 0.1309,
+      "log_bad": -2.1786,
+      "log_good": -1.9139
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9811,
+      "good": 0.9836,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0013,
+      "log_bad": -0.0191,
+      "log_good": -0.0165
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.0566,
+      "good": 9.0656,
+      "ratio": 1.001,
+      "suggested_scalar": 0.0005,
+      "log_bad": 2.2035,
+      "log_good": 2.2045
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 0.7962,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 6.7326,
+      "good": 5.9769,
+      "ratio": 0.8878,
+      "suggested_scalar": -0.0589,
+      "log_bad": 1.907,
+      "log_good": 1.7879
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 111.0,
+      "good": 175.0,
+      "ratio": 1.5766,
+      "suggested_scalar": 0.2252,
+      "log_bad": 4.7095,
+      "log_good": 5.1648
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 0.7962,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9368,
+      "good": 0.9633,
+      "ratio": 1.0283,
+      "suggested_scalar": 0.0138,
+      "log_bad": -0.0653,
+      "log_good": -0.0374
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 32.0,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.0319,
+      "log_bad": 3.4012,
+      "log_good": 3.4657
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6573,
+      "good": 0.6448,
+      "ratio": 0.981,
+      "suggested_scalar": -0.0095,
+      "log_bad": -0.4196,
+      "log_good": -0.4388
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.318,
+      "good": 0.3339,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0241,
+      "log_bad": -1.1457,
+      "log_good": -1.0969
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.918,
+      "good": 2.8149,
+      "ratio": 0.9647,
+      "suggested_scalar": -0.0178,
+      "log_bad": 1.0709,
+      "log_good": 1.0349
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 478.0,
+      "good": 551.0,
+      "ratio": 1.1527,
+      "suggested_scalar": 0.0703,
+      "log_bad": 6.1696,
+      "log_good": 6.3117
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 15.0,
+      "good": 16.0,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.0319,
+      "log_bad": 2.7081,
+      "log_good": 2.7726
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.075,
+      "good": 0.0651,
+      "ratio": 0.868,
+      "suggested_scalar": -0.07,
+      "log_bad": -2.5903,
+      "log_good": -2.7318
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.1085,
+      "good": 6.0444,
+      "ratio": 0.9895,
+      "suggested_scalar": -0.0052,
+      "log_bad": 1.8097,
+      "log_good": 1.7991
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 28.0,
+      "good": 41.0,
+      "ratio": 1.4643,
+      "suggested_scalar": 0.1887,
+      "log_bad": 3.3322,
+      "log_good": 3.7136
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4513,
+      "good": 0.7699,
+      "ratio": 0.5305,
+      "suggested_scalar": -0.3136,
+      "log_bad": 0.3725,
+      "log_good": -0.2615
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9517,
+      "good": 5.9057,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.0038,
+      "log_bad": 1.7837,
+      "log_good": 1.7759
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7734,
+      "good": 0.7754,
+      "ratio": 1.0026,
+      "suggested_scalar": 0.0013,
+      "log_bad": -0.257,
+      "log_good": -0.2544
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.5435,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2838,
+      "good": 0.2561,
+      "ratio": 0.9024,
+      "suggested_scalar": -0.0508,
+      "log_bad": -1.2595,
+      "log_good": -1.3622
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.4125,
+      "good": 3.5458,
+      "ratio": 1.0391,
+      "suggested_scalar": 0.019,
+      "log_bad": 1.2274,
+      "log_good": 1.2658
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 377.0,
+      "good": 425.0,
+      "ratio": 1.1273,
+      "suggested_scalar": 0.0593,
+      "log_bad": 5.9322,
+      "log_good": 6.0521
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.1104,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.923,
+      "good": 0.9371,
+      "ratio": 1.0153,
+      "suggested_scalar": 0.0075,
+      "log_bad": -0.0801,
+      "log_good": -0.065
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 115.0,
+      "good": 134.0,
+      "ratio": 1.1652,
+      "suggested_scalar": 0.0756,
+      "log_bad": 4.7449,
+      "log_good": 4.8978
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1466.0,
+      "good": 1521.0,
+      "ratio": 1.0375,
+      "suggested_scalar": 0.0182,
+      "log_bad": 7.2903,
+      "log_good": 7.3271
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 200.0,
+      "good": 186.0,
+      "ratio": 0.93,
+      "suggested_scalar": -0.0359,
+      "log_bad": 5.2983,
+      "log_good": 5.2257
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 0.7962,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0167,
+      "good": 0.0145,
+      "ratio": 0.8683,
+      "suggested_scalar": -0.0699,
+      "log_bad": -4.0923,
+      "log_good": -4.2336
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2687,
+      "good": 0.2568,
+      "ratio": 0.9557,
+      "suggested_scalar": -0.0224,
+      "log_bad": -1.3142,
+      "log_good": -1.3595
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 74.0,
+      "good": 80.0,
+      "ratio": 1.0811,
+      "suggested_scalar": 0.0386,
+      "log_bad": 4.3041,
+      "log_good": 4.382
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 115.0,
+      "good": 134.0,
+      "ratio": 1.1652,
+      "suggested_scalar": 0.0756,
+      "log_bad": 4.7449,
+      "log_good": 4.8978
+    },
+    "brevity.mean_sample_size": {
+      "bad": 115.0,
+      "good": 134.0,
+      "ratio": 1.1652,
+      "suggested_scalar": 0.0756,
+      "log_bad": 4.7449,
+      "log_good": 4.8978
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 480.0,
+      "good": 553.0,
+      "ratio": 1.1521,
+      "suggested_scalar": 0.07,
+      "log_bad": 6.1738,
+      "log_good": 6.3154
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 221.0,
+      "good": 264.0,
+      "ratio": 1.1946,
+      "suggested_scalar": 0.0879,
+      "log_bad": 5.3982,
+      "log_good": 5.5759
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 306.0,
+      "good": 347.0,
+      "ratio": 1.134,
+      "suggested_scalar": 0.0622,
+      "log_bad": 5.7236,
+      "log_good": 5.8493
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0063,
+      "good": 0.0054,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0763,
+      "log_bad": -5.0672,
+      "log_good": -5.2214
+    },
+    "heaps.mean_k": {
+      "bad": 2.4085,
+      "good": 2.278,
+      "ratio": 0.9458,
+      "suggested_scalar": -0.0276,
+      "log_bad": 0.879,
+      "log_good": 0.8233
+    },
+    "halstead.mean_effort": {
+      "bad": 115377.3549,
+      "good": 126761.8941,
+      "ratio": 1.0987,
+      "suggested_scalar": 0.0466,
+      "log_bad": 11.656,
+      "log_good": 11.7501
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 0.7962,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8694,
+      "good": 0.8358,
+      "ratio": 0.9614,
+      "suggested_scalar": -0.0195,
+      "log_bad": -0.14,
+      "log_good": -0.1794
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 72.0,
+      "good": 66.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.043,
+      "log_bad": 4.2767,
+      "log_good": 4.1897
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 215.0,
+      "good": 239.0,
+      "ratio": 1.1116,
+      "suggested_scalar": 0.0523,
+      "log_bad": 5.3706,
+      "log_good": 5.4765
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3535,
+      "good": 0.4083,
+      "ratio": 1.155,
+      "suggested_scalar": 0.0713,
+      "log_bad": -1.0399,
+      "log_good": -0.8958
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.404,
+      "good": 6.9771,
+      "ratio": 0.9423,
+      "suggested_scalar": -0.0294,
+      "log_bad": 2.002,
+      "log_good": 1.9426
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2838,
+      "good": 0.2561,
+      "ratio": 0.9024,
+      "suggested_scalar": -0.0508,
+      "log_bad": -1.2595,
+      "log_good": -1.3622
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.4132,
+      "good": 4.4743,
+      "ratio": 1.0138,
+      "suggested_scalar": 0.0068,
+      "log_bad": 1.4846,
+      "log_good": 1.4983
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 0.7962,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 479.0,
+      "good": 552.0,
+      "ratio": 1.1524,
+      "suggested_scalar": 0.0702,
+      "log_bad": 6.1717,
+      "log_good": 6.3135
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 51.0,
+      "good": 58.0,
+      "ratio": 1.1373,
+      "suggested_scalar": 0.0636,
+      "log_bad": 3.9318,
+      "log_good": 4.0604
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6409.853,
+      "good": 7042.3275,
+      "ratio": 1.0987,
+      "suggested_scalar": 0.0466,
+      "log_bad": 8.7656,
+      "log_good": 8.8597
+    },
+    "readability.mean_total_lines": {
+      "bad": 53.0,
+      "good": 61.0,
+      "ratio": 1.1509,
+      "suggested_scalar": 0.0695,
+      "log_bad": 3.9703,
+      "log_good": 4.1109
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2769.0565,
+      "good": 2811.2517,
+      "ratio": 1.0152,
+      "suggested_scalar": 0.0075,
+      "log_bad": 7.9263,
+      "log_good": 7.9414
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 841.0,
+      "good": 897.0,
+      "ratio": 1.0666,
+      "suggested_scalar": 0.0319,
+      "log_bad": 6.7346,
+      "log_good": 6.7991
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 44.566,
+      "good": 40.0492,
+      "ratio": 0.8986,
+      "suggested_scalar": -0.0529,
+      "log_bad": 3.797,
+      "log_good": 3.6901
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2925,
+      "good": 1.2085,
+      "ratio": 0.935,
+      "suggested_scalar": -0.0332,
+      "log_bad": 0.2566,
+      "log_good": 0.1894
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 18.0,
+      "good": 26.0,
+      "ratio": 1.4444,
+      "suggested_scalar": 0.1819,
+      "log_bad": 2.8904,
+      "log_good": 3.2581
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8647,
+      "good": 0.8635,
+      "ratio": 0.9986,
+      "suggested_scalar": -0.0007,
+      "log_bad": -0.1454,
+      "log_good": -0.1468
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 3.0,
+      "good": 19.0,
+      "ratio": 6.3333,
+      "suggested_scalar": 0.9131,
+      "log_bad": 1.0986,
+      "log_good": 2.9444
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.972,
+      "good": 0.9875,
+      "ratio": 1.0159,
+      "suggested_scalar": 0.0078,
+      "log_bad": -0.0284,
+      "log_good": -0.0126
+    },
+    "halstead.mean_length": {
+      "bad": 415.0,
+      "good": 425.0,
+      "ratio": 1.0241,
+      "suggested_scalar": 0.0118,
+      "log_bad": 6.0283,
+      "log_good": 6.0521
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.75,
+      "good": 6.75,
+      "ratio": 1.1739,
+      "suggested_scalar": 0.0793,
+      "log_bad": 1.7492,
+      "log_good": 1.9095
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8455,
+      "good": 7.0661,
+      "ratio": 1.0322,
+      "suggested_scalar": 0.0157,
+      "log_bad": 1.9236,
+      "log_good": 1.9553
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.5435,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0907,
+      "good": 0.1046,
+      "ratio": 1.1533,
+      "suggested_scalar": 0.0705,
+      "log_bad": -2.4002,
+      "log_good": -2.2576
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 41.6667,
+      "good": 45.0909,
+      "ratio": 1.0822,
+      "suggested_scalar": 0.0391,
+      "log_bad": 3.7297,
+      "log_good": 3.8087
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 9.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.2006,
+      "log_bad": 1.7918,
+      "log_good": 2.1972
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 70.0,
+      "good": 89.0,
+      "ratio": 1.2714,
+      "suggested_scalar": 0.1188,
+      "log_bad": 4.2485,
+      "log_good": 4.4886
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7582,
+      "good": 0.7695,
+      "ratio": 1.0149,
+      "suggested_scalar": 0.0073,
+      "log_bad": -0.2768,
+      "log_good": -0.262
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 53.0,
+      "good": 61.0,
+      "ratio": 1.1509,
+      "suggested_scalar": 0.0695,
+      "log_bad": 3.9703,
+      "log_good": 4.1109
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.boolean_function_has_question_mark": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3,
+      "good": 1.3,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2624,
+      "log_good": 0.2624
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7188,
+      "good": 0.7188,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3302,
+      "log_good": -0.3302
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4552,
+      "good": 4.4982,
+      "ratio": 1.0097,
+      "suggested_scalar": 0.0045,
+      "log_bad": 1.4941,
+      "log_good": 1.5037
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 54.0,
+      "good": 54.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.989,
+      "log_good": 3.989
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5833,
+      "good": 0.5833,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.5391,
+      "log_good": -0.5391
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 11.0,
+      "good": 12.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0404,
+      "log_bad": 2.3979,
+      "log_good": 2.4849
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6302,
+      "good": 0.6163,
+      "ratio": 0.9779,
+      "suggested_scalar": -0.0104,
+      "log_bad": -0.4617,
+      "log_good": -0.484
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.5,
+      "good": 2.5,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9163,
+      "log_good": 0.9163
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 182.0,
+      "good": 192.0,
+      "ratio": 1.0549,
+      "suggested_scalar": 0.0248,
+      "log_bad": 5.204,
+      "log_good": 5.2575
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0014,
+      "good": 0.0013,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.0344,
+      "log_bad": -6.5713,
+      "log_good": -6.6454
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 0.0135,
+      "ratio": 0.0135,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -4.3051
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9486,
+      "good": 0.9634,
+      "ratio": 1.0156,
+      "suggested_scalar": 0.0072,
+      "log_bad": -0.0528,
+      "log_good": -0.0373
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 60.0,
+      "good": 60.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0943,
+      "log_good": 4.0943
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 108.0859,
+      "good": 107.7688,
+      "ratio": 0.9971,
+      "suggested_scalar": -0.0014,
+      "log_bad": 4.6829,
+      "log_good": 4.68
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4751,
+      "good": 0.5026,
+      "ratio": 1.0579,
+      "suggested_scalar": 0.0261,
+      "log_bad": -0.7442,
+      "log_good": -0.688
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.2122,
+      "good": 7.2122,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9758,
+      "log_good": 1.9758
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 733.0,
+      "good": 743.0,
+      "ratio": 1.0136,
+      "suggested_scalar": 0.0063,
+      "log_bad": 6.5971,
+      "log_good": 6.6107
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0625,
+      "good": 0.0625,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.7726,
+      "log_good": -2.7726
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6875,
+      "good": 0.6875,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3747,
+      "log_good": -0.3747
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.6875,
+      "good": 6.0,
+      "ratio": 1.0549,
+      "suggested_scalar": 0.0248,
+      "log_bad": 1.7383,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.25,
+      "good": 1.25,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2231,
+      "log_good": 0.2231
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 56.0,
+      "good": 56.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0254,
+      "log_good": 4.0254
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9178,
+      "good": 0.9132,
+      "ratio": 0.995,
+      "suggested_scalar": -0.0023,
+      "log_bad": -0.0858,
+      "log_good": -0.0908
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5566,
+      "good": 0.5545,
+      "ratio": 0.9962,
+      "suggested_scalar": -0.0018,
+      "log_bad": -0.5859,
+      "log_good": -0.5897
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2278,
+      "good": 0.2368,
+      "ratio": 1.0395,
+      "suggested_scalar": 0.018,
+      "log_bad": -1.4793,
+      "log_good": -1.4405
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2554,
+      "good": 2.2447,
+      "ratio": 0.9953,
+      "suggested_scalar": -0.0022,
+      "log_bad": 0.8133,
+      "log_good": 0.8086
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 180.0,
+      "good": 190.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.0251,
+      "log_bad": 5.193,
+      "log_good": 5.247
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.4263,
+      "good": 5.4594,
+      "ratio": 1.0061,
+      "suggested_scalar": 0.0028,
+      "log_bad": 1.6913,
+      "log_good": 1.6973
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.3534,
+      "good": 0.3534,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.0402,
+      "log_good": -1.0402
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 4.9728,
+      "good": 5.009,
+      "ratio": 1.0073,
+      "suggested_scalar": 0.0034,
+      "log_bad": 1.604,
+      "log_good": 1.6112
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.821,
+      "good": 0.8239,
+      "ratio": 1.0035,
+      "suggested_scalar": 0.0016,
+      "log_bad": -0.1972,
+      "log_good": -0.1937
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2195,
+      "good": 0.2195,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.5164,
+      "log_good": -1.5164
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.6856,
+      "good": 2.6856,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9879,
+      "log_good": 0.9879
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 154.0,
+      "good": 161.0,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.0207,
+      "log_bad": 5.037,
+      "log_good": 5.0814
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.3338,
+      "good": 0.3338,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.0972,
+      "log_good": -1.0972
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 54.0,
+      "good": 55.0,
+      "ratio": 1.0185,
+      "suggested_scalar": 0.0085,
+      "log_bad": 3.989,
+      "log_good": 4.0073
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 346.0,
+      "good": 346.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.8464,
+      "log_good": 5.8464
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 68.0,
+      "good": 68.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2195,
+      "log_good": 4.2195
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2582,
+      "good": 0.2448,
+      "ratio": 0.9481,
+      "suggested_scalar": -0.0248,
+      "log_bad": -1.354,
+      "log_good": -1.4073
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 24.0,
+      "good": 25.0,
+      "ratio": 1.0417,
+      "suggested_scalar": 0.019,
+      "log_bad": 3.1781,
+      "log_good": 3.2189
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 54.0,
+      "good": 55.0,
+      "ratio": 1.0185,
+      "suggested_scalar": 0.0085,
+      "log_bad": 3.989,
+      "log_good": 4.0073
+    },
+    "brevity.mean_sample_size": {
+      "bad": 54.0,
+      "good": 55.0,
+      "ratio": 1.0185,
+      "suggested_scalar": 0.0085,
+      "log_bad": 3.989,
+      "log_good": 4.0073
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 182.0,
+      "good": 192.0,
+      "ratio": 1.0549,
+      "suggested_scalar": 0.0248,
+      "log_bad": 5.204,
+      "log_good": 5.2575
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 79.0,
+      "good": 89.0,
+      "ratio": 1.1266,
+      "suggested_scalar": 0.0554,
+      "log_bad": 4.3694,
+      "log_good": 4.4886
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 119.0,
+      "good": 120.0,
+      "ratio": 1.0084,
+      "suggested_scalar": 0.0039,
+      "log_bad": 4.7791,
+      "log_good": 4.7875
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.0587,
+      "good": 2.1818,
+      "ratio": 1.0598,
+      "suggested_scalar": 0.027,
+      "log_bad": 0.7221,
+      "log_good": 0.7802
+    },
+    "halstead.mean_effort": {
+      "bad": 14335.1219,
+      "good": 14335.1219,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 9.5705,
+      "log_good": 9.5705
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8641,
+      "good": 0.8664,
+      "ratio": 1.0027,
+      "suggested_scalar": 0.0012,
+      "log_bad": -0.1461,
+      "log_good": -0.1434
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 38.0,
+      "good": 38.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6376,
+      "log_good": 3.6376
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 106.0,
+      "good": 106.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.6634,
+      "log_good": 4.6634
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5833,
+      "good": 0.5833,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.5391,
+      "log_good": -0.5391
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.7667,
+      "good": 5.7667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7521,
+      "log_good": 1.7521
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2195,
+      "good": 0.2195,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.5164,
+      "log_good": -1.5164
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.275,
+      "good": 2.4,
+      "ratio": 1.0549,
+      "suggested_scalar": 0.0248,
+      "log_bad": 0.822,
+      "log_good": 0.8755
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 181.0,
+      "good": 191.0,
+      "ratio": 1.0552,
+      "suggested_scalar": 0.025,
+      "log_bad": 5.1985,
+      "log_good": 5.2523
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 10.0,
+      "ratio": 10.0,
+      "suggested_scalar": 1.0697,
+      "log_bad": 0.0,
+      "log_good": 2.3026
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 15.0,
+      "good": 16.0,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.03,
+      "log_bad": 2.7081,
+      "log_good": 2.7726
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 796.3957,
+      "good": 796.3957,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.6801,
+      "log_good": 6.6801
+    },
+    "readability.mean_total_lines": {
+      "bad": 32.0,
+      "good": 32.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4657,
+      "log_good": 3.4657
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1001.3504,
+      "good": 1001.3504,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.9091,
+      "log_good": 6.9091
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 325.0,
+      "good": 331.0,
+      "ratio": 1.0185,
+      "suggested_scalar": 0.0085,
+      "log_bad": 5.7838,
+      "log_good": 5.8021
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 21.625,
+      "good": 21.9375,
+      "ratio": 1.0145,
+      "suggested_scalar": 0.0067,
+      "log_bad": 3.0739,
+      "log_good": 3.0882
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.099,
+      "good": 1.099,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0944,
+      "log_good": 0.0944
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9026,
+      "good": 0.9006,
+      "ratio": 0.9978,
+      "suggested_scalar": -0.001,
+      "log_bad": -0.1025,
+      "log_good": -0.1047
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9885,
+      "good": 0.986,
+      "ratio": 0.9975,
+      "suggested_scalar": -0.0012,
+      "log_bad": -0.0116,
+      "log_good": -0.0141
+    },
+    "halstead.mean_length": {
+      "bad": 174.0,
+      "good": 174.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.1591,
+      "log_good": 5.1591
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.7549,
+      "good": 5.7814,
+      "ratio": 1.0046,
+      "suggested_scalar": 0.0021,
+      "log_bad": 1.7501,
+      "log_good": 1.7546
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1078,
+      "good": 0.1198,
+      "ratio": 1.1113,
+      "suggested_scalar": 0.049,
+      "log_bad": -2.2275,
+      "log_good": -2.1219
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 14.3158,
+      "good": 14.3158,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6614,
+      "log_good": 2.6614
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 35.0,
+      "good": 35.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5553,
+      "log_good": 3.5553
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7983,
+      "good": 0.7917,
+      "ratio": 0.9917,
+      "suggested_scalar": -0.0039,
+      "log_bad": -0.2253,
+      "log_good": -0.2336
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 32.0,
+      "good": 32.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4657,
+      "log_good": 3.4657
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.uses_ternary_expression": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 8.0,
+      "good": 12.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.2745,
+      "log_bad": 2.0794,
+      "log_good": 2.4849
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0633,
+      "good": 0.0549,
+      "ratio": 0.8673,
+      "suggested_scalar": -0.0964,
+      "log_bad": -2.7599,
+      "log_good": -2.9022
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.6379,
+      "good": 0.8333,
+      "ratio": 1.3063,
+      "suggested_scalar": 0.1809,
+      "log_bad": -0.4496,
+      "log_good": -0.1824
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0633,
+      "good": 0.0549,
+      "ratio": 0.8673,
+      "suggested_scalar": -0.0964,
+      "log_bad": -2.7599,
+      "log_good": -2.9022
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.2219,
+      "good": 4.7154,
+      "ratio": 1.1169,
+      "suggested_scalar": 0.0749,
+      "log_bad": 1.4403,
+      "log_good": 1.5508
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 59.0,
+      "good": 60.0,
+      "ratio": 1.0169,
+      "suggested_scalar": 0.0114,
+      "log_bad": 4.0775,
+      "log_good": 4.0943
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6207,
+      "good": 0.5833,
+      "ratio": 0.9397,
+      "suggested_scalar": -0.0421,
+      "log_bad": -0.4769,
+      "log_good": -0.5391
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 17.0,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.041,
+      "log_bad": 2.7726,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6456,
+      "good": 0.614,
+      "ratio": 0.9511,
+      "suggested_scalar": -0.034,
+      "log_bad": -0.4376,
+      "log_good": -0.4878
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.8621,
+      "good": 2.25,
+      "ratio": 0.5826,
+      "suggested_scalar": -0.3658,
+      "log_bad": 1.3512,
+      "log_good": 0.8109
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 221.0,
+      "good": 255.0,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.0969,
+      "log_bad": 5.3982,
+      "log_good": 5.5413
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0086,
+      "good": 1.0639,
+      "ratio": 1.0548,
+      "suggested_scalar": 0.0361,
+      "log_bad": 0.0086,
+      "log_good": 0.0619
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 58.0,
+      "good": 60.0,
+      "ratio": 1.0345,
+      "suggested_scalar": 0.023,
+      "log_bad": 4.0604,
+      "log_good": 4.0943
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 110.4137,
+      "good": 98.5592,
+      "ratio": 0.8926,
+      "suggested_scalar": -0.0769,
+      "log_bad": 4.7042,
+      "log_good": 4.5907
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5182,
+      "good": 0.5906,
+      "ratio": 1.1397,
+      "suggested_scalar": 0.0886,
+      "log_bad": -0.6574,
+      "log_good": -0.5266
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 14.3532,
+      "good": 17.2233,
+      "ratio": 1.2,
+      "suggested_scalar": 0.1234,
+      "log_bad": 2.664,
+      "log_good": 2.8463
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 996.0,
+      "good": 869.0,
+      "ratio": 0.8725,
+      "suggested_scalar": -0.0924,
+      "log_bad": 6.9037,
+      "log_good": 6.7673
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2759,
+      "good": 0.3333,
+      "ratio": 1.208,
+      "suggested_scalar": 0.128,
+      "log_bad": -1.2877,
+      "log_good": -1.0987
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6034,
+      "good": 0.7917,
+      "ratio": 1.3121,
+      "suggested_scalar": 0.1839,
+      "log_bad": -0.5052,
+      "log_good": -0.2336
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 3.8103,
+      "good": 10.625,
+      "ratio": 2.7885,
+      "suggested_scalar": 0.6944,
+      "log_bad": 1.3377,
+      "log_good": 2.3632
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.7396,
+      "good": 1.1042,
+      "ratio": 0.4031,
+      "suggested_scalar": -0.6153,
+      "log_bad": 1.0078,
+      "log_good": 0.0991
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 49.0,
+      "good": 51.0,
+      "ratio": 1.0408,
+      "suggested_scalar": 0.0271,
+      "log_bad": 3.8918,
+      "log_good": 3.9318
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9172,
+      "good": 0.9378,
+      "ratio": 1.0225,
+      "suggested_scalar": 0.015,
+      "log_bad": -0.0864,
+      "log_good": -0.0642
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 20.0,
+      "good": 21.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.033,
+      "log_bad": 2.9957,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6376,
+      "good": 0.5742,
+      "ratio": 0.9006,
+      "suggested_scalar": -0.0709,
+      "log_bad": -0.45,
+      "log_good": -0.5548
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3151,
+      "good": 0.3834,
+      "ratio": 1.2168,
+      "suggested_scalar": 0.1328,
+      "log_bad": -1.1549,
+      "log_good": -0.9587
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.759,
+      "good": 2.3486,
+      "ratio": 0.8513,
+      "suggested_scalar": -0.109,
+      "log_bad": 1.0149,
+      "log_good": 0.8538
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 219.0,
+      "good": 253.0,
+      "ratio": 1.1553,
+      "suggested_scalar": 0.0977,
+      "log_bad": 5.3891,
+      "log_good": 5.5334
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 8.0,
+      "good": 4.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.4693,
+      "log_bad": 2.0794,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0045,
+      "good": 0.0863,
+      "ratio": 19.1778,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.4037,
+      "log_good": -2.4499
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7549,
+      "good": 5.7814,
+      "ratio": 1.0046,
+      "suggested_scalar": 0.0031,
+      "log_bad": 1.7501,
+      "log_good": 1.7546
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6226,
+      "good": 0.6098,
+      "ratio": 0.9794,
+      "suggested_scalar": -0.0141,
+      "log_bad": -0.4739,
+      "log_good": -0.4946
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.1162,
+      "good": 5.0498,
+      "ratio": 0.987,
+      "suggested_scalar": -0.0088,
+      "log_bad": 1.6324,
+      "log_good": 1.6193
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7336,
+      "good": 0.8156,
+      "ratio": 1.1118,
+      "suggested_scalar": 0.0717,
+      "log_bad": -0.3098,
+      "log_good": -0.2038
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1077,
+      "good": 0.25,
+      "ratio": 2.3213,
+      "suggested_scalar": 0.5702,
+      "log_bad": -2.2284,
+      "log_good": -1.3863
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.7886,
+      "good": 4.1501,
+      "ratio": 1.0954,
+      "suggested_scalar": 0.0617,
+      "log_bad": 1.332,
+      "log_good": 1.4231
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 174.0,
+      "good": 186.0,
+      "ratio": 1.069,
+      "suggested_scalar": 0.0452,
+      "log_bad": 5.1591,
+      "log_good": 5.2257
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 5.0,
+      "good": 12.0,
+      "ratio": 2.4,
+      "suggested_scalar": 0.5928,
+      "log_bad": 1.6094,
+      "log_good": 2.4849
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.3255,
+      "good": 0.4036,
+      "ratio": 1.2399,
+      "suggested_scalar": 0.1456,
+      "log_bad": -1.1224,
+      "log_good": -0.9073
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 63.0,
+      "good": 64.0,
+      "ratio": 1.0159,
+      "suggested_scalar": 0.0107,
+      "log_bad": 4.1431,
+      "log_good": 4.1589
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 376.0,
+      "good": 426.0,
+      "ratio": 1.133,
+      "suggested_scalar": 0.0845,
+      "log_bad": 5.9296,
+      "log_good": 6.0544
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 52.0,
+      "good": 57.0,
+      "ratio": 1.0962,
+      "suggested_scalar": 0.0622,
+      "log_bad": 3.9512,
+      "log_good": 4.0431
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1855,
+      "good": 0.2549,
+      "ratio": 1.3741,
+      "suggested_scalar": 0.2152,
+      "log_bad": -1.6847,
+      "log_good": -1.3669
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 28.0,
+      "good": 40.0,
+      "ratio": 1.4286,
+      "suggested_scalar": 0.2415,
+      "log_bad": 3.3322,
+      "log_good": 3.6889
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 8.0,
+      "good": 12.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.2745,
+      "log_bad": 2.0794,
+      "log_good": 2.4849
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 63.0,
+      "good": 64.0,
+      "ratio": 1.0159,
+      "suggested_scalar": 0.0107,
+      "log_bad": 4.1431,
+      "log_good": 4.1589
+    },
+    "brevity.mean_sample_size": {
+      "bad": 63.0,
+      "good": 64.0,
+      "ratio": 1.0159,
+      "suggested_scalar": 0.0107,
+      "log_bad": 4.1431,
+      "log_good": 4.1589
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 221.0,
+      "good": 255.0,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.0969,
+      "log_bad": 5.3982,
+      "log_good": 5.5413
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 96.0,
+      "good": 142.0,
+      "ratio": 1.4792,
+      "suggested_scalar": 0.2651,
+      "log_bad": 4.5643,
+      "log_good": 4.9558
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 134.0,
+      "good": 144.0,
+      "ratio": 1.0746,
+      "suggested_scalar": 0.0487,
+      "log_bad": 4.8978,
+      "log_good": 4.9698
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.009,
+      "good": 0.0078,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.0969,
+      "log_bad": -4.7105,
+      "log_good": -4.8536
+    },
+    "heaps.mean_k": {
+      "bad": 2.0683,
+      "good": 2.2834,
+      "ratio": 1.104,
+      "suggested_scalar": 0.067,
+      "log_bad": 0.7267,
+      "log_good": 0.8257
+    },
+    "halstead.mean_effort": {
+      "bad": 13020.2499,
+      "good": 18582.8506,
+      "ratio": 1.4272,
+      "suggested_scalar": 0.2409,
+      "log_bad": 9.4743,
+      "log_good": 9.83
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8559,
+      "good": 0.8416,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0114,
+      "log_bad": -0.1556,
+      "log_good": -0.1725
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 39.0,
+      "good": 39.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6636,
+      "log_good": 3.6636
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 114.0,
+      "good": 148.0,
+      "ratio": 1.2982,
+      "suggested_scalar": 0.1767,
+      "log_bad": 4.7362,
+      "log_good": 4.9972
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.6207,
+      "good": 0.5833,
+      "ratio": 0.9397,
+      "suggested_scalar": -0.0421,
+      "log_bad": -0.4769,
+      "log_good": -0.5391
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.4828,
+      "good": 7.1,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.0616,
+      "log_bad": 1.8692,
+      "log_good": 1.9601
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1077,
+      "good": 0.25,
+      "ratio": 2.3213,
+      "suggested_scalar": 0.5702,
+      "log_bad": -2.2284,
+      "log_good": -1.3863
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.2079,
+      "good": 5.3929,
+      "ratio": 2.4425,
+      "suggested_scalar": 0.6047,
+      "log_bad": 0.792,
+      "log_good": 1.6851
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 220.0,
+      "good": 254.0,
+      "ratio": 1.1545,
+      "suggested_scalar": 0.0973,
+      "log_bad": 5.3936,
+      "log_good": 5.5373
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 7.0,
+      "good": 11.0,
+      "ratio": 1.5714,
+      "suggested_scalar": 0.306,
+      "log_bad": 1.9459,
+      "log_good": 2.3979
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 24.0,
+      "good": 30.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.1511,
+      "log_bad": 3.1781,
+      "log_good": 3.4012
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 723.3472,
+      "good": 1032.3806,
+      "ratio": 1.4272,
+      "suggested_scalar": 0.2409,
+      "log_bad": 6.5839,
+      "log_good": 6.9396
+    },
+    "readability.mean_total_lines": {
+      "bad": 58.0,
+      "good": 24.0,
+      "ratio": 0.4138,
+      "suggested_scalar": -0.5975,
+      "log_bad": 4.0604,
+      "log_good": 3.1781
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 4.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.2745,
+      "log_bad": 1.7918,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 976.5187,
+      "good": 1210.9126,
+      "ratio": 1.24,
+      "suggested_scalar": 0.1457,
+      "log_bad": 6.884,
+      "log_good": 7.0991
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 361.0,
+      "good": 370.0,
+      "ratio": 1.0249,
+      "suggested_scalar": 0.0167,
+      "log_bad": 5.8889,
+      "log_good": 5.9135
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 16.0517,
+      "good": 34.875,
+      "ratio": 2.1727,
+      "suggested_scalar": 0.5254,
+      "log_bad": 2.7758,
+      "log_good": 3.5518
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.094,
+      "good": 1.1524,
+      "ratio": 1.0534,
+      "suggested_scalar": 0.0352,
+      "log_bad": 0.0898,
+      "log_good": 0.1418
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 7.0,
+      "good": 1.0,
+      "ratio": 0.1429,
+      "suggested_scalar": -1.3176,
+      "log_bad": 1.9459,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8621,
+      "good": 0.8387,
+      "ratio": 0.9729,
+      "suggested_scalar": -0.0186,
+      "log_bad": -0.1484,
+      "log_good": -0.1759
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9887,
+      "good": 0.9877,
+      "ratio": 0.999,
+      "suggested_scalar": -0.0007,
+      "log_bad": -0.0114,
+      "log_good": -0.0124
+    },
+    "halstead.mean_length": {
+      "bad": 166.0,
+      "good": 205.0,
+      "ratio": 1.2349,
+      "suggested_scalar": 0.1429,
+      "log_bad": 5.112,
+      "log_good": 5.323
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 8.0,
+      "good": 2.5833,
+      "ratio": 0.3229,
+      "suggested_scalar": -0.7654,
+      "log_bad": 2.0794,
+      "log_good": 0.9491
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.9773,
+      "good": 6.0,
+      "ratio": 1.0038,
+      "suggested_scalar": 0.0026,
+      "log_bad": 1.788,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0964,
+      "good": 0.1634,
+      "ratio": 1.695,
+      "suggested_scalar": 0.3573,
+      "log_bad": -2.3392,
+      "log_good": -1.8116
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 13.3333,
+      "good": 15.3462,
+      "ratio": 1.151,
+      "suggested_scalar": 0.0952,
+      "log_bad": 2.5903,
+      "log_good": 2.7309
+    },
+    "branching.mean_branch_count": {
+      "bad": 16.0,
+      "good": 8.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.4693,
+      "log_bad": 2.7726,
+      "log_good": 2.0794
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 36.0,
+      "good": 35.0,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.0191,
+      "log_bad": 3.5835,
+      "log_good": 3.5553
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.791,
+      "good": 0.7222,
+      "ratio": 0.913,
+      "suggested_scalar": -0.0616,
+      "log_bad": -0.2345,
+      "log_good": -0.3255
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 58.0,
+      "good": 24.0,
+      "ratio": 0.4138,
+      "suggested_scalar": -0.5975,
+      "log_bad": 4.0604,
+      "log_good": 3.1781
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.4693,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.goroutine_has_clear_exit_condition": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 9.0,
+      "good": 10.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.2148,
+      "log_bad": 2.1972,
+      "log_good": 2.3026
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0128,
+      "good": 0.0226,
+      "ratio": 1.7656,
+      "suggested_scalar": 1.1592,
+      "log_bad": -4.3583,
+      "log_good": -3.7898
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8974,
+      "good": 0.8913,
+      "ratio": 0.9932,
+      "suggested_scalar": -0.0139,
+      "log_bad": -0.1083,
+      "log_good": -0.1151
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0128,
+      "good": 0.0226,
+      "ratio": 1.7656,
+      "suggested_scalar": 1.1592,
+      "log_bad": -4.3583,
+      "log_good": -3.7898
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.969,
+      "good": 4.9662,
+      "ratio": 0.9994,
+      "suggested_scalar": -0.0011,
+      "log_bad": 1.6032,
+      "log_good": 1.6027
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 84.0,
+      "good": 93.0,
+      "ratio": 1.1071,
+      "suggested_scalar": 0.2075,
+      "log_bad": 4.4308,
+      "log_good": 4.5326
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.485,
+      "good": 0.4767,
+      "ratio": 0.9829,
+      "suggested_scalar": -0.0352,
+      "log_bad": -0.7236,
+      "log_good": -0.7409
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7348,
+      "good": 0.6902,
+      "ratio": 0.9393,
+      "suggested_scalar": -0.1277,
+      "log_bad": -0.3082,
+      "log_good": -0.3708
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.1795,
+      "good": 1.3696,
+      "ratio": 1.1612,
+      "suggested_scalar": 0.3047,
+      "log_bad": 0.1651,
+      "log_good": 0.3145
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 235.0,
+      "good": 310.0,
+      "ratio": 1.3191,
+      "suggested_scalar": 0.5648,
+      "log_bad": 5.4596,
+      "log_good": 5.7366
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.3718,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0011,
+      "good": 0.0016,
+      "ratio": 1.4545,
+      "suggested_scalar": 0.764,
+      "log_bad": -6.8124,
+      "log_good": -6.4378
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1026,
+      "good": 0.1087,
+      "ratio": 1.0595,
+      "suggested_scalar": 0.1178,
+      "log_bad": -2.2769,
+      "log_good": -2.2192
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.7834,
+      "good": 0.8536,
+      "ratio": 1.0896,
+      "suggested_scalar": 0.175,
+      "log_bad": -0.2441,
+      "log_good": -0.1583
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 101.0,
+      "good": 135.0,
+      "ratio": 1.3366,
+      "suggested_scalar": 0.5917,
+      "log_bad": 4.6151,
+      "log_good": 4.9053
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 108.9605,
+      "good": 109.8883,
+      "ratio": 1.0085,
+      "suggested_scalar": 0.0173,
+      "log_bad": 4.691,
+      "log_good": 4.6995
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.2949,
+      "good": 0.3786,
+      "ratio": 1.2838,
+      "suggested_scalar": 0.5095,
+      "log_bad": -1.2211,
+      "log_good": -0.9713
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.5181,
+      "good": 6.1381,
+      "ratio": 0.8164,
+      "suggested_scalar": -0.4135,
+      "log_bad": 2.0173,
+      "log_good": 1.8145
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 945.0,
+      "good": 1230.0,
+      "ratio": 1.3016,
+      "suggested_scalar": 0.5375,
+      "log_bad": 6.8512,
+      "log_good": 7.1148
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1538,
+      "good": 0.1957,
+      "ratio": 1.2724,
+      "suggested_scalar": 0.4913,
+      "log_bad": -1.8721,
+      "log_good": -1.6312
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8205,
+      "good": 0.8043,
+      "ratio": 0.9803,
+      "suggested_scalar": -0.0407,
+      "log_bad": -0.1978,
+      "log_good": -0.2178
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.0256,
+      "good": 6.7391,
+      "ratio": 1.1184,
+      "suggested_scalar": 0.2282,
+      "log_bad": 1.796,
+      "log_good": 1.9079
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.9421,
+      "good": 1.7982,
+      "ratio": 0.9259,
+      "suggested_scalar": -0.157,
+      "log_bad": 0.6638,
+      "log_good": 0.5868
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 73.0,
+      "good": 100.0,
+      "ratio": 1.3699,
+      "suggested_scalar": 0.6417,
+      "log_bad": 4.2905,
+      "log_good": 4.6052
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9208,
+      "good": 0.9348,
+      "ratio": 1.0152,
+      "suggested_scalar": 0.0308,
+      "log_bad": -0.0825,
+      "log_good": -0.0674
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 30.0,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.1407,
+      "log_bad": 3.3322,
+      "log_good": 3.4012
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.4677,
+      "good": 0.5203,
+      "ratio": 1.1125,
+      "suggested_scalar": 0.2173,
+      "log_bad": -0.7599,
+      "log_good": -0.6533
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.0773,
+      "good": 0.1786,
+      "ratio": 2.3105,
+      "suggested_scalar": 1.7076,
+      "log_bad": -2.5601,
+      "log_good": -1.7226
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.8787,
+      "good": 2.0847,
+      "ratio": 1.1097,
+      "suggested_scalar": 0.2122,
+      "log_bad": 0.6306,
+      "log_good": 0.7346
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 233.0,
+      "good": 308.0,
+      "ratio": 1.3219,
+      "suggested_scalar": 0.569,
+      "log_bad": 5.451,
+      "log_good": 5.7301
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 15.0,
+      "good": 21.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.6861,
+      "log_bad": 2.7081,
+      "log_good": 3.0445
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0255,
+      "good": 0.0258,
+      "ratio": 1.0118,
+      "suggested_scalar": 0.0238,
+      "log_bad": -3.6691,
+      "log_good": -3.6574
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.9773,
+      "ratio": 1.0119,
+      "suggested_scalar": 0.0242,
+      "log_bad": 1.7761,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 28.0,
+      "good": 35.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.455,
+      "log_bad": 3.3322,
+      "log_good": 3.5553
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8516,
+      "good": 0.8256,
+      "ratio": 0.9695,
+      "suggested_scalar": -0.0632,
+      "log_bad": -0.1606,
+      "log_good": -0.1916
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9516,
+      "good": 5.983,
+      "ratio": 1.0053,
+      "suggested_scalar": 0.0107,
+      "log_bad": 1.7837,
+      "log_good": 1.7889
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8412,
+      "good": 0.8308,
+      "ratio": 0.9876,
+      "suggested_scalar": -0.0254,
+      "log_bad": -0.1729,
+      "log_good": -0.1854
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1333,
+      "good": 0.1154,
+      "ratio": 0.8657,
+      "suggested_scalar": -0.294,
+      "log_bad": -2.0152,
+      "log_good": -2.1594
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.7419,
+      "good": 2.4775,
+      "ratio": 0.9036,
+      "suggested_scalar": -0.2068,
+      "log_bad": 1.0087,
+      "log_good": 0.9072
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 224.0,
+      "good": 277.0,
+      "ratio": 1.2366,
+      "suggested_scalar": 0.433,
+      "log_bad": 5.4116,
+      "log_good": 5.624
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 1.4134,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.4645,
+      "good": 0.5972,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.5124,
+      "log_bad": -0.7668,
+      "log_good": -0.5155
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 88.0,
+      "good": 98.0,
+      "ratio": 1.1136,
+      "suggested_scalar": 0.2195,
+      "log_bad": 4.4773,
+      "log_good": 4.585
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 492.0,
+      "good": 682.0,
+      "ratio": 1.3862,
+      "suggested_scalar": 0.6659,
+      "log_bad": 6.1985,
+      "log_good": 6.525
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 110.0,
+      "good": 131.0,
+      "ratio": 1.1909,
+      "suggested_scalar": 0.3563,
+      "log_bad": 4.7005,
+      "log_good": 4.8752
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1872,
+      "good": 0.2097,
+      "ratio": 1.1202,
+      "suggested_scalar": 0.2314,
+      "log_bad": -1.6756,
+      "log_good": -1.5621
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 31.0,
+      "good": 47.0,
+      "ratio": 1.5161,
+      "suggested_scalar": 0.8486,
+      "log_bad": 3.434,
+      "log_good": 3.8501
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 88.0,
+      "good": 98.0,
+      "ratio": 1.1136,
+      "suggested_scalar": 0.2195,
+      "log_bad": 4.4773,
+      "log_good": 4.585
+    },
+    "brevity.mean_sample_size": {
+      "bad": 88.0,
+      "good": 98.0,
+      "ratio": 1.1136,
+      "suggested_scalar": 0.2195,
+      "log_bad": 4.4773,
+      "log_good": 4.585
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 235.0,
+      "good": 310.0,
+      "ratio": 1.3191,
+      "suggested_scalar": 0.5648,
+      "log_bad": 5.4596,
+      "log_good": 5.7366
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 104.0,
+      "good": 140.0,
+      "ratio": 1.3462,
+      "suggested_scalar": 0.6061,
+      "log_bad": 4.6444,
+      "log_good": 4.9416
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 196.0,
+      "good": 239.0,
+      "ratio": 1.2194,
+      "suggested_scalar": 0.4045,
+      "log_bad": 5.2781,
+      "log_good": 5.4765
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0043,
+      "good": 0.0032,
+      "ratio": 0.7442,
+      "suggested_scalar": -0.6025,
+      "log_bad": -5.4491,
+      "log_good": -5.7446
+    },
+    "heaps.mean_k": {
+      "bad": 1.7278,
+      "good": 2.025,
+      "ratio": 1.172,
+      "suggested_scalar": 0.3236,
+      "log_bad": 0.5468,
+      "log_good": 0.7056
+    },
+    "halstead.mean_effort": {
+      "bad": 38321.9429,
+      "good": 55884.8968,
+      "ratio": 1.4583,
+      "suggested_scalar": 0.7693,
+      "log_bad": 10.5538,
+      "log_good": 10.931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.9214,
+      "good": 0.9045,
+      "ratio": 0.9817,
+      "suggested_scalar": -0.0377,
+      "log_bad": -0.0819,
+      "log_good": -0.1004
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 56.0,
+      "good": 63.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.2402,
+      "log_bad": 4.0254,
+      "log_good": 4.1431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 108.0,
+      "good": 143.0,
+      "ratio": 1.3241,
+      "suggested_scalar": 0.5724,
+      "log_bad": 4.6821,
+      "log_good": 4.9628
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4851,
+      "good": 0.4444,
+      "ratio": 0.9161,
+      "suggested_scalar": -0.1787,
+      "log_bad": -0.7234,
+      "log_good": -0.811
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.8713,
+      "good": 5.0519,
+      "ratio": 1.0371,
+      "suggested_scalar": 0.0742,
+      "log_bad": 1.5834,
+      "log_good": 1.6198
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1333,
+      "good": 0.1154,
+      "ratio": 0.8657,
+      "suggested_scalar": -0.294,
+      "log_bad": -2.0152,
+      "log_good": -2.1594
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.7179,
+      "good": 2.9323,
+      "ratio": 1.0789,
+      "suggested_scalar": 0.1548,
+      "log_bad": 0.9999,
+      "log_good": 1.0758
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 234.0,
+      "good": 309.0,
+      "ratio": 1.3205,
+      "suggested_scalar": 0.5669,
+      "log_bad": 5.4553,
+      "log_good": 5.7333
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 9.0,
+      "good": 24.0,
+      "ratio": 2.6667,
+      "suggested_scalar": 2.0,
+      "log_bad": 2.1972,
+      "log_good": 3.1781
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2128.9968,
+      "good": 3104.7165,
+      "ratio": 1.4583,
+      "suggested_scalar": 0.7693,
+      "log_bad": 7.6634,
+      "log_good": 8.0407
+    },
+    "readability.mean_total_lines": {
+      "bad": 39.0,
+      "good": 46.0,
+      "ratio": 1.1795,
+      "suggested_scalar": 0.3366,
+      "log_bad": 3.6636,
+      "log_good": 3.8286
+    },
+    "indentation.mean_max_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.455,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1393.5252,
+      "good": 1791.7295,
+      "ratio": 1.2858,
+      "suggested_scalar": 0.5125,
+      "log_bad": 7.2396,
+      "log_good": 7.4909
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 503.0,
+      "good": 590.0,
+      "ratio": 1.173,
+      "suggested_scalar": 0.3253,
+      "log_bad": 6.2206,
+      "log_good": 6.3801
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 22.9744,
+      "good": 25.5217,
+      "ratio": 1.1109,
+      "suggested_scalar": 0.2144,
+      "log_bad": 3.1344,
+      "log_good": 3.2395
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0846,
+      "good": 1.0651,
+      "ratio": 0.982,
+      "suggested_scalar": -0.037,
+      "log_bad": 0.0812,
+      "log_good": 0.0631
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.3718,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 14.0,
+      "good": 24.0,
+      "ratio": 1.7143,
+      "suggested_scalar": 1.0991,
+      "log_bad": 2.6391,
+      "log_good": 3.1781
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.455,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9598,
+      "good": 0.9134,
+      "ratio": 0.9517,
+      "suggested_scalar": -0.101,
+      "log_bad": -0.041,
+      "log_good": -0.0906
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9804,
+      "good": 0.9741,
+      "ratio": 0.9936,
+      "suggested_scalar": -0.0131,
+      "log_bad": -0.0198,
+      "log_good": -0.0262
+    },
+    "halstead.mean_length": {
+      "bad": 218.0,
+      "good": 274.0,
+      "ratio": 1.2569,
+      "suggested_scalar": 0.4662,
+      "log_bad": 5.3845,
+      "log_good": 5.6131
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.0,
+      "good": 13.0,
+      "ratio": 1.3,
+      "suggested_scalar": 0.535,
+      "log_bad": 2.3026,
+      "log_good": 2.5649
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4594,
+      "good": 6.6147,
+      "ratio": 1.024,
+      "suggested_scalar": 0.0484,
+      "log_bad": 1.8655,
+      "log_good": 1.8893
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1105,
+      "good": 0.1142,
+      "ratio": 1.0335,
+      "suggested_scalar": 0.0672,
+      "log_bad": -2.2027,
+      "log_good": -2.1698
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.5,
+      "good": 31.1905,
+      "ratio": 1.1342,
+      "suggested_scalar": 0.2568,
+      "log_bad": 3.3142,
+      "log_good": 3.4401
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 9.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.8268,
+      "log_bad": 1.7918,
+      "log_good": 2.1972
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 49.0,
+      "good": 60.0,
+      "ratio": 1.2245,
+      "suggested_scalar": 0.413,
+      "log_bad": 3.8918,
+      "log_good": 4.0943
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8418,
+      "good": 0.8033,
+      "ratio": 0.9543,
+      "suggested_scalar": -0.0955,
+      "log_bad": -0.1722,
+      "log_good": -0.219
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 39.0,
+      "good": 46.0,
+      "ratio": 1.1795,
+      "suggested_scalar": 0.3366,
+      "log_bad": 3.6636,
+      "log_good": 3.8286
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.supervised_processes_in_supervision_tree": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 26.0,
+      "good": 27.0,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0156,
+      "log_bad": 3.2581,
+      "log_good": 3.2958
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0078,
+      "good": 0.0099,
+      "ratio": 1.2692,
+      "suggested_scalar": 0.0982,
+      "log_bad": -4.8536,
+      "log_good": -4.6152
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1667,
+      "good": 1.3333,
+      "ratio": 1.1428,
+      "suggested_scalar": 0.055,
+      "log_bad": 0.1542,
+      "log_good": 0.2877
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9038,
+      "good": 0.7667,
+      "ratio": 0.8483,
+      "suggested_scalar": -0.0678,
+      "log_bad": -0.1011,
+      "log_good": -0.2657
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0078,
+      "good": 0.0099,
+      "ratio": 1.2692,
+      "suggested_scalar": 0.0982,
+      "log_bad": -4.8536,
+      "log_good": -4.6152
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6586,
+      "good": 4.8066,
+      "ratio": 1.0318,
+      "suggested_scalar": 0.0129,
+      "log_bad": 1.5387,
+      "log_good": 1.57
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 113.0,
+      "good": 92.0,
+      "ratio": 0.8142,
+      "suggested_scalar": -0.0847,
+      "log_bad": 4.7274,
+      "log_good": 4.5218
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5484,
+      "good": 0.4756,
+      "ratio": 0.8673,
+      "suggested_scalar": -0.0587,
+      "log_bad": -0.6008,
+      "log_good": -0.7432
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 19.0,
+      "ratio": 0.95,
+      "suggested_scalar": -0.0211,
+      "log_bad": 2.9957,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6523,
+      "good": 0.5882,
+      "ratio": 0.9017,
+      "suggested_scalar": -0.0426,
+      "log_bad": -0.4273,
+      "log_good": -0.5307
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.8077,
+      "good": 2.8667,
+      "ratio": 0.7529,
+      "suggested_scalar": -0.117,
+      "log_bad": 1.337,
+      "log_good": 1.0532
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 386.0,
+      "good": 406.0,
+      "ratio": 1.0518,
+      "suggested_scalar": 0.0208,
+      "log_bad": 5.9558,
+      "log_good": 6.0064
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0962,
+      "good": 0.0167,
+      "ratio": 0.1736,
+      "suggested_scalar": -0.7215,
+      "log_bad": -2.3413,
+      "log_good": -4.0923
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8907,
+      "good": 0.9876,
+      "ratio": 1.1088,
+      "suggested_scalar": 0.0426,
+      "log_bad": -0.1157,
+      "log_good": -0.0125
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 137.0,
+      "good": 135.0,
+      "ratio": 0.9854,
+      "suggested_scalar": -0.0061,
+      "log_bad": 4.92,
+      "log_good": 4.9053
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 103.163,
+      "good": 98.4168,
+      "ratio": 0.954,
+      "suggested_scalar": -0.0194,
+      "log_bad": 4.6363,
+      "log_good": 4.5892
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4987,
+      "good": 0.563,
+      "ratio": 1.1289,
+      "suggested_scalar": 0.05,
+      "log_bad": -0.6958,
+      "log_good": -0.5745
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.2229,
+      "good": 10.5061,
+      "ratio": 1.1391,
+      "suggested_scalar": 0.0537,
+      "log_bad": 2.2217,
+      "log_good": 2.352
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1622.0,
+      "good": 1728.0,
+      "ratio": 1.0654,
+      "suggested_scalar": 0.0261,
+      "log_bad": 7.3914,
+      "log_good": 7.4547
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2115,
+      "good": 0.0667,
+      "ratio": 0.3154,
+      "suggested_scalar": -0.4755,
+      "log_bad": -1.5535,
+      "log_good": -2.7076
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8269,
+      "good": 0.7333,
+      "ratio": 0.8868,
+      "suggested_scalar": -0.0495,
+      "log_bad": -0.1901,
+      "log_good": -0.3102
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.2128,
+      "good": 6.8814,
+      "ratio": 0.8379,
+      "suggested_scalar": -0.0729,
+      "log_bad": 2.1057,
+      "log_good": 1.9288
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 6.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.4527,
+      "log_bad": 0.6931,
+      "log_good": 1.7918
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 7.2707,
+      "good": 2.3156,
+      "ratio": 0.3185,
+      "suggested_scalar": -0.4715,
+      "log_bad": 1.9839,
+      "log_good": 0.8397
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 110.0,
+      "good": 104.0,
+      "ratio": 0.9455,
+      "suggested_scalar": -0.0231,
+      "log_bad": 4.7005,
+      "log_good": 4.6444
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9475,
+      "good": 0.9346,
+      "ratio": 0.9864,
+      "suggested_scalar": -0.0056,
+      "log_bad": -0.0539,
+      "log_good": -0.0676
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 32.0,
+      "good": 30.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0266,
+      "log_bad": 3.4657,
+      "log_good": 3.4012
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5617,
+      "good": 0.5966,
+      "ratio": 1.0621,
+      "suggested_scalar": 0.0248,
+      "log_bad": -0.5768,
+      "log_good": -0.5165
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.25,
+      "good": 0.3762,
+      "ratio": 1.5048,
+      "suggested_scalar": 0.1684,
+      "log_bad": -1.3863,
+      "log_good": -0.9776
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2813,
+      "good": 2.4792,
+      "ratio": 1.0867,
+      "suggested_scalar": 0.0343,
+      "log_bad": 0.8247,
+      "log_good": 0.9079
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 384.0,
+      "good": 404.0,
+      "ratio": 1.0521,
+      "suggested_scalar": 0.0209,
+      "log_bad": 5.9506,
+      "log_good": 6.0014
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 19.0,
+      "good": 12.0,
+      "ratio": 0.6316,
+      "suggested_scalar": -0.1894,
+      "log_bad": 2.9444,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0311,
+      "good": 0.0394,
+      "ratio": 1.2669,
+      "suggested_scalar": 0.0975,
+      "log_bad": -3.4705,
+      "log_good": -3.234
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8826,
+      "good": 5.9773,
+      "ratio": 1.0161,
+      "suggested_scalar": 0.0066,
+      "log_bad": 1.772,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7911,
+      "good": 0.9401,
+      "ratio": 1.1883,
+      "suggested_scalar": 0.0711,
+      "log_bad": -0.2343,
+      "log_good": -0.0618
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.0455,
+      "good": 5.8591,
+      "ratio": 0.9692,
+      "suggested_scalar": -0.0129,
+      "log_bad": 1.7993,
+      "log_good": 1.768
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7919,
+      "good": 0.8041,
+      "ratio": 1.0154,
+      "suggested_scalar": 0.0063,
+      "log_bad": -0.2333,
+      "log_good": -0.218
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2,
+      "good": 0.1892,
+      "ratio": 0.946,
+      "suggested_scalar": -0.0229,
+      "log_bad": -1.6094,
+      "log_good": -1.665
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.0369,
+      "good": 3.2413,
+      "ratio": 1.0673,
+      "suggested_scalar": 0.0268,
+      "log_bad": 1.1108,
+      "log_good": 1.176
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 328.0,
+      "good": 307.0,
+      "ratio": 0.936,
+      "suggested_scalar": -0.0273,
+      "log_bad": 5.793,
+      "log_good": 5.7268
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.823,
+      "good": 0.7915,
+      "ratio": 0.9617,
+      "suggested_scalar": -0.0161,
+      "log_bad": -0.1948,
+      "log_good": -0.2338
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 119.0,
+      "good": 111.0,
+      "ratio": 0.9328,
+      "suggested_scalar": -0.0287,
+      "log_bad": 4.7791,
+      "log_good": 4.7095
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 814.0,
+      "good": 926.0,
+      "ratio": 1.1376,
+      "suggested_scalar": 0.0531,
+      "log_bad": 6.702,
+      "log_good": 6.8309
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 155.0,
+      "good": 135.0,
+      "ratio": 0.871,
+      "suggested_scalar": -0.0569,
+      "log_bad": 5.0434,
+      "log_good": 4.9053
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0078,
+      "good": 1.0,
+      "ratio": 128.2051,
+      "suggested_scalar": 2.0,
+      "log_bad": -4.8536,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2435,
+      "good": 0.2463,
+      "ratio": 1.0115,
+      "suggested_scalar": 0.0047,
+      "log_bad": -1.4126,
+      "log_good": -1.4012
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 69.0,
+      "good": 72.0,
+      "ratio": 1.0435,
+      "suggested_scalar": 0.0175,
+      "log_bad": 4.2341,
+      "log_good": 4.2767
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 9.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1671,
+      "log_bad": 1.7918,
+      "log_good": 2.1972
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 119.0,
+      "good": 111.0,
+      "ratio": 0.9328,
+      "suggested_scalar": -0.0287,
+      "log_bad": 4.7791,
+      "log_good": 4.7095
+    },
+    "brevity.mean_sample_size": {
+      "bad": 119.0,
+      "good": 111.0,
+      "ratio": 0.9328,
+      "suggested_scalar": -0.0287,
+      "log_bad": 4.7791,
+      "log_good": 4.7095
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 386.0,
+      "good": 406.0,
+      "ratio": 1.0518,
+      "suggested_scalar": 0.0208,
+      "log_bad": 5.9558,
+      "log_good": 6.0064
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 180.0,
+      "good": 202.0,
+      "ratio": 1.1222,
+      "suggested_scalar": 0.0475,
+      "log_bad": 5.193,
+      "log_good": 5.3083
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 262.0,
+      "good": 249.0,
+      "ratio": 0.9504,
+      "suggested_scalar": -0.021,
+      "log_bad": 5.5683,
+      "log_good": 5.5175
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0026,
+      "good": 0.0025,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0162,
+      "log_bad": -5.9522,
+      "log_good": -5.9915
+    },
+    "heaps.mean_k": {
+      "bad": 2.6751,
+      "good": 3.2445,
+      "ratio": 1.2129,
+      "suggested_scalar": 0.0795,
+      "log_bad": 0.984,
+      "log_good": 1.177
+    },
+    "halstead.mean_effort": {
+      "bad": 75591.1588,
+      "good": 77556.7342,
+      "ratio": 1.026,
+      "suggested_scalar": 0.0106,
+      "log_bad": 11.2331,
+      "log_good": 11.2588
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8768,
+      "good": 0.8623,
+      "ratio": 0.9835,
+      "suggested_scalar": -0.0069,
+      "log_bad": -0.1315,
+      "log_good": -0.1482
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 81.0,
+      "good": 62.0,
+      "ratio": 0.7654,
+      "suggested_scalar": -0.1102,
+      "log_bad": 4.3944,
+      "log_good": 4.1271
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 207.0,
+      "good": 229.0,
+      "ratio": 1.1063,
+      "suggested_scalar": 0.0416,
+      "log_bad": 5.3327,
+      "log_good": 5.4337
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5182,
+      "good": 0.5037,
+      "ratio": 0.972,
+      "suggested_scalar": -0.0117,
+      "log_bad": -0.6574,
+      "log_good": -0.6858
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.9416,
+      "good": 6.8593,
+      "ratio": 1.1545,
+      "suggested_scalar": 0.0592,
+      "log_bad": 1.782,
+      "log_good": 1.9256
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2,
+      "good": 0.1892,
+      "ratio": 0.946,
+      "suggested_scalar": -0.0229,
+      "log_bad": -1.6094,
+      "log_good": -1.665
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.8942,
+      "good": 3.773,
+      "ratio": 0.9689,
+      "suggested_scalar": -0.013,
+      "log_bad": 1.3595,
+      "log_good": 1.3279
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 385.0,
+      "good": 405.0,
+      "ratio": 1.0519,
+      "suggested_scalar": 0.0209,
+      "log_bad": 5.9532,
+      "log_good": 6.0039
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 4.0,
+      "good": 7.0,
+      "ratio": 1.75,
+      "suggested_scalar": 0.2306,
+      "log_bad": 1.3863,
+      "log_good": 1.9459
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 40.0,
+      "good": 55.0,
+      "ratio": 1.375,
+      "suggested_scalar": 0.1312,
+      "log_bad": 3.6889,
+      "log_good": 4.0073
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4199.5088,
+      "good": 4308.7075,
+      "ratio": 1.026,
+      "suggested_scalar": 0.0106,
+      "log_bad": 8.3427,
+      "log_good": 8.3684
+    },
+    "readability.mean_total_lines": {
+      "bad": 47.0,
+      "good": 59.0,
+      "ratio": 1.2553,
+      "suggested_scalar": 0.0937,
+      "log_bad": 3.8501,
+      "log_good": 4.0775
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 6.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.2105,
+      "log_bad": 2.3026,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2468.9048,
+      "good": 2374.5766,
+      "ratio": 0.9618,
+      "suggested_scalar": -0.0161,
+      "log_bad": 7.8115,
+      "log_good": 7.7726
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 711.0,
+      "good": 697.0,
+      "ratio": 0.9803,
+      "suggested_scalar": -0.0082,
+      "log_bad": 6.5667,
+      "log_good": 6.5468
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 25.9362,
+      "good": 26.7119,
+      "ratio": 1.0299,
+      "suggested_scalar": 0.0121,
+      "log_bad": 3.2556,
+      "log_good": 3.2851
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1269,
+      "good": 1.199,
+      "ratio": 1.064,
+      "suggested_scalar": 0.0256,
+      "log_bad": 0.1195,
+      "log_good": 0.1815
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 24.0,
+      "good": 19.0,
+      "ratio": 0.7917,
+      "suggested_scalar": -0.0963,
+      "log_bad": 3.1781,
+      "log_good": 2.9444
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 1.0,
+      "ratio": 0.2,
+      "suggested_scalar": -0.6632,
+      "log_bad": 1.6094,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.878,
+      "good": 0.8208,
+      "ratio": 0.9349,
+      "suggested_scalar": -0.0278,
+      "log_bad": -0.1301,
+      "log_good": -0.1975
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.925,
+      "good": 0.9496,
+      "ratio": 1.0266,
+      "suggested_scalar": 0.0108,
+      "log_bad": -0.078,
+      "log_good": -0.0517
+    },
+    "halstead.mean_length": {
+      "bad": 362.0,
+      "good": 364.0,
+      "ratio": 1.0055,
+      "suggested_scalar": 0.0023,
+      "log_bad": 5.8916,
+      "log_good": 5.8972
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.0,
+      "good": 7.0,
+      "ratio": 0.7778,
+      "suggested_scalar": -0.1036,
+      "log_bad": 2.1972,
+      "log_good": 1.9459
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8948,
+      "good": 6.7944,
+      "ratio": 0.9854,
+      "suggested_scalar": -0.006,
+      "log_bad": 1.9308,
+      "log_good": 1.9161
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1111,
+      "good": 0.117,
+      "ratio": 1.0531,
+      "suggested_scalar": 0.0213,
+      "log_bad": -2.1973,
+      "log_good": -2.1456
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.6173,
+      "good": 32.6613,
+      "ratio": 1.0668,
+      "suggested_scalar": 0.0266,
+      "log_bad": 3.4216,
+      "log_good": 3.4862
+    },
+    "branching.mean_branch_count": {
+      "bad": 11.0,
+      "good": 4.0,
+      "ratio": 0.3636,
+      "suggested_scalar": -0.4168,
+      "log_bad": 2.3979,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 71.0,
+      "good": 68.0,
+      "ratio": 0.9577,
+      "suggested_scalar": -0.0178,
+      "log_bad": 4.2627,
+      "log_good": 4.2195
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7366,
+      "good": 0.7108,
+      "ratio": 0.965,
+      "suggested_scalar": -0.0147,
+      "log_bad": -0.3057,
+      "log_good": -0.3414
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 52.0,
+      "good": 60.0,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.059,
+      "log_bad": 3.9512,
+      "log_good": 4.0943
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.uses_immutable_collection_interfaces": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 24.0,
+      "good": 23.0,
+      "ratio": 0.9583,
+      "suggested_scalar": -0.0323,
+      "log_bad": 3.1781,
+      "log_good": 3.1355
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.6667,
+      "good": 0.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.4054,
+      "log_good": -0.4054
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8333,
+      "good": 0.8421,
+      "ratio": 1.0106,
+      "suggested_scalar": 0.008,
+      "log_bad": -0.1824,
+      "log_good": -0.1719
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7303,
+      "good": 4.7077,
+      "ratio": 0.9952,
+      "suggested_scalar": -0.0036,
+      "log_bad": 1.554,
+      "log_good": 1.5492
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 101.0,
+      "good": 100.0,
+      "ratio": 0.9901,
+      "suggested_scalar": -0.0075,
+      "log_bad": 4.6151,
+      "log_good": 4.6052
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5371,
+      "good": 0.5228,
+      "ratio": 0.9734,
+      "suggested_scalar": -0.0205,
+      "log_bad": -0.6216,
+      "log_good": -0.6486
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6852,
+      "good": 0.6751,
+      "ratio": 0.9853,
+      "suggested_scalar": -0.0113,
+      "log_bad": -0.378,
+      "log_good": -0.3929
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.2222,
+      "good": 5.1579,
+      "ratio": 0.9877,
+      "suggested_scalar": -0.0094,
+      "log_bad": 1.6529,
+      "log_good": 1.6405
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 329.0,
+      "good": 341.0,
+      "ratio": 1.0365,
+      "suggested_scalar": 0.0271,
+      "log_bad": 5.7961,
+      "log_good": 5.8319
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1111,
+      "good": 0.1053,
+      "ratio": 0.9478,
+      "suggested_scalar": -0.0406,
+      "log_bad": -2.1973,
+      "log_good": -2.2509
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9435,
+      "good": 0.9705,
+      "ratio": 1.0286,
+      "suggested_scalar": 0.0214,
+      "log_bad": -0.0582,
+      "log_good": -0.0299
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 140.0,
+      "good": 135.0,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.0276,
+      "log_bad": 4.9416,
+      "log_good": 4.9053
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 86.2697,
+      "good": 90.993,
+      "ratio": 1.0548,
+      "suggested_scalar": 0.0404,
+      "log_bad": 4.4575,
+      "log_good": 4.5108
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4695,
+      "good": 0.5118,
+      "ratio": 1.0901,
+      "suggested_scalar": 0.0654,
+      "log_bad": -0.7561,
+      "log_good": -0.6698
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.2495,
+      "good": 9.4615,
+      "ratio": 1.0229,
+      "suggested_scalar": 0.0172,
+      "log_bad": 2.2246,
+      "log_good": 2.2472
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1627.0,
+      "good": 1612.0,
+      "ratio": 0.9908,
+      "suggested_scalar": -0.007,
+      "log_bad": 7.3945,
+      "log_good": 7.3852
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0556,
+      "good": 0.0526,
+      "ratio": 0.946,
+      "suggested_scalar": -0.042,
+      "log_bad": -2.8896,
+      "log_good": -2.945
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7778,
+      "good": 0.7895,
+      "ratio": 1.015,
+      "suggested_scalar": 0.0113,
+      "log_bad": -0.2513,
+      "log_good": -0.2364
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.1389,
+      "good": 8.9737,
+      "ratio": 0.9819,
+      "suggested_scalar": -0.0138,
+      "log_bad": 2.2125,
+      "log_good": 2.1943
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 14.0,
+      "ratio": 14.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 2.6391
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 10.5062,
+      "good": 10.0277,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.0353,
+      "log_bad": 2.352,
+      "log_good": 2.3054
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 83.0,
+      "good": 65.0,
+      "ratio": 0.7831,
+      "suggested_scalar": -0.1853,
+      "log_bad": 4.4188,
+      "log_good": 4.1744
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9352,
+      "good": 0.9268,
+      "ratio": 0.991,
+      "suggested_scalar": -0.0068,
+      "log_bad": -0.067,
+      "log_good": -0.076
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5845,
+      "good": 0.5974,
+      "ratio": 1.0221,
+      "suggested_scalar": 0.0165,
+      "log_bad": -0.537,
+      "log_good": -0.5152
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2599,
+      "good": 0.2979,
+      "ratio": 1.1462,
+      "suggested_scalar": 0.1034,
+      "log_bad": -1.3475,
+      "log_good": -1.211
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4068,
+      "good": 2.4838,
+      "ratio": 1.032,
+      "suggested_scalar": 0.0239,
+      "log_bad": 0.8783,
+      "log_good": 0.9098
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 327.0,
+      "good": 339.0,
+      "ratio": 1.0367,
+      "suggested_scalar": 0.0273,
+      "log_bad": 5.79,
+      "log_good": 5.826
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0334,
+      "good": 0.0323,
+      "ratio": 0.9671,
+      "suggested_scalar": -0.0254,
+      "log_bad": -3.3992,
+      "log_good": -3.4327
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 5.9069,
+      "ratio": 0.996,
+      "suggested_scalar": -0.003,
+      "log_bad": 1.7801,
+      "log_good": 1.7761
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 33.0,
+      "good": 33.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4965,
+      "log_good": 3.4965
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3748,
+      "good": 1.7786,
+      "ratio": 1.2937,
+      "suggested_scalar": 0.1952,
+      "log_bad": 0.3183,
+      "log_good": 0.5758
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7713,
+      "good": 5.7336,
+      "ratio": 0.9935,
+      "suggested_scalar": -0.005,
+      "log_bad": 1.7529,
+      "log_good": 1.7463
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7976,
+      "good": 0.797,
+      "ratio": 0.9992,
+      "suggested_scalar": -0.0006,
+      "log_bad": -0.2261,
+      "log_good": -0.2269
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.234,
+      "good": 0.24,
+      "ratio": 1.0256,
+      "suggested_scalar": 0.0192,
+      "log_bad": -1.4524,
+      "log_good": -1.4271
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.0413,
+      "good": 3.076,
+      "ratio": 1.0114,
+      "suggested_scalar": 0.0086,
+      "log_bad": 1.1123,
+      "log_good": 1.1236
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 279.0,
+      "good": 283.0,
+      "ratio": 1.0143,
+      "suggested_scalar": 0.0108,
+      "log_bad": 5.6312,
+      "log_good": 5.6454
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1382,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7146,
+      "good": 0.7397,
+      "ratio": 1.0351,
+      "suggested_scalar": 0.0262,
+      "log_bad": -0.336,
+      "log_good": -0.3015
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 100.0,
+      "good": 99.0,
+      "ratio": 0.99,
+      "suggested_scalar": -0.0076,
+      "log_bad": 4.6052,
+      "log_good": 4.5951
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 977.0,
+      "good": 907.0,
+      "ratio": 0.9284,
+      "suggested_scalar": -0.0563,
+      "log_bad": 6.8845,
+      "log_good": 6.8101
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 152.0,
+      "good": 154.0,
+      "ratio": 1.0132,
+      "suggested_scalar": 0.0099,
+      "log_bad": 5.0239,
+      "log_good": 5.037
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.003,
+      "good": 0.0029,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0257,
+      "log_bad": -5.8091,
+      "log_good": -5.843
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2584,
+      "good": 0.261,
+      "ratio": 1.0101,
+      "suggested_scalar": 0.0076,
+      "log_bad": -1.3532,
+      "log_good": -1.3432
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 50.0,
+      "good": 57.0,
+      "ratio": 1.14,
+      "suggested_scalar": 0.0993,
+      "log_bad": 3.912,
+      "log_good": 4.0431
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 100.0,
+      "good": 99.0,
+      "ratio": 0.99,
+      "suggested_scalar": -0.0076,
+      "log_bad": 4.6052,
+      "log_good": 4.5951
+    },
+    "brevity.mean_sample_size": {
+      "bad": 100.0,
+      "good": 99.0,
+      "ratio": 0.99,
+      "suggested_scalar": -0.0076,
+      "log_bad": 4.6052,
+      "log_good": 4.5951
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 329.0,
+      "good": 341.0,
+      "ratio": 1.0365,
+      "suggested_scalar": 0.0271,
+      "log_bad": 5.7961,
+      "log_good": 5.8319
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 160.0,
+      "good": 168.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.037,
+      "log_bad": 5.0752,
+      "log_good": 5.124
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 224.0,
+      "good": 223.0,
+      "ratio": 0.9955,
+      "suggested_scalar": -0.0034,
+      "log_bad": 5.4116,
+      "log_good": 5.4072
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.0207,
+      "good": 2.0044,
+      "ratio": 0.9919,
+      "suggested_scalar": -0.0061,
+      "log_bad": 0.7034,
+      "log_good": 0.6953
+    },
+    "halstead.mean_effort": {
+      "bad": 53598.6024,
+      "good": 56955.5645,
+      "ratio": 1.0626,
+      "suggested_scalar": 0.046,
+      "log_bad": 10.8893,
+      "log_good": 10.95
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8687,
+      "good": 0.8649,
+      "ratio": 0.9956,
+      "suggested_scalar": -0.0033,
+      "log_bad": -0.1408,
+      "log_good": -0.1451
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 76.0,
+      "good": 75.0,
+      "ratio": 0.9868,
+      "suggested_scalar": -0.01,
+      "log_bad": 4.3307,
+      "log_good": 4.3175
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 170.0,
+      "good": 180.0,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.0433,
+      "log_bad": 5.1358,
+      "log_good": 5.193
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5071,
+      "good": 0.5037,
+      "ratio": 0.9933,
+      "suggested_scalar": -0.0051,
+      "log_bad": -0.679,
+      "log_good": -0.6858
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.9786,
+      "good": 6.7185,
+      "ratio": 0.9627,
+      "suggested_scalar": -0.0288,
+      "log_bad": 1.9428,
+      "log_good": 1.9049
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.234,
+      "good": 0.24,
+      "ratio": 1.0256,
+      "suggested_scalar": 0.0192,
+      "log_bad": -1.4524,
+      "log_good": -1.4271
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.5603,
+      "good": 4.7523,
+      "ratio": 0.8547,
+      "suggested_scalar": -0.119,
+      "log_bad": 1.7157,
+      "log_good": 1.5586
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 328.0,
+      "good": 340.0,
+      "ratio": 1.0366,
+      "suggested_scalar": 0.0272,
+      "log_bad": 5.793,
+      "log_good": 5.8289
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.5253,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 37.0,
+      "good": 45.0,
+      "ratio": 1.2162,
+      "suggested_scalar": 0.1483,
+      "log_bad": 3.6109,
+      "log_good": 3.8067
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2977.7001,
+      "good": 3164.198,
+      "ratio": 1.0626,
+      "suggested_scalar": 0.046,
+      "log_bad": 7.9989,
+      "log_good": 8.0597
+    },
+    "readability.mean_total_lines": {
+      "bad": 36.0,
+      "good": 38.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.041,
+      "log_bad": 3.5835,
+      "log_good": 3.6376
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2143.9441,
+      "good": 2219.048,
+      "ratio": 1.035,
+      "suggested_scalar": 0.0261,
+      "log_bad": 7.6704,
+      "log_good": 7.7048
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 676.0,
+      "good": 649.0,
+      "ratio": 0.9601,
+      "suggested_scalar": -0.0309,
+      "log_bad": 6.5162,
+      "log_good": 6.4754
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 43.7222,
+      "good": 40.9474,
+      "ratio": 0.9365,
+      "suggested_scalar": -0.0497,
+      "log_bad": 3.7779,
+      "log_good": 3.7123
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3155,
+      "good": 1.2616,
+      "ratio": 0.959,
+      "suggested_scalar": -0.0317,
+      "log_bad": 0.2742,
+      "log_good": 0.2324
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 27.0,
+      "good": 28.0,
+      "ratio": 1.037,
+      "suggested_scalar": 0.0276,
+      "log_bad": 3.2958,
+      "log_good": 3.3322
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8674,
+      "good": 0.841,
+      "ratio": 0.9696,
+      "suggested_scalar": -0.0234,
+      "log_bad": -0.1423,
+      "log_good": -0.1732
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9784,
+      "good": 0.9858,
+      "ratio": 1.0076,
+      "suggested_scalar": 0.0057,
+      "log_bad": -0.0218,
+      "log_good": -0.0143
+    },
+    "halstead.mean_length": {
+      "bad": 322.0,
+      "good": 334.0,
+      "ratio": 1.0373,
+      "suggested_scalar": 0.0277,
+      "log_bad": 5.7746,
+      "log_good": 5.8111
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.5,
+      "good": 5.5,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7047,
+      "log_good": 1.7047
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6439,
+      "good": 6.6294,
+      "ratio": 0.9978,
+      "suggested_scalar": -0.0017,
+      "log_bad": 1.8937,
+      "log_good": 1.8915
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0987,
+      "good": 0.1046,
+      "ratio": 1.0598,
+      "suggested_scalar": 0.044,
+      "log_bad": -2.3157,
+      "log_good": -2.2576
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.0,
+      "good": 25.6667,
+      "ratio": 1.0267,
+      "suggested_scalar": 0.0199,
+      "log_bad": 3.2189,
+      "log_good": 3.2452
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 71.0,
+      "good": 68.0,
+      "ratio": 0.9577,
+      "suggested_scalar": -0.0327,
+      "log_bad": 4.2627,
+      "log_good": 4.2195
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7768,
+      "good": 0.7444,
+      "ratio": 0.9583,
+      "suggested_scalar": -0.0323,
+      "log_bad": -0.2526,
+      "log_good": -0.2952
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 36.0,
+      "good": 38.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.041,
+      "log_bad": 3.5835,
+      "log_good": 3.6376
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.uses_when_for_three_or_more_branches": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0261,
+      "good": 0.0291,
+      "ratio": 1.1149,
+      "suggested_scalar": 0.0629,
+      "log_bad": -3.6458,
+      "log_good": -3.537
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6,
+      "good": 1.6,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.47,
+      "log_good": 0.47
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8302,
+      "good": 0.9211,
+      "ratio": 1.1095,
+      "suggested_scalar": 0.0601,
+      "log_bad": -0.1861,
+      "log_good": -0.0822
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0261,
+      "good": 0.0291,
+      "ratio": 1.1149,
+      "suggested_scalar": 0.0629,
+      "log_bad": -3.6458,
+      "log_good": -3.537
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8265,
+      "good": 4.7929,
+      "ratio": 0.993,
+      "suggested_scalar": -0.004,
+      "log_bad": 1.5741,
+      "log_good": 1.5671
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 94.0,
+      "good": 95.0,
+      "ratio": 1.0106,
+      "suggested_scalar": 0.0061,
+      "log_bad": 4.5433,
+      "log_good": 4.5539
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4116,
+      "good": 0.4282,
+      "ratio": 1.0403,
+      "suggested_scalar": 0.0229,
+      "log_bad": -0.8877,
+      "log_good": -0.8482
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 13.0,
+      "good": 14.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0429,
+      "log_bad": 2.5649,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.545,
+      "good": 0.574,
+      "ratio": 1.0532,
+      "suggested_scalar": 0.03,
+      "log_bad": -0.607,
+      "log_good": -0.5551
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 7.0189,
+      "good": 5.1579,
+      "ratio": 0.7349,
+      "suggested_scalar": -0.1782,
+      "log_bad": 1.9486,
+      "log_good": 1.6405
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 460.0,
+      "good": 413.0,
+      "ratio": 0.8978,
+      "suggested_scalar": -0.0623,
+      "log_bad": 6.1312,
+      "log_good": 6.0234
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1291,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0566,
+      "good": 0.1053,
+      "ratio": 1.8604,
+      "suggested_scalar": 0.3591,
+      "log_bad": -2.8717,
+      "log_good": -2.2509
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1203,
+      "good": 1.0526,
+      "ratio": 0.9396,
+      "suggested_scalar": -0.0361,
+      "log_bad": 0.1136,
+      "log_good": 0.0513
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 131.0,
+      "good": 133.0,
+      "ratio": 1.0153,
+      "suggested_scalar": 0.0088,
+      "log_bad": 4.8752,
+      "log_good": 4.8903
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 85.2256,
+      "good": 77.4614,
+      "ratio": 0.9089,
+      "suggested_scalar": -0.0553,
+      "log_bad": 4.4453,
+      "log_good": 4.3498
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6253,
+      "good": 0.5704,
+      "ratio": 0.9122,
+      "suggested_scalar": -0.0532,
+      "log_bad": -0.4695,
+      "log_good": -0.5614
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 12.1315,
+      "good": 11.5748,
+      "ratio": 0.9541,
+      "suggested_scalar": -0.0272,
+      "log_bad": 2.4958,
+      "log_good": 2.4488
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2287.0,
+      "good": 2199.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0227,
+      "log_bad": 7.735,
+      "log_good": 7.6958
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.6226,
+      "good": 0.3684,
+      "ratio": 0.5917,
+      "suggested_scalar": -0.3035,
+      "log_bad": -0.4739,
+      "log_good": -0.9986
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7925,
+      "good": 0.8947,
+      "ratio": 1.129,
+      "suggested_scalar": 0.0702,
+      "log_bad": -0.2326,
+      "log_good": -0.1113
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.6792,
+      "good": 10.8684,
+      "ratio": 1.2522,
+      "suggested_scalar": 0.1301,
+      "log_bad": 2.1609,
+      "log_good": 2.3859
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 15.0374,
+      "good": 9.1856,
+      "ratio": 0.6109,
+      "suggested_scalar": -0.2851,
+      "log_bad": 2.7105,
+      "log_good": 2.2176
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 49.0,
+      "good": 46.0,
+      "ratio": 0.9388,
+      "suggested_scalar": -0.0365,
+      "log_bad": 3.8918,
+      "log_good": 3.8286
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9325,
+      "good": 0.9445,
+      "ratio": 1.0129,
+      "suggested_scalar": 0.0074,
+      "log_bad": -0.0699,
+      "log_good": -0.0571
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 23.0,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.0257,
+      "log_bad": 3.091,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6965,
+      "good": 0.6753,
+      "ratio": 0.9696,
+      "suggested_scalar": -0.0179,
+      "log_bad": -0.3617,
+      "log_good": -0.3926
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4891,
+      "good": 0.4063,
+      "ratio": 0.8307,
+      "suggested_scalar": -0.1073,
+      "log_bad": -0.7152,
+      "log_good": -0.9007
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.2954,
+      "good": 3.0798,
+      "ratio": 0.9346,
+      "suggested_scalar": -0.0391,
+      "log_bad": 1.1925,
+      "log_good": 1.1249
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 458.0,
+      "good": 411.0,
+      "ratio": 0.8974,
+      "suggested_scalar": -0.0626,
+      "log_bad": 6.1269,
+      "log_good": 6.0186
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 16.0,
+      "good": 9.0,
+      "ratio": 0.5625,
+      "suggested_scalar": -0.3328,
+      "log_bad": 2.7726,
+      "log_good": 2.1972
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0217,
+      "good": 0.0242,
+      "ratio": 1.1152,
+      "suggested_scalar": 0.0631,
+      "log_bad": -3.8304,
+      "log_good": -3.7214
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.2095,
+      "good": 6.2095,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8261,
+      "log_good": 1.8261
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 66.0,
+      "good": 71.0,
+      "ratio": 1.0758,
+      "suggested_scalar": 0.0422,
+      "log_bad": 4.1897,
+      "log_good": 4.2627
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4406,
+      "good": 1.4213,
+      "ratio": 0.9866,
+      "suggested_scalar": -0.0078,
+      "log_bad": 0.3651,
+      "log_good": 0.3516
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0076,
+      "good": 0.0075,
+      "ratio": 0.9868,
+      "suggested_scalar": -0.0077,
+      "log_bad": -4.8796,
+      "log_good": -4.8929
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4397,
+      "good": 5.5963,
+      "ratio": 1.0288,
+      "suggested_scalar": 0.0164,
+      "log_bad": 1.6937,
+      "log_good": 1.7221
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7773,
+      "good": 0.7719,
+      "ratio": 0.9931,
+      "suggested_scalar": -0.004,
+      "log_bad": -0.2519,
+      "log_good": -0.2589
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1452,
+      "good": 0.1915,
+      "ratio": 1.3189,
+      "suggested_scalar": 0.1601,
+      "log_bad": -1.9296,
+      "log_good": -1.6529
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.483,
+      "good": 3.4022,
+      "ratio": 0.9768,
+      "suggested_scalar": -0.0136,
+      "log_bad": 1.2479,
+      "log_good": 1.2244
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 297.0,
+      "good": 304.0,
+      "ratio": 1.0236,
+      "suggested_scalar": 0.0135,
+      "log_bad": 5.6937,
+      "log_good": 5.717
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.946,
+      "good": 0.8256,
+      "ratio": 0.8727,
+      "suggested_scalar": -0.0787,
+      "log_bad": -0.0555,
+      "log_good": -0.1916
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 95.0,
+      "good": 96.0,
+      "ratio": 1.0105,
+      "suggested_scalar": 0.0061,
+      "log_bad": 4.5539,
+      "log_good": 4.5643
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1092.0,
+      "good": 1146.0,
+      "ratio": 1.0495,
+      "suggested_scalar": 0.0279,
+      "log_bad": 6.9958,
+      "log_good": 7.044
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 163.0,
+      "good": 165.0,
+      "ratio": 1.0123,
+      "suggested_scalar": 0.0071,
+      "log_bad": 5.0938,
+      "log_good": 5.1059
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 0.0315,
+      "ratio": 0.0315,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -3.4578
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2043,
+      "good": 0.2107,
+      "ratio": 1.0313,
+      "suggested_scalar": 0.0178,
+      "log_bad": -1.5882,
+      "log_good": -1.5573
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 65.0,
+      "good": 67.0,
+      "ratio": 1.0308,
+      "suggested_scalar": 0.0175,
+      "log_bad": 4.1744,
+      "log_good": 4.2047
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 95.0,
+      "good": 96.0,
+      "ratio": 1.0105,
+      "suggested_scalar": 0.0061,
+      "log_bad": 4.5539,
+      "log_good": 4.5643
+    },
+    "brevity.mean_sample_size": {
+      "bad": 95.0,
+      "good": 96.0,
+      "ratio": 1.0105,
+      "suggested_scalar": 0.0061,
+      "log_bad": 4.5539,
+      "log_good": 4.5643
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 460.0,
+      "good": 413.0,
+      "ratio": 0.8978,
+      "suggested_scalar": -0.0623,
+      "log_bad": 6.1312,
+      "log_good": 6.0234
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 249.0,
+      "good": 230.0,
+      "ratio": 0.9237,
+      "suggested_scalar": -0.0459,
+      "log_bad": 5.5175,
+      "log_good": 5.4381
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 237.0,
+      "good": 244.0,
+      "ratio": 1.0295,
+      "suggested_scalar": 0.0168,
+      "log_bad": 5.4681,
+      "log_good": 5.4972
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0391,
+      "good": 0.0436,
+      "ratio": 1.1151,
+      "suggested_scalar": 0.063,
+      "log_bad": -3.2416,
+      "log_good": -3.1327
+    },
+    "heaps.mean_k": {
+      "bad": 3.4712,
+      "good": 3.0517,
+      "ratio": 0.8791,
+      "suggested_scalar": -0.0745,
+      "log_bad": 1.2445,
+      "log_good": 1.1157
+    },
+    "halstead.mean_effort": {
+      "bad": 70677.4943,
+      "good": 65274.9373,
+      "ratio": 0.9236,
+      "suggested_scalar": -0.046,
+      "log_bad": 11.1659,
+      "log_good": 11.0864
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.828,
+      "good": 0.8499,
+      "ratio": 1.0264,
+      "suggested_scalar": 0.0151,
+      "log_bad": -0.1887,
+      "log_good": -0.1626
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 72.0,
+      "good": 72.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2767,
+      "log_good": 4.2767
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 270.0,
+      "good": 212.0,
+      "ratio": 0.7852,
+      "suggested_scalar": -0.1399,
+      "log_bad": 5.5984,
+      "log_good": 5.3566
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3588,
+      "good": 0.3609,
+      "ratio": 1.0059,
+      "suggested_scalar": 0.0034,
+      "log_bad": -1.025,
+      "log_good": -1.0192
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.3359,
+      "good": 8.6165,
+      "ratio": 1.0337,
+      "suggested_scalar": 0.0191,
+      "log_bad": 2.1206,
+      "log_good": 2.1537
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1452,
+      "good": 0.1915,
+      "ratio": 1.3189,
+      "suggested_scalar": 0.1601,
+      "log_bad": -1.9296,
+      "log_good": -1.6529
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.4667,
+      "good": 5.5034,
+      "ratio": 1.2321,
+      "suggested_scalar": 0.1207,
+      "log_bad": 1.4966,
+      "log_good": 1.7054
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 459.0,
+      "good": 412.0,
+      "ratio": 0.8976,
+      "suggested_scalar": -0.0625,
+      "log_bad": 6.1291,
+      "log_good": 6.021
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 63.0,
+      "good": 60.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0282,
+      "log_bad": 4.1431,
+      "log_good": 4.0943
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3926.5275,
+      "good": 3626.3854,
+      "ratio": 0.9236,
+      "suggested_scalar": -0.046,
+      "log_bad": 8.2755,
+      "log_good": 8.196
+    },
+    "readability.mean_total_lines": {
+      "bad": 53.0,
+      "good": 38.0,
+      "ratio": 0.717,
+      "suggested_scalar": -0.1924,
+      "log_bad": 3.9703,
+      "log_good": 3.6376
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 8.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.2345,
+      "log_bad": 2.4849,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2838.137,
+      "good": 2476.8356,
+      "ratio": 0.8727,
+      "suggested_scalar": -0.0788,
+      "log_bad": 7.9509,
+      "log_good": 7.8147
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 694.0,
+      "good": 714.0,
+      "ratio": 1.0288,
+      "suggested_scalar": 0.0164,
+      "log_bad": 6.5425,
+      "log_good": 6.5709
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 41.8679,
+      "good": 56.4211,
+      "ratio": 1.3476,
+      "suggested_scalar": 0.1726,
+      "log_bad": 3.7345,
+      "log_good": 4.0328
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3333,
+      "good": 1.3988,
+      "ratio": 1.0491,
+      "suggested_scalar": 0.0277,
+      "log_bad": 0.2877,
+      "log_good": 0.3356
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1291,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 36.0,
+      "good": 38.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.0313,
+      "log_bad": 3.5835,
+      "log_good": 3.6376
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1664,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7879,
+      "good": 0.8026,
+      "ratio": 1.0187,
+      "suggested_scalar": 0.0107,
+      "log_bad": -0.2384,
+      "log_good": -0.2199
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9464,
+      "good": 0.9668,
+      "ratio": 1.0216,
+      "suggested_scalar": 0.0123,
+      "log_bad": -0.0551,
+      "log_good": -0.0338
+    },
+    "halstead.mean_length": {
+      "bad": 433.0,
+      "good": 377.0,
+      "ratio": 0.8707,
+      "suggested_scalar": -0.0801,
+      "log_bad": 6.0707,
+      "log_good": 5.9322
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.0,
+      "good": 7.0,
+      "ratio": 0.7,
+      "suggested_scalar": -0.2063,
+      "log_bad": 2.3026,
+      "log_good": 1.9459
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5699,
+      "good": 6.585,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0013,
+      "log_bad": 1.8825,
+      "log_good": 1.8848
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1092,
+      "good": 0.105,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0227,
+      "log_bad": -2.2146,
+      "log_good": -2.2538
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 24.9028,
+      "good": 26.3542,
+      "ratio": 1.0583,
+      "suggested_scalar": 0.0328,
+      "log_bad": 3.215,
+      "log_good": 3.2716
+    },
+    "branching.mean_branch_count": {
+      "bad": 33.0,
+      "good": 14.0,
+      "ratio": 0.4242,
+      "suggested_scalar": -0.496,
+      "log_bad": 3.4965,
+      "log_good": 2.6391
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 47.0,
+      "good": 48.0,
+      "ratio": 1.0213,
+      "suggested_scalar": 0.0122,
+      "log_bad": 3.8501,
+      "log_good": 3.8712
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7257,
+      "good": 0.7254,
+      "ratio": 0.9996,
+      "suggested_scalar": -0.0002,
+      "log_bad": -0.3206,
+      "log_good": -0.321
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 53.0,
+      "good": 38.0,
+      "ratio": 0.717,
+      "suggested_scalar": -0.1924,
+      "log_bad": 3.9703,
+      "log_good": 3.6376
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "dependencies.no_wildcard_imports": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 45.0,
+      "good": 47.0,
+      "ratio": 1.0444,
+      "suggested_scalar": 0.0355,
+      "log_bad": 3.8067,
+      "log_good": 3.8501
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0133,
+      "good": 0.0087,
+      "ratio": 0.6541,
+      "suggested_scalar": -0.3463,
+      "log_bad": -4.32,
+      "log_good": -4.7444
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8548,
+      "good": 0.85,
+      "ratio": 0.9944,
+      "suggested_scalar": -0.0046,
+      "log_bad": -0.1569,
+      "log_good": -0.1625
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0133,
+      "good": 0.0087,
+      "ratio": 0.6541,
+      "suggested_scalar": -0.3463,
+      "log_bad": -4.32,
+      "log_good": -4.7444
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8497,
+      "good": 4.8538,
+      "ratio": 1.0008,
+      "suggested_scalar": 0.0007,
+      "log_bad": 1.5789,
+      "log_good": 1.5798
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 108.0,
+      "good": 105.0,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.023,
+      "log_bad": 4.6821,
+      "log_good": 4.654
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3653,
+      "good": 0.3749,
+      "ratio": 1.0263,
+      "suggested_scalar": 0.0212,
+      "log_bad": -1.007,
+      "log_good": -0.9811
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.0,
+      "good": 19.0,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.0817,
+      "log_bad": 3.0445,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5365,
+      "good": 0.5023,
+      "ratio": 0.9363,
+      "suggested_scalar": -0.0537,
+      "log_bad": -0.6227,
+      "log_good": -0.6886
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.8065,
+      "good": 2.7667,
+      "ratio": 0.9858,
+      "suggested_scalar": -0.0117,
+      "log_bad": 1.0319,
+      "log_good": 1.0177
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 679.0,
+      "good": 690.0,
+      "ratio": 1.0162,
+      "suggested_scalar": 0.0131,
+      "log_bad": 6.5206,
+      "log_good": 6.5367
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.186,
+      "good": 1.1474,
+      "ratio": 0.9675,
+      "suggested_scalar": -0.027,
+      "log_bad": 0.1706,
+      "log_good": 0.1375
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 231.0,
+      "good": 235.0,
+      "ratio": 1.0173,
+      "suggested_scalar": 0.014,
+      "log_bad": 5.4424,
+      "log_good": 5.4596
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 93.9023,
+      "good": 92.2865,
+      "ratio": 0.9828,
+      "suggested_scalar": -0.0142,
+      "log_bad": 4.5423,
+      "log_good": 4.5249
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7139,
+      "good": 0.701,
+      "ratio": 0.9819,
+      "suggested_scalar": -0.0149,
+      "log_bad": -0.337,
+      "log_good": -0.3552
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 15.7958,
+      "good": 17.8102,
+      "ratio": 1.1275,
+      "suggested_scalar": 0.0979,
+      "log_bad": 2.7597,
+      "log_good": 2.8798
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2324.0,
+      "good": 2414.0,
+      "ratio": 1.0387,
+      "suggested_scalar": 0.031,
+      "log_bad": 7.751,
+      "log_good": 7.789
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0323,
+      "good": 0.0333,
+      "ratio": 1.031,
+      "suggested_scalar": 0.0249,
+      "log_bad": -3.4327,
+      "log_good": -3.4022
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8387,
+      "good": 0.8333,
+      "ratio": 0.9936,
+      "suggested_scalar": -0.0053,
+      "log_bad": -0.1759,
+      "log_good": -0.1824
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.9516,
+      "good": 11.5,
+      "ratio": 1.0501,
+      "suggested_scalar": 0.0399,
+      "log_bad": 2.3935,
+      "log_good": 2.4423
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.7367,
+      "good": 1.7456,
+      "ratio": 1.0051,
+      "suggested_scalar": 0.0042,
+      "log_bad": 0.552,
+      "log_good": 0.5571
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 171.0,
+      "good": 175.0,
+      "ratio": 1.0234,
+      "suggested_scalar": 0.0189,
+      "log_bad": 5.1417,
+      "log_good": 5.1648
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9631,
+      "good": 0.9614,
+      "ratio": 0.9982,
+      "suggested_scalar": -0.0014,
+      "log_bad": -0.0376,
+      "log_good": -0.0394
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 32.0,
+      "good": 32.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4657,
+      "log_good": 3.4657
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6674,
+      "good": 0.6665,
+      "ratio": 0.9987,
+      "suggested_scalar": -0.0011,
+      "log_bad": -0.4044,
+      "log_good": -0.4057
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4874,
+      "good": 0.4724,
+      "ratio": 0.9692,
+      "suggested_scalar": -0.0255,
+      "log_bad": -0.7187,
+      "log_good": -0.7499
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0065,
+      "good": 2.9988,
+      "ratio": 0.9974,
+      "suggested_scalar": -0.0021,
+      "log_bad": 1.1008,
+      "log_good": 1.0982
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 677.0,
+      "good": 688.0,
+      "ratio": 1.0162,
+      "suggested_scalar": 0.0132,
+      "log_bad": 6.5177,
+      "log_good": 6.5338
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0015,
+      "good": 0.0174,
+      "ratio": 11.6,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.5023,
+      "log_good": -4.0513
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.8826,
+      "ratio": 0.9959,
+      "suggested_scalar": -0.0034,
+      "log_bad": 1.7761,
+      "log_good": 1.772
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 59.0,
+      "good": 59.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0775,
+      "log_good": 4.0775
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8581,
+      "good": 0.8508,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.007,
+      "log_bad": -0.153,
+      "log_good": -0.1616
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.336,
+      "good": 5.3519,
+      "ratio": 1.003,
+      "suggested_scalar": 0.0024,
+      "log_bad": 1.6745,
+      "log_good": 1.6775
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.821,
+      "good": 0.8251,
+      "ratio": 1.005,
+      "suggested_scalar": 0.0041,
+      "log_bad": -0.1972,
+      "log_good": -0.1923
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1622,
+      "good": 0.1781,
+      "ratio": 1.098,
+      "suggested_scalar": 0.0763,
+      "log_bad": -1.8189,
+      "log_good": -1.7254
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.9744,
+      "good": 4.2202,
+      "ratio": 1.0618,
+      "suggested_scalar": 0.049,
+      "log_bad": 1.3799,
+      "log_good": 1.4399
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 1.1312,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 410.0,
+      "good": 424.0,
+      "ratio": 1.0341,
+      "suggested_scalar": 0.0274,
+      "log_bad": 6.0162,
+      "log_good": 6.0497
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 19.0,
+      "good": 17.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.0908,
+      "log_bad": 2.9444,
+      "log_good": 2.8332
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.432,
+      "good": 1.4637,
+      "ratio": 1.0221,
+      "suggested_scalar": 0.0179,
+      "log_bad": 0.3591,
+      "log_good": 0.381
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 106.0,
+      "good": 105.0,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.0077,
+      "log_bad": 4.6634,
+      "log_good": 4.654
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1333.0,
+      "good": 1422.0,
+      "ratio": 1.0668,
+      "suggested_scalar": 0.0527,
+      "log_bad": 7.1952,
+      "log_good": 7.2598
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 237.0,
+      "good": 245.0,
+      "ratio": 1.0338,
+      "suggested_scalar": 0.0271,
+      "log_bad": 5.4681,
+      "log_good": 5.5013
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0059,
+      "good": 0.0058,
+      "ratio": 0.9831,
+      "suggested_scalar": -0.0139,
+      "log_bad": -5.1328,
+      "log_good": -5.1499
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.299,
+      "good": 0.3043,
+      "ratio": 1.0177,
+      "suggested_scalar": 0.0143,
+      "log_bad": -1.2073,
+      "log_good": -1.1897
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 92.0,
+      "good": 91.0,
+      "ratio": 0.9891,
+      "suggested_scalar": -0.0089,
+      "log_bad": 4.5218,
+      "log_good": 4.5109
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 106.0,
+      "good": 105.0,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.0077,
+      "log_bad": 4.6634,
+      "log_good": 4.654
+    },
+    "brevity.mean_sample_size": {
+      "bad": 106.0,
+      "good": 105.0,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.0077,
+      "log_bad": 4.6634,
+      "log_good": 4.654
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 679.0,
+      "good": 690.0,
+      "ratio": 1.0162,
+      "suggested_scalar": 0.0131,
+      "log_bad": 6.5206,
+      "log_good": 6.5367
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 391.0,
+      "good": 393.0,
+      "ratio": 1.0051,
+      "suggested_scalar": 0.0042,
+      "log_bad": 5.9687,
+      "log_good": 5.9738
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 286.0,
+      "good": 297.0,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0308,
+      "log_bad": 5.656,
+      "log_good": 5.6937
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0015,
+      "good": 0.0058,
+      "ratio": 3.8667,
+      "suggested_scalar": 1.1035,
+      "log_bad": -6.5023,
+      "log_good": -5.1499
+    },
+    "heaps.mean_k": {
+      "bad": 3.1692,
+      "good": 4.0487,
+      "ratio": 1.2775,
+      "suggested_scalar": 0.1998,
+      "log_bad": 1.1535,
+      "log_good": 1.3984
+    },
+    "halstead.mean_effort": {
+      "bad": 214353.2006,
+      "good": 235796.9445,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0778,
+      "log_bad": 12.2754,
+      "log_good": 12.3707
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.7931,
+      "good": 0.7971,
+      "ratio": 1.005,
+      "suggested_scalar": 0.0041,
+      "log_bad": -0.2318,
+      "log_good": -0.2268
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 76.0,
+      "good": 73.0,
+      "ratio": 0.9605,
+      "suggested_scalar": -0.0329,
+      "log_bad": 4.3307,
+      "log_good": 4.2905
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 399.0,
+      "good": 409.0,
+      "ratio": 1.0251,
+      "suggested_scalar": 0.0202,
+      "log_bad": 5.989,
+      "log_good": 6.0137
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.2944,
+      "good": 0.2894,
+      "ratio": 0.983,
+      "suggested_scalar": -0.014,
+      "log_bad": -1.2228,
+      "log_good": -1.2399
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.7706,
+      "good": 6.0511,
+      "ratio": 1.0486,
+      "suggested_scalar": 0.0387,
+      "log_bad": 1.7528,
+      "log_good": 1.8002
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1622,
+      "good": 0.1781,
+      "ratio": 1.098,
+      "suggested_scalar": 0.0763,
+      "log_bad": -1.8189,
+      "log_good": -1.7254
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.7842,
+      "good": 5.9937,
+      "ratio": 1.0362,
+      "suggested_scalar": 0.029,
+      "log_bad": 1.7551,
+      "log_good": 1.7907
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 678.0,
+      "good": 689.0,
+      "ratio": 1.0162,
+      "suggested_scalar": 0.0131,
+      "log_bad": 6.5191,
+      "log_good": 6.5352
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.5656,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 63.0,
+      "good": 61.0,
+      "ratio": 0.9683,
+      "suggested_scalar": -0.0263,
+      "log_bad": 4.1431,
+      "log_good": 4.1109
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 11908.5111,
+      "good": 13099.8303,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0778,
+      "log_bad": 9.385,
+      "log_good": 9.4804
+    },
+    "readability.mean_total_lines": {
+      "bad": 62.0,
+      "good": 60.0,
+      "ratio": 0.9677,
+      "suggested_scalar": -0.0268,
+      "log_bad": 4.1271,
+      "log_good": 4.0943
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 4296.1085,
+      "good": 4391.1166,
+      "ratio": 1.0221,
+      "suggested_scalar": 0.0178,
+      "log_bad": 8.3655,
+      "log_good": 8.3873
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 773.0,
+      "good": 805.0,
+      "ratio": 1.0414,
+      "suggested_scalar": 0.0331,
+      "log_bad": 6.6503,
+      "log_good": 6.6908
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 36.2903,
+      "good": 39.0167,
+      "ratio": 1.0751,
+      "suggested_scalar": 0.0591,
+      "log_bad": 3.5916,
+      "log_good": 3.664
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2035,
+      "good": 1.216,
+      "ratio": 1.0104,
+      "suggested_scalar": 0.0084,
+      "log_bad": 0.1852,
+      "log_good": 0.1956
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 60.0,
+      "good": 59.0,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0137,
+      "log_bad": 4.0943,
+      "log_good": 4.0775
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8463,
+      "good": 0.8561,
+      "ratio": 1.0116,
+      "suggested_scalar": 0.0094,
+      "log_bad": -0.1669,
+      "log_good": -0.1554
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9925,
+      "good": 0.9738,
+      "ratio": 0.9812,
+      "suggested_scalar": -0.0155,
+      "log_bad": -0.0075,
+      "log_good": -0.0265
+    },
+    "halstead.mean_length": {
+      "bad": 636.0,
+      "good": 654.0,
+      "ratio": 1.0283,
+      "suggested_scalar": 0.0228,
+      "log_bad": 6.4552,
+      "log_good": 6.4831
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.3,
+      "good": 6.1,
+      "ratio": 0.9683,
+      "suggested_scalar": -0.0263,
+      "log_bad": 1.8405,
+      "log_good": 1.8083
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7279,
+      "good": 6.7142,
+      "ratio": 0.998,
+      "suggested_scalar": -0.0017,
+      "log_bad": 1.9063,
+      "log_good": 1.9042
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1682,
+      "good": 0.1628,
+      "ratio": 0.9679,
+      "suggested_scalar": -0.0266,
+      "log_bad": -1.7826,
+      "log_good": -1.8152
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 49.8947,
+      "good": 53.6986,
+      "ratio": 1.0762,
+      "suggested_scalar": 0.06,
+      "log_bad": 3.9099,
+      "log_good": 3.9834
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 68.0,
+      "good": 68.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2195,
+      "log_good": 4.2195
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6783,
+      "good": 0.6936,
+      "ratio": 1.0226,
+      "suggested_scalar": 0.0182,
+      "log_bad": -0.3882,
+      "log_good": -0.3659
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 62.0,
+      "good": 60.0,
+      "ratio": 0.9677,
+      "suggested_scalar": -0.0268,
+      "log_bad": 4.1271,
+      "log_good": 4.0943
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.shares_memory_by_communicating": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 0.4852,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 12.0,
+      "good": 16.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1007,
+      "log_bad": 2.4849,
+      "log_good": 2.7726
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0041,
+      "good": 1.0,
+      "ratio": 243.9024,
+      "suggested_scalar": 1.924,
+      "log_bad": -5.4968,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.75,
+      "good": 0.8,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.0226,
+      "log_bad": -0.2877,
+      "log_good": -0.2231
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7576,
+      "good": 0.8542,
+      "ratio": 1.1275,
+      "suggested_scalar": 0.042,
+      "log_bad": -0.2776,
+      "log_good": -0.1576
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0041,
+      "good": 1.0,
+      "ratio": 243.9024,
+      "suggested_scalar": 1.924,
+      "log_bad": -5.4968,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7994,
+      "good": 4.8113,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0009,
+      "log_bad": 1.5685,
+      "log_good": 1.571
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 74.0,
+      "good": 85.0,
+      "ratio": 1.1486,
+      "suggested_scalar": 0.0485,
+      "log_bad": 4.3041,
+      "log_good": 4.4427
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4323,
+      "good": 0.4096,
+      "ratio": 0.9475,
+      "suggested_scalar": -0.0189,
+      "log_bad": -0.8386,
+      "log_good": -0.8926
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6498,
+      "good": 0.6043,
+      "ratio": 0.93,
+      "suggested_scalar": -0.0254,
+      "log_bad": -0.4311,
+      "log_good": -0.5037
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.4848,
+      "good": 0.875,
+      "ratio": 1.8049,
+      "suggested_scalar": 0.2067,
+      "log_bad": -0.724,
+      "log_good": -0.1335
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 242.0,
+      "good": 305.0,
+      "ratio": 1.2603,
+      "suggested_scalar": 0.081,
+      "log_bad": 5.4889,
+      "log_good": 5.7203
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2121,
+      "good": 0.1042,
+      "ratio": 0.4913,
+      "suggested_scalar": -0.2488,
+      "log_bad": -1.5507,
+      "log_good": -2.2614
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.881,
+      "good": 0.9389,
+      "ratio": 1.0657,
+      "suggested_scalar": 0.0223,
+      "log_bad": -0.1267,
+      "log_good": -0.063
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 112.0,
+      "good": 123.0,
+      "ratio": 1.0982,
+      "suggested_scalar": 0.0328,
+      "log_bad": 4.7185,
+      "log_good": 4.8122
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 109.2743,
+      "good": 108.6933,
+      "ratio": 0.9947,
+      "suggested_scalar": -0.0019,
+      "log_bad": 4.6939,
+      "log_good": 4.6885
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5809,
+      "good": 0.4901,
+      "ratio": 0.8437,
+      "suggested_scalar": -0.0595,
+      "log_bad": -0.5432,
+      "log_good": -0.7131
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.5796,
+      "good": 7.8538,
+      "ratio": 0.8198,
+      "suggested_scalar": -0.0695,
+      "log_bad": 2.2596,
+      "log_good": 2.061
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 952.0,
+      "good": 1173.0,
+      "ratio": 1.2321,
+      "suggested_scalar": 0.0731,
+      "log_bad": 6.8586,
+      "log_good": 7.0673
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0606,
+      "good": 0.1458,
+      "ratio": 2.4059,
+      "suggested_scalar": 0.3073,
+      "log_bad": -2.8035,
+      "log_good": -1.9255
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7273,
+      "good": 0.8125,
+      "ratio": 1.1171,
+      "suggested_scalar": 0.0388,
+      "log_bad": -0.3184,
+      "log_good": -0.2076
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.3333,
+      "good": 6.3542,
+      "ratio": 0.8665,
+      "suggested_scalar": -0.0502,
+      "log_bad": 1.9924,
+      "log_good": 1.8491
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.3104,
+      "good": 0.8177,
+      "ratio": 2.6343,
+      "suggested_scalar": 0.339,
+      "log_bad": -1.1699,
+      "log_good": -0.2013
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 88.0,
+      "good": 102.0,
+      "ratio": 1.1591,
+      "suggested_scalar": 0.0517,
+      "log_bad": 4.4773,
+      "log_good": 4.625
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.947,
+      "good": 0.8987,
+      "ratio": 0.949,
+      "suggested_scalar": -0.0183,
+      "log_bad": -0.0545,
+      "log_good": -0.1068
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 26.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0585,
+      "log_bad": 3.091,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5536,
+      "good": 0.5405,
+      "ratio": 0.9763,
+      "suggested_scalar": -0.0084,
+      "log_bad": -0.5913,
+      "log_good": -0.6153
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4417,
+      "good": 0.2211,
+      "ratio": 0.5006,
+      "suggested_scalar": -0.2422,
+      "log_bad": -0.8171,
+      "log_good": -1.5091
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.24,
+      "good": 2.1763,
+      "ratio": 0.9716,
+      "suggested_scalar": -0.0101,
+      "log_bad": 0.8065,
+      "log_good": 0.7776
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 240.0,
+      "good": 303.0,
+      "ratio": 1.2625,
+      "suggested_scalar": 0.0816,
+      "log_bad": 5.4806,
+      "log_good": 5.7137
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 8.0,
+      "good": 15.0,
+      "ratio": 1.875,
+      "suggested_scalar": 0.22,
+      "log_bad": 2.0794,
+      "log_good": 2.7081
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0041,
+      "good": 0.0262,
+      "ratio": 6.3902,
+      "suggested_scalar": 0.6492,
+      "log_bad": -5.4968,
+      "log_good": -3.642
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7549,
+      "good": 5.7279,
+      "ratio": 0.9953,
+      "suggested_scalar": -0.0016,
+      "log_bad": 1.7501,
+      "log_good": 1.7453
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 24.0,
+      "good": 17.0,
+      "ratio": 0.7083,
+      "suggested_scalar": -0.1207,
+      "log_bad": 3.1781,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7496,
+      "good": 0.7793,
+      "ratio": 1.0396,
+      "suggested_scalar": 0.0136,
+      "log_bad": -0.2882,
+      "log_good": -0.2494
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5555,
+      "good": 5.7487,
+      "ratio": 1.0348,
+      "suggested_scalar": 0.012,
+      "log_bad": 1.7148,
+      "log_good": 1.749
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.834,
+      "good": 0.84,
+      "ratio": 1.0072,
+      "suggested_scalar": 0.0025,
+      "log_bad": -0.1815,
+      "log_good": -0.1744
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1538,
+      "good": 0.1273,
+      "ratio": 0.8277,
+      "suggested_scalar": -0.0662,
+      "log_bad": -1.8721,
+      "log_good": -2.0612
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.0951,
+      "good": 2.8025,
+      "ratio": 0.9055,
+      "suggested_scalar": -0.0348,
+      "log_bad": 1.1298,
+      "log_good": 1.0305
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 173.0,
+      "good": 262.0,
+      "ratio": 1.5145,
+      "suggested_scalar": 0.1453,
+      "log_bad": 5.1533,
+      "log_good": 5.5683
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2426,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.4947,
+      "good": 0.6409,
+      "ratio": 1.2955,
+      "suggested_scalar": 0.0906,
+      "log_bad": -0.7038,
+      "log_good": -0.4449
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 75.0,
+      "good": 85.0,
+      "ratio": 1.1333,
+      "suggested_scalar": 0.0438,
+      "log_bad": 4.3175,
+      "log_good": 4.4427
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 563.0,
+      "good": 604.0,
+      "ratio": 1.0728,
+      "suggested_scalar": 0.0246,
+      "log_bad": 6.3333,
+      "log_good": 6.4036
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 124.0,
+      "good": 149.0,
+      "ratio": 1.2016,
+      "suggested_scalar": 0.0643,
+      "log_bad": 4.8203,
+      "log_good": 5.0039
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2355,
+      "good": 0.1934,
+      "ratio": 0.8212,
+      "suggested_scalar": -0.0689,
+      "log_bad": -1.446,
+      "log_good": -1.643
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 47.0,
+      "good": 52.0,
+      "ratio": 1.1064,
+      "suggested_scalar": 0.0354,
+      "log_bad": 3.8501,
+      "log_good": 3.9512
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0781,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 75.0,
+      "good": 85.0,
+      "ratio": 1.1333,
+      "suggested_scalar": 0.0438,
+      "log_bad": 4.3175,
+      "log_good": 4.4427
+    },
+    "brevity.mean_sample_size": {
+      "bad": 75.0,
+      "good": 85.0,
+      "ratio": 1.1333,
+      "suggested_scalar": 0.0438,
+      "log_bad": 4.3175,
+      "log_good": 4.4427
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 242.0,
+      "good": 305.0,
+      "ratio": 1.2603,
+      "suggested_scalar": 0.081,
+      "log_bad": 5.4889,
+      "log_good": 5.7203
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 104.0,
+      "good": 136.0,
+      "ratio": 1.3077,
+      "suggested_scalar": 0.0939,
+      "log_bad": 4.6444,
+      "log_good": 4.9127
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 148.0,
+      "good": 207.0,
+      "ratio": 1.3986,
+      "suggested_scalar": 0.1174,
+      "log_bad": 4.9972,
+      "log_good": 5.3327
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0033,
+      "ratio": 0.0033,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.7138
+    },
+    "heaps.mean_k": {
+      "bad": 2.5241,
+      "good": 3.0019,
+      "ratio": 1.1893,
+      "suggested_scalar": 0.0607,
+      "log_bad": 0.9259,
+      "log_good": 1.0992
+    },
+    "halstead.mean_effort": {
+      "bad": 38928.0184,
+      "good": 63127.069,
+      "ratio": 1.6216,
+      "suggested_scalar": 0.1692,
+      "log_bad": 10.5695,
+      "log_good": 11.0529
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8919,
+      "good": 0.8969,
+      "ratio": 1.0056,
+      "suggested_scalar": 0.002,
+      "log_bad": -0.1144,
+      "log_good": -0.1088
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 52.0,
+      "good": 59.0,
+      "ratio": 1.1346,
+      "suggested_scalar": 0.0442,
+      "log_bad": 3.9512,
+      "log_good": 4.0775
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 115.0,
+      "good": 151.0,
+      "ratio": 1.313,
+      "suggested_scalar": 0.0953,
+      "log_bad": 4.7449,
+      "log_good": 5.0173
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4107,
+      "good": 0.4228,
+      "ratio": 1.0295,
+      "suggested_scalar": 0.0102,
+      "log_bad": -0.8899,
+      "log_good": -0.8609
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.0268,
+      "good": 4.9106,
+      "ratio": 0.9769,
+      "suggested_scalar": -0.0082,
+      "log_bad": 1.6148,
+      "log_good": 1.5914
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1538,
+      "good": 0.1273,
+      "ratio": 0.8277,
+      "suggested_scalar": -0.0662,
+      "log_bad": -1.8721,
+      "log_good": -2.0612
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.2232,
+      "good": 2.7812,
+      "ratio": 0.8629,
+      "suggested_scalar": -0.0516,
+      "log_bad": 1.1704,
+      "log_good": 1.0229
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 241.0,
+      "good": 304.0,
+      "ratio": 1.2614,
+      "suggested_scalar": 0.0813,
+      "log_bad": 5.4848,
+      "log_good": 5.717
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 39.0,
+      "good": 26.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1419,
+      "log_bad": 3.6636,
+      "log_good": 3.2581
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2162.6677,
+      "good": 3507.0594,
+      "ratio": 1.6216,
+      "suggested_scalar": 0.1692,
+      "log_bad": 7.6791,
+      "log_good": 8.1625
+    },
+    "readability.mean_total_lines": {
+      "bad": 33.0,
+      "good": 48.0,
+      "ratio": 1.4545,
+      "suggested_scalar": 0.1312,
+      "log_bad": 3.4965,
+      "log_good": 3.8712
+    },
+    "indentation.mean_max_depth": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1419,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "halstead.mean_volume": {
+      "bad": 1484.0594,
+      "good": 1922.8173,
+      "ratio": 1.2956,
+      "suggested_scalar": 0.0907,
+      "log_bad": 7.3025,
+      "log_good": 7.5615
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 425.0,
+      "good": 539.0,
+      "ratio": 1.2682,
+      "suggested_scalar": 0.0832,
+      "log_bad": 6.0521,
+      "log_good": 6.2897
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 27.6061,
+      "good": 23.2917,
+      "ratio": 0.8437,
+      "suggested_scalar": -0.0595,
+      "log_bad": 3.318,
+      "log_good": 3.1481
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0652,
+      "good": 1.0838,
+      "ratio": 1.0175,
+      "suggested_scalar": 0.0061,
+      "log_bad": 0.0632,
+      "log_good": 0.0805
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 23.0,
+      "good": 15.0,
+      "ratio": 0.6522,
+      "suggested_scalar": -0.1496,
+      "log_bad": 3.1355,
+      "log_good": 2.7081
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.1178,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7746,
+      "good": 0.9008,
+      "ratio": 1.1629,
+      "suggested_scalar": 0.0528,
+      "log_bad": -0.2554,
+      "log_good": -0.1045
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9342,
+      "good": 0.9452,
+      "ratio": 1.0118,
+      "suggested_scalar": 0.0041,
+      "log_bad": -0.0681,
+      "log_good": -0.0564
+    },
+    "halstead.mean_length": {
+      "bad": 239.0,
+      "good": 300.0,
+      "ratio": 1.2552,
+      "suggested_scalar": 0.0796,
+      "log_bad": 5.4765,
+      "log_good": 5.7038
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.0,
+      "good": 8.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.0467,
+      "log_bad": 1.9459,
+      "log_good": 2.0794
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2288,
+      "good": 6.4094,
+      "ratio": 1.029,
+      "suggested_scalar": 0.01,
+      "log_bad": 1.8292,
+      "log_good": 1.8578
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1095,
+      "good": 0.1159,
+      "ratio": 1.0584,
+      "suggested_scalar": 0.0199,
+      "log_bad": -2.2118,
+      "log_good": -2.155
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 26.2308,
+      "good": 32.8305,
+      "ratio": 1.2516,
+      "suggested_scalar": 0.0786,
+      "log_bad": 3.2669,
+      "log_good": 3.4914
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 7.0,
+      "ratio": 3.5,
+      "suggested_scalar": 0.4385,
+      "log_bad": 0.6931,
+      "log_good": 1.9459
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 46.0,
+      "good": 52.0,
+      "ratio": 1.1304,
+      "suggested_scalar": 0.0429,
+      "log_bad": 3.8286,
+      "log_good": 3.9512
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6824,
+      "good": 0.7488,
+      "ratio": 1.0973,
+      "suggested_scalar": 0.0325,
+      "log_bad": -0.3821,
+      "log_good": -0.2893
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 33.0,
+      "good": 48.0,
+      "ratio": 1.4545,
+      "suggested_scalar": 0.1312,
+      "log_bad": 3.4965,
+      "log_good": 3.8712
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_problematic_operator_overloads": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 3.0,
+      "good": 7.0,
+      "ratio": 2.3333,
+      "suggested_scalar": 0.255,
+      "log_bad": 1.0986,
+      "log_good": 1.9459
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0866,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0048,
+      "good": 1.0,
+      "ratio": 208.3333,
+      "suggested_scalar": 1.6069,
+      "log_bad": -5.3391,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9348,
+      "good": 0.875,
+      "ratio": 0.936,
+      "suggested_scalar": -0.0199,
+      "log_bad": -0.0674,
+      "log_good": -0.1335
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0048,
+      "good": 1.0,
+      "ratio": 208.3333,
+      "suggested_scalar": 1.6069,
+      "log_bad": -5.3391,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6609,
+      "good": 4.7365,
+      "ratio": 1.0162,
+      "suggested_scalar": 0.0048,
+      "log_bad": 1.5392,
+      "log_good": 1.5553
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 122.0,
+      "good": 113.0,
+      "ratio": 0.9262,
+      "suggested_scalar": -0.0231,
+      "log_bad": 4.804,
+      "log_good": 4.7274
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6026,
+      "good": 0.437,
+      "ratio": 0.7252,
+      "suggested_scalar": -0.0967,
+      "log_bad": -0.5065,
+      "log_good": -0.8278
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 22.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0287,
+      "log_bad": 2.9957,
+      "log_good": 3.091
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7908,
+      "good": 0.6126,
+      "ratio": 0.7747,
+      "suggested_scalar": -0.0768,
+      "log_bad": -0.2347,
+      "log_good": -0.49
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.6522,
+      "good": 3.4286,
+      "ratio": 0.9388,
+      "suggested_scalar": -0.019,
+      "log_bad": 1.2953,
+      "log_good": 1.2322
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 419.0,
+      "good": 571.0,
+      "ratio": 1.3628,
+      "suggested_scalar": 0.0932,
+      "log_bad": 6.0379,
+      "log_good": 6.3474
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0866,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 0.0013,
+      "ratio": 0.0013,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.6454
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2609,
+      "good": 0.1964,
+      "ratio": 0.7528,
+      "suggested_scalar": -0.0855,
+      "log_bad": -1.3436,
+      "log_good": -1.6276
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9302,
+      "good": 1.1102,
+      "ratio": 1.1935,
+      "suggested_scalar": 0.0532,
+      "log_bad": -0.0724,
+      "log_good": 0.1045
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 149.0,
+      "good": 160.0,
+      "ratio": 1.0738,
+      "suggested_scalar": 0.0214,
+      "log_bad": 5.0039,
+      "log_good": 5.0752
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 111.1642,
+      "good": 103.9698,
+      "ratio": 0.9353,
+      "suggested_scalar": -0.0201,
+      "log_bad": 4.711,
+      "log_good": 4.6441
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.433,
+      "good": 0.6526,
+      "ratio": 1.5072,
+      "suggested_scalar": 0.1235,
+      "log_bad": -0.837,
+      "log_good": -0.4268
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.9164,
+      "good": 9.7086,
+      "ratio": 1.2264,
+      "suggested_scalar": 0.0614,
+      "log_bad": 2.0689,
+      "log_good": 2.273
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1765.0,
+      "good": 2393.0,
+      "ratio": 1.3558,
+      "suggested_scalar": 0.0916,
+      "log_bad": 7.4759,
+      "log_good": 7.7803
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0652,
+      "good": 0.0893,
+      "ratio": 1.3696,
+      "suggested_scalar": 0.0947,
+      "log_bad": -2.7303,
+      "log_good": -2.4158
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.913,
+      "good": 0.875,
+      "ratio": 0.9584,
+      "suggested_scalar": -0.0128,
+      "log_bad": -0.091,
+      "log_good": -0.1335
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.7442,
+      "good": 10.7736,
+      "ratio": 1.1056,
+      "suggested_scalar": 0.0302,
+      "log_bad": 2.2767,
+      "log_good": 2.3771
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 16.0,
+      "good": 32.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2086,
+      "log_bad": 2.7726,
+      "log_good": 3.4657
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.4442,
+      "good": 9.3878,
+      "ratio": 1.7244,
+      "suggested_scalar": 0.164,
+      "log_bad": 1.6946,
+      "log_good": 2.2394
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 107.0,
+      "good": 91.0,
+      "ratio": 0.8505,
+      "suggested_scalar": -0.0487,
+      "log_bad": 4.6728,
+      "log_good": 4.5109
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9348,
+      "good": 0.9253,
+      "ratio": 0.9898,
+      "suggested_scalar": -0.0031,
+      "log_bad": -0.0674,
+      "log_good": -0.0776
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 32.0,
+      "ratio": 1.1034,
+      "suggested_scalar": 0.0296,
+      "log_bad": 3.3673,
+      "log_good": 3.4657
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5649,
+      "good": 0.649,
+      "ratio": 1.1489,
+      "suggested_scalar": 0.0418,
+      "log_bad": -0.5711,
+      "log_good": -0.4323
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.1847,
+      "good": 0.4464,
+      "ratio": 2.4169,
+      "suggested_scalar": 0.2656,
+      "log_bad": -1.689,
+      "log_good": -0.8065
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2982,
+      "good": 2.8488,
+      "ratio": 1.2396,
+      "suggested_scalar": 0.0646,
+      "log_bad": 0.8321,
+      "log_good": 1.0469
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 417.0,
+      "good": 569.0,
+      "ratio": 1.3645,
+      "suggested_scalar": 0.0935,
+      "log_bad": 6.0331,
+      "log_good": 6.3439
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0167,
+      "good": 0.0333,
+      "ratio": 1.994,
+      "suggested_scalar": 0.2077,
+      "log_bad": -4.0923,
+      "log_good": -3.4022
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 6.0224,
+      "ratio": 1.0155,
+      "suggested_scalar": 0.0046,
+      "log_bad": 1.7801,
+      "log_good": 1.7955
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 23.0,
+      "good": 30.0,
+      "ratio": 1.3043,
+      "suggested_scalar": 0.08,
+      "log_bad": 3.1355,
+      "log_good": 3.4012
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2183,
+      "good": 1.5778,
+      "ratio": 1.2951,
+      "suggested_scalar": 0.0778,
+      "log_bad": 0.1975,
+      "log_good": 0.456
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.1253,
+      "good": 5.824,
+      "ratio": 0.9508,
+      "suggested_scalar": -0.0152,
+      "log_bad": 1.8124,
+      "log_good": 1.762
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7859,
+      "good": 0.7865,
+      "ratio": 1.0008,
+      "suggested_scalar": 0.0002,
+      "log_bad": -0.2409,
+      "log_good": -0.2402
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2069,
+      "good": 0.2222,
+      "ratio": 1.0739,
+      "suggested_scalar": 0.0215,
+      "log_bad": -1.5755,
+      "log_good": -1.5042
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.8136,
+      "good": 3.1159,
+      "ratio": 1.1074,
+      "suggested_scalar": 0.0307,
+      "log_bad": 1.0345,
+      "log_good": 1.1365
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 366.0,
+      "good": 397.0,
+      "ratio": 1.0847,
+      "suggested_scalar": 0.0245,
+      "log_bad": 5.9026,
+      "log_good": 5.9839
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 9.0,
+      "good": 15.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.1537,
+      "log_bad": 2.1972,
+      "log_good": 2.7081
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9264,
+      "good": 1.2731,
+      "ratio": 1.3742,
+      "suggested_scalar": 0.0957,
+      "log_bad": -0.0764,
+      "log_good": 0.2415
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 125.0,
+      "good": 114.0,
+      "ratio": 0.912,
+      "suggested_scalar": -0.0277,
+      "log_bad": 4.8283,
+      "log_good": 4.7362
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 796.0,
+      "good": 950.0,
+      "ratio": 1.1935,
+      "suggested_scalar": 0.0532,
+      "log_bad": 6.6796,
+      "log_good": 6.8565
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 196.0,
+      "good": 243.0,
+      "ratio": 1.2398,
+      "suggested_scalar": 0.0647,
+      "log_bad": 5.2781,
+      "log_good": 5.4931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2029,
+      "good": 0.2277,
+      "ratio": 1.1222,
+      "suggested_scalar": 0.0347,
+      "log_bad": -1.595,
+      "log_good": -1.4797
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 57.0,
+      "good": 99.0,
+      "ratio": 1.7368,
+      "suggested_scalar": 0.1662,
+      "log_bad": 4.0431,
+      "log_good": 4.5951
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 125.0,
+      "good": 114.0,
+      "ratio": 0.912,
+      "suggested_scalar": -0.0277,
+      "log_bad": 4.8283,
+      "log_good": 4.7362
+    },
+    "brevity.mean_sample_size": {
+      "bad": 125.0,
+      "good": 114.0,
+      "ratio": 0.912,
+      "suggested_scalar": -0.0277,
+      "log_bad": 4.8283,
+      "log_good": 4.7362
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 419.0,
+      "good": 571.0,
+      "ratio": 1.3628,
+      "suggested_scalar": 0.0932,
+      "log_bad": 6.0379,
+      "log_good": 6.3474
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 202.0,
+      "good": 293.0,
+      "ratio": 1.4505,
+      "suggested_scalar": 0.1119,
+      "log_bad": 5.3083,
+      "log_good": 5.6802
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 294.0,
+      "good": 297.0,
+      "ratio": 1.0102,
+      "suggested_scalar": 0.0031,
+      "log_bad": 5.6836,
+      "log_good": 5.6937
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0018,
+      "ratio": 0.0018,
+      "suggested_scalar": -1.9021,
+      "log_bad": 0.0,
+      "log_good": -6.32
+    },
+    "heaps.mean_k": {
+      "bad": 1.1338,
+      "good": 2.4289,
+      "ratio": 2.1423,
+      "suggested_scalar": 0.2293,
+      "log_bad": 0.1256,
+      "log_good": 0.8874
+    },
+    "halstead.mean_effort": {
+      "bad": 84930.7458,
+      "good": 183326.4105,
+      "ratio": 2.1585,
+      "suggested_scalar": 0.2316,
+      "log_bad": 11.3496,
+      "log_good": 12.119
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8793,
+      "good": 0.8523,
+      "ratio": 0.9693,
+      "suggested_scalar": -0.0094,
+      "log_bad": -0.1286,
+      "log_good": -0.1598
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 93.0,
+      "good": 81.0,
+      "ratio": 0.871,
+      "suggested_scalar": -0.0416,
+      "log_bad": 4.5326,
+      "log_good": 4.3944
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 205.0,
+      "good": 317.0,
+      "ratio": 1.5463,
+      "suggested_scalar": 0.1312,
+      "log_bad": 5.323,
+      "log_good": 5.7589
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5101,
+      "good": 0.3937,
+      "ratio": 0.7718,
+      "suggested_scalar": -0.078,
+      "log_bad": -0.6731,
+      "log_good": -0.9322
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.3423,
+      "good": 5.9375,
+      "ratio": 1.1114,
+      "suggested_scalar": 0.0318,
+      "log_bad": 1.6757,
+      "log_good": 1.7813
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2069,
+      "good": 0.2222,
+      "ratio": 1.0739,
+      "suggested_scalar": 0.0215,
+      "log_bad": -1.5755,
+      "log_good": -1.5042
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.8977,
+      "good": 4.7426,
+      "ratio": 1.2168,
+      "suggested_scalar": 0.059,
+      "log_bad": 1.3604,
+      "log_good": 1.5566
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 418.0,
+      "good": 570.0,
+      "ratio": 1.3636,
+      "suggested_scalar": 0.0933,
+      "log_bad": 6.0355,
+      "log_good": 6.3456
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 4.0,
+      "good": 9.0,
+      "ratio": 2.25,
+      "suggested_scalar": 0.2441,
+      "log_bad": 1.3863,
+      "log_good": 2.1972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 26.0,
+      "good": 82.0,
+      "ratio": 3.1538,
+      "suggested_scalar": 0.3457,
+      "log_bad": 3.2581,
+      "log_good": 4.4067
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4718.3748,
+      "good": 10184.8006,
+      "ratio": 2.1585,
+      "suggested_scalar": 0.2316,
+      "log_bad": 8.4592,
+      "log_good": 9.2287
+    },
+    "readability.mean_total_lines": {
+      "bad": 43.0,
+      "good": 53.0,
+      "ratio": 1.2326,
+      "suggested_scalar": 0.0629,
+      "log_bad": 3.7612,
+      "log_good": 3.9703
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 16.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2086,
+      "log_bad": 2.0794,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2779.2257,
+      "good": 3819.3002,
+      "ratio": 1.3742,
+      "suggested_scalar": 0.0957,
+      "log_bad": 7.9299,
+      "log_good": 8.2478
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 768.0,
+      "good": 840.0,
+      "ratio": 1.0938,
+      "suggested_scalar": 0.027,
+      "log_bad": 6.6438,
+      "log_good": 6.7334
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 38.1395,
+      "good": 42.7547,
+      "ratio": 1.121,
+      "suggested_scalar": 0.0344,
+      "log_bad": 3.6413,
+      "log_good": 3.7555
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.014,
+      "good": 1.0866,
+      "ratio": 1.0716,
+      "suggested_scalar": 0.0208,
+      "log_bad": 0.0139,
+      "log_good": 0.0831
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0866,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 6.0,
+      "good": 12.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2086,
+      "log_bad": 1.7918,
+      "log_good": 2.4849
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 12.0,
+      "good": 11.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0262,
+      "log_bad": 2.4849,
+      "log_good": 2.3979
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.929,
+      "good": 0.7935,
+      "ratio": 0.8541,
+      "suggested_scalar": -0.0474,
+      "log_bad": -0.0736,
+      "log_good": -0.2313
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9891,
+      "good": 0.9505,
+      "ratio": 0.961,
+      "suggested_scalar": -0.012,
+      "log_bad": -0.011,
+      "log_good": -0.0508
+    },
+    "halstead.mean_length": {
+      "bad": 401.0,
+      "good": 560.0,
+      "ratio": 1.3965,
+      "suggested_scalar": 0.1005,
+      "log_bad": 5.994,
+      "log_good": 6.3279
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9658,
+      "good": 6.8329,
+      "ratio": 0.9809,
+      "suggested_scalar": -0.0058,
+      "log_bad": 1.941,
+      "log_good": 1.9217
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1155,
+      "good": 0.1226,
+      "ratio": 1.0615,
+      "suggested_scalar": 0.018,
+      "log_bad": -2.1585,
+      "log_good": -2.0988
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.5591,
+      "good": 48.0,
+      "ratio": 1.5707,
+      "suggested_scalar": 0.1359,
+      "log_bad": 3.4197,
+      "log_good": 3.8712
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.1537,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 76.0,
+      "good": 63.0,
+      "ratio": 0.8289,
+      "suggested_scalar": -0.0565,
+      "log_bad": 4.3307,
+      "log_good": 4.1431
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8061,
+      "good": 0.6667,
+      "ratio": 0.8271,
+      "suggested_scalar": -0.0571,
+      "log_bad": -0.2155,
+      "log_good": -0.4054
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 46.0,
+      "good": 56.0,
+      "ratio": 1.2174,
+      "suggested_scalar": 0.0592,
+      "log_bad": 3.8286,
+      "log_good": 4.0254
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 13.0,
+      "good": 22.0,
+      "ratio": 1.6923,
+      "suggested_scalar": 0.1583,
+      "log_bad": 2.5649,
+      "log_good": 3.091
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "variable_naming.name_contains_type_suffix": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 97.0,
+      "good": 36.0,
+      "ratio": 0.3711,
+      "suggested_scalar": -1.43,
+      "log_bad": 4.5747,
+      "log_good": 3.5835
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 42.6667,
+      "good": 42.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7534,
+      "log_good": 3.7534
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.6667,
+      "good": 2.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9808,
+      "log_good": 0.9808
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0082,
+      "good": 0.0082,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.8036,
+      "log_good": -4.8036
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.4377,
+      "good": 1.4377,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.363,
+      "log_good": 0.363
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9198,
+      "good": 0.9198,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0836,
+      "log_good": -0.0836
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0132,
+      "good": 0.0133,
+      "ratio": 1.0076,
+      "suggested_scalar": 0.0109,
+      "log_bad": -4.3275,
+      "log_good": -4.32
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7528,
+      "good": 4.7257,
+      "ratio": 0.9943,
+      "suggested_scalar": -0.0082,
+      "log_bad": 1.5587,
+      "log_good": 1.553
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 135.3333,
+      "good": 120.6667,
+      "ratio": 0.8916,
+      "suggested_scalar": -0.1655,
+      "log_bad": 4.9077,
+      "log_good": 4.793
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6082,
+      "good": 0.5171,
+      "ratio": 0.8502,
+      "suggested_scalar": -0.2341,
+      "log_bad": -0.4973,
+      "log_good": -0.6595
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.6667,
+      "good": 21.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0758,
+      "log_good": 3.0758
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6306,
+      "good": 0.5882,
+      "ratio": 0.9328,
+      "suggested_scalar": -0.1004,
+      "log_bad": -0.4611,
+      "log_good": -0.5307
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.1891,
+      "good": 3.1891,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.1597,
+      "log_good": 1.1597
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 611.3333,
+      "good": 605.3333,
+      "ratio": 0.9902,
+      "suggested_scalar": -0.0142,
+      "log_bad": 6.4156,
+      "log_good": 6.4058
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.3333,
+      "good": 3.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.204,
+      "log_good": 1.204
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0001,
+      "good": 0.0001,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -9.2103,
+      "log_good": -9.2103
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0193,
+      "good": 0.0193,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.9477,
+      "log_good": -3.9477
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0002,
+      "good": 0.0003,
+      "ratio": 1.5,
+      "suggested_scalar": 0.585,
+      "log_bad": -8.5172,
+      "log_good": -8.1117
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.99,
+      "good": 1.046,
+      "ratio": 1.0566,
+      "suggested_scalar": 0.0794,
+      "log_bad": -0.0101,
+      "log_good": 0.045
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 197.0,
+      "good": 191.3333,
+      "ratio": 0.9712,
+      "suggested_scalar": -0.0421,
+      "log_bad": 5.2832,
+      "log_good": 5.254
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 76.8838,
+      "good": 102.4086,
+      "ratio": 1.332,
+      "suggested_scalar": 0.4136,
+      "log_bad": 4.3423,
+      "log_good": 4.629
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4923,
+      "good": 0.5234,
+      "ratio": 1.0632,
+      "suggested_scalar": 0.0884,
+      "log_bad": -0.7087,
+      "log_good": -0.6474
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 19.0012,
+      "good": 8.1737,
+      "ratio": 0.4302,
+      "suggested_scalar": -1.217,
+      "log_bad": 2.9445,
+      "log_good": 2.1009
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2777.6667,
+      "good": 2292.6667,
+      "ratio": 0.8254,
+      "suggested_scalar": -0.2768,
+      "log_bad": 7.9294,
+      "log_good": 7.7375
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0571,
+      "good": 0.0429,
+      "ratio": 0.7513,
+      "suggested_scalar": -0.4125,
+      "log_bad": -2.863,
+      "log_good": -3.1489
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.892,
+      "good": 0.892,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1143,
+      "log_good": -0.1143
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.6956,
+      "good": 8.6073,
+      "ratio": 0.9898,
+      "suggested_scalar": -0.0147,
+      "log_bad": 2.1628,
+      "log_good": 2.1526
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 6.0,
+      "good": 1.5,
+      "ratio": 0.25,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.7918,
+      "log_good": 0.4055
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.0744,
+      "good": 3.0744,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.1231,
+      "log_good": 1.1231
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 145.3333,
+      "good": 164.6667,
+      "ratio": 1.133,
+      "suggested_scalar": 0.1802,
+      "log_bad": 4.979,
+      "log_good": 5.1039
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9484,
+      "good": 0.9551,
+      "ratio": 1.0071,
+      "suggested_scalar": 0.0102,
+      "log_bad": -0.053,
+      "log_good": -0.0459
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.6667,
+      "good": 29.0,
+      "ratio": 1.0482,
+      "suggested_scalar": 0.0679,
+      "log_bad": 3.3202,
+      "log_good": 3.3673
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6487,
+      "good": 0.6027,
+      "ratio": 0.9291,
+      "suggested_scalar": -0.1061,
+      "log_bad": -0.4328,
+      "log_good": -0.5063
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2423,
+      "good": 0.2859,
+      "ratio": 1.1799,
+      "suggested_scalar": 0.2387,
+      "log_bad": -1.4176,
+      "log_good": -1.2521
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.8467,
+      "good": 2.5181,
+      "ratio": 0.8846,
+      "suggested_scalar": -0.177,
+      "log_bad": 1.0462,
+      "log_good": 0.9235
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 609.3333,
+      "good": 603.3333,
+      "ratio": 0.9902,
+      "suggested_scalar": -0.0143,
+      "log_bad": 6.4124,
+      "log_good": 6.4025
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 30.3333,
+      "good": 30.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4122,
+      "log_good": 3.4122
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0357,
+      "good": 0.0323,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.1444,
+      "log_bad": -3.3326,
+      "log_good": -3.4327
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9518,
+      "good": 5.9443,
+      "ratio": 0.9987,
+      "suggested_scalar": -0.0018,
+      "log_bad": 1.7837,
+      "log_good": 1.7824
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 15.3333,
+      "good": 13.6667,
+      "ratio": 0.8913,
+      "suggested_scalar": -0.166,
+      "log_bad": 2.73,
+      "log_good": 2.615
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8125,
+      "good": 0.6202,
+      "ratio": 0.7633,
+      "suggested_scalar": -0.3896,
+      "log_bad": -0.2076,
+      "log_good": -0.4777
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9473,
+      "good": 5.8273,
+      "ratio": 0.9798,
+      "suggested_scalar": -0.0294,
+      "log_bad": 1.7829,
+      "log_good": 1.7626
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7985,
+      "good": 0.795,
+      "ratio": 0.9956,
+      "suggested_scalar": -0.0063,
+      "log_bad": -0.225,
+      "log_good": -0.2294
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1582,
+      "good": 0.1582,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.8439,
+      "log_good": -1.8439
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.347,
+      "good": 2.8562,
+      "ratio": 0.6571,
+      "suggested_scalar": -0.6059,
+      "log_bad": 1.4695,
+      "log_good": 1.0495
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 0.3333,
+      "good": 0.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.0987,
+      "log_good": -1.0987
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 514.6667,
+      "good": 494.0,
+      "ratio": 0.9598,
+      "suggested_scalar": -0.0591,
+      "log_bad": 6.2435,
+      "log_good": 6.2025
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 18.6667,
+      "good": 18.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9267,
+      "log_good": 2.9267
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.3455,
+      "good": 1.2994,
+      "ratio": 0.9657,
+      "suggested_scalar": -0.0503,
+      "log_bad": 0.2968,
+      "log_good": 0.2619
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 143.3333,
+      "good": 125.3333,
+      "ratio": 0.8744,
+      "suggested_scalar": -0.1936,
+      "log_bad": 4.9652,
+      "log_good": 4.831
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1620.3333,
+      "good": 1126.3333,
+      "ratio": 0.6951,
+      "suggested_scalar": -0.5247,
+      "log_bad": 7.3904,
+      "log_good": 7.0267
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 220.3333,
+      "good": 217.3333,
+      "ratio": 0.9864,
+      "suggested_scalar": -0.0198,
+      "log_bad": 5.3951,
+      "log_good": 5.3814
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0057,
+      "good": 0.0057,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.1673,
+      "log_good": -5.1673
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2904,
+      "good": 0.2848,
+      "ratio": 0.9807,
+      "suggested_scalar": -0.0281,
+      "log_bad": -1.2365,
+      "log_good": -1.256
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 93.6667,
+      "good": 96.0,
+      "ratio": 1.0249,
+      "suggested_scalar": 0.0355,
+      "log_bad": 4.5397,
+      "log_good": 4.5643
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 13.6667,
+      "good": 13.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.615,
+      "log_good": 2.615
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 143.3333,
+      "good": 125.3333,
+      "ratio": 0.8744,
+      "suggested_scalar": -0.1936,
+      "log_bad": 4.9652,
+      "log_good": 4.831
+    },
+    "brevity.mean_sample_size": {
+      "bad": 143.3333,
+      "good": 125.3333,
+      "ratio": 0.8744,
+      "suggested_scalar": -0.1936,
+      "log_bad": 4.9652,
+      "log_good": 4.831
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 611.3333,
+      "good": 605.3333,
+      "ratio": 0.9902,
+      "suggested_scalar": -0.0142,
+      "log_bad": 6.4156,
+      "log_good": 6.4058
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 341.6667,
+      "good": 336.6667,
+      "ratio": 0.9854,
+      "suggested_scalar": -0.0213,
+      "log_bad": 5.8338,
+      "log_good": 5.8191
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 401.3333,
+      "good": 382.3333,
+      "ratio": 0.9527,
+      "suggested_scalar": -0.07,
+      "log_bad": 5.9948,
+      "log_good": 5.9463
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0005,
+      "good": 0.0005,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.6009,
+      "log_good": -7.6009
+    },
+    "heaps.mean_k": {
+      "bad": 2.7889,
+      "good": 3.1577,
+      "ratio": 1.1322,
+      "suggested_scalar": 0.1792,
+      "log_bad": 1.0256,
+      "log_good": 1.1498
+    },
+    "halstead.mean_effort": {
+      "bad": 114612.9934,
+      "good": 134745.0251,
+      "ratio": 1.1757,
+      "suggested_scalar": 0.2335,
+      "log_bad": 11.6493,
+      "log_good": 11.8111
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8303,
+      "good": 0.8362,
+      "ratio": 1.0071,
+      "suggested_scalar": 0.0102,
+      "log_bad": -0.186,
+      "log_good": -0.1789
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 107.6667,
+      "good": 91.6667,
+      "ratio": 0.8514,
+      "suggested_scalar": -0.2321,
+      "log_bad": 4.679,
+      "log_good": 4.5182
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 349.6667,
+      "good": 346.3333,
+      "ratio": 0.9905,
+      "suggested_scalar": -0.0138,
+      "log_bad": 5.857,
+      "log_good": 5.8474
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5252,
+      "good": 0.4396,
+      "ratio": 0.837,
+      "suggested_scalar": -0.2567,
+      "log_bad": -0.644,
+      "log_good": -0.8219
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.2434,
+      "good": 5.8927,
+      "ratio": 0.7148,
+      "suggested_scalar": -0.4843,
+      "log_bad": 2.1094,
+      "log_good": 1.7737
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1582,
+      "good": 0.1582,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.8439,
+      "log_good": -1.8439
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 7.1237,
+      "good": 3.4429,
+      "ratio": 0.4833,
+      "suggested_scalar": -1.049,
+      "log_bad": 1.9634,
+      "log_good": 1.2363
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 610.3333,
+      "good": 604.3333,
+      "ratio": 0.9902,
+      "suggested_scalar": -0.0143,
+      "log_bad": 6.414,
+      "log_good": 6.4041
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 6.3333,
+      "good": 6.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8458,
+      "log_good": 1.8458
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 55.3333,
+      "good": 65.3333,
+      "ratio": 1.1807,
+      "suggested_scalar": 0.2397,
+      "log_bad": 4.0134,
+      "log_good": 4.1795
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6367.3885,
+      "good": 7485.8347,
+      "ratio": 1.1757,
+      "suggested_scalar": 0.2335,
+      "log_bad": 8.7589,
+      "log_good": 8.9208
+    },
+    "readability.mean_total_lines": {
+      "bad": 70.3333,
+      "good": 70.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2532,
+      "log_good": 4.2532
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 4036.3849,
+      "good": 3898.17,
+      "ratio": 0.9658,
+      "suggested_scalar": -0.0503,
+      "log_bad": 8.3031,
+      "log_good": 8.2683
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 975.6667,
+      "good": 910.0,
+      "ratio": 0.9327,
+      "suggested_scalar": -0.1005,
+      "log_bad": 6.8831,
+      "log_good": 6.8134
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 37.6483,
+      "good": 30.802,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.2896,
+      "log_bad": 3.6283,
+      "log_good": 3.4276
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.4317,
+      "good": 1.1311,
+      "ratio": 0.79,
+      "suggested_scalar": -0.34,
+      "log_bad": 0.3589,
+      "log_good": 0.1232
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.3333,
+      "good": 3.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.204,
+      "log_good": 1.204
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 26.3333,
+      "good": 26.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2708,
+      "log_good": 3.2708
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8933,
+      "good": 0.8685,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.0406,
+      "log_bad": -0.1128,
+      "log_good": -0.141
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9842,
+      "good": 0.9846,
+      "ratio": 1.0004,
+      "suggested_scalar": 0.0006,
+      "log_bad": -0.0159,
+      "log_good": -0.0155
+    },
+    "halstead.mean_length": {
+      "bad": 570.0,
+      "good": 563.6667,
+      "ratio": 0.9889,
+      "suggested_scalar": -0.0161,
+      "log_bad": 6.3456,
+      "log_good": 6.3345
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.837,
+      "good": 5.837,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7642,
+      "log_good": 1.7642
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.163,
+      "good": 6.9693,
+      "ratio": 0.973,
+      "suggested_scalar": -0.0396,
+      "log_bad": 1.9689,
+      "log_good": 1.9415
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1228,
+      "good": 0.1465,
+      "ratio": 1.193,
+      "suggested_scalar": 0.2546,
+      "log_bad": -2.0972,
+      "log_good": -1.9207
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 28.283,
+      "good": 34.3993,
+      "ratio": 1.2163,
+      "suggested_scalar": 0.2824,
+      "log_bad": 3.3423,
+      "log_good": 3.538
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.415,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 103.3333,
+      "good": 84.0,
+      "ratio": 0.8129,
+      "suggested_scalar": -0.2988,
+      "log_bad": 4.638,
+      "log_good": 4.4308
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7668,
+      "good": 0.7491,
+      "ratio": 0.9769,
+      "suggested_scalar": -0.0337,
+      "log_bad": -0.2655,
+      "log_good": -0.2889
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 71.0,
+      "good": 71.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2627,
+      "log_good": 4.2627
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 14.6667,
+      "ratio": 0.7719,
+      "suggested_scalar": -0.3735,
+      "log_bad": 2.9444,
+      "log_good": 2.6856
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_debug_print_statements": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 56.0,
+      "good": 37.0,
+      "ratio": 0.6607,
+      "suggested_scalar": -0.4114,
+      "log_bad": 4.0254,
+      "log_good": 3.6109
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0368,
+      "good": 0.0124,
+      "ratio": 0.337,
+      "suggested_scalar": -1.0798,
+      "log_bad": -3.3023,
+      "log_good": -4.3901
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.8,
+      "good": 1.8,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.5878,
+      "log_good": 0.5878
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9125,
+      "good": 0.8364,
+      "ratio": 0.9166,
+      "suggested_scalar": -0.0864,
+      "log_bad": -0.0916,
+      "log_good": -0.1786
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0368,
+      "good": 0.0124,
+      "ratio": 0.337,
+      "suggested_scalar": -1.0798,
+      "log_bad": -3.3023,
+      "log_good": -4.3901
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5721,
+      "good": 4.5453,
+      "ratio": 0.9941,
+      "suggested_scalar": -0.0058,
+      "log_bad": 1.52,
+      "log_good": 1.5141
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 110.0,
+      "good": 85.0,
+      "ratio": 0.7727,
+      "suggested_scalar": -0.2559,
+      "log_bad": 4.7005,
+      "log_good": 4.4427
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3888,
+      "good": 0.4889,
+      "ratio": 1.2575,
+      "suggested_scalar": 0.2274,
+      "log_bad": -0.9447,
+      "log_good": -0.7156
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 15.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.1242,
+      "log_bad": 2.8332,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5321,
+      "good": 0.5488,
+      "ratio": 1.0314,
+      "suggested_scalar": 0.0307,
+      "log_bad": -0.6309,
+      "log_good": -0.6
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.55,
+      "good": 4.5818,
+      "ratio": 0.8255,
+      "suggested_scalar": -0.1903,
+      "log_bad": 1.7138,
+      "log_good": 1.5221
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 680.0,
+      "good": 404.0,
+      "ratio": 0.5941,
+      "suggested_scalar": -0.5168,
+      "log_bad": 6.5221,
+      "log_good": 6.0014
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.4025,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.217,
+      "good": 1.0789,
+      "ratio": 0.8865,
+      "suggested_scalar": -0.1196,
+      "log_bad": 0.1964,
+      "log_good": 0.0759
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 242.0,
+      "good": 134.0,
+      "ratio": 0.5537,
+      "suggested_scalar": -0.5867,
+      "log_bad": 5.4889,
+      "log_good": 4.8978
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.2075,
+      "good": 99.3551,
+      "ratio": 0.9534,
+      "suggested_scalar": -0.0473,
+      "log_bad": 4.6464,
+      "log_good": 4.5987
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6937,
+      "good": 0.6427,
+      "ratio": 0.9265,
+      "suggested_scalar": -0.0758,
+      "log_bad": -0.3657,
+      "log_good": -0.4421
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.6629,
+      "good": 16.2854,
+      "ratio": 1.1919,
+      "suggested_scalar": 0.1743,
+      "log_bad": 2.6147,
+      "log_good": 2.7903
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2869.0,
+      "good": 1825.0,
+      "ratio": 0.6361,
+      "suggested_scalar": -0.449,
+      "log_bad": 7.9617,
+      "log_good": 7.5093
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.125,
+      "good": 0.1273,
+      "ratio": 1.0184,
+      "suggested_scalar": 0.0181,
+      "log_bad": -2.0794,
+      "log_good": -2.0612
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.85,
+      "good": 0.8,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0602,
+      "log_bad": -0.1625,
+      "log_good": -0.2231
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.5,
+      "good": 7.3455,
+      "ratio": 0.8642,
+      "suggested_scalar": -0.1449,
+      "log_bad": 2.1401,
+      "log_good": 1.9941
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 8.0,
+      "good": 9.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.1169,
+      "log_bad": 2.0794,
+      "log_good": 2.1972
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 7.3975,
+      "good": 5.916,
+      "ratio": 0.7997,
+      "suggested_scalar": -0.2218,
+      "log_bad": 2.0011,
+      "log_good": 1.7777
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 209.0,
+      "good": 116.0,
+      "ratio": 0.555,
+      "suggested_scalar": -0.5844,
+      "log_bad": 5.3423,
+      "log_good": 4.7536
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9344,
+      "good": 0.9464,
+      "ratio": 1.0128,
+      "suggested_scalar": 0.0127,
+      "log_bad": -0.0679,
+      "log_good": -0.0551
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 25.0,
+      "ratio": 0.8621,
+      "suggested_scalar": -0.1473,
+      "log_bad": 3.3673,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6922,
+      "good": 0.657,
+      "ratio": 0.9491,
+      "suggested_scalar": -0.0518,
+      "log_bad": -0.3679,
+      "log_good": -0.4201
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5162,
+      "good": 0.4701,
+      "ratio": 0.9107,
+      "suggested_scalar": -0.0929,
+      "log_bad": -0.6613,
+      "log_good": -0.7548
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.2492,
+      "good": 2.9153,
+      "ratio": 0.8972,
+      "suggested_scalar": -0.1076,
+      "log_bad": 1.1784,
+      "log_good": 1.07
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 678.0,
+      "good": 402.0,
+      "ratio": 0.5929,
+      "suggested_scalar": -0.5188,
+      "log_bad": 6.5191,
+      "log_good": 5.9965
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 23.0,
+      "good": 15.0,
+      "ratio": 0.6522,
+      "suggested_scalar": -0.4243,
+      "log_bad": 3.1355,
+      "log_good": 2.7081
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0382,
+      "good": 0.0322,
+      "ratio": 0.8429,
+      "suggested_scalar": -0.1696,
+      "log_bad": -3.2649,
+      "log_good": -3.4358
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7549,
+      "good": 5.7549,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7501,
+      "log_good": 1.7501
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 25.0,
+      "good": 9.0,
+      "ratio": 0.36,
+      "suggested_scalar": -1.0141,
+      "log_bad": 3.2189,
+      "log_good": 2.1972
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6836,
+      "good": 0.7035,
+      "ratio": 1.0291,
+      "suggested_scalar": 0.0285,
+      "log_bad": -0.3804,
+      "log_good": -0.3517
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5129,
+      "good": 5.3947,
+      "ratio": 0.9786,
+      "suggested_scalar": -0.0215,
+      "log_bad": 1.7071,
+      "log_good": 1.6854
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7945,
+      "good": 0.7898,
+      "ratio": 0.9941,
+      "suggested_scalar": -0.0059,
+      "log_bad": -0.23,
+      "log_good": -0.236
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1753,
+      "good": 0.1667,
+      "ratio": 0.9509,
+      "suggested_scalar": -0.0499,
+      "log_bad": -1.7413,
+      "log_good": -1.7916
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6963,
+      "good": 4.0355,
+      "ratio": 1.0918,
+      "suggested_scalar": 0.0871,
+      "log_bad": 1.3073,
+      "log_good": 1.3951
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 411.0,
+      "good": 273.0,
+      "ratio": 0.6642,
+      "suggested_scalar": -0.4061,
+      "log_bad": 6.0186,
+      "log_good": 5.6095
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 18.0,
+      "good": 5.0,
+      "ratio": 0.2778,
+      "suggested_scalar": -1.2715,
+      "log_bad": 2.8904,
+      "log_good": 1.6094
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.2636,
+      "good": 0.8097,
+      "ratio": 0.6408,
+      "suggested_scalar": -0.4418,
+      "log_bad": 0.234,
+      "log_good": -0.2111
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 114.0,
+      "good": 92.0,
+      "ratio": 0.807,
+      "suggested_scalar": -0.2128,
+      "log_bad": 4.7362,
+      "log_good": 4.5218
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1577.0,
+      "good": 992.0,
+      "ratio": 0.629,
+      "suggested_scalar": -0.4601,
+      "log_bad": 7.3633,
+      "log_good": 6.8997
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 199.0,
+      "good": 133.0,
+      "ratio": 0.6683,
+      "suggested_scalar": -0.4,
+      "log_bad": 5.2933,
+      "log_good": 4.8903
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0176,
+      "good": 0.0272,
+      "ratio": 1.5455,
+      "suggested_scalar": 0.4321,
+      "log_bad": -4.0399,
+      "log_good": -3.6045
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2794,
+      "good": 0.2772,
+      "ratio": 0.9921,
+      "suggested_scalar": -0.0078,
+      "log_bad": -1.2751,
+      "log_good": -1.283
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 94.0,
+      "good": 69.0,
+      "ratio": 0.734,
+      "suggested_scalar": -0.3069,
+      "log_bad": 4.5433,
+      "log_good": 4.2341
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 114.0,
+      "good": 92.0,
+      "ratio": 0.807,
+      "suggested_scalar": -0.2128,
+      "log_bad": 4.7362,
+      "log_good": 4.5218
+    },
+    "brevity.mean_sample_size": {
+      "bad": 114.0,
+      "good": 92.0,
+      "ratio": 0.807,
+      "suggested_scalar": -0.2128,
+      "log_bad": 4.7362,
+      "log_good": 4.5218
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 680.0,
+      "good": 404.0,
+      "ratio": 0.5941,
+      "suggested_scalar": -0.5168,
+      "log_bad": 6.5221,
+      "log_good": 6.0014
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 383.0,
+      "good": 223.0,
+      "ratio": 0.5822,
+      "suggested_scalar": -0.5369,
+      "log_bad": 5.948,
+      "log_good": 5.4072
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 302.0,
+      "good": 213.0,
+      "ratio": 0.7053,
+      "suggested_scalar": -0.3466,
+      "log_bad": 5.7104,
+      "log_good": 5.3613
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0088,
+      "good": 0.0149,
+      "ratio": 1.6932,
+      "suggested_scalar": 0.5227,
+      "log_bad": -4.733,
+      "log_good": -4.2064
+    },
+    "heaps.mean_k": {
+      "bad": 3.4057,
+      "good": 3.5188,
+      "ratio": 1.0332,
+      "suggested_scalar": 0.0324,
+      "log_bad": 1.2255,
+      "log_good": 1.2581
+    },
+    "halstead.mean_effort": {
+      "bad": 135040.6904,
+      "good": 67307.9519,
+      "ratio": 0.4984,
+      "suggested_scalar": -0.6911,
+      "log_bad": 11.8133,
+      "log_good": 11.117
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8068,
+      "good": 0.827,
+      "ratio": 1.025,
+      "suggested_scalar": 0.0245,
+      "log_bad": -0.2147,
+      "log_good": -0.19
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 81.0,
+      "good": 60.0,
+      "ratio": 0.7407,
+      "suggested_scalar": -0.2979,
+      "log_bad": 4.3944,
+      "log_good": 4.0943
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 360.0,
+      "good": 246.0,
+      "ratio": 0.6833,
+      "suggested_scalar": -0.378,
+      "log_bad": 5.8861,
+      "log_good": 5.5053
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.314,
+      "good": 0.4478,
+      "ratio": 1.4261,
+      "suggested_scalar": 0.3523,
+      "log_bad": -1.1584,
+      "log_good": -0.8034
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.5165,
+      "good": 7.403,
+      "ratio": 1.136,
+      "suggested_scalar": 0.1266,
+      "log_bad": 1.8743,
+      "log_good": 2.0019
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1753,
+      "good": 0.1667,
+      "ratio": 0.9509,
+      "suggested_scalar": -0.0499,
+      "log_bad": -1.7413,
+      "log_good": -1.7916
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.9387,
+      "good": 3.8222,
+      "ratio": 0.9704,
+      "suggested_scalar": -0.0298,
+      "log_bad": 1.3709,
+      "log_good": 1.3408
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 679.0,
+      "good": 403.0,
+      "ratio": 0.5935,
+      "suggested_scalar": -0.5178,
+      "log_bad": 6.5206,
+      "log_good": 5.9989
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 15.0,
+      "good": 2.0,
+      "ratio": 0.1333,
+      "suggested_scalar": -2.0,
+      "log_bad": 2.7081,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 83.0,
+      "good": 60.0,
+      "ratio": 0.7229,
+      "suggested_scalar": -0.3221,
+      "log_bad": 4.4188,
+      "log_good": 4.0943
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 7502.2606,
+      "good": 3739.3307,
+      "ratio": 0.4984,
+      "suggested_scalar": -0.6911,
+      "log_bad": 8.923,
+      "log_good": 8.2267
+    },
+    "readability.mean_total_lines": {
+      "bad": 80.0,
+      "good": 55.0,
+      "ratio": 0.6875,
+      "suggested_scalar": -0.3719,
+      "log_bad": 4.382,
+      "log_good": 4.0073
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 8.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.2215,
+      "log_bad": 2.3026,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 3790.7801,
+      "good": 2429.1592,
+      "ratio": 0.6408,
+      "suggested_scalar": -0.4417,
+      "log_bad": 8.2403,
+      "log_good": 7.7953
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 883.0,
+      "good": 626.0,
+      "ratio": 0.7089,
+      "suggested_scalar": -0.3414,
+      "log_bad": 6.7833,
+      "log_good": 6.4394
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 34.65,
+      "good": 31.9818,
+      "ratio": 0.923,
+      "suggested_scalar": -0.0795,
+      "log_bad": 3.5453,
+      "log_good": 3.4652
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1111,
+      "good": 1.1823,
+      "ratio": 1.0641,
+      "suggested_scalar": 0.0617,
+      "log_bad": 0.1054,
+      "log_good": 0.1675
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.4025,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 35.0,
+      "good": 14.0,
+      "ratio": 0.4,
+      "suggested_scalar": -0.9095,
+      "log_bad": 3.5553,
+      "log_good": 2.6391
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7981,
+      "good": 0.7802,
+      "ratio": 0.9776,
+      "suggested_scalar": -0.0225,
+      "log_bad": -0.2255,
+      "log_good": -0.2482
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9849,
+      "good": 0.9773,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.0077,
+      "log_bad": -0.0152,
+      "log_good": -0.023
+    },
+    "halstead.mean_length": {
+      "bad": 559.0,
+      "good": 379.0,
+      "ratio": 0.678,
+      "suggested_scalar": -0.3857,
+      "log_bad": 6.3261,
+      "log_good": 5.9375
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.4,
+      "good": 6.1,
+      "ratio": 0.6489,
+      "suggested_scalar": -0.4292,
+      "log_bad": 2.2407,
+      "log_good": 1.8083
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8329,
+      "good": 6.5236,
+      "ratio": 0.9547,
+      "suggested_scalar": -0.046,
+      "log_bad": 1.9217,
+      "log_good": 1.8754
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1335,
+      "good": 0.1222,
+      "ratio": 0.9154,
+      "suggested_scalar": -0.0878,
+      "log_bad": -2.0137,
+      "log_good": -2.1021
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 35.6235,
+      "good": 27.7083,
+      "ratio": 0.7778,
+      "suggested_scalar": -0.2494,
+      "log_bad": 3.573,
+      "log_good": 3.3217
+    },
+    "branching.mean_branch_count": {
+      "bad": 10.0,
+      "good": 7.0,
+      "ratio": 0.7,
+      "suggested_scalar": -0.354,
+      "log_bad": 2.3026,
+      "log_good": 1.9459
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 76.0,
+      "good": 60.0,
+      "ratio": 0.7895,
+      "suggested_scalar": -0.2346,
+      "log_bad": 4.3307,
+      "log_good": 4.0943
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6887,
+      "good": 0.6761,
+      "ratio": 0.9817,
+      "suggested_scalar": -0.0183,
+      "log_bad": -0.3729,
+      "log_good": -0.3914
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 80.0,
+      "good": 55.0,
+      "ratio": 0.6875,
+      "suggested_scalar": -0.3719,
+      "log_bad": 4.382,
+      "log_good": 4.0073
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.is_less_than_20_lines": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 16.0,
+      "good": 31.0,
+      "ratio": 1.9375,
+      "suggested_scalar": 0.1886,
+      "log_bad": 2.7726,
+      "log_good": 3.434
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.082,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0164,
+      "good": 0.0125,
+      "ratio": 0.7622,
+      "suggested_scalar": -0.0774,
+      "log_bad": -4.1105,
+      "log_good": -4.382
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1156,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9091,
+      "good": 0.8085,
+      "ratio": 0.8893,
+      "suggested_scalar": -0.0334,
+      "log_bad": -0.0953,
+      "log_good": -0.2126
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0164,
+      "good": 0.0125,
+      "ratio": 0.7622,
+      "suggested_scalar": -0.0774,
+      "log_bad": -4.1105,
+      "log_good": -4.382
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6746,
+      "good": 4.7072,
+      "ratio": 1.007,
+      "suggested_scalar": 0.002,
+      "log_bad": 1.5421,
+      "log_good": 1.5491
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 97.0,
+      "good": 102.0,
+      "ratio": 1.0515,
+      "suggested_scalar": 0.0143,
+      "log_bad": 4.5747,
+      "log_good": 4.625
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4768,
+      "good": 0.4191,
+      "ratio": 0.879,
+      "suggested_scalar": -0.0368,
+      "log_bad": -0.7407,
+      "log_good": -0.8696
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 22.0,
+      "good": 23.0,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.0127,
+      "log_bad": 3.091,
+      "log_good": 3.1355
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6291,
+      "good": 0.6287,
+      "ratio": 0.9994,
+      "suggested_scalar": -0.0002,
+      "log_bad": -0.4635,
+      "log_good": -0.4641
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.5909,
+      "good": 3.2766,
+      "ratio": 0.7137,
+      "suggested_scalar": -0.0962,
+      "log_bad": 1.5241,
+      "log_good": 1.1868
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 489.0,
+      "good": 638.0,
+      "ratio": 1.3047,
+      "suggested_scalar": 0.0759,
+      "log_bad": 6.1924,
+      "log_good": 6.4583
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1156,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0012,
+      "good": 0.0009,
+      "ratio": 0.75,
+      "suggested_scalar": -0.082,
+      "log_bad": -6.7254,
+      "log_good": -7.0131
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 0.0009,
+      "ratio": 0.0009,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -7.0131
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0052,
+      "good": 1.0877,
+      "ratio": 1.0821,
+      "suggested_scalar": 0.0225,
+      "log_bad": 0.0052,
+      "log_good": 0.0841
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 161.0,
+      "good": 218.0,
+      "ratio": 1.354,
+      "suggested_scalar": 0.0864,
+      "log_bad": 5.0814,
+      "log_good": 5.3845
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 96.2039,
+      "good": 94.883,
+      "ratio": 0.9863,
+      "suggested_scalar": -0.0039,
+      "log_bad": 4.5665,
+      "log_good": 4.5526
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.584,
+      "good": 0.7111,
+      "ratio": 1.2176,
+      "suggested_scalar": 0.0562,
+      "log_bad": -0.5379,
+      "log_good": -0.3409
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.5925,
+      "good": 10.698,
+      "ratio": 1.245,
+      "suggested_scalar": 0.0625,
+      "log_bad": 2.1509,
+      "log_good": 2.3701
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1733.0,
+      "good": 2251.0,
+      "ratio": 1.2989,
+      "suggested_scalar": 0.0746,
+      "log_bad": 7.4576,
+      "log_good": 7.7191
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0909,
+      "good": 0.0638,
+      "ratio": 0.7019,
+      "suggested_scalar": -0.101,
+      "log_bad": -2.398,
+      "log_good": -2.752
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8409,
+      "good": 0.7872,
+      "ratio": 0.9361,
+      "suggested_scalar": -0.0188,
+      "log_bad": -0.1733,
+      "log_good": -0.2393
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 11.1136,
+      "good": 13.5745,
+      "ratio": 1.2214,
+      "suggested_scalar": 0.057,
+      "log_bad": 2.4082,
+      "log_good": 2.6082
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 9.0,
+      "ratio": 9.0,
+      "suggested_scalar": 0.6266,
+      "log_bad": 0.0,
+      "log_good": 2.1972
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.3781,
+      "good": 2.2852,
+      "ratio": 0.6765,
+      "suggested_scalar": -0.1115,
+      "log_bad": 1.2173,
+      "log_good": 0.8265
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 142.0,
+      "good": 188.0,
+      "ratio": 1.3239,
+      "suggested_scalar": 0.08,
+      "log_bad": 4.9558,
+      "log_good": 5.2364
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.937,
+      "good": 0.9468,
+      "ratio": 1.0105,
+      "suggested_scalar": 0.003,
+      "log_bad": -0.0651,
+      "log_good": -0.0547
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 29.0,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0097,
+      "log_bad": 3.4012,
+      "log_good": 3.3673
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6001,
+      "good": 0.6499,
+      "ratio": 1.083,
+      "suggested_scalar": 0.0227,
+      "log_bad": -0.5107,
+      "log_good": -0.4309
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3306,
+      "good": 0.4717,
+      "ratio": 1.4268,
+      "suggested_scalar": 0.1014,
+      "log_bad": -1.1068,
+      "log_good": -0.7514
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5007,
+      "good": 2.8566,
+      "ratio": 1.1423,
+      "suggested_scalar": 0.0379,
+      "log_bad": 0.9166,
+      "log_good": 1.0496
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 487.0,
+      "good": 636.0,
+      "ratio": 1.306,
+      "suggested_scalar": 0.0761,
+      "log_bad": 6.1883,
+      "log_good": 6.4552
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 49.0,
+      "good": 10.0,
+      "ratio": 0.2041,
+      "suggested_scalar": -0.4532,
+      "log_bad": 3.8918,
+      "log_good": 2.3026
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0225,
+      "good": 0.0313,
+      "ratio": 1.3911,
+      "suggested_scalar": 0.0941,
+      "log_bad": -3.7942,
+      "log_good": -3.4641
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 5.9542,
+      "ratio": 1.004,
+      "suggested_scalar": 0.0011,
+      "log_bad": 1.7801,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 18.0,
+      "good": 21.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.044,
+      "log_bad": 2.8904,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.5587,
+      "good": 0.6992,
+      "ratio": 1.2515,
+      "suggested_scalar": 0.064,
+      "log_bad": -0.5821,
+      "log_good": -0.3578
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8014,
+      "good": 5.719,
+      "ratio": 0.9858,
+      "suggested_scalar": -0.0041,
+      "log_bad": 1.7581,
+      "log_good": 1.7438
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7882,
+      "good": 0.7906,
+      "ratio": 1.003,
+      "suggested_scalar": 0.0009,
+      "log_bad": -0.238,
+      "log_good": -0.235
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1698,
+      "good": 0.1455,
+      "ratio": 0.8569,
+      "suggested_scalar": -0.044,
+      "log_bad": -1.7731,
+      "log_good": -1.9276
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.9313,
+      "good": 3.2708,
+      "ratio": 1.1158,
+      "suggested_scalar": 0.0313,
+      "log_bad": 1.0754,
+      "log_good": 1.185
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1156,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 393.0,
+      "good": 450.0,
+      "ratio": 1.145,
+      "suggested_scalar": 0.0386,
+      "log_bad": 5.9738,
+      "log_good": 6.1092
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0476,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8954,
+      "good": 1.2388,
+      "ratio": 1.3835,
+      "suggested_scalar": 0.0926,
+      "log_bad": -0.1105,
+      "log_good": 0.2141
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 101.0,
+      "good": 107.0,
+      "ratio": 1.0594,
+      "suggested_scalar": 0.0165,
+      "log_bad": 4.6151,
+      "log_good": 4.6728
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 931.0,
+      "good": 1328.0,
+      "ratio": 1.4264,
+      "suggested_scalar": 0.1013,
+      "log_bad": 6.8363,
+      "log_good": 7.1914
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 139.0,
+      "good": 195.0,
+      "ratio": 1.4029,
+      "suggested_scalar": 0.0965,
+      "log_bad": 4.9345,
+      "log_good": 5.273
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0184,
+      "good": 0.0047,
+      "ratio": 0.2554,
+      "suggested_scalar": -0.3892,
+      "log_bad": -3.9954,
+      "log_good": -5.3602
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2679,
+      "good": 0.3213,
+      "ratio": 1.1993,
+      "suggested_scalar": 0.0518,
+      "log_bad": -1.3171,
+      "log_good": -1.1354
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 97.0,
+      "good": 141.0,
+      "ratio": 1.4536,
+      "suggested_scalar": 0.1067,
+      "log_bad": 4.5747,
+      "log_good": 4.9488
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 11.0,
+      "ratio": 3.6667,
+      "suggested_scalar": 0.3705,
+      "log_bad": 1.0986,
+      "log_good": 2.3979
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 101.0,
+      "good": 107.0,
+      "ratio": 1.0594,
+      "suggested_scalar": 0.0165,
+      "log_bad": 4.6151,
+      "log_good": 4.6728
+    },
+    "brevity.mean_sample_size": {
+      "bad": 101.0,
+      "good": 107.0,
+      "ratio": 1.0594,
+      "suggested_scalar": 0.0165,
+      "log_bad": 4.6151,
+      "log_good": 4.6728
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 489.0,
+      "good": 638.0,
+      "ratio": 1.3047,
+      "suggested_scalar": 0.0759,
+      "log_bad": 6.1924,
+      "log_good": 6.4583
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 291.0,
+      "good": 367.0,
+      "ratio": 1.2612,
+      "suggested_scalar": 0.0662,
+      "log_bad": 5.6733,
+      "log_good": 5.9054
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 300.0,
+      "good": 325.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.0228,
+      "log_bad": 5.7038,
+      "log_good": 5.7838
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0041,
+      "good": 0.0047,
+      "ratio": 1.1463,
+      "suggested_scalar": 0.0389,
+      "log_bad": -5.4968,
+      "log_good": -5.3602
+    },
+    "heaps.mean_k": {
+      "bad": 2.0975,
+      "good": 1.9185,
+      "ratio": 0.9147,
+      "suggested_scalar": -0.0254,
+      "log_bad": 0.7407,
+      "log_good": 0.6515
+    },
+    "halstead.mean_effort": {
+      "bad": 83591.8364,
+      "good": 143952.3211,
+      "ratio": 1.7221,
+      "suggested_scalar": 0.155,
+      "log_bad": 11.3337,
+      "log_good": 11.8772
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8713,
+      "good": 0.8483,
+      "ratio": 0.9736,
+      "suggested_scalar": -0.0076,
+      "log_bad": -0.1378,
+      "log_good": -0.1645
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 67.0,
+      "good": 73.0,
+      "ratio": 1.0896,
+      "suggested_scalar": 0.0245,
+      "log_bad": 4.2047,
+      "log_good": 4.2905
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 268.0,
+      "good": 362.0,
+      "ratio": 1.3507,
+      "suggested_scalar": 0.0857,
+      "log_bad": 5.591,
+      "log_good": 5.8916
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3913,
+      "good": 0.3119,
+      "ratio": 0.7971,
+      "suggested_scalar": -0.0647,
+      "log_bad": -0.9383,
+      "log_good": -1.1651
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.7826,
+      "good": 6.0917,
+      "ratio": 1.0535,
+      "suggested_scalar": 0.0149,
+      "log_bad": 1.7549,
+      "log_good": 1.8069
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1698,
+      "good": 0.1455,
+      "ratio": 0.8569,
+      "suggested_scalar": -0.044,
+      "log_bad": -1.7731,
+      "log_good": -1.9276
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.4455,
+      "good": 6.0268,
+      "ratio": 1.3557,
+      "suggested_scalar": 0.0868,
+      "log_bad": 1.4919,
+      "log_good": 1.7962
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 488.0,
+      "good": 637.0,
+      "ratio": 1.3053,
+      "suggested_scalar": 0.076,
+      "log_bad": 6.1903,
+      "log_good": 6.4568
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 19.0,
+      "good": 22.0,
+      "ratio": 1.1579,
+      "suggested_scalar": 0.0418,
+      "log_bad": 2.9444,
+      "log_good": 3.091
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 67.0,
+      "good": 114.0,
+      "ratio": 1.7015,
+      "suggested_scalar": 0.1516,
+      "log_bad": 4.2047,
+      "log_good": 4.7362
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4643.9909,
+      "good": 7997.3512,
+      "ratio": 1.7221,
+      "suggested_scalar": 0.155,
+      "log_bad": 8.4433,
+      "log_good": 8.9869
+    },
+    "readability.mean_total_lines": {
+      "bad": 44.0,
+      "good": 47.0,
+      "ratio": 1.0682,
+      "suggested_scalar": 0.0188,
+      "log_bad": 3.7842,
+      "log_good": 3.8501
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2686.1645,
+      "good": 3716.5409,
+      "ratio": 1.3836,
+      "suggested_scalar": 0.0926,
+      "log_bad": 7.8959,
+      "log_good": 8.2205
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 693.0,
+      "good": 788.0,
+      "ratio": 1.1371,
+      "suggested_scalar": 0.0366,
+      "log_bad": 6.541,
+      "log_good": 6.6695
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 38.1818,
+      "good": 46.7234,
+      "ratio": 1.2237,
+      "suggested_scalar": 0.0576,
+      "log_bad": 3.6424,
+      "log_good": 3.8442
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1744,
+      "good": 1.1604,
+      "ratio": 0.9881,
+      "suggested_scalar": -0.0034,
+      "log_bad": 0.1608,
+      "log_good": 0.1488
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1156,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 28.0,
+      "good": 36.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.0717,
+      "log_bad": 3.3322,
+      "log_good": 3.5835
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8295,
+      "good": 0.7467,
+      "ratio": 0.9002,
+      "suggested_scalar": -0.03,
+      "log_bad": -0.1869,
+      "log_good": -0.2921
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9901,
+      "good": 0.9888,
+      "ratio": 0.9987,
+      "suggested_scalar": -0.0004,
+      "log_bad": -0.0099,
+      "log_good": -0.0113
+    },
+    "halstead.mean_length": {
+      "bad": 407.0,
+      "good": 557.0,
+      "ratio": 1.3686,
+      "suggested_scalar": 0.0895,
+      "log_bad": 6.0088,
+      "log_good": 6.3226
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 17.3333,
+      "good": 4.9091,
+      "ratio": 0.2832,
+      "suggested_scalar": -0.3598,
+      "log_bad": 2.8526,
+      "log_good": 1.5911
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6582,
+      "good": 6.7415,
+      "ratio": 1.0125,
+      "suggested_scalar": 0.0035,
+      "log_bad": 1.8958,
+      "log_good": 1.9083
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1679,
+      "good": 0.163,
+      "ratio": 0.9708,
+      "suggested_scalar": -0.0084,
+      "log_bad": -1.7844,
+      "log_good": -1.814
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 31.1194,
+      "good": 38.7329,
+      "ratio": 1.2447,
+      "suggested_scalar": 0.0624,
+      "log_bad": 3.4378,
+      "log_good": 3.6567
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.082,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 63.0,
+      "good": 68.0,
+      "ratio": 1.0794,
+      "suggested_scalar": 0.0218,
+      "log_bad": 4.1431,
+      "log_good": 4.2195
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6767,
+      "good": 0.5662,
+      "ratio": 0.8367,
+      "suggested_scalar": -0.0508,
+      "log_bad": -0.3905,
+      "log_good": -0.5688
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 44.0,
+      "good": 47.0,
+      "ratio": 1.0682,
+      "suggested_scalar": 0.0188,
+      "log_bad": 3.7842,
+      "log_good": 3.8501
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "consistency.same_concept_same_name": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 75.0,
+      "good": 75.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3175,
+      "log_good": 4.3175
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0111,
+      "good": 0.0111,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.5008,
+      "log_good": -4.5008
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3077,
+      "good": 1.3077,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2683,
+      "log_good": 0.2683
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.809,
+      "good": 0.7978,
+      "ratio": 0.9862,
+      "suggested_scalar": -0.3343,
+      "log_bad": -0.212,
+      "log_good": -0.2259
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0111,
+      "good": 0.0111,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.5008,
+      "log_good": -4.5008
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4788,
+      "good": 4.4442,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.1859,
+      "log_bad": 1.4994,
+      "log_good": 1.4916
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 104.0,
+      "good": 98.0,
+      "ratio": 0.9423,
+      "suggested_scalar": -1.4248,
+      "log_bad": 4.6444,
+      "log_good": 4.585
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4886,
+      "good": 0.4534,
+      "ratio": 0.928,
+      "suggested_scalar": -1.7927,
+      "log_bad": -0.7162,
+      "log_good": -0.791
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5069,
+      "good": 0.4943,
+      "ratio": 0.9751,
+      "suggested_scalar": -0.6035,
+      "log_bad": -0.6794,
+      "log_good": -0.7046
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.3708,
+      "good": 4.3708,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.4749,
+      "log_good": 1.4749
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 631.0,
+      "good": 631.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.4473,
+      "log_good": 6.4473
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1054,
+      "good": 1.1425,
+      "ratio": 1.0336,
+      "suggested_scalar": 0.7915,
+      "log_bad": 0.1002,
+      "log_good": 0.1332
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 187.0,
+      "good": 187.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.2311,
+      "log_good": 5.2311
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 85.5876,
+      "good": 86.4538,
+      "ratio": 1.0101,
+      "suggested_scalar": 0.2414,
+      "log_bad": 4.4495,
+      "log_good": 4.4596
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7254,
+      "good": 0.746,
+      "ratio": 1.0284,
+      "suggested_scalar": 0.6714,
+      "log_bad": -0.321,
+      "log_good": -0.293
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 33.476,
+      "good": 32.7047,
+      "ratio": 0.977,
+      "suggested_scalar": -0.5589,
+      "log_bad": 3.5108,
+      "log_good": 3.4875
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2882.0,
+      "good": 2904.0,
+      "ratio": 1.0076,
+      "suggested_scalar": 0.1823,
+      "log_bad": 7.9662,
+      "log_good": 7.9738
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1236,
+      "good": 0.1236,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.0907,
+      "log_good": -2.0907
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.764,
+      "good": 0.7416,
+      "ratio": 0.9707,
+      "suggested_scalar": -0.7135,
+      "log_bad": -0.2692,
+      "log_good": -0.2989
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.0899,
+      "good": 7.0899,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9587,
+      "log_good": 1.9587
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 6.9299,
+      "good": 6.9299,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9358,
+      "log_good": 1.9358
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 165.0,
+      "good": 165.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.1059,
+      "log_good": 5.1059
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9588,
+      "good": 0.9591,
+      "ratio": 1.0003,
+      "suggested_scalar": 0.0075,
+      "log_bad": -0.0421,
+      "log_good": -0.0418
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 26.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2581,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.711,
+      "good": 0.7231,
+      "ratio": 1.017,
+      "suggested_scalar": 0.4046,
+      "log_bad": -0.3411,
+      "log_good": -0.3242
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4881,
+      "good": 0.5231,
+      "ratio": 1.0717,
+      "suggested_scalar": 1.6604,
+      "log_bad": -0.7172,
+      "log_good": -0.648
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.4598,
+      "good": 3.6119,
+      "ratio": 1.044,
+      "suggested_scalar": 1.0316,
+      "log_bad": 1.2412,
+      "log_good": 1.2842
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 629.0,
+      "good": 629.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.4441,
+      "log_good": 6.4441
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0285,
+      "good": 0.0285,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.5579,
+      "log_good": -3.5579
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.5546,
+      "good": 5.5546,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7146,
+      "log_good": 1.7146
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.5743,
+      "good": 0.5743,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.5546,
+      "log_good": -0.5546
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4608,
+      "good": 5.3784,
+      "ratio": 0.9849,
+      "suggested_scalar": -0.3646,
+      "log_bad": 1.6976,
+      "log_good": 1.6824
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8063,
+      "good": 0.8001,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.1851,
+      "log_bad": -0.2153,
+      "log_good": -0.223
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1275,
+      "good": 0.1275,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.0596,
+      "log_good": -2.0596
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 5.7858,
+      "good": 5.7188,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.2793,
+      "log_bad": 1.7554,
+      "log_good": 1.7438
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 410.0,
+      "good": 393.0,
+      "ratio": 0.9585,
+      "suggested_scalar": -1.0154,
+      "log_bad": 6.0162,
+      "log_good": 5.9738
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.3468,
+      "good": 1.3296,
+      "ratio": 0.9872,
+      "suggested_scalar": -0.3082,
+      "log_bad": 0.2977,
+      "log_good": 0.2849
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 101.0,
+      "ratio": 0.9439,
+      "suggested_scalar": -1.3837,
+      "log_bad": 4.6728,
+      "log_good": 4.6151
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1554.0,
+      "good": 1576.0,
+      "ratio": 1.0142,
+      "suggested_scalar": 0.3371,
+      "log_bad": 7.3486,
+      "log_good": 7.3626
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 198.0,
+      "good": 198.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.2883,
+      "log_good": 5.2883
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0174,
+      "good": 0.0174,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.0513,
+      "log_good": -4.0513
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2995,
+      "good": 0.2995,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.2056,
+      "log_good": -1.2056
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 112.0,
+      "good": 111.0,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.215,
+      "log_bad": 4.7185,
+      "log_good": 4.7095
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 26.0,
+      "good": 26.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2581,
+      "log_good": 3.2581
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 101.0,
+      "ratio": 0.9439,
+      "suggested_scalar": -1.3837,
+      "log_bad": 4.6728,
+      "log_good": 4.6151
+    },
+    "brevity.mean_sample_size": {
+      "bad": 107.0,
+      "good": 101.0,
+      "ratio": 0.9439,
+      "suggested_scalar": -1.3837,
+      "log_bad": 4.6728,
+      "log_good": 4.6151
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 631.0,
+      "good": 631.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.4473,
+      "log_good": 6.4473
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 336.0,
+      "good": 336.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.8171,
+      "log_good": 5.8171
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 285.0,
+      "good": 271.0,
+      "ratio": 0.9509,
+      "suggested_scalar": -1.2077,
+      "log_bad": 5.6525,
+      "log_good": 5.6021
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 4.2498,
+      "good": 4.3438,
+      "ratio": 1.0221,
+      "suggested_scalar": 0.5246,
+      "log_bad": 1.4469,
+      "log_good": 1.4687
+    },
+    "halstead.mean_effort": {
+      "bad": 133332.05,
+      "good": 142594.9538,
+      "ratio": 1.0695,
+      "suggested_scalar": 1.6104,
+      "log_bad": 11.8006,
+      "log_good": 11.8678
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.81,
+      "good": 0.8078,
+      "ratio": 0.9973,
+      "suggested_scalar": -0.0652,
+      "log_bad": -0.2107,
+      "log_good": -0.2134
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 78.0,
+      "good": 72.0,
+      "ratio": 0.9231,
+      "suggested_scalar": -1.9192,
+      "log_bad": 4.3567,
+      "log_good": 4.2767
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 405.0,
+      "good": 405.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.0039,
+      "log_good": 6.0039
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4011,
+      "good": 0.369,
+      "ratio": 0.92,
+      "suggested_scalar": -2.0,
+      "log_bad": -0.9135,
+      "log_good": -0.997
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.3102,
+      "good": 8.4278,
+      "ratio": 1.0142,
+      "suggested_scalar": 0.3369,
+      "log_bad": 2.1175,
+      "log_good": 2.1315
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1275,
+      "good": 0.1275,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.0596,
+      "log_good": -2.0596
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.4298,
+      "good": 5.4298,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6919,
+      "log_good": 1.6919
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 630.0,
+      "good": 630.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.4457,
+      "log_good": 6.4457
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 88.0,
+      "good": 93.0,
+      "ratio": 1.0568,
+      "suggested_scalar": 1.325,
+      "log_bad": 4.4773,
+      "log_good": 4.5326
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 7407.3361,
+      "good": 7921.9419,
+      "ratio": 1.0695,
+      "suggested_scalar": 1.6104,
+      "log_bad": 8.9102,
+      "log_good": 8.9774
+    },
+    "readability.mean_total_lines": {
+      "bad": 89.0,
+      "good": 89.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.4886,
+      "log_good": 4.4886
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 4040.3652,
+      "good": 3988.67,
+      "ratio": 0.9872,
+      "suggested_scalar": -0.3088,
+      "log_bad": 8.3041,
+      "log_good": 8.2912
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 833.0,
+      "good": 804.0,
+      "ratio": 0.9652,
+      "suggested_scalar": -0.8496,
+      "log_bad": 6.725,
+      "log_good": 6.6896
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.236,
+      "good": 31.4831,
+      "ratio": 1.0079,
+      "suggested_scalar": 0.1889,
+      "log_bad": 3.4416,
+      "log_good": 3.4495
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3481,
+      "good": 1.3379,
+      "ratio": 0.9924,
+      "suggested_scalar": -0.1821,
+      "log_bad": 0.2987,
+      "log_good": 0.2911
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7854,
+      "good": 0.7634,
+      "ratio": 0.972,
+      "suggested_scalar": -0.6812,
+      "log_bad": -0.2416,
+      "log_good": -0.27
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9844,
+      "good": 0.9846,
+      "ratio": 1.0002,
+      "suggested_scalar": 0.0049,
+      "log_bad": -0.0157,
+      "log_good": -0.0155
+    },
+    "halstead.mean_length": {
+      "bad": 603.0,
+      "good": 603.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.4019,
+      "log_good": 6.4019
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 3.8077,
+      "good": 3.8077,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.337,
+      "log_good": 1.337
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7415,
+      "good": 6.6582,
+      "ratio": 0.9876,
+      "suggested_scalar": -0.2981,
+      "log_bad": 1.9083,
+      "log_good": 1.8958
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1166,
+      "good": 0.1157,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.1858,
+      "log_bad": -2.149,
+      "log_good": -2.1568
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 33.0,
+      "good": 35.75,
+      "ratio": 1.0833,
+      "suggested_scalar": 1.9192,
+      "log_bad": 3.4965,
+      "log_good": 3.5766
+    },
+    "branching.mean_branch_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 75.0,
+      "good": 69.0,
+      "ratio": 0.92,
+      "suggested_scalar": -1.9992,
+      "log_bad": 4.3175,
+      "log_good": 4.2341
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.607,
+      "good": 0.5904,
+      "ratio": 0.9727,
+      "suggested_scalar": -0.6648,
+      "log_bad": -0.4992,
+      "log_good": -0.527
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 89.0,
+      "good": 89.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.4886,
+      "log_good": 4.4886
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.no_star_args_abuse": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 70.0,
+      "good": 24.0,
+      "ratio": 0.3429,
+      "suggested_scalar": -0.2817,
+      "log_bad": 4.2485,
+      "log_good": 3.1781
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0672,
+      "good": 0.0528,
+      "ratio": 0.7857,
+      "suggested_scalar": -0.0635,
+      "log_bad": -2.7001,
+      "log_good": -2.9412
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.25,
+      "good": 1.0,
+      "ratio": 0.4444,
+      "suggested_scalar": -0.2134,
+      "log_bad": 0.8109,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7895,
+      "good": 0.8154,
+      "ratio": 1.0328,
+      "suggested_scalar": 0.0085,
+      "log_bad": -0.2364,
+      "log_good": -0.2041
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0672,
+      "good": 0.0528,
+      "ratio": 0.7857,
+      "suggested_scalar": -0.0635,
+      "log_bad": -2.7001,
+      "log_good": -2.9412
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.828,
+      "good": 4.5279,
+      "ratio": 0.9378,
+      "suggested_scalar": -0.0169,
+      "log_bad": 1.5744,
+      "log_good": 1.5103
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 64.0,
+      "good": 66.0,
+      "ratio": 1.0313,
+      "suggested_scalar": 0.0081,
+      "log_bad": 4.1589,
+      "log_good": 4.1897
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3882,
+      "good": 0.3756,
+      "ratio": 0.9675,
+      "suggested_scalar": -0.0087,
+      "log_bad": -0.9462,
+      "log_good": -0.9792
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 16.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.031,
+      "log_bad": 2.8904,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5245,
+      "good": 0.5961,
+      "ratio": 1.1365,
+      "suggested_scalar": 0.0337,
+      "log_bad": -0.6453,
+      "log_good": -0.5173
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.7895,
+      "good": 4.7385,
+      "ratio": 1.2504,
+      "suggested_scalar": 0.0588,
+      "log_bad": 1.3322,
+      "log_good": 1.5557
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 521.0,
+      "good": 417.0,
+      "ratio": 0.8004,
+      "suggested_scalar": -0.0586,
+      "log_bad": 6.2558,
+      "log_good": 6.0331
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0016,
+      "good": 0.0015,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.017,
+      "log_bad": -6.4378,
+      "log_good": -6.5023
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0005,
+      "good": 1.0,
+      "ratio": 2.0e3,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.6009,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1257,
+      "good": 1.0623,
+      "ratio": 0.9437,
+      "suggested_scalar": -0.0153,
+      "log_bad": 0.1184,
+      "log_good": 0.0604
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 172.0,
+      "good": 161.0,
+      "ratio": 0.936,
+      "suggested_scalar": -0.0174,
+      "log_bad": 5.1475,
+      "log_good": 5.0814
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.6104,
+      "good": 106.9717,
+      "ratio": 1.0528,
+      "suggested_scalar": 0.0135,
+      "log_bad": 4.6211,
+      "log_good": 4.6726
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7827,
+      "good": 0.6899,
+      "ratio": 0.8814,
+      "suggested_scalar": -0.0332,
+      "log_bad": -0.245,
+      "log_good": -0.3712
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.7751,
+      "good": 13.1476,
+      "ratio": 1.4983,
+      "suggested_scalar": 0.1064,
+      "log_bad": 2.1719,
+      "log_good": 2.5762
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1882.0,
+      "good": 2019.0,
+      "ratio": 1.0728,
+      "suggested_scalar": 0.0185,
+      "log_bad": 7.5401,
+      "log_good": 7.6104
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.4737,
+      "good": 0.0462,
+      "ratio": 0.0975,
+      "suggested_scalar": -0.6125,
+      "log_bad": -0.7472,
+      "log_good": -3.0748
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7895,
+      "good": 0.7385,
+      "ratio": 0.9354,
+      "suggested_scalar": -0.0176,
+      "log_bad": -0.2364,
+      "log_good": -0.3031
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 13.7105,
+      "good": 6.4154,
+      "ratio": 0.4679,
+      "suggested_scalar": -0.1998,
+      "log_bad": 2.6182,
+      "log_good": 1.8587
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 4.1662,
+      "good": 13.2393,
+      "ratio": 3.1778,
+      "suggested_scalar": 0.3042,
+      "log_bad": 1.427,
+      "log_good": 2.5832
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 161.0,
+      "good": 133.0,
+      "ratio": 0.8261,
+      "suggested_scalar": -0.0503,
+      "log_bad": 5.0814,
+      "log_good": 4.8903
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9261,
+      "good": 0.9429,
+      "ratio": 1.0181,
+      "suggested_scalar": 0.0047,
+      "log_bad": -0.0768,
+      "log_good": -0.0588
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 22.0,
+      "ratio": 0.88,
+      "suggested_scalar": -0.0336,
+      "log_bad": 3.2189,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6631,
+      "good": 0.6984,
+      "ratio": 1.0532,
+      "suggested_scalar": 0.0136,
+      "log_bad": -0.4108,
+      "log_good": -0.359
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.7148,
+      "good": 0.5614,
+      "ratio": 0.7854,
+      "suggested_scalar": -0.0636,
+      "log_bad": -0.3358,
+      "log_good": -0.5773
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9685,
+      "good": 3.3153,
+      "ratio": 1.1168,
+      "suggested_scalar": 0.0291,
+      "log_bad": 1.0881,
+      "log_good": 1.1985
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 519.0,
+      "good": 415.0,
+      "ratio": 0.7996,
+      "suggested_scalar": -0.0588,
+      "log_bad": 6.2519,
+      "log_good": 6.0283
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 19.0,
+      "good": 22.0,
+      "ratio": 1.1579,
+      "suggested_scalar": 0.0386,
+      "log_bad": 2.9444,
+      "log_good": 3.091
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0096,
+      "good": 0.0624,
+      "ratio": 6.5,
+      "suggested_scalar": 0.4925,
+      "log_bad": -4.646,
+      "log_good": -2.7742
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9773,
+      "good": 5.8826,
+      "ratio": 0.9842,
+      "suggested_scalar": -0.0042,
+      "log_bad": 1.788,
+      "log_good": 1.772
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 10.0,
+      "good": 27.0,
+      "ratio": 2.7,
+      "suggested_scalar": 0.2614,
+      "log_bad": 2.3026,
+      "log_good": 3.2958
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.3711,
+      "good": 0.7052,
+      "ratio": 1.9003,
+      "suggested_scalar": 0.1689,
+      "log_bad": -0.9913,
+      "log_good": -0.3493
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5647,
+      "good": 5.4579,
+      "ratio": 0.9808,
+      "suggested_scalar": -0.0051,
+      "log_bad": 1.7164,
+      "log_good": 1.6971
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8077,
+      "good": 0.7697,
+      "ratio": 0.953,
+      "suggested_scalar": -0.0127,
+      "log_bad": -0.2136,
+      "log_good": -0.2618
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1824,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2083,
+      "good": 0.1667,
+      "ratio": 0.8003,
+      "suggested_scalar": -0.0586,
+      "log_bad": -1.5688,
+      "log_good": -1.7916
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.9623,
+      "good": 3.626,
+      "ratio": 1.224,
+      "suggested_scalar": 0.0532,
+      "log_bad": 1.086,
+      "log_good": 1.2881
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 252.0,
+      "good": 259.0,
+      "ratio": 1.0278,
+      "suggested_scalar": 0.0072,
+      "log_bad": 5.5294,
+      "log_good": 5.5568
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0757,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.756,
+      "good": 0.6488,
+      "ratio": 0.8582,
+      "suggested_scalar": -0.0402,
+      "log_bad": -0.2797,
+      "log_good": -0.4326
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 83.0,
+      "ratio": 0.7757,
+      "suggested_scalar": -0.0668,
+      "log_bad": 4.6728,
+      "log_good": 4.4188
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1015.0,
+      "good": 1108.0,
+      "ratio": 1.0916,
+      "suggested_scalar": 0.0231,
+      "log_bad": 6.9226,
+      "log_good": 7.0103
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 146.0,
+      "good": 138.0,
+      "ratio": 0.9452,
+      "suggested_scalar": -0.0148,
+      "log_bad": 4.9836,
+      "log_good": 4.9273
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0077,
+      "good": 0.0096,
+      "ratio": 1.2468,
+      "suggested_scalar": 0.058,
+      "log_bad": -4.8665,
+      "log_good": -4.646
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2438,
+      "good": 0.2998,
+      "ratio": 1.2297,
+      "suggested_scalar": 0.0544,
+      "log_bad": -1.4114,
+      "log_good": -1.2046
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 92.0,
+      "good": 78.0,
+      "ratio": 0.8478,
+      "suggested_scalar": -0.0434,
+      "log_bad": 4.5218,
+      "log_good": 4.3567
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 83.0,
+      "ratio": 0.7757,
+      "suggested_scalar": -0.0668,
+      "log_bad": 4.6728,
+      "log_good": 4.4188
+    },
+    "brevity.mean_sample_size": {
+      "bad": 107.0,
+      "good": 83.0,
+      "ratio": 0.7757,
+      "suggested_scalar": -0.0668,
+      "log_bad": 4.6728,
+      "log_good": 4.4188
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 521.0,
+      "good": 417.0,
+      "ratio": 0.8004,
+      "suggested_scalar": -0.0586,
+      "log_bad": 6.2558,
+      "log_good": 6.0331
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 278.0,
+      "good": 210.0,
+      "ratio": 0.7554,
+      "suggested_scalar": -0.0738,
+      "log_bad": 5.6276,
+      "log_good": 5.3471
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 205.0,
+      "good": 207.0,
+      "ratio": 1.0098,
+      "suggested_scalar": 0.0026,
+      "log_bad": 5.323,
+      "log_good": 5.3327
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 4.614,
+      "good": 2.7899,
+      "ratio": 0.6047,
+      "suggested_scalar": -0.1324,
+      "log_bad": 1.5291,
+      "log_good": 1.026
+    },
+    "halstead.mean_effort": {
+      "bad": 106130.7692,
+      "good": 67147.1743,
+      "ratio": 0.6327,
+      "suggested_scalar": -0.1205,
+      "log_bad": 11.5724,
+      "log_good": 11.1146
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8254,
+      "good": 0.8561,
+      "ratio": 1.0372,
+      "suggested_scalar": 0.0096,
+      "log_bad": -0.1919,
+      "log_good": -0.1554
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 39.0,
+      "good": 44.0,
+      "ratio": 1.1282,
+      "suggested_scalar": 0.0317,
+      "log_bad": 3.6636,
+      "log_good": 3.7842
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 232.0,
+      "good": 184.0,
+      "ratio": 0.7931,
+      "suggested_scalar": -0.061,
+      "log_bad": 5.4467,
+      "log_good": 5.2149
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4244,
+      "good": 0.3168,
+      "ratio": 0.7465,
+      "suggested_scalar": -0.0769,
+      "log_bad": -0.8571,
+      "log_good": -1.1495
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.9012,
+      "good": 6.882,
+      "ratio": 1.1662,
+      "suggested_scalar": 0.0405,
+      "log_bad": 1.7752,
+      "log_good": 1.9289
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2083,
+      "good": 0.1667,
+      "ratio": 0.8003,
+      "suggested_scalar": -0.0586,
+      "log_bad": -1.5688,
+      "log_good": -1.7916
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.4842,
+      "good": 2.5662,
+      "ratio": 0.4679,
+      "suggested_scalar": -0.1998,
+      "log_bad": 1.7019,
+      "log_good": 0.9424
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1824,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 520.0,
+      "good": 416.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0587,
+      "log_bad": 6.2538,
+      "log_good": 6.0307
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 104.0,
+      "good": 77.0,
+      "ratio": 0.7404,
+      "suggested_scalar": -0.0791,
+      "log_bad": 4.6444,
+      "log_good": 4.3438
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5896.1538,
+      "good": 3730.3986,
+      "ratio": 0.6327,
+      "suggested_scalar": -0.1205,
+      "log_bad": 8.6821,
+      "log_good": 8.2243
+    },
+    "readability.mean_total_lines": {
+      "bad": 38.0,
+      "good": 65.0,
+      "ratio": 1.7105,
+      "suggested_scalar": 0.1412,
+      "log_bad": 3.6376,
+      "log_good": 4.1744
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 12.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1067,
+      "log_bad": 2.0794,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2268.0,
+      "good": 1946.2949,
+      "ratio": 0.8582,
+      "suggested_scalar": -0.0403,
+      "log_bad": 7.7267,
+      "log_good": 7.5737
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 634.0,
+      "good": 609.0,
+      "ratio": 0.9606,
+      "suggested_scalar": -0.0106,
+      "log_bad": 6.452,
+      "log_good": 6.4118
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 48.1053,
+      "good": 29.8308,
+      "ratio": 0.6201,
+      "suggested_scalar": -0.1257,
+      "log_bad": 3.8734,
+      "log_good": 3.3955
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0793,
+      "good": 1.1034,
+      "ratio": 1.0223,
+      "suggested_scalar": 0.0058,
+      "log_bad": 0.0763,
+      "log_good": 0.0984
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 16.0,
+      "good": 21.0,
+      "ratio": 1.3125,
+      "suggested_scalar": 0.0716,
+      "log_bad": 2.7726,
+      "log_good": 3.0445
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.5873,
+      "good": 0.7027,
+      "ratio": 1.1965,
+      "suggested_scalar": 0.0472,
+      "log_bad": -0.5322,
+      "log_good": -0.3528
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 9.0,
+      "good": 11.0,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.0528,
+      "log_bad": 2.1972,
+      "log_good": 2.3979
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.8779,
+      "good": 0.939,
+      "ratio": 1.0696,
+      "suggested_scalar": 0.0177,
+      "log_bad": -0.1302,
+      "log_good": -0.0629
+    },
+    "halstead.mean_length": {
+      "bad": 378.0,
+      "good": 322.0,
+      "ratio": 0.8519,
+      "suggested_scalar": -0.0422,
+      "log_bad": 5.9349,
+      "log_good": 5.7746
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.0,
+      "good": 13.5,
+      "ratio": 1.2273,
+      "suggested_scalar": 0.0539,
+      "log_bad": 2.3979,
+      "log_good": 2.6027
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7415,
+      "good": 6.375,
+      "ratio": 0.9456,
+      "suggested_scalar": -0.0147,
+      "log_bad": 1.9083,
+      "log_good": 1.8524
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1482,
+      "good": 0.1041,
+      "ratio": 0.7024,
+      "suggested_scalar": -0.0929,
+      "log_bad": -1.9092,
+      "log_good": -2.2624
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 46.7949,
+      "good": 34.5,
+      "ratio": 0.7373,
+      "suggested_scalar": -0.0802,
+      "log_bad": 3.8458,
+      "log_good": 3.541
+    },
+    "branching.mean_branch_count": {
+      "bad": 18.0,
+      "good": 3.0,
+      "ratio": 0.1667,
+      "suggested_scalar": -0.4715,
+      "log_bad": 2.8904,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 73.0,
+      "good": 51.0,
+      "ratio": 0.6986,
+      "suggested_scalar": -0.0944,
+      "log_bad": 4.2905,
+      "log_good": 3.9318
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5512,
+      "good": 0.6232,
+      "ratio": 1.1306,
+      "suggested_scalar": 0.0323,
+      "log_bad": -0.5957,
+      "log_good": -0.4729
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 38.0,
+      "good": 65.0,
+      "ratio": 1.7105,
+      "suggested_scalar": 0.1412,
+      "log_bad": 3.6376,
+      "log_good": 4.1744
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 8.0,
+      "good": 1.0,
+      "ratio": 0.125,
+      "suggested_scalar": -0.5472,
+      "log_bad": 2.0794,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 12.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0406,
+      "log_bad": 2.6391,
+      "log_good": 2.4849
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.does_not_use_force_try": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 26.0,
+      "good": 35.0,
+      "ratio": 1.3462,
+      "suggested_scalar": 0.1191,
+      "log_bad": 3.2581,
+      "log_good": 3.5553
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 1.6667,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0422,
+      "log_bad": 0.4055,
+      "log_good": 0.5108
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8205,
+      "good": 0.7255,
+      "ratio": 0.8842,
+      "suggested_scalar": -0.0493,
+      "log_bad": -0.1978,
+      "log_good": -0.3209
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6628,
+      "good": 4.4677,
+      "ratio": 0.9582,
+      "suggested_scalar": -0.0171,
+      "log_bad": 1.5396,
+      "log_good": 1.4969
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 104.0,
+      "good": 91.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0535,
+      "log_bad": 4.6444,
+      "log_good": 4.5109
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6022,
+      "good": 0.5117,
+      "ratio": 0.8497,
+      "suggested_scalar": -0.0653,
+      "log_bad": -0.5072,
+      "log_good": -0.67
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 13.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.0573,
+      "log_bad": 2.7081,
+      "log_good": 2.5649
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7151,
+      "good": 0.6699,
+      "ratio": 0.9368,
+      "suggested_scalar": -0.0262,
+      "log_bad": -0.3353,
+      "log_good": -0.4006
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.8205,
+      "good": 6.5882,
+      "ratio": 1.3667,
+      "suggested_scalar": 0.1252,
+      "log_bad": 1.5729,
+      "log_good": 1.8853
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 317.0,
+      "good": 337.0,
+      "ratio": 1.0631,
+      "suggested_scalar": 0.0245,
+      "log_bad": 5.7589,
+      "log_good": 5.8201
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0894,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0068,
+      "good": 1.0,
+      "ratio": 147.0588,
+      "suggested_scalar": 2.0,
+      "log_bad": -4.9908,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1026,
+      "good": 1.0,
+      "ratio": 9.7466,
+      "suggested_scalar": 0.9124,
+      "log_bad": -2.2769,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8668,
+      "good": 0.9504,
+      "ratio": 1.0964,
+      "suggested_scalar": 0.0369,
+      "log_bad": -0.1429,
+      "log_good": -0.0509
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 108.0,
+      "good": 105.0,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.0113,
+      "log_bad": 4.6821,
+      "log_good": 4.654
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 94.4242,
+      "good": 88.6321,
+      "ratio": 0.9387,
+      "suggested_scalar": -0.0254,
+      "log_bad": 4.5478,
+      "log_good": 4.4845
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.462,
+      "good": 0.5417,
+      "ratio": 1.1725,
+      "suggested_scalar": 0.0638,
+      "log_bad": -0.7722,
+      "log_good": -0.613
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 21.3754,
+      "good": 20.6307,
+      "ratio": 0.9652,
+      "suggested_scalar": -0.0142,
+      "log_bad": 3.0622,
+      "log_good": 3.0268
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1627.0,
+      "good": 1891.0,
+      "ratio": 1.1623,
+      "suggested_scalar": 0.0603,
+      "log_bad": 7.3945,
+      "log_good": 7.5449
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.4615,
+      "good": 0.3137,
+      "ratio": 0.6797,
+      "suggested_scalar": -0.1547,
+      "log_bad": -0.7733,
+      "log_good": -1.1593
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7949,
+      "good": 0.6863,
+      "ratio": 0.8634,
+      "suggested_scalar": -0.0589,
+      "log_bad": -0.2295,
+      "log_good": -0.3764
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.1282,
+      "good": 6.6078,
+      "ratio": 0.8129,
+      "suggested_scalar": -0.083,
+      "log_bad": 2.0953,
+      "log_good": 1.8883
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 8.3524,
+      "good": 15.5755,
+      "ratio": 1.8648,
+      "suggested_scalar": 0.2497,
+      "log_bad": 2.1225,
+      "log_good": 2.7457
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 46.0,
+      "good": 33.0,
+      "ratio": 0.7174,
+      "suggested_scalar": -0.1331,
+      "log_bad": 3.8286,
+      "log_good": 3.4965
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9546,
+      "good": 0.9549,
+      "ratio": 1.0003,
+      "suggested_scalar": 0.0001,
+      "log_bad": -0.0465,
+      "log_good": -0.0461
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 29.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3673,
+      "log_good": 3.3673
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6005,
+      "good": 0.6626,
+      "ratio": 1.1034,
+      "suggested_scalar": 0.0394,
+      "log_bad": -0.51,
+      "log_good": -0.4116
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3048,
+      "good": 0.3373,
+      "ratio": 1.1066,
+      "suggested_scalar": 0.0406,
+      "log_bad": -1.1881,
+      "log_good": -1.0868
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5031,
+      "good": 2.9639,
+      "ratio": 1.1841,
+      "suggested_scalar": 0.0677,
+      "log_bad": 0.9175,
+      "log_good": 1.0865
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 315.0,
+      "good": 335.0,
+      "ratio": 1.0635,
+      "suggested_scalar": 0.0247,
+      "log_bad": 5.7526,
+      "log_good": 5.8141
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 8.0,
+      "good": 18.0,
+      "ratio": 2.25,
+      "suggested_scalar": 0.325,
+      "log_bad": 2.0794,
+      "log_good": 2.8904
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0789,
+      "good": 0.0682,
+      "ratio": 0.8644,
+      "suggested_scalar": -0.0584,
+      "log_bad": -2.5396,
+      "log_good": -2.6853
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.858,
+      "good": 5.7814,
+      "ratio": 0.9869,
+      "suggested_scalar": -0.0053,
+      "log_bad": 1.7678,
+      "log_good": 1.7546
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 35.0,
+      "good": 36.0,
+      "ratio": 1.0286,
+      "suggested_scalar": 0.0113,
+      "log_bad": 3.5553,
+      "log_good": 3.5835
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.6084,
+      "good": 1.6466,
+      "ratio": 1.0238,
+      "suggested_scalar": 0.0094,
+      "log_bad": 0.4752,
+      "log_good": 0.4987
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9394,
+      "good": 5.5938,
+      "ratio": 0.9418,
+      "suggested_scalar": -0.024,
+      "log_bad": 1.7816,
+      "log_good": 1.7217
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.796,
+      "good": 0.7728,
+      "ratio": 0.9709,
+      "suggested_scalar": -0.0119,
+      "log_bad": -0.2282,
+      "log_good": -0.2577
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2041,
+      "good": 0.15,
+      "ratio": 0.7349,
+      "suggested_scalar": -0.1234,
+      "log_bad": -1.5891,
+      "log_good": -1.8971
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.6234,
+      "good": 4.5421,
+      "ratio": 0.9824,
+      "suggested_scalar": -0.0071,
+      "log_bad": 1.5311,
+      "log_good": 1.5134
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 261.0,
+      "good": 269.0,
+      "ratio": 1.0307,
+      "suggested_scalar": 0.0121,
+      "log_bad": 5.5645,
+      "log_good": 5.5947
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7013,
+      "good": 0.7267,
+      "ratio": 1.0362,
+      "suggested_scalar": 0.0143,
+      "log_bad": -0.3548,
+      "log_good": -0.3192
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 104.0,
+      "good": 91.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0535,
+      "log_bad": 4.6444,
+      "log_good": 4.5109
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 871.0,
+      "good": 936.0,
+      "ratio": 1.0746,
+      "suggested_scalar": 0.0288,
+      "log_bad": 6.7696,
+      "log_good": 6.8416
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 136.0,
+      "good": 137.0,
+      "ratio": 1.0074,
+      "suggested_scalar": 0.0029,
+      "log_bad": 4.9127,
+      "log_good": 4.92
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0095,
+      "good": 0.0059,
+      "ratio": 0.6211,
+      "suggested_scalar": -0.1909,
+      "log_bad": -4.6565,
+      "log_good": -5.1328
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2808,
+      "good": 0.2878,
+      "ratio": 1.0249,
+      "suggested_scalar": 0.0099,
+      "log_bad": -1.2701,
+      "log_good": -1.2455
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 57.0,
+      "good": 69.0,
+      "ratio": 1.2105,
+      "suggested_scalar": 0.0766,
+      "log_bad": 4.0431,
+      "log_good": 4.2341
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1153,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 104.0,
+      "good": 91.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0535,
+      "log_bad": 4.6444,
+      "log_good": 4.5109
+    },
+    "brevity.mean_sample_size": {
+      "bad": 104.0,
+      "good": 91.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0535,
+      "log_bad": 4.6444,
+      "log_good": 4.5109
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 317.0,
+      "good": 337.0,
+      "ratio": 1.0631,
+      "suggested_scalar": 0.0245,
+      "log_bad": 5.7589,
+      "log_good": 5.8201
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 143.0,
+      "good": 163.0,
+      "ratio": 1.1399,
+      "suggested_scalar": 0.0525,
+      "log_bad": 4.9628,
+      "log_good": 5.0938
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 227.0,
+      "good": 223.0,
+      "ratio": 0.9824,
+      "suggested_scalar": -0.0071,
+      "log_bad": 5.425,
+      "log_good": 5.4072
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.8373,
+      "good": 2.1,
+      "ratio": 1.143,
+      "suggested_scalar": 0.0536,
+      "log_bad": 0.6083,
+      "log_good": 0.7419
+    },
+    "halstead.mean_effort": {
+      "bad": 55319.545,
+      "good": 69851.4663,
+      "ratio": 1.2627,
+      "suggested_scalar": 0.0935,
+      "log_bad": 10.9209,
+      "log_good": 11.1541
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8864,
+      "good": 0.8596,
+      "ratio": 0.9698,
+      "suggested_scalar": -0.0123,
+      "log_bad": -0.1206,
+      "log_good": -0.1513
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 75.0,
+      "good": 62.0,
+      "ratio": 0.8267,
+      "suggested_scalar": -0.0763,
+      "log_bad": 4.3175,
+      "log_good": 4.1271
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 178.0,
+      "good": 198.0,
+      "ratio": 1.1124,
+      "suggested_scalar": 0.0427,
+      "log_bad": 5.1818,
+      "log_good": 5.2883
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5926,
+      "good": 0.4952,
+      "ratio": 0.8356,
+      "suggested_scalar": -0.072,
+      "log_bad": -0.5232,
+      "log_good": -0.7028
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.0648,
+      "good": 8.9143,
+      "ratio": 1.1053,
+      "suggested_scalar": 0.0401,
+      "log_bad": 2.0875,
+      "log_good": 2.1877
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2041,
+      "good": 0.15,
+      "ratio": 0.7349,
+      "suggested_scalar": -0.1234,
+      "log_bad": -1.5891,
+      "log_good": -1.8971
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.4074,
+      "good": 4.7241,
+      "ratio": 1.0719,
+      "suggested_scalar": 0.0278,
+      "log_bad": 1.4833,
+      "log_good": 1.5527
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 316.0,
+      "good": 336.0,
+      "ratio": 1.0633,
+      "suggested_scalar": 0.0246,
+      "log_bad": 5.7557,
+      "log_good": 5.8171
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 42.0,
+      "good": 47.0,
+      "ratio": 1.119,
+      "suggested_scalar": 0.0451,
+      "log_bad": 3.7377,
+      "log_good": 3.8501
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3073.3081,
+      "good": 3880.637,
+      "ratio": 1.2627,
+      "suggested_scalar": 0.0935,
+      "log_bad": 8.0305,
+      "log_good": 8.2638
+    },
+    "readability.mean_total_lines": {
+      "bad": 39.0,
+      "good": 51.0,
+      "ratio": 1.3077,
+      "suggested_scalar": 0.1075,
+      "log_bad": 3.6636,
+      "log_good": 3.9318
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 12.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1625,
+      "log_bad": 2.0794,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2103.9381,
+      "good": 2180.1112,
+      "ratio": 1.0362,
+      "suggested_scalar": 0.0143,
+      "log_bad": 7.6516,
+      "log_good": 7.6871
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 650.0,
+      "good": 638.0,
+      "ratio": 0.9815,
+      "suggested_scalar": -0.0075,
+      "log_bad": 6.477,
+      "log_good": 6.4583
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 40.4615,
+      "good": 35.902,
+      "ratio": 0.8873,
+      "suggested_scalar": -0.0479,
+      "log_bad": 3.7004,
+      "log_good": 3.5808
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2312,
+      "good": 1.3179,
+      "ratio": 1.0704,
+      "suggested_scalar": 0.0273,
+      "log_bad": 0.208,
+      "log_good": 0.276
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0894,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 15.0,
+      "good": 26.0,
+      "ratio": 1.7333,
+      "suggested_scalar": 0.2204,
+      "log_bad": 2.7081,
+      "log_good": 3.2581
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 1.0,
+      "ratio": 0.25,
+      "suggested_scalar": -0.5555,
+      "log_bad": 1.3863,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8391,
+      "good": 0.8253,
+      "ratio": 0.9836,
+      "suggested_scalar": -0.0066,
+      "log_bad": -0.1754,
+      "log_good": -0.192
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9933,
+      "good": 0.9866,
+      "ratio": 0.9933,
+      "suggested_scalar": -0.0027,
+      "log_bad": -0.0067,
+      "log_good": -0.0135
+    },
+    "halstead.mean_length": {
+      "bad": 314.0,
+      "good": 335.0,
+      "ratio": 1.0669,
+      "suggested_scalar": 0.0259,
+      "log_bad": 5.7494,
+      "log_good": 5.8141
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.75,
+      "good": 12.3333,
+      "ratio": 1.8272,
+      "suggested_scalar": 0.2415,
+      "log_bad": 1.9095,
+      "log_good": 2.5123
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7004,
+      "good": 6.5078,
+      "ratio": 0.9713,
+      "suggested_scalar": -0.0117,
+      "log_bad": 1.9022,
+      "log_good": 1.873
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0879,
+      "good": 0.0862,
+      "ratio": 0.9807,
+      "suggested_scalar": -0.0078,
+      "log_bad": -2.4316,
+      "log_good": -2.4511
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 26.2933,
+      "good": 32.0403,
+      "ratio": 1.2186,
+      "suggested_scalar": 0.0792,
+      "log_bad": 3.2693,
+      "log_good": 3.467
+    },
+    "branching.mean_branch_count": {
+      "bad": 18.0,
+      "good": 16.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0472,
+      "log_bad": 2.8904,
+      "log_good": 2.7726
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 64.0,
+      "good": 52.0,
+      "ratio": 0.8125,
+      "suggested_scalar": -0.0832,
+      "log_bad": 4.1589,
+      "log_good": 3.9512
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7489,
+      "good": 0.6906,
+      "ratio": 0.9222,
+      "suggested_scalar": -0.0325,
+      "log_bad": -0.2891,
+      "log_good": -0.3702
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 39.0,
+      "good": 51.0,
+      "ratio": 1.3077,
+      "suggested_scalar": 0.1075,
+      "log_bad": 3.6636,
+      "log_good": 3.9318
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.uses_identity_operators": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0203,
+      "good": 0.0193,
+      "ratio": 0.9507,
+      "suggested_scalar": -0.9495,
+      "log_bad": -3.8971,
+      "log_good": -3.9477
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.8,
+      "good": 1.8,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.5878,
+      "log_good": 0.5878
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7959,
+      "good": 0.7959,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2283,
+      "log_good": -0.2283
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0203,
+      "good": 0.0193,
+      "ratio": 0.9507,
+      "suggested_scalar": -0.9495,
+      "log_bad": -3.8971,
+      "log_good": -3.9477
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7566,
+      "good": 4.7657,
+      "ratio": 1.0019,
+      "suggested_scalar": 0.0359,
+      "log_bad": 1.5595,
+      "log_good": 1.5614
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 81.0,
+      "good": 82.0,
+      "ratio": 1.0123,
+      "suggested_scalar": 0.2306,
+      "log_bad": 4.3944,
+      "log_good": 4.4067
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.47,
+      "good": 0.47,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.755,
+      "log_good": -0.755
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 19.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 1.0163,
+      "log_bad": 2.8904,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6474,
+      "good": 0.6503,
+      "ratio": 1.0045,
+      "suggested_scalar": 0.084,
+      "log_bad": -0.4348,
+      "log_good": -0.4303
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.6122,
+      "good": 2.6122,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9602,
+      "log_good": 0.9602
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 395.0,
+      "good": 414.0,
+      "ratio": 1.0481,
+      "suggested_scalar": 0.8831,
+      "log_bad": 5.9789,
+      "log_good": 6.0259
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.002,
+      "good": 0.0019,
+      "ratio": 0.95,
+      "suggested_scalar": -0.9642,
+      "log_bad": -6.2146,
+      "log_good": -6.2659
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.002,
+      "good": 0.0019,
+      "ratio": 0.95,
+      "suggested_scalar": -0.9642,
+      "log_bad": -6.2146,
+      "log_good": -6.2659
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0395,
+      "good": 1.055,
+      "ratio": 1.0149,
+      "suggested_scalar": 0.2782,
+      "log_bad": 0.0387,
+      "log_good": 0.0535
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 113.0,
+      "good": 114.0,
+      "ratio": 1.0088,
+      "suggested_scalar": 0.1656,
+      "log_bad": 4.7274,
+      "log_good": 4.7362
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 93.2921,
+      "good": 93.1502,
+      "ratio": 0.9985,
+      "suggested_scalar": -0.0286,
+      "log_bad": 4.5357,
+      "log_good": 4.5342
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6091,
+      "good": 0.6247,
+      "ratio": 1.0256,
+      "suggested_scalar": 0.4754,
+      "log_bad": -0.4958,
+      "log_good": -0.4705
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 12.4207,
+      "good": 12.3128,
+      "ratio": 0.9913,
+      "suggested_scalar": -0.164,
+      "log_bad": 2.5194,
+      "log_good": 2.5106
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1536.0,
+      "good": 1572.0,
+      "ratio": 1.0234,
+      "suggested_scalar": 0.4355,
+      "log_bad": 7.3369,
+      "log_good": 7.3601
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1633,
+      "good": 0.1633,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.8122,
+      "log_good": -1.8122
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7347,
+      "good": 0.7347,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3083,
+      "log_good": -0.3083
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.0612,
+      "good": 8.449,
+      "ratio": 1.0481,
+      "suggested_scalar": 0.8832,
+      "log_bad": 2.0871,
+      "log_good": 2.134
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.4211,
+      "good": 5.4211,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6903,
+      "log_good": 1.6903
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 78.0,
+      "good": 79.0,
+      "ratio": 1.0128,
+      "suggested_scalar": 0.2395,
+      "log_bad": 4.3567,
+      "log_good": 4.3694
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9442,
+      "good": 0.9553,
+      "ratio": 1.0118,
+      "suggested_scalar": 0.2197,
+      "log_bad": -0.0574,
+      "log_good": -0.0457
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 28.0,
+      "ratio": 1.037,
+      "suggested_scalar": 0.6836,
+      "log_bad": 3.2958,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6081,
+      "good": 0.6139,
+      "ratio": 1.0095,
+      "suggested_scalar": 0.1784,
+      "log_bad": -0.4974,
+      "log_good": -0.4879
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4122,
+      "good": 0.4442,
+      "ratio": 1.0776,
+      "suggested_scalar": 1.4054,
+      "log_bad": -0.8862,
+      "log_good": -0.8115
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5515,
+      "good": 2.5898,
+      "ratio": 1.015,
+      "suggested_scalar": 0.2801,
+      "log_bad": 0.9367,
+      "log_good": 0.9516
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 393.0,
+      "good": 412.0,
+      "ratio": 1.0483,
+      "suggested_scalar": 0.8875,
+      "log_bad": 5.9738,
+      "log_good": 6.021
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0177,
+      "good": 0.0169,
+      "ratio": 0.9548,
+      "suggested_scalar": -0.8694,
+      "log_bad": -4.0342,
+      "log_good": -4.0804
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.9773,
+      "ratio": 1.0039,
+      "suggested_scalar": 0.0728,
+      "log_bad": 1.7841,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1716,
+      "good": 1.1659,
+      "ratio": 0.9951,
+      "suggested_scalar": -0.0917,
+      "log_bad": 0.1584,
+      "log_good": 0.1535
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0088,
+      "good": 0.0088,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.733,
+      "log_good": -4.733
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4467,
+      "good": 5.4004,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.1605,
+      "log_bad": 1.695,
+      "log_good": 1.6865
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7989,
+      "good": 0.7973,
+      "ratio": 0.998,
+      "suggested_scalar": -0.0377,
+      "log_bad": -0.2245,
+      "log_good": -0.2265
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2097,
+      "good": 0.2097,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.5621,
+      "log_good": -1.5621
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.5243,
+      "good": 3.509,
+      "ratio": 0.9957,
+      "suggested_scalar": -0.0818,
+      "log_bad": 1.2597,
+      "log_good": 1.2553
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 294.0,
+      "good": 296.0,
+      "ratio": 1.0068,
+      "suggested_scalar": 0.1274,
+      "log_bad": 5.6836,
+      "log_good": 5.6904
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7312,
+      "good": 0.7714,
+      "ratio": 1.055,
+      "suggested_scalar": 1.006,
+      "log_bad": -0.3131,
+      "log_good": -0.2595
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 86.0,
+      "ratio": 1.0118,
+      "suggested_scalar": 0.2198,
+      "log_bad": 4.4427,
+      "log_good": 4.4543
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 717.0,
+      "good": 723.0,
+      "ratio": 1.0084,
+      "suggested_scalar": 0.1566,
+      "log_bad": 6.5751,
+      "log_good": 6.5834
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 120.0,
+      "good": 122.0,
+      "ratio": 1.0167,
+      "suggested_scalar": 0.3107,
+      "log_bad": 4.7875,
+      "log_good": 4.804
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0101,
+      "good": 0.0097,
+      "ratio": 0.9604,
+      "suggested_scalar": -0.7596,
+      "log_bad": -4.5952,
+      "log_good": -4.6356
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2278,
+      "good": 0.2174,
+      "ratio": 0.9543,
+      "suggested_scalar": -0.8784,
+      "log_bad": -1.4793,
+      "log_good": -1.526
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 70.0,
+      "good": 71.0,
+      "ratio": 1.0143,
+      "suggested_scalar": 0.2666,
+      "log_bad": 4.2485,
+      "log_good": 4.2627
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 86.0,
+      "ratio": 1.0118,
+      "suggested_scalar": 0.2198,
+      "log_bad": 4.4427,
+      "log_good": 4.4543
+    },
+    "brevity.mean_sample_size": {
+      "bad": 85.0,
+      "good": 86.0,
+      "ratio": 1.0118,
+      "suggested_scalar": 0.2198,
+      "log_bad": 4.4427,
+      "log_good": 4.4543
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 395.0,
+      "good": 414.0,
+      "ratio": 1.0481,
+      "suggested_scalar": 0.8831,
+      "log_bad": 5.9789,
+      "log_good": 6.0259
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 228.0,
+      "good": 245.0,
+      "ratio": 1.0746,
+      "suggested_scalar": 1.3517,
+      "log_bad": 5.4293,
+      "log_good": 5.5013
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 224.0,
+      "good": 226.0,
+      "ratio": 1.0089,
+      "suggested_scalar": 0.1671,
+      "log_bad": 5.4116,
+      "log_good": 5.4205
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0025,
+      "good": 0.0024,
+      "ratio": 0.96,
+      "suggested_scalar": -0.7673,
+      "log_bad": -5.9915,
+      "log_good": -6.0323
+    },
+    "heaps.mean_k": {
+      "bad": 1.8413,
+      "good": 1.7789,
+      "ratio": 0.9661,
+      "suggested_scalar": -0.6481,
+      "log_bad": 0.6105,
+      "log_good": 0.576
+    },
+    "halstead.mean_effort": {
+      "bad": 65807.643,
+      "good": 73195.6736,
+      "ratio": 1.1123,
+      "suggested_scalar": 2.0,
+      "log_bad": 11.0945,
+      "log_good": 11.2009
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8498,
+      "good": 0.8404,
+      "ratio": 0.9889,
+      "suggested_scalar": -0.2091,
+      "log_bad": -0.1628,
+      "log_good": -0.1739
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 54.0,
+      "good": 54.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.989,
+      "log_good": 3.989
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 226.0,
+      "good": 242.0,
+      "ratio": 1.0708,
+      "suggested_scalar": 1.2858,
+      "log_bad": 5.4205,
+      "log_good": 5.4889
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4248,
+      "good": 0.4211,
+      "ratio": 0.9913,
+      "suggested_scalar": -0.1644,
+      "log_bad": -0.8561,
+      "log_good": -0.8649
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.3451,
+      "good": 6.3421,
+      "ratio": 0.9995,
+      "suggested_scalar": -0.0089,
+      "log_bad": 1.8477,
+      "log_good": 1.8472
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2097,
+      "good": 0.2097,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.5621,
+      "log_good": -1.5621
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.4331,
+      "good": 5.5614,
+      "ratio": 1.0236,
+      "suggested_scalar": 0.4387,
+      "log_bad": 1.6925,
+      "log_good": 1.7158
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 394.0,
+      "good": 413.0,
+      "ratio": 1.0482,
+      "suggested_scalar": 0.8853,
+      "log_bad": 5.9764,
+      "log_good": 6.0234
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 63.0,
+      "good": 67.0,
+      "ratio": 1.0635,
+      "suggested_scalar": 1.1571,
+      "log_bad": 4.1431,
+      "log_good": 4.2047
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3655.9802,
+      "good": 4066.4263,
+      "ratio": 1.1123,
+      "suggested_scalar": 2.0,
+      "log_bad": 8.2041,
+      "log_good": 8.3105
+    },
+    "readability.mean_total_lines": {
+      "bad": 49.0,
+      "good": 49.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8918,
+      "log_good": 3.8918
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 2193.5881,
+      "good": 2314.1489,
+      "ratio": 1.055,
+      "suggested_scalar": 1.0057,
+      "log_bad": 7.6933,
+      "log_good": 7.7468
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 602.0,
+      "good": 607.0,
+      "ratio": 1.0083,
+      "suggested_scalar": 0.1555,
+      "log_bad": 6.4003,
+      "log_good": 6.4085
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.0816,
+      "good": 30.8163,
+      "ratio": 1.0244,
+      "suggested_scalar": 0.4536,
+      "log_bad": 3.4039,
+      "log_good": 3.428
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2454,
+      "good": 1.2424,
+      "ratio": 0.9976,
+      "suggested_scalar": -0.0453,
+      "log_bad": 0.2195,
+      "log_good": 0.217
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 30.0,
+      "good": 30.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4012,
+      "log_good": 3.4012
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7857,
+      "good": 0.7736,
+      "ratio": 0.9846,
+      "suggested_scalar": -0.2917,
+      "log_bad": -0.2412,
+      "log_good": -0.2567
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9819,
+      "good": 0.985,
+      "ratio": 1.0032,
+      "suggested_scalar": 0.0593,
+      "log_bad": -0.0183,
+      "log_good": -0.0151
+    },
+    "halstead.mean_length": {
+      "bad": 346.0,
+      "good": 364.0,
+      "ratio": 1.052,
+      "suggested_scalar": 0.9533,
+      "log_bad": 5.8464,
+      "log_good": 5.8972
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 12.4,
+      "good": 12.4,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5177,
+      "log_good": 2.5177
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4094,
+      "good": 6.4263,
+      "ratio": 1.0026,
+      "suggested_scalar": 0.0495,
+      "log_bad": 1.8578,
+      "log_good": 1.8604
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1484,
+      "good": 0.1559,
+      "ratio": 1.0505,
+      "suggested_scalar": 0.9268,
+      "log_bad": -1.9078,
+      "log_good": -1.8585
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.0,
+      "good": 31.6296,
+      "ratio": 1.0543,
+      "suggested_scalar": 0.9943,
+      "log_bad": 3.4012,
+      "log_good": 3.4541
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 48.0,
+      "good": 48.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8712,
+      "log_good": 3.8712
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6875,
+      "good": 0.6858,
+      "ratio": 0.9975,
+      "suggested_scalar": -0.0465,
+      "log_bad": -0.3747,
+      "log_good": -0.3772
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 49.0,
+      "good": 49.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8918,
+      "log_good": 3.8918
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "testing.test_single_concept": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 36.0,
+      "good": 51.0,
+      "ratio": 1.4167,
+      "suggested_scalar": 0.1857,
+      "log_bad": 3.5835,
+      "log_good": 3.9318
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0141,
+      "good": 0.0276,
+      "ratio": 1.9574,
+      "suggested_scalar": 0.3581,
+      "log_bad": -4.2616,
+      "log_good": -3.5899
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 1.3333,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0628,
+      "log_bad": 0.4055,
+      "log_good": 0.2877
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9423,
+      "good": 0.6706,
+      "ratio": 0.7117,
+      "suggested_scalar": -0.1814,
+      "log_bad": -0.0594,
+      "log_good": -0.3996
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0141,
+      "good": 0.0276,
+      "ratio": 1.9574,
+      "suggested_scalar": 0.3581,
+      "log_bad": -4.2616,
+      "log_good": -3.5899
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7311,
+      "good": 4.5839,
+      "ratio": 0.9689,
+      "suggested_scalar": -0.0169,
+      "log_bad": 1.5542,
+      "log_good": 1.5226
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 103.0,
+      "good": 109.0,
+      "ratio": 1.0583,
+      "suggested_scalar": 0.0302,
+      "log_bad": 4.6347,
+      "log_good": 4.6913
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4583,
+      "good": 0.4003,
+      "ratio": 0.8734,
+      "suggested_scalar": -0.0722,
+      "log_bad": -0.7802,
+      "log_good": -0.9155
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5294,
+      "good": 0.4688,
+      "ratio": 0.8855,
+      "suggested_scalar": -0.0648,
+      "log_bad": -0.636,
+      "log_good": -0.7576
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.0769,
+      "good": 3.8588,
+      "ratio": 1.2541,
+      "suggested_scalar": 0.1207,
+      "log_bad": 1.1239,
+      "log_good": 1.3504
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 639.0,
+      "good": 868.0,
+      "ratio": 1.3584,
+      "suggested_scalar": 0.1633,
+      "log_bad": 6.4599,
+      "log_good": 6.7662
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1534,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1346,
+      "good": 1.0,
+      "ratio": 7.4294,
+      "suggested_scalar": 1.0694,
+      "log_bad": -2.0054,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1471,
+      "good": 1.2092,
+      "ratio": 1.0541,
+      "suggested_scalar": 0.0281,
+      "log_bad": 0.1372,
+      "log_good": 0.19
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 224.0,
+      "good": 311.0,
+      "ratio": 1.3884,
+      "suggested_scalar": 0.175,
+      "log_bad": 5.4116,
+      "log_good": 5.7398
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 103.5151,
+      "good": 105.4447,
+      "ratio": 1.0186,
+      "suggested_scalar": 0.0098,
+      "log_bad": 4.6397,
+      "log_good": 4.6582
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6881,
+      "good": 0.7624,
+      "ratio": 1.108,
+      "suggested_scalar": 0.0547,
+      "log_bad": -0.3738,
+      "log_good": -0.2713
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 6.4281,
+      "good": 8.1791,
+      "ratio": 1.2724,
+      "suggested_scalar": 0.1285,
+      "log_bad": 1.8607,
+      "log_good": 2.1016
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2233.0,
+      "good": 3231.0,
+      "ratio": 1.4469,
+      "suggested_scalar": 0.197,
+      "log_bad": 7.7111,
+      "log_good": 8.0805
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 0.0235,
+      "ratio": 0.0235,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -3.7508
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9231,
+      "good": 0.6471,
+      "ratio": 0.701,
+      "suggested_scalar": -0.1894,
+      "log_bad": -0.08,
+      "log_good": -0.4353
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 14.2,
+      "good": 10.2118,
+      "ratio": 0.7191,
+      "suggested_scalar": -0.1758,
+      "log_bad": 2.6532,
+      "log_good": 2.3235
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3696,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.6095,
+      "good": 3.2742,
+      "ratio": 2.0343,
+      "suggested_scalar": 0.3787,
+      "log_bad": 0.4759,
+      "log_good": 1.1861
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 186.0,
+      "good": 273.0,
+      "ratio": 1.4677,
+      "suggested_scalar": 0.2046,
+      "log_bad": 5.2257,
+      "log_good": 5.6095
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9564,
+      "good": 0.9495,
+      "ratio": 0.9928,
+      "suggested_scalar": -0.0039,
+      "log_bad": -0.0446,
+      "log_good": -0.0518
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 27.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0628,
+      "log_bad": 3.1781,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6426,
+      "good": 0.7103,
+      "ratio": 1.1054,
+      "suggested_scalar": 0.0534,
+      "log_bad": -0.4422,
+      "log_good": -0.3421
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4694,
+      "good": 0.612,
+      "ratio": 1.3038,
+      "suggested_scalar": 0.1415,
+      "log_bad": -0.7563,
+      "log_good": -0.491
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7982,
+      "good": 3.4519,
+      "ratio": 1.2336,
+      "suggested_scalar": 0.1119,
+      "log_bad": 1.029,
+      "log_good": 1.2389
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 637.0,
+      "good": 866.0,
+      "ratio": 1.3595,
+      "suggested_scalar": 0.1638,
+      "log_bad": 6.4568,
+      "log_good": 6.7639
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 6.0,
+      "good": 76.0,
+      "ratio": 12.6667,
+      "suggested_scalar": 1.3538,
+      "log_bad": 1.7918,
+      "log_good": 4.3307
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0548,
+      "good": 0.0461,
+      "ratio": 0.8412,
+      "suggested_scalar": -0.0922,
+      "log_bad": -2.9041,
+      "log_good": -3.0769
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0661,
+      "good": 6.0875,
+      "ratio": 1.0035,
+      "suggested_scalar": 0.0019,
+      "log_bad": 1.8027,
+      "log_good": 1.8062
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 37.0,
+      "good": 36.0,
+      "ratio": 0.973,
+      "suggested_scalar": -0.0146,
+      "log_bad": 3.6109,
+      "log_good": 3.5835
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6867,
+      "good": 0.572,
+      "ratio": 0.833,
+      "suggested_scalar": -0.0975,
+      "log_bad": -0.3759,
+      "log_good": -0.5586
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6121,
+      "good": 5.6806,
+      "ratio": 1.0122,
+      "suggested_scalar": 0.0065,
+      "log_bad": 1.7249,
+      "log_good": 1.7371
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7799,
+      "good": 0.753,
+      "ratio": 0.9655,
+      "suggested_scalar": -0.0187,
+      "log_bad": -0.2486,
+      "log_good": -0.2837
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1613,
+      "good": 0.1414,
+      "ratio": 0.8766,
+      "suggested_scalar": -0.0702,
+      "log_bad": -1.8245,
+      "log_good": -1.9562
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.5354,
+      "good": 2.8599,
+      "ratio": 1.128,
+      "suggested_scalar": 0.0642,
+      "log_bad": 0.9304,
+      "log_good": 1.0508
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 9.0,
+      "good": 12.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1534,
+      "log_bad": 2.1972,
+      "log_good": 2.4849
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 432.0,
+      "good": 490.0,
+      "ratio": 1.1343,
+      "suggested_scalar": 0.0672,
+      "log_bad": 6.0684,
+      "log_good": 6.1944
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.3262,
+      "good": 1.7078,
+      "ratio": 1.2877,
+      "suggested_scalar": 0.1348,
+      "log_bad": 0.2823,
+      "log_good": 0.5352
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 124.0,
+      "ratio": 1.0973,
+      "suggested_scalar": 0.0495,
+      "log_bad": 4.7274,
+      "log_good": 4.8203
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1195.0,
+      "good": 1706.0,
+      "ratio": 1.4276,
+      "suggested_scalar": 0.1898,
+      "log_bad": 7.0859,
+      "log_good": 7.4419
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 249.0,
+      "good": 298.0,
+      "ratio": 1.1968,
+      "suggested_scalar": 0.0958,
+      "log_bad": 5.5175,
+      "log_good": 5.6971
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0031,
+      "good": 0.0023,
+      "ratio": 0.7419,
+      "suggested_scalar": -0.1592,
+      "log_bad": -5.7764,
+      "log_good": -6.0748
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2629,
+      "good": 0.2465,
+      "ratio": 0.9376,
+      "suggested_scalar": -0.0343,
+      "log_bad": -1.336,
+      "log_good": -1.4004
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 122.0,
+      "good": 157.0,
+      "ratio": 1.2869,
+      "suggested_scalar": 0.1345,
+      "log_bad": 4.804,
+      "log_good": 5.0562
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 8.0,
+      "good": 9.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0628,
+      "log_bad": 2.0794,
+      "log_good": 2.1972
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 124.0,
+      "ratio": 1.0973,
+      "suggested_scalar": 0.0495,
+      "log_bad": 4.7274,
+      "log_good": 4.8203
+    },
+    "brevity.mean_sample_size": {
+      "bad": 113.0,
+      "good": 124.0,
+      "ratio": 1.0973,
+      "suggested_scalar": 0.0495,
+      "log_bad": 4.7274,
+      "log_good": 4.8203
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 639.0,
+      "good": 868.0,
+      "ratio": 1.3584,
+      "suggested_scalar": 0.1633,
+      "log_bad": 6.4599,
+      "log_good": 6.7662
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 354.0,
+      "good": 455.0,
+      "ratio": 1.2853,
+      "suggested_scalar": 0.1338,
+      "log_bad": 5.8693,
+      "log_good": 6.1203
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 321.0,
+      "good": 363.0,
+      "ratio": 1.1308,
+      "suggested_scalar": 0.0656,
+      "log_bad": 5.7714,
+      "log_good": 5.8944
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0141,
+      "good": 0.0138,
+      "ratio": 0.9787,
+      "suggested_scalar": -0.0115,
+      "log_bad": -4.2616,
+      "log_good": -4.2831
+    },
+    "heaps.mean_k": {
+      "bad": 4.2719,
+      "good": 5.662,
+      "ratio": 1.3254,
+      "suggested_scalar": 0.1502,
+      "log_bad": 1.4521,
+      "log_good": 1.7338
+    },
+    "halstead.mean_effort": {
+      "bad": 150476.732,
+      "good": 251364.6706,
+      "ratio": 1.6705,
+      "suggested_scalar": 0.2736,
+      "log_bad": 11.9216,
+      "log_good": 12.4347
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8229,
+      "good": 0.8169,
+      "ratio": 0.9927,
+      "suggested_scalar": -0.0039,
+      "log_bad": -0.1949,
+      "log_good": -0.2022
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 79.0,
+      "good": 82.0,
+      "ratio": 1.038,
+      "suggested_scalar": 0.0199,
+      "log_bad": 4.3694,
+      "log_good": 4.4067
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 346.0,
+      "good": 459.0,
+      "ratio": 1.3266,
+      "suggested_scalar": 0.1507,
+      "log_bad": 5.8464,
+      "log_good": 6.1291
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3348,
+      "good": 0.2605,
+      "ratio": 0.7781,
+      "suggested_scalar": -0.1338,
+      "log_bad": -1.0942,
+      "log_good": -1.3452
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.3348,
+      "good": 5.4855,
+      "ratio": 1.0282,
+      "suggested_scalar": 0.0149,
+      "log_bad": 1.6743,
+      "log_good": 1.7021
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1613,
+      "good": 0.1414,
+      "ratio": 0.8766,
+      "suggested_scalar": -0.0702,
+      "log_bad": -1.8245,
+      "log_good": -1.9562
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.68,
+      "good": 4.0847,
+      "ratio": 0.7191,
+      "suggested_scalar": -0.1758,
+      "log_bad": 1.737,
+      "log_good": 1.4072
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 638.0,
+      "good": 867.0,
+      "ratio": 1.3589,
+      "suggested_scalar": 0.1635,
+      "log_bad": 6.4583,
+      "log_good": 6.765
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 14.0,
+      "good": 16.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.0712,
+      "log_bad": 2.6391,
+      "log_good": 2.7726
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 94.0,
+      "good": 154.0,
+      "ratio": 1.6383,
+      "suggested_scalar": 0.2632,
+      "log_bad": 4.5433,
+      "log_good": 5.037
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 8359.8184,
+      "good": 13964.7039,
+      "ratio": 1.6705,
+      "suggested_scalar": 0.2736,
+      "log_bad": 9.0312,
+      "log_good": 9.5443
+    },
+    "readability.mean_total_lines": {
+      "bad": 45.0,
+      "good": 85.0,
+      "ratio": 1.8889,
+      "suggested_scalar": 0.3391,
+      "log_bad": 3.8067,
+      "log_good": 4.4427
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.2162,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 3978.4678,
+      "good": 5123.5155,
+      "ratio": 1.2878,
+      "suggested_scalar": 0.1349,
+      "log_bad": 8.2887,
+      "log_good": 8.5416
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 798.0,
+      "good": 936.0,
+      "ratio": 1.1729,
+      "suggested_scalar": 0.0851,
+      "log_bad": 6.6821,
+      "log_good": 6.8416
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 44.9556,
+      "good": 36.8235,
+      "ratio": 0.8191,
+      "suggested_scalar": -0.1064,
+      "log_bad": 3.8057,
+      "log_good": 3.6061
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0509,
+      "good": 1.0759,
+      "ratio": 1.0238,
+      "suggested_scalar": 0.0125,
+      "log_bad": 0.0496,
+      "log_good": 0.0732
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1534,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 49.0,
+      "good": 52.0,
+      "ratio": 1.0612,
+      "suggested_scalar": 0.0317,
+      "log_bad": 3.8918,
+      "log_good": 3.9512
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 1.0,
+      "ratio": 0.1429,
+      "suggested_scalar": -1.0376,
+      "log_bad": 1.9459,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7824,
+      "good": 0.6857,
+      "ratio": 0.8764,
+      "suggested_scalar": -0.0703,
+      "log_bad": -0.2454,
+      "log_good": -0.3773
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9594,
+      "good": 0.9678,
+      "ratio": 1.0088,
+      "suggested_scalar": 0.0046,
+      "log_bad": -0.0414,
+      "log_good": -0.0327
+    },
+    "halstead.mean_length": {
+      "bad": 595.0,
+      "good": 757.0,
+      "ratio": 1.2723,
+      "suggested_scalar": 0.1284,
+      "log_bad": 6.3886,
+      "log_good": 6.6294
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 2.25,
+      "good": 10.3333,
+      "ratio": 4.5926,
+      "suggested_scalar": 0.8129,
+      "log_bad": 0.8109,
+      "log_good": 2.3354
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8202,
+      "good": 6.9542,
+      "ratio": 1.0196,
+      "suggested_scalar": 0.0104,
+      "log_bad": 1.9199,
+      "log_good": 1.9393
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1587,
+      "good": 0.1409,
+      "ratio": 0.8878,
+      "suggested_scalar": -0.0634,
+      "log_bad": -1.8407,
+      "log_good": -1.9597
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 37.8228,
+      "good": 49.061,
+      "ratio": 1.2971,
+      "suggested_scalar": 0.1387,
+      "log_bad": 3.6329,
+      "log_good": 3.8931
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3696,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 75.0,
+      "good": 81.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.041,
+      "log_bad": 4.3175,
+      "log_good": 4.3944
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6199,
+      "good": 0.5675,
+      "ratio": 0.9155,
+      "suggested_scalar": -0.0471,
+      "log_bad": -0.4782,
+      "log_good": -0.5665
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 52.0,
+      "good": 85.0,
+      "ratio": 1.6346,
+      "suggested_scalar": 0.262,
+      "log_bad": 3.9512,
+      "log_good": 4.4427
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.parameter_count_under_4": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 7.0,
+      "good": 3.0,
+      "ratio": 0.4286,
+      "suggested_scalar": -0.2847,
+      "log_bad": 1.9459,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0048,
+      "good": 0.0079,
+      "ratio": 1.6458,
+      "suggested_scalar": 0.1674,
+      "log_bad": -5.3391,
+      "log_good": -4.8409
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 4.6364,
+      "good": 1.8,
+      "ratio": 0.3882,
+      "suggested_scalar": -0.3179,
+      "log_bad": 1.5339,
+      "log_good": 0.5878
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8667,
+      "good": 0.825,
+      "ratio": 0.9519,
+      "suggested_scalar": -0.0166,
+      "log_bad": -0.1431,
+      "log_good": -0.1924
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0048,
+      "good": 0.0079,
+      "ratio": 1.6458,
+      "suggested_scalar": 0.1674,
+      "log_bad": -5.3391,
+      "log_good": -4.8409
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6319,
+      "good": 4.7461,
+      "ratio": 1.0247,
+      "suggested_scalar": 0.0082,
+      "log_bad": 1.533,
+      "log_good": 1.5573
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 61.0,
+      "good": 63.0,
+      "ratio": 1.0328,
+      "suggested_scalar": 0.0108,
+      "log_bad": 4.1109,
+      "log_good": 4.1431
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.356,
+      "good": 0.375,
+      "ratio": 1.0534,
+      "suggested_scalar": 0.0175,
+      "log_bad": -1.0328,
+      "log_good": -0.9808
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 11.0,
+      "good": 15.0,
+      "ratio": 1.3636,
+      "suggested_scalar": 0.1042,
+      "log_bad": 2.3979,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5007,
+      "good": 0.5281,
+      "ratio": 1.0547,
+      "suggested_scalar": 0.0179,
+      "log_bad": -0.6917,
+      "log_good": -0.6385
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.6667,
+      "good": 3.1,
+      "ratio": 1.1625,
+      "suggested_scalar": 0.0506,
+      "log_bad": 0.9808,
+      "log_good": 1.1314
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 421.0,
+      "good": 381.0,
+      "ratio": 0.905,
+      "suggested_scalar": -0.0335,
+      "log_bad": 6.0426,
+      "log_good": 5.9428
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0345,
+      "good": 1.0662,
+      "ratio": 1.0306,
+      "suggested_scalar": 0.0101,
+      "log_bad": 0.0339,
+      "log_good": 0.0641
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 146.0,
+      "good": 129.0,
+      "ratio": 0.8836,
+      "suggested_scalar": -0.0416,
+      "log_bad": 4.9836,
+      "log_good": 4.8598
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 88.3366,
+      "good": 95.7461,
+      "ratio": 1.0839,
+      "suggested_scalar": 0.0271,
+      "log_bad": 4.4812,
+      "log_good": 4.5617
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7619,
+      "good": 0.6605,
+      "ratio": 0.8669,
+      "suggested_scalar": -0.048,
+      "log_bad": -0.2719,
+      "log_good": -0.4148
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 23.2106,
+      "good": 20.3473,
+      "ratio": 0.8766,
+      "suggested_scalar": -0.0442,
+      "log_bad": 3.1446,
+      "log_good": 3.0129
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1752.0,
+      "good": 1582.0,
+      "ratio": 0.903,
+      "suggested_scalar": -0.0343,
+      "log_bad": 7.4685,
+      "log_good": 7.3664
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8333,
+      "good": 0.8,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0137,
+      "log_bad": -0.1824,
+      "log_good": -0.2231
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 14.0333,
+      "good": 9.525,
+      "ratio": 0.6787,
+      "suggested_scalar": -0.1302,
+      "log_bad": 2.6414,
+      "log_good": 2.2539
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 0.5408,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.4222,
+      "good": 2.19,
+      "ratio": 1.5399,
+      "suggested_scalar": 0.1451,
+      "log_bad": 0.3522,
+      "log_good": 0.7839
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 145.0,
+      "good": 122.0,
+      "ratio": 0.8414,
+      "suggested_scalar": -0.058,
+      "log_bad": 4.9767,
+      "log_good": 4.804
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9476,
+      "good": 0.927,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.0074,
+      "log_bad": -0.0538,
+      "log_good": -0.0758
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 15.0,
+      "good": 18.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0613,
+      "log_bad": 2.7081,
+      "log_good": 2.8904
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.7032,
+      "good": 0.6416,
+      "ratio": 0.9124,
+      "suggested_scalar": -0.0308,
+      "log_bad": -0.3521,
+      "log_good": -0.4438
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5895,
+      "good": 0.3641,
+      "ratio": 0.6176,
+      "suggested_scalar": -0.1619,
+      "log_bad": -0.5285,
+      "log_good": -1.0103
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.3692,
+      "good": 2.7901,
+      "ratio": 0.8281,
+      "suggested_scalar": -0.0634,
+      "log_bad": 1.2147,
+      "log_good": 1.0261
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 419.0,
+      "good": 379.0,
+      "ratio": 0.9045,
+      "suggested_scalar": -0.0337,
+      "log_bad": 6.0379,
+      "log_good": 5.9375
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 6.0,
+      "good": 11.0,
+      "ratio": 1.8333,
+      "suggested_scalar": 0.2037,
+      "log_bad": 1.7918,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0594,
+      "good": 0.0604,
+      "ratio": 1.0168,
+      "suggested_scalar": 0.0056,
+      "log_bad": -2.8235,
+      "log_good": -2.8068
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.3576,
+      "good": 5.6439,
+      "ratio": 1.0534,
+      "suggested_scalar": 0.0175,
+      "log_bad": 1.6785,
+      "log_good": 1.7306
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2329,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.0591,
+      "good": 0.3511,
+      "ratio": 5.9408,
+      "suggested_scalar": 0.5987,
+      "log_bad": -2.8285,
+      "log_good": -1.0467
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 4.9368,
+      "good": 5.2492,
+      "ratio": 1.0633,
+      "suggested_scalar": 0.0206,
+      "log_bad": 1.5967,
+      "log_good": 1.6581
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8646,
+      "good": 0.8409,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.0093,
+      "log_bad": -0.1455,
+      "log_good": -0.1733
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1429,
+      "good": 0.1667,
+      "ratio": 1.1666,
+      "suggested_scalar": 0.0518,
+      "log_bad": -1.9456,
+      "log_good": -1.7916
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.8177,
+      "good": 4.5108,
+      "ratio": 0.9363,
+      "suggested_scalar": -0.0221,
+      "log_bad": 1.5723,
+      "log_good": 1.5065
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 255.0,
+      "good": 298.0,
+      "ratio": 1.1686,
+      "suggested_scalar": 0.0524,
+      "log_bad": 5.5413,
+      "log_good": 5.6971
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 14.0,
+      "good": 10.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.1131,
+      "log_bad": 2.6391,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7927,
+      "good": 0.7193,
+      "ratio": 0.9074,
+      "suggested_scalar": -0.0326,
+      "log_bad": -0.2323,
+      "log_good": -0.3295
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 62.0,
+      "good": 67.0,
+      "ratio": 1.0806,
+      "suggested_scalar": 0.0261,
+      "log_bad": 4.1271,
+      "log_good": 4.2047
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1079.0,
+      "good": 941.0,
+      "ratio": 0.8721,
+      "suggested_scalar": -0.046,
+      "log_bad": 6.9838,
+      "log_good": 6.8469
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 150.0,
+      "good": 129.0,
+      "ratio": 0.86,
+      "suggested_scalar": -0.0507,
+      "log_bad": 5.0106,
+      "log_good": 4.8598
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.3943,
+      "good": 0.3465,
+      "ratio": 0.8788,
+      "suggested_scalar": -0.0434,
+      "log_bad": -0.9306,
+      "log_good": -1.0599
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 94.0,
+      "good": 88.0,
+      "ratio": 0.9362,
+      "suggested_scalar": -0.0222,
+      "log_bad": 4.5433,
+      "log_good": 4.4773
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 11.0,
+      "good": 10.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.032,
+      "log_bad": 2.3979,
+      "log_good": 2.3026
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 62.0,
+      "good": 67.0,
+      "ratio": 1.0806,
+      "suggested_scalar": 0.0261,
+      "log_bad": 4.1271,
+      "log_good": 4.2047
+    },
+    "brevity.mean_sample_size": {
+      "bad": 62.0,
+      "good": 67.0,
+      "ratio": 1.0806,
+      "suggested_scalar": 0.0261,
+      "log_bad": 4.1271,
+      "log_good": 4.2047
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 421.0,
+      "good": 381.0,
+      "ratio": 0.905,
+      "suggested_scalar": -0.0335,
+      "log_bad": 6.0426,
+      "log_good": 5.9428
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 223.0,
+      "good": 209.0,
+      "ratio": 0.9372,
+      "suggested_scalar": -0.0218,
+      "log_bad": 5.4072,
+      "log_good": 5.3423
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 194.0,
+      "good": 217.0,
+      "ratio": 1.1186,
+      "suggested_scalar": 0.0376,
+      "log_bad": 5.2679,
+      "log_good": 5.3799
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0026,
+      "ratio": 0.0026,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.9522
+    },
+    "heaps.mean_k": {
+      "bad": 3.1641,
+      "good": 3.0875,
+      "ratio": 0.9758,
+      "suggested_scalar": -0.0082,
+      "log_bad": 1.1519,
+      "log_good": 1.1274
+    },
+    "halstead.mean_effort": {
+      "bad": 58163.1279,
+      "good": 55671.1898,
+      "ratio": 0.9572,
+      "suggested_scalar": -0.0147,
+      "log_bad": 10.971,
+      "log_good": 10.9272
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8291,
+      "good": 0.8653,
+      "ratio": 1.0437,
+      "suggested_scalar": 0.0144,
+      "log_bad": -0.1874,
+      "log_good": -0.1447
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 46.0,
+      "good": 45.0,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.0074,
+      "log_bad": 3.8286,
+      "log_good": 3.8067
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 251.0,
+      "good": 232.0,
+      "ratio": 0.9243,
+      "suggested_scalar": -0.0264,
+      "log_bad": 5.5255,
+      "log_good": 5.4467
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.2877,
+      "good": 0.3256,
+      "ratio": 1.1317,
+      "suggested_scalar": 0.0416,
+      "log_bad": -1.2458,
+      "log_good": -1.1221
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.3904,
+      "good": 7.2946,
+      "ratio": 0.987,
+      "suggested_scalar": -0.0044,
+      "log_bad": 2.0002,
+      "log_good": 1.9871
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1429,
+      "good": 0.1667,
+      "ratio": 1.1666,
+      "suggested_scalar": 0.0518,
+      "log_bad": -1.9456,
+      "log_good": -1.7916
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.6234,
+      "good": 4.5118,
+      "ratio": 0.6812,
+      "suggested_scalar": -0.129,
+      "log_bad": 1.8906,
+      "log_good": 1.5067
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 420.0,
+      "good": 380.0,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.0336,
+      "log_bad": 6.0403,
+      "log_good": 5.9402
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 12.0,
+      "good": 9.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0967,
+      "log_bad": 2.4849,
+      "log_good": 2.1972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 83.0,
+      "good": 57.0,
+      "ratio": 0.6867,
+      "suggested_scalar": -0.1263,
+      "log_bad": 4.4188,
+      "log_good": 4.0431
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3231.2849,
+      "good": 3092.8439,
+      "ratio": 0.9572,
+      "suggested_scalar": -0.0147,
+      "log_bad": 8.0806,
+      "log_good": 8.0368
+    },
+    "readability.mean_total_lines": {
+      "bad": 30.0,
+      "good": 40.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0967,
+      "log_bad": 3.4012,
+      "log_good": 3.6889
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1362,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2378.2257,
+      "good": 2157.7981,
+      "ratio": 0.9073,
+      "suggested_scalar": -0.0327,
+      "log_bad": 7.7741,
+      "log_good": 7.6768
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 520.0,
+      "good": 567.0,
+      "ratio": 1.0904,
+      "suggested_scalar": 0.0291,
+      "log_bad": 6.2538,
+      "log_good": 6.3404
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 57.2333,
+      "good": 38.35,
+      "ratio": 0.6701,
+      "suggested_scalar": -0.1345,
+      "log_bad": 4.0471,
+      "log_good": 3.6468
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2323,
+      "good": 1.1988,
+      "ratio": 0.9728,
+      "suggested_scalar": -0.0093,
+      "log_bad": 0.2089,
+      "log_good": 0.1813
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 15.0,
+      "ratio": 15.0,
+      "suggested_scalar": 0.9099,
+      "log_bad": 0.0,
+      "log_good": 2.7081
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6745,
+      "good": 0.8087,
+      "ratio": 1.199,
+      "suggested_scalar": 0.061,
+      "log_bad": -0.3938,
+      "log_good": -0.2123
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9828,
+      "good": 0.9647,
+      "ratio": 0.9816,
+      "suggested_scalar": -0.0062,
+      "log_bad": -0.0173,
+      "log_good": -0.0359
+    },
+    "halstead.mean_length": {
+      "bad": 401.0,
+      "good": 361.0,
+      "ratio": 0.9002,
+      "suggested_scalar": -0.0353,
+      "log_bad": 5.994,
+      "log_good": 5.8889
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 3.0909,
+      "good": 4.5,
+      "ratio": 1.4559,
+      "suggested_scalar": 0.1262,
+      "log_bad": 1.1285,
+      "log_good": 1.5041
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.9542,
+      "good": 6.0661,
+      "ratio": 1.0188,
+      "suggested_scalar": 0.0063,
+      "log_bad": 1.7841,
+      "log_good": 1.8027
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1273,
+      "good": 0.1321,
+      "ratio": 1.0377,
+      "suggested_scalar": 0.0124,
+      "log_bad": -2.0612,
+      "log_good": -2.0242
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 24.4565,
+      "good": 25.8,
+      "ratio": 1.0549,
+      "suggested_scalar": 0.018,
+      "log_bad": 3.1969,
+      "log_good": 3.2504
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 42.0,
+      "good": 42.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7377,
+      "log_good": 3.7377
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5155,
+      "good": 0.5945,
+      "ratio": 1.1532,
+      "suggested_scalar": 0.0479,
+      "log_bad": -0.6626,
+      "log_good": -0.52
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 30.0,
+      "good": 40.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0967,
+      "log_bad": 3.4012,
+      "log_good": 3.6889
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_const_enum": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0404,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0461,
+      "good": 0.0475,
+      "ratio": 1.0304,
+      "suggested_scalar": 0.0175,
+      "log_bad": -3.0769,
+      "log_good": -3.047
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8852,
+      "good": 0.8833,
+      "ratio": 0.9979,
+      "suggested_scalar": -0.0013,
+      "log_bad": -0.1219,
+      "log_good": -0.1241
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0461,
+      "good": 0.0475,
+      "ratio": 1.0304,
+      "suggested_scalar": 0.0175,
+      "log_bad": -3.0769,
+      "log_good": -3.047
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.9059,
+      "good": 4.949,
+      "ratio": 1.0088,
+      "suggested_scalar": 0.0051,
+      "log_bad": 1.5904,
+      "log_good": 1.5992
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 120.0,
+      "good": 105.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0781,
+      "log_bad": 4.7875,
+      "log_good": 4.654
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4961,
+      "good": 0.466,
+      "ratio": 0.9393,
+      "suggested_scalar": -0.0366,
+      "log_bad": -0.701,
+      "log_good": -0.7636
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6431,
+      "good": 0.6887,
+      "ratio": 1.0709,
+      "suggested_scalar": 0.0401,
+      "log_bad": -0.4415,
+      "log_good": -0.3729
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.4754,
+      "good": 1.5333,
+      "ratio": 1.0392,
+      "suggested_scalar": 0.0225,
+      "log_bad": 0.3889,
+      "log_good": 0.4274
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 477.0,
+      "good": 463.0,
+      "ratio": 0.9706,
+      "suggested_scalar": -0.0174,
+      "log_bad": 6.1675,
+      "log_good": 6.1377
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0005,
+      "good": 0.0005,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.6009,
+      "log_good": -7.6009
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0328,
+      "good": 1.0,
+      "ratio": 30.4878,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.4173,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.003,
+      "good": 0.0032,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.0378,
+      "log_bad": -5.8091,
+      "log_good": -5.7446
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0183,
+      "good": 1.0544,
+      "ratio": 1.0355,
+      "suggested_scalar": 0.0204,
+      "log_bad": 0.0181,
+      "log_good": 0.053
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 148.0,
+      "good": 141.0,
+      "ratio": 0.9527,
+      "suggested_scalar": -0.0284,
+      "log_bad": 4.9972,
+      "log_good": 4.9488
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 93.8497,
+      "good": 91.9026,
+      "ratio": 0.9793,
+      "suggested_scalar": -0.0123,
+      "log_bad": 4.5417,
+      "log_good": 4.5207
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5021,
+      "good": 0.5195,
+      "ratio": 1.0347,
+      "suggested_scalar": 0.0199,
+      "log_bad": -0.689,
+      "log_good": -0.6549
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.411,
+      "good": 10.1259,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.0163,
+      "log_bad": 2.3429,
+      "log_good": 2.3151
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1997.0,
+      "good": 1869.0,
+      "ratio": 0.9359,
+      "suggested_scalar": -0.0388,
+      "log_bad": 7.5994,
+      "log_good": 7.5332
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2131,
+      "good": 0.1,
+      "ratio": 0.4693,
+      "suggested_scalar": -0.4428,
+      "log_bad": -1.546,
+      "log_good": -2.3026
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8689,
+      "good": 0.8833,
+      "ratio": 1.0166,
+      "suggested_scalar": 0.0096,
+      "log_bad": -0.1405,
+      "log_good": -0.1241
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.8197,
+      "good": 7.7167,
+      "ratio": 0.9868,
+      "suggested_scalar": -0.0078,
+      "log_bad": 2.0566,
+      "log_good": 2.0434
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.2986,
+      "good": 1.2489,
+      "ratio": 0.9617,
+      "suggested_scalar": -0.0228,
+      "log_bad": 0.2613,
+      "log_good": 0.2223
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 77.0,
+      "good": 70.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0558,
+      "log_bad": 4.3438,
+      "log_good": 4.2485
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9503,
+      "good": 0.9521,
+      "ratio": 1.0019,
+      "suggested_scalar": 0.0011,
+      "log_bad": -0.051,
+      "log_good": -0.0491
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 33.0,
+      "good": 26.0,
+      "ratio": 0.7879,
+      "suggested_scalar": -0.1395,
+      "log_bad": 3.4965,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6109,
+      "good": 0.618,
+      "ratio": 1.0116,
+      "suggested_scalar": 0.0068,
+      "log_bad": -0.4928,
+      "log_good": -0.4813
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2737,
+      "good": 0.2798,
+      "ratio": 1.0223,
+      "suggested_scalar": 0.0129,
+      "log_bad": -1.2957,
+      "log_good": -1.2737
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5701,
+      "good": 2.6176,
+      "ratio": 1.0185,
+      "suggested_scalar": 0.0107,
+      "log_bad": 0.9439,
+      "log_good": 0.9623
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 475.0,
+      "good": 461.0,
+      "ratio": 0.9705,
+      "suggested_scalar": -0.0175,
+      "log_bad": 6.1633,
+      "log_good": 6.1334
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0314,
+      "good": 0.0259,
+      "ratio": 0.8248,
+      "suggested_scalar": -0.1127,
+      "log_bad": -3.4609,
+      "log_good": -3.6535
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0444,
+      "good": 6.0,
+      "ratio": 0.9927,
+      "suggested_scalar": -0.0043,
+      "log_bad": 1.7991,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 56.0,
+      "good": 57.0,
+      "ratio": 1.0179,
+      "suggested_scalar": 0.0104,
+      "log_bad": 4.0254,
+      "log_good": 4.0431
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3557,
+      "good": 1.3606,
+      "ratio": 1.0036,
+      "suggested_scalar": 0.0021,
+      "log_bad": 0.3043,
+      "log_good": 0.3079
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8101,
+      "good": 5.6481,
+      "ratio": 0.9721,
+      "suggested_scalar": -0.0166,
+      "log_bad": 1.7596,
+      "log_good": 1.7313
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8116,
+      "good": 0.8248,
+      "ratio": 1.0163,
+      "suggested_scalar": 0.0094,
+      "log_bad": -0.2087,
+      "log_good": -0.1926
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1286,
+      "good": 0.1304,
+      "ratio": 1.014,
+      "suggested_scalar": 0.0081,
+      "log_bad": -2.051,
+      "log_good": -2.0371
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.2266,
+      "good": 3.1821,
+      "ratio": 0.9862,
+      "suggested_scalar": -0.0081,
+      "log_bad": 1.1714,
+      "log_good": 1.1575
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 390.0,
+      "good": 376.0,
+      "ratio": 0.9641,
+      "suggested_scalar": -0.0214,
+      "log_bad": 5.9661,
+      "log_good": 5.9296
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 17.0,
+      "good": 23.0,
+      "ratio": 1.3529,
+      "suggested_scalar": 0.1769,
+      "log_bad": 2.8332,
+      "log_good": 3.1355
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9624,
+      "good": 0.9042,
+      "ratio": 0.9395,
+      "suggested_scalar": -0.0365,
+      "log_bad": -0.0383,
+      "log_good": -0.1007
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 118.0,
+      "good": 103.0,
+      "ratio": 0.8729,
+      "suggested_scalar": -0.0796,
+      "log_bad": 4.7707,
+      "log_good": 4.6347
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1115.0,
+      "good": 1072.0,
+      "ratio": 0.9614,
+      "suggested_scalar": -0.023,
+      "log_bad": 7.0166,
+      "log_good": 6.9773
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 177.0,
+      "good": 167.0,
+      "ratio": 0.9435,
+      "suggested_scalar": -0.034,
+      "log_bad": 5.1761,
+      "log_good": 5.118
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2558,
+      "good": 0.2721,
+      "ratio": 1.0637,
+      "suggested_scalar": 0.0362,
+      "log_bad": -1.3634,
+      "log_good": -1.3016
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 67.0,
+      "good": 67.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2047,
+      "log_good": 4.2047
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 118.0,
+      "good": 103.0,
+      "ratio": 0.8729,
+      "suggested_scalar": -0.0796,
+      "log_bad": 4.7707,
+      "log_good": 4.6347
+    },
+    "brevity.mean_sample_size": {
+      "bad": 118.0,
+      "good": 103.0,
+      "ratio": 0.8729,
+      "suggested_scalar": -0.0796,
+      "log_bad": 4.7707,
+      "log_good": 4.6347
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 477.0,
+      "good": 463.0,
+      "ratio": 0.9706,
+      "suggested_scalar": -0.0174,
+      "log_bad": 6.1675,
+      "log_good": 6.1377
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 265.0,
+      "good": 274.0,
+      "ratio": 1.034,
+      "suggested_scalar": 0.0195,
+      "log_bad": 5.5797,
+      "log_good": 5.6131
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 304.0,
+      "good": 289.0,
+      "ratio": 0.9507,
+      "suggested_scalar": -0.0296,
+      "log_bad": 5.717,
+      "log_good": 5.6664
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.4216,
+      "good": 1.64,
+      "ratio": 0.6772,
+      "suggested_scalar": -0.2281,
+      "log_bad": 0.8844,
+      "log_good": 0.4947
+    },
+    "halstead.mean_effort": {
+      "bad": 96916.298,
+      "good": 74543.7635,
+      "ratio": 0.7692,
+      "suggested_scalar": -0.1536,
+      "log_bad": 11.4816,
+      "log_good": 11.2191
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8442,
+      "good": 0.8447,
+      "ratio": 1.0006,
+      "suggested_scalar": 0.0003,
+      "log_bad": -0.1694,
+      "log_good": -0.1688
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 87.0,
+      "good": 79.0,
+      "ratio": 0.908,
+      "suggested_scalar": -0.0565,
+      "log_bad": 4.4659,
+      "log_good": 4.3694
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 241.0,
+      "good": 237.0,
+      "ratio": 0.9834,
+      "suggested_scalar": -0.0098,
+      "log_bad": 5.4848,
+      "log_good": 5.4681
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4932,
+      "good": 0.461,
+      "ratio": 0.9347,
+      "suggested_scalar": -0.0395,
+      "log_bad": -0.7068,
+      "log_good": -0.7744
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.5338,
+      "good": 7.6028,
+      "ratio": 1.0092,
+      "suggested_scalar": 0.0053,
+      "log_bad": 2.0194,
+      "log_good": 2.0285
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1286,
+      "good": 0.1304,
+      "ratio": 1.014,
+      "suggested_scalar": 0.0081,
+      "log_bad": -2.051,
+      "log_good": -2.0371
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.0757,
+      "good": 4.1505,
+      "ratio": 1.0184,
+      "suggested_scalar": 0.0106,
+      "log_bad": 1.405,
+      "log_good": 1.4232
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 476.0,
+      "good": 462.0,
+      "ratio": 0.9706,
+      "suggested_scalar": -0.0175,
+      "log_bad": 6.1654,
+      "log_good": 6.1356
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 45.0,
+      "good": 44.0,
+      "ratio": 0.9778,
+      "suggested_scalar": -0.0132,
+      "log_bad": 3.8067,
+      "log_good": 3.7842
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5384.2388,
+      "good": 4141.3202,
+      "ratio": 0.7692,
+      "suggested_scalar": -0.1536,
+      "log_bad": 8.5912,
+      "log_good": 8.3288
+    },
+    "readability.mean_total_lines": {
+      "bad": 61.0,
+      "good": 60.0,
+      "ratio": 0.9836,
+      "suggested_scalar": -0.0097,
+      "log_bad": 4.1109,
+      "log_good": 4.0943
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2887.0803,
+      "good": 2712.5552,
+      "ratio": 0.9395,
+      "suggested_scalar": -0.0365,
+      "log_bad": 7.968,
+      "log_good": 7.9056
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 777.0,
+      "good": 714.0,
+      "ratio": 0.9189,
+      "suggested_scalar": -0.0495,
+      "log_bad": 6.6554,
+      "log_good": 6.5709
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.5902,
+      "good": 30.0,
+      "ratio": 0.9497,
+      "suggested_scalar": -0.0302,
+      "log_bad": 3.4528,
+      "log_good": 3.4012
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2417,
+      "good": 1.266,
+      "ratio": 1.0196,
+      "suggested_scalar": 0.0113,
+      "log_bad": 0.2165,
+      "log_good": 0.2359
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.4057,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8846,
+      "good": 0.883,
+      "ratio": 0.9982,
+      "suggested_scalar": -0.0011,
+      "log_bad": -0.1226,
+      "log_good": -0.1244
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9875,
+      "good": 0.9875,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0126,
+      "log_good": -0.0126
+    },
+    "halstead.mean_length": {
+      "bad": 418.0,
+      "good": 404.0,
+      "ratio": 0.9665,
+      "suggested_scalar": -0.0199,
+      "log_bad": 6.0355,
+      "log_good": 6.0014
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.3333,
+      "good": 9.6667,
+      "ratio": 1.0357,
+      "suggested_scalar": 0.0205,
+      "log_bad": 2.2336,
+      "log_good": 2.2687
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8826,
+      "good": 6.6865,
+      "ratio": 0.9715,
+      "suggested_scalar": -0.0169,
+      "log_bad": 1.929,
+      "log_good": 1.9001
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1327,
+      "good": 0.1466,
+      "ratio": 1.1047,
+      "suggested_scalar": 0.0583,
+      "log_bad": -2.0197,
+      "log_good": -1.92
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 33.569,
+      "good": 27.481,
+      "ratio": 0.8186,
+      "suggested_scalar": -0.1171,
+      "log_bad": 3.5136,
+      "log_good": 3.3135
+    },
+    "branching.mean_branch_count": {
+      "bad": 13.0,
+      "good": 6.0,
+      "ratio": 0.4615,
+      "suggested_scalar": -0.4525,
+      "log_bad": 2.5649,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 73.0,
+      "good": 65.0,
+      "ratio": 0.8904,
+      "suggested_scalar": -0.0679,
+      "log_bad": 4.2905,
+      "log_good": 4.1744
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7796,
+      "good": 0.7682,
+      "ratio": 0.9854,
+      "suggested_scalar": -0.0086,
+      "log_bad": -0.249,
+      "log_good": -0.2637
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 61.0,
+      "good": 60.0,
+      "ratio": 0.9836,
+      "suggested_scalar": -0.0097,
+      "log_bad": 4.1109,
+      "log_good": 4.0943
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "dependencies.low_coupling": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 38.0,
+      "good": 29.0,
+      "ratio": 0.7632,
+      "suggested_scalar": -0.0902,
+      "log_bad": 3.6376,
+      "log_good": 3.3673
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0173,
+      "good": 0.0254,
+      "ratio": 1.4682,
+      "suggested_scalar": 0.1282,
+      "log_bad": -4.057,
+      "log_good": -3.673
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8551,
+      "good": 0.7826,
+      "ratio": 0.9152,
+      "suggested_scalar": -0.0296,
+      "log_bad": -0.1565,
+      "log_good": -0.2451
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0173,
+      "good": 0.0254,
+      "ratio": 1.4682,
+      "suggested_scalar": 0.1282,
+      "log_bad": -4.057,
+      "log_good": -3.673
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6238,
+      "good": 4.5637,
+      "ratio": 0.987,
+      "suggested_scalar": -0.0044,
+      "log_bad": 1.5312,
+      "log_good": 1.5181
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 110.0,
+      "good": 67.0,
+      "ratio": 0.6091,
+      "suggested_scalar": -0.1655,
+      "log_bad": 4.7005,
+      "log_good": 4.2047
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4144,
+      "good": 0.3087,
+      "ratio": 0.7449,
+      "suggested_scalar": -0.0983,
+      "log_bad": -0.8809,
+      "log_good": -1.1754
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 15.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.096,
+      "log_bad": 2.9957,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5722,
+      "good": 0.4842,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.0557,
+      "log_bad": -0.5583,
+      "log_good": -0.7253
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.3913,
+      "good": 3.5652,
+      "ratio": 0.6613,
+      "suggested_scalar": -0.1381,
+      "log_bad": 1.6848,
+      "log_good": 1.2712
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 635.0,
+      "good": 393.0,
+      "ratio": 0.6189,
+      "suggested_scalar": -0.1602,
+      "log_bad": 6.4536,
+      "log_good": 5.9738
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1353,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0035,
+      "good": 1.0,
+      "ratio": 285.7143,
+      "suggested_scalar": 1.8877,
+      "log_bad": -5.655,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1441,
+      "good": 1.1665,
+      "ratio": 1.0196,
+      "suggested_scalar": 0.0065,
+      "log_bad": 0.1346,
+      "log_good": 0.154
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 230.0,
+      "good": 138.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.1705,
+      "log_bad": 5.4381,
+      "log_good": 4.9273
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 98.5912,
+      "good": 98.3076,
+      "ratio": 0.9971,
+      "suggested_scalar": -0.001,
+      "log_bad": 4.591,
+      "log_good": 4.5881
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6877,
+      "good": 0.7526,
+      "ratio": 1.0944,
+      "suggested_scalar": 0.0301,
+      "log_bad": -0.3744,
+      "log_good": -0.2842
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.3713,
+      "good": 12.0582,
+      "ratio": 0.9018,
+      "suggested_scalar": -0.0345,
+      "log_bad": 2.5931,
+      "log_good": 2.4897
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2561.0,
+      "good": 1559.0,
+      "ratio": 0.6087,
+      "suggested_scalar": -0.1657,
+      "log_bad": 7.8482,
+      "log_good": 7.3518
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.058,
+      "good": 0.1087,
+      "ratio": 1.8741,
+      "suggested_scalar": 0.2097,
+      "log_bad": -2.8473,
+      "log_good": -2.2192
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8116,
+      "good": 0.7391,
+      "ratio": 0.9107,
+      "suggested_scalar": -0.0312,
+      "log_bad": -0.2087,
+      "log_good": -0.3023
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.2029,
+      "good": 8.5435,
+      "ratio": 0.9283,
+      "suggested_scalar": -0.0248,
+      "log_bad": 2.2195,
+      "log_good": 2.1452
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 8.3831,
+      "good": 3.9414,
+      "ratio": 0.4702,
+      "suggested_scalar": -0.2519,
+      "log_bad": 2.1262,
+      "log_good": 1.3715
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 168.0,
+      "good": 117.0,
+      "ratio": 0.6964,
+      "suggested_scalar": -0.1208,
+      "log_bad": 5.124,
+      "log_good": 4.7622
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9491,
+      "good": 0.8925,
+      "ratio": 0.9404,
+      "suggested_scalar": -0.0205,
+      "log_bad": -0.0522,
+      "log_good": -0.1137
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 32.0,
+      "good": 21.0,
+      "ratio": 0.6563,
+      "suggested_scalar": -0.1406,
+      "log_bad": 3.4657,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6615,
+      "good": 0.687,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0126,
+      "log_bad": -0.4132,
+      "log_good": -0.3754
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5087,
+      "good": 0.6368,
+      "ratio": 1.2518,
+      "suggested_scalar": 0.075,
+      "log_bad": -0.6759,
+      "log_good": -0.4513
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9539,
+      "good": 3.1947,
+      "ratio": 1.0815,
+      "suggested_scalar": 0.0262,
+      "log_bad": 1.0831,
+      "log_good": 1.1615
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 633.0,
+      "good": 391.0,
+      "ratio": 0.6177,
+      "suggested_scalar": -0.1608,
+      "log_bad": 6.4505,
+      "log_good": 5.9687
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 35.0,
+      "good": 12.0,
+      "ratio": 0.3429,
+      "suggested_scalar": -0.3573,
+      "log_bad": 3.5553,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0252,
+      "good": 0.0204,
+      "ratio": 0.8095,
+      "suggested_scalar": -0.0705,
+      "log_bad": -3.6809,
+      "log_good": -3.8922
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.6439,
+      "ratio": 0.9555,
+      "suggested_scalar": -0.0152,
+      "log_bad": 1.7761,
+      "log_good": 1.7306
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 61.0,
+      "good": 20.0,
+      "ratio": 0.3279,
+      "suggested_scalar": -0.3722,
+      "log_bad": 4.1109,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8729,
+      "good": 0.6573,
+      "ratio": 0.753,
+      "suggested_scalar": -0.0947,
+      "log_bad": -0.1359,
+      "log_good": -0.4196
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6146,
+      "good": 5.2643,
+      "ratio": 0.9376,
+      "suggested_scalar": -0.0215,
+      "log_bad": 1.7254,
+      "log_good": 1.6609
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7828,
+      "good": 0.8086,
+      "ratio": 1.033,
+      "suggested_scalar": 0.0108,
+      "log_bad": -0.2449,
+      "log_good": -0.2125
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2418,
+      "good": 0.193,
+      "ratio": 0.7982,
+      "suggested_scalar": -0.0752,
+      "log_bad": -1.4196,
+      "log_good": -1.6451
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6567,
+      "good": 3.4725,
+      "ratio": 0.9496,
+      "suggested_scalar": -0.0173,
+      "log_bad": 1.2966,
+      "log_good": 1.2449
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 439.0,
+      "good": 217.0,
+      "ratio": 0.4943,
+      "suggested_scalar": -0.2352,
+      "log_bad": 6.0845,
+      "log_good": 5.3799
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2314,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.3653,
+      "good": 0.734,
+      "ratio": 0.5376,
+      "suggested_scalar": -0.2072,
+      "log_bad": 0.3114,
+      "log_good": -0.3092
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 73.0,
+      "ratio": 0.6822,
+      "suggested_scalar": -0.1276,
+      "log_bad": 4.6728,
+      "log_good": 4.2905
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1427.0,
+      "good": 859.0,
+      "ratio": 0.602,
+      "suggested_scalar": -0.1694,
+      "log_bad": 7.2633,
+      "log_good": 6.7558
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 239.0,
+      "good": 140.0,
+      "ratio": 0.5858,
+      "suggested_scalar": -0.1785,
+      "log_bad": 5.4765,
+      "log_good": 4.9416
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0142,
+      "good": 0.0127,
+      "ratio": 0.8944,
+      "suggested_scalar": -0.0373,
+      "log_bad": -4.2545,
+      "log_good": -4.3662
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.3291,
+      "good": 0.3181,
+      "ratio": 0.9666,
+      "suggested_scalar": -0.0113,
+      "log_bad": -1.1114,
+      "log_good": -1.1454
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 130.0,
+      "good": 76.0,
+      "ratio": 0.5846,
+      "suggested_scalar": -0.1792,
+      "log_bad": 4.8675,
+      "log_good": 4.3307
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1353,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 73.0,
+      "ratio": 0.6822,
+      "suggested_scalar": -0.1276,
+      "log_bad": 4.6728,
+      "log_good": 4.2905
+    },
+    "brevity.mean_sample_size": {
+      "bad": 107.0,
+      "good": 73.0,
+      "ratio": 0.6822,
+      "suggested_scalar": -0.1276,
+      "log_bad": 4.6728,
+      "log_good": 4.2905
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 635.0,
+      "good": 393.0,
+      "ratio": 0.6189,
+      "suggested_scalar": -0.1602,
+      "log_bad": 6.4536,
+      "log_good": 5.9738
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 356.0,
+      "good": 208.0,
+      "ratio": 0.5843,
+      "suggested_scalar": -0.1794,
+      "log_bad": 5.8749,
+      "log_good": 5.3375
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 328.0,
+      "good": 173.0,
+      "ratio": 0.5274,
+      "suggested_scalar": -0.2135,
+      "log_bad": 5.793,
+      "log_good": 5.1533
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0025,
+      "ratio": 0.0025,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.9915
+    },
+    "heaps.mean_k": {
+      "bad": 2.9886,
+      "good": 4.495,
+      "ratio": 1.504,
+      "suggested_scalar": 0.1362,
+      "log_bad": 1.0948,
+      "log_good": 1.503
+    },
+    "halstead.mean_effort": {
+      "bad": 200806.1462,
+      "good": 70367.9533,
+      "ratio": 0.3504,
+      "suggested_scalar": -0.35,
+      "log_bad": 12.2101,
+      "log_good": 11.1615
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8328,
+      "good": 0.8505,
+      "ratio": 1.0213,
+      "suggested_scalar": 0.007,
+      "log_bad": -0.183,
+      "log_good": -0.1619
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 78.0,
+      "good": 46.0,
+      "ratio": 0.5897,
+      "suggested_scalar": -0.1763,
+      "log_bad": 4.3567,
+      "log_good": 3.8286
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 365.0,
+      "good": 223.0,
+      "ratio": 0.611,
+      "suggested_scalar": -0.1645,
+      "log_bad": 5.8999,
+      "log_good": 5.4072
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3043,
+      "good": 0.3333,
+      "ratio": 1.0953,
+      "suggested_scalar": 0.0304,
+      "log_bad": -1.1897,
+      "log_good": -1.0987
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.2043,
+      "good": 6.2246,
+      "ratio": 1.0033,
+      "suggested_scalar": 0.0011,
+      "log_bad": 1.8252,
+      "log_good": 1.8285
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2418,
+      "good": 0.193,
+      "ratio": 0.7982,
+      "suggested_scalar": -0.0752,
+      "log_bad": -1.4196,
+      "log_good": -1.6451
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.4006,
+      "good": 4.5103,
+      "ratio": 1.0249,
+      "suggested_scalar": 0.0082,
+      "log_bad": 1.4817,
+      "log_good": 1.5064
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 634.0,
+      "good": 392.0,
+      "ratio": 0.6183,
+      "suggested_scalar": -0.1605,
+      "log_bad": 6.452,
+      "log_good": 5.9713
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 15.0,
+      "good": 4.0,
+      "ratio": 0.2667,
+      "suggested_scalar": -0.4412,
+      "log_bad": 2.7081,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 128.0,
+      "good": 75.0,
+      "ratio": 0.5859,
+      "suggested_scalar": -0.1784,
+      "log_bad": 4.852,
+      "log_good": 4.3175
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 11155.897,
+      "good": 3909.3307,
+      "ratio": 0.3504,
+      "suggested_scalar": -0.35,
+      "log_bad": 9.3197,
+      "log_good": 8.2711
+    },
+    "readability.mean_total_lines": {
+      "bad": 69.0,
+      "good": 46.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1353,
+      "log_bad": 4.2341,
+      "log_good": 3.8286
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 9.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0352,
+      "log_bad": 2.3026,
+      "log_good": 2.1972
+    },
+    "halstead.mean_volume": {
+      "bad": 4095.9413,
+      "good": 2201.9904,
+      "ratio": 0.5376,
+      "suggested_scalar": -0.2072,
+      "log_bad": 8.3178,
+      "log_good": 7.6971
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 867.0,
+      "good": 488.0,
+      "ratio": 0.5629,
+      "suggested_scalar": -0.1918,
+      "log_bad": 6.765,
+      "log_good": 6.1903
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.7971,
+      "good": 32.6522,
+      "ratio": 0.9121,
+      "suggested_scalar": -0.0307,
+      "log_bad": 3.5779,
+      "log_good": 3.4859
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1691,
+      "good": 1.1803,
+      "ratio": 1.0096,
+      "suggested_scalar": 0.0032,
+      "log_bad": 0.1562,
+      "log_good": 0.1658
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1353,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 59.0,
+      "good": 27.0,
+      "ratio": 0.4576,
+      "suggested_scalar": -0.2609,
+      "log_bad": 4.0775,
+      "log_good": 3.2958
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7084,
+      "good": 0.6544,
+      "ratio": 0.9238,
+      "suggested_scalar": -0.0265,
+      "log_bad": -0.3447,
+      "log_good": -0.424
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9613,
+      "good": 0.8963,
+      "ratio": 0.9324,
+      "suggested_scalar": -0.0234,
+      "log_bad": -0.0395,
+      "log_good": -0.1095
+    },
+    "halstead.mean_length": {
+      "bad": 604.0,
+      "good": 363.0,
+      "ratio": 0.601,
+      "suggested_scalar": -0.17,
+      "log_bad": 6.4036,
+      "log_good": 5.8944
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 19.0,
+      "good": 7.5,
+      "ratio": 0.3947,
+      "suggested_scalar": -0.3103,
+      "log_bad": 2.9444,
+      "log_good": 2.0149
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7415,
+      "good": 6.1898,
+      "ratio": 0.9182,
+      "suggested_scalar": -0.0285,
+      "log_bad": 1.9083,
+      "log_good": 1.8229
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.139,
+      "good": 0.1334,
+      "ratio": 0.9597,
+      "suggested_scalar": -0.0137,
+      "log_bad": -1.9733,
+      "log_good": -2.0144
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 49.0256,
+      "good": 31.9565,
+      "ratio": 0.6518,
+      "suggested_scalar": -0.1429,
+      "log_bad": 3.8923,
+      "log_good": 3.4644
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0745,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 70.0,
+      "good": 46.0,
+      "ratio": 0.6571,
+      "suggested_scalar": -0.1402,
+      "log_bad": 4.2485,
+      "log_good": 3.8286
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6037,
+      "good": 0.5607,
+      "ratio": 0.9288,
+      "suggested_scalar": -0.0247,
+      "log_bad": -0.5047,
+      "log_good": -0.5786
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 69.0,
+      "good": 46.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1353,
+      "log_bad": 4.2341,
+      "log_good": 3.8286
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 25.0,
+      "good": 22.0,
+      "ratio": 0.88,
+      "suggested_scalar": -0.0427,
+      "log_bad": 3.2189,
+      "log_good": 3.091
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.name_reflects_role_not_type": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 42.0,
+      "good": 21.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.6021,
+      "log_bad": 3.7377,
+      "log_good": 3.0445
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0206,
+      "good": 0.0061,
+      "ratio": 0.2961,
+      "suggested_scalar": -1.0571,
+      "log_bad": -3.8825,
+      "log_good": -5.0995
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.2,
+      "good": 1.2,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1823,
+      "log_good": 0.1823
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8667,
+      "good": 0.84,
+      "ratio": 0.9692,
+      "suggested_scalar": -0.0272,
+      "log_bad": -0.1431,
+      "log_good": -0.1744
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0206,
+      "good": 0.0061,
+      "ratio": 0.2961,
+      "suggested_scalar": -1.0571,
+      "log_bad": -3.8825,
+      "log_good": -5.0995
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4611,
+      "good": 4.4135,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.0093,
+      "log_bad": 1.4954,
+      "log_good": 1.4847
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 121.0,
+      "good": 83.0,
+      "ratio": 0.686,
+      "suggested_scalar": -0.3274,
+      "log_bad": 4.7958,
+      "log_good": 4.4188
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5096,
+      "good": 0.4426,
+      "ratio": 0.8685,
+      "suggested_scalar": -0.1224,
+      "log_bad": -0.6741,
+      "log_good": -0.8151
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 23.0,
+      "good": 21.0,
+      "ratio": 0.913,
+      "suggested_scalar": -0.079,
+      "log_bad": 3.1355,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6523,
+      "good": 0.622,
+      "ratio": 0.9535,
+      "suggested_scalar": -0.0413,
+      "log_bad": -0.4273,
+      "log_good": -0.4748
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.3333,
+      "good": 5.92,
+      "ratio": 0.9347,
+      "suggested_scalar": -0.0586,
+      "log_bad": 1.8458,
+      "log_good": 1.7783
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 436.0,
+      "good": 330.0,
+      "ratio": 0.7569,
+      "suggested_scalar": -0.2419,
+      "log_bad": 6.0776,
+      "log_good": 5.7991
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0004,
+      "good": 0.0006,
+      "ratio": 1.5,
+      "suggested_scalar": 0.3522,
+      "log_bad": -7.824,
+      "log_good": -7.4186
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1,
+      "good": 1.0,
+      "ratio": 10.0,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.3026,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0004,
+      "good": 0.0006,
+      "ratio": 1.5,
+      "suggested_scalar": 0.3522,
+      "log_bad": -7.824,
+      "log_good": -7.4186
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.904,
+      "good": 0.9278,
+      "ratio": 1.0263,
+      "suggested_scalar": 0.0226,
+      "log_bad": -0.1009,
+      "log_good": -0.0749
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 169.0,
+      "good": 122.0,
+      "ratio": 0.7219,
+      "suggested_scalar": -0.2831,
+      "log_bad": 5.1299,
+      "log_good": 4.804
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 97.2655,
+      "good": 101.7885,
+      "ratio": 1.0465,
+      "suggested_scalar": 0.0395,
+      "log_bad": 4.5774,
+      "log_good": 4.6229
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4161,
+      "good": 0.4043,
+      "ratio": 0.9716,
+      "suggested_scalar": -0.025,
+      "log_bad": -0.8768,
+      "log_good": -0.9056
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.2473,
+      "good": 5.5359,
+      "ratio": 0.5402,
+      "suggested_scalar": -0.5348,
+      "log_bad": 2.327,
+      "log_good": 1.7113
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2259.0,
+      "good": 1644.0,
+      "ratio": 0.7278,
+      "suggested_scalar": -0.276,
+      "log_bad": 7.7227,
+      "log_good": 7.4049
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0833,
+      "good": 0.12,
+      "ratio": 1.4406,
+      "suggested_scalar": 0.3171,
+      "log_bad": -2.4853,
+      "log_good": -2.1203
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8,
+      "good": 0.76,
+      "ratio": 0.95,
+      "suggested_scalar": -0.0446,
+      "log_bad": -0.2231,
+      "log_good": -0.2744
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.2667,
+      "good": 6.6,
+      "ratio": 0.9083,
+      "suggested_scalar": -0.0836,
+      "log_bad": 1.9833,
+      "log_good": 1.8871
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 18.8222,
+      "good": 20.6336,
+      "ratio": 1.0962,
+      "suggested_scalar": 0.0798,
+      "log_bad": 2.935,
+      "log_good": 3.0269
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 91.0,
+      "good": 69.0,
+      "ratio": 0.7582,
+      "suggested_scalar": -0.2404,
+      "log_bad": 4.5109,
+      "log_good": 4.2341
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9391,
+      "good": 0.9246,
+      "ratio": 0.9846,
+      "suggested_scalar": -0.0135,
+      "log_bad": -0.0628,
+      "log_good": -0.0784
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 27.0,
+      "ratio": 0.931,
+      "suggested_scalar": -0.0621,
+      "log_bad": 3.3673,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.633,
+      "good": 0.6186,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.02,
+      "log_bad": -0.4573,
+      "log_good": -0.4803
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2396,
+      "good": 0.2348,
+      "ratio": 0.98,
+      "suggested_scalar": -0.0176,
+      "log_bad": -1.4288,
+      "log_good": -1.449
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.725,
+      "good": 2.622,
+      "ratio": 0.9622,
+      "suggested_scalar": -0.0335,
+      "log_bad": 1.0025,
+      "log_good": 0.9639
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 434.0,
+      "good": 328.0,
+      "ratio": 0.7558,
+      "suggested_scalar": -0.2432,
+      "log_bad": 6.073,
+      "log_good": 5.793
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 10.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1584,
+      "log_bad": 2.4849,
+      "log_good": 2.3026
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.039,
+      "good": 0.0515,
+      "ratio": 1.3205,
+      "suggested_scalar": 0.2415,
+      "log_bad": -3.2442,
+      "log_good": -2.9662
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0444,
+      "good": 5.9542,
+      "ratio": 0.9851,
+      "suggested_scalar": -0.0131,
+      "log_bad": 1.7991,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 35.0,
+      "good": 31.0,
+      "ratio": 0.8857,
+      "suggested_scalar": -0.1054,
+      "log_bad": 3.5553,
+      "log_good": 3.434
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4943,
+      "good": 1.461,
+      "ratio": 0.9777,
+      "suggested_scalar": -0.0196,
+      "log_bad": 0.4017,
+      "log_good": 0.3791
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.1885,
+      "good": 5.7678,
+      "ratio": 0.932,
+      "suggested_scalar": -0.0612,
+      "log_bad": 1.8227,
+      "log_good": 1.7523
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7381,
+      "good": 0.7412,
+      "ratio": 1.0042,
+      "suggested_scalar": 0.0036,
+      "log_bad": -0.3037,
+      "log_good": -0.2995
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1304,
+      "good": 0.1525,
+      "ratio": 1.1695,
+      "suggested_scalar": 0.136,
+      "log_bad": -2.0371,
+      "log_good": -1.8806
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.2011,
+      "good": 2.3529,
+      "ratio": 0.735,
+      "suggested_scalar": -0.2674,
+      "log_bad": 1.1635,
+      "log_good": 0.8556
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 375.0,
+      "good": 285.0,
+      "ratio": 0.76,
+      "suggested_scalar": -0.2384,
+      "log_bad": 5.9269,
+      "log_good": 5.6525
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9133,
+      "good": 0.6481,
+      "ratio": 0.7096,
+      "suggested_scalar": -0.2979,
+      "log_bad": -0.0907,
+      "log_good": -0.4337
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 120.0,
+      "good": 87.0,
+      "ratio": 0.725,
+      "suggested_scalar": -0.2793,
+      "log_bad": 4.7875,
+      "log_good": 4.4659
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1177.0,
+      "good": 833.0,
+      "ratio": 0.7077,
+      "suggested_scalar": -0.3003,
+      "log_bad": 7.0707,
+      "log_good": 6.725
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 200.0,
+      "good": 137.0,
+      "ratio": 0.685,
+      "suggested_scalar": -0.3286,
+      "log_bad": 5.2983,
+      "log_good": 4.92
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0092,
+      "good": 0.0121,
+      "ratio": 1.3152,
+      "suggested_scalar": 0.238,
+      "log_bad": -4.6886,
+      "log_good": -4.4145
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1881,
+      "good": 0.2182,
+      "ratio": 1.16,
+      "suggested_scalar": 0.1289,
+      "log_bad": -1.6708,
+      "log_good": -1.5223
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 68.0,
+      "good": 49.0,
+      "ratio": 0.7206,
+      "suggested_scalar": -0.2846,
+      "log_bad": 4.2195,
+      "log_good": 3.8918
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 120.0,
+      "good": 87.0,
+      "ratio": 0.725,
+      "suggested_scalar": -0.2793,
+      "log_bad": 4.7875,
+      "log_good": 4.4659
+    },
+    "brevity.mean_sample_size": {
+      "bad": 120.0,
+      "good": 87.0,
+      "ratio": 0.725,
+      "suggested_scalar": -0.2793,
+      "log_bad": 4.7875,
+      "log_good": 4.4659
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 436.0,
+      "good": 330.0,
+      "ratio": 0.7569,
+      "suggested_scalar": -0.2419,
+      "log_bad": 6.0776,
+      "log_good": 5.7991
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 205.0,
+      "good": 165.0,
+      "ratio": 0.8049,
+      "suggested_scalar": -0.1885,
+      "log_bad": 5.323,
+      "log_good": 5.1059
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 322.0,
+      "good": 245.0,
+      "ratio": 0.7609,
+      "suggested_scalar": -0.2374,
+      "log_bad": 5.7746,
+      "log_good": 5.5013
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0092,
+      "good": 0.0121,
+      "ratio": 1.3152,
+      "suggested_scalar": 0.238,
+      "log_bad": -4.6886,
+      "log_good": -4.4145
+    },
+    "heaps.mean_k": {
+      "bad": 2.3458,
+      "good": 2.4661,
+      "ratio": 1.0513,
+      "suggested_scalar": 0.0434,
+      "log_bad": 0.8526,
+      "log_good": 0.9026
+    },
+    "halstead.mean_effort": {
+      "bad": 86365.4624,
+      "good": 64216.8537,
+      "ratio": 0.7435,
+      "suggested_scalar": -0.2574,
+      "log_bad": 11.3663,
+      "log_good": 11.07
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.896,
+      "good": 0.8952,
+      "ratio": 0.9991,
+      "suggested_scalar": -0.0008,
+      "log_bad": -0.1098,
+      "log_good": -0.1107
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 92.0,
+      "good": 56.0,
+      "ratio": 0.6087,
+      "suggested_scalar": -0.4312,
+      "log_bad": 4.5218,
+      "log_good": 4.0254
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 196.0,
+      "good": 168.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.1339,
+      "log_bad": 5.2781,
+      "log_good": 5.124
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4379,
+      "good": 0.4098,
+      "ratio": 0.9358,
+      "suggested_scalar": -0.0576,
+      "log_bad": -0.8258,
+      "log_good": -0.8921
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.9645,
+      "good": 6.8279,
+      "ratio": 0.9804,
+      "suggested_scalar": -0.0172,
+      "log_bad": 1.9408,
+      "log_good": 1.921
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1304,
+      "good": 0.1525,
+      "ratio": 1.1695,
+      "suggested_scalar": 0.136,
+      "log_bad": -2.0371,
+      "log_good": -1.8806
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.9067,
+      "good": 2.64,
+      "ratio": 0.9082,
+      "suggested_scalar": -0.0836,
+      "log_bad": 1.067,
+      "log_good": 0.9708
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 435.0,
+      "good": 329.0,
+      "ratio": 0.7563,
+      "suggested_scalar": -0.2426,
+      "log_bad": 6.0753,
+      "log_good": 5.7961
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 45.0,
+      "good": 34.0,
+      "ratio": 0.7556,
+      "suggested_scalar": -0.2435,
+      "log_bad": 3.8067,
+      "log_good": 3.5264
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4798.0812,
+      "good": 3567.603,
+      "ratio": 0.7435,
+      "suggested_scalar": -0.2574,
+      "log_bad": 8.476,
+      "log_good": 8.1796
+    },
+    "readability.mean_total_lines": {
+      "bad": 60.0,
+      "good": 50.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1584,
+      "log_bad": 4.0943,
+      "log_good": 3.912
+    },
+    "indentation.mean_max_depth": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "halstead.mean_volume": {
+      "bad": 2739.8698,
+      "good": 1944.387,
+      "ratio": 0.7097,
+      "suggested_scalar": -0.2979,
+      "log_bad": 7.9157,
+      "log_good": 7.5727
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 829.0,
+      "good": 627.0,
+      "ratio": 0.7563,
+      "suggested_scalar": -0.2426,
+      "log_bad": 6.7202,
+      "log_good": 6.4409
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 36.5,
+      "good": 31.7,
+      "ratio": 0.8685,
+      "suggested_scalar": -0.1225,
+      "log_bad": 3.5973,
+      "log_good": 3.4563
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.208,
+      "good": 1.1625,
+      "ratio": 0.9623,
+      "suggested_scalar": -0.0333,
+      "log_bad": 0.189,
+      "log_good": 0.1506
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 28.0,
+      "good": 28.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3322,
+      "log_good": 3.3322
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 1.0,
+      "ratio": 0.1667,
+      "suggested_scalar": -1.5563,
+      "log_bad": 1.7918,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.88,
+      "good": 0.8807,
+      "ratio": 1.0008,
+      "suggested_scalar": 0.0007,
+      "log_bad": -0.1278,
+      "log_good": -0.127
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9873,
+      "good": 0.9884,
+      "ratio": 1.0011,
+      "suggested_scalar": 0.001,
+      "log_bad": -0.0128,
+      "log_good": -0.0117
+    },
+    "halstead.mean_length": {
+      "bad": 396.0,
+      "good": 305.0,
+      "ratio": 0.7702,
+      "suggested_scalar": -0.2268,
+      "log_bad": 5.9814,
+      "log_good": 5.7203
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.0,
+      "good": 7.2,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1938,
+      "log_bad": 2.1972,
+      "log_good": 1.9741
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9069,
+      "good": 6.4429,
+      "ratio": 0.9328,
+      "suggested_scalar": -0.0604,
+      "log_bad": 1.9325,
+      "log_good": 1.863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0907,
+      "good": 0.1004,
+      "ratio": 1.1069,
+      "suggested_scalar": 0.0883,
+      "log_bad": -2.4002,
+      "log_good": -2.2986
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 31.5217,
+      "good": 33.0268,
+      "ratio": 1.0477,
+      "suggested_scalar": 0.0405,
+      "log_bad": 3.4507,
+      "log_good": 3.4973
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.1584,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 74.0,
+      "good": 50.0,
+      "ratio": 0.6757,
+      "suggested_scalar": -0.3405,
+      "log_bad": 4.3041,
+      "log_good": 3.912
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7888,
+      "good": 0.8,
+      "ratio": 1.0142,
+      "suggested_scalar": 0.0122,
+      "log_bad": -0.2372,
+      "log_good": -0.2231
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 60.0,
+      "good": 50.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1584,
+      "log_bad": 4.0943,
+      "log_good": 3.912
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 13.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.1243,
+      "log_bad": 2.7081,
+      "log_good": 2.5649
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.boolean_reads_as_assertion": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 19.0,
+      "good": 22.0,
+      "ratio": 1.1579,
+      "suggested_scalar": 0.0821,
+      "log_bad": 2.9444,
+      "log_good": 3.091
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0281,
+      "good": 1.0,
+      "ratio": 35.5872,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.572,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8372,
+      "good": 0.8,
+      "ratio": 0.9556,
+      "suggested_scalar": -0.0254,
+      "log_bad": -0.1777,
+      "log_good": -0.2231
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0281,
+      "good": 1.0,
+      "ratio": 35.5872,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.572,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5695,
+      "good": 4.5424,
+      "ratio": 0.9941,
+      "suggested_scalar": -0.0033,
+      "log_bad": 1.5194,
+      "log_good": 1.5135
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 100.0,
+      "good": 64.0,
+      "ratio": 0.64,
+      "suggested_scalar": -0.2499,
+      "log_bad": 4.6052,
+      "log_good": 4.1589
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.506,
+      "good": 0.3804,
+      "ratio": 0.7518,
+      "suggested_scalar": -0.1598,
+      "log_bad": -0.6812,
+      "log_good": -0.9665
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 16.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1249,
+      "log_bad": 2.9957,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7098,
+      "good": 0.64,
+      "ratio": 0.9017,
+      "suggested_scalar": -0.058,
+      "log_bad": -0.3428,
+      "log_good": -0.4463
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.4651,
+      "good": 4.6,
+      "ratio": 1.0302,
+      "suggested_scalar": 0.0167,
+      "log_bad": 1.4963,
+      "log_good": 1.5261
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 320.0,
+      "good": 248.0,
+      "ratio": 0.775,
+      "suggested_scalar": -0.1427,
+      "log_bad": 5.7683,
+      "log_good": 5.5134
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0013,
+      "good": 0.0016,
+      "ratio": 1.2308,
+      "suggested_scalar": 0.1163,
+      "log_bad": -6.6454,
+      "log_good": -6.4378
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1395,
+      "good": 1.0,
+      "ratio": 7.1685,
+      "suggested_scalar": 1.1029,
+      "log_bad": -1.9697,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0007,
+      "good": 0.0016,
+      "ratio": 2.2857,
+      "suggested_scalar": 0.4629,
+      "log_bad": -7.2644,
+      "log_good": -6.4378
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8613,
+      "good": 0.9302,
+      "ratio": 1.08,
+      "suggested_scalar": 0.0431,
+      "log_bad": -0.1493,
+      "log_good": -0.0724
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 129.0,
+      "good": 92.0,
+      "ratio": 0.7132,
+      "suggested_scalar": -0.1893,
+      "log_bad": 4.8598,
+      "log_good": 4.5218
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 105.828,
+      "good": 101.953,
+      "ratio": 0.9634,
+      "suggested_scalar": -0.0209,
+      "log_bad": 4.6618,
+      "log_good": 4.6245
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4013,
+      "good": 0.4656,
+      "ratio": 1.1602,
+      "suggested_scalar": 0.0832,
+      "log_bad": -0.913,
+      "log_good": -0.7644
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 12.7281,
+      "good": 10.437,
+      "ratio": 0.82,
+      "suggested_scalar": -0.1111,
+      "log_bad": 2.5438,
+      "log_good": 2.3454
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1515.0,
+      "good": 1221.0,
+      "ratio": 0.8059,
+      "suggested_scalar": -0.1208,
+      "log_bad": 7.3232,
+      "log_good": 7.1074
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1163,
+      "good": 0.1,
+      "ratio": 0.8598,
+      "suggested_scalar": -0.0845,
+      "log_bad": -2.1516,
+      "log_good": -2.3026
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.814,
+      "good": 0.775,
+      "ratio": 0.9521,
+      "suggested_scalar": -0.0275,
+      "log_bad": -0.2058,
+      "log_good": -0.2549
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.4419,
+      "good": 6.2,
+      "ratio": 0.8331,
+      "suggested_scalar": -0.1022,
+      "log_bad": 2.0071,
+      "log_good": 1.8245
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1611,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.3651,
+      "good": 6.04,
+      "ratio": 1.1258,
+      "suggested_scalar": 0.0663,
+      "log_bad": 1.6799,
+      "log_good": 1.7984
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 80.0,
+      "good": 39.0,
+      "ratio": 0.4875,
+      "suggested_scalar": -0.4023,
+      "log_bad": 4.382,
+      "log_good": 3.6636
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9317,
+      "good": 0.9037,
+      "ratio": 0.9699,
+      "suggested_scalar": -0.0171,
+      "log_bad": -0.0707,
+      "log_good": -0.1013
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 22.0,
+      "ratio": 0.7333,
+      "suggested_scalar": -0.1737,
+      "log_bad": 3.4012,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6092,
+      "good": 0.6306,
+      "ratio": 1.0351,
+      "suggested_scalar": 0.0193,
+      "log_bad": -0.4956,
+      "log_good": -0.4611
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2138,
+      "good": 0.2724,
+      "ratio": 1.2741,
+      "suggested_scalar": 0.1356,
+      "log_bad": -1.5427,
+      "log_good": -1.3005
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5591,
+      "good": 2.7073,
+      "ratio": 1.0579,
+      "suggested_scalar": 0.0315,
+      "log_bad": 0.9397,
+      "log_good": 0.996
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 318.0,
+      "good": 246.0,
+      "ratio": 0.7736,
+      "suggested_scalar": -0.1437,
+      "log_bad": 5.7621,
+      "log_good": 5.5053
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 7.0,
+      "good": 6.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0863,
+      "log_bad": 1.9459,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0531,
+      "good": 0.0726,
+      "ratio": 1.3672,
+      "suggested_scalar": 0.1751,
+      "log_bad": -2.9356,
+      "log_good": -2.6228
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.858,
+      "good": 5.7279,
+      "ratio": 0.9778,
+      "suggested_scalar": -0.0126,
+      "log_bad": 1.7678,
+      "log_good": 1.7453
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4329,
+      "good": 1.7342,
+      "ratio": 1.2103,
+      "suggested_scalar": 0.1069,
+      "log_bad": 0.3597,
+      "log_good": 0.5505
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9795,
+      "good": 5.4312,
+      "ratio": 0.9083,
+      "suggested_scalar": -0.0539,
+      "log_bad": 1.7883,
+      "log_good": 1.6922
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7801,
+      "good": 0.793,
+      "ratio": 1.0165,
+      "suggested_scalar": 0.0092,
+      "log_bad": -0.2483,
+      "log_good": -0.2319
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1731,
+      "good": 0.2,
+      "ratio": 1.1554,
+      "suggested_scalar": 0.0809,
+      "log_bad": -1.7539,
+      "log_good": -1.6094
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.5676,
+      "good": 3.2306,
+      "ratio": 0.9055,
+      "suggested_scalar": -0.0556,
+      "log_bad": 1.2719,
+      "log_good": 1.1727
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 276.0,
+      "good": 207.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1611,
+      "log_bad": 5.6204,
+      "log_good": 5.3327
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6157,
+      "good": 0.48,
+      "ratio": 0.7796,
+      "suggested_scalar": -0.1394,
+      "log_bad": -0.485,
+      "log_good": -0.734
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 97.0,
+      "good": 65.0,
+      "ratio": 0.6701,
+      "suggested_scalar": -0.2241,
+      "log_bad": 4.5747,
+      "log_good": 4.1744
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 802.0,
+      "good": 619.0,
+      "ratio": 0.7718,
+      "suggested_scalar": -0.145,
+      "log_bad": 6.6871,
+      "log_good": 6.4281
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 133.0,
+      "good": 111.0,
+      "ratio": 0.8346,
+      "suggested_scalar": -0.1012,
+      "log_bad": 4.8903,
+      "log_good": 4.7095
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0125,
+      "good": 0.0161,
+      "ratio": 1.288,
+      "suggested_scalar": 0.1417,
+      "log_bad": -4.382,
+      "log_good": -4.1289
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.225,
+      "good": 0.254,
+      "ratio": 1.1289,
+      "suggested_scalar": 0.0679,
+      "log_bad": -1.4917,
+      "log_good": -1.3704
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 45.0,
+      "good": 40.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0659,
+      "log_bad": 3.8067,
+      "log_good": 3.6889
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.1021,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 97.0,
+      "good": 65.0,
+      "ratio": 0.6701,
+      "suggested_scalar": -0.2241,
+      "log_bad": 4.5747,
+      "log_good": 4.1744
+    },
+    "brevity.mean_sample_size": {
+      "bad": 97.0,
+      "good": 65.0,
+      "ratio": 0.6701,
+      "suggested_scalar": -0.2241,
+      "log_bad": 4.5747,
+      "log_good": 4.1744
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 320.0,
+      "good": 248.0,
+      "ratio": 0.775,
+      "suggested_scalar": -0.1427,
+      "log_bad": 5.7683,
+      "log_good": 5.5134
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 145.0,
+      "good": 118.0,
+      "ratio": 0.8138,
+      "suggested_scalar": -0.1154,
+      "log_bad": 4.9767,
+      "log_good": 4.7707
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 236.0,
+      "good": 172.0,
+      "ratio": 0.7288,
+      "suggested_scalar": -0.1771,
+      "log_bad": 5.4638,
+      "log_good": 5.1475
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0063,
+      "good": 0.0081,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.1407,
+      "log_bad": -5.0672,
+      "log_good": -4.8159
+    },
+    "heaps.mean_k": {
+      "bad": 1.8794,
+      "good": 2.2052,
+      "ratio": 1.1734,
+      "suggested_scalar": 0.0895,
+      "log_bad": 0.631,
+      "log_good": 0.7908
+    },
+    "halstead.mean_effort": {
+      "bad": 52639.2726,
+      "good": 41862.8571,
+      "ratio": 0.7953,
+      "suggested_scalar": -0.1283,
+      "log_bad": 10.8712,
+      "log_good": 10.6422
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.906,
+      "good": 0.9018,
+      "ratio": 0.9954,
+      "suggested_scalar": -0.0026,
+      "log_bad": -0.0987,
+      "log_good": -0.1034
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 70.0,
+      "good": 42.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.286,
+      "log_bad": 4.2485,
+      "log_good": 3.7377
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 145.0,
+      "good": 129.0,
+      "ratio": 0.8897,
+      "suggested_scalar": -0.0655,
+      "log_bad": 4.9767,
+      "log_good": 4.8598
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4419,
+      "good": 0.3804,
+      "ratio": 0.8608,
+      "suggested_scalar": -0.0839,
+      "log_bad": -0.8167,
+      "log_good": -0.9665
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.2171,
+      "good": 6.7283,
+      "ratio": 1.0822,
+      "suggested_scalar": 0.0442,
+      "log_bad": 1.8273,
+      "log_good": 1.9063
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1731,
+      "good": 0.2,
+      "ratio": 1.1554,
+      "suggested_scalar": 0.0809,
+      "log_bad": -1.7539,
+      "log_good": -1.6094
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.9767,
+      "good": 2.795,
+      "ratio": 0.939,
+      "suggested_scalar": -0.0353,
+      "log_bad": 1.0908,
+      "log_good": 1.0278
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 319.0,
+      "good": 247.0,
+      "ratio": 0.7743,
+      "suggested_scalar": -0.1432,
+      "log_bad": 5.7652,
+      "log_good": 5.5094
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 26.0,
+      "good": 28.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0415,
+      "log_bad": 3.2581,
+      "log_good": 3.3322
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2924.404,
+      "good": 2325.7143,
+      "ratio": 0.7953,
+      "suggested_scalar": -0.1283,
+      "log_bad": 7.9808,
+      "log_good": 7.7518
+    },
+    "readability.mean_total_lines": {
+      "bad": 43.0,
+      "good": 40.0,
+      "ratio": 0.9302,
+      "suggested_scalar": -0.0405,
+      "log_bad": 3.7612,
+      "log_good": 3.6889
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 1846.992,
+      "good": 1440.0,
+      "ratio": 0.7796,
+      "suggested_scalar": -0.1394,
+      "log_bad": 7.5213,
+      "log_good": 7.2724
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 592.0,
+      "good": 451.0,
+      "ratio": 0.7618,
+      "suggested_scalar": -0.1523,
+      "log_bad": 6.3835,
+      "log_good": 6.1115
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 34.0233,
+      "good": 29.275,
+      "ratio": 0.8604,
+      "suggested_scalar": -0.0842,
+      "log_bad": 3.527,
+      "log_good": 3.3767
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1047,
+      "good": 1.1654,
+      "ratio": 1.0549,
+      "suggested_scalar": 0.03,
+      "log_bad": 0.0996,
+      "log_good": 0.1531
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 15.0,
+      "good": 16.0,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.0361,
+      "log_bad": 2.7081,
+      "log_good": 2.7726
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 1.0,
+      "ratio": 0.1667,
+      "suggested_scalar": -1.0032,
+      "log_bad": 1.7918,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9058,
+      "good": 0.8647,
+      "ratio": 0.9546,
+      "suggested_scalar": -0.026,
+      "log_bad": -0.0989,
+      "log_good": -0.1454
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9873,
+      "good": 0.978,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.0053,
+      "log_bad": -0.0128,
+      "log_good": -0.0222
+    },
+    "halstead.mean_length": {
+      "bad": 278.0,
+      "good": 240.0,
+      "ratio": 0.8633,
+      "suggested_scalar": -0.0823,
+      "log_bad": 5.6276,
+      "log_good": 5.4806
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.0,
+      "good": 4.5,
+      "ratio": 0.9,
+      "suggested_scalar": -0.059,
+      "log_bad": 1.6094,
+      "log_good": 1.5041
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5999,
+      "good": 6.0224,
+      "ratio": 0.9125,
+      "suggested_scalar": -0.0513,
+      "log_bad": 1.8871,
+      "log_good": 1.7955
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0957,
+      "good": 0.0966,
+      "ratio": 1.0094,
+      "suggested_scalar": 0.0052,
+      "log_bad": -2.3465,
+      "log_good": -2.3372
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 28.5,
+      "good": 29.0714,
+      "ratio": 1.02,
+      "suggested_scalar": 0.0111,
+      "log_bad": 3.3499,
+      "log_good": 3.3698
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1249,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 57.0,
+      "good": 35.0,
+      "ratio": 0.614,
+      "suggested_scalar": -0.2731,
+      "log_bad": 4.0431,
+      "log_good": 3.5553
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8093,
+      "good": 0.7674,
+      "ratio": 0.9482,
+      "suggested_scalar": -0.0298,
+      "log_bad": -0.2116,
+      "log_good": -0.2647
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 43.0,
+      "good": 40.0,
+      "ratio": 0.9302,
+      "suggested_scalar": -0.0405,
+      "log_bad": 3.7612,
+      "log_good": 3.6889
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.uses_named_arguments_for_multiple_same_type_params": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 40.0,
+      "good": 53.0,
+      "ratio": 1.325,
+      "suggested_scalar": 0.3639,
+      "log_bad": 3.6889,
+      "log_good": 3.9703
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0291,
+      "good": 0.0201,
+      "ratio": 0.6907,
+      "suggested_scalar": -0.4785,
+      "log_bad": -3.537,
+      "log_good": -3.907
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.25,
+      "good": 1.6,
+      "ratio": 0.7111,
+      "suggested_scalar": -0.4409,
+      "log_bad": 0.8109,
+      "log_good": 0.47
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9,
+      "good": 0.8723,
+      "ratio": 0.9692,
+      "suggested_scalar": -0.0404,
+      "log_bad": -0.1054,
+      "log_good": -0.1366
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0291,
+      "good": 0.0201,
+      "ratio": 0.6907,
+      "suggested_scalar": -0.4785,
+      "log_bad": -3.537,
+      "log_good": -3.907
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8703,
+      "good": 4.6903,
+      "ratio": 0.963,
+      "suggested_scalar": -0.0487,
+      "log_bad": 1.5832,
+      "log_good": 1.5455
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 94.0,
+      "good": 88.0,
+      "ratio": 0.9362,
+      "suggested_scalar": -0.0853,
+      "log_bad": 4.5433,
+      "log_good": 4.4773
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4851,
+      "good": 0.4653,
+      "ratio": 0.9592,
+      "suggested_scalar": -0.0539,
+      "log_bad": -0.7234,
+      "log_good": -0.7651
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 14.0,
+      "good": 15.0,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.0892,
+      "log_bad": 2.6391,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6273,
+      "good": 0.6122,
+      "ratio": 0.9759,
+      "suggested_scalar": -0.0315,
+      "log_bad": -0.4663,
+      "log_good": -0.4907
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.6667,
+      "good": 5.5319,
+      "ratio": 1.1854,
+      "suggested_scalar": 0.22,
+      "log_bad": 1.5405,
+      "log_good": 1.7105
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 344.0,
+      "good": 348.0,
+      "ratio": 1.0116,
+      "suggested_scalar": 0.015,
+      "log_bad": 5.8406,
+      "log_good": 5.8522
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0006,
+      "good": 0.0005,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.2358,
+      "log_bad": -7.4186,
+      "log_good": -7.6009
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1,
+      "good": 0.0213,
+      "ratio": 0.213,
+      "suggested_scalar": -2.0,
+      "log_bad": -2.3026,
+      "log_good": -3.849
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0023,
+      "good": 0.0021,
+      "ratio": 0.913,
+      "suggested_scalar": -0.1177,
+      "log_bad": -6.0748,
+      "log_good": -6.1658
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9301,
+      "good": 0.9913,
+      "ratio": 1.0658,
+      "suggested_scalar": 0.0824,
+      "log_bad": -0.0725,
+      "log_good": -0.0087
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 134.0,
+      "good": 133.0,
+      "ratio": 0.9925,
+      "suggested_scalar": -0.0097,
+      "log_bad": 4.8978,
+      "log_good": 4.8903
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 76.9602,
+      "good": 71.9038,
+      "ratio": 0.9343,
+      "suggested_scalar": -0.0879,
+      "log_bad": 4.3433,
+      "log_good": 4.2753
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5335,
+      "good": 0.5562,
+      "ratio": 1.0425,
+      "suggested_scalar": 0.0539,
+      "log_bad": -0.6283,
+      "log_good": -0.5866
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 22.1931,
+      "good": 21.1677,
+      "ratio": 0.9538,
+      "suggested_scalar": -0.0612,
+      "log_bad": 3.0998,
+      "log_good": 3.0525
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1714.0,
+      "good": 1939.0,
+      "ratio": 1.1313,
+      "suggested_scalar": 0.1595,
+      "log_bad": 7.4466,
+      "log_good": 7.5699
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0333,
+      "good": 0.0426,
+      "ratio": 1.2793,
+      "suggested_scalar": 0.3185,
+      "log_bad": -3.4022,
+      "log_good": -3.1559
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8667,
+      "good": 0.8511,
+      "ratio": 0.982,
+      "suggested_scalar": -0.0235,
+      "log_bad": -0.1431,
+      "log_good": -0.1612
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 11.4667,
+      "good": 7.4043,
+      "ratio": 0.6457,
+      "suggested_scalar": -0.5657,
+      "log_bad": 2.4394,
+      "log_good": 2.0021
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 8.6222,
+      "good": 7.866,
+      "ratio": 0.9123,
+      "suggested_scalar": -0.1187,
+      "log_bad": 2.1543,
+      "log_good": 2.0625
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 69.0,
+      "good": 53.0,
+      "ratio": 0.7681,
+      "suggested_scalar": -0.3412,
+      "log_bad": 4.2341,
+      "log_good": 3.9703
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9483,
+      "good": 0.9434,
+      "ratio": 0.9948,
+      "suggested_scalar": -0.0067,
+      "log_bad": -0.0531,
+      "log_good": -0.0583
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 20.0,
+      "good": 21.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0631,
+      "log_bad": 2.9957,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6219,
+      "good": 0.6565,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.07,
+      "log_bad": -0.475,
+      "log_good": -0.4208
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3041,
+      "good": 0.2948,
+      "ratio": 0.9694,
+      "suggested_scalar": -0.0402,
+      "log_bad": -1.1904,
+      "log_good": -1.2215
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6451,
+      "good": 2.9114,
+      "ratio": 1.1007,
+      "suggested_scalar": 0.1241,
+      "log_bad": 0.9727,
+      "log_good": 1.0686
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 342.0,
+      "good": 346.0,
+      "ratio": 1.0117,
+      "suggested_scalar": 0.015,
+      "log_bad": 5.8348,
+      "log_good": 5.8464
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 22.0,
+      "ratio": 1.8333,
+      "suggested_scalar": 0.7839,
+      "log_bad": 2.4849,
+      "log_good": 3.091
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0291,
+      "good": 0.0345,
+      "ratio": 1.1856,
+      "suggested_scalar": 0.2201,
+      "log_bad": -3.537,
+      "log_good": -3.3668
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0,
+      "good": 5.9542,
+      "ratio": 0.9924,
+      "suggested_scalar": -0.0099,
+      "log_bad": 1.7918,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 25.0,
+      "good": 27.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.0995,
+      "log_bad": 3.2189,
+      "log_good": 3.2958
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4656,
+      "good": 1.5249,
+      "ratio": 1.0405,
+      "suggested_scalar": 0.0513,
+      "log_bad": 0.3823,
+      "log_good": 0.4219
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7839,
+      "good": 5.6003,
+      "ratio": 0.9683,
+      "suggested_scalar": -0.0417,
+      "log_bad": 1.7551,
+      "log_good": 1.7228
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8117,
+      "good": 0.7877,
+      "ratio": 0.9704,
+      "suggested_scalar": -0.0388,
+      "log_bad": -0.2086,
+      "log_good": -0.2386
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2308,
+      "good": 0.1754,
+      "ratio": 0.76,
+      "suggested_scalar": -0.355,
+      "log_bad": -1.4662,
+      "log_good": -1.7407
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.711,
+      "good": 4.6008,
+      "ratio": 0.9766,
+      "suggested_scalar": -0.0306,
+      "log_bad": 1.5499,
+      "log_good": 1.5262
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 9.0,
+      "good": 8.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.1523,
+      "log_bad": 2.1972,
+      "log_good": 2.0794
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 283.0,
+      "good": 290.0,
+      "ratio": 1.0247,
+      "suggested_scalar": 0.0316,
+      "log_bad": 5.6454,
+      "log_good": 5.6699
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.3721,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6729,
+      "good": 0.6955,
+      "ratio": 1.0336,
+      "suggested_scalar": 0.0427,
+      "log_bad": -0.3962,
+      "log_good": -0.3631
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 98.0,
+      "good": 91.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.0958,
+      "log_bad": 4.585,
+      "log_good": 4.5109
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1068.0,
+      "good": 1163.0,
+      "ratio": 1.089,
+      "suggested_scalar": 0.1102,
+      "log_bad": 6.9735,
+      "log_good": 7.0588
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 151.0,
+      "good": 150.0,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0086,
+      "log_bad": 5.0173,
+      "log_good": 5.0106
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2616,
+      "good": 0.273,
+      "ratio": 1.0436,
+      "suggested_scalar": 0.0552,
+      "log_bad": -1.3409,
+      "log_good": -1.2983
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 70.0,
+      "good": 72.0,
+      "ratio": 1.0286,
+      "suggested_scalar": 0.0364,
+      "log_bad": 4.2485,
+      "log_good": 4.2767
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.2886,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 98.0,
+      "good": 91.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.0958,
+      "log_bad": 4.585,
+      "log_good": 4.5109
+    },
+    "brevity.mean_sample_size": {
+      "bad": 98.0,
+      "good": 91.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.0958,
+      "log_bad": 4.585,
+      "log_good": 4.5109
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 344.0,
+      "good": 348.0,
+      "ratio": 1.0116,
+      "suggested_scalar": 0.015,
+      "log_bad": 5.8406,
+      "log_good": 5.8522
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 168.0,
+      "good": 175.0,
+      "ratio": 1.0417,
+      "suggested_scalar": 0.0528,
+      "log_bad": 5.124,
+      "log_good": 5.1648
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 230.0,
+      "good": 226.0,
+      "ratio": 0.9826,
+      "suggested_scalar": -0.0227,
+      "log_bad": 5.4381,
+      "log_good": 5.4205
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0262,
+      "good": 0.023,
+      "ratio": 0.8779,
+      "suggested_scalar": -0.1685,
+      "log_bad": -3.642,
+      "log_good": -3.7723
+    },
+    "heaps.mean_k": {
+      "bad": 2.3404,
+      "good": 2.4821,
+      "ratio": 1.0605,
+      "suggested_scalar": 0.076,
+      "log_bad": 0.8503,
+      "log_good": 0.9091
+    },
+    "halstead.mean_effort": {
+      "bad": 41194.7052,
+      "good": 49045.8858,
+      "ratio": 1.1906,
+      "suggested_scalar": 0.2256,
+      "log_bad": 10.6261,
+      "log_good": 10.8005
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8744,
+      "good": 0.8606,
+      "ratio": 0.9842,
+      "suggested_scalar": -0.0206,
+      "log_bad": -0.1342,
+      "log_good": -0.1501
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 74.0,
+      "good": 67.0,
+      "ratio": 0.9054,
+      "suggested_scalar": -0.1285,
+      "log_bad": 4.3041,
+      "log_good": 4.2047
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 157.0,
+      "good": 173.0,
+      "ratio": 1.1019,
+      "suggested_scalar": 0.1255,
+      "log_bad": 5.0562,
+      "log_good": 5.1533
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4552,
+      "good": 0.4135,
+      "ratio": 0.9084,
+      "suggested_scalar": -0.1243,
+      "log_bad": -0.787,
+      "log_good": -0.8831
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.9701,
+      "good": 8.7444,
+      "ratio": 1.0972,
+      "suggested_scalar": 0.1199,
+      "log_bad": 2.0757,
+      "log_good": 2.1684
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2308,
+      "good": 0.1754,
+      "ratio": 0.76,
+      "suggested_scalar": -0.355,
+      "log_bad": -1.4662,
+      "log_good": -1.7407
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 7.9602,
+      "good": 6.8641,
+      "ratio": 0.8623,
+      "suggested_scalar": -0.1916,
+      "log_bad": 2.0745,
+      "log_good": 1.9263
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 343.0,
+      "good": 347.0,
+      "ratio": 1.0117,
+      "suggested_scalar": 0.015,
+      "log_bad": 5.8377,
+      "log_good": 5.8493
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 45.0,
+      "good": 46.0,
+      "ratio": 1.0222,
+      "suggested_scalar": 0.0284,
+      "log_bad": 3.8067,
+      "log_good": 3.8286
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2288.5947,
+      "good": 2724.7714,
+      "ratio": 1.1906,
+      "suggested_scalar": 0.2256,
+      "log_bad": 7.7357,
+      "log_good": 7.9101
+    },
+    "readability.mean_total_lines": {
+      "bad": 30.0,
+      "good": 47.0,
+      "ratio": 1.5667,
+      "suggested_scalar": 0.5806,
+      "log_bad": 3.4012,
+      "log_good": 3.8501
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2018.8134,
+      "good": 2086.3964,
+      "ratio": 1.0335,
+      "suggested_scalar": 0.0426,
+      "log_bad": 7.6103,
+      "log_good": 7.6432
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 648.0,
+      "good": 666.0,
+      "ratio": 1.0278,
+      "suggested_scalar": 0.0354,
+      "log_bad": 6.4739,
+      "log_good": 6.5013
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 55.6333,
+      "good": 40.0426,
+      "ratio": 0.7198,
+      "suggested_scalar": -0.4253,
+      "log_bad": 4.0188,
+      "log_good": 3.6899
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3976,
+      "good": 1.5061,
+      "ratio": 1.0776,
+      "suggested_scalar": 0.0967,
+      "log_bad": 0.3348,
+      "log_good": 0.4095
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 18.0,
+      "good": 19.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.0699,
+      "log_bad": 2.8904,
+      "log_good": 2.9444
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -1.4208,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.841,
+      "good": 0.8414,
+      "ratio": 1.0005,
+      "suggested_scalar": 0.0006,
+      "log_bad": -0.1732,
+      "log_good": -0.1727
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.969,
+      "good": 0.9696,
+      "ratio": 1.0006,
+      "suggested_scalar": 0.0008,
+      "log_bad": -0.0315,
+      "log_good": -0.0309
+    },
+    "halstead.mean_length": {
+      "bad": 308.0,
+      "good": 323.0,
+      "ratio": 1.0487,
+      "suggested_scalar": 0.0615,
+      "log_bad": 5.7301,
+      "log_good": 5.7777
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 8.25,
+      "good": 10.2,
+      "ratio": 1.2364,
+      "suggested_scalar": 0.2744,
+      "log_bad": 2.1102,
+      "log_good": 2.3224
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6147,
+      "good": 6.5078,
+      "ratio": 0.9838,
+      "suggested_scalar": -0.0211,
+      "log_bad": 1.8893,
+      "log_good": 1.873
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0984,
+      "good": 0.0903,
+      "ratio": 0.9177,
+      "suggested_scalar": -0.1111,
+      "log_bad": -2.3187,
+      "log_good": -2.4046
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 20.4054,
+      "good": 23.5075,
+      "ratio": 1.152,
+      "suggested_scalar": 0.183,
+      "log_bad": 3.0158,
+      "log_good": 3.1573
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.8964,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 61.0,
+      "good": 55.0,
+      "ratio": 0.9016,
+      "suggested_scalar": -0.1339,
+      "log_bad": 4.1109,
+      "log_good": 4.0073
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6957,
+      "good": 0.6814,
+      "ratio": 0.9794,
+      "suggested_scalar": -0.0269,
+      "log_bad": -0.3628,
+      "log_good": -0.3836
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 30.0,
+      "good": 47.0,
+      "ratio": 1.5667,
+      "suggested_scalar": 0.5806,
+      "log_bad": 3.4012,
+      "log_good": 3.8501
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "variable_naming.name_is_generic": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 9.0,
+      "good": 90.0,
+      "ratio": 10.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 2.1972,
+      "log_good": 4.4998
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 25.6667,
+      "good": 33.3333,
+      "ratio": 1.2987,
+      "suggested_scalar": 0.227,
+      "log_bad": 3.2452,
+      "log_good": 3.5066
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0013,
+      "good": 0.0011,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.1451,
+      "log_bad": -6.6454,
+      "log_good": -6.8124
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0909,
+      "good": 1.0367,
+      "ratio": 0.9503,
+      "suggested_scalar": -0.0443,
+      "log_bad": 0.087,
+      "log_good": 0.036
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7706,
+      "good": 0.7744,
+      "ratio": 1.0049,
+      "suggested_scalar": 0.0043,
+      "log_bad": -0.2606,
+      "log_good": -0.2557
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0023,
+      "good": 0.0022,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.0386,
+      "log_bad": -6.0748,
+      "log_good": -6.1193
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4712,
+      "good": 4.5739,
+      "ratio": 1.023,
+      "suggested_scalar": 0.0197,
+      "log_bad": 1.4977,
+      "log_good": 1.5204
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 81.0,
+      "good": 104.3333,
+      "ratio": 1.2881,
+      "suggested_scalar": 0.2199,
+      "log_bad": 4.3944,
+      "log_good": 4.6476
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3195,
+      "good": 0.3933,
+      "ratio": 1.231,
+      "suggested_scalar": 0.1805,
+      "log_bad": -1.141,
+      "log_good": -0.9332
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 22.6667,
+      "good": 23.3333,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.0252,
+      "log_bad": 3.1209,
+      "log_good": 3.1499
+    },
+    "heaps.mean_beta": {
+      "bad": 0.4669,
+      "good": 0.5345,
+      "ratio": 1.1448,
+      "suggested_scalar": 0.1174,
+      "log_bad": -0.7616,
+      "log_good": -0.6264
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.2354,
+      "good": 3.8804,
+      "ratio": 0.9162,
+      "suggested_scalar": -0.076,
+      "log_bad": 1.4435,
+      "log_good": 1.3559
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 557.3333,
+      "good": 610.0,
+      "ratio": 1.0945,
+      "suggested_scalar": 0.0784,
+      "log_bad": 6.3232,
+      "log_good": 6.4135
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.6667,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0599,
+      "log_bad": 1.6094,
+      "log_good": 1.5405
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0007,
+      "good": 0.0005,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.2923,
+      "log_bad": -7.2644,
+      "log_good": -7.6009
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0005,
+      "good": 0.0006,
+      "ratio": 1.2,
+      "suggested_scalar": 0.1584,
+      "log_bad": -7.6009,
+      "log_good": -7.4186
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.2337,
+      "good": 1.1024,
+      "ratio": 0.8936,
+      "suggested_scalar": -0.0977,
+      "log_bad": 0.21,
+      "log_good": 0.0975
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 155.6667,
+      "good": 197.3333,
+      "ratio": 1.2677,
+      "suggested_scalar": 0.206,
+      "log_bad": 5.0477,
+      "log_good": 5.2849
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 110.6715,
+      "good": 79.7802,
+      "ratio": 0.7209,
+      "suggested_scalar": -0.2843,
+      "log_bad": 4.7066,
+      "log_good": 4.3793
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7143,
+      "good": 0.6185,
+      "ratio": 0.8659,
+      "suggested_scalar": -0.1251,
+      "log_bad": -0.3365,
+      "log_good": -0.4805
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 5.131,
+      "good": 25.109,
+      "ratio": 4.8936,
+      "suggested_scalar": 1.3793,
+      "log_bad": 1.6353,
+      "log_good": 3.2232
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1937.6667,
+      "good": 2891.6667,
+      "ratio": 1.4923,
+      "suggested_scalar": 0.3477,
+      "log_bad": 7.5692,
+      "log_good": 7.9696
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0478,
+      "good": 0.0748,
+      "ratio": 1.5649,
+      "suggested_scalar": 0.3889,
+      "log_bad": -3.0407,
+      "log_good": -2.5929
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7269,
+      "good": 0.7423,
+      "ratio": 1.0212,
+      "suggested_scalar": 0.0182,
+      "log_bad": -0.319,
+      "log_good": -0.298
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.2351,
+      "good": 7.263,
+      "ratio": 1.0039,
+      "suggested_scalar": 0.0033,
+      "log_bad": 1.9789,
+      "log_good": 1.9828
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 4.5247,
+      "good": 3.2912,
+      "ratio": 0.7274,
+      "suggested_scalar": -0.2765,
+      "log_bad": 1.5096,
+      "log_good": 1.1913
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 145.3333,
+      "good": 160.0,
+      "ratio": 1.1009,
+      "suggested_scalar": 0.0835,
+      "log_bad": 4.979,
+      "log_good": 5.0752
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9109,
+      "good": 0.9446,
+      "ratio": 1.037,
+      "suggested_scalar": 0.0316,
+      "log_bad": -0.0933,
+      "log_good": -0.057
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 27.0,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0328,
+      "log_bad": 3.2581,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.655,
+      "good": 0.6957,
+      "ratio": 1.0621,
+      "suggested_scalar": 0.0524,
+      "log_bad": -0.4231,
+      "log_good": -0.3628
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5286,
+      "good": 0.4155,
+      "ratio": 0.786,
+      "suggested_scalar": -0.2091,
+      "log_bad": -0.6375,
+      "log_good": -0.8783
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.8991,
+      "good": 3.2879,
+      "ratio": 1.1341,
+      "suggested_scalar": 0.1093,
+      "log_bad": 1.0644,
+      "log_good": 1.1902
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 555.3333,
+      "good": 608.0,
+      "ratio": 1.0948,
+      "suggested_scalar": 0.0787,
+      "log_bad": 6.3196,
+      "log_good": 6.4102
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 13.0,
+      "good": 10.0,
+      "ratio": 0.7692,
+      "suggested_scalar": -0.2279,
+      "log_bad": 2.5649,
+      "log_good": 2.3026
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0241,
+      "good": 0.0221,
+      "ratio": 0.917,
+      "suggested_scalar": -0.0752,
+      "log_bad": -3.7255,
+      "log_good": -3.8122
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8814,
+      "good": 5.941,
+      "ratio": 1.0101,
+      "suggested_scalar": 0.0088,
+      "log_bad": 1.7718,
+      "log_good": 1.7819
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 7.3333,
+      "good": 7.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9924,
+      "log_good": 1.9924
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.3328,
+      "good": 0.5193,
+      "ratio": 1.5604,
+      "suggested_scalar": 0.3865,
+      "log_bad": -1.1002,
+      "log_good": -0.6553
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.3465,
+      "good": 5.5802,
+      "ratio": 1.0437,
+      "suggested_scalar": 0.0372,
+      "log_bad": 1.6764,
+      "log_good": 1.7192
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7603,
+      "good": 0.77,
+      "ratio": 1.0128,
+      "suggested_scalar": 0.011,
+      "log_bad": -0.274,
+      "log_good": -0.2614
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1663,
+      "good": 0.1773,
+      "ratio": 1.0661,
+      "suggested_scalar": 0.0556,
+      "log_bad": -1.794,
+      "log_good": -1.7299
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.2648,
+      "good": 4.9921,
+      "ratio": 2.2042,
+      "suggested_scalar": 0.6865,
+      "log_bad": 0.8175,
+      "log_good": 1.6079
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 5.6667,
+      "good": 5.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7346,
+      "log_good": 1.7346
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 356.6667,
+      "good": 426.3333,
+      "ratio": 1.1953,
+      "suggested_scalar": 0.155,
+      "log_bad": 5.8768,
+      "log_good": 6.0552
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 13.3333,
+      "good": 13.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5903,
+      "log_good": 2.5903
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.149,
+      "good": 1.3324,
+      "ratio": 1.1596,
+      "suggested_scalar": 0.1286,
+      "log_bad": 0.1389,
+      "log_good": 0.287
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 107.6667,
+      "ratio": 1.2667,
+      "suggested_scalar": 0.2053,
+      "log_bad": 4.4427,
+      "log_good": 4.679
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 707.0,
+      "good": 1696.3333,
+      "ratio": 2.3993,
+      "suggested_scalar": 0.7602,
+      "log_bad": 6.561,
+      "log_good": 7.4362
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 211.3333,
+      "good": 222.6667,
+      "ratio": 1.0536,
+      "suggested_scalar": 0.0454,
+      "log_bad": 5.3534,
+      "log_good": 5.4057
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0102,
+      "good": 0.009,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.1087,
+      "log_bad": -4.5854,
+      "log_good": -4.7105
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2712,
+      "good": 0.2608,
+      "ratio": 0.9617,
+      "suggested_scalar": -0.034,
+      "log_bad": -1.3049,
+      "log_good": -1.344
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 102.3333,
+      "good": 87.6667,
+      "ratio": 0.8567,
+      "suggested_scalar": -0.1344,
+      "log_bad": 4.6282,
+      "log_good": 4.4735
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.3333,
+      "good": 10.0,
+      "ratio": 1.3636,
+      "suggested_scalar": 0.2694,
+      "log_bad": 1.9924,
+      "log_good": 2.3026
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 107.6667,
+      "ratio": 1.2667,
+      "suggested_scalar": 0.2053,
+      "log_bad": 4.4427,
+      "log_good": 4.679
+    },
+    "brevity.mean_sample_size": {
+      "bad": 85.0,
+      "good": 107.6667,
+      "ratio": 1.2667,
+      "suggested_scalar": 0.2053,
+      "log_bad": 4.4427,
+      "log_good": 4.679
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 557.3333,
+      "good": 610.0,
+      "ratio": 1.0945,
+      "suggested_scalar": 0.0784,
+      "log_bad": 6.3232,
+      "log_good": 6.4135
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 305.0,
+      "good": 336.6667,
+      "ratio": 1.1038,
+      "suggested_scalar": 0.0858,
+      "log_bad": 5.7203,
+      "log_good": 5.8191
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 260.6667,
+      "good": 317.6667,
+      "ratio": 1.2187,
+      "suggested_scalar": 0.1718,
+      "log_bad": 5.5632,
+      "log_good": 5.761
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0101,
+      "good": 0.0094,
+      "ratio": 0.9307,
+      "suggested_scalar": -0.0624,
+      "log_bad": -4.5952,
+      "log_good": -4.667
+    },
+    "heaps.mean_k": {
+      "bad": 4.3087,
+      "good": 3.2916,
+      "ratio": 0.7639,
+      "suggested_scalar": -0.2339,
+      "log_bad": 1.4606,
+      "log_good": 1.1914
+    },
+    "halstead.mean_effort": {
+      "bad": 173394.38,
+      "good": 157297.4076,
+      "ratio": 0.9072,
+      "suggested_scalar": -0.0846,
+      "log_bad": 12.0633,
+      "log_good": 11.9659
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8344,
+      "good": 0.827,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.0077,
+      "log_bad": -0.181,
+      "log_good": -0.19
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 55.0,
+      "good": 77.3333,
+      "ratio": 1.4061,
+      "suggested_scalar": 0.296,
+      "log_bad": 4.0073,
+      "log_good": 4.3481
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 332.3333,
+      "good": 372.6667,
+      "ratio": 1.1214,
+      "suggested_scalar": 0.0995,
+      "log_bad": 5.8061,
+      "log_good": 5.9207
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.2802,
+      "good": 0.3381,
+      "ratio": 1.2066,
+      "suggested_scalar": 0.1632,
+      "log_bad": -1.2723,
+      "log_good": -1.0844
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.5437,
+      "good": 8.6187,
+      "ratio": 1.8968,
+      "suggested_scalar": 0.5561,
+      "log_bad": 1.5137,
+      "log_good": 2.1539
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1663,
+      "good": 0.1773,
+      "ratio": 1.0661,
+      "suggested_scalar": 0.0556,
+      "log_bad": -1.794,
+      "log_good": -1.7299
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.9996,
+      "good": 5.3527,
+      "ratio": 1.7845,
+      "suggested_scalar": 0.503,
+      "log_bad": 1.0985,
+      "log_good": 1.6776
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 556.3333,
+      "good": 609.0,
+      "ratio": 1.0947,
+      "suggested_scalar": 0.0786,
+      "log_bad": 6.3214,
+      "log_good": 6.4118
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.6667,
+      "good": 3.6667,
+      "ratio": 1.375,
+      "suggested_scalar": 0.2766,
+      "log_bad": 0.9808,
+      "log_good": 1.2993
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 95.6667,
+      "good": 72.6667,
+      "ratio": 0.7596,
+      "suggested_scalar": -0.2389,
+      "log_bad": 4.5609,
+      "log_good": 4.2859
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 9633.0211,
+      "good": 8738.7449,
+      "ratio": 0.9072,
+      "suggested_scalar": -0.0846,
+      "log_bad": 9.173,
+      "log_good": 9.0755
+    },
+    "readability.mean_total_lines": {
+      "bad": 77.0,
+      "good": 84.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0756,
+      "log_bad": 4.3438,
+      "log_good": 4.4308
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.6667,
+      "good": 7.3333,
+      "ratio": 0.8461,
+      "suggested_scalar": -0.1451,
+      "log_bad": 2.1595,
+      "log_good": 1.9924
+    },
+    "halstead.mean_volume": {
+      "bad": 3447.052,
+      "good": 3997.2942,
+      "ratio": 1.1596,
+      "suggested_scalar": 0.1286,
+      "log_bad": 8.1453,
+      "log_good": 8.2934
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 668.0,
+      "good": 879.6667,
+      "ratio": 1.3169,
+      "suggested_scalar": 0.2391,
+      "log_bad": 6.5043,
+      "log_good": 6.7795
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 23.9363,
+      "good": 33.414,
+      "ratio": 1.396,
+      "suggested_scalar": 0.2897,
+      "log_bad": 3.1754,
+      "log_good": 3.509
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0499,
+      "good": 1.4147,
+      "ratio": 1.3475,
+      "suggested_scalar": 0.259,
+      "log_bad": 0.0487,
+      "log_good": 0.3469
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.6667,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0599,
+      "log_bad": 1.6094,
+      "log_good": 1.5405
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 40.0,
+      "good": 40.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6889,
+      "log_good": 3.6889
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7325,
+      "good": 0.8301,
+      "ratio": 1.1332,
+      "suggested_scalar": 0.1086,
+      "log_bad": -0.3113,
+      "log_good": -0.1862
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9709,
+      "good": 0.9873,
+      "ratio": 1.0169,
+      "suggested_scalar": 0.0145,
+      "log_bad": -0.0295,
+      "log_good": -0.0128
+    },
+    "halstead.mean_length": {
+      "bad": 543.6667,
+      "good": 595.3333,
+      "ratio": 1.095,
+      "suggested_scalar": 0.0789,
+      "log_bad": 6.2983,
+      "log_good": 6.3891
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.4849,
+      "good": 4.7193,
+      "ratio": 0.8604,
+      "suggested_scalar": -0.1306,
+      "log_bad": 1.702,
+      "log_good": 1.5517
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4076,
+      "good": 6.748,
+      "ratio": 1.0531,
+      "suggested_scalar": 0.045,
+      "log_bad": 1.8575,
+      "log_good": 1.9092
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1571,
+      "good": 0.1159,
+      "ratio": 0.7377,
+      "suggested_scalar": -0.2642,
+      "log_bad": -1.8509,
+      "log_good": -2.155
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 49.9788,
+      "good": 38.8214,
+      "ratio": 0.7768,
+      "suggested_scalar": -0.2194,
+      "log_bad": 3.9116,
+      "log_good": 3.659
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.6667,
+      "good": 6.6667,
+      "ratio": 1.8182,
+      "suggested_scalar": 0.5193,
+      "log_bad": 1.2993,
+      "log_good": 1.8971
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 43.6667,
+      "good": 66.6667,
+      "ratio": 1.5267,
+      "suggested_scalar": 0.3675,
+      "log_bad": 3.7766,
+      "log_good": 4.1997
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6078,
+      "good": 0.7247,
+      "ratio": 1.1923,
+      "suggested_scalar": 0.1528,
+      "log_bad": -0.4979,
+      "log_good": -0.322
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 77.0,
+      "good": 84.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0756,
+      "log_bad": 4.3438,
+      "log_good": 4.4308
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.3333,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.2499,
+      "log_bad": 0.0,
+      "log_good": 0.2877
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.3333,
+      "good": 24.0,
+      "ratio": 1.6744,
+      "suggested_scalar": 0.4477,
+      "log_bad": 2.6626,
+      "log_good": 3.1781
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.no_blind_rescue": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 12.0,
+      "good": 22.0,
+      "ratio": 1.8333,
+      "suggested_scalar": 0.468,
+      "log_bad": 2.4849,
+      "log_good": 3.091
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.005,
+      "good": 0.0179,
+      "ratio": 3.58,
+      "suggested_scalar": 0.9847,
+      "log_bad": -5.2983,
+      "log_good": -4.023
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.8,
+      "good": 1.8,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.5878,
+      "log_good": 0.5878
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.775,
+      "good": 0.8333,
+      "ratio": 1.0752,
+      "suggested_scalar": 0.056,
+      "log_bad": -0.2549,
+      "log_good": -0.1824
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.005,
+      "good": 0.0179,
+      "ratio": 3.58,
+      "suggested_scalar": 0.9847,
+      "log_bad": -5.2983,
+      "log_good": -4.023
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4301,
+      "good": 4.5685,
+      "ratio": 1.0312,
+      "suggested_scalar": 0.0238,
+      "log_bad": 1.4884,
+      "log_good": 1.5192
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 65.0,
+      "good": 71.0,
+      "ratio": 1.0923,
+      "suggested_scalar": 0.0682,
+      "log_bad": 4.1744,
+      "log_good": 4.2627
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5422,
+      "good": 0.4977,
+      "ratio": 0.9179,
+      "suggested_scalar": -0.0661,
+      "log_bad": -0.6121,
+      "log_good": -0.6978
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 13.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.1105,
+      "log_bad": 2.7081,
+      "log_good": 2.5649
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7632,
+      "good": 0.6757,
+      "ratio": 0.8854,
+      "suggested_scalar": -0.094,
+      "log_bad": -0.2702,
+      "log_good": -0.392
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.25,
+      "good": 4.375,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.0224,
+      "log_bad": 1.4469,
+      "log_good": 1.4759
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 200.0,
+      "good": 392.0,
+      "ratio": 1.96,
+      "suggested_scalar": 0.5196,
+      "log_bad": 5.2983,
+      "log_good": 5.9713
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.5352,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.075,
+      "good": 1.0,
+      "ratio": 13.3333,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.5903,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8262,
+      "good": 1.053,
+      "ratio": 1.2745,
+      "suggested_scalar": 0.1873,
+      "log_bad": -0.1909,
+      "log_good": 0.0516
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 83.0,
+      "good": 151.0,
+      "ratio": 1.8193,
+      "suggested_scalar": 0.4621,
+      "log_bad": 4.4188,
+      "log_good": 5.0173
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 100.8408,
+      "good": 93.6771,
+      "ratio": 0.929,
+      "suggested_scalar": -0.0569,
+      "log_bad": 4.6135,
+      "log_good": 4.5399
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4623,
+      "good": 0.711,
+      "ratio": 1.538,
+      "suggested_scalar": 0.3324,
+      "log_bad": -0.7715,
+      "log_good": -0.3411
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 21.1015,
+      "good": 24.5281,
+      "ratio": 1.1624,
+      "suggested_scalar": 0.1162,
+      "log_bad": 3.0493,
+      "log_good": 3.1998
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1141.0,
+      "good": 1858.0,
+      "ratio": 1.6284,
+      "suggested_scalar": 0.3765,
+      "log_bad": 7.0397,
+      "log_good": 7.5273
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.225,
+      "good": 0.25,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0814,
+      "log_bad": -1.4917,
+      "log_good": -1.3863
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.65,
+      "good": 0.75,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.1105,
+      "log_bad": -0.4308,
+      "log_good": -0.2877
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.4054,
+      "good": 8.1667,
+      "ratio": 1.5108,
+      "suggested_scalar": 0.3186,
+      "log_bad": 1.6874,
+      "log_good": 2.1001
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 4.8375,
+      "good": 4.1094,
+      "ratio": 0.8495,
+      "suggested_scalar": -0.1259,
+      "log_bad": 1.5764,
+      "log_good": 1.4133
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 77.0,
+      "good": 130.0,
+      "ratio": 1.6883,
+      "suggested_scalar": 0.4044,
+      "log_bad": 4.3438,
+      "log_good": 4.8675
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9263,
+      "good": 0.9345,
+      "ratio": 1.0089,
+      "suggested_scalar": 0.0068,
+      "log_bad": -0.0766,
+      "log_good": -0.0677
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 19.0,
+      "good": 20.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0396,
+      "log_bad": 2.9444,
+      "log_good": 2.9957
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5986,
+      "good": 0.6765,
+      "ratio": 1.1301,
+      "suggested_scalar": 0.0945,
+      "log_bad": -0.5132,
+      "log_good": -0.3908
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3434,
+      "good": 0.5795,
+      "ratio": 1.6875,
+      "suggested_scalar": 0.404,
+      "log_bad": -1.0689,
+      "log_good": -0.5456
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4913,
+      "good": 3.0915,
+      "ratio": 1.2409,
+      "suggested_scalar": 0.1667,
+      "log_bad": 0.9128,
+      "log_good": 1.1287
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 198.0,
+      "good": 390.0,
+      "ratio": 1.9697,
+      "suggested_scalar": 0.5234,
+      "log_bad": 5.2883,
+      "log_good": 5.9661
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 18.0,
+      "ratio": 1.6364,
+      "suggested_scalar": 0.3803,
+      "log_bad": 2.3979,
+      "log_good": 2.8904
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.025,
+      "good": 0.0408,
+      "ratio": 1.632,
+      "suggested_scalar": 0.3782,
+      "log_bad": -3.6889,
+      "log_good": -3.1991
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.6147,
+      "good": 5.6439,
+      "ratio": 1.0052,
+      "suggested_scalar": 0.004,
+      "log_bad": 1.7254,
+      "log_good": 1.7306
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 6.0,
+      "good": 21.0,
+      "ratio": 3.5,
+      "suggested_scalar": 0.9673,
+      "log_bad": 1.7918,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.3744,
+      "good": 0.5818,
+      "ratio": 1.554,
+      "suggested_scalar": 0.3404,
+      "log_bad": -0.9824,
+      "log_good": -0.5416
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6045,
+      "good": 5.564,
+      "ratio": 0.9928,
+      "suggested_scalar": -0.0056,
+      "log_bad": 1.7236,
+      "log_good": 1.7163
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.789,
+      "good": 0.8095,
+      "ratio": 1.026,
+      "suggested_scalar": 0.0198,
+      "log_bad": -0.237,
+      "log_good": -0.2113
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1111,
+      "good": 0.0943,
+      "ratio": 0.8488,
+      "suggested_scalar": -0.1266,
+      "log_bad": -2.1973,
+      "log_good": -2.3613
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.5936,
+      "good": 4.9526,
+      "ratio": 1.0782,
+      "suggested_scalar": 0.0581,
+      "log_bad": 1.5247,
+      "log_good": 1.5999
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 161.0,
+      "good": 243.0,
+      "ratio": 1.5093,
+      "suggested_scalar": 0.3178,
+      "log_bad": 5.0814,
+      "log_good": 5.4931
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 10.0,
+      "ratio": 10.0,
+      "suggested_scalar": 1.7779,
+      "log_bad": 0.0,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.3654,
+      "good": 0.6457,
+      "ratio": 1.7671,
+      "suggested_scalar": 0.4396,
+      "log_bad": -1.0068,
+      "log_good": -0.4374
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 71.0,
+      "good": 87.0,
+      "ratio": 1.2254,
+      "suggested_scalar": 0.1569,
+      "log_bad": 4.2627,
+      "log_good": 4.4659
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 633.0,
+      "good": 1133.0,
+      "ratio": 1.7899,
+      "suggested_scalar": 0.4495,
+      "log_bad": 6.4505,
+      "log_good": 7.0326
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 83.0,
+      "good": 115.0,
+      "ratio": 1.3855,
+      "suggested_scalar": 0.2518,
+      "log_bad": 4.4188,
+      "log_good": 4.7449
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.005,
+      "good": 0.0153,
+      "ratio": 3.06,
+      "suggested_scalar": 0.8636,
+      "log_bad": -5.2983,
+      "log_good": -4.1799
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.27,
+      "good": 0.2781,
+      "ratio": 1.03,
+      "suggested_scalar": 0.0228,
+      "log_bad": -1.3093,
+      "log_good": -1.2798
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 36.0,
+      "good": 82.0,
+      "ratio": 2.2778,
+      "suggested_scalar": 0.6356,
+      "log_bad": 3.5835,
+      "log_good": 4.4067
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 71.0,
+      "good": 87.0,
+      "ratio": 1.2254,
+      "suggested_scalar": 0.1569,
+      "log_bad": 4.2627,
+      "log_good": 4.4659
+    },
+    "brevity.mean_sample_size": {
+      "bad": 71.0,
+      "good": 87.0,
+      "ratio": 1.2254,
+      "suggested_scalar": 0.1569,
+      "log_bad": 4.2627,
+      "log_good": 4.4659
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 200.0,
+      "good": 392.0,
+      "ratio": 1.96,
+      "suggested_scalar": 0.5196,
+      "log_bad": 5.2983,
+      "log_good": 5.9713
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 83.0,
+      "good": 200.0,
+      "ratio": 2.4096,
+      "suggested_scalar": 0.6791,
+      "log_bad": 4.4188,
+      "log_good": 5.2983
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 143.0,
+      "good": 195.0,
+      "ratio": 1.3636,
+      "suggested_scalar": 0.2395,
+      "log_bad": 4.9628,
+      "log_good": 5.273
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.2903,
+      "good": 1.797,
+      "ratio": 1.3927,
+      "suggested_scalar": 0.2558,
+      "log_bad": 0.2549,
+      "log_good": 0.5861
+    },
+    "halstead.mean_effort": {
+      "bad": 18788.0856,
+      "good": 43681.292,
+      "ratio": 2.3249,
+      "suggested_scalar": 0.6514,
+      "log_bad": 9.841,
+      "log_good": 10.6847
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.9113,
+      "good": 0.8636,
+      "ratio": 0.9477,
+      "suggested_scalar": -0.0415,
+      "log_bad": -0.0929,
+      "log_good": -0.1466
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 46.0,
+      "good": 51.0,
+      "ratio": 1.1087,
+      "suggested_scalar": 0.0797,
+      "log_bad": 3.8286,
+      "log_good": 3.9318
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 99.0,
+      "good": 200.0,
+      "ratio": 2.0202,
+      "suggested_scalar": 0.543,
+      "log_bad": 4.5951,
+      "log_good": 5.2983
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5422,
+      "good": 0.3974,
+      "ratio": 0.7329,
+      "suggested_scalar": -0.2399,
+      "log_bad": -0.6121,
+      "log_good": -0.9228
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.6265,
+      "good": 7.5033,
+      "ratio": 0.9838,
+      "suggested_scalar": -0.0126,
+      "log_bad": 2.0316,
+      "log_good": 2.0153
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1111,
+      "good": 0.0943,
+      "ratio": 0.8488,
+      "suggested_scalar": -0.1266,
+      "log_bad": -2.1973,
+      "log_good": -2.3613
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.8459,
+      "good": 4.5167,
+      "ratio": 1.5871,
+      "suggested_scalar": 0.3566,
+      "log_bad": 1.0459,
+      "log_good": 1.5078
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 199.0,
+      "good": 391.0,
+      "ratio": 1.9648,
+      "suggested_scalar": 0.5215,
+      "log_bad": 5.2933,
+      "log_good": 5.9687
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 11.0,
+      "ratio": 11.0,
+      "suggested_scalar": 1.8515,
+      "log_bad": 0.0,
+      "log_good": 2.3979
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 31.0,
+      "good": 79.0,
+      "ratio": 2.5484,
+      "suggested_scalar": 0.7223,
+      "log_bad": 3.434,
+      "log_good": 4.3694
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1043.7825,
+      "good": 2426.7384,
+      "ratio": 2.3249,
+      "suggested_scalar": 0.6514,
+      "log_bad": 6.9506,
+      "log_good": 7.7943
+    },
+    "readability.mean_total_lines": {
+      "bad": 37.0,
+      "good": 48.0,
+      "ratio": 1.2973,
+      "suggested_scalar": 0.201,
+      "log_bad": 3.6109,
+      "log_good": 3.8712
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 1096.0709,
+      "good": 1937.1703,
+      "ratio": 1.7674,
+      "suggested_scalar": 0.4397,
+      "log_bad": 6.9995,
+      "log_good": 7.569
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 458.0,
+      "good": 601.0,
+      "ratio": 1.3122,
+      "suggested_scalar": 0.2098,
+      "log_bad": 6.1269,
+      "log_good": 6.3986
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 24.3784,
+      "good": 37.6042,
+      "ratio": 1.5425,
+      "suggested_scalar": 0.3347,
+      "log_bad": 3.1937,
+      "log_good": 3.6271
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.188,
+      "good": 1.2396,
+      "ratio": 1.0434,
+      "suggested_scalar": 0.0328,
+      "log_bad": 0.1723,
+      "log_good": 0.2148
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.5352,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 14.0,
+      "good": 33.0,
+      "ratio": 2.3571,
+      "suggested_scalar": 0.6621,
+      "log_bad": 2.6391,
+      "log_good": 3.4965
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.8483,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8075,
+      "good": 0.6749,
+      "ratio": 0.8358,
+      "suggested_scalar": -0.1385,
+      "log_bad": -0.2138,
+      "log_good": -0.3932
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9742,
+      "good": 0.9685,
+      "ratio": 0.9941,
+      "suggested_scalar": -0.0045,
+      "log_bad": -0.0261,
+      "log_good": -0.032
+    },
+    "halstead.mean_length": {
+      "bad": 182.0,
+      "good": 315.0,
+      "ratio": 1.7308,
+      "suggested_scalar": 0.4236,
+      "log_bad": 5.204,
+      "log_good": 5.7526
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 8.8,
+      "good": 10.4,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.129,
+      "log_bad": 2.1748,
+      "log_good": 2.3418
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.1497,
+      "good": 6.4429,
+      "ratio": 1.0477,
+      "suggested_scalar": 0.036,
+      "log_bad": 1.8164,
+      "log_good": 1.863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0731,
+      "good": 0.1076,
+      "ratio": 1.472,
+      "suggested_scalar": 0.2985,
+      "log_bad": -2.6159,
+      "log_good": -2.2293
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 17.1413,
+      "good": 22.549,
+      "ratio": 1.3155,
+      "suggested_scalar": 0.2117,
+      "log_bad": 2.8415,
+      "log_good": 3.1157
+    },
+    "branching.mean_branch_count": {
+      "bad": 9.0,
+      "good": 12.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.2221,
+      "log_bad": 2.1972,
+      "log_good": 2.4849
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 45.0,
+      "good": 60.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.2221,
+      "log_bad": 3.8067,
+      "log_good": 4.0943
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7483,
+      "good": 0.5795,
+      "ratio": 0.7744,
+      "suggested_scalar": -0.1974,
+      "log_bad": -0.29,
+      "log_good": -0.5456
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 40.0,
+      "good": 48.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.1408,
+      "log_bad": 3.6889,
+      "log_good": 3.8712
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.does_not_expose_implementation_errors": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0208,
+      "good": 0.0213,
+      "ratio": 1.024,
+      "suggested_scalar": 0.1651,
+      "log_bad": -3.8728,
+      "log_good": -3.849
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8605,
+      "good": 0.8605,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1502,
+      "log_good": -0.1502
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0208,
+      "good": 0.0213,
+      "ratio": 1.024,
+      "suggested_scalar": 0.1651,
+      "log_bad": -3.8728,
+      "log_good": -3.849
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.9449,
+      "good": 4.9615,
+      "ratio": 1.0034,
+      "suggested_scalar": 0.0233,
+      "log_bad": 1.5984,
+      "log_good": 1.6017
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 107.0,
+      "good": 116.0,
+      "ratio": 1.0841,
+      "suggested_scalar": 0.5615,
+      "log_bad": 4.6728,
+      "log_good": 4.7536
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5975,
+      "good": 0.6397,
+      "ratio": 1.0706,
+      "suggested_scalar": 0.4744,
+      "log_bad": -0.515,
+      "log_good": -0.4468
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7138,
+      "good": 0.7553,
+      "ratio": 1.0581,
+      "suggested_scalar": 0.3929,
+      "log_bad": -0.3372,
+      "log_good": -0.2806
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.7674,
+      "good": 0.7674,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2647,
+      "log_good": -0.2647
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 385.0,
+      "good": 376.0,
+      "ratio": 0.9766,
+      "suggested_scalar": -0.1644,
+      "log_bad": 5.9532,
+      "log_good": 5.9296
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0019,
+      "good": 0.002,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.3566,
+      "log_bad": -6.2659,
+      "log_good": -6.2146
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.186,
+      "good": 0.186,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.682,
+      "log_good": -1.682
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9342,
+      "good": 0.8951,
+      "ratio": 0.9581,
+      "suggested_scalar": -0.2972,
+      "log_bad": -0.0681,
+      "log_good": -0.1108
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 168.0,
+      "good": 165.0,
+      "ratio": 0.9821,
+      "suggested_scalar": -0.1253,
+      "log_bad": 5.124,
+      "log_good": 5.1059
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 102.7285,
+      "good": 104.1912,
+      "ratio": 1.0142,
+      "suggested_scalar": 0.0983,
+      "log_bad": 4.6321,
+      "log_good": 4.6462
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4714,
+      "good": 0.44,
+      "ratio": 0.9334,
+      "suggested_scalar": -0.4792,
+      "log_bad": -0.752,
+      "log_good": -0.821
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 14.2114,
+      "good": 13.3374,
+      "ratio": 0.9385,
+      "suggested_scalar": -0.4413,
+      "log_bad": 2.654,
+      "log_good": 2.5906
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1539.0,
+      "good": 1516.0,
+      "ratio": 0.9851,
+      "suggested_scalar": -0.1047,
+      "log_bad": 7.3389,
+      "log_good": 7.3238
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0698,
+      "good": 0.093,
+      "ratio": 1.3324,
+      "suggested_scalar": 1.995,
+      "log_bad": -2.6621,
+      "log_good": -2.3752
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8372,
+      "good": 0.8372,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1777,
+      "log_good": -0.1777
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.9535,
+      "good": 8.7442,
+      "ratio": 0.9766,
+      "suggested_scalar": -0.1644,
+      "log_bad": 2.192,
+      "log_good": 2.1684
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.4575,
+      "good": 0.4575,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.782,
+      "log_good": -0.782
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 129.0,
+      "good": 125.0,
+      "ratio": 0.969,
+      "suggested_scalar": -0.219,
+      "log_bad": 4.8598,
+      "log_good": 4.8283
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9428,
+      "good": 0.9453,
+      "ratio": 1.0027,
+      "suggested_scalar": 0.0184,
+      "log_bad": -0.0589,
+      "log_good": -0.0563
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 26.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 1.1614,
+      "log_bad": 3.091,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5543,
+      "good": 0.5455,
+      "ratio": 0.9841,
+      "suggested_scalar": -0.1113,
+      "log_bad": -0.59,
+      "log_good": -0.6061
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2768,
+      "good": 0.2567,
+      "ratio": 0.9274,
+      "suggested_scalar": -0.5241,
+      "log_bad": -1.2845,
+      "log_good": -1.3598
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2434,
+      "good": 2.2003,
+      "ratio": 0.9808,
+      "suggested_scalar": -0.1349,
+      "log_bad": 0.808,
+      "log_good": 0.7886
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 383.0,
+      "good": 374.0,
+      "ratio": 0.9765,
+      "suggested_scalar": -0.1653,
+      "log_bad": 5.948,
+      "log_good": 5.9243
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0208,
+      "good": 0.0239,
+      "ratio": 1.149,
+      "suggested_scalar": 0.9658,
+      "log_bad": -3.8728,
+      "log_good": -3.7339
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.858,
+      "good": 5.9069,
+      "ratio": 1.0083,
+      "suggested_scalar": 0.0578,
+      "log_bad": 1.7678,
+      "log_good": 1.7761
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 34.0,
+      "good": 35.0,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.2015,
+      "log_bad": 3.5264,
+      "log_good": 3.5553
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.91,
+      "good": 0.9308,
+      "ratio": 1.0229,
+      "suggested_scalar": 0.1571,
+      "log_bad": -0.0943,
+      "log_good": -0.0717
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9881,
+      "good": 6.094,
+      "ratio": 1.0177,
+      "suggested_scalar": 0.1219,
+      "log_bad": 1.7898,
+      "log_good": 1.8073
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8441,
+      "good": 0.8399,
+      "ratio": 0.995,
+      "suggested_scalar": -0.0347,
+      "log_bad": -0.1695,
+      "log_good": -0.1745
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.14,
+      "good": 0.14,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.9661,
+      "log_good": -1.9661
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.7698,
+      "good": 3.652,
+      "ratio": 0.9688,
+      "suggested_scalar": -0.2207,
+      "log_bad": 1.327,
+      "log_good": 1.2953
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 316.0,
+      "good": 312.0,
+      "ratio": 0.9873,
+      "suggested_scalar": -0.0886,
+      "log_bad": 5.7557,
+      "log_good": 5.743
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7685,
+      "good": 0.7612,
+      "ratio": 0.9905,
+      "suggested_scalar": -0.0664,
+      "log_bad": -0.2633,
+      "log_good": -0.2729
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 111.0,
+      "good": 120.0,
+      "ratio": 1.0811,
+      "suggested_scalar": 0.542,
+      "log_bad": 4.7095,
+      "log_good": 4.7875
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 957.0,
+      "good": 935.0,
+      "ratio": 0.977,
+      "suggested_scalar": -0.1617,
+      "log_bad": 6.8638,
+      "log_good": 6.8405
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 167.0,
+      "good": 164.0,
+      "ratio": 0.982,
+      "suggested_scalar": -0.126,
+      "log_bad": 5.118,
+      "log_good": 5.0999
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2416,
+      "good": 0.2314,
+      "ratio": 0.9578,
+      "suggested_scalar": -0.2999,
+      "log_bad": -1.4205,
+      "log_good": -1.4636
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 62.0,
+      "good": 55.0,
+      "ratio": 0.8871,
+      "suggested_scalar": -0.8329,
+      "log_bad": 4.1271,
+      "log_good": 4.0073
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 111.0,
+      "good": 120.0,
+      "ratio": 1.0811,
+      "suggested_scalar": 0.542,
+      "log_bad": 4.7095,
+      "log_good": 4.7875
+    },
+    "brevity.mean_sample_size": {
+      "bad": 111.0,
+      "good": 120.0,
+      "ratio": 1.0811,
+      "suggested_scalar": 0.542,
+      "log_bad": 4.7095,
+      "log_good": 4.7875
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 385.0,
+      "good": 376.0,
+      "ratio": 0.9766,
+      "suggested_scalar": -0.1644,
+      "log_bad": 5.9532,
+      "log_good": 5.9296
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 182.0,
+      "good": 173.0,
+      "ratio": 0.9505,
+      "suggested_scalar": -0.3526,
+      "log_bad": 5.204,
+      "log_good": 5.1533
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 265.0,
+      "good": 265.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.5797,
+      "log_good": 5.5797
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.8,
+      "good": 1.5608,
+      "ratio": 0.8671,
+      "suggested_scalar": -0.9913,
+      "log_bad": 0.5878,
+      "log_good": 0.4452
+    },
+    "halstead.mean_effort": {
+      "bad": 49827.6894,
+      "good": 54098.4973,
+      "ratio": 1.0857,
+      "suggested_scalar": 0.5717,
+      "log_bad": 10.8163,
+      "log_good": 10.8986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8813,
+      "good": 0.8823,
+      "ratio": 1.0011,
+      "suggested_scalar": 0.0079,
+      "log_bad": -0.1264,
+      "log_good": -0.1252
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 85.0,
+      "good": 90.0,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.3974,
+      "log_bad": 4.4427,
+      "log_good": 4.4998
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 175.0,
+      "good": 169.0,
+      "ratio": 0.9657,
+      "suggested_scalar": -0.2425,
+      "log_bad": 5.1648,
+      "log_good": 5.1299
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4881,
+      "good": 0.5273,
+      "ratio": 1.0803,
+      "suggested_scalar": 0.537,
+      "log_bad": -0.7172,
+      "log_good": -0.64
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.6964,
+      "good": 5.6667,
+      "ratio": 0.9948,
+      "suggested_scalar": -0.0363,
+      "log_bad": 1.7398,
+      "log_good": 1.7346
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.14,
+      "good": 0.14,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.9661,
+      "log_good": -1.9661
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.9755,
+      "good": 3.6947,
+      "ratio": 0.9294,
+      "suggested_scalar": -0.5093,
+      "log_bad": 1.3802,
+      "log_good": 1.3069
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 384.0,
+      "good": 375.0,
+      "ratio": 0.9766,
+      "suggested_scalar": -0.1649,
+      "log_bad": 5.9506,
+      "log_good": 5.9269
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 39.0,
+      "good": 34.0,
+      "ratio": 0.8718,
+      "suggested_scalar": -0.9538,
+      "log_bad": 3.6636,
+      "log_good": 3.5264
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2768.205,
+      "good": 3005.4721,
+      "ratio": 1.0857,
+      "suggested_scalar": 0.5717,
+      "log_bad": 7.926,
+      "log_good": 8.0082
+    },
+    "readability.mean_total_lines": {
+      "bad": 43.0,
+      "good": 43.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7612,
+      "log_good": 3.7612
+    },
+    "indentation.mean_max_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_volume": {
+      "bad": 2305.5817,
+      "good": 2283.7077,
+      "ratio": 0.9905,
+      "suggested_scalar": -0.0663,
+      "log_bad": 7.7431,
+      "log_good": 7.7336
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 686.0,
+      "good": 689.0,
+      "ratio": 1.0044,
+      "suggested_scalar": 0.0303,
+      "log_bad": 6.5309,
+      "log_good": 6.5352
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 34.6279,
+      "good": 34.093,
+      "ratio": 0.9846,
+      "suggested_scalar": -0.1082,
+      "log_bad": 3.5447,
+      "log_good": 3.5291
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1232,
+      "good": 1.1084,
+      "ratio": 0.9868,
+      "suggested_scalar": -0.0922,
+      "log_bad": 0.1162,
+      "log_good": 0.1029
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 27.0,
+      "good": 25.0,
+      "ratio": 0.9259,
+      "suggested_scalar": -0.535,
+      "log_bad": 3.2958,
+      "log_good": 3.2189
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8766,
+      "good": 0.891,
+      "ratio": 1.0164,
+      "suggested_scalar": 0.1133,
+      "log_bad": -0.1317,
+      "log_good": -0.1154
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9837,
+      "good": 0.986,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0162,
+      "log_bad": -0.0164,
+      "log_good": -0.0141
+    },
+    "halstead.mean_length": {
+      "bad": 342.0,
+      "good": 333.0,
+      "ratio": 0.9737,
+      "suggested_scalar": -0.1854,
+      "log_bad": 5.8348,
+      "log_good": 5.8081
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 14.5,
+      "good": 14.5,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6741,
+      "log_good": 2.6741
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7944,
+      "good": 6.9069,
+      "ratio": 1.0166,
+      "suggested_scalar": 0.1142,
+      "log_bad": 1.9161,
+      "log_good": 1.9325
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1183,
+      "good": 0.1141,
+      "ratio": 0.9645,
+      "suggested_scalar": -0.2513,
+      "log_bad": -2.1345,
+      "log_good": -2.1707
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 21.6118,
+      "good": 23.6889,
+      "ratio": 1.0961,
+      "suggested_scalar": 0.638,
+      "log_bad": 3.0732,
+      "log_good": 3.165
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 2.0,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 82.0,
+      "good": 87.0,
+      "ratio": 1.061,
+      "suggested_scalar": 0.4115,
+      "log_bad": 4.4067,
+      "log_good": 4.4659
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.766,
+      "good": 0.7925,
+      "ratio": 1.0346,
+      "suggested_scalar": 0.2364,
+      "log_bad": -0.2666,
+      "log_good": -0.2326
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 43.0,
+      "good": 43.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7612,
+      "log_good": 3.7612
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.wraps_errors_with_context": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0231,
+      "good": 0.0243,
+      "ratio": 1.0519,
+      "suggested_scalar": 0.0775,
+      "log_bad": -3.7679,
+      "log_good": -3.7173
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.881,
+      "good": 0.878,
+      "ratio": 0.9966,
+      "suggested_scalar": -0.0052,
+      "log_bad": -0.1267,
+      "log_good": -0.1301
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0231,
+      "good": 0.0243,
+      "ratio": 1.0519,
+      "suggested_scalar": 0.0775,
+      "log_bad": -3.7679,
+      "log_good": -3.7173
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 5.125,
+      "good": 5.1156,
+      "ratio": 0.9982,
+      "suggested_scalar": -0.0028,
+      "log_bad": 1.6341,
+      "log_good": 1.6323
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 92.0,
+      "good": 87.0,
+      "ratio": 0.9457,
+      "suggested_scalar": -0.0855,
+      "log_bad": 4.5218,
+      "log_good": 4.4659
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5271,
+      "good": 0.5128,
+      "ratio": 0.9729,
+      "suggested_scalar": -0.0421,
+      "log_bad": -0.6404,
+      "log_good": -0.6679
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6916,
+      "good": 0.677,
+      "ratio": 0.9789,
+      "suggested_scalar": -0.0326,
+      "log_bad": -0.3687,
+      "log_good": -0.3901
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.9286,
+      "good": 0.9024,
+      "ratio": 0.9718,
+      "suggested_scalar": -0.0438,
+      "log_bad": -0.0741,
+      "log_good": -0.1027
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 303.0,
+      "good": 329.0,
+      "ratio": 1.0858,
+      "suggested_scalar": 0.1259,
+      "log_bad": 5.7137,
+      "log_good": 5.7961
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.44,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0017,
+      "good": 0.0017,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.3771,
+      "log_good": -6.3771
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0476,
+      "good": 0.0244,
+      "ratio": 0.5126,
+      "suggested_scalar": -1.0222,
+      "log_bad": -3.0449,
+      "log_good": -3.7132
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8845,
+      "good": 0.9051,
+      "ratio": 1.0233,
+      "suggested_scalar": 0.0352,
+      "log_bad": -0.1227,
+      "log_good": -0.0997
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 127.0,
+      "good": 135.0,
+      "ratio": 1.063,
+      "suggested_scalar": 0.0934,
+      "log_bad": 4.8442,
+      "log_good": 4.9053
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 103.9964,
+      "good": 103.2573,
+      "ratio": 0.9929,
+      "suggested_scalar": -0.0109,
+      "log_bad": 4.6444,
+      "log_good": 4.6372
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4934,
+      "good": 0.5762,
+      "ratio": 1.1678,
+      "suggested_scalar": 0.2373,
+      "log_bad": -0.7064,
+      "log_good": -0.5513
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 12.9823,
+      "good": 13.1649,
+      "ratio": 1.0141,
+      "suggested_scalar": 0.0214,
+      "log_bad": 2.5636,
+      "log_good": 2.5776
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1163.0,
+      "good": 1185.0,
+      "ratio": 1.0189,
+      "suggested_scalar": 0.0287,
+      "log_bad": 7.0588,
+      "log_good": 7.0775
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0714,
+      "good": 0.122,
+      "ratio": 1.7087,
+      "suggested_scalar": 0.8195,
+      "log_bad": -2.6395,
+      "log_good": -2.1037
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8333,
+      "good": 0.8293,
+      "ratio": 0.9952,
+      "suggested_scalar": -0.0074,
+      "log_bad": -0.1824,
+      "log_good": -0.1872
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.2143,
+      "good": 8.0244,
+      "ratio": 1.1123,
+      "suggested_scalar": 0.1628,
+      "log_bad": 1.9761,
+      "log_good": 2.0825
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.6378,
+      "good": 0.6246,
+      "ratio": 0.9793,
+      "suggested_scalar": -0.032,
+      "log_bad": -0.4497,
+      "log_good": -0.4706
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 80.0,
+      "good": 85.0,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.0927,
+      "log_bad": 4.382,
+      "log_good": 4.4427
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9375,
+      "good": 0.9334,
+      "ratio": 0.9956,
+      "suggested_scalar": -0.0067,
+      "log_bad": -0.0645,
+      "log_good": -0.0689
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 23.0,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.1392,
+      "log_bad": 3.0445,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5004,
+      "good": 0.5308,
+      "ratio": 1.0608,
+      "suggested_scalar": 0.0902,
+      "log_bad": -0.6923,
+      "log_good": -0.6334
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2425,
+      "good": 0.3486,
+      "ratio": 1.4375,
+      "suggested_scalar": 0.5551,
+      "log_bad": -1.4168,
+      "log_good": -1.0538
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.0017,
+      "good": 2.1313,
+      "ratio": 1.0647,
+      "suggested_scalar": 0.096,
+      "log_bad": 0.694,
+      "log_good": 0.7567
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 301.0,
+      "good": 327.0,
+      "ratio": 1.0864,
+      "suggested_scalar": 0.1267,
+      "log_bad": 5.7071,
+      "log_good": 5.79
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0033,
+      "good": 0.0122,
+      "ratio": 3.697,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.7138,
+      "log_good": -4.4063
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.1293,
+      "good": 6.0875,
+      "ratio": 0.9932,
+      "suggested_scalar": -0.0105,
+      "log_bad": 1.8131,
+      "log_good": 1.8062
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 42.0,
+      "good": 45.0,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.1055,
+      "log_bad": 3.7377,
+      "log_good": 3.8067
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1317,
+      "good": 1.1247,
+      "ratio": 0.9938,
+      "suggested_scalar": -0.0095,
+      "log_bad": 0.1237,
+      "log_good": 0.1175
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8465,
+      "good": 5.7894,
+      "ratio": 0.9902,
+      "suggested_scalar": -0.015,
+      "log_bad": 1.7658,
+      "log_good": 1.756
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8361,
+      "good": 0.8404,
+      "ratio": 1.0051,
+      "suggested_scalar": 0.0078,
+      "log_bad": -0.179,
+      "log_good": -0.1739
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.16,
+      "good": 0.1633,
+      "ratio": 1.0206,
+      "suggested_scalar": 0.0312,
+      "log_bad": -1.8326,
+      "log_good": -1.8122
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6031,
+      "good": 3.6283,
+      "ratio": 1.007,
+      "suggested_scalar": 0.0107,
+      "log_bad": 1.2818,
+      "log_good": 1.2888
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 264.0,
+      "good": 264.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.5759,
+      "log_good": 5.5759
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5915,
+      "good": 0.6228,
+      "ratio": 1.0529,
+      "suggested_scalar": 0.0789,
+      "log_bad": -0.5251,
+      "log_good": -0.4735
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 92.0,
+      "good": 89.0,
+      "ratio": 0.9674,
+      "suggested_scalar": -0.0507,
+      "log_bad": 4.5218,
+      "log_good": 4.4886
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 679.0,
+      "good": 685.0,
+      "ratio": 1.0088,
+      "suggested_scalar": 0.0135,
+      "log_bad": 6.5206,
+      "log_good": 6.5294
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 139.0,
+      "good": 139.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.9345,
+      "log_good": 4.9345
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.231,
+      "good": 0.2523,
+      "ratio": 1.0922,
+      "suggested_scalar": 0.1349,
+      "log_bad": -1.4653,
+      "log_good": -1.3771
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 64.0,
+      "good": 76.0,
+      "ratio": 1.1875,
+      "suggested_scalar": 0.2629,
+      "log_bad": 4.1589,
+      "log_good": 4.3307
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 92.0,
+      "good": 89.0,
+      "ratio": 0.9674,
+      "suggested_scalar": -0.0507,
+      "log_bad": 4.5218,
+      "log_good": 4.4886
+    },
+    "brevity.mean_sample_size": {
+      "bad": 92.0,
+      "good": 89.0,
+      "ratio": 0.9674,
+      "suggested_scalar": -0.0507,
+      "log_bad": 4.5218,
+      "log_good": 4.4886
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 303.0,
+      "good": 329.0,
+      "ratio": 1.0858,
+      "suggested_scalar": 0.1259,
+      "log_bad": 5.7137,
+      "log_good": 5.7961
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 145.0,
+      "good": 162.0,
+      "ratio": 1.1172,
+      "suggested_scalar": 0.1696,
+      "log_bad": 4.9767,
+      "log_good": 5.0876
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 217.0,
+      "good": 215.0,
+      "ratio": 0.9908,
+      "suggested_scalar": -0.0142,
+      "log_bad": 5.3799,
+      "log_good": 5.3706
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.8607,
+      "good": 1.9703,
+      "ratio": 1.0589,
+      "suggested_scalar": 0.0875,
+      "log_bad": 0.621,
+      "log_good": 0.6782
+    },
+    "halstead.mean_effort": {
+      "bad": 36475.3482,
+      "good": 46667.5485,
+      "ratio": 1.2794,
+      "suggested_scalar": 0.3769,
+      "log_bad": 10.5044,
+      "log_good": 10.7508
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8962,
+      "good": 0.894,
+      "ratio": 0.9975,
+      "suggested_scalar": -0.0038,
+      "log_bad": -0.1096,
+      "log_good": -0.112
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 71.0,
+      "good": 64.0,
+      "ratio": 0.9014,
+      "suggested_scalar": -0.1588,
+      "log_bad": 4.2627,
+      "log_good": 4.1589
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 133.0,
+      "good": 151.0,
+      "ratio": 1.1353,
+      "suggested_scalar": 0.1942,
+      "log_bad": 4.8903,
+      "log_good": 5.0173
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4882,
+      "good": 0.4296,
+      "ratio": 0.88,
+      "suggested_scalar": -0.1956,
+      "log_bad": -0.717,
+      "log_good": -0.8449
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.3465,
+      "good": 5.0741,
+      "ratio": 0.9491,
+      "suggested_scalar": -0.08,
+      "log_bad": 1.6764,
+      "log_good": 1.6241
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.16,
+      "good": 0.1633,
+      "ratio": 1.0206,
+      "suggested_scalar": 0.0312,
+      "log_bad": -1.8326,
+      "log_good": -1.8122
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.176,
+      "good": 4.4293,
+      "ratio": 1.0607,
+      "suggested_scalar": 0.0901,
+      "log_bad": 1.4294,
+      "log_good": 1.4882
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 302.0,
+      "good": 328.0,
+      "ratio": 1.0861,
+      "suggested_scalar": 0.1263,
+      "log_bad": 5.7104,
+      "log_good": 5.793
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 36.0,
+      "good": 51.0,
+      "ratio": 1.4167,
+      "suggested_scalar": 0.5328,
+      "log_bad": 3.5835,
+      "log_good": 3.9318
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2026.4082,
+      "good": 2592.6416,
+      "ratio": 1.2794,
+      "suggested_scalar": 0.3769,
+      "log_bad": 7.614,
+      "log_good": 7.8604
+    },
+    "readability.mean_total_lines": {
+      "bad": 42.0,
+      "good": 41.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0369,
+      "log_bad": 3.7377,
+      "log_good": 3.7136
+    },
+    "indentation.mean_max_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "halstead.mean_volume": {
+      "bad": 1774.4089,
+      "good": 1868.4536,
+      "ratio": 1.053,
+      "suggested_scalar": 0.079,
+      "log_bad": 7.4812,
+      "log_good": 7.5329
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 581.0,
+      "good": 556.0,
+      "ratio": 0.957,
+      "suggested_scalar": -0.0673,
+      "log_bad": 6.3648,
+      "log_good": 6.3208
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 26.4048,
+      "good": 27.7073,
+      "ratio": 1.0493,
+      "suggested_scalar": 0.0737,
+      "log_bad": 3.2735,
+      "log_good": 3.3217
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.129,
+      "good": 1.128,
+      "ratio": 0.9991,
+      "suggested_scalar": -0.0014,
+      "log_bad": 0.1213,
+      "log_good": 0.1204
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.44,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 21.0,
+      "good": 23.0,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.1392,
+      "log_bad": 3.0445,
+      "log_good": 3.1355
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -1.0603,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8636,
+      "good": 0.8068,
+      "ratio": 0.9342,
+      "suggested_scalar": -0.1041,
+      "log_bad": -0.1466,
+      "log_good": -0.2147
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9877,
+      "good": 0.9849,
+      "ratio": 0.9972,
+      "suggested_scalar": -0.0043,
+      "log_bad": -0.0124,
+      "log_good": -0.0152
+    },
+    "halstead.mean_length": {
+      "bad": 272.0,
+      "good": 290.0,
+      "ratio": 1.0662,
+      "suggested_scalar": 0.098,
+      "log_bad": 5.6058,
+      "log_good": 5.6699
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.6667,
+      "good": 9.3333,
+      "ratio": 0.9655,
+      "suggested_scalar": -0.0537,
+      "log_bad": 2.2687,
+      "log_good": 2.2336
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5236,
+      "good": 6.4757,
+      "ratio": 0.9927,
+      "suggested_scalar": -0.0113,
+      "log_bad": 1.8754,
+      "log_good": 1.8681
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1251,
+      "good": 0.1367,
+      "ratio": 1.0927,
+      "suggested_scalar": 0.1356,
+      "log_bad": -2.0786,
+      "log_good": -1.99
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 20.5563,
+      "good": 24.9766,
+      "ratio": 1.215,
+      "suggested_scalar": 0.2979,
+      "log_bad": 3.0232,
+      "log_good": 3.2179
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.7814,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 62.0,
+      "good": 58.0,
+      "ratio": 0.9355,
+      "suggested_scalar": -0.102,
+      "log_bad": 4.1271,
+      "log_good": 4.0604
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7051,
+      "good": 0.6465,
+      "ratio": 0.9169,
+      "suggested_scalar": -0.1327,
+      "log_bad": -0.3494,
+      "log_good": -0.4362
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 42.0,
+      "good": 41.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0369,
+      "log_bad": 3.7377,
+      "log_good": 3.7136
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.size_vs_length_naming_is_consistent": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 43.0,
+      "good": 37.0,
+      "ratio": 0.8605,
+      "suggested_scalar": -0.1545,
+      "log_bad": 3.7612,
+      "log_good": 3.6109
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0077,
+      "good": 0.0423,
+      "ratio": 5.4935,
+      "suggested_scalar": 1.7509,
+      "log_bad": -4.8665,
+      "log_good": -3.163
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8571,
+      "good": 0.7358,
+      "ratio": 0.8585,
+      "suggested_scalar": -0.1568,
+      "log_bad": -0.1542,
+      "log_good": -0.3068
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0077,
+      "good": 0.0423,
+      "ratio": 5.4935,
+      "suggested_scalar": 1.7509,
+      "log_bad": -4.8665,
+      "log_good": -3.163
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.762,
+      "good": 4.7181,
+      "ratio": 0.9908,
+      "suggested_scalar": -0.0095,
+      "log_bad": 1.5607,
+      "log_good": 1.5514
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 80.0,
+      "good": 61.0,
+      "ratio": 0.7625,
+      "suggested_scalar": -0.2787,
+      "log_bad": 4.382,
+      "log_good": 4.1109
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.429,
+      "good": 0.4788,
+      "ratio": 1.1161,
+      "suggested_scalar": 0.1129,
+      "log_bad": -0.8463,
+      "log_good": -0.7365
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 17.0,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.0623,
+      "log_bad": 2.7726,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5673,
+      "good": 0.5736,
+      "ratio": 1.0111,
+      "suggested_scalar": 0.0114,
+      "log_bad": -0.5669,
+      "log_good": -0.5558
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.2381,
+      "good": 2.0755,
+      "ratio": 0.9273,
+      "suggested_scalar": -0.0775,
+      "log_bad": 0.8056,
+      "log_good": 0.7302
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 388.0,
+      "good": 496.0,
+      "ratio": 1.2784,
+      "suggested_scalar": 0.2524,
+      "log_bad": 5.961,
+      "log_good": 6.2066
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1667,
+      "good": 1.0,
+      "ratio": 5.9988,
+      "suggested_scalar": 1.8414,
+      "log_bad": -1.7916,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9832,
+      "good": 1.0115,
+      "ratio": 1.0288,
+      "suggested_scalar": 0.0292,
+      "log_bad": -0.0169,
+      "log_good": 0.0114
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 147.0,
+      "good": 213.0,
+      "ratio": 1.449,
+      "suggested_scalar": 0.3812,
+      "log_bad": 4.9904,
+      "log_good": 5.3613
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 92.3276,
+      "good": 101.5202,
+      "ratio": 1.0996,
+      "suggested_scalar": 0.0976,
+      "log_bad": 4.5253,
+      "log_good": 4.6203
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7235,
+      "good": 0.6747,
+      "ratio": 0.9326,
+      "suggested_scalar": -0.0718,
+      "log_bad": -0.3237,
+      "log_good": -0.3935
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 16.6028,
+      "good": 14.3612,
+      "ratio": 0.865,
+      "suggested_scalar": -0.1491,
+      "log_bad": 2.8096,
+      "log_good": 2.6645
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1568.0,
+      "good": 2008.0,
+      "ratio": 1.2806,
+      "suggested_scalar": 0.2542,
+      "log_bad": 7.3576,
+      "log_good": 7.6049
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.3095,
+      "good": 0.0943,
+      "ratio": 0.3047,
+      "suggested_scalar": -1.2215,
+      "log_bad": -1.1728,
+      "log_good": -2.3613
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8333,
+      "good": 0.717,
+      "ratio": 0.8604,
+      "suggested_scalar": -0.1545,
+      "log_bad": -0.1824,
+      "log_good": -0.3327
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 11.0857,
+      "good": 9.3585,
+      "ratio": 0.8442,
+      "suggested_scalar": -0.1741,
+      "log_bad": 2.4057,
+      "log_good": 2.2363
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.8005,
+      "good": 0.4471,
+      "ratio": 0.5585,
+      "suggested_scalar": -0.5986,
+      "log_bad": -0.2225,
+      "log_good": -0.805
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 115.0,
+      "good": 175.0,
+      "ratio": 1.5217,
+      "suggested_scalar": 0.4315,
+      "log_bad": 4.7449,
+      "log_good": 5.1648
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9397,
+      "good": 0.938,
+      "ratio": 0.9982,
+      "suggested_scalar": -0.0019,
+      "log_bad": -0.0622,
+      "log_good": -0.064
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 19.0,
+      "good": 23.0,
+      "ratio": 1.2105,
+      "suggested_scalar": 0.1964,
+      "log_bad": 2.9444,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6684,
+      "good": 0.6614,
+      "ratio": 0.9895,
+      "suggested_scalar": -0.0108,
+      "log_bad": -0.4029,
+      "log_good": -0.4134
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5052,
+      "good": 0.4879,
+      "ratio": 0.9658,
+      "suggested_scalar": -0.0358,
+      "log_bad": -0.6828,
+      "log_good": -0.7176
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0154,
+      "good": 2.9529,
+      "ratio": 0.9793,
+      "suggested_scalar": -0.0215,
+      "log_bad": 1.1037,
+      "log_good": 1.0828
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 386.0,
+      "good": 494.0,
+      "ratio": 1.2798,
+      "suggested_scalar": 0.2536,
+      "log_bad": 5.9558,
+      "log_good": 6.2025
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 6.0,
+      "good": 9.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.4167,
+      "log_bad": 1.7918,
+      "log_good": 2.1972
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0258,
+      "good": 0.0161,
+      "ratio": 0.624,
+      "suggested_scalar": -0.4847,
+      "log_bad": -3.6574,
+      "log_good": -4.1289
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7549,
+      "good": 5.8074,
+      "ratio": 1.0091,
+      "suggested_scalar": 0.0093,
+      "log_bad": 1.7501,
+      "log_good": 1.7591
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 32.0,
+      "good": 38.0,
+      "ratio": 1.1875,
+      "suggested_scalar": 0.1766,
+      "log_bad": 3.4657,
+      "log_good": 3.6376
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7559,
+      "good": 0.6766,
+      "ratio": 0.8951,
+      "suggested_scalar": -0.1139,
+      "log_bad": -0.2798,
+      "log_good": -0.3907
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4232,
+      "good": 5.7789,
+      "ratio": 1.0656,
+      "suggested_scalar": 0.0653,
+      "log_bad": 1.6907,
+      "log_good": 1.7542
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8275,
+      "good": 0.8124,
+      "ratio": 0.9818,
+      "suggested_scalar": -0.0189,
+      "log_bad": -0.1893,
+      "log_good": -0.2078
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1765,
+      "good": 0.1311,
+      "ratio": 0.7428,
+      "suggested_scalar": -0.3056,
+      "log_bad": -1.7344,
+      "log_good": -2.0318
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.0747,
+      "good": 3.7896,
+      "ratio": 0.93,
+      "suggested_scalar": -0.0746,
+      "log_bad": 1.4048,
+      "log_good": 1.3323
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 250.0,
+      "good": 318.0,
+      "ratio": 1.272,
+      "suggested_scalar": 0.2473,
+      "log_bad": 5.5215,
+      "log_good": 5.7621
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 1.1292,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7376,
+      "good": 0.6049,
+      "ratio": 0.8201,
+      "suggested_scalar": -0.2039,
+      "log_bad": -0.3044,
+      "log_good": -0.5027
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 108.0,
+      "ratio": 1.2706,
+      "suggested_scalar": 0.2461,
+      "log_bad": 4.4427,
+      "log_good": 4.6821
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 951.0,
+      "good": 1257.0,
+      "ratio": 1.3218,
+      "suggested_scalar": 0.2867,
+      "log_bad": 6.8575,
+      "log_good": 7.1365
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 154.0,
+      "good": 105.0,
+      "ratio": 0.6818,
+      "suggested_scalar": -0.3936,
+      "log_bad": 5.037,
+      "log_good": 4.654
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2784,
+      "good": 0.2137,
+      "ratio": 0.7676,
+      "suggested_scalar": -0.2718,
+      "log_bad": -1.2787,
+      "log_good": -1.5432
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 77.0,
+      "good": 87.0,
+      "ratio": 1.1299,
+      "suggested_scalar": 0.1255,
+      "log_bad": 4.3438,
+      "log_good": 4.4659
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 8.0,
+      "good": 7.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.1372,
+      "log_bad": 2.0794,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 108.0,
+      "ratio": 1.2706,
+      "suggested_scalar": 0.2461,
+      "log_bad": 4.4427,
+      "log_good": 4.6821
+    },
+    "brevity.mean_sample_size": {
+      "bad": 85.0,
+      "good": 108.0,
+      "ratio": 1.2706,
+      "suggested_scalar": 0.2461,
+      "log_bad": 4.4427,
+      "log_good": 4.6821
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 388.0,
+      "good": 496.0,
+      "ratio": 1.2784,
+      "suggested_scalar": 0.2524,
+      "log_bad": 5.961,
+      "log_good": 6.2066
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 188.0,
+      "good": 225.0,
+      "ratio": 1.1968,
+      "suggested_scalar": 0.1847,
+      "log_bad": 5.2364,
+      "log_good": 5.4161
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 184.0,
+      "good": 248.0,
+      "ratio": 1.3478,
+      "suggested_scalar": 0.3068,
+      "log_bad": 5.2149,
+      "log_good": 5.5134
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 3.1575,
+      "good": 3.4183,
+      "ratio": 1.0826,
+      "suggested_scalar": 0.0816,
+      "log_bad": 1.1498,
+      "log_good": 1.2291
+    },
+    "halstead.mean_effort": {
+      "bad": 53067.9226,
+      "good": 57667.8366,
+      "ratio": 1.0867,
+      "suggested_scalar": 0.0854,
+      "log_bad": 10.8793,
+      "log_good": 10.9625
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.7124,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8461,
+      "good": 0.8555,
+      "ratio": 1.0111,
+      "suggested_scalar": 0.0114,
+      "log_bad": -0.1671,
+      "log_good": -0.1561
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 61.0,
+      "good": 38.0,
+      "ratio": 0.623,
+      "suggested_scalar": -0.4864,
+      "log_bad": 4.1109,
+      "log_good": 3.6376
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 196.0,
+      "good": 201.0,
+      "ratio": 1.0255,
+      "suggested_scalar": 0.0259,
+      "log_bad": 5.2781,
+      "log_good": 5.3033
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3946,
+      "good": 0.3521,
+      "ratio": 0.8923,
+      "suggested_scalar": -0.1171,
+      "log_bad": -0.9299,
+      "log_good": -1.0438
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.4694,
+      "good": 5.9014,
+      "ratio": 0.9122,
+      "suggested_scalar": -0.0944,
+      "log_bad": 1.8671,
+      "log_good": 1.7752
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1765,
+      "good": 0.1311,
+      "ratio": 0.7428,
+      "suggested_scalar": -0.3056,
+      "log_bad": -1.7344,
+      "log_good": -2.0318
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.8702,
+      "good": 4.6525,
+      "ratio": 0.7926,
+      "suggested_scalar": -0.2389,
+      "log_bad": 1.7699,
+      "log_good": 1.5374
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 387.0,
+      "good": 495.0,
+      "ratio": 1.2791,
+      "suggested_scalar": 0.253,
+      "log_bad": 5.9584,
+      "log_good": 6.2046
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 59.0,
+      "good": 65.0,
+      "ratio": 1.1017,
+      "suggested_scalar": 0.0995,
+      "log_bad": 4.0775,
+      "log_good": 4.1744
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2948.2179,
+      "good": 3203.7687,
+      "ratio": 1.0867,
+      "suggested_scalar": 0.0854,
+      "log_bad": 7.989,
+      "log_good": 8.0721
+    },
+    "readability.mean_total_lines": {
+      "bad": 35.0,
+      "good": 53.0,
+      "ratio": 1.5143,
+      "suggested_scalar": 0.4265,
+      "log_bad": 3.5553,
+      "log_good": 3.9703
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2212.6748,
+      "good": 1814.8056,
+      "ratio": 0.8202,
+      "suggested_scalar": -0.2037,
+      "log_bad": 7.702,
+      "log_good": 7.5037
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 520.0,
+      "good": 680.0,
+      "ratio": 1.3077,
+      "suggested_scalar": 0.2757,
+      "log_bad": 6.2538,
+      "log_good": 6.5221
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.1714,
+      "good": 36.6604,
+      "ratio": 1.1761,
+      "suggested_scalar": 0.1667,
+      "log_bad": 3.4395,
+      "log_good": 3.6017
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2205,
+      "good": 1.1326,
+      "ratio": 0.928,
+      "suggested_scalar": -0.0768,
+      "log_bad": 0.1993,
+      "log_good": 0.1245
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 12.0,
+      "good": 22.0,
+      "ratio": 1.8333,
+      "suggested_scalar": 0.623,
+      "log_bad": 2.4849,
+      "log_good": 3.091
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 1.0,
+      "ratio": 0.1429,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.9459,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.764,
+      "good": 0.7956,
+      "ratio": 1.0414,
+      "suggested_scalar": 0.0417,
+      "log_bad": -0.2692,
+      "log_good": -0.2287
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 8.0,
+      "ratio": 4.0,
+      "suggested_scalar": 1.4248,
+      "log_bad": 0.6931,
+      "log_good": 2.0794
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9371,
+      "good": 0.9707,
+      "ratio": 1.0359,
+      "suggested_scalar": 0.0362,
+      "log_bad": -0.065,
+      "log_good": -0.0297
+    },
+    "halstead.mean_length": {
+      "bad": 350.0,
+      "good": 306.0,
+      "ratio": 0.8743,
+      "suggested_scalar": -0.1381,
+      "log_bad": 5.8579,
+      "log_good": 5.7236
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.25,
+      "good": 6.7143,
+      "ratio": 1.2789,
+      "suggested_scalar": 0.2528,
+      "log_bad": 1.6582,
+      "log_good": 1.9042
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4094,
+      "good": 6.7549,
+      "ratio": 1.0539,
+      "suggested_scalar": 0.054,
+      "log_bad": 1.8578,
+      "log_good": 1.9103
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1204,
+      "good": 0.1123,
+      "ratio": 0.9327,
+      "suggested_scalar": -0.0716,
+      "log_bad": -2.1169,
+      "log_good": -2.1866
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 23.9836,
+      "good": 31.7763,
+      "ratio": 1.3249,
+      "suggested_scalar": 0.2892,
+      "log_bad": 3.1774,
+      "log_good": 3.4587
+    },
+    "branching.mean_branch_count": {
+      "bad": 13.0,
+      "good": 5.0,
+      "ratio": 0.3846,
+      "suggested_scalar": -0.9821,
+      "log_bad": 2.5649,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 58.0,
+      "good": 75.0,
+      "ratio": 1.2931,
+      "suggested_scalar": 0.2642,
+      "log_bad": 4.0604,
+      "log_good": 4.3175
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5815,
+      "good": 0.6492,
+      "ratio": 1.1164,
+      "suggested_scalar": 0.1132,
+      "log_bad": -0.5421,
+      "log_good": -0.432
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 42.0,
+      "good": 53.0,
+      "ratio": 1.2619,
+      "suggested_scalar": 0.2391,
+      "log_bad": 3.7377,
+      "log_good": 3.9703
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.525,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 18.0,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.0587,
+      "log_bad": 2.8332,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.get_fetch_fetch_bang_contract_is_consistent": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 38.0,
+      "good": 42.0,
+      "ratio": 1.1053,
+      "suggested_scalar": 0.0993,
+      "log_bad": 3.6376,
+      "log_good": 3.7377
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0059,
+      "good": 0.0333,
+      "ratio": 5.6441,
+      "suggested_scalar": 1.7176,
+      "log_bad": -5.1328,
+      "log_good": -3.4022
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 1.5714,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.0462,
+      "log_bad": 0.4055,
+      "log_good": 0.452
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8,
+      "good": 0.6812,
+      "ratio": 0.8515,
+      "suggested_scalar": -0.1595,
+      "log_bad": -0.2231,
+      "log_good": -0.3839
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0059,
+      "good": 0.0333,
+      "ratio": 5.6441,
+      "suggested_scalar": 1.7176,
+      "log_bad": -5.1328,
+      "log_good": -3.4022
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7201,
+      "good": 4.6933,
+      "ratio": 0.9943,
+      "suggested_scalar": -0.0057,
+      "log_bad": 1.5518,
+      "log_good": 1.5461
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 79.0,
+      "good": 74.0,
+      "ratio": 0.9367,
+      "suggested_scalar": -0.0649,
+      "log_bad": 4.3694,
+      "log_good": 4.3041
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3321,
+      "good": 0.3557,
+      "ratio": 1.0711,
+      "suggested_scalar": 0.0681,
+      "log_bad": -1.1023,
+      "log_good": -1.0337
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.0,
+      "good": 20.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0484,
+      "log_bad": 3.0445,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5326,
+      "good": 0.4878,
+      "ratio": 0.9159,
+      "suggested_scalar": -0.0872,
+      "log_bad": -0.63,
+      "log_good": -0.7178
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.9778,
+      "good": 2.6377,
+      "ratio": 0.8858,
+      "suggested_scalar": -0.1204,
+      "log_bad": 1.0912,
+      "log_good": 0.9699
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 509.0,
+      "good": 721.0,
+      "ratio": 1.4165,
+      "suggested_scalar": 0.3456,
+      "log_bad": 6.2324,
+      "log_good": 6.5806
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0034,
+      "good": 0.0028,
+      "ratio": 0.8235,
+      "suggested_scalar": -0.1927,
+      "log_bad": -5.684,
+      "log_good": -5.8781
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1333,
+      "good": 1.0,
+      "ratio": 7.5019,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.0152,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.089,
+      "good": 1.1119,
+      "ratio": 1.021,
+      "suggested_scalar": 0.0207,
+      "log_bad": 0.0853,
+      "log_good": 0.1061
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 152.0,
+      "good": 226.0,
+      "ratio": 1.4868,
+      "suggested_scalar": 0.3937,
+      "log_bad": 5.0239,
+      "log_good": 5.4205
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 96.5696,
+      "good": 103.6817,
+      "ratio": 1.0736,
+      "suggested_scalar": 0.0705,
+      "log_bad": 4.5703,
+      "log_good": 4.6413
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.8189,
+      "good": 0.8389,
+      "ratio": 1.0244,
+      "suggested_scalar": 0.0239,
+      "log_bad": -0.1998,
+      "log_good": -0.1757
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.6141,
+      "good": 8.9668,
+      "ratio": 0.7721,
+      "suggested_scalar": -0.2567,
+      "log_bad": 2.4522,
+      "log_good": 2.1935
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1755.0,
+      "good": 2501.0,
+      "ratio": 1.4251,
+      "suggested_scalar": 0.3516,
+      "log_bad": 7.4702,
+      "log_good": 7.8244
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1556,
+      "good": 0.3188,
+      "ratio": 2.0488,
+      "suggested_scalar": 0.7119,
+      "log_bad": -1.8605,
+      "log_good": -1.1432
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7556,
+      "good": 0.6522,
+      "ratio": 0.8632,
+      "suggested_scalar": -0.1461,
+      "log_bad": -0.2802,
+      "log_good": -0.4274
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 13.0513,
+      "good": 10.4493,
+      "ratio": 0.8006,
+      "suggested_scalar": -0.2207,
+      "log_bad": 2.5689,
+      "log_good": 2.3465
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 6.0,
+      "ratio": 6.0,
+      "suggested_scalar": 1.7783,
+      "log_bad": 0.0,
+      "log_good": 1.7918
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.7773,
+      "good": 2.0281,
+      "ratio": 0.7302,
+      "suggested_scalar": -0.312,
+      "log_bad": 1.0215,
+      "log_good": 0.7071
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 123.0,
+      "good": 178.0,
+      "ratio": 1.4472,
+      "suggested_scalar": 0.3668,
+      "log_bad": 4.8122,
+      "log_good": 5.1818
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9038,
+      "good": 0.9108,
+      "ratio": 1.0077,
+      "suggested_scalar": 0.0077,
+      "log_bad": -0.1011,
+      "log_good": -0.0934
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 33.0,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.1992,
+      "log_bad": 3.2958,
+      "log_good": 3.4965
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.7009,
+      "good": 0.7197,
+      "ratio": 1.0268,
+      "suggested_scalar": 0.0263,
+      "log_bad": -0.3554,
+      "log_good": -0.3289
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.6765,
+      "good": 0.7191,
+      "ratio": 1.063,
+      "suggested_scalar": 0.0606,
+      "log_bad": -0.3908,
+      "log_good": -0.3298
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.3429,
+      "good": 3.5678,
+      "ratio": 1.0673,
+      "suggested_scalar": 0.0646,
+      "log_bad": 1.2068,
+      "log_good": 1.2719
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 507.0,
+      "good": 719.0,
+      "ratio": 1.4181,
+      "suggested_scalar": 0.3467,
+      "log_bad": 6.2285,
+      "log_good": 6.5779
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 9.0,
+      "good": 12.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.2855,
+      "log_bad": 2.1972,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0255,
+      "good": 0.0125,
+      "ratio": 0.4902,
+      "suggested_scalar": -0.7076,
+      "log_bad": -3.6691,
+      "log_good": -4.382
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7004,
+      "good": 5.7549,
+      "ratio": 1.0096,
+      "suggested_scalar": 0.0094,
+      "log_bad": 1.7405,
+      "log_good": 1.7501
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 28.0,
+      "good": 42.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.4024,
+      "log_bad": 3.3322,
+      "log_good": 3.7377
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7444,
+      "good": 0.8615,
+      "ratio": 1.1573,
+      "suggested_scalar": 0.145,
+      "log_bad": -0.2952,
+      "log_good": -0.1491
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5299,
+      "good": 5.7026,
+      "ratio": 1.0312,
+      "suggested_scalar": 0.0305,
+      "log_bad": 1.7102,
+      "log_good": 1.7409
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.828,
+      "good": 0.8155,
+      "ratio": 0.9849,
+      "suggested_scalar": -0.0151,
+      "log_bad": -0.1887,
+      "log_good": -0.204
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1509,
+      "good": 0.1154,
+      "ratio": 0.7647,
+      "suggested_scalar": -0.2662,
+      "log_bad": -1.8911,
+      "log_good": -2.1594
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.4079,
+      "good": 2.9945,
+      "ratio": 0.8787,
+      "suggested_scalar": -0.1283,
+      "log_bad": 1.2261,
+      "log_good": 1.0968
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 1.0904,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 277.0,
+      "good": 364.0,
+      "ratio": 1.3141,
+      "suggested_scalar": 0.2711,
+      "log_bad": 5.624,
+      "log_good": 5.8972
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.1658,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9519,
+      "good": 1.0597,
+      "ratio": 1.1132,
+      "suggested_scalar": 0.1065,
+      "log_bad": -0.0493,
+      "log_good": 0.058
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 84.0,
+      "good": 100.0,
+      "ratio": 1.1905,
+      "suggested_scalar": 0.173,
+      "log_bad": 4.4308,
+      "log_good": 4.6052
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 902.0,
+      "good": 1244.0,
+      "ratio": 1.3792,
+      "suggested_scalar": 0.3191,
+      "log_bad": 6.8046,
+      "log_good": 7.1261
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 177.0,
+      "good": 168.0,
+      "ratio": 0.9492,
+      "suggested_scalar": -0.0518,
+      "log_bad": 5.1761,
+      "log_good": 5.124
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0157,
+      "good": 0.0111,
+      "ratio": 0.707,
+      "suggested_scalar": -0.3441,
+      "log_bad": -4.1541,
+      "log_good": -4.5008
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2574,
+      "good": 0.2233,
+      "ratio": 0.8675,
+      "suggested_scalar": -0.141,
+      "log_bad": -1.3571,
+      "log_good": -1.4992
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 116.0,
+      "good": 157.0,
+      "ratio": 1.3534,
+      "suggested_scalar": 0.3004,
+      "log_bad": 4.7536,
+      "log_good": 5.0562
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 7.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.153,
+      "log_bad": 1.7918,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 84.0,
+      "good": 100.0,
+      "ratio": 1.1905,
+      "suggested_scalar": 0.173,
+      "log_bad": 4.4308,
+      "log_good": 4.6052
+    },
+    "brevity.mean_sample_size": {
+      "bad": 84.0,
+      "good": 100.0,
+      "ratio": 1.1905,
+      "suggested_scalar": 0.173,
+      "log_bad": 4.4308,
+      "log_good": 4.6052
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 509.0,
+      "good": 721.0,
+      "ratio": 1.4165,
+      "suggested_scalar": 0.3456,
+      "log_bad": 6.2324,
+      "log_good": 6.5806
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 291.0,
+      "good": 391.0,
+      "ratio": 1.3436,
+      "suggested_scalar": 0.2932,
+      "log_bad": 5.6733,
+      "log_good": 5.9687
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 208.0,
+      "good": 273.0,
+      "ratio": 1.3125,
+      "suggested_scalar": 0.2699,
+      "log_bad": 5.3375,
+      "log_good": 5.6095
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 3.4516,
+      "good": 4.5908,
+      "ratio": 1.33,
+      "suggested_scalar": 0.2831,
+      "log_bad": 1.2388,
+      "log_good": 1.5241
+    },
+    "halstead.mean_effort": {
+      "bad": 131220.8942,
+      "good": 214947.6493,
+      "ratio": 1.6381,
+      "suggested_scalar": 0.4898,
+      "log_bad": 11.7846,
+      "log_good": 12.2781
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8651,
+      "good": 0.8583,
+      "ratio": 0.9921,
+      "suggested_scalar": -0.0078,
+      "log_bad": -0.1449,
+      "log_good": -0.1528
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 52.0,
+      "good": 41.0,
+      "ratio": 0.7885,
+      "suggested_scalar": -0.2359,
+      "log_bad": 3.9512,
+      "log_good": 3.7136
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 276.0,
+      "good": 344.0,
+      "ratio": 1.2464,
+      "suggested_scalar": 0.2186,
+      "log_bad": 5.6204,
+      "log_good": 5.8406
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.2961,
+      "good": 0.2566,
+      "ratio": 0.8666,
+      "suggested_scalar": -0.1421,
+      "log_bad": -1.2171,
+      "log_good": -1.3602
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.9342,
+      "good": 5.5044,
+      "ratio": 0.9276,
+      "suggested_scalar": -0.0746,
+      "log_bad": 1.7807,
+      "log_good": 1.7055
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1509,
+      "good": 0.1154,
+      "ratio": 0.7647,
+      "suggested_scalar": -0.2662,
+      "log_bad": -1.8911,
+      "log_good": -2.1594
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.2205,
+      "good": 4.1797,
+      "ratio": 0.8006,
+      "suggested_scalar": -0.2207,
+      "log_bad": 1.6526,
+      "log_good": 1.4302
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 508.0,
+      "good": 720.0,
+      "ratio": 1.4173,
+      "suggested_scalar": 0.3461,
+      "log_bad": 6.2305,
+      "log_good": 6.5793
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 7.0,
+      "good": 8.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.1325,
+      "log_bad": 1.9459,
+      "log_good": 2.0794
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 113.0,
+      "good": 162.0,
+      "ratio": 1.4336,
+      "suggested_scalar": 0.3575,
+      "log_bad": 4.7274,
+      "log_good": 5.0876
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 7290.0497,
+      "good": 11941.5361,
+      "ratio": 1.6381,
+      "suggested_scalar": 0.4898,
+      "log_bad": 8.8943,
+      "log_good": 9.3878
+    },
+    "readability.mean_total_lines": {
+      "bad": 39.0,
+      "good": 69.0,
+      "ratio": 1.7692,
+      "suggested_scalar": 0.5663,
+      "log_bad": 3.6636,
+      "log_good": 4.2341
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2855.6127,
+      "good": 3179.2401,
+      "ratio": 1.1133,
+      "suggested_scalar": 0.1065,
+      "log_bad": 7.957,
+      "log_good": 8.0644
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 525.0,
+      "good": 701.0,
+      "ratio": 1.3352,
+      "suggested_scalar": 0.2869,
+      "log_bad": 6.2634,
+      "log_good": 6.5525
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 33.4872,
+      "good": 35.1159,
+      "ratio": 1.0486,
+      "suggested_scalar": 0.0471,
+      "log_bad": 3.5112,
+      "log_good": 3.5587
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1468,
+      "good": 1.0939,
+      "ratio": 0.9539,
+      "suggested_scalar": -0.0469,
+      "log_bad": 0.137,
+      "log_good": 0.0897
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 19.0,
+      "good": 35.0,
+      "ratio": 1.8421,
+      "suggested_scalar": 0.6063,
+      "log_bad": 2.9444,
+      "log_good": 3.5553
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 1.0,
+      "ratio": 0.1667,
+      "suggested_scalar": -1.7783,
+      "log_bad": 1.7918,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.5921,
+      "good": 0.5549,
+      "ratio": 0.9372,
+      "suggested_scalar": -0.0644,
+      "log_bad": -0.5241,
+      "log_good": -0.589
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 9.0,
+      "ratio": 4.5,
+      "suggested_scalar": 1.4928,
+      "log_bad": 0.6931,
+      "log_good": 2.1972
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9297,
+      "good": 0.9258,
+      "ratio": 0.9958,
+      "suggested_scalar": -0.0042,
+      "log_bad": -0.0729,
+      "log_good": -0.0771
+    },
+    "halstead.mean_length": {
+      "bad": 453.0,
+      "good": 512.0,
+      "ratio": 1.1302,
+      "suggested_scalar": 0.1215,
+      "log_bad": 6.1159,
+      "log_good": 6.2383
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.0,
+      "good": 8.7143,
+      "ratio": 1.2449,
+      "suggested_scalar": 0.2174,
+      "log_bad": 1.9459,
+      "log_good": 2.165
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.3923,
+      "good": 6.6439,
+      "ratio": 1.0394,
+      "suggested_scalar": 0.0383,
+      "log_bad": 1.8551,
+      "log_good": 1.8937
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.6879,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1658,
+      "good": 0.1563,
+      "ratio": 0.9427,
+      "suggested_scalar": -0.0586,
+      "log_bad": -1.797,
+      "log_good": -1.856
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 45.9519,
+      "good": 67.6098,
+      "ratio": 1.4713,
+      "suggested_scalar": 0.3833,
+      "log_bad": 3.8276,
+      "log_good": 4.2138
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 22.0,
+      "ratio": 3.1429,
+      "suggested_scalar": 1.1365,
+      "log_bad": 1.9459,
+      "log_good": 3.091
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 45.0,
+      "good": 58.0,
+      "ratio": 1.2889,
+      "suggested_scalar": 0.2519,
+      "log_bad": 3.8067,
+      "log_good": 4.0604
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.4423,
+      "good": 0.4249,
+      "ratio": 0.9607,
+      "suggested_scalar": -0.0398,
+      "log_bad": -0.8158,
+      "log_good": -0.8559
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 45.0,
+      "good": 69.0,
+      "ratio": 1.5333,
+      "suggested_scalar": 0.4242,
+      "log_bad": 3.8067,
+      "log_good": 4.2341
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_empty_string_initial": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 8.0,
+      "good": 16.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2212,
+      "log_bad": 2.0794,
+      "log_good": 2.7726
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0826,
+      "good": 0.0388,
+      "ratio": 0.4697,
+      "suggested_scalar": -0.2412,
+      "log_bad": -2.4937,
+      "log_good": -3.2493
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7714,
+      "good": 0.85,
+      "ratio": 1.1019,
+      "suggested_scalar": 0.031,
+      "log_bad": -0.2595,
+      "log_good": -0.1625
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0826,
+      "good": 0.0388,
+      "ratio": 0.4697,
+      "suggested_scalar": -0.2412,
+      "log_bad": -2.4937,
+      "log_good": -3.2493
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.2962,
+      "good": 4.6944,
+      "ratio": 1.0927,
+      "suggested_scalar": 0.0283,
+      "log_bad": 1.4577,
+      "log_good": 1.5464
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 74.0,
+      "good": 71.0,
+      "ratio": 0.9595,
+      "suggested_scalar": -0.0132,
+      "log_bad": 4.3041,
+      "log_good": 4.2627
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.59,
+      "good": 0.5895,
+      "ratio": 0.9992,
+      "suggested_scalar": -0.0003,
+      "log_bad": -0.5276,
+      "log_good": -0.5285
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 20.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0164,
+      "log_bad": 2.9444,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5764,
+      "good": 0.6082,
+      "ratio": 1.0552,
+      "suggested_scalar": 0.0171,
+      "log_bad": -0.551,
+      "log_good": -0.4973
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.8286,
+      "good": 3.6,
+      "ratio": 0.7456,
+      "suggested_scalar": -0.0937,
+      "log_bad": 1.5746,
+      "log_good": 1.2809
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 351.0,
+      "good": 335.0,
+      "ratio": 0.9544,
+      "suggested_scalar": -0.0149,
+      "log_bad": 5.8608,
+      "log_good": 5.8141
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1294,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0019,
+      "good": 1.0,
+      "ratio": 526.3158,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.2659,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0049,
+      "good": 0.9881,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0054,
+      "log_bad": 0.0049,
+      "log_good": -0.012
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 100.0,
+      "good": 95.0,
+      "ratio": 0.95,
+      "suggested_scalar": -0.0164,
+      "log_bad": 4.6052,
+      "log_good": 4.5539
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 111.2556,
+      "good": 105.0426,
+      "ratio": 0.9442,
+      "suggested_scalar": -0.0183,
+      "log_bad": 4.7118,
+      "log_good": 4.6544
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5371,
+      "good": 0.6018,
+      "ratio": 1.1205,
+      "suggested_scalar": 0.0363,
+      "log_bad": -0.6216,
+      "log_good": -0.5078
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.24,
+      "good": 9.0101,
+      "ratio": 0.9751,
+      "suggested_scalar": -0.008,
+      "log_bad": 2.2235,
+      "log_good": 2.1983
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1564.0,
+      "good": 1224.0,
+      "ratio": 0.7826,
+      "suggested_scalar": -0.0782,
+      "log_bad": 7.355,
+      "log_good": 7.1099
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2,
+      "good": 0.2,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.6094,
+      "log_good": -1.6094
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7286,
+      "good": 0.75,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.0092,
+      "log_bad": -0.3166,
+      "log_good": -0.2877
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.0143,
+      "good": 8.375,
+      "ratio": 1.6702,
+      "suggested_scalar": 0.1637,
+      "log_bad": 1.6123,
+      "log_good": 2.1253
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 8.0,
+      "good": 1.0,
+      "ratio": 0.125,
+      "suggested_scalar": -0.6637,
+      "log_bad": 2.0794,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 4.2849,
+      "good": 3.84,
+      "ratio": 0.8962,
+      "suggested_scalar": -0.035,
+      "log_bad": 1.4551,
+      "log_good": 1.3455
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 78.0,
+      "good": 77.0,
+      "ratio": 0.9872,
+      "suggested_scalar": -0.0041,
+      "log_bad": 4.3567,
+      "log_good": 4.3438
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9457,
+      "good": 0.9356,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.0034,
+      "log_bad": -0.0558,
+      "log_good": -0.0666
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 25.0,
+      "ratio": 1.087,
+      "suggested_scalar": 0.0266,
+      "log_bad": 3.1355,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6113,
+      "good": 0.5588,
+      "ratio": 0.9141,
+      "suggested_scalar": -0.0287,
+      "log_bad": -0.4922,
+      "log_good": -0.582
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2693,
+      "good": 0.4294,
+      "ratio": 1.5945,
+      "suggested_scalar": 0.1489,
+      "log_bad": -1.3119,
+      "log_good": -0.8454
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5724,
+      "good": 2.2667,
+      "ratio": 0.8812,
+      "suggested_scalar": -0.0404,
+      "log_bad": 0.9448,
+      "log_good": 0.8183
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 349.0,
+      "good": 333.0,
+      "ratio": 0.9542,
+      "suggested_scalar": -0.015,
+      "log_bad": 5.8551,
+      "log_good": 5.8081
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 26.0,
+      "good": 12.0,
+      "ratio": 0.4615,
+      "suggested_scalar": -0.2468,
+      "log_bad": 3.2581,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0057,
+      "good": 0.0388,
+      "ratio": 6.807,
+      "suggested_scalar": 0.6122,
+      "log_bad": -5.1673,
+      "log_good": -3.2493
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 5.9307,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7801,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 14.0,
+      "good": 18.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.0802,
+      "log_bad": 2.6391,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9682,
+      "good": 0.7004,
+      "ratio": 0.7234,
+      "suggested_scalar": -0.1033,
+      "log_bad": -0.0323,
+      "log_good": -0.3561
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.3657,
+      "good": 5.6437,
+      "ratio": 1.0518,
+      "suggested_scalar": 0.0161,
+      "log_bad": 1.68,
+      "log_good": 1.7305
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7244,
+      "good": 0.7915,
+      "ratio": 1.0926,
+      "suggested_scalar": 0.0283,
+      "log_bad": -0.3224,
+      "log_good": -0.2338
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2045,
+      "good": 0.1667,
+      "ratio": 0.8152,
+      "suggested_scalar": -0.0652,
+      "log_bad": -1.5872,
+      "log_good": -1.7916
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.0397,
+      "good": 3.0017,
+      "ratio": 0.9875,
+      "suggested_scalar": -0.004,
+      "log_bad": 1.1118,
+      "log_good": 1.0992
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 291.0,
+      "good": 246.0,
+      "ratio": 0.8454,
+      "suggested_scalar": -0.0536,
+      "log_bad": 5.6733,
+      "log_good": 5.5053
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5402,
+      "good": 0.5576,
+      "ratio": 1.0322,
+      "suggested_scalar": 0.0101,
+      "log_bad": -0.6158,
+      "log_good": -0.5841
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 92.0,
+      "good": 91.0,
+      "ratio": 0.9891,
+      "suggested_scalar": -0.0035,
+      "log_bad": 4.5218,
+      "log_good": 4.5109
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 660.0,
+      "good": 587.0,
+      "ratio": 0.8894,
+      "suggested_scalar": -0.0374,
+      "log_bad": 6.4922,
+      "log_good": 6.375
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 100.0,
+      "good": 87.0,
+      "ratio": 0.87,
+      "suggested_scalar": -0.0445,
+      "log_bad": 4.6052,
+      "log_good": 4.4659
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1681,
+      "good": 0.2657,
+      "ratio": 1.5806,
+      "suggested_scalar": 0.1461,
+      "log_bad": -1.7832,
+      "log_good": -1.3254
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 54.0,
+      "good": 64.0,
+      "ratio": 1.1852,
+      "suggested_scalar": 0.0542,
+      "log_bad": 3.989,
+      "log_good": 4.1589
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 7.0,
+      "ratio": 1.75,
+      "suggested_scalar": 0.1786,
+      "log_bad": 1.3863,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 92.0,
+      "good": 91.0,
+      "ratio": 0.9891,
+      "suggested_scalar": -0.0035,
+      "log_bad": 4.5218,
+      "log_good": 4.5109
+    },
+    "brevity.mean_sample_size": {
+      "bad": 92.0,
+      "good": 91.0,
+      "ratio": 0.9891,
+      "suggested_scalar": -0.0035,
+      "log_bad": 4.5218,
+      "log_good": 4.5109
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 351.0,
+      "good": 335.0,
+      "ratio": 0.9544,
+      "suggested_scalar": -0.0149,
+      "log_bad": 5.8608,
+      "log_good": 5.8141
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 192.0,
+      "good": 186.0,
+      "ratio": 0.9688,
+      "suggested_scalar": -0.0101,
+      "log_bad": 5.2575,
+      "log_good": 5.2257
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 216.0,
+      "good": 197.0,
+      "ratio": 0.912,
+      "suggested_scalar": -0.0294,
+      "log_bad": 5.3753,
+      "log_good": 5.2832
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 3.1579,
+      "good": 2.9535,
+      "ratio": 0.9353,
+      "suggested_scalar": -0.0214,
+      "log_bad": 1.1499,
+      "log_good": 1.083
+    },
+    "halstead.mean_effort": {
+      "bad": 36544.4594,
+      "good": 39545.5478,
+      "ratio": 1.0821,
+      "suggested_scalar": 0.0252,
+      "log_bad": 10.5063,
+      "log_good": 10.5852
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8225,
+      "good": 0.8672,
+      "ratio": 1.0543,
+      "suggested_scalar": 0.0169,
+      "log_bad": -0.1954,
+      "log_good": -0.1425
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 51.0,
+      "good": 46.0,
+      "ratio": 0.902,
+      "suggested_scalar": -0.0329,
+      "log_bad": 3.9318,
+      "log_good": 3.8286
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 161.0,
+      "good": 185.0,
+      "ratio": 1.1491,
+      "suggested_scalar": 0.0444,
+      "log_bad": 5.0814,
+      "log_good": 5.2204
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.59,
+      "good": 0.5895,
+      "ratio": 0.9992,
+      "suggested_scalar": -0.0003,
+      "log_bad": -0.5276,
+      "log_good": -0.5285
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.6,
+      "good": 6.1789,
+      "ratio": 0.9362,
+      "suggested_scalar": -0.021,
+      "log_bad": 1.8871,
+      "log_good": 1.8211
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2045,
+      "good": 0.1667,
+      "ratio": 0.8152,
+      "suggested_scalar": -0.0652,
+      "log_bad": -1.5872,
+      "log_good": -1.7916
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.0057,
+      "good": 3.35,
+      "ratio": 1.6702,
+      "suggested_scalar": 0.1637,
+      "log_bad": 0.696,
+      "log_good": 1.209
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 350.0,
+      "good": 334.0,
+      "ratio": 0.9543,
+      "suggested_scalar": -0.0149,
+      "log_bad": 5.8579,
+      "log_good": 5.8111
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 12.0,
+      "good": 9.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0918,
+      "log_bad": 2.4849,
+      "log_good": 2.1972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 36.0,
+      "good": 56.0,
+      "ratio": 1.5556,
+      "suggested_scalar": 0.141,
+      "log_bad": 3.5835,
+      "log_good": 4.0254
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2030.2477,
+      "good": 2196.9749,
+      "ratio": 1.0821,
+      "suggested_scalar": 0.0252,
+      "log_bad": 7.6159,
+      "log_good": 7.6948
+    },
+    "readability.mean_total_lines": {
+      "bad": 70.0,
+      "good": 40.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -0.1786,
+      "log_bad": 4.2485,
+      "log_good": 3.6889
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 1620.6673,
+      "good": 1672.7312,
+      "ratio": 1.0321,
+      "suggested_scalar": 0.0101,
+      "log_bad": 7.3906,
+      "log_good": 7.4222
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 608.0,
+      "good": 540.0,
+      "ratio": 0.8882,
+      "suggested_scalar": -0.0379,
+      "log_bad": 6.4102,
+      "log_good": 6.2916
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 21.0571,
+      "good": 29.35,
+      "ratio": 1.3938,
+      "suggested_scalar": 0.106,
+      "log_bad": 3.0472,
+      "log_good": 3.3793
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0696,
+      "good": 1.1027,
+      "ratio": 1.0309,
+      "suggested_scalar": 0.0097,
+      "log_bad": 0.0673,
+      "log_good": 0.0978
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1294,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 25.0,
+      "good": 27.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.0246,
+      "log_bad": 3.2189,
+      "log_good": 3.2958
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8763,
+      "good": 0.7724,
+      "ratio": 0.8814,
+      "suggested_scalar": -0.0403,
+      "log_bad": -0.132,
+      "log_good": -0.2583
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9787,
+      "good": 0.9682,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.0034,
+      "log_bad": -0.0215,
+      "log_good": -0.0323
+    },
+    "halstead.mean_length": {
+      "bad": 261.0,
+      "good": 272.0,
+      "ratio": 1.0421,
+      "suggested_scalar": 0.0132,
+      "log_bad": 5.5645,
+      "log_good": 5.6058
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 20.75,
+      "good": 6.1429,
+      "ratio": 0.296,
+      "suggested_scalar": -0.3885,
+      "log_bad": 3.0325,
+      "log_good": 1.8153
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5236,
+      "good": 6.5078,
+      "ratio": 0.9976,
+      "suggested_scalar": -0.0008,
+      "log_bad": 1.8754,
+      "log_good": 1.873
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1229,
+      "good": 0.1522,
+      "ratio": 1.2384,
+      "suggested_scalar": 0.0683,
+      "log_bad": -2.0964,
+      "log_good": -1.8826
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 22.549,
+      "good": 23.6413,
+      "ratio": 1.0484,
+      "suggested_scalar": 0.0151,
+      "log_bad": 3.1157,
+      "log_good": 3.163
+    },
+    "branching.mean_branch_count": {
+      "bad": 14.0,
+      "good": 8.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -0.1786,
+      "log_bad": 2.6391,
+      "log_good": 2.0794
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 59.0,
+      "good": 56.0,
+      "ratio": 0.9492,
+      "suggested_scalar": -0.0167,
+      "log_bad": 4.0775,
+      "log_good": 4.0254
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.75,
+      "good": 0.6751,
+      "ratio": 0.9001,
+      "suggested_scalar": -0.0336,
+      "log_bad": -0.2877,
+      "log_good": -0.3929
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 70.0,
+      "good": 40.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -0.1786,
+      "log_bad": 4.2485,
+      "log_good": 3.6889
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.hardcoded_url_or_path": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 20.0,
+      "good": 29.0,
+      "ratio": 1.45,
+      "suggested_scalar": 0.8771,
+      "log_bad": 2.9957,
+      "log_good": 3.3673
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.9571,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0354,
+      "good": 0.0351,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0201,
+      "log_bad": -3.341,
+      "log_good": -3.3496
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.5,
+      "ratio": 1.5,
+      "suggested_scalar": 0.9571,
+      "log_bad": 0.0,
+      "log_good": 0.4055
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7955,
+      "good": 0.8409,
+      "ratio": 1.0571,
+      "suggested_scalar": 0.131,
+      "log_bad": -0.2288,
+      "log_good": -0.1733
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0354,
+      "good": 0.0351,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0201,
+      "log_bad": -3.341,
+      "log_good": -3.3496
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.9184,
+      "good": 4.9581,
+      "ratio": 1.0081,
+      "suggested_scalar": 0.019,
+      "log_bad": 1.593,
+      "log_good": 1.601
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 60.0,
+      "good": 82.0,
+      "ratio": 1.3667,
+      "suggested_scalar": 0.7373,
+      "log_bad": 4.0943,
+      "log_good": 4.4067
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4778,
+      "good": 0.5567,
+      "ratio": 1.1651,
+      "suggested_scalar": 0.3608,
+      "log_bad": -0.7386,
+      "log_good": -0.5857
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5825,
+      "good": 0.594,
+      "ratio": 1.0197,
+      "suggested_scalar": 0.0461,
+      "log_bad": -0.5404,
+      "log_good": -0.5209
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.8636,
+      "good": 2.5455,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.2779,
+      "log_bad": 1.0521,
+      "log_good": 0.9343
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 396.0,
+      "good": 485.0,
+      "ratio": 1.2247,
+      "suggested_scalar": 0.4785,
+      "log_bad": 5.9814,
+      "log_good": 6.1841
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.9571,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0015,
+      "good": 0.0017,
+      "ratio": 1.1333,
+      "suggested_scalar": 0.2954,
+      "log_bad": -6.5023,
+      "log_good": -6.3771
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0015,
+      "good": 0.0011,
+      "ratio": 0.7333,
+      "suggested_scalar": -0.7321,
+      "log_bad": -6.5023,
+      "log_good": -6.8124
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0583,
+      "good": 1.059,
+      "ratio": 1.0007,
+      "suggested_scalar": 0.0016,
+      "log_bad": 0.0567,
+      "log_good": 0.0573
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 139.0,
+      "good": 151.0,
+      "ratio": 1.0863,
+      "suggested_scalar": 0.1955,
+      "log_bad": 4.9345,
+      "log_good": 5.0173
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 106.1656,
+      "good": 85.9955,
+      "ratio": 0.81,
+      "suggested_scalar": -0.4974,
+      "log_bad": 4.665,
+      "log_good": 4.4543
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6076,
+      "good": 0.626,
+      "ratio": 1.0303,
+      "suggested_scalar": 0.0704,
+      "log_bad": -0.4982,
+      "log_good": -0.4684
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.1732,
+      "good": 16.7325,
+      "ratio": 1.6448,
+      "suggested_scalar": 1.1745,
+      "log_bad": 2.3198,
+      "log_good": 2.8174
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1359.0,
+      "good": 1.8e3,
+      "ratio": 1.3245,
+      "suggested_scalar": 0.6634,
+      "log_bad": 7.2145,
+      "log_good": 7.4955
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7727,
+      "good": 0.8182,
+      "ratio": 1.0589,
+      "suggested_scalar": 0.1351,
+      "log_bad": -0.2579,
+      "log_good": -0.2006
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.0,
+      "good": 11.0227,
+      "ratio": 1.2247,
+      "suggested_scalar": 0.4785,
+      "log_bad": 2.1972,
+      "log_good": 2.4
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 7.0,
+      "good": 3.0,
+      "ratio": 0.4286,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.9459,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.345,
+      "good": 1.157,
+      "ratio": 0.8602,
+      "suggested_scalar": -0.3554,
+      "log_bad": 0.2964,
+      "log_good": 0.1458
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 120.0,
+      "good": 130.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.1889,
+      "log_bad": 4.7875,
+      "log_good": 4.8675
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9287,
+      "good": 0.9424,
+      "ratio": 1.0148,
+      "suggested_scalar": 0.0346,
+      "log_bad": -0.074,
+      "log_good": -0.0593
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 20.0,
+      "good": 23.0,
+      "ratio": 1.15,
+      "suggested_scalar": 0.3299,
+      "log_bad": 2.9957,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5865,
+      "good": 0.6183,
+      "ratio": 1.0542,
+      "suggested_scalar": 0.1246,
+      "log_bad": -0.5336,
+      "log_good": -0.4808
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4746,
+      "good": 0.4224,
+      "ratio": 0.89,
+      "suggested_scalar": -0.275,
+      "log_bad": -0.7453,
+      "log_good": -0.8618
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4181,
+      "good": 2.6201,
+      "ratio": 1.0835,
+      "suggested_scalar": 0.1894,
+      "log_bad": 0.883,
+      "log_good": 0.9632
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 394.0,
+      "good": 483.0,
+      "ratio": 1.2259,
+      "suggested_scalar": 0.4807,
+      "log_bad": 5.9764,
+      "log_good": 6.18
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0429,
+      "good": 0.0351,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.4737,
+      "log_bad": -3.1489,
+      "log_good": -3.3496
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0,
+      "good": 5.9773,
+      "ratio": 0.9962,
+      "suggested_scalar": -0.0089,
+      "log_bad": 1.7918,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 12.0,
+      "good": 18.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.9571,
+      "log_bad": 2.4849,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7053,
+      "good": 0.6641,
+      "ratio": 0.9416,
+      "suggested_scalar": -0.1421,
+      "log_bad": -0.3491,
+      "log_good": -0.4093
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4955,
+      "good": 5.6547,
+      "ratio": 1.029,
+      "suggested_scalar": 0.0674,
+      "log_bad": 1.7039,
+      "log_good": 1.7325
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8197,
+      "good": 0.8295,
+      "ratio": 1.012,
+      "suggested_scalar": 0.0281,
+      "log_bad": -0.1988,
+      "log_good": -0.1869
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1698,
+      "good": 0.2,
+      "ratio": 1.1779,
+      "suggested_scalar": 0.3864,
+      "log_bad": -1.7731,
+      "log_good": -1.6094
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1895,
+      "good": 4.0905,
+      "ratio": 1.2825,
+      "suggested_scalar": 0.5873,
+      "log_bad": 1.1599,
+      "log_good": 1.4087
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 257.0,
+      "good": 346.0,
+      "ratio": 1.3463,
+      "suggested_scalar": 0.7019,
+      "log_bad": 5.5491,
+      "log_good": 5.8464
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 6.0,
+      "good": 14.0,
+      "ratio": 2.3333,
+      "suggested_scalar": 2.0,
+      "log_bad": 1.7918,
+      "log_good": 2.6391
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5848,
+      "good": 0.8201,
+      "ratio": 1.4024,
+      "suggested_scalar": 0.7982,
+      "log_bad": -0.5365,
+      "log_good": -0.1983
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 98.0,
+      "good": 112.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.3152,
+      "log_bad": 4.585,
+      "log_good": 4.7185
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 739.0,
+      "good": 1076.0,
+      "ratio": 1.456,
+      "suggested_scalar": 0.8868,
+      "log_bad": 6.6053,
+      "log_good": 6.981
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 88.0,
+      "good": 121.0,
+      "ratio": 1.375,
+      "suggested_scalar": 0.7517,
+      "log_bad": 4.4773,
+      "log_good": 4.7958
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.3232,
+      "good": 0.3031,
+      "ratio": 0.9378,
+      "suggested_scalar": -0.1516,
+      "log_bad": -1.1295,
+      "log_good": -1.1937
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 59.0,
+      "good": 86.0,
+      "ratio": 1.4576,
+      "suggested_scalar": 0.8894,
+      "log_bad": 4.0775,
+      "log_good": 4.4543
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 10.0,
+      "good": 14.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.7942,
+      "log_bad": 2.3026,
+      "log_good": 2.6391
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 98.0,
+      "good": 112.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.3152,
+      "log_bad": 4.585,
+      "log_good": 4.7185
+    },
+    "brevity.mean_sample_size": {
+      "bad": 98.0,
+      "good": 112.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.3152,
+      "log_bad": 4.585,
+      "log_good": 4.7185
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 396.0,
+      "good": 485.0,
+      "ratio": 1.2247,
+      "suggested_scalar": 0.4785,
+      "log_bad": 5.9814,
+      "log_good": 6.1841
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 211.0,
+      "good": 277.0,
+      "ratio": 1.3128,
+      "suggested_scalar": 0.6424,
+      "log_bad": 5.3519,
+      "log_good": 5.624
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 214.0,
+      "good": 267.0,
+      "ratio": 1.2477,
+      "suggested_scalar": 0.5223,
+      "log_bad": 5.366,
+      "log_good": 5.5872
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0025,
+      "good": 0.0021,
+      "ratio": 0.84,
+      "suggested_scalar": -0.4116,
+      "log_bad": -5.9915,
+      "log_good": -6.1658
+    },
+    "heaps.mean_k": {
+      "bad": 3.1662,
+      "good": 2.9627,
+      "ratio": 0.9357,
+      "suggested_scalar": -0.1568,
+      "log_bad": 1.1525,
+      "log_good": 1.0861
+    },
+    "halstead.mean_effort": {
+      "bad": 38595.6232,
+      "good": 58027.2629,
+      "ratio": 1.5035,
+      "suggested_scalar": 0.9625,
+      "log_bad": 10.5609,
+      "log_good": 10.9687
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8308,
+      "good": 0.8307,
+      "ratio": 0.9999,
+      "suggested_scalar": -0.0003,
+      "log_bad": -0.1854,
+      "log_good": -0.1855
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 40.0,
+      "good": 59.0,
+      "ratio": 1.475,
+      "suggested_scalar": 0.9174,
+      "log_bad": 3.6889,
+      "log_good": 4.0775
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 209.0,
+      "good": 266.0,
+      "ratio": 1.2727,
+      "suggested_scalar": 0.5692,
+      "log_bad": 5.3423,
+      "log_good": 5.5835
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.482,
+      "good": 0.5166,
+      "ratio": 1.0718,
+      "suggested_scalar": 0.1636,
+      "log_bad": -0.7298,
+      "log_good": -0.6605
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.3165,
+      "good": 7.1258,
+      "ratio": 1.3403,
+      "suggested_scalar": 0.6914,
+      "log_bad": 1.6708,
+      "log_good": 1.9637
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1698,
+      "good": 0.2,
+      "ratio": 1.1779,
+      "suggested_scalar": 0.3864,
+      "log_bad": -1.7731,
+      "log_good": -1.6094
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.2557,
+      "good": 6.545,
+      "ratio": 1.5379,
+      "suggested_scalar": 1.016,
+      "log_bad": 1.4483,
+      "log_good": 1.8787
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 395.0,
+      "good": 484.0,
+      "ratio": 1.2253,
+      "suggested_scalar": 0.4796,
+      "log_bad": 5.9789,
+      "log_good": 6.1821
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 10.0,
+      "good": 16.0,
+      "ratio": 1.6,
+      "suggested_scalar": 1.1094,
+      "log_bad": 2.3026,
+      "log_good": 2.7726
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 50.0,
+      "good": 67.0,
+      "ratio": 1.34,
+      "suggested_scalar": 0.6908,
+      "log_bad": 3.912,
+      "log_good": 4.2047
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2144.2013,
+      "good": 3223.7368,
+      "ratio": 1.5035,
+      "suggested_scalar": 0.9625,
+      "log_bad": 7.6705,
+      "log_good": 8.0783
+    },
+    "readability.mean_total_lines": {
+      "bad": 44.0,
+      "good": 44.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7842,
+      "log_good": 3.7842
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1754.3465,
+      "good": 2460.3726,
+      "ratio": 1.4024,
+      "suggested_scalar": 0.7983,
+      "log_bad": 7.4699,
+      "log_good": 7.8081
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 562.0,
+      "good": 687.0,
+      "ratio": 1.2224,
+      "suggested_scalar": 0.4741,
+      "log_bad": 6.3315,
+      "log_good": 6.5323
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 29.6364,
+      "good": 39.6136,
+      "ratio": 1.3367,
+      "suggested_scalar": 0.6849,
+      "log_bad": 3.389,
+      "log_good": 3.6792
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.082,
+      "good": 1.2961,
+      "ratio": 1.1979,
+      "suggested_scalar": 0.4262,
+      "log_bad": 0.0788,
+      "log_good": 0.2594
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.9571,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 21.0,
+      "good": 22.0,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.1098,
+      "log_bad": 3.0445,
+      "log_good": 3.091
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8054,
+      "good": 0.8064,
+      "ratio": 1.0012,
+      "suggested_scalar": 0.0029,
+      "log_bad": -0.2164,
+      "log_good": -0.2152
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9779,
+      "good": 0.9788,
+      "ratio": 1.0009,
+      "suggested_scalar": 0.0022,
+      "log_bad": -0.0223,
+      "log_good": -0.0214
+    },
+    "halstead.mean_length": {
+      "bad": 297.0,
+      "good": 387.0,
+      "ratio": 1.303,
+      "suggested_scalar": 0.6248,
+      "log_bad": 5.6937,
+      "log_good": 5.9584
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.8,
+      "good": 3.2857,
+      "ratio": 0.6845,
+      "suggested_scalar": -0.8947,
+      "log_bad": 1.5686,
+      "log_good": 1.1896
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6147,
+      "good": 6.8074,
+      "ratio": 1.0291,
+      "suggested_scalar": 0.0678,
+      "log_bad": 1.8893,
+      "log_good": 1.918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1555,
+      "good": 0.1541,
+      "ratio": 0.991,
+      "suggested_scalar": -0.0213,
+      "log_bad": -1.8611,
+      "log_good": -1.8702
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 22.0,
+      "good": 23.5847,
+      "ratio": 1.072,
+      "suggested_scalar": 0.1642,
+      "log_bad": 3.091,
+      "log_good": 3.1606
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 67.0,
+      "good": 78.0,
+      "ratio": 1.1642,
+      "suggested_scalar": 0.3588,
+      "log_bad": 4.2047,
+      "log_good": 4.3567
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7243,
+      "good": 0.6779,
+      "ratio": 0.9359,
+      "suggested_scalar": -0.1563,
+      "log_bad": -0.3225,
+      "log_good": -0.3888
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 44.0,
+      "good": 44.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7842,
+      "log_good": 3.7842
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.does_not_hold_mutex_across_await": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0111,
+      "good": 0.0103,
+      "ratio": 0.9279,
+      "suggested_scalar": -0.0202,
+      "log_bad": -4.5008,
+      "log_good": -4.5756
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.2,
+      "good": 1.2,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1823,
+      "log_good": 0.1823
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8636,
+      "good": 0.8571,
+      "ratio": 0.9925,
+      "suggested_scalar": -0.002,
+      "log_bad": -0.1466,
+      "log_good": -0.1542
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0111,
+      "good": 0.0103,
+      "ratio": 0.9279,
+      "suggested_scalar": -0.0202,
+      "log_bad": -4.5008,
+      "log_good": -4.5756
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8032,
+      "good": 4.7419,
+      "ratio": 0.9872,
+      "suggested_scalar": -0.0035,
+      "log_bad": 1.5693,
+      "log_good": 1.5564
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 113.0,
+      "good": 104.0,
+      "ratio": 0.9204,
+      "suggested_scalar": -0.0224,
+      "log_bad": 4.7274,
+      "log_good": 4.6444
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5865,
+      "good": 0.5956,
+      "ratio": 1.0155,
+      "suggested_scalar": 0.0042,
+      "log_bad": -0.5336,
+      "log_good": -0.5182
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.0,
+      "good": 20.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0132,
+      "log_bad": 3.0445,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7669,
+      "good": 0.7754,
+      "ratio": 1.0111,
+      "suggested_scalar": 0.003,
+      "log_bad": -0.2654,
+      "log_good": -0.2544
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.9091,
+      "good": 5.4286,
+      "ratio": 1.1058,
+      "suggested_scalar": 0.0271,
+      "log_bad": 1.5911,
+      "log_good": 1.6917
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 452.0,
+      "good": 387.0,
+      "ratio": 0.8562,
+      "suggested_scalar": -0.0419,
+      "log_bad": 6.1137,
+      "log_good": 5.9584
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0012,
+      "good": 0.0007,
+      "ratio": 0.5833,
+      "suggested_scalar": -0.1453,
+      "log_bad": -6.7254,
+      "log_good": -7.2644
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2273,
+      "good": 0.1667,
+      "ratio": 0.7334,
+      "suggested_scalar": -0.0836,
+      "log_bad": -1.4815,
+      "log_good": -1.7916
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0006,
+      "good": 1.0,
+      "ratio": 1666.6667,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.4186,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9459,
+      "good": 0.9583,
+      "ratio": 1.0131,
+      "suggested_scalar": 0.0035,
+      "log_bad": -0.0556,
+      "log_good": -0.0426
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 145.0,
+      "good": 117.0,
+      "ratio": 0.8069,
+      "suggested_scalar": -0.0578,
+      "log_bad": 4.9767,
+      "log_good": 4.7622
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.5157,
+      "good": 106.8862,
+      "ratio": 1.0227,
+      "suggested_scalar": 0.006,
+      "log_bad": 4.6493,
+      "log_good": 4.6718
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5743,
+      "good": 0.5259,
+      "ratio": 0.9157,
+      "suggested_scalar": -0.0237,
+      "log_bad": -0.5546,
+      "log_good": -0.6426
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 6.3518,
+      "good": 6.0637,
+      "ratio": 0.9546,
+      "suggested_scalar": -0.0125,
+      "log_bad": 1.8487,
+      "log_good": 1.8023
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1682.0,
+      "good": 1419.0,
+      "ratio": 0.8436,
+      "suggested_scalar": -0.0458,
+      "log_bad": 7.4277,
+      "log_good": 7.2577
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.25,
+      "good": 0.0952,
+      "ratio": 0.3808,
+      "suggested_scalar": -0.2603,
+      "log_bad": -1.3863,
+      "log_good": -2.3518
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8182,
+      "good": 0.7857,
+      "ratio": 0.9603,
+      "suggested_scalar": -0.0109,
+      "log_bad": -0.2006,
+      "log_good": -0.2412
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.5116,
+      "good": 9.439,
+      "ratio": 0.898,
+      "suggested_scalar": -0.029,
+      "log_bad": 2.3525,
+      "log_good": 2.2449
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 10.0826,
+      "good": 14.3401,
+      "ratio": 1.4223,
+      "suggested_scalar": 0.095,
+      "log_bad": 2.3108,
+      "log_good": 2.6631
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 110.0,
+      "good": 85.0,
+      "ratio": 0.7727,
+      "suggested_scalar": -0.0695,
+      "log_bad": 4.7005,
+      "log_good": 4.4427
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.963,
+      "good": 0.9541,
+      "ratio": 0.9908,
+      "suggested_scalar": -0.0025,
+      "log_bad": -0.0377,
+      "log_good": -0.047
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 35.0,
+      "good": 30.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0416,
+      "log_bad": 3.5553,
+      "log_good": 3.4012
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.563,
+      "good": 0.5363,
+      "ratio": 0.9526,
+      "suggested_scalar": -0.0131,
+      "log_bad": -0.5745,
+      "log_good": -0.6231
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3622,
+      "good": 0.3065,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.045,
+      "log_bad": -1.0156,
+      "log_good": -1.1825
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.2884,
+      "good": 2.1565,
+      "ratio": 0.9424,
+      "suggested_scalar": -0.016,
+      "log_bad": 0.8279,
+      "log_good": 0.7685
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 450.0,
+      "good": 385.0,
+      "ratio": 0.8556,
+      "suggested_scalar": -0.0421,
+      "log_bad": 6.1092,
+      "log_good": 5.9532
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 15.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0602,
+      "log_bad": 2.4849,
+      "log_good": 2.7081
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0575,
+      "good": 0.0491,
+      "ratio": 0.8539,
+      "suggested_scalar": -0.0426,
+      "log_bad": -2.856,
+      "log_good": -3.0139
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0661,
+      "good": 6.1293,
+      "ratio": 1.0104,
+      "suggested_scalar": 0.0028,
+      "log_bad": 1.8027,
+      "log_good": 1.8131
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 34.0,
+      "good": 31.0,
+      "ratio": 0.9118,
+      "suggested_scalar": -0.0249,
+      "log_bad": 3.5264,
+      "log_good": 3.434
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8425,
+      "good": 0.9013,
+      "ratio": 1.0698,
+      "suggested_scalar": 0.0182,
+      "log_bad": -0.1714,
+      "log_good": -0.1039
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9533,
+      "good": 5.8198,
+      "ratio": 0.9776,
+      "suggested_scalar": -0.0061,
+      "log_bad": 1.7839,
+      "log_good": 1.7613
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7918,
+      "good": 0.7737,
+      "ratio": 0.9771,
+      "suggested_scalar": -0.0062,
+      "log_bad": -0.2334,
+      "log_good": -0.2566
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1538,
+      "good": 0.16,
+      "ratio": 1.0403,
+      "suggested_scalar": 0.0107,
+      "log_bad": -1.8721,
+      "log_good": -1.8326
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.5203,
+      "good": 2.4625,
+      "ratio": 0.9771,
+      "suggested_scalar": -0.0063,
+      "log_bad": 0.9244,
+      "log_good": 0.9012
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 352.0,
+      "good": 316.0,
+      "ratio": 0.8977,
+      "suggested_scalar": -0.0291,
+      "log_bad": 5.8636,
+      "log_good": 5.7557
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 16.0,
+      "good": 14.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.036,
+      "log_bad": 2.7726,
+      "log_good": 2.6391
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.973,
+      "good": 0.8108,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0492,
+      "log_bad": -0.0274,
+      "log_good": -0.2097
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 118.0,
+      "good": 107.0,
+      "ratio": 0.9068,
+      "suggested_scalar": -0.0264,
+      "log_bad": 4.7707,
+      "log_good": 4.6728
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 742.0,
+      "good": 577.0,
+      "ratio": 0.7776,
+      "suggested_scalar": -0.0678,
+      "log_bad": 6.6093,
+      "log_good": 6.3578
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 162.0,
+      "good": 138.0,
+      "ratio": 0.8519,
+      "suggested_scalar": -0.0432,
+      "log_bad": 5.0876,
+      "log_good": 4.9273
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0066,
+      "good": 0.0155,
+      "ratio": 2.3485,
+      "suggested_scalar": 0.2302,
+      "log_bad": -5.0207,
+      "log_good": -4.1669
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2235,
+      "good": 0.2326,
+      "ratio": 1.0407,
+      "suggested_scalar": 0.0108,
+      "log_bad": -1.4983,
+      "log_good": -1.4584
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 87.0,
+      "good": 71.0,
+      "ratio": 0.8161,
+      "suggested_scalar": -0.0548,
+      "log_bad": 4.4659,
+      "log_good": 4.2627
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 118.0,
+      "good": 107.0,
+      "ratio": 0.9068,
+      "suggested_scalar": -0.0264,
+      "log_bad": 4.7707,
+      "log_good": 4.6728
+    },
+    "brevity.mean_sample_size": {
+      "bad": 118.0,
+      "good": 107.0,
+      "ratio": 0.9068,
+      "suggested_scalar": -0.0264,
+      "log_bad": 4.7707,
+      "log_good": 4.6728
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 452.0,
+      "good": 387.0,
+      "ratio": 0.8562,
+      "suggested_scalar": -0.0419,
+      "log_bad": 6.1137,
+      "log_good": 5.9584
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 234.0,
+      "good": 210.0,
+      "ratio": 0.8974,
+      "suggested_scalar": -0.0292,
+      "log_bad": 5.4553,
+      "log_good": 5.3471
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 279.0,
+      "good": 254.0,
+      "ratio": 0.9104,
+      "suggested_scalar": -0.0253,
+      "log_bad": 5.6312,
+      "log_good": 5.5373
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0022,
+      "good": 1.0,
+      "ratio": 454.5455,
+      "suggested_scalar": 1.6497,
+      "log_bad": -6.1193,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.2433,
+      "good": 1.1658,
+      "ratio": 0.9377,
+      "suggested_scalar": -0.0174,
+      "log_bad": 0.2178,
+      "log_good": 0.1534
+    },
+    "halstead.mean_effort": {
+      "bad": 106095.7532,
+      "good": 68037.5325,
+      "ratio": 0.6413,
+      "suggested_scalar": -0.1198,
+      "log_bad": 11.5721,
+      "log_good": 11.1278
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.865,
+      "good": 0.8633,
+      "ratio": 0.998,
+      "suggested_scalar": -0.0005,
+      "log_bad": -0.145,
+      "log_good": -0.147
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 78.0,
+      "good": 74.0,
+      "ratio": 0.9487,
+      "suggested_scalar": -0.0142,
+      "log_bad": 4.3567,
+      "log_good": 4.3041
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 266.0,
+      "good": 225.0,
+      "ratio": 0.8459,
+      "suggested_scalar": -0.0451,
+      "log_bad": 5.5835,
+      "log_good": 5.4161
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4897,
+      "good": 0.5556,
+      "ratio": 1.1346,
+      "suggested_scalar": 0.034,
+      "log_bad": -0.714,
+      "log_good": -0.5877
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.1172,
+      "good": 4.9316,
+      "ratio": 0.9637,
+      "suggested_scalar": -0.01,
+      "log_bad": 1.6326,
+      "log_good": 1.5957
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1538,
+      "good": 0.16,
+      "ratio": 1.0403,
+      "suggested_scalar": 0.0107,
+      "log_bad": -1.8721,
+      "log_good": -1.8326
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.575,
+      "good": 3.7756,
+      "ratio": 0.8253,
+      "suggested_scalar": -0.0518,
+      "log_bad": 1.5206,
+      "log_good": 1.3286
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 451.0,
+      "good": 386.0,
+      "ratio": 0.8559,
+      "suggested_scalar": -0.042,
+      "log_bad": 6.1115,
+      "log_good": 5.9558
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0602,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 65.0,
+      "good": 49.0,
+      "ratio": 0.7538,
+      "suggested_scalar": -0.0762,
+      "log_bad": 4.1744,
+      "log_good": 3.8918
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5894.2085,
+      "good": 3779.8629,
+      "ratio": 0.6413,
+      "suggested_scalar": -0.1198,
+      "log_bad": 8.6817,
+      "log_good": 8.2374
+    },
+    "readability.mean_total_lines": {
+      "bad": 43.0,
+      "good": 41.0,
+      "ratio": 0.9535,
+      "suggested_scalar": -0.0128,
+      "log_bad": 3.7612,
+      "log_good": 3.7136
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2919.0366,
+      "good": 2432.2596,
+      "ratio": 0.8332,
+      "suggested_scalar": -0.0492,
+      "log_bad": 7.979,
+      "log_good": 7.7966
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 735.0,
+      "good": 658.0,
+      "ratio": 0.8952,
+      "suggested_scalar": -0.0298,
+      "log_bad": 6.5999,
+      "log_good": 6.4892
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 37.2326,
+      "good": 32.7317,
+      "ratio": 0.8791,
+      "suggested_scalar": -0.0347,
+      "log_bad": 3.6172,
+      "log_good": 3.4883
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0833,
+      "good": 1.0682,
+      "ratio": 0.9861,
+      "suggested_scalar": -0.0038,
+      "log_bad": 0.08,
+      "log_good": 0.066
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 22.0,
+      "good": 25.0,
+      "ratio": 1.1364,
+      "suggested_scalar": 0.0345,
+      "log_bad": 3.091,
+      "log_good": 3.2189
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 10.0,
+      "good": 7.0,
+      "ratio": 0.7,
+      "suggested_scalar": -0.0962,
+      "log_bad": 2.3026,
+      "log_good": 1.9459
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8153,
+      "good": 0.8449,
+      "ratio": 1.0363,
+      "suggested_scalar": 0.0096,
+      "log_bad": -0.2042,
+      "log_good": -0.1685
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9828,
+      "good": 0.9809,
+      "ratio": 0.9981,
+      "suggested_scalar": -0.0005,
+      "log_bad": -0.0173,
+      "log_good": -0.0193
+    },
+    "halstead.mean_length": {
+      "bad": 428.0,
+      "good": 363.0,
+      "ratio": 0.8481,
+      "suggested_scalar": -0.0444,
+      "log_bad": 6.0591,
+      "log_good": 5.8944
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.6,
+      "good": 7.2,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.0146,
+      "log_bad": 2.0281,
+      "log_good": 1.9741
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8826,
+      "good": 6.7415,
+      "ratio": 0.9795,
+      "suggested_scalar": -0.0056,
+      "log_bad": 1.929,
+      "log_good": 1.9083
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1396,
+      "good": 0.1484,
+      "ratio": 1.063,
+      "suggested_scalar": 0.0165,
+      "log_bad": -1.969,
+      "log_good": -1.9078
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 36.3462,
+      "good": 27.973,
+      "ratio": 0.7696,
+      "suggested_scalar": -0.0706,
+      "log_bad": 3.5931,
+      "log_good": 3.3312
+    },
+    "branching.mean_branch_count": {
+      "bad": 11.0,
+      "good": 4.0,
+      "ratio": 0.3636,
+      "suggested_scalar": -0.2727,
+      "log_bad": 2.3979,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 71.0,
+      "good": 65.0,
+      "ratio": 0.9155,
+      "suggested_scalar": -0.0238,
+      "log_bad": 4.2627,
+      "log_good": 4.1744
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6882,
+      "good": 0.7205,
+      "ratio": 1.0469,
+      "suggested_scalar": 0.0124,
+      "log_bad": -0.3737,
+      "log_good": -0.3278
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 44.0,
+      "good": 42.0,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.0125,
+      "log_bad": 3.7842,
+      "log_good": 3.7377
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.1869,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 12.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0776,
+      "log_bad": 2.7726,
+      "log_good": 2.4849
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.function_name_matches_return_type": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 20.0,
+      "good": 22.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0314,
+      "log_bad": 2.9957,
+      "log_good": 3.091
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0123,
+      "good": 0.0122,
+      "ratio": 0.9919,
+      "suggested_scalar": -0.0027,
+      "log_bad": -4.3982,
+      "log_good": -4.4063
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3,
+      "good": 1.3,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2624,
+      "log_good": 0.2624
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8205,
+      "good": 0.7949,
+      "ratio": 0.9688,
+      "suggested_scalar": -0.0104,
+      "log_bad": -0.1978,
+      "log_good": -0.2295
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0123,
+      "good": 0.0122,
+      "ratio": 0.9919,
+      "suggested_scalar": -0.0027,
+      "log_bad": -4.3982,
+      "log_good": -4.4063
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5005,
+      "good": 4.6096,
+      "ratio": 1.0242,
+      "suggested_scalar": 0.0079,
+      "log_bad": 1.5042,
+      "log_good": 1.5281
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 73.0,
+      "good": 78.0,
+      "ratio": 1.0685,
+      "suggested_scalar": 0.0218,
+      "log_bad": 4.2905,
+      "log_good": 4.3567
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4086,
+      "good": 0.4379,
+      "ratio": 1.0717,
+      "suggested_scalar": 0.0228,
+      "log_bad": -0.895,
+      "log_good": -0.8258
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 14.0,
+      "good": 17.0,
+      "ratio": 1.2143,
+      "suggested_scalar": 0.0639,
+      "log_bad": 2.6391,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5438,
+      "good": 0.5941,
+      "ratio": 1.0925,
+      "suggested_scalar": 0.0291,
+      "log_bad": -0.6092,
+      "log_good": -0.5207
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.6667,
+      "good": 2.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9808,
+      "log_good": 0.9808
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 325.0,
+      "good": 328.0,
+      "ratio": 1.0092,
+      "suggested_scalar": 0.003,
+      "log_bad": 5.7838,
+      "log_good": 5.793
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1335,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1795,
+      "good": 0.1795,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.7176,
+      "log_good": -1.7176
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 0.0023,
+      "ratio": 0.0023,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.0748
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0463,
+      "good": 1.0316,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0047,
+      "log_bad": 0.0453,
+      "log_good": 0.0311
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 128.0,
+      "good": 113.0,
+      "ratio": 0.8828,
+      "suggested_scalar": -0.041,
+      "log_bad": 4.852,
+      "log_good": 4.7274
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 90.9016,
+      "good": 87.9843,
+      "ratio": 0.9679,
+      "suggested_scalar": -0.0107,
+      "log_bad": 4.5098,
+      "log_good": 4.4772
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6852,
+      "good": 0.6514,
+      "ratio": 0.9507,
+      "suggested_scalar": -0.0167,
+      "log_bad": -0.378,
+      "log_good": -0.4286
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 12.3486,
+      "good": 12.9713,
+      "ratio": 1.0504,
+      "suggested_scalar": 0.0162,
+      "log_bad": 2.5135,
+      "log_good": 2.5627
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1356.0,
+      "good": 1280.0,
+      "ratio": 0.944,
+      "suggested_scalar": -0.019,
+      "log_bad": 7.2123,
+      "log_good": 7.1546
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7949,
+      "good": 0.7692,
+      "ratio": 0.9677,
+      "suggested_scalar": -0.0108,
+      "log_bad": -0.2295,
+      "log_good": -0.2624
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.1563,
+      "good": 10.25,
+      "ratio": 1.0092,
+      "suggested_scalar": 0.003,
+      "log_bad": 2.3181,
+      "log_good": 2.3273
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 9.0,
+      "good": 10.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0347,
+      "log_bad": 2.1972,
+      "log_good": 2.3026
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.7094,
+      "good": 1.7094,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.5361,
+      "log_good": 0.5361
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 115.0,
+      "good": 99.0,
+      "ratio": 0.8609,
+      "suggested_scalar": -0.0493,
+      "log_bad": 4.7449,
+      "log_good": 4.5951
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9141,
+      "good": 0.9438,
+      "ratio": 1.0325,
+      "suggested_scalar": 0.0105,
+      "log_bad": -0.0898,
+      "log_good": -0.0578
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 19.0,
+      "good": 23.0,
+      "ratio": 1.2105,
+      "suggested_scalar": 0.0629,
+      "log_bad": 2.9444,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6667,
+      "good": 0.6312,
+      "ratio": 0.9468,
+      "suggested_scalar": -0.018,
+      "log_bad": -0.4054,
+      "log_good": -0.4601
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4985,
+      "good": 0.4356,
+      "ratio": 0.8738,
+      "suggested_scalar": -0.0444,
+      "log_bad": -0.6962,
+      "log_good": -0.831
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0,
+      "good": 2.7119,
+      "ratio": 0.904,
+      "suggested_scalar": -0.0332,
+      "log_bad": 1.0986,
+      "log_good": 0.9976
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 323.0,
+      "good": 326.0,
+      "ratio": 1.0093,
+      "suggested_scalar": 0.003,
+      "log_bad": 5.7777,
+      "log_good": 5.7869
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0615,
+      "good": 0.061,
+      "ratio": 0.9919,
+      "suggested_scalar": -0.0027,
+      "log_bad": -2.7887,
+      "log_good": -2.7969
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.5236,
+      "good": 5.6439,
+      "ratio": 1.0218,
+      "suggested_scalar": 0.0071,
+      "log_bad": 1.709,
+      "log_good": 1.7306
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.5644,
+      "good": 0.6474,
+      "ratio": 1.1471,
+      "suggested_scalar": 0.0452,
+      "log_bad": -0.572,
+      "log_good": -0.4348
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.3855,
+      "good": 5.4085,
+      "ratio": 1.0043,
+      "suggested_scalar": 0.0014,
+      "log_bad": 1.6837,
+      "log_good": 1.688
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8148,
+      "good": 0.8167,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0008,
+      "log_bad": -0.2048,
+      "log_good": -0.2025
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1522,
+      "good": 0.1522,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.8826,
+      "log_good": -1.8826
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.5141,
+      "good": 3.6016,
+      "ratio": 1.0249,
+      "suggested_scalar": 0.0081,
+      "log_bad": 1.2568,
+      "log_good": 1.2814
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 220.0,
+      "good": 237.0,
+      "ratio": 1.0773,
+      "suggested_scalar": 0.0245,
+      "log_bad": 5.3936,
+      "log_good": 5.4681
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6293,
+      "good": 0.639,
+      "ratio": 1.0154,
+      "suggested_scalar": 0.005,
+      "log_bad": -0.4631,
+      "log_good": -0.4479
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 74.0,
+      "good": 80.0,
+      "ratio": 1.0811,
+      "suggested_scalar": 0.0257,
+      "log_bad": 4.3041,
+      "log_good": 4.382
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 775.0,
+      "good": 727.0,
+      "ratio": 0.9381,
+      "suggested_scalar": -0.021,
+      "log_bad": 6.6529,
+      "log_good": 6.5889
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 139.0,
+      "good": 118.0,
+      "ratio": 0.8489,
+      "suggested_scalar": -0.0539,
+      "log_bad": 4.9345,
+      "log_good": 4.7707
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2615,
+      "good": 0.2835,
+      "ratio": 1.0841,
+      "suggested_scalar": 0.0266,
+      "log_bad": -1.3413,
+      "log_good": -1.2605
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 68.0,
+      "good": 70.0,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.0095,
+      "log_bad": 4.2195,
+      "log_good": 4.2485
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 74.0,
+      "good": 80.0,
+      "ratio": 1.0811,
+      "suggested_scalar": 0.0257,
+      "log_bad": 4.3041,
+      "log_good": 4.382
+    },
+    "brevity.mean_sample_size": {
+      "bad": 74.0,
+      "good": 80.0,
+      "ratio": 1.0811,
+      "suggested_scalar": 0.0257,
+      "log_bad": 4.3041,
+      "log_good": 4.382
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 325.0,
+      "good": 328.0,
+      "ratio": 1.0092,
+      "suggested_scalar": 0.003,
+      "log_bad": 5.7838,
+      "log_good": 5.793
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 153.0,
+      "good": 175.0,
+      "ratio": 1.1438,
+      "suggested_scalar": 0.0442,
+      "log_bad": 5.0304,
+      "log_good": 5.1648
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 170.0,
+      "good": 184.0,
+      "ratio": 1.0824,
+      "suggested_scalar": 0.0261,
+      "log_bad": 5.1358,
+      "log_good": 5.2149
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0031,
+      "good": 0.003,
+      "ratio": 0.9677,
+      "suggested_scalar": -0.0108,
+      "log_bad": -5.7764,
+      "log_good": -5.8091
+    },
+    "heaps.mean_k": {
+      "bad": 3.266,
+      "good": 2.7898,
+      "ratio": 0.8542,
+      "suggested_scalar": -0.0519,
+      "log_bad": 1.1836,
+      "log_good": 1.026
+    },
+    "halstead.mean_effort": {
+      "bad": 46166.0614,
+      "good": 47298.7945,
+      "ratio": 1.0245,
+      "suggested_scalar": 0.008,
+      "log_bad": 10.74,
+      "log_good": 10.7642
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8673,
+      "good": 0.8555,
+      "ratio": 0.9864,
+      "suggested_scalar": -0.0045,
+      "log_bad": -0.1424,
+      "log_good": -0.1561
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 54.0,
+      "good": 55.0,
+      "ratio": 1.0185,
+      "suggested_scalar": 0.006,
+      "log_bad": 3.989,
+      "log_good": 4.0073
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 166.0,
+      "good": 187.0,
+      "ratio": 1.1265,
+      "suggested_scalar": 0.0392,
+      "log_bad": 5.112,
+      "log_good": 5.2311
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.375,
+      "good": 0.4336,
+      "ratio": 1.1563,
+      "suggested_scalar": 0.0478,
+      "log_bad": -0.9808,
+      "log_good": -0.8356
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0547,
+      "good": 6.4336,
+      "ratio": 1.0626,
+      "suggested_scalar": 0.02,
+      "log_bad": 1.8008,
+      "log_good": 1.8615
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1522,
+      "good": 0.1522,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.8826,
+      "log_good": -1.8826
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.6661,
+      "good": 6.7846,
+      "ratio": 1.0178,
+      "suggested_scalar": 0.0058,
+      "log_bad": 1.897,
+      "log_good": 1.9147
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 324.0,
+      "good": 327.0,
+      "ratio": 1.0093,
+      "suggested_scalar": 0.003,
+      "log_bad": 5.7807,
+      "log_good": 5.79
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 8.0,
+      "good": 11.0,
+      "ratio": 1.375,
+      "suggested_scalar": 0.1048,
+      "log_bad": 2.0794,
+      "log_good": 2.3979
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 58.0,
+      "good": 53.0,
+      "ratio": 0.9138,
+      "suggested_scalar": -0.0297,
+      "log_bad": 4.0604,
+      "log_good": 3.9703
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2564.7812,
+      "good": 2627.7108,
+      "ratio": 1.0245,
+      "suggested_scalar": 0.008,
+      "log_bad": 7.8496,
+      "log_good": 7.8739
+    },
+    "readability.mean_total_lines": {
+      "bad": 32.0,
+      "good": 32.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4657,
+      "log_good": 3.4657
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 1887.8965,
+      "good": 1917.0477,
+      "ratio": 1.0154,
+      "suggested_scalar": 0.005,
+      "log_bad": 7.5432,
+      "log_good": 7.5585
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 452.0,
+      "good": 472.0,
+      "ratio": 1.0442,
+      "suggested_scalar": 0.0143,
+      "log_bad": 6.1137,
+      "log_good": 6.157
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.375,
+      "good": 32.0313,
+      "ratio": 1.0545,
+      "suggested_scalar": 0.0175,
+      "log_bad": 3.4136,
+      "log_good": 3.4667
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2485,
+      "good": 1.2819,
+      "ratio": 1.0268,
+      "suggested_scalar": 0.0087,
+      "log_bad": 0.2219,
+      "log_good": 0.2483
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1335,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1335,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7364,
+      "good": 0.7764,
+      "ratio": 1.0543,
+      "suggested_scalar": 0.0174,
+      "log_bad": -0.306,
+      "log_good": -0.2531
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9762,
+      "good": 0.9875,
+      "ratio": 1.0116,
+      "suggested_scalar": 0.0038,
+      "log_bad": -0.0241,
+      "log_good": -0.0126
+    },
+    "halstead.mean_length": {
+      "bad": 305.0,
+      "good": 305.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.7203,
+      "log_good": 5.7203
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.4,
+      "good": 4.4,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.4816,
+      "log_good": 1.4816
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2095,
+      "good": 6.3219,
+      "ratio": 1.0181,
+      "suggested_scalar": 0.0059,
+      "log_bad": 1.8261,
+      "log_good": 1.844
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1128,
+      "good": 0.1367,
+      "ratio": 1.2119,
+      "suggested_scalar": 0.0633,
+      "log_bad": -2.1821,
+      "log_good": -1.99
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 24.4537,
+      "good": 24.6727,
+      "ratio": 1.009,
+      "suggested_scalar": 0.0029,
+      "log_bad": 3.1968,
+      "log_good": 3.2057
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 48.0,
+      "good": 49.0,
+      "ratio": 1.0208,
+      "suggested_scalar": 0.0068,
+      "log_bad": 3.8712,
+      "log_good": 3.8918
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6,
+      "good": 0.6196,
+      "ratio": 1.0327,
+      "suggested_scalar": 0.0106,
+      "log_bad": -0.5108,
+      "log_good": -0.4787
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 39.0,
+      "good": 39.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6636,
+      "log_good": 3.6636
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 25.0,
+      "ratio": 1.3889,
+      "suggested_scalar": 0.1082,
+      "log_bad": 2.8904,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.uses_caps_words_for_classes": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.6667,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 46.0,
+      "good": 42.0,
+      "ratio": 0.913,
+      "suggested_scalar": -0.0875,
+      "log_bad": 3.8286,
+      "log_good": 3.7377
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0244,
+      "good": 0.0514,
+      "ratio": 2.1066,
+      "suggested_scalar": 0.7166,
+      "log_bad": -3.7132,
+      "log_good": -2.9681
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.2857,
+      "good": 1.2857,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2513,
+      "log_good": 0.2513
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9804,
+      "good": 0.9818,
+      "ratio": 1.0014,
+      "suggested_scalar": 0.0014,
+      "log_bad": -0.0198,
+      "log_good": -0.0184
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0244,
+      "good": 0.0514,
+      "ratio": 2.1066,
+      "suggested_scalar": 0.7166,
+      "log_bad": -3.7132,
+      "log_good": -2.9681
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4741,
+      "good": 4.506,
+      "ratio": 1.0071,
+      "suggested_scalar": 0.0068,
+      "log_bad": 1.4983,
+      "log_good": 1.5054
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 101.0,
+      "good": 91.0,
+      "ratio": 0.901,
+      "suggested_scalar": -0.1003,
+      "log_bad": 4.6151,
+      "log_good": 4.5109
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5409,
+      "good": 0.5161,
+      "ratio": 0.9542,
+      "suggested_scalar": -0.0451,
+      "log_bad": -0.6145,
+      "log_good": -0.6615
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 15.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.1204,
+      "log_bad": 2.8332,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6937,
+      "good": 0.6798,
+      "ratio": 0.98,
+      "suggested_scalar": -0.0195,
+      "log_bad": -0.3657,
+      "log_good": -0.386
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.8431,
+      "good": 3.8545,
+      "ratio": 1.003,
+      "suggested_scalar": 0.0028,
+      "log_bad": 1.3463,
+      "log_good": 1.3492
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 409.0,
+      "good": 428.0,
+      "ratio": 1.0465,
+      "suggested_scalar": 0.0437,
+      "log_bad": 6.0137,
+      "log_good": 6.0591
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9512,
+      "good": 0.9883,
+      "ratio": 1.039,
+      "suggested_scalar": 0.0368,
+      "log_bad": -0.05,
+      "log_good": -0.0118
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 153.0,
+      "good": 155.0,
+      "ratio": 1.0131,
+      "suggested_scalar": 0.0125,
+      "log_bad": 5.0304,
+      "log_good": 5.0434
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 92.1618,
+      "good": 95.1092,
+      "ratio": 1.032,
+      "suggested_scalar": 0.0303,
+      "log_bad": 4.5235,
+      "log_good": 4.555
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.473,
+      "good": 0.4614,
+      "ratio": 0.9755,
+      "suggested_scalar": -0.0239,
+      "log_bad": -0.7487,
+      "log_good": -0.7735
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.1525,
+      "good": 12.9225,
+      "ratio": 0.9825,
+      "suggested_scalar": -0.017,
+      "log_bad": 2.5766,
+      "log_good": 2.559
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2123.0,
+      "good": 2073.0,
+      "ratio": 0.9764,
+      "suggested_scalar": -0.0229,
+      "log_bad": 7.6606,
+      "log_good": 7.6368
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1373,
+      "good": 0.1818,
+      "ratio": 1.3241,
+      "suggested_scalar": 0.27,
+      "log_bad": -1.9856,
+      "log_good": -1.7048
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9804,
+      "good": 0.9818,
+      "ratio": 1.0014,
+      "suggested_scalar": 0.0014,
+      "log_bad": -0.0198,
+      "log_good": -0.0184
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.0196,
+      "good": 7.7818,
+      "ratio": 0.9703,
+      "suggested_scalar": -0.029,
+      "log_bad": 2.0819,
+      "log_good": 2.0518
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 8.7597,
+      "good": 8.1243,
+      "ratio": 0.9275,
+      "suggested_scalar": -0.0724,
+      "log_bad": 2.1702,
+      "log_good": 2.0949
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 131.0,
+      "good": 123.0,
+      "ratio": 0.9389,
+      "suggested_scalar": -0.0606,
+      "log_bad": 4.8752,
+      "log_good": 4.8122
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9458,
+      "good": 0.9582,
+      "ratio": 1.0131,
+      "suggested_scalar": 0.0125,
+      "log_bad": -0.0557,
+      "log_good": -0.0427
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 29.0,
+      "ratio": 1.0357,
+      "suggested_scalar": 0.0338,
+      "log_bad": 3.3322,
+      "log_good": 3.3673
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6302,
+      "good": 0.6276,
+      "ratio": 0.9959,
+      "suggested_scalar": -0.004,
+      "log_bad": -0.4617,
+      "log_good": -0.4659
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2752,
+      "good": 0.2746,
+      "ratio": 0.9978,
+      "suggested_scalar": -0.0021,
+      "log_bad": -1.2903,
+      "log_good": -1.2924
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7045,
+      "good": 2.6852,
+      "ratio": 0.9929,
+      "suggested_scalar": -0.0069,
+      "log_bad": 0.9949,
+      "log_good": 0.9878
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 407.0,
+      "good": 426.0,
+      "ratio": 1.0467,
+      "suggested_scalar": 0.0439,
+      "log_bad": 6.0088,
+      "log_good": 6.0544
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 17.0,
+      "good": 18.0,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.055,
+      "log_bad": 2.8332,
+      "log_good": 2.8904
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.066,
+      "good": 0.0631,
+      "ratio": 0.9561,
+      "suggested_scalar": -0.0432,
+      "log_bad": -2.7181,
+      "log_good": -2.763
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.8074,
+      "ratio": 0.9832,
+      "suggested_scalar": -0.0163,
+      "log_bad": 1.7761,
+      "log_good": 1.7591
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 13.0,
+      "good": 25.0,
+      "ratio": 1.9231,
+      "suggested_scalar": 0.6289,
+      "log_bad": 2.5649,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7794,
+      "good": 0.8911,
+      "ratio": 1.1433,
+      "suggested_scalar": 0.1288,
+      "log_bad": -0.2492,
+      "log_good": -0.1153
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9494,
+      "good": 5.7829,
+      "ratio": 0.972,
+      "suggested_scalar": -0.0273,
+      "log_bad": 1.7833,
+      "log_good": 1.7549
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7574,
+      "good": 0.7759,
+      "ratio": 1.0244,
+      "suggested_scalar": 0.0232,
+      "log_bad": -0.2779,
+      "log_good": -0.2537
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 8.0,
+      "ratio": 8.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 2.0794
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2609,
+      "good": 0.2466,
+      "ratio": 0.9452,
+      "suggested_scalar": -0.0542,
+      "log_bad": -1.3436,
+      "log_good": -1.4
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6266,
+      "good": 3.5948,
+      "ratio": 0.9912,
+      "suggested_scalar": -0.0085,
+      "log_bad": 1.2883,
+      "log_good": 1.2795
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.6667,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 338.0,
+      "good": 348.0,
+      "ratio": 1.0296,
+      "suggested_scalar": 0.028,
+      "log_bad": 5.823,
+      "log_good": 5.8522
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8012,
+      "good": 0.7614,
+      "ratio": 0.9503,
+      "suggested_scalar": -0.049,
+      "log_bad": -0.2216,
+      "log_good": -0.2726
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 111.0,
+      "ratio": 0.9823,
+      "suggested_scalar": -0.0172,
+      "log_bad": 4.7274,
+      "log_good": 4.7095
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1208.0,
+      "good": 1179.0,
+      "ratio": 0.976,
+      "suggested_scalar": -0.0234,
+      "log_bad": 7.0967,
+      "log_good": 7.0724
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 172.0,
+      "good": 160.0,
+      "ratio": 0.9302,
+      "suggested_scalar": -0.0696,
+      "log_bad": 5.1475,
+      "log_good": 5.0752
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 1.0566,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0171,
+      "good": 0.0164,
+      "ratio": 0.9591,
+      "suggested_scalar": -0.0402,
+      "log_bad": -4.0687,
+      "log_good": -4.1105
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2861,
+      "good": 0.278,
+      "ratio": 0.9717,
+      "suggested_scalar": -0.0276,
+      "log_bad": -1.2514,
+      "log_good": -1.2801
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 66.0,
+      "good": 60.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0917,
+      "log_bad": 4.1897,
+      "log_good": 4.0943
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 111.0,
+      "ratio": 0.9823,
+      "suggested_scalar": -0.0172,
+      "log_bad": 4.7274,
+      "log_good": 4.7095
+    },
+    "brevity.mean_sample_size": {
+      "bad": 113.0,
+      "good": 111.0,
+      "ratio": 0.9823,
+      "suggested_scalar": -0.0172,
+      "log_bad": 4.7274,
+      "log_good": 4.7095
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 409.0,
+      "good": 428.0,
+      "ratio": 1.0465,
+      "suggested_scalar": 0.0437,
+      "log_bad": 6.0137,
+      "log_good": 6.0591
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 189.0,
+      "good": 204.0,
+      "ratio": 1.0794,
+      "suggested_scalar": 0.0735,
+      "log_bad": 5.2417,
+      "log_good": 5.3181
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 281.0,
+      "good": 290.0,
+      "ratio": 1.032,
+      "suggested_scalar": 0.0303,
+      "log_bad": 5.6384,
+      "log_good": 5.6699
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0073,
+      "good": 0.007,
+      "ratio": 0.9589,
+      "suggested_scalar": -0.0404,
+      "log_bad": -4.9199,
+      "log_good": -4.9618
+    },
+    "heaps.mean_k": {
+      "bad": 1.9504,
+      "good": 1.9955,
+      "ratio": 1.0231,
+      "suggested_scalar": 0.022,
+      "log_bad": 0.668,
+      "log_good": 0.6909
+    },
+    "halstead.mean_effort": {
+      "bad": 79286.3472,
+      "good": 85474.6344,
+      "ratio": 1.078,
+      "suggested_scalar": 0.0723,
+      "log_bad": 11.2808,
+      "log_good": 11.356
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8723,
+      "good": 0.8511,
+      "ratio": 0.9757,
+      "suggested_scalar": -0.0237,
+      "log_bad": -0.1366,
+      "log_good": -0.1612
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 73.0,
+      "good": 62.0,
+      "ratio": 0.8493,
+      "suggested_scalar": -0.1571,
+      "log_bad": 4.2905,
+      "log_good": 4.1271
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 189.0,
+      "good": 191.0,
+      "ratio": 1.0106,
+      "suggested_scalar": 0.0101,
+      "log_bad": 5.2417,
+      "log_good": 5.2523
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4641,
+      "good": 0.4516,
+      "ratio": 0.9731,
+      "suggested_scalar": -0.0263,
+      "log_bad": -0.7677,
+      "log_good": -0.795
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.8954,
+      "good": 7.6065,
+      "ratio": 0.9634,
+      "suggested_scalar": -0.0359,
+      "log_bad": 2.0663,
+      "log_good": 2.029
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2609,
+      "good": 0.2466,
+      "ratio": 0.9452,
+      "suggested_scalar": -0.0542,
+      "log_bad": -1.3436,
+      "log_good": -1.4
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.7634,
+      "good": 3.6582,
+      "ratio": 0.972,
+      "suggested_scalar": -0.0273,
+      "log_bad": 1.3253,
+      "log_good": 1.297
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 1.3333,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 408.0,
+      "good": 427.0,
+      "ratio": 1.0466,
+      "suggested_scalar": 0.0438,
+      "log_bad": 6.0113,
+      "log_good": 6.0568
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 43.0,
+      "good": 39.0,
+      "ratio": 0.907,
+      "suggested_scalar": -0.0939,
+      "log_bad": 3.7612,
+      "log_good": 3.6636
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4404.7971,
+      "good": 4748.5908,
+      "ratio": 1.078,
+      "suggested_scalar": 0.0723,
+      "log_bad": 8.3904,
+      "log_good": 8.4656
+    },
+    "readability.mean_total_lines": {
+      "bad": 51.0,
+      "good": 55.0,
+      "ratio": 1.0784,
+      "suggested_scalar": 0.0726,
+      "log_bad": 3.9318,
+      "log_good": 4.0073
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2403.6143,
+      "good": 2284.2359,
+      "ratio": 0.9503,
+      "suggested_scalar": -0.049,
+      "log_bad": 7.7847,
+      "log_good": 7.7338
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 785.0,
+      "good": 772.0,
+      "ratio": 0.9834,
+      "suggested_scalar": -0.0161,
+      "log_bad": 6.6657,
+      "log_good": 6.649
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 40.1176,
+      "good": 36.3636,
+      "ratio": 0.9064,
+      "suggested_scalar": -0.0945,
+      "log_bad": 3.6918,
+      "log_good": 3.5936
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2593,
+      "good": 1.2273,
+      "ratio": 0.9746,
+      "suggested_scalar": -0.0248,
+      "log_bad": 0.2306,
+      "log_good": 0.2048
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 21.0,
+      "good": 25.0,
+      "ratio": 1.1905,
+      "suggested_scalar": 0.1677,
+      "log_bad": 3.0445,
+      "log_good": 3.2189
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8728,
+      "good": 0.8879,
+      "ratio": 1.0173,
+      "suggested_scalar": 0.0165,
+      "log_bad": -0.136,
+      "log_good": -0.1189
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 7.0,
+      "good": 15.0,
+      "ratio": 2.1429,
+      "suggested_scalar": 0.733,
+      "log_bad": 1.9459,
+      "log_good": 2.7081
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9752,
+      "good": 0.9791,
+      "ratio": 1.004,
+      "suggested_scalar": 0.0038,
+      "log_bad": -0.0251,
+      "log_good": -0.0211
+    },
+    "halstead.mean_length": {
+      "bad": 361.0,
+      "good": 351.0,
+      "ratio": 0.9723,
+      "suggested_scalar": -0.027,
+      "log_bad": 5.8889,
+      "log_good": 5.8608
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.8571,
+      "good": 6.1429,
+      "ratio": 1.0488,
+      "suggested_scalar": 0.0458,
+      "log_bad": 1.7677,
+      "log_good": 1.8153
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8202,
+      "good": 6.7944,
+      "ratio": 0.9962,
+      "suggested_scalar": -0.0036,
+      "log_bad": 1.9199,
+      "log_good": 1.9161
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.6667,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0894,
+      "good": 0.0984,
+      "ratio": 1.1007,
+      "suggested_scalar": 0.0923,
+      "log_bad": -2.4146,
+      "log_good": -2.3187
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 32.9863,
+      "good": 37.4194,
+      "ratio": 1.1344,
+      "suggested_scalar": 0.1213,
+      "log_bad": 3.4961,
+      "log_good": 3.6222
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 10.0,
+      "ratio": 1.4286,
+      "suggested_scalar": 0.343,
+      "log_bad": 1.9459,
+      "log_good": 2.3026
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 71.0,
+      "good": 70.0,
+      "ratio": 0.9859,
+      "suggested_scalar": -0.0136,
+      "log_bad": 4.2627,
+      "log_good": 4.2485
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7651,
+      "good": 0.7931,
+      "ratio": 1.0366,
+      "suggested_scalar": 0.0346,
+      "log_bad": -0.2677,
+      "log_good": -0.2318
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 51.0,
+      "good": 55.0,
+      "ratio": 1.0784,
+      "suggested_scalar": 0.0726,
+      "log_bad": 3.9318,
+      "log_good": 4.0073
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 19.0,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.0963,
+      "log_bad": 3.0445,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_private_inheritance": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 16.0,
+      "good": 15.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0278,
+      "log_bad": 2.7726,
+      "log_good": 2.7081
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0037,
+      "good": 0.0039,
+      "ratio": 1.0541,
+      "suggested_scalar": 0.0227,
+      "log_bad": -5.5994,
+      "log_good": -5.5468
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.873,
+      "good": 0.8548,
+      "ratio": 0.9792,
+      "suggested_scalar": -0.0091,
+      "log_bad": -0.1358,
+      "log_good": -0.1569
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0037,
+      "good": 0.0039,
+      "ratio": 1.0541,
+      "suggested_scalar": 0.0227,
+      "log_bad": -5.5994,
+      "log_good": -5.5468
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5962,
+      "good": 4.6018,
+      "ratio": 1.0012,
+      "suggested_scalar": 0.0005,
+      "log_bad": 1.5252,
+      "log_good": 1.5264
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 114.0,
+      "good": 94.0,
+      "ratio": 0.8246,
+      "suggested_scalar": -0.0832,
+      "log_bad": 4.7362,
+      "log_good": 4.5433
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5551,
+      "good": 0.419,
+      "ratio": 0.7548,
+      "suggested_scalar": -0.1214,
+      "log_bad": -0.5886,
+      "log_good": -0.8699
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 18.0,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.0233,
+      "log_bad": 2.9444,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6912,
+      "good": 0.6251,
+      "ratio": 0.9044,
+      "suggested_scalar": -0.0434,
+      "log_bad": -0.3693,
+      "log_good": -0.4698
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.6984,
+      "good": 4.6452,
+      "ratio": 0.9887,
+      "suggested_scalar": -0.0049,
+      "log_bad": 1.5472,
+      "log_good": 1.5358
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 540.0,
+      "good": 513.0,
+      "ratio": 0.95,
+      "suggested_scalar": -0.0221,
+      "log_bad": 6.2916,
+      "log_good": 6.2403
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0012,
+      "good": 0.0013,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.0345,
+      "log_bad": -6.7254,
+      "log_good": -6.6454
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1111,
+      "good": 0.1129,
+      "ratio": 1.0162,
+      "suggested_scalar": 0.0069,
+      "log_bad": -2.1973,
+      "log_good": -2.1813
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0054,
+      "good": 1.0163,
+      "ratio": 1.0108,
+      "suggested_scalar": 0.0047,
+      "log_bad": 0.0054,
+      "log_good": 0.0162
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 158.0,
+      "good": 141.0,
+      "ratio": 0.8924,
+      "suggested_scalar": -0.0491,
+      "log_bad": 5.0626,
+      "log_good": 4.9488
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 100.4433,
+      "good": 100.0158,
+      "ratio": 0.9957,
+      "suggested_scalar": -0.0018,
+      "log_bad": 4.6096,
+      "log_good": 4.6053
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6345,
+      "good": 0.7012,
+      "ratio": 1.1051,
+      "suggested_scalar": 0.0431,
+      "log_bad": -0.4549,
+      "log_good": -0.355
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.7935,
+      "good": 10.1202,
+      "ratio": 1.0334,
+      "suggested_scalar": 0.0142,
+      "log_bad": 2.2817,
+      "log_good": 2.3145
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2469.0,
+      "good": 2276.0,
+      "ratio": 0.9218,
+      "suggested_scalar": -0.0351,
+      "log_bad": 7.8116,
+      "log_good": 7.7302
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1429,
+      "good": 0.0968,
+      "ratio": 0.6774,
+      "suggested_scalar": -0.168,
+      "log_bad": -1.9456,
+      "log_good": -2.3351
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8413,
+      "good": 0.8226,
+      "ratio": 0.9778,
+      "suggested_scalar": -0.0097,
+      "log_bad": -0.1728,
+      "log_good": -0.1953
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.0,
+      "good": 8.8448,
+      "ratio": 0.9828,
+      "suggested_scalar": -0.0075,
+      "log_bad": 2.1972,
+      "log_good": 2.1798
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 16.0,
+      "good": 25.0,
+      "ratio": 1.5625,
+      "suggested_scalar": 0.1925,
+      "log_bad": 2.7726,
+      "log_good": 3.2189
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 20.5916,
+      "good": 21.2612,
+      "ratio": 1.0325,
+      "suggested_scalar": 0.0138,
+      "log_bad": 3.0249,
+      "log_good": 3.0569
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 101.0,
+      "good": 78.0,
+      "ratio": 0.7723,
+      "suggested_scalar": -0.1115,
+      "log_bad": 4.6151,
+      "log_good": 4.3567
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9631,
+      "good": 0.9518,
+      "ratio": 0.9883,
+      "suggested_scalar": -0.0051,
+      "log_bad": -0.0376,
+      "log_good": -0.0494
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 26.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2581,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6565,
+      "good": 0.6718,
+      "ratio": 1.0233,
+      "suggested_scalar": 0.0099,
+      "log_bad": -0.4208,
+      "log_good": -0.3978
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4368,
+      "good": 0.4951,
+      "ratio": 1.1335,
+      "suggested_scalar": 0.0541,
+      "log_bad": -0.8283,
+      "log_good": -0.703
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9116,
+      "good": 3.0469,
+      "ratio": 1.0465,
+      "suggested_scalar": 0.0196,
+      "log_bad": 1.0687,
+      "log_good": 1.1141
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 538.0,
+      "good": 511.0,
+      "ratio": 0.9498,
+      "suggested_scalar": -0.0222,
+      "log_bad": 6.2879,
+      "log_good": 6.2364
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0593,
+      "good": 0.0565,
+      "ratio": 0.9528,
+      "suggested_scalar": -0.0209,
+      "log_bad": -2.8251,
+      "log_good": -2.8735
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.8826,
+      "ratio": 0.988,
+      "suggested_scalar": -0.0052,
+      "log_bad": 1.7841,
+      "log_good": 1.772
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 25.0,
+      "good": 23.0,
+      "ratio": 0.92,
+      "suggested_scalar": -0.036,
+      "log_bad": 3.2189,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.5027,
+      "good": 1.6856,
+      "ratio": 1.1217,
+      "suggested_scalar": 0.0496,
+      "log_bad": 0.4073,
+      "log_good": 0.5221
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7241,
+      "good": 5.5768,
+      "ratio": 0.9743,
+      "suggested_scalar": -0.0112,
+      "log_bad": 1.7447,
+      "log_good": 1.7186
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7719,
+      "good": 0.7823,
+      "ratio": 1.0135,
+      "suggested_scalar": 0.0058,
+      "log_bad": -0.2589,
+      "log_good": -0.2455
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.16,
+      "good": 0.1733,
+      "ratio": 1.0831,
+      "suggested_scalar": 0.0345,
+      "log_bad": -1.8326,
+      "log_good": -1.7527
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1295,
+      "good": 3.1812,
+      "ratio": 1.0165,
+      "suggested_scalar": 0.0071,
+      "log_bad": 1.1409,
+      "log_good": 1.1573
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 390.0,
+      "good": 351.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0455,
+      "log_bad": 5.9661,
+      "log_good": 5.8608
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.2003,
+      "good": 1.0881,
+      "ratio": 0.9065,
+      "suggested_scalar": -0.0423,
+      "log_bad": 0.1826,
+      "log_good": 0.0844
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 117.0,
+      "good": 95.0,
+      "ratio": 0.812,
+      "suggested_scalar": -0.0899,
+      "log_bad": 4.7622,
+      "log_good": 4.5539
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1096.0,
+      "good": 1004.0,
+      "ratio": 0.9161,
+      "suggested_scalar": -0.0378,
+      "log_bad": 6.9994,
+      "log_good": 6.9117
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 226.0,
+      "good": 206.0,
+      "ratio": 0.9115,
+      "suggested_scalar": -0.04,
+      "log_bad": 5.4205,
+      "log_good": 5.3279
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 0.0097,
+      "ratio": 0.0097,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -4.6356
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2296,
+      "good": 0.2573,
+      "ratio": 1.1206,
+      "suggested_scalar": 0.0491,
+      "log_bad": -1.4714,
+      "log_good": -1.3575
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 94.0,
+      "good": 102.0,
+      "ratio": 1.0851,
+      "suggested_scalar": 0.0352,
+      "log_bad": 4.5433,
+      "log_good": 4.625
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 117.0,
+      "good": 95.0,
+      "ratio": 0.812,
+      "suggested_scalar": -0.0899,
+      "log_bad": 4.7622,
+      "log_good": 4.5539
+    },
+    "brevity.mean_sample_size": {
+      "bad": 117.0,
+      "good": 95.0,
+      "ratio": 0.812,
+      "suggested_scalar": -0.0899,
+      "log_bad": 4.7622,
+      "log_good": 4.5539
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 540.0,
+      "good": 513.0,
+      "ratio": 0.95,
+      "suggested_scalar": -0.0221,
+      "log_bad": 6.2916,
+      "log_good": 6.2403
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 284.0,
+      "good": 281.0,
+      "ratio": 0.9894,
+      "suggested_scalar": -0.0046,
+      "log_bad": 5.649,
+      "log_good": 5.6384
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 291.0,
+      "good": 255.0,
+      "ratio": 0.8763,
+      "suggested_scalar": -0.057,
+      "log_bad": 5.6733,
+      "log_good": 5.5413
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0019,
+      "good": 0.0019,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.2659,
+      "log_good": -6.2659
+    },
+    "heaps.mean_k": {
+      "bad": 1.5566,
+      "good": 2.113,
+      "ratio": 1.3574,
+      "suggested_scalar": 0.1319,
+      "log_bad": 0.4425,
+      "log_good": 0.7481
+    },
+    "halstead.mean_effort": {
+      "bad": 120222.0598,
+      "good": 128551.2955,
+      "ratio": 1.0693,
+      "suggested_scalar": 0.0289,
+      "log_bad": 11.6971,
+      "log_good": 11.7641
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8332,
+      "good": 0.8489,
+      "ratio": 1.0188,
+      "suggested_scalar": 0.0081,
+      "log_bad": -0.1825,
+      "log_good": -0.1638
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 88.0,
+      "good": 68.0,
+      "ratio": 0.7727,
+      "suggested_scalar": -0.1112,
+      "log_bad": 4.4773,
+      "log_good": 4.2195
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 301.0,
+      "good": 292.0,
+      "ratio": 0.9701,
+      "suggested_scalar": -0.0131,
+      "log_bad": 5.7071,
+      "log_good": 5.6768
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.443,
+      "good": 0.3617,
+      "ratio": 0.8165,
+      "suggested_scalar": -0.0875,
+      "log_bad": -0.8142,
+      "log_good": -1.0169
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.9367,
+      "good": 7.1206,
+      "ratio": 1.0265,
+      "suggested_scalar": 0.0113,
+      "log_bad": 1.9368,
+      "log_good": 1.963
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.16,
+      "good": 0.1733,
+      "ratio": 1.0831,
+      "suggested_scalar": 0.0345,
+      "log_bad": -1.8326,
+      "log_good": -1.7527
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.6,
+      "good": 3.5379,
+      "ratio": 0.9828,
+      "suggested_scalar": -0.0075,
+      "log_bad": 1.2809,
+      "log_good": 1.2635
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 539.0,
+      "good": 512.0,
+      "ratio": 0.9499,
+      "suggested_scalar": -0.0222,
+      "log_bad": 6.2897,
+      "log_good": 6.2383
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 87.0,
+      "good": 93.0,
+      "ratio": 1.069,
+      "suggested_scalar": 0.0288,
+      "log_bad": 4.4659,
+      "log_good": 4.5326
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6679.0033,
+      "good": 7141.7386,
+      "ratio": 1.0693,
+      "suggested_scalar": 0.0289,
+      "log_bad": 8.8067,
+      "log_good": 8.8737
+    },
+    "readability.mean_total_lines": {
+      "bad": 60.0,
+      "good": 58.0,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0146,
+      "log_bad": 4.0943,
+      "log_good": 4.0604
+    },
+    "indentation.mean_max_depth": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "halstead.mean_volume": {
+      "bad": 3600.933,
+      "good": 3264.1852,
+      "ratio": 0.9065,
+      "suggested_scalar": -0.0424,
+      "log_bad": 8.1889,
+      "log_good": 8.0908
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 848.0,
+      "good": 747.0,
+      "ratio": 0.8809,
+      "suggested_scalar": -0.0547,
+      "log_bad": 6.7429,
+      "log_good": 6.6161
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 38.8667,
+      "good": 36.7241,
+      "ratio": 0.9449,
+      "suggested_scalar": -0.0245,
+      "log_bad": 3.6601,
+      "log_good": 3.6034
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1496,
+      "good": 1.1565,
+      "ratio": 1.006,
+      "suggested_scalar": 0.0026,
+      "log_bad": 0.1394,
+      "log_good": 0.1454
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2991,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7769,
+      "good": 0.735,
+      "ratio": 0.9461,
+      "suggested_scalar": -0.0239,
+      "log_bad": -0.2524,
+      "log_good": -0.3079
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9774,
+      "good": 0.9449,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0146,
+      "log_bad": -0.0229,
+      "log_good": -0.0567
+    },
+    "halstead.mean_length": {
+      "bad": 527.0,
+      "good": 498.0,
+      "ratio": 0.945,
+      "suggested_scalar": -0.0244,
+      "log_bad": 6.2672,
+      "log_good": 6.2106
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8704,
+      "good": 6.5699,
+      "ratio": 0.9563,
+      "suggested_scalar": -0.0193,
+      "log_bad": 1.9272,
+      "log_good": 1.8825
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1154,
+      "good": 0.1235,
+      "ratio": 1.0702,
+      "suggested_scalar": 0.0293,
+      "log_bad": -2.1594,
+      "log_good": -2.0915
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 33.3864,
+      "good": 39.3824,
+      "ratio": 1.1796,
+      "suggested_scalar": 0.0713,
+      "log_bad": 3.5081,
+      "log_good": 3.6733
+    },
+    "branching.mean_branch_count": {
+      "bad": 9.0,
+      "good": 6.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1749,
+      "log_bad": 2.1972,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 70.0,
+      "good": 51.0,
+      "ratio": 0.7286,
+      "suggested_scalar": -0.1366,
+      "log_bad": 4.2485,
+      "log_good": 3.9318
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.677,
+      "good": 0.6,
+      "ratio": 0.8863,
+      "suggested_scalar": -0.0521,
+      "log_bad": -0.3901,
+      "log_good": -0.5108
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 63.0,
+      "good": 62.0,
+      "ratio": 0.9841,
+      "suggested_scalar": -0.0069,
+      "log_bad": 4.1431,
+      "log_good": 4.1271
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.no_error_suppression_operator": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "documentation.function_todo_comment_in_body": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 51.0,
+      "good": 56.0,
+      "ratio": 1.098,
+      "suggested_scalar": 0.0281,
+      "log_bad": 3.9318,
+      "log_good": 4.0254
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0082,
+      "good": 0.0078,
+      "ratio": 0.9512,
+      "suggested_scalar": -0.0151,
+      "log_bad": -4.8036,
+      "log_good": -4.8536
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 0.8889,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0354,
+      "log_bad": 0.0,
+      "log_good": -0.1178
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8375,
+      "good": 0.8452,
+      "ratio": 1.0092,
+      "suggested_scalar": 0.0028,
+      "log_bad": -0.1773,
+      "log_good": -0.1682
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0082,
+      "good": 0.0078,
+      "ratio": 0.9512,
+      "suggested_scalar": -0.0151,
+      "log_bad": -4.8036,
+      "log_good": -4.8536
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7333,
+      "good": 4.7749,
+      "ratio": 1.0088,
+      "suggested_scalar": 0.0026,
+      "log_bad": 1.5546,
+      "log_good": 1.5634
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 140.0,
+      "good": 117.0,
+      "ratio": 0.8357,
+      "suggested_scalar": -0.054,
+      "log_bad": 4.9416,
+      "log_good": 4.7622
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5177,
+      "good": 0.4478,
+      "ratio": 0.865,
+      "suggested_scalar": -0.0437,
+      "log_bad": -0.6584,
+      "log_good": -0.8034
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 22.0,
+      "good": 21.0,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.014,
+      "log_bad": 3.091,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5905,
+      "good": 0.5005,
+      "ratio": 0.8476,
+      "suggested_scalar": -0.0498,
+      "log_bad": -0.5268,
+      "log_good": -0.6921
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.1,
+      "good": 3.8571,
+      "ratio": 0.9408,
+      "suggested_scalar": -0.0184,
+      "log_bad": 1.411,
+      "log_good": 1.3499
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 728.0,
+      "good": 767.0,
+      "ratio": 1.0536,
+      "suggested_scalar": 0.0157,
+      "log_bad": 6.5903,
+      "log_good": 6.6425
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.075,
+      "good": 1.0,
+      "ratio": 13.3333,
+      "suggested_scalar": 0.7796,
+      "log_bad": -2.5903,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0011,
+      "good": 0.001,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0287,
+      "log_bad": -6.8124,
+      "log_good": -6.9078
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0771,
+      "good": 1.0749,
+      "ratio": 0.998,
+      "suggested_scalar": -0.0006,
+      "log_bad": 0.0743,
+      "log_good": 0.0722
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 253.0,
+      "good": 251.0,
+      "ratio": 0.9921,
+      "suggested_scalar": -0.0024,
+      "log_bad": 5.5334,
+      "log_good": 5.5255
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 98.2839,
+      "good": 96.5758,
+      "ratio": 0.9826,
+      "suggested_scalar": -0.0053,
+      "log_bad": 4.5879,
+      "log_good": 4.5703
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6685,
+      "good": 0.6906,
+      "ratio": 1.0331,
+      "suggested_scalar": 0.0098,
+      "log_bad": -0.4027,
+      "log_good": -0.3702
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 12.2225,
+      "good": 13.5441,
+      "ratio": 1.1081,
+      "suggested_scalar": 0.0309,
+      "log_bad": 2.5033,
+      "log_good": 2.606
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2810.0,
+      "good": 2888.0,
+      "ratio": 1.0278,
+      "suggested_scalar": 0.0082,
+      "log_bad": 7.9409,
+      "log_good": 7.9683
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1375,
+      "good": 0.119,
+      "ratio": 0.8655,
+      "suggested_scalar": -0.0435,
+      "log_bad": -1.9841,
+      "log_good": -2.1286
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8125,
+      "good": 0.8214,
+      "ratio": 1.011,
+      "suggested_scalar": 0.0033,
+      "log_bad": -0.2076,
+      "log_good": -0.1967
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.8378,
+      "good": 9.131,
+      "ratio": 0.9282,
+      "suggested_scalar": -0.0224,
+      "log_bad": 2.2862,
+      "log_good": 2.2117
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 6.0,
+      "good": 1.0,
+      "ratio": 0.1667,
+      "suggested_scalar": -0.5392,
+      "log_bad": 1.7918,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 4.99,
+      "good": 4.551,
+      "ratio": 0.912,
+      "suggested_scalar": -0.0277,
+      "log_bad": 1.6074,
+      "log_good": 1.5153
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 195.0,
+      "good": 192.0,
+      "ratio": 0.9846,
+      "suggested_scalar": -0.0047,
+      "log_bad": 5.273,
+      "log_good": 5.2575
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9606,
+      "good": 0.96,
+      "ratio": 0.9994,
+      "suggested_scalar": -0.0002,
+      "log_bad": -0.0402,
+      "log_good": -0.0408
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 37.0,
+      "good": 37.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6109,
+      "log_good": 3.6109
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6295,
+      "good": 0.6305,
+      "ratio": 1.0016,
+      "suggested_scalar": 0.0005,
+      "log_bad": -0.4628,
+      "log_good": -0.4612
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4807,
+      "good": 0.5007,
+      "ratio": 1.0416,
+      "suggested_scalar": 0.0123,
+      "log_bad": -0.7325,
+      "log_good": -0.6917
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6993,
+      "good": 2.7067,
+      "ratio": 1.0027,
+      "suggested_scalar": 0.0008,
+      "log_bad": 0.993,
+      "log_good": 0.9957
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 726.0,
+      "good": 765.0,
+      "ratio": 1.0537,
+      "suggested_scalar": 0.0157,
+      "log_bad": 6.5876,
+      "log_good": 6.6399
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 17.0,
+      "good": 16.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0182,
+      "log_bad": 2.8332,
+      "log_good": 2.7726
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0302,
+      "good": 0.0274,
+      "ratio": 0.9073,
+      "suggested_scalar": -0.0293,
+      "log_bad": -3.4999,
+      "log_good": -3.5972
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.9542,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7841,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 54.0,
+      "good": 55.0,
+      "ratio": 1.0185,
+      "suggested_scalar": 0.0055,
+      "log_bad": 3.989,
+      "log_good": 4.0073
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8597,
+      "good": 0.8708,
+      "ratio": 1.0129,
+      "suggested_scalar": 0.0039,
+      "log_bad": -0.1512,
+      "log_good": -0.1383
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8987,
+      "good": 5.9045,
+      "ratio": 1.001,
+      "suggested_scalar": 0.0003,
+      "log_bad": 1.7747,
+      "log_good": 1.7757
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.795,
+      "good": 0.8019,
+      "ratio": 1.0087,
+      "suggested_scalar": 0.0026,
+      "log_bad": -0.2294,
+      "log_good": -0.2208
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1579,
+      "good": 0.1923,
+      "ratio": 1.2179,
+      "suggested_scalar": 0.0593,
+      "log_bad": -1.8458,
+      "log_good": -1.6487
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.4961,
+      "good": 3.6802,
+      "ratio": 1.0527,
+      "suggested_scalar": 0.0154,
+      "log_bad": 1.2516,
+      "log_good": 1.303
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 493.0,
+      "good": 518.0,
+      "ratio": 1.0507,
+      "suggested_scalar": 0.0149,
+      "log_bad": 6.2005,
+      "log_good": 6.25
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.6255,
+      "good": 1.5848,
+      "ratio": 0.975,
+      "suggested_scalar": -0.0076,
+      "log_bad": 0.4858,
+      "log_good": 0.4605
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 146.0,
+      "good": 142.0,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.0084,
+      "log_bad": 4.9836,
+      "log_good": 4.9558
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1556.0,
+      "good": 1574.0,
+      "ratio": 1.0116,
+      "suggested_scalar": 0.0035,
+      "log_bad": 7.3499,
+      "log_good": 7.3614
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 256.0,
+      "good": 231.0,
+      "ratio": 0.9023,
+      "suggested_scalar": -0.0309,
+      "log_bad": 5.5452,
+      "log_good": 5.4424
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0096,
+      "good": 0.0091,
+      "ratio": 0.9479,
+      "suggested_scalar": -0.0161,
+      "log_bad": -4.646,
+      "log_good": -4.6995
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.272,
+      "good": 0.2777,
+      "ratio": 1.021,
+      "suggested_scalar": 0.0062,
+      "log_bad": -1.302,
+      "log_good": -1.2812
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 126.0,
+      "good": 147.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.0464,
+      "log_bad": 4.8363,
+      "log_good": 4.9904
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 8.0,
+      "good": 9.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0354,
+      "log_bad": 2.0794,
+      "log_good": 2.1972
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 146.0,
+      "good": 142.0,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.0084,
+      "log_bad": 4.9836,
+      "log_good": 4.9558
+    },
+    "brevity.mean_sample_size": {
+      "bad": 146.0,
+      "good": 142.0,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.0084,
+      "log_bad": 4.9836,
+      "log_good": 4.9558
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 728.0,
+      "good": 767.0,
+      "ratio": 1.0536,
+      "suggested_scalar": 0.0157,
+      "log_bad": 6.5903,
+      "log_good": 6.6425
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 407.0,
+      "good": 435.0,
+      "ratio": 1.0688,
+      "suggested_scalar": 0.02,
+      "log_bad": 6.0088,
+      "log_good": 6.0753
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 367.0,
+      "good": 384.0,
+      "ratio": 1.0463,
+      "suggested_scalar": 0.0136,
+      "log_bad": 5.9054,
+      "log_good": 5.9506
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0013,
+      "ratio": 0.0013,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.6454
+    },
+    "heaps.mean_k": {
+      "bad": 3.0791,
+      "good": 5.2536,
+      "ratio": 1.7062,
+      "suggested_scalar": 0.1608,
+      "log_bad": 1.1246,
+      "log_good": 1.6589
+    },
+    "halstead.mean_effort": {
+      "bad": 224221.0729,
+      "good": 253968.3564,
+      "ratio": 1.1327,
+      "suggested_scalar": 0.0375,
+      "log_bad": 12.3204,
+      "log_good": 12.445
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8204,
+      "good": 0.8258,
+      "ratio": 1.0066,
+      "suggested_scalar": 0.002,
+      "log_bad": -0.198,
+      "log_good": -0.1914
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 103.0,
+      "good": 80.0,
+      "ratio": 0.7767,
+      "suggested_scalar": -0.0761,
+      "log_bad": 4.6347,
+      "log_good": 4.382
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 428.0,
+      "good": 461.0,
+      "ratio": 1.0771,
+      "suggested_scalar": 0.0224,
+      "log_bad": 6.0591,
+      "log_good": 6.1334
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4032,
+      "good": 0.3825,
+      "ratio": 0.9487,
+      "suggested_scalar": -0.0159,
+      "log_bad": -0.9083,
+      "log_good": -0.961
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.1502,
+      "good": 6.2709,
+      "ratio": 1.0196,
+      "suggested_scalar": 0.0058,
+      "log_bad": 1.8165,
+      "log_good": 1.8359
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1579,
+      "good": 0.1923,
+      "ratio": 1.2179,
+      "suggested_scalar": 0.0593,
+      "log_bad": -1.8458,
+      "log_good": -1.6487
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.824,
+      "good": 4.6524,
+      "ratio": 0.9644,
+      "suggested_scalar": -0.0109,
+      "log_bad": 1.5736,
+      "log_good": 1.5374
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 727.0,
+      "good": 766.0,
+      "ratio": 1.0536,
+      "suggested_scalar": 0.0157,
+      "log_bad": 6.5889,
+      "log_good": 6.6412
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 11.0,
+      "good": 10.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0287,
+      "log_bad": 2.3979,
+      "log_good": 2.3026
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 116.0,
+      "good": 136.0,
+      "ratio": 1.1724,
+      "suggested_scalar": 0.0479,
+      "log_bad": 4.7536,
+      "log_good": 4.9127
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 12456.7263,
+      "good": 14109.3531,
+      "ratio": 1.1327,
+      "suggested_scalar": 0.0375,
+      "log_bad": 9.43,
+      "log_good": 9.5546
+    },
+    "readability.mean_total_lines": {
+      "bad": 74.0,
+      "good": 84.0,
+      "ratio": 1.1351,
+      "suggested_scalar": 0.0381,
+      "log_bad": 4.3041,
+      "log_good": 4.4308
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 4876.4296,
+      "good": 4754.2924,
+      "ratio": 0.975,
+      "suggested_scalar": -0.0076,
+      "log_bad": 8.4922,
+      "log_good": 8.4668
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1041.0,
+      "good": 1067.0,
+      "ratio": 1.025,
+      "suggested_scalar": 0.0074,
+      "log_bad": 6.9479,
+      "log_good": 6.9726
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.8108,
+      "good": 33.1429,
+      "ratio": 1.0419,
+      "suggested_scalar": 0.0123,
+      "log_bad": 3.4598,
+      "log_good": 3.5008
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1651,
+      "good": 1.1938,
+      "ratio": 1.0246,
+      "suggested_scalar": 0.0073,
+      "log_bad": 0.1528,
+      "log_good": 0.1771
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 40.0,
+      "good": 47.0,
+      "ratio": 1.175,
+      "suggested_scalar": 0.0485,
+      "log_bad": 3.6889,
+      "log_good": 3.8501
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 1.0,
+      "ratio": 0.1667,
+      "suggested_scalar": -0.5392,
+      "log_bad": 1.7918,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7647,
+      "good": 0.7375,
+      "ratio": 0.9644,
+      "suggested_scalar": -0.0109,
+      "log_bad": -0.2683,
+      "log_good": -0.3045
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.983,
+      "good": 0.9523,
+      "ratio": 0.9688,
+      "suggested_scalar": -0.0095,
+      "log_bad": -0.0171,
+      "log_good": -0.0489
+    },
+    "halstead.mean_length": {
+      "bad": 684.0,
+      "good": 692.0,
+      "ratio": 1.0117,
+      "suggested_scalar": 0.0035,
+      "log_bad": 6.528,
+      "log_good": 6.5396
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.625,
+      "good": 9.7778,
+      "ratio": 0.9203,
+      "suggested_scalar": -0.025,
+      "log_bad": 2.3632,
+      "log_good": 2.2801
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.1898,
+      "good": 7.1497,
+      "ratio": 0.9944,
+      "suggested_scalar": -0.0017,
+      "log_bad": 1.9727,
+      "log_good": 1.9671
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1449,
+      "good": 0.1506,
+      "ratio": 1.0393,
+      "suggested_scalar": 0.0116,
+      "log_bad": -1.9317,
+      "log_good": -1.8931
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 45.9806,
+      "good": 53.4188,
+      "ratio": 1.1618,
+      "suggested_scalar": 0.0451,
+      "log_bad": 3.8282,
+      "log_good": 3.9782
+    },
+    "branching.mean_branch_count": {
+      "bad": 11.0,
+      "good": 10.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0287,
+      "log_bad": 2.3979,
+      "log_good": 2.3026
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 102.0,
+      "good": 96.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0182,
+      "log_bad": 4.625,
+      "log_good": 4.5643
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6567,
+      "good": 0.6172,
+      "ratio": 0.9399,
+      "suggested_scalar": -0.0187,
+      "log_bad": -0.4205,
+      "log_good": -0.4826
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 80.0,
+      "good": 84.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0147,
+      "log_bad": 4.382,
+      "log_good": 4.4308
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_dynamic_atom_creation_from_external_input": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 27.0,
+      "good": 37.0,
+      "ratio": 1.3704,
+      "suggested_scalar": 0.3238,
+      "log_bad": 3.2958,
+      "log_good": 3.6109
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0108,
+      "good": 0.0414,
+      "ratio": 3.8333,
+      "suggested_scalar": 1.3811,
+      "log_bad": -4.5282,
+      "log_good": -3.1845
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 1.1,
+      "ratio": 0.7333,
+      "suggested_scalar": -0.3188,
+      "log_bad": 0.4055,
+      "log_good": 0.0953
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.875,
+      "good": 0.8298,
+      "ratio": 0.9483,
+      "suggested_scalar": -0.0545,
+      "log_bad": -0.1335,
+      "log_good": -0.1866
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0108,
+      "good": 0.0414,
+      "ratio": 3.8333,
+      "suggested_scalar": 1.3811,
+      "log_bad": -4.5282,
+      "log_good": -3.1845
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7419,
+      "good": 4.7109,
+      "ratio": 0.9935,
+      "suggested_scalar": -0.0067,
+      "log_bad": 1.5564,
+      "log_good": 1.5499
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 107.0,
+      "good": 88.0,
+      "ratio": 0.8224,
+      "suggested_scalar": -0.2009,
+      "log_bad": 4.6728,
+      "log_good": 4.4773
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5198,
+      "good": 0.5881,
+      "ratio": 1.1314,
+      "suggested_scalar": 0.1269,
+      "log_bad": -0.6543,
+      "log_good": -0.5309
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 20.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.1083,
+      "log_bad": 2.8904,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6399,
+      "good": 0.6264,
+      "ratio": 0.9789,
+      "suggested_scalar": -0.0219,
+      "log_bad": -0.4464,
+      "log_good": -0.4678
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.5,
+      "good": 2.7234,
+      "ratio": 1.0894,
+      "suggested_scalar": 0.088,
+      "log_bad": 0.9163,
+      "log_good": 1.0019
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 369.0,
+      "good": 507.0,
+      "ratio": 1.374,
+      "suggested_scalar": 0.3265,
+      "log_bad": 5.9108,
+      "log_good": 6.2285
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.4167,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.175,
+      "good": 1.0,
+      "ratio": 5.7143,
+      "suggested_scalar": 1.7914,
+      "log_bad": -1.743,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8877,
+      "good": 0.9702,
+      "ratio": 1.0929,
+      "suggested_scalar": 0.0913,
+      "log_bad": -0.1191,
+      "log_good": -0.0303
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 147.0,
+      "good": 178.0,
+      "ratio": 1.2109,
+      "suggested_scalar": 0.1967,
+      "log_bad": 4.9904,
+      "log_good": 5.1818
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 94.7504,
+      "good": 94.7338,
+      "ratio": 0.9998,
+      "suggested_scalar": -0.0002,
+      "log_bad": 4.5512,
+      "log_good": 4.5511
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5353,
+      "good": 0.6285,
+      "ratio": 1.1741,
+      "suggested_scalar": 0.165,
+      "log_bad": -0.6249,
+      "log_good": -0.4644
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.7949,
+      "good": 18.0944,
+      "ratio": 1.5341,
+      "suggested_scalar": 0.4398,
+      "log_bad": 2.4677,
+      "log_good": 2.8956
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1528.0,
+      "good": 1951.0,
+      "ratio": 1.2768,
+      "suggested_scalar": 0.2512,
+      "log_bad": 7.3317,
+      "log_good": 7.5761
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.125,
+      "good": 0.1277,
+      "ratio": 1.0216,
+      "suggested_scalar": 0.022,
+      "log_bad": -2.0794,
+      "log_good": -2.0581
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.85,
+      "good": 0.7872,
+      "ratio": 0.9261,
+      "suggested_scalar": -0.0789,
+      "log_bad": -0.1625,
+      "log_good": -0.2393
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 11.1818,
+      "good": 10.7872,
+      "ratio": 0.9647,
+      "suggested_scalar": -0.0369,
+      "log_bad": 2.4143,
+      "log_good": 2.3784
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.4167,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.15,
+      "good": 2.4554,
+      "ratio": 2.1351,
+      "suggested_scalar": 0.7796,
+      "log_bad": 0.1398,
+      "log_good": 0.8983
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 121.0,
+      "good": 158.0,
+      "ratio": 1.3058,
+      "suggested_scalar": 0.2742,
+      "log_bad": 4.7958,
+      "log_good": 5.0626
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9565,
+      "good": 0.9604,
+      "ratio": 1.0041,
+      "suggested_scalar": 0.0042,
+      "log_bad": -0.0445,
+      "log_good": -0.0404
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 28.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0762,
+      "log_bad": 3.2581,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5785,
+      "good": 0.6074,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0501,
+      "log_bad": -0.5473,
+      "log_good": -0.4986
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2834,
+      "good": 0.4297,
+      "ratio": 1.5162,
+      "suggested_scalar": 0.4278,
+      "log_bad": -1.2609,
+      "log_good": -0.8447
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3727,
+      "good": 2.547,
+      "ratio": 1.0735,
+      "suggested_scalar": 0.0729,
+      "log_bad": 0.864,
+      "log_good": 0.9349
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 367.0,
+      "good": 505.0,
+      "ratio": 1.376,
+      "suggested_scalar": 0.3281,
+      "log_bad": 5.9054,
+      "log_good": 6.2246
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 8.0,
+      "good": 15.0,
+      "ratio": 1.875,
+      "suggested_scalar": 0.6461,
+      "log_bad": 2.0794,
+      "log_good": 2.7081
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0163,
+      "good": 0.0138,
+      "ratio": 0.8466,
+      "suggested_scalar": -0.1711,
+      "log_bad": -4.1166,
+      "log_good": -4.2831
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.858,
+      "good": 5.9069,
+      "ratio": 1.0083,
+      "suggested_scalar": 0.0085,
+      "log_bad": 1.7678,
+      "log_good": 1.7761
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 24.0,
+      "good": 17.0,
+      "ratio": 0.7083,
+      "suggested_scalar": -0.3544,
+      "log_bad": 3.1781,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7424,
+      "good": 0.5755,
+      "ratio": 0.7752,
+      "suggested_scalar": -0.2617,
+      "log_bad": -0.2979,
+      "log_good": -0.5525
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8681,
+      "good": 5.8089,
+      "ratio": 0.9899,
+      "suggested_scalar": -0.0104,
+      "log_bad": 1.7695,
+      "log_good": 1.7594
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8095,
+      "good": 0.7975,
+      "ratio": 0.9852,
+      "suggested_scalar": -0.0154,
+      "log_bad": -0.2113,
+      "log_good": -0.2263
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1304,
+      "good": 0.1132,
+      "ratio": 0.8681,
+      "suggested_scalar": -0.1454,
+      "log_bad": -2.0371,
+      "log_good": -2.1786
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.4344,
+      "good": 4.2538,
+      "ratio": 1.2386,
+      "suggested_scalar": 0.2199,
+      "log_bad": 1.2338,
+      "log_good": 1.4478
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 297.0,
+      "good": 343.0,
+      "ratio": 1.1549,
+      "suggested_scalar": 0.148,
+      "log_bad": 5.6937,
+      "log_good": 5.8377
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 5.0,
+      "good": 9.0,
+      "ratio": 1.8,
+      "suggested_scalar": 0.6041,
+      "log_bad": 1.6094,
+      "log_good": 2.1972
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7798,
+      "good": 0.8182,
+      "ratio": 1.0492,
+      "suggested_scalar": 0.0494,
+      "log_bad": -0.2487,
+      "log_good": -0.2006
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 109.0,
+      "good": 131.0,
+      "ratio": 1.2018,
+      "suggested_scalar": 0.189,
+      "log_bad": 4.6913,
+      "log_good": 4.8752
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 895.0,
+      "good": 1120.0,
+      "ratio": 1.2514,
+      "suggested_scalar": 0.2305,
+      "log_bad": 6.7968,
+      "log_good": 7.0211
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 164.0,
+      "good": 125.0,
+      "ratio": 0.7622,
+      "suggested_scalar": -0.2791,
+      "log_bad": 5.0999,
+      "log_good": 4.8283
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0054,
+      "good": 0.0099,
+      "ratio": 1.8333,
+      "suggested_scalar": 0.623,
+      "log_bad": -5.2214,
+      "log_good": -4.6152
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2547,
+      "good": 0.217,
+      "ratio": 0.852,
+      "suggested_scalar": -0.1646,
+      "log_bad": -1.3677,
+      "log_good": -1.5279
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 58.0,
+      "good": 78.0,
+      "ratio": 1.3448,
+      "suggested_scalar": 0.3045,
+      "log_bad": 4.0604,
+      "log_good": 4.3567
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 10.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.525,
+      "log_bad": 1.7918,
+      "log_good": 2.3026
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 109.0,
+      "good": 131.0,
+      "ratio": 1.2018,
+      "suggested_scalar": 0.189,
+      "log_bad": 4.6913,
+      "log_good": 4.8752
+    },
+    "brevity.mean_sample_size": {
+      "bad": 109.0,
+      "good": 131.0,
+      "ratio": 1.2018,
+      "suggested_scalar": 0.189,
+      "log_bad": 4.6913,
+      "log_good": 4.8752
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 369.0,
+      "good": 507.0,
+      "ratio": 1.374,
+      "suggested_scalar": 0.3265,
+      "log_bad": 5.9108,
+      "log_good": 6.2285
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 175.0,
+      "good": 275.0,
+      "ratio": 1.5714,
+      "suggested_scalar": 0.4645,
+      "log_bad": 5.1648,
+      "log_good": 5.6168
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 229.0,
+      "good": 266.0,
+      "ratio": 1.1616,
+      "suggested_scalar": 0.1539,
+      "log_bad": 5.4337,
+      "log_good": 5.5835
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.714,
+      "good": 3.2162,
+      "ratio": 1.185,
+      "suggested_scalar": 0.1745,
+      "log_bad": 0.9984,
+      "log_good": 1.1682
+    },
+    "halstead.mean_effort": {
+      "bad": 61572.3981,
+      "good": 71592.0338,
+      "ratio": 1.1627,
+      "suggested_scalar": 0.155,
+      "log_bad": 11.028,
+      "log_good": 11.1787
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.867,
+      "good": 0.8259,
+      "ratio": 0.9526,
+      "suggested_scalar": -0.0499,
+      "log_bad": -0.1427,
+      "log_good": -0.1913
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 81.0,
+      "good": 60.0,
+      "ratio": 0.7407,
+      "suggested_scalar": -0.3084,
+      "log_bad": 4.3944,
+      "log_good": 4.0943
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 183.0,
+      "good": 255.0,
+      "ratio": 1.3934,
+      "suggested_scalar": 0.341,
+      "log_bad": 5.2095,
+      "log_good": 5.5413
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4898,
+      "good": 0.5112,
+      "ratio": 1.0437,
+      "suggested_scalar": 0.044,
+      "log_bad": -0.7138,
+      "log_good": -0.671
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0884,
+      "good": 6.2921,
+      "ratio": 1.0335,
+      "suggested_scalar": 0.0338,
+      "log_bad": 1.8064,
+      "log_good": 1.8393
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1304,
+      "good": 0.1132,
+      "ratio": 0.8681,
+      "suggested_scalar": -0.1454,
+      "log_bad": -2.0371,
+      "log_good": -2.1786
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.4727,
+      "good": 5.1845,
+      "ratio": 1.1591,
+      "suggested_scalar": 0.1518,
+      "log_bad": 1.498,
+      "log_good": 1.6457
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 368.0,
+      "good": 506.0,
+      "ratio": 1.375,
+      "suggested_scalar": 0.3273,
+      "log_bad": 5.9081,
+      "log_good": 6.2265
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.7124,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 34.0,
+      "good": 55.0,
+      "ratio": 1.6176,
+      "suggested_scalar": 0.4943,
+      "log_bad": 3.5264,
+      "log_good": 4.0073
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3420.6888,
+      "good": 3977.3352,
+      "ratio": 1.1627,
+      "suggested_scalar": 0.155,
+      "log_bad": 8.1376,
+      "log_good": 8.2884
+    },
+    "readability.mean_total_lines": {
+      "bad": 33.0,
+      "good": 47.0,
+      "ratio": 1.4242,
+      "suggested_scalar": 0.3635,
+      "log_bad": 3.4965,
+      "log_good": 3.8501
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.4167,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2339.289,
+      "good": 2454.584,
+      "ratio": 1.0493,
+      "suggested_scalar": 0.0494,
+      "log_bad": 7.7576,
+      "log_good": 7.8057
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 644.0,
+      "good": 766.0,
+      "ratio": 1.1894,
+      "suggested_scalar": 0.1783,
+      "log_bad": 6.4677,
+      "log_good": 6.6412
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.2727,
+      "good": 40.3404,
+      "ratio": 1.29,
+      "suggested_scalar": 0.2617,
+      "log_bad": 3.4427,
+      "log_good": 3.6974
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1907,
+      "good": 1.1957,
+      "ratio": 1.0042,
+      "suggested_scalar": 0.0043,
+      "log_bad": 0.1745,
+      "log_good": 0.1787
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.4167,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 18.0,
+      "good": 16.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.1211,
+      "log_bad": 2.8904,
+      "log_good": 2.7726
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 1.0,
+      "ratio": 0.1429,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.9459,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8855,
+      "good": 0.8397,
+      "ratio": 0.9483,
+      "suggested_scalar": -0.0546,
+      "log_bad": -0.1216,
+      "log_good": -0.1747
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 5.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.9418,
+      "log_bad": 0.6931,
+      "log_good": 1.6094
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.956,
+      "good": 0.9488,
+      "ratio": 0.9925,
+      "suggested_scalar": -0.0078,
+      "log_bad": -0.045,
+      "log_good": -0.0526
+    },
+    "halstead.mean_length": {
+      "bad": 347.0,
+      "good": 380.0,
+      "ratio": 1.0951,
+      "suggested_scalar": 0.0934,
+      "log_bad": 5.8493,
+      "log_good": 5.9402
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.1667,
+      "good": 4.0,
+      "ratio": 0.6486,
+      "suggested_scalar": -0.4449,
+      "log_bad": 1.8192,
+      "log_good": 1.3863
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7682,
+      "good": 7.0334,
+      "ratio": 1.0392,
+      "suggested_scalar": 0.0395,
+      "log_bad": 1.9122,
+      "log_good": 1.9507
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1147,
+      "good": 0.1411,
+      "ratio": 1.2302,
+      "suggested_scalar": 0.2129,
+      "log_bad": -2.1654,
+      "log_good": -1.9583
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 26.321,
+      "good": 29.1667,
+      "ratio": 1.1081,
+      "suggested_scalar": 0.1055,
+      "log_bad": 3.2704,
+      "log_good": 3.373
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.1874,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 72.0,
+      "good": 91.0,
+      "ratio": 1.2639,
+      "suggested_scalar": 0.2407,
+      "log_bad": 4.2767,
+      "log_good": 4.5109
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7467,
+      "good": 0.7068,
+      "ratio": 0.9466,
+      "suggested_scalar": -0.0564,
+      "log_bad": -0.2921,
+      "log_good": -0.347
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 40.0,
+      "good": 47.0,
+      "ratio": 1.175,
+      "suggested_scalar": 0.1658,
+      "log_bad": 3.6889,
+      "log_good": 3.8501
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 16.0,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.0663,
+      "log_bad": 2.7081,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "variable_naming.name_is_abbreviation": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 30.0,
+      "good": 32.0,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.4951,
+      "log_bad": 3.4012,
+      "log_good": 3.4657
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 43.6667,
+      "good": 43.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7766,
+      "log_good": 3.7766
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0116,
+      "good": 0.0111,
+      "ratio": 0.9569,
+      "suggested_scalar": -0.338,
+      "log_bad": -4.4568,
+      "log_good": -4.5008
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.9167,
+      "good": 1.9167,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6506,
+      "log_good": 0.6506
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7005,
+      "good": 0.718,
+      "ratio": 1.025,
+      "suggested_scalar": 0.1893,
+      "log_bad": -0.356,
+      "log_good": -0.3313
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.021,
+      "good": 0.0206,
+      "ratio": 0.981,
+      "suggested_scalar": -0.1475,
+      "log_bad": -3.8632,
+      "log_good": -3.8825
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8399,
+      "good": 4.801,
+      "ratio": 0.992,
+      "suggested_scalar": -0.0619,
+      "log_bad": 1.5769,
+      "log_good": 1.5688
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 99.6667,
+      "good": 95.3333,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.341,
+      "log_bad": 4.6018,
+      "log_good": 4.5574
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4266,
+      "good": 0.3955,
+      "ratio": 0.9271,
+      "suggested_scalar": -0.5807,
+      "log_bad": -0.8519,
+      "log_good": -0.9276
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.4626,
+      "good": 0.4528,
+      "ratio": 0.9788,
+      "suggested_scalar": -0.1643,
+      "log_bad": -0.7709,
+      "log_good": -0.7923
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.2971,
+      "good": 3.2971,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.193,
+      "log_good": 1.193
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 791.3333,
+      "good": 774.0,
+      "ratio": 0.9781,
+      "suggested_scalar": -0.1699,
+      "log_bad": 6.6737,
+      "log_good": 6.6516
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.6667,
+      "good": 3.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.2993,
+      "log_good": 1.2993
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0011,
+      "good": 0.001,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.7311,
+      "log_bad": -6.8124,
+      "log_good": -6.9078
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.018,
+      "good": 0.018,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.0174,
+      "log_good": -4.0174
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0009,
+      "good": 0.0008,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.9035,
+      "log_bad": -7.0131,
+      "log_good": -7.1309
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.2364,
+      "good": 1.2516,
+      "ratio": 1.0123,
+      "suggested_scalar": 0.0937,
+      "log_bad": 0.2122,
+      "log_good": 0.2244
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 263.3333,
+      "good": 256.6667,
+      "ratio": 0.9747,
+      "suggested_scalar": -0.1967,
+      "log_bad": 5.5734,
+      "log_good": 5.5478
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.678,
+      "good": 101.5556,
+      "ratio": 0.9988,
+      "suggested_scalar": -0.0092,
+      "log_bad": 4.6218,
+      "log_good": 4.6206
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.8027,
+      "good": 0.7989,
+      "ratio": 0.9953,
+      "suggested_scalar": -0.0364,
+      "log_bad": -0.2198,
+      "log_good": -0.2245
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.7238,
+      "good": 8.5594,
+      "ratio": 1.1082,
+      "suggested_scalar": 0.788,
+      "log_bad": 2.0443,
+      "log_good": 2.147
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2590.6667,
+      "good": 2884.6667,
+      "ratio": 1.1135,
+      "suggested_scalar": 0.8246,
+      "log_bad": 7.8597,
+      "log_good": 7.9672
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0989,
+      "good": 0.0989,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.3136,
+      "log_good": -2.3136
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6689,
+      "good": 0.6864,
+      "ratio": 1.0262,
+      "suggested_scalar": 0.1981,
+      "log_bad": -0.4021,
+      "log_good": -0.3763
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.9681,
+      "good": 10.7277,
+      "ratio": 0.9781,
+      "suggested_scalar": -0.17,
+      "log_bad": 2.395,
+      "log_good": 2.3728
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.476,
+      "good": 3.476,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.2459,
+      "log_good": 1.2459
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 216.3333,
+      "good": 209.0,
+      "ratio": 0.9661,
+      "suggested_scalar": -0.2645,
+      "log_bad": 5.3768,
+      "log_good": 5.3423
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9336,
+      "good": 0.9306,
+      "ratio": 0.9968,
+      "suggested_scalar": -0.0247,
+      "log_bad": -0.0687,
+      "log_good": -0.0719
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.3333,
+      "good": 25.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2321,
+      "log_good": 3.2321
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6844,
+      "good": 0.7122,
+      "ratio": 1.0406,
+      "suggested_scalar": 0.3054,
+      "log_bad": -0.3792,
+      "log_good": -0.3394
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.6792,
+      "good": 0.6677,
+      "ratio": 0.9831,
+      "suggested_scalar": -0.131,
+      "log_bad": -0.3868,
+      "log_good": -0.4039
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.1707,
+      "good": 3.4789,
+      "ratio": 1.0972,
+      "suggested_scalar": 0.7116,
+      "log_bad": 1.154,
+      "log_good": 1.2467
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 789.3333,
+      "good": 772.0,
+      "ratio": 0.978,
+      "suggested_scalar": -0.1703,
+      "log_bad": 6.6712,
+      "log_good": 6.649
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0464,
+      "good": 0.0426,
+      "ratio": 0.9181,
+      "suggested_scalar": -0.6554,
+      "log_bad": -3.0705,
+      "log_good": -3.1559
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0147,
+      "good": 6.0364,
+      "ratio": 1.0036,
+      "suggested_scalar": 0.0276,
+      "log_bad": 1.7942,
+      "log_good": 1.7978
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 37.0,
+      "good": 37.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6109,
+      "log_good": 3.6109
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7222,
+      "good": 0.7408,
+      "ratio": 1.0258,
+      "suggested_scalar": 0.1951,
+      "log_bad": -0.3255,
+      "log_good": -0.3
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5611,
+      "good": 5.519,
+      "ratio": 0.9924,
+      "suggested_scalar": -0.0583,
+      "log_bad": 1.7158,
+      "log_good": 1.7082
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8048,
+      "good": 0.7955,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0892,
+      "log_bad": -0.2172,
+      "log_good": -0.2288
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.206,
+      "good": 0.206,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.5799,
+      "log_good": -1.5799
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.7751,
+      "good": 2.9221,
+      "ratio": 1.053,
+      "suggested_scalar": 0.3959,
+      "log_bad": 1.0207,
+      "log_good": 1.0723
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 393.3333,
+      "good": 390.6667,
+      "ratio": 0.9932,
+      "suggested_scalar": -0.0522,
+      "log_bad": 5.9747,
+      "log_good": 5.9679
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 29.3333,
+      "good": 28.6667,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.1763,
+      "log_bad": 3.3787,
+      "log_good": 3.3557
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.5664,
+      "good": 1.5181,
+      "ratio": 0.9692,
+      "suggested_scalar": -0.2403,
+      "log_bad": 0.4488,
+      "log_good": 0.4175
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 108.3333,
+      "good": 105.0,
+      "ratio": 0.9692,
+      "suggested_scalar": -0.2397,
+      "log_bad": 4.6852,
+      "log_good": 4.654
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1280.3333,
+      "good": 1587.3333,
+      "ratio": 1.2398,
+      "suggested_scalar": 1.6488,
+      "log_bad": 7.1549,
+      "log_good": 7.3698
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 261.6667,
+      "good": 256.0,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.1679,
+      "log_bad": 5.5671,
+      "log_good": 5.5452
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0063,
+      "good": 0.0066,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.3569,
+      "log_bad": -5.0672,
+      "log_good": -5.0207
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.29,
+      "good": 0.2876,
+      "ratio": 0.9917,
+      "suggested_scalar": -0.0637,
+      "log_bad": -1.2379,
+      "log_good": -1.2462
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 136.3333,
+      "good": 134.6667,
+      "ratio": 0.9878,
+      "suggested_scalar": -0.0944,
+      "log_bad": 4.9151,
+      "log_good": 4.9028
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 108.3333,
+      "good": 105.0,
+      "ratio": 0.9692,
+      "suggested_scalar": -0.2397,
+      "log_bad": 4.6852,
+      "log_good": 4.654
+    },
+    "brevity.mean_sample_size": {
+      "bad": 108.3333,
+      "good": 105.0,
+      "ratio": 0.9692,
+      "suggested_scalar": -0.2397,
+      "log_bad": 4.6852,
+      "log_good": 4.654
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 791.3333,
+      "good": 774.0,
+      "ratio": 0.9781,
+      "suggested_scalar": -0.1699,
+      "log_bad": 6.6737,
+      "log_good": 6.6516
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 464.6667,
+      "good": 453.3333,
+      "ratio": 0.9756,
+      "suggested_scalar": -0.1894,
+      "log_bad": 6.1413,
+      "log_good": 6.1166
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 291.6667,
+      "good": 289.6667,
+      "ratio": 0.9931,
+      "suggested_scalar": -0.0528,
+      "log_bad": 5.6756,
+      "log_good": 5.6687
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0013,
+      "good": 0.0014,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.5685,
+      "log_bad": -6.6454,
+      "log_good": -6.5713
+    },
+    "heaps.mean_k": {
+      "bad": 5.3136,
+      "good": 5.5675,
+      "ratio": 1.0478,
+      "suggested_scalar": 0.3581,
+      "log_bad": 1.6703,
+      "log_good": 1.7169
+    },
+    "halstead.mean_effort": {
+      "bad": 207663.97,
+      "good": 208968.1108,
+      "ratio": 1.0063,
+      "suggested_scalar": 0.048,
+      "log_bad": 12.2437,
+      "log_good": 12.2499
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8229,
+      "good": 0.8221,
+      "ratio": 0.999,
+      "suggested_scalar": -0.0075,
+      "log_bad": -0.1949,
+      "log_good": -0.1959
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 74.3333,
+      "good": 70.0,
+      "ratio": 0.9417,
+      "suggested_scalar": -0.4607,
+      "log_bad": 4.3086,
+      "log_good": 4.2485
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 446.0,
+      "good": 436.3333,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.1681,
+      "log_bad": 6.1003,
+      "log_good": 6.0784
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.2867,
+      "good": 0.2816,
+      "ratio": 0.9822,
+      "suggested_scalar": -0.1377,
+      "log_bad": -1.2493,
+      "log_good": -1.2673
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.8807,
+      "good": 6.1936,
+      "ratio": 1.269,
+      "suggested_scalar": 1.8274,
+      "log_bad": 1.5853,
+      "log_good": 1.8235
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.206,
+      "good": 0.206,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.5799,
+      "log_good": -1.5799
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.7089,
+      "good": 4.6182,
+      "ratio": 0.9807,
+      "suggested_scalar": -0.1492,
+      "log_bad": 1.5495,
+      "log_good": 1.53
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 790.3333,
+      "good": 773.0,
+      "ratio": 0.9781,
+      "suggested_scalar": -0.1701,
+      "log_bad": 6.6725,
+      "log_good": 6.6503
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 16.6667,
+      "good": 15.6667,
+      "ratio": 0.94,
+      "suggested_scalar": -0.4746,
+      "log_bad": 2.8134,
+      "log_good": 2.7515
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 141.3333,
+      "good": 135.6667,
+      "ratio": 0.9599,
+      "suggested_scalar": -0.3139,
+      "log_bad": 4.9511,
+      "log_good": 4.9102
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 11536.8872,
+      "good": 11609.3395,
+      "ratio": 1.0063,
+      "suggested_scalar": 0.048,
+      "log_bad": 9.3533,
+      "log_good": 9.3596
+    },
+    "readability.mean_total_lines": {
+      "bad": 72.6667,
+      "good": 72.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2859,
+      "log_good": 4.2859
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.6667,
+      "good": 6.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8971,
+      "log_good": 1.8971
+    },
+    "halstead.mean_volume": {
+      "bad": 4699.2053,
+      "good": 4554.1596,
+      "ratio": 0.9691,
+      "suggested_scalar": -0.2405,
+      "log_bad": 8.4551,
+      "log_good": 8.4238
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 817.0,
+      "good": 828.6667,
+      "ratio": 1.0143,
+      "suggested_scalar": 0.1088,
+      "log_bad": 6.7056,
+      "log_good": 6.7198
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 33.9607,
+      "good": 37.9804,
+      "ratio": 1.1184,
+      "suggested_scalar": 0.8581,
+      "log_bad": 3.5252,
+      "log_good": 3.6371
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1114,
+      "good": 1.1157,
+      "ratio": 1.0039,
+      "suggested_scalar": 0.0296,
+      "log_bad": 0.1056,
+      "log_good": 0.1095
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.6667,
+      "good": 3.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.2993,
+      "log_good": 1.2993
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 42.3333,
+      "good": 41.3333,
+      "ratio": 0.9764,
+      "suggested_scalar": -0.1834,
+      "log_bad": 3.7456,
+      "log_good": 3.7217
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6409,
+      "good": 0.6529,
+      "ratio": 1.0187,
+      "suggested_scalar": 0.1423,
+      "log_bad": -0.4449,
+      "log_good": -0.4263
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9699,
+      "good": 0.9647,
+      "ratio": 0.9946,
+      "suggested_scalar": -0.0412,
+      "log_bad": -0.0306,
+      "log_good": -0.0359
+    },
+    "halstead.mean_length": {
+      "bad": 707.6667,
+      "good": 692.3333,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.168,
+      "log_bad": 6.562,
+      "log_good": 6.5401
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.7917,
+      "good": 10.7917,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3788,
+      "log_good": 2.3788
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7581,
+      "good": 6.713,
+      "ratio": 0.9933,
+      "suggested_scalar": -0.0514,
+      "log_bad": 1.9107,
+      "log_good": 1.904
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1794,
+      "good": 0.1573,
+      "ratio": 0.8768,
+      "suggested_scalar": -1.0085,
+      "log_bad": -1.7181,
+      "log_good": -1.8496
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 44.3503,
+      "good": 46.2093,
+      "ratio": 1.0419,
+      "suggested_scalar": 0.315,
+      "log_bad": 3.7921,
+      "log_good": 3.8332
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.3333,
+      "good": 7.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9924,
+      "log_good": 1.9924
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 75.0,
+      "good": 71.6667,
+      "ratio": 0.9556,
+      "suggested_scalar": -0.3487,
+      "log_bad": 4.3175,
+      "log_good": 4.272
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5327,
+      "good": 0.5348,
+      "ratio": 1.0039,
+      "suggested_scalar": 0.0302,
+      "log_bad": -0.6298,
+      "log_good": -0.6259
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 73.3333,
+      "good": 73.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.295,
+      "log_good": 4.295
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.6667,
+      "good": 20.3333,
+      "ratio": 1.2979,
+      "suggested_scalar": 2.0,
+      "log_bad": 2.7515,
+      "log_good": 3.0123
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.no_hungarian_notation": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 44.0,
+      "good": 15.0,
+      "ratio": 0.3409,
+      "suggested_scalar": -1.4943,
+      "log_bad": 3.7842,
+      "log_good": 2.7081
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0098,
+      "good": 0.0098,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.6254,
+      "log_good": -4.6254
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6667,
+      "good": 1.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.5108,
+      "log_good": 0.5108
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8696,
+      "good": 0.8696,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1397,
+      "log_good": -0.1397
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0098,
+      "good": 0.0098,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.6254,
+      "log_good": -4.6254
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5918,
+      "good": 4.4756,
+      "ratio": 0.9747,
+      "suggested_scalar": -0.0356,
+      "log_bad": 1.5243,
+      "log_good": 1.4986
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 76.0,
+      "good": 76.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3307,
+      "log_good": 4.3307
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4875,
+      "good": 0.4675,
+      "ratio": 0.959,
+      "suggested_scalar": -0.0582,
+      "log_bad": -0.7185,
+      "log_good": -0.7604
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.73,
+      "good": 0.7212,
+      "ratio": 0.9879,
+      "suggested_scalar": -0.0168,
+      "log_bad": -0.3147,
+      "log_good": -0.3268
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 9.5652,
+      "good": 9.5652,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.2581,
+      "log_good": 2.2581
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 305.0,
+      "good": 305.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.7203,
+      "log_good": 5.7203
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0009,
+      "good": 0.001,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.1463,
+      "log_bad": -7.0131,
+      "log_good": -6.9078
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9453,
+      "good": 0.9531,
+      "ratio": 1.0083,
+      "suggested_scalar": 0.0114,
+      "log_bad": -0.0563,
+      "log_good": -0.048
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 107.0,
+      "good": 107.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.6728,
+      "log_good": 4.6728
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 49.7051,
+      "good": 79.5639,
+      "ratio": 1.6007,
+      "suggested_scalar": 0.6532,
+      "log_bad": 3.9061,
+      "log_good": 4.3766
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4967,
+      "good": 0.4967,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.6998,
+      "log_good": -0.6998
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 27.3849,
+      "good": 25.9757,
+      "ratio": 0.9485,
+      "suggested_scalar": -0.0734,
+      "log_bad": 3.31,
+      "log_good": 3.2572
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2157.0,
+      "good": 2015.0,
+      "ratio": 0.9342,
+      "suggested_scalar": -0.0946,
+      "log_bad": 7.6765,
+      "log_good": 7.6084
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1087,
+      "good": 0.1087,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.2192,
+      "log_good": -2.2192
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7391,
+      "good": 0.7391,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3023,
+      "log_good": -0.3023
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.6304,
+      "good": 6.6304,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8917,
+      "log_good": 1.8917
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 21.8979,
+      "good": 21.8979,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0864,
+      "log_good": 3.0864
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 9.0,
+      "good": 38.0,
+      "ratio": 4.2222,
+      "suggested_scalar": 2.0,
+      "log_bad": 2.1972,
+      "log_good": 3.6376
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9515,
+      "good": 0.9496,
+      "ratio": 0.998,
+      "suggested_scalar": -0.0028,
+      "log_bad": -0.0497,
+      "log_good": -0.0517
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6903,
+      "good": 0.6749,
+      "ratio": 0.9777,
+      "suggested_scalar": -0.0313,
+      "log_bad": -0.3706,
+      "log_good": -0.3932
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2937,
+      "good": 0.2937,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.2252,
+      "log_good": -1.2252
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.229,
+      "good": 3.0763,
+      "ratio": 0.9527,
+      "suggested_scalar": -0.0673,
+      "log_bad": 1.1722,
+      "log_good": 1.1237
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 303.0,
+      "good": 303.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.7137,
+      "log_good": 5.7137
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0,
+      "good": 5.9773,
+      "ratio": 0.9962,
+      "suggested_scalar": -0.0053,
+      "log_bad": 1.7918,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 44.0,
+      "good": 44.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7842,
+      "log_good": 3.7842
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.6744,
+      "good": 1.7746,
+      "ratio": 1.0598,
+      "suggested_scalar": 0.0807,
+      "log_bad": 0.5155,
+      "log_good": 0.5736
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.593,
+      "good": 5.5705,
+      "ratio": 0.996,
+      "suggested_scalar": -0.0056,
+      "log_bad": 1.7215,
+      "log_good": 1.7175
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7653,
+      "good": 0.7488,
+      "ratio": 0.9784,
+      "suggested_scalar": -0.0303,
+      "log_bad": -0.2675,
+      "log_good": -0.2893
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.193,
+      "good": 0.193,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.6451,
+      "log_good": -1.6451
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 5.2331,
+      "good": 5.0966,
+      "ratio": 0.9739,
+      "suggested_scalar": -0.0367,
+      "log_bad": 1.655,
+      "log_good": 1.6286
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 252.0,
+      "good": 252.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.5294,
+      "log_good": 5.5294
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5831,
+      "good": 0.5831,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.5394,
+      "log_good": -0.5394
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 87.0,
+      "good": 85.0,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0323,
+      "log_bad": 4.4659,
+      "log_good": 4.4427
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1204.0,
+      "good": 1062.0,
+      "ratio": 0.8821,
+      "suggested_scalar": -0.1743,
+      "log_bad": 7.0934,
+      "log_good": 6.9679
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 117.0,
+      "good": 117.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.7622,
+      "log_good": 4.7622
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2656,
+      "good": 0.2656,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.3258,
+      "log_good": -1.3258
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 51.0,
+      "good": 51.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9318,
+      "log_good": 3.9318
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 87.0,
+      "good": 85.0,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0323,
+      "log_bad": 4.4659,
+      "log_good": 4.4427
+    },
+    "brevity.mean_sample_size": {
+      "bad": 87.0,
+      "good": 85.0,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0323,
+      "log_bad": 4.4659,
+      "log_good": 4.4427
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 305.0,
+      "good": 305.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.7203,
+      "log_good": 5.7203
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 151.0,
+      "good": 151.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.0173,
+      "log_good": 5.0173
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 204.0,
+      "good": 204.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.3181,
+      "log_good": 5.3181
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.4798,
+      "good": 1.5286,
+      "ratio": 1.033,
+      "suggested_scalar": 0.0451,
+      "log_bad": 0.3919,
+      "log_good": 0.4244
+    },
+    "halstead.mean_effort": {
+      "bad": 47234.332,
+      "good": 47234.332,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 10.7629,
+      "log_good": 10.7629
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8681,
+      "good": 0.8691,
+      "ratio": 1.0012,
+      "suggested_scalar": 0.0016,
+      "log_bad": -0.1414,
+      "log_good": -0.1403
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 52.0,
+      "good": 52.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9512,
+      "log_good": 3.9512
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 163.0,
+      "good": 163.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.0938,
+      "log_good": 5.0938
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.486,
+      "good": 0.4673,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0545,
+      "log_bad": -0.7215,
+      "log_good": -0.7608
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 11.2523,
+      "good": 9.9252,
+      "ratio": 0.8821,
+      "suggested_scalar": -0.1743,
+      "log_bad": 2.4206,
+      "log_good": 2.2951
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.193,
+      "good": 0.193,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.6451,
+      "log_good": -1.6451
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 11.8025,
+      "good": 6.3123,
+      "ratio": 0.5348,
+      "suggested_scalar": -0.869,
+      "log_bad": 2.4683,
+      "log_good": 1.8425
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 304.0,
+      "good": 304.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.717,
+      "log_good": 5.717
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 38.0,
+      "good": 38.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6376,
+      "log_good": 3.6376
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2624.1296,
+      "good": 2624.1296,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 7.8725,
+      "log_good": 7.8725
+    },
+    "readability.mean_total_lines": {
+      "bad": 46.0,
+      "good": 46.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8286,
+      "log_good": 3.8286
+    },
+    "indentation.mean_max_depth": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "halstead.mean_volume": {
+      "bad": 1749.4197,
+      "good": 1749.4197,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 7.467,
+      "log_good": 7.467
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 668.0,
+      "good": 655.0,
+      "ratio": 0.9805,
+      "suggested_scalar": -0.0273,
+      "log_bad": 6.5043,
+      "log_good": 6.4846
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 45.6522,
+      "good": 42.5652,
+      "ratio": 0.9324,
+      "suggested_scalar": -0.0972,
+      "log_bad": 3.8211,
+      "log_good": 3.751
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.7778,
+      "good": 1.4248,
+      "ratio": 0.8014,
+      "suggested_scalar": -0.3073,
+      "log_bad": 0.5754,
+      "log_good": 0.354
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8492,
+      "good": 0.8492,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1635,
+      "log_good": -0.1635
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9889,
+      "good": 0.9872,
+      "ratio": 0.9983,
+      "suggested_scalar": -0.0024,
+      "log_bad": -0.0112,
+      "log_good": -0.0129
+    },
+    "halstead.mean_length": {
+      "bad": 280.0,
+      "good": 280.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.6348,
+      "log_good": 5.6348
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 13.6667,
+      "good": 13.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.615,
+      "log_good": 2.615
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4429,
+      "good": 6.4094,
+      "ratio": 0.9948,
+      "suggested_scalar": -0.0072,
+      "log_bad": 1.863,
+      "log_good": 1.8578
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.07,
+      "good": 0.0749,
+      "ratio": 1.07,
+      "suggested_scalar": 0.0939,
+      "log_bad": -2.6593,
+      "log_good": -2.5916
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 52.0,
+      "good": 50.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0545,
+      "log_bad": 3.9512,
+      "log_good": 3.912
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.75,
+      "good": 0.75,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2877,
+      "log_good": -0.2877
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 46.0,
+      "good": 46.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8286,
+      "log_good": 3.8286
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 26.0,
+      "good": 26.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2581,
+      "log_good": 3.2581
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_unparameterized_generic": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 34.0,
+      "good": 54.0,
+      "ratio": 1.5882,
+      "suggested_scalar": 0.1319,
+      "log_bad": 3.5264,
+      "log_good": 3.989
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0358,
+      "good": 0.0443,
+      "ratio": 1.2374,
+      "suggested_scalar": 0.0608,
+      "log_bad": -3.3298,
+      "log_good": -3.1168
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9231,
+      "good": 0.9077,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0048,
+      "log_bad": -0.08,
+      "log_good": -0.0968
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0358,
+      "good": 0.0443,
+      "ratio": 1.2374,
+      "suggested_scalar": 0.0608,
+      "log_bad": -3.3298,
+      "log_good": -3.1168
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5246,
+      "good": 4.5833,
+      "ratio": 1.013,
+      "suggested_scalar": 0.0037,
+      "log_bad": 1.5095,
+      "log_good": 1.5224
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 101.0,
+      "good": 90.0,
+      "ratio": 0.8911,
+      "suggested_scalar": -0.0329,
+      "log_bad": 4.6151,
+      "log_good": 4.4998
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5175,
+      "good": 0.4734,
+      "ratio": 0.9148,
+      "suggested_scalar": -0.0254,
+      "log_bad": -0.6587,
+      "log_good": -0.7478
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.0,
+      "good": 18.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.044,
+      "log_bad": 3.0445,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7126,
+      "good": 0.6334,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0336,
+      "log_bad": -0.3388,
+      "log_good": -0.4567
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.6154,
+      "good": 3.8154,
+      "ratio": 1.0553,
+      "suggested_scalar": 0.0154,
+      "log_bad": 1.2852,
+      "log_good": 1.339
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 447.0,
+      "good": 519.0,
+      "ratio": 1.1611,
+      "suggested_scalar": 0.0426,
+      "log_bad": 6.1026,
+      "log_good": 6.2519
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0009,
+      "good": 1.0,
+      "ratio": 1111.1111,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.0131,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9302,
+      "good": 1.0239,
+      "ratio": 1.1007,
+      "suggested_scalar": 0.0274,
+      "log_bad": -0.0724,
+      "log_good": 0.0236
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 210.0,
+      "good": 201.0,
+      "ratio": 0.9571,
+      "suggested_scalar": -0.0125,
+      "log_bad": 5.3471,
+      "log_good": 5.3033
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 107.2064,
+      "good": 105.8614,
+      "ratio": 0.9875,
+      "suggested_scalar": -0.0036,
+      "log_bad": 4.6748,
+      "log_good": 4.6621
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4731,
+      "good": 0.5232,
+      "ratio": 1.1059,
+      "suggested_scalar": 0.0287,
+      "log_bad": -0.7484,
+      "log_good": -0.6478
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.2958,
+      "good": 11.5055,
+      "ratio": 1.1175,
+      "suggested_scalar": 0.0317,
+      "log_bad": 2.3317,
+      "log_good": 2.4428
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2137.0,
+      "good": 2232.0,
+      "ratio": 1.0445,
+      "suggested_scalar": 0.0124,
+      "log_bad": 7.6672,
+      "log_good": 7.7107
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1538,
+      "good": 0.2,
+      "ratio": 1.3004,
+      "suggested_scalar": 0.0749,
+      "log_bad": -1.8721,
+      "log_good": -1.6094
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9231,
+      "good": 0.8923,
+      "ratio": 0.9666,
+      "suggested_scalar": -0.0097,
+      "log_bad": -0.08,
+      "log_good": -0.114
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.5962,
+      "good": 7.9846,
+      "ratio": 0.9289,
+      "suggested_scalar": -0.021,
+      "log_bad": 2.1513,
+      "log_good": 2.0775
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 10.6213,
+      "good": 10.5505,
+      "ratio": 0.9933,
+      "suggested_scalar": -0.0019,
+      "log_bad": 2.3629,
+      "log_good": 2.3562
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 159.0,
+      "good": 171.0,
+      "ratio": 1.0755,
+      "suggested_scalar": 0.0207,
+      "log_bad": 5.0689,
+      "log_good": 5.1417
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9507,
+      "good": 0.9542,
+      "ratio": 1.0037,
+      "suggested_scalar": 0.001,
+      "log_bad": -0.0506,
+      "log_good": -0.0469
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 28.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.044,
+      "log_bad": 3.1781,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6168,
+      "good": 0.6214,
+      "ratio": 1.0075,
+      "suggested_scalar": 0.0021,
+      "log_bad": -0.4832,
+      "log_good": -0.4758
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2876,
+      "good": 0.3617,
+      "ratio": 1.2576,
+      "suggested_scalar": 0.0654,
+      "log_bad": -1.2462,
+      "log_good": -1.0169
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6093,
+      "good": 2.6414,
+      "ratio": 1.0123,
+      "suggested_scalar": 0.0035,
+      "log_bad": 0.9591,
+      "log_good": 0.9713
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 445.0,
+      "good": 517.0,
+      "ratio": 1.1618,
+      "suggested_scalar": 0.0428,
+      "log_bad": 6.0981,
+      "log_good": 6.248
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 14.0,
+      "good": 18.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.0717,
+      "log_bad": 2.6391,
+      "log_good": 2.8904
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0582,
+      "good": 0.0501,
+      "ratio": 0.8608,
+      "suggested_scalar": -0.0427,
+      "log_bad": -2.8439,
+      "log_good": -2.9937
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 5.8074,
+      "ratio": 0.9792,
+      "suggested_scalar": -0.006,
+      "log_bad": 1.7801,
+      "log_good": 1.7591
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 50.0,
+      "good": 29.0,
+      "ratio": 0.58,
+      "suggested_scalar": -0.1553,
+      "log_bad": 3.912,
+      "log_good": 3.3673
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8336,
+      "good": 0.6394,
+      "ratio": 0.767,
+      "suggested_scalar": -0.0756,
+      "log_bad": -0.182,
+      "log_good": -0.4472
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.1115,
+      "good": 5.8728,
+      "ratio": 0.9609,
+      "suggested_scalar": -0.0114,
+      "log_bad": 1.8102,
+      "log_good": 1.7703
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7629,
+      "good": 0.7892,
+      "ratio": 1.0345,
+      "suggested_scalar": 0.0097,
+      "log_bad": -0.2706,
+      "log_good": -0.2367
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.3133,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2,
+      "good": 0.1875,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0184,
+      "log_bad": -1.6094,
+      "log_good": -1.674
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.2087,
+      "good": 3.392,
+      "ratio": 1.0571,
+      "suggested_scalar": 0.0158,
+      "log_bad": 1.1659,
+      "log_good": 1.2214
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 362.0,
+      "good": 389.0,
+      "ratio": 1.0746,
+      "suggested_scalar": 0.0205,
+      "log_bad": 5.8916,
+      "log_good": 5.9636
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 16.0,
+      "ratio": 8.0,
+      "suggested_scalar": 0.593,
+      "log_bad": 0.6931,
+      "log_good": 2.7726
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7923,
+      "good": 0.9262,
+      "ratio": 1.169,
+      "suggested_scalar": 0.0445,
+      "log_bad": -0.2328,
+      "log_good": -0.0767
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 123.0,
+      "good": 119.0,
+      "ratio": 0.9675,
+      "suggested_scalar": -0.0094,
+      "log_bad": 4.8122,
+      "log_good": 4.7791
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1164.0,
+      "good": 1215.0,
+      "ratio": 1.0438,
+      "suggested_scalar": 0.0122,
+      "log_bad": 7.0596,
+      "log_good": 7.1025
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 195.0,
+      "good": 187.0,
+      "ratio": 0.959,
+      "suggested_scalar": -0.0119,
+      "log_bad": 5.273,
+      "log_good": 5.2311
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0089,
+      "good": 0.0096,
+      "ratio": 1.0787,
+      "suggested_scalar": 0.0216,
+      "log_bad": -4.7217,
+      "log_good": -4.646
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2215,
+      "good": 0.262,
+      "ratio": 1.1828,
+      "suggested_scalar": 0.0479,
+      "log_bad": -1.5073,
+      "log_good": -1.3394
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 68.0,
+      "good": 73.0,
+      "ratio": 1.0735,
+      "suggested_scalar": 0.0202,
+      "log_bad": 4.2195,
+      "log_good": 4.2905
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0636,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 123.0,
+      "good": 119.0,
+      "ratio": 0.9675,
+      "suggested_scalar": -0.0094,
+      "log_bad": 4.8122,
+      "log_good": 4.7791
+    },
+    "brevity.mean_sample_size": {
+      "bad": 123.0,
+      "good": 119.0,
+      "ratio": 0.9675,
+      "suggested_scalar": -0.0094,
+      "log_bad": 4.8122,
+      "log_good": 4.7791
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 447.0,
+      "good": 519.0,
+      "ratio": 1.1611,
+      "suggested_scalar": 0.0426,
+      "log_bad": 6.1026,
+      "log_good": 6.2519
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 192.0,
+      "good": 251.0,
+      "ratio": 1.3073,
+      "suggested_scalar": 0.0764,
+      "log_bad": 5.2575,
+      "log_good": 5.5255
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 303.0,
+      "good": 320.0,
+      "ratio": 1.0561,
+      "suggested_scalar": 0.0156,
+      "log_bad": 5.7137,
+      "log_good": 5.7683
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0019,
+      "ratio": 0.0019,
+      "suggested_scalar": -1.7869,
+      "log_bad": 0.0,
+      "log_good": -6.2659
+    },
+    "heaps.mean_k": {
+      "bad": 1.8507,
+      "good": 2.3974,
+      "ratio": 1.2954,
+      "suggested_scalar": 0.0738,
+      "log_bad": 0.6156,
+      "log_good": 0.8744
+    },
+    "halstead.mean_effort": {
+      "bad": 72235.5417,
+      "good": 117324.9574,
+      "ratio": 1.6242,
+      "suggested_scalar": 0.1383,
+      "log_bad": 11.1877,
+      "log_good": 11.6727
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1977,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8803,
+      "good": 0.8518,
+      "ratio": 0.9676,
+      "suggested_scalar": -0.0094,
+      "log_bad": -0.1275,
+      "log_good": -0.1604
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 77.0,
+      "good": 62.0,
+      "ratio": 0.8052,
+      "suggested_scalar": -0.0618,
+      "log_bad": 4.3438,
+      "log_good": 4.1271
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 162.0,
+      "good": 241.0,
+      "ratio": 1.4877,
+      "suggested_scalar": 0.1133,
+      "log_bad": 5.0876,
+      "log_good": 5.4848
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4143,
+      "good": 0.398,
+      "ratio": 0.9607,
+      "suggested_scalar": -0.0114,
+      "log_bad": -0.8812,
+      "log_good": -0.9213
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.5429,
+      "good": 6.0448,
+      "ratio": 1.0905,
+      "suggested_scalar": 0.0247,
+      "log_bad": 1.7125,
+      "log_good": 1.7992
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2,
+      "good": 0.1875,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0184,
+      "log_bad": -1.6094,
+      "log_good": -1.674
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.909,
+      "good": 3.7953,
+      "ratio": 0.9709,
+      "suggested_scalar": -0.0084,
+      "log_bad": 1.3633,
+      "log_good": 1.3338
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1977,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 446.0,
+      "good": 518.0,
+      "ratio": 1.1614,
+      "suggested_scalar": 0.0427,
+      "log_bad": 6.1003,
+      "log_good": 6.25
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 45.0,
+      "good": 59.0,
+      "ratio": 1.3111,
+      "suggested_scalar": 0.0772,
+      "log_bad": 3.8067,
+      "log_good": 4.0775
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4013.0856,
+      "good": 6518.0532,
+      "ratio": 1.6242,
+      "suggested_scalar": 0.1383,
+      "log_bad": 8.2973,
+      "log_good": 8.7823
+    },
+    "readability.mean_total_lines": {
+      "bad": 52.0,
+      "good": 65.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0636,
+      "log_bad": 3.9512,
+      "log_good": 4.1744
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2376.9815,
+      "good": 2778.5131,
+      "ratio": 1.1689,
+      "suggested_scalar": 0.0445,
+      "log_bad": 7.7736,
+      "log_good": 7.9297
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 819.0,
+      "good": 845.0,
+      "ratio": 1.0317,
+      "suggested_scalar": 0.0089,
+      "log_bad": 6.7081,
+      "log_good": 6.7393
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 39.5385,
+      "good": 33.1077,
+      "ratio": 0.8374,
+      "suggested_scalar": -0.0506,
+      "log_bad": 3.6773,
+      "log_good": 3.4998
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0745,
+      "good": 1.0977,
+      "ratio": 1.0216,
+      "suggested_scalar": 0.0061,
+      "log_bad": 0.0719,
+      "log_good": 0.0932
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 15.0,
+      "good": 19.0,
+      "ratio": 1.2667,
+      "suggested_scalar": 0.0674,
+      "log_bad": 2.7081,
+      "log_good": 2.9444
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8757,
+      "good": 0.8483,
+      "ratio": 0.9687,
+      "suggested_scalar": -0.0091,
+      "log_bad": -0.1327,
+      "log_good": -0.1645
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 9.0,
+      "good": 13.0,
+      "ratio": 1.4444,
+      "suggested_scalar": 0.1049,
+      "log_bad": 2.1972,
+      "log_good": 2.5649
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9853,
+      "good": 0.9855,
+      "ratio": 1.0002,
+      "suggested_scalar": 0.0001,
+      "log_bad": -0.0148,
+      "log_good": -0.0146
+    },
+    "halstead.mean_length": {
+      "bad": 357.0,
+      "good": 428.0,
+      "ratio": 1.1989,
+      "suggested_scalar": 0.0517,
+      "log_bad": 5.8777,
+      "log_good": 6.0591
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.5,
+      "good": 11.4,
+      "ratio": 1.0857,
+      "suggested_scalar": 0.0235,
+      "log_bad": 2.3514,
+      "log_good": 2.4336
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9425,
+      "good": 6.8948,
+      "ratio": 0.9931,
+      "suggested_scalar": -0.002,
+      "log_bad": 1.9377,
+      "log_good": 1.9308
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 0.3953,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0905,
+      "good": 0.1125,
+      "ratio": 1.2431,
+      "suggested_scalar": 0.0621,
+      "log_bad": -2.4024,
+      "log_good": -2.1848
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.3896,
+      "good": 42.2258,
+      "ratio": 1.3895,
+      "suggested_scalar": 0.0938,
+      "log_bad": 3.4141,
+      "log_good": 3.743
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 13.0,
+      "ratio": 1.625,
+      "suggested_scalar": 0.1385,
+      "log_bad": 2.0794,
+      "log_good": 2.5649
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 87.0,
+      "good": 80.0,
+      "ratio": 0.9195,
+      "suggested_scalar": -0.0239,
+      "log_bad": 4.4659,
+      "log_good": 4.382
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7756,
+      "good": 0.7719,
+      "ratio": 0.9952,
+      "suggested_scalar": -0.0014,
+      "log_bad": -0.2541,
+      "log_good": -0.2589
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 52.0,
+      "good": 65.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0636,
+      "log_bad": 3.9512,
+      "log_good": 4.1744
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.error_type_includes_context": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 11.0,
+      "good": 14.0,
+      "ratio": 1.2727,
+      "suggested_scalar": 0.4748,
+      "log_bad": 2.3979,
+      "log_good": 2.6391
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0265,
+      "good": 0.0224,
+      "ratio": 0.8453,
+      "suggested_scalar": -0.3309,
+      "log_bad": -3.6306,
+      "log_good": -3.7987
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8205,
+      "good": 0.8085,
+      "ratio": 0.9854,
+      "suggested_scalar": -0.029,
+      "log_bad": -0.1978,
+      "log_good": -0.2126
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0265,
+      "good": 0.0224,
+      "ratio": 0.8453,
+      "suggested_scalar": -0.3309,
+      "log_bad": -3.6306,
+      "log_good": -3.7987
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8912,
+      "good": 4.937,
+      "ratio": 1.0094,
+      "suggested_scalar": 0.0183,
+      "log_bad": 1.5874,
+      "log_good": 1.5968
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 87.0,
+      "good": 76.0,
+      "ratio": 0.8736,
+      "suggested_scalar": -0.2661,
+      "log_bad": 4.4659,
+      "log_good": 4.3307
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.58,
+      "good": 0.3907,
+      "ratio": 0.6736,
+      "suggested_scalar": -0.7778,
+      "log_bad": -0.5447,
+      "log_good": -0.9398
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.1358,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7063,
+      "good": 0.565,
+      "ratio": 0.7999,
+      "suggested_scalar": -0.4394,
+      "log_bad": -0.3477,
+      "log_good": -0.5709
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.7949,
+      "good": 0.8936,
+      "ratio": 1.1242,
+      "suggested_scalar": 0.2304,
+      "log_bad": -0.2295,
+      "log_good": -0.1125
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 264.0,
+      "good": 357.0,
+      "ratio": 1.3523,
+      "suggested_scalar": 0.5941,
+      "log_bad": 5.5759,
+      "log_good": 5.8777
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0028,
+      "good": 0.0031,
+      "ratio": 1.1071,
+      "suggested_scalar": 0.2004,
+      "log_bad": -5.8781,
+      "log_good": -5.7764
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1026,
+      "good": 0.0426,
+      "ratio": 0.4152,
+      "suggested_scalar": -1.7304,
+      "log_bad": -2.2769,
+      "log_good": -3.1559
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8563,
+      "good": 0.9973,
+      "ratio": 1.1647,
+      "suggested_scalar": 0.3001,
+      "log_bad": -0.1551,
+      "log_good": -0.0027
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 107.0,
+      "good": 140.0,
+      "ratio": 1.3084,
+      "suggested_scalar": 0.5292,
+      "log_bad": 4.6728,
+      "log_good": 4.9416
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 107.5085,
+      "good": 107.8714,
+      "ratio": 1.0034,
+      "suggested_scalar": 0.0066,
+      "log_bad": 4.6776,
+      "log_good": 4.6809
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.384,
+      "good": 0.5983,
+      "ratio": 1.5581,
+      "suggested_scalar": 0.873,
+      "log_bad": -0.9571,
+      "log_good": -0.5137
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.3944,
+      "good": 9.0949,
+      "ratio": 1.0834,
+      "suggested_scalar": 0.1578,
+      "log_bad": 2.1276,
+      "log_good": 2.2077
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1059.0,
+      "good": 1281.0,
+      "ratio": 1.2096,
+      "suggested_scalar": 0.3747,
+      "log_bad": 6.9651,
+      "log_good": 7.1554
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0769,
+      "good": 0.1064,
+      "ratio": 1.3836,
+      "suggested_scalar": 0.6392,
+      "log_bad": -2.5652,
+      "log_good": -2.2405
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7949,
+      "good": 0.766,
+      "ratio": 0.9636,
+      "suggested_scalar": -0.0729,
+      "log_bad": -0.2295,
+      "log_good": -0.2666
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.7692,
+      "good": 7.5957,
+      "ratio": 1.1221,
+      "suggested_scalar": 0.2268,
+      "log_bad": 1.9124,
+      "log_good": 2.0276
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.4707,
+      "good": 0.6908,
+      "ratio": 1.4676,
+      "suggested_scalar": 0.7552,
+      "log_bad": -0.7535,
+      "log_good": -0.3699
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 76.0,
+      "good": 82.0,
+      "ratio": 1.0789,
+      "suggested_scalar": 0.1496,
+      "log_bad": 4.3307,
+      "log_good": 4.4067
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9217,
+      "good": 0.8845,
+      "ratio": 0.9596,
+      "suggested_scalar": -0.0811,
+      "log_bad": -0.0815,
+      "log_good": -0.1227
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 21.0,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.0916,
+      "log_bad": 3.091,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.4873,
+      "good": 0.566,
+      "ratio": 1.1615,
+      "suggested_scalar": 0.2947,
+      "log_bad": -0.7189,
+      "log_good": -0.5692
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.1641,
+      "good": 0.4085,
+      "ratio": 2.4893,
+      "suggested_scalar": 1.7954,
+      "log_bad": -1.8073,
+      "log_good": -0.8953
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.9503,
+      "good": 2.304,
+      "ratio": 1.1814,
+      "suggested_scalar": 0.3281,
+      "log_bad": 0.668,
+      "log_good": 0.8346
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 262.0,
+      "good": 355.0,
+      "ratio": 1.355,
+      "suggested_scalar": 0.598,
+      "log_bad": 5.5683,
+      "log_good": 5.8721
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 21.0,
+      "good": 22.0,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.0916,
+      "log_bad": 3.0445,
+      "log_good": 3.091
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0152,
+      "good": 0.0392,
+      "ratio": 2.5789,
+      "suggested_scalar": 1.8651,
+      "log_bad": -4.1865,
+      "log_good": -3.2391
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.8074,
+      "ratio": 0.9956,
+      "suggested_scalar": -0.0086,
+      "log_bad": 1.7635,
+      "log_good": 1.7591
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 28.0,
+      "good": 55.0,
+      "ratio": 1.9643,
+      "suggested_scalar": 1.3291,
+      "log_bad": 3.3322,
+      "log_good": 4.0073
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0012,
+      "good": 1.1004,
+      "ratio": 1.0991,
+      "suggested_scalar": 0.186,
+      "log_bad": 0.0012,
+      "log_good": 0.0957
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8546,
+      "good": 5.603,
+      "ratio": 0.957,
+      "suggested_scalar": -0.0865,
+      "log_bad": 1.7672,
+      "log_good": 1.7233
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8386,
+      "good": 0.8501,
+      "ratio": 1.0137,
+      "suggested_scalar": 0.0268,
+      "log_bad": -0.176,
+      "log_good": -0.1624
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1702,
+      "good": 0.1607,
+      "ratio": 0.9442,
+      "suggested_scalar": -0.1131,
+      "log_bad": -1.7708,
+      "log_good": -1.8282
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.8973,
+      "good": 3.0158,
+      "ratio": 1.0409,
+      "suggested_scalar": 0.0789,
+      "log_bad": 1.0638,
+      "log_good": 1.1039
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 240.0,
+      "good": 268.0,
+      "ratio": 1.1167,
+      "suggested_scalar": 0.2172,
+      "log_bad": 5.4806,
+      "log_good": 5.591
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.509,
+      "good": 0.6727,
+      "ratio": 1.3216,
+      "suggested_scalar": 0.549,
+      "log_bad": -0.6753,
+      "log_good": -0.3965
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 89.0,
+      "good": 78.0,
+      "ratio": 0.8764,
+      "suggested_scalar": -0.2597,
+      "log_bad": 4.4886,
+      "log_good": 4.3567
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 605.0,
+      "good": 690.0,
+      "ratio": 1.1405,
+      "suggested_scalar": 0.2588,
+      "log_bad": 6.4052,
+      "log_good": 6.5367
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 114.0,
+      "good": 146.0,
+      "ratio": 1.2807,
+      "suggested_scalar": 0.4871,
+      "log_bad": 4.7362,
+      "log_good": 4.9836
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2235,
+      "good": 0.2717,
+      "ratio": 1.2157,
+      "suggested_scalar": 0.3845,
+      "log_bad": -1.4983,
+      "log_good": -1.3031
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 43.0,
+      "good": 75.0,
+      "ratio": 1.7442,
+      "suggested_scalar": 1.0951,
+      "log_bad": 3.7612,
+      "log_good": 4.3175
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.5663,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 89.0,
+      "good": 78.0,
+      "ratio": 0.8764,
+      "suggested_scalar": -0.2597,
+      "log_bad": 4.4886,
+      "log_good": 4.3567
+    },
+    "brevity.mean_sample_size": {
+      "bad": 89.0,
+      "good": 78.0,
+      "ratio": 0.8764,
+      "suggested_scalar": -0.2597,
+      "log_bad": 4.4886,
+      "log_good": 4.3567
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 264.0,
+      "good": 357.0,
+      "ratio": 1.3523,
+      "suggested_scalar": 0.5941,
+      "log_bad": 5.5759,
+      "log_good": 5.8777
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 124.0,
+      "good": 179.0,
+      "ratio": 1.4435,
+      "suggested_scalar": 0.7227,
+      "log_bad": 4.8203,
+      "log_good": 5.1874
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 205.0,
+      "good": 218.0,
+      "ratio": 1.0634,
+      "suggested_scalar": 0.121,
+      "log_bad": 5.323,
+      "log_good": 5.3845
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.7704,
+      "good": 3.1712,
+      "ratio": 1.7912,
+      "suggested_scalar": 1.1475,
+      "log_bad": 0.5712,
+      "log_good": 1.1541
+    },
+    "halstead.mean_effort": {
+      "bad": 29458.9219,
+      "good": 56249.4098,
+      "ratio": 1.9094,
+      "suggested_scalar": 1.2733,
+      "log_bad": 10.2908,
+      "log_good": 10.9376
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.9041,
+      "good": 0.8914,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0279,
+      "log_bad": -0.1008,
+      "log_good": -0.115
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 65.0,
+      "good": 55.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.3289,
+      "log_bad": 4.1744,
+      "log_good": 4.0073
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 123.0,
+      "good": 177.0,
+      "ratio": 1.439,
+      "suggested_scalar": 0.7165,
+      "log_bad": 4.8122,
+      "log_good": 5.1761
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5701,
+      "good": 0.3643,
+      "ratio": 0.639,
+      "suggested_scalar": -0.8816,
+      "log_bad": -0.5619,
+      "log_good": -1.0098
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.6542,
+      "good": 4.9286,
+      "ratio": 0.8717,
+      "suggested_scalar": -0.2704,
+      "log_bad": 1.7324,
+      "log_good": 1.5951
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1702,
+      "good": 0.1607,
+      "ratio": 0.9442,
+      "suggested_scalar": -0.1131,
+      "log_bad": -1.7708,
+      "log_good": -1.8282
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.9934,
+      "good": 3.263,
+      "ratio": 1.0901,
+      "suggested_scalar": 0.1698,
+      "log_bad": 1.0964,
+      "log_good": 1.1826
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 263.0,
+      "good": 356.0,
+      "ratio": 1.3536,
+      "suggested_scalar": 0.5961,
+      "log_bad": 5.5722,
+      "log_good": 5.8749
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 21.0,
+      "good": 58.0,
+      "ratio": 2.7619,
+      "suggested_scalar": 2.0,
+      "log_bad": 3.0445,
+      "log_good": 4.0604
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1636.6068,
+      "good": 3124.9672,
+      "ratio": 1.9094,
+      "suggested_scalar": 1.2733,
+      "log_bad": 7.4004,
+      "log_good": 8.0472
+    },
+    "readability.mean_total_lines": {
+      "bad": 39.0,
+      "good": 47.0,
+      "ratio": 1.2051,
+      "suggested_scalar": 0.3673,
+      "log_bad": 3.6636,
+      "log_good": 3.8501
+    },
+    "indentation.mean_max_depth": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.7982,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "halstead.mean_volume": {
+      "bad": 1526.9776,
+      "good": 2018.0806,
+      "ratio": 1.3216,
+      "suggested_scalar": 0.549,
+      "log_bad": 7.331,
+      "log_good": 7.6099
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 543.0,
+      "good": 556.0,
+      "ratio": 1.0239,
+      "suggested_scalar": 0.0466,
+      "log_bad": 6.2971,
+      "log_good": 6.3208
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 25.9487,
+      "good": 26.0638,
+      "ratio": 1.0044,
+      "suggested_scalar": 0.0087,
+      "log_bad": 3.2561,
+      "log_good": 3.2605
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0929,
+      "good": 1.0787,
+      "ratio": 0.987,
+      "suggested_scalar": -0.0257,
+      "log_bad": 0.0888,
+      "log_good": 0.0758
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 15.0,
+      "good": 25.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 1.0056,
+      "log_bad": 2.7081,
+      "log_good": 3.2189
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 2.0,
+      "ratio": 0.5,
+      "suggested_scalar": -1.3646,
+      "log_bad": 1.3863,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9125,
+      "good": 0.7836,
+      "ratio": 0.8587,
+      "suggested_scalar": -0.2998,
+      "log_bad": -0.0916,
+      "log_good": -0.2439
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9806,
+      "good": 0.9249,
+      "ratio": 0.9432,
+      "suggested_scalar": -0.1151,
+      "log_bad": -0.0196,
+      "log_good": -0.0781
+    },
+    "halstead.mean_length": {
+      "bad": 237.0,
+      "good": 323.0,
+      "ratio": 1.3629,
+      "suggested_scalar": 0.6095,
+      "log_bad": 5.4681,
+      "log_good": 5.7777
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.3333,
+      "good": 10.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.2464,
+      "log_bad": 2.4277,
+      "log_good": 2.3026
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4757,
+      "good": 6.2854,
+      "ratio": 0.9706,
+      "suggested_scalar": -0.0587,
+      "log_bad": 1.8681,
+      "log_good": 1.8382
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1171,
+      "good": 0.1397,
+      "ratio": 1.193,
+      "suggested_scalar": 0.3474,
+      "log_bad": -2.1447,
+      "log_good": -1.9683
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 19.2923,
+      "good": 27.8727,
+      "ratio": 1.4448,
+      "suggested_scalar": 0.7244,
+      "log_bad": 2.9597,
+      "log_good": 3.3276
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 1.0056,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 61.0,
+      "good": 51.0,
+      "ratio": 0.8361,
+      "suggested_scalar": -0.3525,
+      "log_bad": 4.1109,
+      "log_good": 3.9318
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7902,
+      "good": 0.656,
+      "ratio": 0.8302,
+      "suggested_scalar": -0.3664,
+      "log_bad": -0.2355,
+      "log_good": -0.4216
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 39.0,
+      "good": 47.0,
+      "ratio": 1.2051,
+      "suggested_scalar": 0.3673,
+      "log_bad": 3.6636,
+      "log_good": 3.8501
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.uses_context_manager_for_resources": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 48.0,
+      "good": 46.0,
+      "ratio": 0.9583,
+      "suggested_scalar": -0.0775,
+      "log_bad": 3.8712,
+      "log_good": 3.8286
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0456,
+      "good": 0.0466,
+      "ratio": 1.0219,
+      "suggested_scalar": 0.0395,
+      "log_bad": -3.0878,
+      "log_good": -3.0662
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.25,
+      "good": 0.25,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.3863,
+      "log_good": -1.3863
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8571,
+      "good": 0.8333,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.0513,
+      "log_bad": -0.1542,
+      "log_good": -0.1824
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.048,
+      "good": 0.0466,
+      "ratio": 0.9708,
+      "suggested_scalar": -0.0539,
+      "log_bad": -3.0366,
+      "log_good": -3.0662
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6381,
+      "good": 4.7144,
+      "ratio": 1.0165,
+      "suggested_scalar": 0.0297,
+      "log_bad": 1.5343,
+      "log_good": 1.5506
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 95.0,
+      "good": 89.0,
+      "ratio": 0.9368,
+      "suggested_scalar": -0.1188,
+      "log_bad": 4.5539,
+      "log_good": 4.4886
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5635,
+      "good": 0.5631,
+      "ratio": 0.9993,
+      "suggested_scalar": -0.0013,
+      "log_bad": -0.5736,
+      "log_good": -0.5743
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.1256,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6951,
+      "good": 0.7097,
+      "ratio": 1.021,
+      "suggested_scalar": 0.0378,
+      "log_bad": -0.3637,
+      "log_good": -0.3429
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.102,
+      "good": 4.1481,
+      "ratio": 1.3372,
+      "suggested_scalar": 0.529,
+      "log_bad": 1.132,
+      "log_good": 1.4227
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 417.0,
+      "good": 408.0,
+      "ratio": 0.9784,
+      "suggested_scalar": -0.0397,
+      "log_bad": 6.0331,
+      "log_good": 6.0113
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9273,
+      "good": 0.9218,
+      "ratio": 0.9941,
+      "suggested_scalar": -0.0108,
+      "log_bad": -0.0755,
+      "log_good": -0.0814
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 171.0,
+      "good": 160.0,
+      "ratio": 0.9357,
+      "suggested_scalar": -0.121,
+      "log_bad": 5.1417,
+      "log_good": 5.0752
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 105.616,
+      "good": 106.9118,
+      "ratio": 1.0123,
+      "suggested_scalar": 0.0222,
+      "log_bad": 4.6598,
+      "log_good": 4.672
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4904,
+      "good": 0.4816,
+      "ratio": 0.9821,
+      "suggested_scalar": -0.033,
+      "log_bad": -0.7125,
+      "log_good": -0.7306
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.3663,
+      "good": 9.4559,
+      "ratio": 1.1302,
+      "suggested_scalar": 0.2229,
+      "log_bad": 2.1242,
+      "log_good": 2.2466
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1816.0,
+      "good": 1809.0,
+      "ratio": 0.9961,
+      "suggested_scalar": -0.007,
+      "log_bad": 7.5044,
+      "log_good": 7.5005
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1429,
+      "good": 0.1667,
+      "ratio": 1.1666,
+      "suggested_scalar": 0.2804,
+      "log_bad": -1.9456,
+      "log_good": -1.7916
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8571,
+      "good": 0.8333,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.0513,
+      "log_bad": -0.1542,
+      "log_good": -0.1824
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.5102,
+      "good": 7.5556,
+      "ratio": 0.8878,
+      "suggested_scalar": -0.2166,
+      "log_bad": 2.1413,
+      "log_good": 2.0223
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 1.2619,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.4386,
+      "good": 8.8669,
+      "ratio": 2.5786,
+      "suggested_scalar": 1.7245,
+      "log_bad": 1.2351,
+      "log_good": 2.1823
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 149.0,
+      "good": 131.0,
+      "ratio": 0.8792,
+      "suggested_scalar": -0.2344,
+      "log_bad": 5.0039,
+      "log_good": 4.8752
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9523,
+      "good": 0.9352,
+      "ratio": 0.982,
+      "suggested_scalar": -0.033,
+      "log_bad": -0.0489,
+      "log_good": -0.067
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 28.0,
+      "ratio": 1.2174,
+      "suggested_scalar": 0.3581,
+      "log_bad": 3.1355,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5865,
+      "good": 0.5732,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.0418,
+      "log_bad": -0.5336,
+      "log_good": -0.5565
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.347,
+      "good": 0.3424,
+      "ratio": 0.9867,
+      "suggested_scalar": -0.0243,
+      "log_bad": -1.0584,
+      "log_good": -1.0718
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4181,
+      "good": 2.3433,
+      "ratio": 0.9691,
+      "suggested_scalar": -0.0572,
+      "log_bad": 0.883,
+      "log_good": 0.8516
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 415.0,
+      "good": 406.0,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.0399,
+      "log_bad": 6.0283,
+      "log_good": 6.0064
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 18.0,
+      "good": 17.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.1041,
+      "log_bad": 2.8904,
+      "log_good": 2.8332
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.036,
+      "good": 0.049,
+      "ratio": 1.3611,
+      "suggested_scalar": 0.5613,
+      "log_bad": -3.3242,
+      "log_good": -3.0159
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 6.0224,
+      "ratio": 1.0196,
+      "suggested_scalar": 0.0353,
+      "log_bad": 1.7761,
+      "log_good": 1.7955
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 12.0,
+      "good": 19.0,
+      "ratio": 1.5833,
+      "suggested_scalar": 0.8366,
+      "log_bad": 2.4849,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7401,
+      "good": 0.9138,
+      "ratio": 1.2347,
+      "suggested_scalar": 0.3838,
+      "log_bad": -0.301,
+      "log_good": -0.0901
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0292,
+      "good": 0.0313,
+      "ratio": 1.0719,
+      "suggested_scalar": 0.1264,
+      "log_bad": -3.5336,
+      "log_good": -3.4641
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9148,
+      "good": 5.8792,
+      "ratio": 0.994,
+      "suggested_scalar": -0.011,
+      "log_bad": 1.7775,
+      "log_good": 1.7714
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7852,
+      "good": 0.7828,
+      "ratio": 0.9969,
+      "suggested_scalar": -0.0056,
+      "log_bad": -0.2418,
+      "log_good": -0.2449
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2097,
+      "good": 0.194,
+      "ratio": 0.9251,
+      "suggested_scalar": -0.1417,
+      "log_bad": -1.5621,
+      "log_good": -1.6399
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.8925,
+      "good": 3.075,
+      "ratio": 1.0631,
+      "suggested_scalar": 0.1114,
+      "log_bad": 1.0621,
+      "log_good": 1.1233
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 326.0,
+      "good": 320.0,
+      "ratio": 0.9816,
+      "suggested_scalar": -0.0338,
+      "log_bad": 5.7869,
+      "log_good": 5.7683
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.4062,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7314,
+      "good": 0.7145,
+      "ratio": 0.9769,
+      "suggested_scalar": -0.0426,
+      "log_bad": -0.3128,
+      "log_good": -0.3362
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 124.0,
+      "good": 126.0,
+      "ratio": 1.0161,
+      "suggested_scalar": 0.0291,
+      "log_bad": 4.8203,
+      "log_good": 4.8363
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 986.0,
+      "good": 963.0,
+      "ratio": 0.9767,
+      "suggested_scalar": -0.043,
+      "log_bad": 6.8937,
+      "log_good": 6.8701
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 157.0,
+      "good": 140.0,
+      "ratio": 0.8917,
+      "suggested_scalar": -0.2086,
+      "log_bad": 5.0562,
+      "log_good": 4.9416
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0096,
+      "good": 0.0098,
+      "ratio": 1.0208,
+      "suggested_scalar": 0.0375,
+      "log_bad": -4.646,
+      "log_good": -4.6254
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2398,
+      "good": 0.2598,
+      "ratio": 1.0834,
+      "suggested_scalar": 0.1458,
+      "log_bad": -1.428,
+      "log_good": -1.3478
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 59.0,
+      "good": 58.0,
+      "ratio": 0.9831,
+      "suggested_scalar": -0.0311,
+      "log_bad": 4.0775,
+      "log_good": 4.0604
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 124.0,
+      "good": 126.0,
+      "ratio": 1.0161,
+      "suggested_scalar": 0.0291,
+      "log_bad": 4.8203,
+      "log_good": 4.8363
+    },
+    "brevity.mean_sample_size": {
+      "bad": 124.0,
+      "good": 126.0,
+      "ratio": 1.0161,
+      "suggested_scalar": 0.0291,
+      "log_bad": 4.8203,
+      "log_good": 4.8363
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 417.0,
+      "good": 408.0,
+      "ratio": 0.9784,
+      "suggested_scalar": -0.0397,
+      "log_bad": 6.0331,
+      "log_good": 6.0113
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 202.0,
+      "good": 195.0,
+      "ratio": 0.9653,
+      "suggested_scalar": -0.0642,
+      "log_bad": 5.3083,
+      "log_good": 5.273
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 271.0,
+      "good": 269.0,
+      "ratio": 0.9926,
+      "suggested_scalar": -0.0135,
+      "log_bad": 5.6021,
+      "log_good": 5.5947
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0024,
+      "good": 0.0025,
+      "ratio": 1.0417,
+      "suggested_scalar": 0.0743,
+      "log_bad": -6.0323,
+      "log_good": -5.9915
+    },
+    "heaps.mean_k": {
+      "bad": 1.9508,
+      "good": 1.8321,
+      "ratio": 0.9392,
+      "suggested_scalar": -0.1143,
+      "log_bad": 0.6682,
+      "log_good": 0.6055
+    },
+    "halstead.mean_effort": {
+      "bad": 55025.9169,
+      "good": 68872.079,
+      "ratio": 1.2516,
+      "suggested_scalar": 0.4086,
+      "log_bad": 10.9156,
+      "log_good": 11.14
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -1.2619,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8505,
+      "good": 0.8426,
+      "ratio": 0.9907,
+      "suggested_scalar": -0.017,
+      "log_bad": -0.1619,
+      "log_good": -0.1713
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 72.0,
+      "good": 61.0,
+      "ratio": 0.8472,
+      "suggested_scalar": -0.3018,
+      "log_bad": 4.2767,
+      "log_good": 4.1109
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 177.0,
+      "good": 191.0,
+      "ratio": 1.0791,
+      "suggested_scalar": 0.1386,
+      "log_bad": 5.1761,
+      "log_good": 5.2523
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5205,
+      "good": 0.55,
+      "ratio": 1.0567,
+      "suggested_scalar": 0.1004,
+      "log_bad": -0.653,
+      "log_good": -0.5978
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.7661,
+      "good": 6.0187,
+      "ratio": 1.0438,
+      "suggested_scalar": 0.0781,
+      "log_bad": 1.752,
+      "log_good": 1.7949
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2097,
+      "good": 0.194,
+      "ratio": 0.9251,
+      "suggested_scalar": -0.1417,
+      "log_bad": -1.5621,
+      "log_good": -1.6399
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.5928,
+      "good": 3.2127,
+      "ratio": 0.8942,
+      "suggested_scalar": -0.2036,
+      "log_bad": 1.2789,
+      "log_good": 1.1671
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 416.0,
+      "good": 407.0,
+      "ratio": 0.9784,
+      "suggested_scalar": -0.0398,
+      "log_bad": 6.0307,
+      "log_good": 6.0088
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 55.0,
+      "good": 53.0,
+      "ratio": 0.9636,
+      "suggested_scalar": -0.0674,
+      "log_bad": 4.0073,
+      "log_good": 3.9703
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3056.9954,
+      "good": 3826.2266,
+      "ratio": 1.2516,
+      "suggested_scalar": 0.4086,
+      "log_bad": 8.0252,
+      "log_good": 8.2496
+    },
+    "readability.mean_total_lines": {
+      "bad": 49.0,
+      "good": 54.0,
+      "ratio": 1.102,
+      "suggested_scalar": 0.1769,
+      "log_bad": 3.8918,
+      "log_good": 3.989
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2194.3318,
+      "good": 2143.4678,
+      "ratio": 0.9768,
+      "suggested_scalar": -0.0427,
+      "log_bad": 7.6936,
+      "log_good": 7.6702
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 751.0,
+      "good": 772.0,
+      "ratio": 1.028,
+      "suggested_scalar": 0.0502,
+      "log_bad": 6.6214,
+      "log_good": 6.649
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.6327,
+      "good": 32.2222,
+      "ratio": 0.9043,
+      "suggested_scalar": -0.1832,
+      "log_bad": 3.5733,
+      "log_good": 3.4727
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0943,
+      "good": 1.0905,
+      "ratio": 0.9965,
+      "suggested_scalar": -0.0063,
+      "log_bad": 0.0901,
+      "log_good": 0.0866
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 23.0,
+      "good": 22.0,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.0809,
+      "log_bad": 3.1355,
+      "log_good": 3.091
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8313,
+      "good": 0.8344,
+      "ratio": 1.0037,
+      "suggested_scalar": 0.0068,
+      "log_bad": -0.1848,
+      "log_good": -0.181
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9827,
+      "good": 0.9843,
+      "ratio": 1.0016,
+      "suggested_scalar": 0.003,
+      "log_bad": -0.0175,
+      "log_good": -0.0158
+    },
+    "halstead.mean_length": {
+      "bad": 334.0,
+      "good": 331.0,
+      "ratio": 0.991,
+      "suggested_scalar": -0.0164,
+      "log_bad": 5.8111,
+      "log_good": 5.8021
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 13.0,
+      "good": 13.75,
+      "ratio": 1.0577,
+      "suggested_scalar": 0.1021,
+      "log_bad": 2.5649,
+      "log_good": 2.621
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9542,
+      "good": 6.9773,
+      "ratio": 1.0033,
+      "suggested_scalar": 0.006,
+      "log_bad": 1.9393,
+      "log_good": 1.9427
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -1.2619,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1117,
+      "good": 0.1079,
+      "ratio": 0.966,
+      "suggested_scalar": -0.063,
+      "log_bad": -2.1919,
+      "log_good": -2.2266
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.0764,
+      "good": 32.1311,
+      "ratio": 1.2813,
+      "suggested_scalar": 0.4513,
+      "log_bad": 3.2219,
+      "log_good": 3.4698
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 9.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.4575,
+      "log_bad": 1.9459,
+      "log_good": 2.1972
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 89.0,
+      "good": 88.0,
+      "ratio": 0.9888,
+      "suggested_scalar": -0.0206,
+      "log_bad": 4.4886,
+      "log_good": 4.4773
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7823,
+      "good": 0.7844,
+      "ratio": 1.0027,
+      "suggested_scalar": 0.0049,
+      "log_bad": -0.2455,
+      "log_good": -0.2428
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 49.0,
+      "good": 54.0,
+      "ratio": 1.102,
+      "suggested_scalar": 0.1769,
+      "log_bad": 3.8918,
+      "log_good": 3.989
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    }
+  },
+  "type_and_value.no_unsafe_assignment": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 21.0,
+      "good": 18.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0511,
+      "log_bad": 3.0445,
+      "log_good": 2.8904
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 19.0,
+      "good": 17.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.0369,
+      "log_bad": 2.9444,
+      "log_good": 2.8332
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.01,
+      "good": 0.0118,
+      "ratio": 1.18,
+      "suggested_scalar": 0.0549,
+      "log_bad": -4.6052,
+      "log_good": -4.4397
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3333,
+      "good": 1.2,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0349,
+      "log_bad": 0.2877,
+      "log_good": 0.1823
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8222,
+      "good": 0.8077,
+      "ratio": 0.9824,
+      "suggested_scalar": -0.0059,
+      "log_bad": -0.1958,
+      "log_good": -0.2136
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.01,
+      "good": 0.0118,
+      "ratio": 1.18,
+      "suggested_scalar": 0.0549,
+      "log_bad": -4.6052,
+      "log_good": -4.4397
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7951,
+      "good": 4.8687,
+      "ratio": 1.0153,
+      "suggested_scalar": 0.0051,
+      "log_bad": 1.5676,
+      "log_good": 1.5828
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 82.0,
+      "good": 81.0,
+      "ratio": 0.9878,
+      "suggested_scalar": -0.0041,
+      "log_bad": 4.4067,
+      "log_good": 4.3944
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4389,
+      "good": 0.4297,
+      "ratio": 0.979,
+      "suggested_scalar": -0.007,
+      "log_bad": -0.8235,
+      "log_good": -0.8447
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5869,
+      "good": 0.6398,
+      "ratio": 1.0901,
+      "suggested_scalar": 0.0286,
+      "log_bad": -0.5329,
+      "log_good": -0.4466
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.4222,
+      "good": 1.7308,
+      "ratio": 1.217,
+      "suggested_scalar": 0.0651,
+      "log_bad": 0.3522,
+      "log_good": 0.5486
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 399.0,
+      "good": 424.0,
+      "ratio": 1.0627,
+      "suggested_scalar": 0.0201,
+      "log_bad": 5.989,
+      "log_good": 6.0497
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0013,
+      "good": 0.0012,
+      "ratio": 0.9231,
+      "suggested_scalar": -0.0265,
+      "log_bad": -6.6454,
+      "log_good": -6.7254
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0222,
+      "good": 1.0,
+      "ratio": 45.045,
+      "suggested_scalar": 1.2624,
+      "log_bad": -3.8077,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0013,
+      "good": 0.0019,
+      "ratio": 1.4615,
+      "suggested_scalar": 0.1258,
+      "log_bad": -6.6454,
+      "log_good": -6.2659
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9717,
+      "good": 0.9609,
+      "ratio": 0.9889,
+      "suggested_scalar": -0.0037,
+      "log_bad": -0.0287,
+      "log_good": -0.0399
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 118.0,
+      "good": 130.0,
+      "ratio": 1.1017,
+      "suggested_scalar": 0.0321,
+      "log_bad": 4.7707,
+      "log_good": 4.8675
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 99.6389,
+      "good": 94.7763,
+      "ratio": 0.9512,
+      "suggested_scalar": -0.0166,
+      "log_bad": 4.6016,
+      "log_good": 4.5515
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.608,
+      "good": 0.6312,
+      "ratio": 1.0382,
+      "suggested_scalar": 0.0124,
+      "log_bad": -0.4976,
+      "log_good": -0.4601
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.2468,
+      "good": 13.3716,
+      "ratio": 1.305,
+      "suggested_scalar": 0.0882,
+      "log_bad": 2.327,
+      "log_good": 2.5931
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1549.0,
+      "good": 1606.0,
+      "ratio": 1.0368,
+      "suggested_scalar": 0.012,
+      "log_bad": 7.3454,
+      "log_good": 7.3815
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0444,
+      "good": 0.0385,
+      "ratio": 0.8671,
+      "suggested_scalar": -0.0473,
+      "log_bad": -3.1145,
+      "log_good": -3.2571
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8,
+      "good": 0.7885,
+      "ratio": 0.9856,
+      "suggested_scalar": -0.0048,
+      "log_bad": -0.2231,
+      "log_good": -0.2376
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.8667,
+      "good": 8.1538,
+      "ratio": 0.9196,
+      "suggested_scalar": -0.0278,
+      "log_bad": 2.1823,
+      "log_good": 2.0985
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.3551,
+      "good": 1.8506,
+      "ratio": 1.3657,
+      "suggested_scalar": 0.1033,
+      "log_bad": 0.3039,
+      "log_good": 0.6155
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 75.0,
+      "good": 93.0,
+      "ratio": 1.24,
+      "suggested_scalar": 0.0713,
+      "log_bad": 4.3175,
+      "log_good": 4.5326
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9263,
+      "good": 0.9373,
+      "ratio": 1.0119,
+      "suggested_scalar": 0.0039,
+      "log_bad": -0.0766,
+      "log_good": -0.0648
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 28.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3322,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6288,
+      "good": 0.6364,
+      "ratio": 1.0121,
+      "suggested_scalar": 0.004,
+      "log_bad": -0.4639,
+      "log_good": -0.4519
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4131,
+      "good": 0.4147,
+      "ratio": 1.0039,
+      "suggested_scalar": 0.0013,
+      "log_bad": -0.8841,
+      "log_good": -0.8802
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6939,
+      "good": 2.75,
+      "ratio": 1.0208,
+      "suggested_scalar": 0.0068,
+      "log_bad": 0.991,
+      "log_good": 1.0116
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 397.0,
+      "good": 422.0,
+      "ratio": 1.063,
+      "suggested_scalar": 0.0202,
+      "log_bad": 5.9839,
+      "log_good": 6.045
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 13.0,
+      "good": 11.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.0554,
+      "log_bad": 2.5649,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0576,
+      "good": 0.066,
+      "ratio": 1.1458,
+      "suggested_scalar": 0.0451,
+      "log_bad": -2.8542,
+      "log_good": -2.7181
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.858,
+      "ratio": 1.0043,
+      "suggested_scalar": 0.0014,
+      "log_bad": 1.7635,
+      "log_good": 1.7678
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 22.0,
+      "good": 19.0,
+      "ratio": 0.8636,
+      "suggested_scalar": -0.0486,
+      "log_bad": 3.091,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3105,
+      "good": 1.1461,
+      "ratio": 0.8746,
+      "suggested_scalar": -0.0444,
+      "log_bad": 0.2704,
+      "log_good": 0.1364
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.637,
+      "good": 5.6088,
+      "ratio": 0.995,
+      "suggested_scalar": -0.0017,
+      "log_bad": 1.7294,
+      "log_good": 1.7243
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8221,
+      "good": 0.8311,
+      "ratio": 1.0109,
+      "suggested_scalar": 0.0036,
+      "log_bad": -0.1959,
+      "log_good": -0.185
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1964,
+      "good": 0.1746,
+      "ratio": 0.889,
+      "suggested_scalar": -0.039,
+      "log_bad": -1.6276,
+      "log_good": -1.7453
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.2011,
+      "good": 3.6567,
+      "ratio": 1.1423,
+      "suggested_scalar": 0.0441,
+      "log_bad": 1.1635,
+      "log_good": 1.2966
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 302.0,
+      "good": 320.0,
+      "ratio": 1.0596,
+      "suggested_scalar": 0.0192,
+      "log_bad": 5.7104,
+      "log_good": 5.7683
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 25.0,
+      "good": 28.0,
+      "ratio": 1.12,
+      "suggested_scalar": 0.0376,
+      "log_bad": 3.2189,
+      "log_good": 3.3322
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7841,
+      "good": 0.839,
+      "ratio": 1.07,
+      "suggested_scalar": 0.0224,
+      "log_bad": -0.2432,
+      "log_good": -0.1755
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 84.0,
+      "good": 82.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.008,
+      "log_bad": 4.4308,
+      "log_good": 4.4067
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 802.0,
+      "good": 840.0,
+      "ratio": 1.0474,
+      "suggested_scalar": 0.0153,
+      "log_bad": 6.6871,
+      "log_good": 6.7334
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 142.0,
+      "good": 150.0,
+      "ratio": 1.0563,
+      "suggested_scalar": 0.0182,
+      "log_bad": 4.9558,
+      "log_good": 5.0106
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.005,
+      "good": 0.0071,
+      "ratio": 1.42,
+      "suggested_scalar": 0.1163,
+      "log_bad": -5.2983,
+      "log_good": -4.9477
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2607,
+      "good": 0.283,
+      "ratio": 1.0855,
+      "suggested_scalar": 0.0272,
+      "log_bad": -1.3444,
+      "log_good": -1.2623
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 82.0,
+      "good": 90.0,
+      "ratio": 1.0976,
+      "suggested_scalar": 0.0309,
+      "log_bad": 4.4067,
+      "log_good": 4.4998
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0604,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 84.0,
+      "good": 82.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.008,
+      "log_bad": 4.4308,
+      "log_good": 4.4067
+    },
+    "brevity.mean_sample_size": {
+      "bad": 84.0,
+      "good": 82.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.008,
+      "log_bad": 4.4308,
+      "log_good": 4.4067
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 399.0,
+      "good": 424.0,
+      "ratio": 1.0627,
+      "suggested_scalar": 0.0201,
+      "log_bad": 5.989,
+      "log_good": 6.0497
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 230.0,
+      "good": 250.0,
+      "ratio": 1.087,
+      "suggested_scalar": 0.0276,
+      "log_bad": 5.4381,
+      "log_good": 5.5215
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 238.0,
+      "good": 246.0,
+      "ratio": 1.0336,
+      "suggested_scalar": 0.011,
+      "log_bad": 5.4723,
+      "log_good": 5.5053
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0024,
+      "ratio": 0.0024,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.0323
+    },
+    "heaps.mean_k": {
+      "bad": 2.7121,
+      "good": 1.7857,
+      "ratio": 0.6584,
+      "suggested_scalar": -0.1386,
+      "log_bad": 0.9977,
+      "log_good": 0.5798
+    },
+    "halstead.mean_effort": {
+      "bad": 86599.2769,
+      "good": 99727.0367,
+      "ratio": 1.1516,
+      "suggested_scalar": 0.0468,
+      "log_bad": 11.369,
+      "log_good": 11.5102
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8818,
+      "good": 0.8822,
+      "ratio": 1.0005,
+      "suggested_scalar": 0.0002,
+      "log_bad": -0.1258,
+      "log_good": -0.1253
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 54.0,
+      "good": 53.0,
+      "ratio": 0.9815,
+      "suggested_scalar": -0.0062,
+      "log_bad": 3.989,
+      "log_good": 3.9703
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 228.0,
+      "good": 247.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.0265,
+      "log_bad": 5.4293,
+      "log_good": 5.5094
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3983,
+      "good": 0.3538,
+      "ratio": 0.8883,
+      "suggested_scalar": -0.0393,
+      "log_bad": -0.9205,
+      "log_good": -1.039
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.7966,
+      "good": 6.4615,
+      "ratio": 0.9507,
+      "suggested_scalar": -0.0168,
+      "log_bad": 1.9164,
+      "log_good": 1.8659
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1964,
+      "good": 0.1746,
+      "ratio": 0.889,
+      "suggested_scalar": -0.039,
+      "log_bad": -1.6276,
+      "log_good": -1.7453
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.9752,
+      "good": 5.122,
+      "ratio": 1.0295,
+      "suggested_scalar": 0.0096,
+      "log_bad": 1.6045,
+      "log_good": 1.6335
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 398.0,
+      "good": 423.0,
+      "ratio": 1.0628,
+      "suggested_scalar": 0.0202,
+      "log_bad": 5.9865,
+      "log_good": 6.0474
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 69.0,
+      "good": 73.0,
+      "ratio": 1.058,
+      "suggested_scalar": 0.0187,
+      "log_bad": 4.2341,
+      "log_good": 4.2905
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4811.0709,
+      "good": 5540.3909,
+      "ratio": 1.1516,
+      "suggested_scalar": 0.0468,
+      "log_bad": 8.4787,
+      "log_good": 8.6198
+    },
+    "readability.mean_total_lines": {
+      "bad": 45.0,
+      "good": 52.0,
+      "ratio": 1.1556,
+      "suggested_scalar": 0.0479,
+      "log_bad": 3.8067,
+      "log_good": 3.9512
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2352.2942,
+      "good": 2516.9205,
+      "ratio": 1.07,
+      "suggested_scalar": 0.0224,
+      "log_bad": 7.7631,
+      "log_good": 7.8308
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 575.0,
+      "good": 584.0,
+      "ratio": 1.0157,
+      "suggested_scalar": 0.0051,
+      "log_bad": 6.3544,
+      "log_good": 6.3699
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 33.1778,
+      "good": 29.6731,
+      "ratio": 0.8944,
+      "suggested_scalar": -0.037,
+      "log_bad": 3.5019,
+      "log_good": 3.3902
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1607,
+      "good": 1.2267,
+      "ratio": 1.0569,
+      "suggested_scalar": 0.0183,
+      "log_bad": 0.149,
+      "log_good": 0.2043
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 23.0,
+      "good": 26.0,
+      "ratio": 1.1304,
+      "suggested_scalar": 0.0406,
+      "log_bad": 3.1355,
+      "log_good": 3.2581
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7715,
+      "good": 0.7719,
+      "ratio": 1.0005,
+      "suggested_scalar": 0.0002,
+      "log_bad": -0.2594,
+      "log_good": -0.2589
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.952,
+      "good": 0.9841,
+      "ratio": 1.0337,
+      "suggested_scalar": 0.011,
+      "log_bad": -0.0492,
+      "log_good": -0.016
+    },
+    "halstead.mean_length": {
+      "bad": 370.0,
+      "good": 397.0,
+      "ratio": 1.073,
+      "suggested_scalar": 0.0234,
+      "log_bad": 5.9135,
+      "log_good": 5.9839
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.8333,
+      "good": 9.0,
+      "ratio": 1.1489,
+      "suggested_scalar": 0.046,
+      "log_bad": 2.0584,
+      "log_good": 2.1972
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.3923,
+      "good": 6.3576,
+      "ratio": 0.9946,
+      "suggested_scalar": -0.0018,
+      "log_bad": 1.8551,
+      "log_good": 1.8497
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1485,
+      "good": 0.1557,
+      "ratio": 1.0485,
+      "suggested_scalar": 0.0157,
+      "log_bad": -1.9072,
+      "log_good": -1.8598
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 36.8148,
+      "good": 39.6226,
+      "ratio": 1.0763,
+      "suggested_scalar": 0.0244,
+      "log_bad": 3.6059,
+      "log_good": 3.6794
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 47.0,
+      "good": 46.0,
+      "ratio": 0.9787,
+      "suggested_scalar": -0.0071,
+      "log_bad": 3.8501,
+      "log_good": 3.8286
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6555,
+      "good": 0.6341,
+      "ratio": 0.9674,
+      "suggested_scalar": -0.011,
+      "log_bad": -0.4224,
+      "log_good": -0.4555
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 45.0,
+      "good": 52.0,
+      "ratio": 1.1556,
+      "suggested_scalar": 0.0479,
+      "log_bad": 3.8067,
+      "log_good": 3.9512
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 15.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0214,
+      "log_bad": 2.7726,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_boolean_obsession": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 15.0,
+      "good": 31.0,
+      "ratio": 2.0667,
+      "suggested_scalar": 0.601,
+      "log_bad": 2.7081,
+      "log_good": 3.434
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 5.0,
+      "good": 3.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.4229,
+      "log_bad": 1.6094,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0081,
+      "good": 0.0244,
+      "ratio": 3.0123,
+      "suggested_scalar": 0.9129,
+      "log_bad": -4.8159,
+      "log_good": -3.7132
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 4.0,
+      "good": 2.1,
+      "ratio": 0.525,
+      "suggested_scalar": -0.5335,
+      "log_bad": 1.3863,
+      "log_good": 0.7419
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8571,
+      "good": 0.8372,
+      "ratio": 0.9768,
+      "suggested_scalar": -0.0194,
+      "log_bad": -0.1542,
+      "log_good": -0.1777
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0081,
+      "good": 0.0244,
+      "ratio": 3.0123,
+      "suggested_scalar": 0.9129,
+      "log_bad": -4.8159,
+      "log_good": -3.7132
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.428,
+      "good": 4.799,
+      "ratio": 1.0838,
+      "suggested_scalar": 0.0666,
+      "log_bad": 1.4879,
+      "log_good": 1.5684
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 100.0,
+      "good": 89.0,
+      "ratio": 0.89,
+      "suggested_scalar": -0.0965,
+      "log_bad": 4.6052,
+      "log_good": 4.4886
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.612,
+      "good": 0.5594,
+      "ratio": 0.9141,
+      "suggested_scalar": -0.0744,
+      "log_bad": -0.491,
+      "log_good": -0.5809
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.0,
+      "good": 19.0,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.0829,
+      "log_bad": 3.0445,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6782,
+      "good": 0.6254,
+      "ratio": 0.9221,
+      "suggested_scalar": -0.0671,
+      "log_bad": -0.3883,
+      "log_good": -0.4694
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.0357,
+      "good": 2.2791,
+      "ratio": 0.4526,
+      "suggested_scalar": -0.6563,
+      "log_bad": 1.6166,
+      "log_good": 0.8238
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 370.0,
+      "good": 491.0,
+      "ratio": 1.327,
+      "suggested_scalar": 0.2342,
+      "log_bad": 5.9135,
+      "log_good": 6.1964
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0893,
+      "good": 1.0,
+      "ratio": 11.1982,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.4158,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0006,
+      "good": 0.0005,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1509,
+      "log_bad": -7.4186,
+      "log_good": -7.6009
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9172,
+      "good": 0.9747,
+      "ratio": 1.0627,
+      "suggested_scalar": 0.0503,
+      "log_bad": -0.0864,
+      "log_good": -0.0256
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 119.0,
+      "good": 169.0,
+      "ratio": 1.4202,
+      "suggested_scalar": 0.2904,
+      "log_bad": 4.7791,
+      "log_good": 5.1299
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.5586,
+      "good": 100.1188,
+      "ratio": 0.9858,
+      "suggested_scalar": -0.0118,
+      "log_bad": 4.6206,
+      "log_good": 4.6064
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.458,
+      "good": 0.6327,
+      "ratio": 1.3814,
+      "suggested_scalar": 0.2675,
+      "log_bad": -0.7809,
+      "log_good": -0.4578
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 14.8295,
+      "good": 14.4447,
+      "ratio": 0.9741,
+      "suggested_scalar": -0.0218,
+      "log_bad": 2.6966,
+      "log_good": 2.6703
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1759.0,
+      "good": 1931.0,
+      "ratio": 1.0978,
+      "suggested_scalar": 0.0772,
+      "log_bad": 7.4725,
+      "log_good": 7.5658
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.3214,
+      "good": 0.1395,
+      "ratio": 0.434,
+      "suggested_scalar": -0.691,
+      "log_bad": -1.1351,
+      "log_good": -1.9697
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7143,
+      "good": 0.814,
+      "ratio": 1.1396,
+      "suggested_scalar": 0.1082,
+      "log_bad": -0.3365,
+      "log_good": -0.2058
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.2549,
+      "good": 11.4186,
+      "ratio": 1.5739,
+      "suggested_scalar": 0.3755,
+      "log_bad": 1.9817,
+      "log_good": 2.4352
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.9095,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 9.4273,
+      "good": 0.8524,
+      "ratio": 0.0904,
+      "suggested_scalar": -1.9897,
+      "log_bad": 2.2436,
+      "log_good": -0.1597
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 96.0,
+      "good": 143.0,
+      "ratio": 1.4896,
+      "suggested_scalar": 0.3299,
+      "log_bad": 4.5643,
+      "log_good": 4.9628
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9642,
+      "good": 0.9649,
+      "ratio": 1.0007,
+      "suggested_scalar": 0.0006,
+      "log_bad": -0.0365,
+      "log_good": -0.0357
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 32.0,
+      "ratio": 1.2308,
+      "suggested_scalar": 0.1719,
+      "log_bad": 3.2581,
+      "log_good": 3.4657
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6094,
+      "good": 0.6194,
+      "ratio": 1.0164,
+      "suggested_scalar": 0.0135,
+      "log_bad": -0.4953,
+      "log_good": -0.479
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2935,
+      "good": 0.3681,
+      "ratio": 1.2542,
+      "suggested_scalar": 0.1875,
+      "log_bad": -1.2259,
+      "log_good": -0.9994
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5604,
+      "good": 2.6272,
+      "ratio": 1.0261,
+      "suggested_scalar": 0.0213,
+      "log_bad": 0.9402,
+      "log_good": 0.9659
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 368.0,
+      "good": 489.0,
+      "ratio": 1.3288,
+      "suggested_scalar": 0.2354,
+      "log_bad": 5.9081,
+      "log_good": 6.1924
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 21.0,
+      "good": 11.0,
+      "ratio": 0.5238,
+      "suggested_scalar": -0.5353,
+      "log_bad": 3.0445,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0108,
+      "good": 0.0183,
+      "ratio": 1.6944,
+      "suggested_scalar": 0.4366,
+      "log_bad": -4.5282,
+      "log_good": -4.0009
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8826,
+      "good": 5.8074,
+      "ratio": 0.9872,
+      "suggested_scalar": -0.0107,
+      "log_bad": 1.772,
+      "log_good": 1.7591
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7083,
+      "good": 0.6988,
+      "ratio": 0.9866,
+      "suggested_scalar": -0.0112,
+      "log_bad": -0.3449,
+      "log_good": -0.3584
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7576,
+      "good": 5.719,
+      "ratio": 0.9933,
+      "suggested_scalar": -0.0056,
+      "log_bad": 1.7505,
+      "log_good": 1.7438
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7527,
+      "good": 0.8264,
+      "ratio": 1.0979,
+      "suggested_scalar": 0.0773,
+      "log_bad": -0.2841,
+      "log_good": -0.1907
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.0968,
+      "good": 0.1569,
+      "ratio": 1.6209,
+      "suggested_scalar": 0.3998,
+      "log_bad": -2.3351,
+      "log_good": -1.8521
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.8509,
+      "good": 3.8006,
+      "ratio": 0.9869,
+      "suggested_scalar": -0.0109,
+      "log_bad": 1.3483,
+      "log_good": 1.3352
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 292.0,
+      "good": 375.0,
+      "ratio": 1.2842,
+      "suggested_scalar": 0.2071,
+      "log_bad": 5.6768,
+      "log_good": 5.9269
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 11.0,
+      "good": 12.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.072,
+      "log_bad": 2.3979,
+      "log_good": 2.4849
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7773,
+      "good": 0.8893,
+      "ratio": 1.1441,
+      "suggested_scalar": 0.1114,
+      "log_bad": -0.2519,
+      "log_good": -0.1173
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 116.0,
+      "ratio": 1.0841,
+      "suggested_scalar": 0.0669,
+      "log_bad": 4.6728,
+      "log_good": 4.7536
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 798.0,
+      "good": 1171.0,
+      "ratio": 1.4674,
+      "suggested_scalar": 0.3175,
+      "log_bad": 6.6821,
+      "log_good": 7.0656
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 145.0,
+      "good": 140.0,
+      "ratio": 0.9655,
+      "suggested_scalar": -0.0291,
+      "log_bad": 4.9767,
+      "log_good": 4.9416
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0027,
+      "good": 0.002,
+      "ratio": 0.7407,
+      "suggested_scalar": -0.2485,
+      "log_bad": -5.9145,
+      "log_good": -6.2146
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2541,
+      "good": 0.2403,
+      "ratio": 0.9457,
+      "suggested_scalar": -0.0462,
+      "log_bad": -1.37,
+      "log_good": -1.4259
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 46.0,
+      "good": 95.0,
+      "ratio": 2.0652,
+      "suggested_scalar": 0.6004,
+      "log_bad": 3.8286,
+      "log_good": 4.5539
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 10.0,
+      "ratio": 3.3333,
+      "suggested_scalar": 0.9968,
+      "log_bad": 1.0986,
+      "log_good": 2.3026
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 116.0,
+      "ratio": 1.0841,
+      "suggested_scalar": 0.0669,
+      "log_bad": 4.6728,
+      "log_good": 4.7536
+    },
+    "brevity.mean_sample_size": {
+      "bad": 107.0,
+      "good": 116.0,
+      "ratio": 1.0841,
+      "suggested_scalar": 0.0669,
+      "log_bad": 4.6728,
+      "log_good": 4.7536
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 370.0,
+      "good": 491.0,
+      "ratio": 1.327,
+      "suggested_scalar": 0.2342,
+      "log_bad": 5.9135,
+      "log_good": 6.1964
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 173.0,
+      "good": 272.0,
+      "ratio": 1.5723,
+      "suggested_scalar": 0.3746,
+      "log_bad": 5.1533,
+      "log_good": 5.6058
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 246.0,
+      "good": 275.0,
+      "ratio": 1.1179,
+      "suggested_scalar": 0.0923,
+      "log_bad": 5.5053,
+      "log_good": 5.6168
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.1544,
+      "good": 2.704,
+      "ratio": 1.2551,
+      "suggested_scalar": 0.1881,
+      "log_bad": 0.7675,
+      "log_good": 0.9947
+    },
+    "halstead.mean_effort": {
+      "bad": 59402.808,
+      "good": 104847.8047,
+      "ratio": 1.765,
+      "suggested_scalar": 0.4704,
+      "log_bad": 10.9921,
+      "log_good": 11.5603
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8541,
+      "good": 0.8339,
+      "ratio": 0.9763,
+      "suggested_scalar": -0.0198,
+      "log_bad": -0.1577,
+      "log_good": -0.1816
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 74.0,
+      "good": 57.0,
+      "ratio": 0.7703,
+      "suggested_scalar": -0.2161,
+      "log_bad": 4.3041,
+      "log_good": 4.0431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 206.0,
+      "good": 272.0,
+      "ratio": 1.3204,
+      "suggested_scalar": 0.2301,
+      "log_bad": 5.3279,
+      "log_good": 5.6058
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5798,
+      "good": 0.4438,
+      "ratio": 0.7654,
+      "suggested_scalar": -0.2213,
+      "log_bad": -0.5451,
+      "log_good": -0.8124
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.7059,
+      "good": 6.929,
+      "ratio": 1.0333,
+      "suggested_scalar": 0.0271,
+      "log_bad": 1.903,
+      "log_good": 1.9357
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.0968,
+      "good": 0.1569,
+      "ratio": 1.6209,
+      "suggested_scalar": 0.3998,
+      "log_bad": -2.3351,
+      "log_good": -1.8521
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.3081,
+      "good": 4.5674,
+      "ratio": 1.3807,
+      "suggested_scalar": 0.2671,
+      "log_bad": 1.1964,
+      "log_good": 1.5189
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 369.0,
+      "good": 490.0,
+      "ratio": 1.3279,
+      "suggested_scalar": 0.2348,
+      "log_bad": 5.9108,
+      "log_good": 6.1944
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.5739,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 32.0,
+      "good": 66.0,
+      "ratio": 2.0625,
+      "suggested_scalar": 0.5993,
+      "log_bad": 3.4657,
+      "log_good": 4.1897
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3300.156,
+      "good": 5824.878,
+      "ratio": 1.765,
+      "suggested_scalar": 0.4704,
+      "log_bad": 8.1017,
+      "log_good": 8.6699
+    },
+    "readability.mean_total_lines": {
+      "bad": 51.0,
+      "good": 43.0,
+      "ratio": 0.8431,
+      "suggested_scalar": -0.1413,
+      "log_bad": 3.9318,
+      "log_good": 3.7612
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 4.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.9095,
+      "log_bad": 2.4849,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2331.9935,
+      "good": 2668.0022,
+      "ratio": 1.1441,
+      "suggested_scalar": 0.1114,
+      "log_bad": 7.7545,
+      "log_good": 7.8891
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 687.0,
+      "good": 735.0,
+      "ratio": 1.0699,
+      "suggested_scalar": 0.0559,
+      "log_bad": 6.5323,
+      "log_good": 6.5999
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 26.5098,
+      "good": 43.7209,
+      "ratio": 1.6492,
+      "suggested_scalar": 0.4142,
+      "log_bad": 3.2775,
+      "log_good": 3.7778
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1574,
+      "good": 1.1244,
+      "ratio": 0.9715,
+      "suggested_scalar": -0.0239,
+      "log_bad": 0.1462,
+      "log_good": 0.1172
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 16.0,
+      "good": 19.0,
+      "ratio": 1.1875,
+      "suggested_scalar": 0.1423,
+      "log_bad": 2.7726,
+      "log_good": 2.9444
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 1.0,
+      "ratio": 0.2,
+      "suggested_scalar": -1.3325,
+      "log_bad": 1.6094,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8904,
+      "good": 0.824,
+      "ratio": 0.9254,
+      "suggested_scalar": -0.0642,
+      "log_bad": -0.1161,
+      "log_good": -0.1936
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 5.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.7586,
+      "log_bad": 0.6931,
+      "log_good": 1.6094
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9647,
+      "good": 0.9876,
+      "ratio": 1.0237,
+      "suggested_scalar": 0.0194,
+      "log_bad": -0.0359,
+      "log_good": -0.0125
+    },
+    "halstead.mean_length": {
+      "bad": 351.0,
+      "good": 412.0,
+      "ratio": 1.1738,
+      "suggested_scalar": 0.1327,
+      "log_bad": 5.8608,
+      "log_good": 6.021
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 16.6667,
+      "good": 3.5,
+      "ratio": 0.21,
+      "suggested_scalar": -1.2921,
+      "log_bad": 2.8134,
+      "log_good": 1.2528
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7415,
+      "good": 6.858,
+      "ratio": 1.0173,
+      "suggested_scalar": 0.0142,
+      "log_bad": 1.9083,
+      "log_good": 1.9254
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0985,
+      "good": 0.1409,
+      "ratio": 1.4305,
+      "suggested_scalar": 0.2964,
+      "log_bad": -2.3177,
+      "log_good": -1.9597
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.473,
+      "good": 39.2982,
+      "ratio": 1.5427,
+      "suggested_scalar": 0.3589,
+      "log_bad": 3.2376,
+      "log_good": 3.6712
+    },
+    "branching.mean_branch_count": {
+      "bad": 18.0,
+      "good": 6.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.9095,
+      "log_bad": 2.8904,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 69.0,
+      "good": 75.0,
+      "ratio": 1.087,
+      "suggested_scalar": 0.069,
+      "log_bad": 4.2341,
+      "log_good": 4.3175
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.813,
+      "good": 0.6545,
+      "ratio": 0.805,
+      "suggested_scalar": -0.1795,
+      "log_bad": -0.207,
+      "log_good": -0.4239
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 56.0,
+      "good": 43.0,
+      "ratio": 0.7679,
+      "suggested_scalar": -0.2187,
+      "log_bad": 4.0254,
+      "log_good": 3.7612
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_list_comprehension_for_side_effects": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 38.0,
+      "good": 46.0,
+      "ratio": 1.2105,
+      "suggested_scalar": 0.1009,
+      "log_bad": 3.6376,
+      "log_good": 3.8286
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0369,
+      "good": 0.0424,
+      "ratio": 1.1491,
+      "suggested_scalar": 0.0734,
+      "log_bad": -3.2995,
+      "log_good": -3.1606
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.2,
+      "good": 1.2,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1823,
+      "log_good": 0.1823
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9773,
+      "good": 0.8814,
+      "ratio": 0.9019,
+      "suggested_scalar": -0.0546,
+      "log_bad": -0.023,
+      "log_good": -0.1262
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0369,
+      "good": 0.0424,
+      "ratio": 1.1491,
+      "suggested_scalar": 0.0734,
+      "log_bad": -3.2995,
+      "log_good": -3.1606
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6427,
+      "good": 4.4486,
+      "ratio": 0.9582,
+      "suggested_scalar": -0.0226,
+      "log_bad": 1.5353,
+      "log_good": 1.4926
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 95.0,
+      "good": 84.0,
+      "ratio": 0.8842,
+      "suggested_scalar": -0.065,
+      "log_bad": 4.5539,
+      "log_good": 4.4308
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5251,
+      "good": 0.4754,
+      "ratio": 0.9054,
+      "suggested_scalar": -0.0525,
+      "log_bad": -0.6442,
+      "log_good": -0.7436
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 15.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.0661,
+      "log_bad": 2.8332,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6589,
+      "good": 0.6359,
+      "ratio": 0.9651,
+      "suggested_scalar": -0.0188,
+      "log_bad": -0.4172,
+      "log_good": -0.4527
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.0909,
+      "good": 4.9492,
+      "ratio": 1.6012,
+      "suggested_scalar": 0.2487,
+      "log_bad": 1.1285,
+      "log_good": 1.5992
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 461.0,
+      "good": 448.0,
+      "ratio": 0.9718,
+      "suggested_scalar": -0.0151,
+      "log_bad": 6.1334,
+      "log_good": 6.1048
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 2.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.3662,
+      "log_bad": 1.3863,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0227,
+      "good": 1.0,
+      "ratio": 44.0529,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.7854,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9418,
+      "good": 0.9868,
+      "ratio": 1.0478,
+      "suggested_scalar": 0.0247,
+      "log_bad": -0.06,
+      "log_good": -0.0133
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 193.0,
+      "good": 173.0,
+      "ratio": 0.8964,
+      "suggested_scalar": -0.0578,
+      "log_bad": 5.2627,
+      "log_good": 5.1533
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 102.6934,
+      "good": 103.3411,
+      "ratio": 1.0063,
+      "suggested_scalar": 0.0033,
+      "log_bad": 4.6317,
+      "log_good": 4.638
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4957,
+      "good": 0.5034,
+      "ratio": 1.0155,
+      "suggested_scalar": 0.0081,
+      "log_bad": -0.7018,
+      "log_good": -0.6864
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.1387,
+      "good": 8.197,
+      "ratio": 0.8085,
+      "suggested_scalar": -0.1123,
+      "log_bad": 2.3164,
+      "log_good": 2.1038
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2056.0,
+      "good": 2072.0,
+      "ratio": 1.0078,
+      "suggested_scalar": 0.0041,
+      "log_bad": 7.6285,
+      "log_good": 7.6363
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2727,
+      "good": 0.2542,
+      "ratio": 0.9322,
+      "suggested_scalar": -0.0371,
+      "log_bad": -1.2994,
+      "log_good": -1.3696
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9773,
+      "good": 0.8814,
+      "ratio": 0.9019,
+      "suggested_scalar": -0.0546,
+      "log_bad": -0.023,
+      "log_good": -0.1262
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.7209,
+      "good": 7.5932,
+      "ratio": 0.7083,
+      "suggested_scalar": -0.1822,
+      "log_bad": 2.3722,
+      "log_good": 2.0273
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 0.7324,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.152,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 6.4463,
+      "good": 16.455,
+      "ratio": 2.5526,
+      "suggested_scalar": 0.4951,
+      "log_bad": 1.8635,
+      "log_good": 2.8006
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 163.0,
+      "good": 143.0,
+      "ratio": 0.8773,
+      "suggested_scalar": -0.0692,
+      "log_bad": 5.0938,
+      "log_good": 4.9628
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9416,
+      "good": 0.9423,
+      "ratio": 1.0007,
+      "suggested_scalar": 0.0004,
+      "log_bad": -0.0602,
+      "log_good": -0.0594
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 28.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3322,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6104,
+      "good": 0.6245,
+      "ratio": 1.0231,
+      "suggested_scalar": 0.0121,
+      "log_bad": -0.4936,
+      "log_good": -0.4708
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3094,
+      "good": 0.3363,
+      "ratio": 1.0869,
+      "suggested_scalar": 0.044,
+      "log_bad": -1.1731,
+      "log_good": -1.0898
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5668,
+      "good": 2.6632,
+      "ratio": 1.0376,
+      "suggested_scalar": 0.0195,
+      "log_bad": 0.9427,
+      "log_good": 0.9795
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 459.0,
+      "good": 446.0,
+      "ratio": 0.9717,
+      "suggested_scalar": -0.0152,
+      "log_bad": 6.1291,
+      "log_good": 6.1003
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 9.0,
+      "good": 21.0,
+      "ratio": 2.3333,
+      "suggested_scalar": 0.4477,
+      "log_bad": 2.1972,
+      "log_good": 3.0445
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0607,
+      "good": 0.0625,
+      "ratio": 1.0297,
+      "suggested_scalar": 0.0154,
+      "log_bad": -2.8018,
+      "log_good": -2.7726
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8826,
+      "good": 5.8074,
+      "ratio": 0.9872,
+      "suggested_scalar": -0.0068,
+      "log_bad": 1.772,
+      "log_good": 1.7591
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 26.0,
+      "good": 27.0,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0199,
+      "log_bad": 3.2581,
+      "log_good": 3.2958
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7113,
+      "good": 0.7468,
+      "ratio": 1.0499,
+      "suggested_scalar": 0.0257,
+      "log_bad": -0.3407,
+      "log_good": -0.292
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.0975,
+      "good": 5.9454,
+      "ratio": 0.9751,
+      "suggested_scalar": -0.0133,
+      "log_bad": 1.8079,
+      "log_good": 1.7826
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7892,
+      "good": 0.766,
+      "ratio": 0.9706,
+      "suggested_scalar": -0.0158,
+      "log_bad": -0.2367,
+      "log_good": -0.2666
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2787,
+      "good": 0.2237,
+      "ratio": 0.8027,
+      "suggested_scalar": -0.1161,
+      "log_bad": -1.2776,
+      "log_good": -1.4974
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1841,
+      "good": 2.863,
+      "ratio": 0.8992,
+      "suggested_scalar": -0.0562,
+      "log_bad": 1.1582,
+      "log_good": 1.0519
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 368.0,
+      "good": 351.0,
+      "ratio": 0.9538,
+      "suggested_scalar": -0.025,
+      "log_bad": 5.9081,
+      "log_good": 5.8608
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 6.0,
+      "good": 8.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.152,
+      "log_bad": 1.7918,
+      "log_good": 2.0794
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7906,
+      "good": 0.7735,
+      "ratio": 0.9784,
+      "suggested_scalar": -0.0116,
+      "log_bad": -0.235,
+      "log_good": -0.2568
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 121.0,
+      "good": 116.0,
+      "ratio": 0.9587,
+      "suggested_scalar": -0.0223,
+      "log_bad": 4.7958,
+      "log_good": 4.7536
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1222.0,
+      "good": 1070.0,
+      "ratio": 0.8756,
+      "suggested_scalar": -0.0702,
+      "log_bad": 7.1082,
+      "log_good": 6.9754
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 162.0,
+      "good": 155.0,
+      "ratio": 0.9568,
+      "suggested_scalar": -0.0233,
+      "log_bad": 5.0876,
+      "log_good": 5.0434
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.2142,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0108,
+      "good": 0.0112,
+      "ratio": 1.037,
+      "suggested_scalar": 0.0192,
+      "log_bad": -4.5282,
+      "log_good": -4.4918
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2495,
+      "good": 0.2612,
+      "ratio": 1.0469,
+      "suggested_scalar": 0.0242,
+      "log_bad": -1.3883,
+      "log_good": -1.3425
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 78.0,
+      "good": 75.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0207,
+      "log_bad": 4.3567,
+      "log_good": 4.3175
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 121.0,
+      "good": 116.0,
+      "ratio": 0.9587,
+      "suggested_scalar": -0.0223,
+      "log_bad": 4.7958,
+      "log_good": 4.7536
+    },
+    "brevity.mean_sample_size": {
+      "bad": 121.0,
+      "good": 116.0,
+      "ratio": 0.9587,
+      "suggested_scalar": -0.0223,
+      "log_bad": 4.7958,
+      "log_good": 4.7536
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 461.0,
+      "good": 448.0,
+      "ratio": 0.9718,
+      "suggested_scalar": -0.0151,
+      "log_bad": 6.1334,
+      "log_good": 6.1048
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 206.0,
+      "good": 205.0,
+      "ratio": 0.9951,
+      "suggested_scalar": -0.0026,
+      "log_bad": 5.3279,
+      "log_good": 5.323
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 310.0,
+      "good": 297.0,
+      "ratio": 0.9581,
+      "suggested_scalar": -0.0226,
+      "log_bad": 5.7366,
+      "log_good": 5.6937
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.2614,
+      "good": 2.4979,
+      "ratio": 1.1046,
+      "suggested_scalar": 0.0526,
+      "log_bad": 0.816,
+      "log_good": 0.9155
+    },
+    "halstead.mean_effort": {
+      "bad": 80284.42,
+      "good": 89915.9349,
+      "ratio": 1.12,
+      "suggested_scalar": 0.0599,
+      "log_bad": 11.2933,
+      "log_good": 11.4066
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.5804,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8813,
+      "good": 0.8669,
+      "ratio": 0.9837,
+      "suggested_scalar": -0.0087,
+      "log_bad": -0.1264,
+      "log_good": -0.1428
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 67.0,
+      "good": 56.0,
+      "ratio": 0.8358,
+      "suggested_scalar": -0.0948,
+      "log_bad": 4.2047,
+      "log_good": 4.0254
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 199.0,
+      "good": 208.0,
+      "ratio": 1.0452,
+      "suggested_scalar": 0.0234,
+      "log_bad": 5.2933,
+      "log_good": 5.3375
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4249,
+      "good": 0.4393,
+      "ratio": 1.0339,
+      "suggested_scalar": 0.0176,
+      "log_bad": -0.8559,
+      "log_good": -0.8226
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.3316,
+      "good": 6.185,
+      "ratio": 0.9768,
+      "suggested_scalar": -0.0124,
+      "log_bad": 1.8456,
+      "log_good": 1.8221
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2787,
+      "good": 0.2237,
+      "ratio": 0.8027,
+      "suggested_scalar": -0.1161,
+      "log_bad": -1.2776,
+      "log_good": -1.4974
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.4459,
+      "good": 3.0373,
+      "ratio": 0.6832,
+      "suggested_scalar": -0.2013,
+      "log_bad": 1.492,
+      "log_good": 1.111
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.3662,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 460.0,
+      "good": 447.0,
+      "ratio": 0.9717,
+      "suggested_scalar": -0.0151,
+      "log_bad": 6.1312,
+      "log_good": 6.1026
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 51.0,
+      "good": 55.0,
+      "ratio": 1.0784,
+      "suggested_scalar": 0.0399,
+      "log_bad": 3.9318,
+      "log_good": 4.0073
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4460.2456,
+      "good": 4995.3297,
+      "ratio": 1.12,
+      "suggested_scalar": 0.0599,
+      "log_bad": 8.403,
+      "log_good": 8.5163
+    },
+    "readability.mean_total_lines": {
+      "bad": 43.0,
+      "good": 59.0,
+      "ratio": 1.3721,
+      "suggested_scalar": 0.1671,
+      "log_bad": 3.7612,
+      "log_good": 4.0775
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 12.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.2142,
+      "log_bad": 2.0794,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2371.7179,
+      "good": 2320.4112,
+      "ratio": 0.9784,
+      "suggested_scalar": -0.0116,
+      "log_bad": 7.7714,
+      "log_good": 7.7495
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 801.0,
+      "good": 778.0,
+      "ratio": 0.9713,
+      "suggested_scalar": -0.0154,
+      "log_bad": 6.6859,
+      "log_good": 6.6567
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 44.4651,
+      "good": 33.7627,
+      "ratio": 0.7593,
+      "suggested_scalar": -0.1455,
+      "log_bad": 3.7947,
+      "log_good": 3.5194
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1024,
+      "good": 1.1322,
+      "ratio": 1.027,
+      "suggested_scalar": 0.0141,
+      "log_bad": 0.0975,
+      "log_good": 0.1242
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 2.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.3662,
+      "log_bad": 1.3863,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 16.0,
+      "good": 20.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.1179,
+      "log_bad": 2.7726,
+      "log_good": 2.9957
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8614,
+      "good": 0.8433,
+      "ratio": 0.979,
+      "suggested_scalar": -0.0112,
+      "log_bad": -0.1492,
+      "log_good": -0.1704
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0883,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9853,
+      "good": 0.9774,
+      "ratio": 0.992,
+      "suggested_scalar": -0.0043,
+      "log_bad": -0.0148,
+      "log_good": -0.0229
+    },
+    "halstead.mean_length": {
+      "bad": 361.0,
+      "good": 363.0,
+      "ratio": 1.0055,
+      "suggested_scalar": 0.0029,
+      "log_bad": 5.8889,
+      "log_good": 5.8944
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.6,
+      "good": 9.6,
+      "ratio": 1.4545,
+      "suggested_scalar": 0.198,
+      "log_bad": 1.8871,
+      "log_good": 2.2618
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9189,
+      "good": 6.858,
+      "ratio": 0.9912,
+      "suggested_scalar": -0.0047,
+      "log_bad": 1.9343,
+      "log_good": 1.9254
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1006,
+      "good": 0.0991,
+      "ratio": 0.9851,
+      "suggested_scalar": -0.0079,
+      "log_bad": -2.2966,
+      "log_good": -2.3116
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 33.8507,
+      "good": 38.75,
+      "ratio": 1.1447,
+      "suggested_scalar": 0.0714,
+      "log_bad": 3.522,
+      "log_good": 3.6571
+    },
+    "branching.mean_branch_count": {
+      "bad": 12.0,
+      "good": 15.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.1179,
+      "log_bad": 2.4849,
+      "log_good": 2.7081
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 82.0,
+      "good": 76.0,
+      "ratio": 0.9268,
+      "suggested_scalar": -0.0401,
+      "log_bad": 4.4067,
+      "log_good": 4.3307
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7484,
+      "good": 0.7475,
+      "ratio": 0.9988,
+      "suggested_scalar": -0.0006,
+      "log_bad": -0.2898,
+      "log_good": -0.291
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 44.0,
+      "good": 59.0,
+      "ratio": 1.3409,
+      "suggested_scalar": 0.155,
+      "log_bad": 3.7842,
+      "log_good": 4.0775
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 15.0,
+      "ratio": 0.7895,
+      "suggested_scalar": -0.1249,
+      "log_bad": 2.9444,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_class_variables": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -1.2661,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.7143,
+      "good": 0.6667,
+      "ratio": 0.9334,
+      "suggested_scalar": -0.2153,
+      "log_bad": -0.3365,
+      "log_good": -0.4054
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8108,
+      "good": 0.8378,
+      "ratio": 1.0333,
+      "suggested_scalar": 0.1023,
+      "log_bad": -0.2097,
+      "log_good": -0.177
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4949,
+      "good": 4.4523,
+      "ratio": 0.9905,
+      "suggested_scalar": -0.0297,
+      "log_bad": 1.5029,
+      "log_good": 1.4934
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 55.0,
+      "good": 62.0,
+      "ratio": 1.1273,
+      "suggested_scalar": 0.3741,
+      "log_bad": 4.0073,
+      "log_good": 4.1271
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5075,
+      "good": 0.6119,
+      "ratio": 1.2057,
+      "suggested_scalar": 0.5842,
+      "log_bad": -0.6783,
+      "log_good": -0.4912
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6135,
+      "good": 0.6461,
+      "ratio": 1.0531,
+      "suggested_scalar": 0.1617,
+      "log_bad": -0.4886,
+      "log_good": -0.4368
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.3243,
+      "good": 2.8108,
+      "ratio": 1.2093,
+      "suggested_scalar": 0.5935,
+      "log_bad": 0.8434,
+      "log_good": 1.0335
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 177.0,
+      "good": 163.0,
+      "ratio": 0.9209,
+      "suggested_scalar": -0.2573,
+      "log_bad": 5.1761,
+      "log_good": 5.0938
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0811,
+      "good": 0.0811,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.5121,
+      "log_good": -2.5121
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0011,
+      "good": 0.001,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.2976,
+      "log_bad": -6.8124,
+      "log_good": -6.9078
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9324,
+      "good": 0.8342,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.3475,
+      "log_bad": -0.07,
+      "log_good": -0.1813
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 67.0,
+      "good": 67.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2047,
+      "log_good": 4.2047
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 85.1123,
+      "good": 85.31,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0072,
+      "log_bad": 4.444,
+      "log_good": 4.4463
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.3864,
+      "good": 0.2716,
+      "ratio": 0.7029,
+      "suggested_scalar": -1.1009,
+      "log_bad": -0.9509,
+      "log_good": -1.3034
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 16.6376,
+      "good": 29.3696,
+      "ratio": 1.7653,
+      "suggested_scalar": 1.7746,
+      "log_bad": 2.8117,
+      "log_good": 3.38
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 947.0,
+      "good": 1.0e3,
+      "ratio": 1.056,
+      "suggested_scalar": 0.17,
+      "log_bad": 6.8533,
+      "log_good": 6.9078
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.027,
+      "good": 0.027,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.6119,
+      "log_good": -3.6119
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7838,
+      "good": 0.7568,
+      "ratio": 0.9656,
+      "suggested_scalar": -0.1095,
+      "log_bad": -0.2436,
+      "log_good": -0.2787
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.2059,
+      "good": 4.7941,
+      "ratio": 0.9209,
+      "suggested_scalar": -0.2573,
+      "log_bad": 1.6498,
+      "log_good": 1.5674
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.4083,
+      "good": 2.4777,
+      "ratio": 1.7594,
+      "suggested_scalar": 1.7641,
+      "log_bad": 0.3424,
+      "log_good": 0.9073
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 60.0,
+      "good": 60.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0943,
+      "log_good": 4.0943
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9249,
+      "good": 0.915,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.0336,
+      "log_bad": -0.0781,
+      "log_good": -0.0888
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 14.0,
+      "good": 16.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.417,
+      "log_bad": 2.6391,
+      "log_good": 2.7726
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.604,
+      "good": 0.581,
+      "ratio": 0.9619,
+      "suggested_scalar": -0.1212,
+      "log_bad": -0.5042,
+      "log_good": -0.543
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.1886,
+      "good": 0.0994,
+      "ratio": 0.527,
+      "suggested_scalar": -2.0,
+      "log_bad": -1.6681,
+      "log_good": -2.3086
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5253,
+      "good": 2.3866,
+      "ratio": 0.9451,
+      "suggested_scalar": -0.1764,
+      "log_bad": 0.9264,
+      "log_good": 0.8699
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 175.0,
+      "good": 161.0,
+      "ratio": 0.92,
+      "suggested_scalar": -0.2604,
+      "log_bad": 5.1648,
+      "log_good": 5.0814
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 12.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.2717,
+      "log_bad": 2.3979,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0169,
+      "good": 0.0184,
+      "ratio": 1.0888,
+      "suggested_scalar": 0.2655,
+      "log_bad": -4.0804,
+      "log_good": -3.9954
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.5236,
+      "good": 5.5546,
+      "ratio": 1.0056,
+      "suggested_scalar": 0.0175,
+      "log_bad": 1.709,
+      "log_good": 1.7146
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.483,
+      "good": 0.483,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.7277,
+      "log_good": -0.7277
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 4.9583,
+      "good": 5.3718,
+      "ratio": 1.0834,
+      "suggested_scalar": 0.2501,
+      "log_bad": 1.6011,
+      "log_good": 1.6812
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8138,
+      "good": 0.8016,
+      "ratio": 0.985,
+      "suggested_scalar": -0.0472,
+      "log_bad": -0.206,
+      "log_good": -0.2211
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1957,
+      "good": 0.2128,
+      "ratio": 1.0874,
+      "suggested_scalar": 0.2616,
+      "log_bad": -1.6312,
+      "log_good": -1.5474
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.0789,
+      "good": 5.4194,
+      "ratio": 1.3286,
+      "suggested_scalar": 0.8873,
+      "log_bad": 1.4058,
+      "log_good": 1.69
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 153.0,
+      "good": 153.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.0304,
+      "log_good": 5.0304
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.2621,
+      "good": 0.2798,
+      "ratio": 1.0675,
+      "suggested_scalar": 0.2041,
+      "log_bad": -1.339,
+      "log_good": -1.2737
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 58.0,
+      "good": 64.0,
+      "ratio": 1.1034,
+      "suggested_scalar": 0.3074,
+      "log_bad": 4.0604,
+      "log_good": 4.1589
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 571.0,
+      "good": 599.0,
+      "ratio": 1.049,
+      "suggested_scalar": 0.1495,
+      "log_bad": 6.3474,
+      "log_good": 6.3953
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 78.0,
+      "good": 76.0,
+      "ratio": 0.9744,
+      "suggested_scalar": -0.0811,
+      "log_bad": 4.3567,
+      "log_good": 4.3307
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1017,
+      "good": 0.1043,
+      "ratio": 1.0256,
+      "suggested_scalar": 0.0788,
+      "log_bad": -2.2857,
+      "log_good": -2.2605
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 18.0,
+      "good": 19.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.1688,
+      "log_bad": 2.8904,
+      "log_good": 2.9444
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 6.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.4814,
+      "log_bad": 1.9459,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 58.0,
+      "good": 64.0,
+      "ratio": 1.1034,
+      "suggested_scalar": 0.3074,
+      "log_bad": 4.0604,
+      "log_good": 4.1589
+    },
+    "brevity.mean_sample_size": {
+      "bad": 58.0,
+      "good": 64.0,
+      "ratio": 1.1034,
+      "suggested_scalar": 0.3074,
+      "log_bad": 4.0604,
+      "log_good": 4.1589
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 177.0,
+      "good": 163.0,
+      "ratio": 0.9209,
+      "suggested_scalar": -0.2573,
+      "log_bad": 5.1761,
+      "log_good": 5.0938
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 79.0,
+      "good": 62.0,
+      "ratio": 0.7848,
+      "suggested_scalar": -0.7567,
+      "log_bad": 4.3694,
+      "log_good": 4.1271
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 126.0,
+      "good": 137.0,
+      "ratio": 1.0873,
+      "suggested_scalar": 0.2614,
+      "log_bad": 4.8363,
+      "log_good": 4.92
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0113,
+      "good": 0.0123,
+      "ratio": 1.0885,
+      "suggested_scalar": 0.2648,
+      "log_bad": -4.483,
+      "log_good": -4.3982
+    },
+    "heaps.mean_k": {
+      "bad": 2.1839,
+      "good": 2.1106,
+      "ratio": 0.9664,
+      "suggested_scalar": -0.1066,
+      "log_bad": 0.7811,
+      "log_good": 0.747
+    },
+    "halstead.mean_effort": {
+      "bad": 10470.7475,
+      "good": 11096.5509,
+      "ratio": 1.0598,
+      "suggested_scalar": 0.1813,
+      "log_bad": 9.2563,
+      "log_good": 9.3144
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8464,
+      "good": 0.8953,
+      "ratio": 1.0578,
+      "suggested_scalar": 0.1754,
+      "log_bad": -0.1668,
+      "log_good": -0.1106
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 41.0,
+      "good": 46.0,
+      "ratio": 1.122,
+      "suggested_scalar": 0.3593,
+      "log_bad": 3.7136,
+      "log_good": 3.8286
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 58.0,
+      "good": 65.0,
+      "ratio": 1.1207,
+      "suggested_scalar": 0.3558,
+      "log_bad": 4.0604,
+      "log_good": 4.1744
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5075,
+      "good": 0.6119,
+      "ratio": 1.2057,
+      "suggested_scalar": 0.5842,
+      "log_bad": -0.6783,
+      "log_good": -0.4912
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.5224,
+      "good": 8.9403,
+      "ratio": 1.049,
+      "suggested_scalar": 0.1495,
+      "log_bad": 2.1427,
+      "log_good": 2.1906
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1957,
+      "good": 0.2128,
+      "ratio": 1.0874,
+      "suggested_scalar": 0.2616,
+      "log_bad": -1.6312,
+      "log_good": -1.5474
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.663,
+      "good": 5.2861,
+      "ratio": 1.1336,
+      "suggested_scalar": 0.3917,
+      "log_bad": 1.5397,
+      "log_good": 1.6651
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 176.0,
+      "good": 162.0,
+      "ratio": 0.9205,
+      "suggested_scalar": -0.2588,
+      "log_bad": 5.1705,
+      "log_good": 5.0876
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 11.0,
+      "good": 8.0,
+      "ratio": 0.7273,
+      "suggested_scalar": -0.9944,
+      "log_bad": 2.3979,
+      "log_good": 2.0794
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 581.7082,
+      "good": 616.475,
+      "ratio": 1.0598,
+      "suggested_scalar": 0.1813,
+      "log_bad": 6.366,
+      "log_good": 6.424
+    },
+    "readability.mean_total_lines": {
+      "bad": 34.0,
+      "good": 34.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5264,
+      "log_good": 3.5264
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 1.2661,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 786.2649,
+      "good": 839.5417,
+      "ratio": 1.0678,
+      "suggested_scalar": 0.2047,
+      "log_bad": 6.6673,
+      "log_good": 6.7329
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 375.0,
+      "good": 419.0,
+      "ratio": 1.1173,
+      "suggested_scalar": 0.3464,
+      "log_bad": 5.9269,
+      "log_good": 6.0379
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 20.2059,
+      "good": 22.2647,
+      "ratio": 1.1019,
+      "suggested_scalar": 0.303,
+      "log_bad": 3.006,
+      "log_good": 3.103
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3763,
+      "good": 1.3789,
+      "ratio": 1.0019,
+      "suggested_scalar": 0.0059,
+      "log_bad": 0.3194,
+      "log_good": 0.3213
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9281,
+      "good": 0.9477,
+      "ratio": 1.0211,
+      "suggested_scalar": 0.0653,
+      "log_bad": -0.0746,
+      "log_good": -0.0537
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9571,
+      "good": 0.9719,
+      "ratio": 1.0155,
+      "suggested_scalar": 0.0479,
+      "log_bad": -0.0438,
+      "log_good": -0.0285
+    },
+    "halstead.mean_length": {
+      "bad": 136.0,
+      "good": 141.0,
+      "ratio": 1.0368,
+      "suggested_scalar": 0.1127,
+      "log_bad": 4.9127,
+      "log_good": 4.9488
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.7143,
+      "good": 6.3333,
+      "ratio": 1.1083,
+      "suggested_scalar": 0.3212,
+      "log_bad": 1.743,
+      "log_good": 1.8458
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.858,
+      "good": 6.0,
+      "ratio": 1.0242,
+      "suggested_scalar": 0.0748,
+      "log_bad": 1.7678,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0836,
+      "good": 0.062,
+      "ratio": 0.7416,
+      "suggested_scalar": -0.9334,
+      "log_bad": -2.4817,
+      "log_good": -2.7806
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 13.3171,
+      "good": 13.2174,
+      "ratio": 0.9925,
+      "suggested_scalar": -0.0235,
+      "log_bad": 2.589,
+      "log_good": 2.5815
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 34.0,
+      "good": 41.0,
+      "ratio": 1.2059,
+      "suggested_scalar": 0.5846,
+      "log_bad": 3.5264,
+      "log_good": 3.7136
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8571,
+      "good": 0.8613,
+      "ratio": 1.0049,
+      "suggested_scalar": 0.0153,
+      "log_bad": -0.1542,
+      "log_good": -0.1493
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 37.0,
+      "good": 37.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6109,
+      "log_good": 3.6109
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 26.0,
+      "ratio": 1.5294,
+      "suggested_scalar": 1.3268,
+      "log_bad": 2.8332,
+      "log_good": 3.2581
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.fields_defined_in_constructor": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 48.0,
+      "good": 42.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0392,
+      "log_bad": 3.8712,
+      "log_good": 3.7377
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7887,
+      "good": 0.8154,
+      "ratio": 1.0339,
+      "suggested_scalar": 0.0098,
+      "log_bad": -0.2374,
+      "log_good": -0.2041
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5919,
+      "good": 4.5812,
+      "ratio": 0.9977,
+      "suggested_scalar": -0.0007,
+      "log_bad": 1.5243,
+      "log_good": 1.522
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 70.0,
+      "good": 67.0,
+      "ratio": 0.9571,
+      "suggested_scalar": -0.0129,
+      "log_bad": 4.2485,
+      "log_good": 4.2047
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.34,
+      "good": 0.3368,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.0028,
+      "log_bad": -1.0788,
+      "log_good": -1.0883
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 15.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.0367,
+      "log_bad": 2.8332,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5309,
+      "good": 0.538,
+      "ratio": 1.0134,
+      "suggested_scalar": 0.0039,
+      "log_bad": -0.6332,
+      "log_good": -0.6199
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.2394,
+      "good": 3.2923,
+      "ratio": 1.0163,
+      "suggested_scalar": 0.0048,
+      "log_bad": 1.1754,
+      "log_good": 1.1916
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 424.0,
+      "good": 394.0,
+      "ratio": 0.9292,
+      "suggested_scalar": -0.0215,
+      "log_bad": 6.0497,
+      "log_good": 5.9764
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0011,
+      "good": 1.0,
+      "ratio": 909.0909,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.8124,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0034,
+      "good": 0.005,
+      "ratio": 1.4706,
+      "suggested_scalar": 0.1132,
+      "log_bad": -5.684,
+      "log_good": -5.2983
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1015,
+      "good": 1.1036,
+      "ratio": 1.0019,
+      "suggested_scalar": 0.0006,
+      "log_bad": 0.0967,
+      "log_good": 0.0986
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 105.0,
+      "good": 95.0,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.0294,
+      "log_bad": 4.654,
+      "log_good": 4.5539
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 89.1016,
+      "good": 91.1102,
+      "ratio": 1.0225,
+      "suggested_scalar": 0.0065,
+      "log_bad": 4.4898,
+      "log_good": 4.5121
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6832,
+      "good": 0.6692,
+      "ratio": 0.9795,
+      "suggested_scalar": -0.0061,
+      "log_bad": -0.381,
+      "log_good": -0.4017
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.8119,
+      "good": 7.8294,
+      "ratio": 1.0022,
+      "suggested_scalar": 0.0007,
+      "log_bad": 2.0556,
+      "log_good": 2.0579
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1739.0,
+      "good": 1613.0,
+      "ratio": 0.9275,
+      "suggested_scalar": -0.0221,
+      "log_bad": 7.4611,
+      "log_good": 7.3859
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0423,
+      "good": 0.0154,
+      "ratio": 0.3641,
+      "suggested_scalar": -0.2966,
+      "log_bad": -3.163,
+      "log_good": -4.1734
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7606,
+      "good": 0.7846,
+      "ratio": 1.0316,
+      "suggested_scalar": 0.0091,
+      "log_bad": -0.2736,
+      "log_good": -0.2426
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.9718,
+      "good": 6.0615,
+      "ratio": 1.015,
+      "suggested_scalar": 0.0044,
+      "log_bad": 1.787,
+      "log_good": 1.802
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.5201,
+      "good": 2.6376,
+      "ratio": 1.0466,
+      "suggested_scalar": 0.0134,
+      "log_bad": 0.9243,
+      "log_good": 0.9699
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 39.0,
+      "good": 35.0,
+      "ratio": 0.8974,
+      "suggested_scalar": -0.0318,
+      "log_bad": 3.6636,
+      "log_good": 3.5553
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9481,
+      "good": 0.9457,
+      "ratio": 0.9975,
+      "suggested_scalar": -0.0007,
+      "log_bad": -0.0533,
+      "log_good": -0.0558
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 22.0,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.0131,
+      "log_bad": 3.1355,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6688,
+      "good": 0.6609,
+      "ratio": 0.9882,
+      "suggested_scalar": -0.0035,
+      "log_bad": -0.4023,
+      "log_good": -0.4142
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4479,
+      "good": 0.4592,
+      "ratio": 1.0252,
+      "suggested_scalar": 0.0073,
+      "log_bad": -0.8032,
+      "log_good": -0.7783
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0191,
+      "good": 2.9488,
+      "ratio": 0.9767,
+      "suggested_scalar": -0.0069,
+      "log_bad": 1.105,
+      "log_good": 1.0814
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 422.0,
+      "good": 392.0,
+      "ratio": 0.9289,
+      "suggested_scalar": -0.0216,
+      "log_bad": 6.045,
+      "log_good": 5.9713
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0142,
+      "good": 0.0203,
+      "ratio": 1.4296,
+      "suggested_scalar": 0.1049,
+      "log_bad": -4.2545,
+      "log_good": -3.8971
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.7814,
+      "ratio": 0.9912,
+      "suggested_scalar": -0.0026,
+      "log_bad": 1.7635,
+      "log_good": 1.7546
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.6546,
+      "good": 1.6955,
+      "ratio": 1.0247,
+      "suggested_scalar": 0.0072,
+      "log_bad": 0.5036,
+      "log_good": 0.528
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.12,
+      "good": 5.1201,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6332,
+      "log_good": 1.6332
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7872,
+      "good": 0.7924,
+      "ratio": 1.0066,
+      "suggested_scalar": 0.0019,
+      "log_bad": -0.2393,
+      "log_good": -0.2327
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1548,
+      "good": 0.1447,
+      "ratio": 0.9348,
+      "suggested_scalar": -0.0198,
+      "log_bad": -1.8656,
+      "log_good": -1.9331
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.795,
+      "good": 2.7981,
+      "ratio": 1.0011,
+      "suggested_scalar": 0.0003,
+      "log_bad": 1.0278,
+      "log_good": 1.0289
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 301.0,
+      "good": 273.0,
+      "ratio": 0.907,
+      "suggested_scalar": -0.0287,
+      "log_bad": 5.7071,
+      "log_good": 5.6095
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.854,
+      "good": 0.7805,
+      "ratio": 0.9139,
+      "suggested_scalar": -0.0264,
+      "log_bad": -0.1578,
+      "log_good": -0.2478
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 71.0,
+      "good": 68.0,
+      "ratio": 0.9577,
+      "suggested_scalar": -0.0127,
+      "log_bad": 4.2627,
+      "log_good": 4.2195
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 773.0,
+      "good": 685.0,
+      "ratio": 0.8862,
+      "suggested_scalar": -0.0355,
+      "log_bad": 6.6503,
+      "log_good": 6.5294
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 161.0,
+      "good": 150.0,
+      "ratio": 0.9317,
+      "suggested_scalar": -0.0208,
+      "log_bad": 5.0814,
+      "log_good": 5.0106
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.309,
+      "good": 0.3122,
+      "ratio": 1.0104,
+      "suggested_scalar": 0.003,
+      "log_bad": -1.1744,
+      "log_good": -1.1641
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 77.0,
+      "good": 67.0,
+      "ratio": 0.8701,
+      "suggested_scalar": -0.0408,
+      "log_bad": 4.3438,
+      "log_good": 4.2047
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 71.0,
+      "good": 68.0,
+      "ratio": 0.9577,
+      "suggested_scalar": -0.0127,
+      "log_bad": 4.2627,
+      "log_good": 4.2195
+    },
+    "brevity.mean_sample_size": {
+      "bad": 71.0,
+      "good": 68.0,
+      "ratio": 0.9577,
+      "suggested_scalar": -0.0127,
+      "log_bad": 4.2627,
+      "log_good": 4.2195
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 424.0,
+      "good": 394.0,
+      "ratio": 0.9292,
+      "suggested_scalar": -0.0215,
+      "log_bad": 6.0497,
+      "log_good": 5.9764
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 245.0,
+      "good": 224.0,
+      "ratio": 0.9143,
+      "suggested_scalar": -0.0263,
+      "log_bad": 5.5013,
+      "log_good": 5.4116
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 211.0,
+      "good": 197.0,
+      "ratio": 0.9336,
+      "suggested_scalar": -0.0202,
+      "log_bad": 5.3519,
+      "log_good": 5.2832
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0071,
+      "good": 0.0076,
+      "ratio": 1.0704,
+      "suggested_scalar": 0.02,
+      "log_bad": -4.9477,
+      "log_good": -4.8796
+    },
+    "heaps.mean_k": {
+      "bad": 2.9043,
+      "good": 2.9298,
+      "ratio": 1.0088,
+      "suggested_scalar": 0.0026,
+      "log_bad": 1.0662,
+      "log_good": 1.0749
+    },
+    "halstead.mean_effort": {
+      "bad": 100928.0344,
+      "good": 85855.3823,
+      "ratio": 0.8507,
+      "suggested_scalar": -0.0475,
+      "log_bad": 11.5222,
+      "log_good": 11.3604
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8326,
+      "good": 0.8411,
+      "ratio": 1.0102,
+      "suggested_scalar": 0.003,
+      "log_bad": -0.1832,
+      "log_good": -0.173
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 47.0,
+      "good": 45.0,
+      "ratio": 0.9574,
+      "suggested_scalar": -0.0128,
+      "log_bad": 3.8501,
+      "log_good": 3.8067
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 257.0,
+      "good": 236.0,
+      "ratio": 0.9183,
+      "suggested_scalar": -0.025,
+      "log_bad": 5.5491,
+      "log_good": 5.4638
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3238,
+      "good": 0.3368,
+      "ratio": 1.0401,
+      "suggested_scalar": 0.0116,
+      "log_bad": -1.1276,
+      "log_good": -1.0883
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.3619,
+      "good": 7.2105,
+      "ratio": 0.9794,
+      "suggested_scalar": -0.0061,
+      "log_bad": 1.9963,
+      "log_good": 1.9755
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1548,
+      "good": 0.1447,
+      "ratio": 0.9348,
+      "suggested_scalar": -0.0198,
+      "log_bad": -1.8656,
+      "log_good": -1.9331
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.3887,
+      "good": 2.4246,
+      "ratio": 1.015,
+      "suggested_scalar": 0.0044,
+      "log_bad": 0.8707,
+      "log_good": 0.8857
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 423.0,
+      "good": 393.0,
+      "ratio": 0.9291,
+      "suggested_scalar": -0.0216,
+      "log_bad": 6.0474,
+      "log_good": 5.9738
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 68.0,
+      "good": 61.0,
+      "ratio": 0.8971,
+      "suggested_scalar": -0.0319,
+      "log_bad": 4.2195,
+      "log_good": 4.1109
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5607.113,
+      "good": 4769.7435,
+      "ratio": 0.8507,
+      "suggested_scalar": -0.0475,
+      "log_bad": 8.6318,
+      "log_good": 8.47
+    },
+    "readability.mean_total_lines": {
+      "bad": 71.0,
+      "good": 65.0,
+      "ratio": 0.9155,
+      "suggested_scalar": -0.0259,
+      "log_bad": 4.2627,
+      "log_good": 4.1744
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2562.0403,
+      "good": 2341.5104,
+      "ratio": 0.9139,
+      "suggested_scalar": -0.0264,
+      "log_bad": 7.8486,
+      "log_good": 7.7586
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 576.0,
+      "good": 547.0,
+      "ratio": 0.9497,
+      "suggested_scalar": -0.0152,
+      "log_bad": 6.3561,
+      "log_good": 6.3044
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 23.3099,
+      "good": 23.6462,
+      "ratio": 1.0144,
+      "suggested_scalar": 0.0042,
+      "log_bad": 3.1489,
+      "log_good": 3.1632
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.32,
+      "good": 1.2952,
+      "ratio": 0.9812,
+      "suggested_scalar": -0.0056,
+      "log_bad": 0.2776,
+      "log_good": 0.2587
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 50.0,
+      "good": 47.0,
+      "ratio": 0.94,
+      "suggested_scalar": -0.0182,
+      "log_bad": 3.912,
+      "log_good": 3.8501
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7741,
+      "good": 0.7766,
+      "ratio": 1.0032,
+      "suggested_scalar": 0.0009,
+      "log_bad": -0.2561,
+      "log_good": -0.2528
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9938,
+      "good": 0.9844,
+      "ratio": 0.9905,
+      "suggested_scalar": -0.0028,
+      "log_bad": -0.0062,
+      "log_good": -0.0157
+    },
+    "halstead.mean_length": {
+      "bad": 418.0,
+      "good": 386.0,
+      "ratio": 0.9234,
+      "suggested_scalar": -0.0234,
+      "log_bad": 6.0355,
+      "log_good": 5.9558
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.1497,
+      "good": 6.0875,
+      "ratio": 0.9899,
+      "suggested_scalar": -0.003,
+      "log_bad": 1.8164,
+      "log_good": 1.8062
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1409,
+      "good": 0.1389,
+      "ratio": 0.9858,
+      "suggested_scalar": -0.0042,
+      "log_bad": -1.9597,
+      "log_good": -1.974
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 39.3936,
+      "good": 36.6667,
+      "ratio": 0.9308,
+      "suggested_scalar": -0.0211,
+      "log_bad": 3.6736,
+      "log_good": 3.6019
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.3225,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 34.0,
+      "good": 32.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0178,
+      "log_bad": 3.5264,
+      "log_good": 3.4657
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6351,
+      "good": 0.6599,
+      "ratio": 1.039,
+      "suggested_scalar": 0.0112,
+      "log_bad": -0.454,
+      "log_good": -0.4157
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 71.0,
+      "good": 65.0,
+      "ratio": 0.9155,
+      "suggested_scalar": -0.0259,
+      "log_bad": 4.2627,
+      "log_good": 4.1744
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "consistency.protocol_conformance_in_separate_extension": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 12.0,
+      "good": 10.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0492,
+      "log_bad": 2.4849,
+      "log_good": 2.3026
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 7.0,
+      "ratio": 2.3333,
+      "suggested_scalar": 0.2284,
+      "log_bad": 1.0986,
+      "log_good": 1.9459
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0066,
+      "good": 0.0039,
+      "ratio": 0.5909,
+      "suggested_scalar": -0.1418,
+      "log_bad": -5.0207,
+      "log_good": -5.5468
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.3333,
+      "good": 1.0,
+      "ratio": 3.0003,
+      "suggested_scalar": 0.2962,
+      "log_bad": -1.0987,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8409,
+      "good": 0.7955,
+      "ratio": 0.946,
+      "suggested_scalar": -0.015,
+      "log_bad": -0.1733,
+      "log_good": -0.2288
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0066,
+      "good": 0.0039,
+      "ratio": 0.5909,
+      "suggested_scalar": -0.1418,
+      "log_bad": -5.0207,
+      "log_good": -5.5468
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6305,
+      "good": 4.6837,
+      "ratio": 1.0115,
+      "suggested_scalar": 0.0031,
+      "log_bad": 1.5327,
+      "log_good": 1.5441
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 94.0,
+      "good": 78.0,
+      "ratio": 0.8298,
+      "suggested_scalar": -0.0503,
+      "log_bad": 4.5433,
+      "log_good": 4.3567
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5567,
+      "good": 0.5033,
+      "ratio": 0.9041,
+      "suggested_scalar": -0.0272,
+      "log_bad": -0.5857,
+      "log_good": -0.6866
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 15.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0174,
+      "log_bad": 2.7726,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7075,
+      "good": 0.708,
+      "ratio": 1.0007,
+      "suggested_scalar": 0.0002,
+      "log_bad": -0.346,
+      "log_good": -0.3453
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.7273,
+      "good": 2.5455,
+      "ratio": 0.6829,
+      "suggested_scalar": -0.1028,
+      "log_bad": 1.3157,
+      "log_good": 0.9343
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 301.0,
+      "good": 259.0,
+      "ratio": 0.8605,
+      "suggested_scalar": -0.0405,
+      "log_bad": 5.7071,
+      "log_good": 5.5568
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0006,
+      "good": 1.0,
+      "ratio": 1666.6667,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.4186,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1591,
+      "good": 0.1136,
+      "ratio": 0.714,
+      "suggested_scalar": -0.0908,
+      "log_bad": -1.8382,
+      "log_good": -2.1751
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0012,
+      "good": 0.0014,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.0416,
+      "log_bad": -6.7254,
+      "log_good": -6.5713
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8717,
+      "good": 0.8917,
+      "ratio": 1.0229,
+      "suggested_scalar": 0.0061,
+      "log_bad": -0.1373,
+      "log_good": -0.1146
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 117.0,
+      "good": 102.0,
+      "ratio": 0.8718,
+      "suggested_scalar": -0.037,
+      "log_bad": 4.7622,
+      "log_good": 4.625
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.4478,
+      "good": 99.5787,
+      "ratio": 0.9816,
+      "suggested_scalar": -0.005,
+      "log_bad": 4.6195,
+      "log_good": 4.6009
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.3933,
+      "good": 0.4109,
+      "ratio": 1.0447,
+      "suggested_scalar": 0.0118,
+      "log_bad": -0.9332,
+      "log_good": -0.8894
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 17.3957,
+      "good": 23.2289,
+      "ratio": 1.3353,
+      "suggested_scalar": 0.078,
+      "log_bad": 2.8562,
+      "log_good": 3.1454
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1604.0,
+      "good": 1402.0,
+      "ratio": 0.8741,
+      "suggested_scalar": -0.0363,
+      "log_bad": 7.3803,
+      "log_good": 7.2457
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2273,
+      "good": 0.1136,
+      "ratio": 0.4998,
+      "suggested_scalar": -0.187,
+      "log_bad": -1.4815,
+      "log_good": -2.1751
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8182,
+      "good": 0.7727,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.0154,
+      "log_bad": -0.2006,
+      "log_good": -0.2579
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.8409,
+      "good": 5.8864,
+      "ratio": 0.8605,
+      "suggested_scalar": -0.0405,
+      "log_bad": 1.9229,
+      "log_good": 1.7726
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.3802,
+      "good": 6.6116,
+      "ratio": 1.2289,
+      "suggested_scalar": 0.0556,
+      "log_bad": 1.6827,
+      "log_good": 1.8888
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 67.0,
+      "good": 50.0,
+      "ratio": 0.7463,
+      "suggested_scalar": -0.0789,
+      "log_bad": 4.2047,
+      "log_good": 3.912
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9376,
+      "good": 0.938,
+      "ratio": 1.0004,
+      "suggested_scalar": 0.0001,
+      "log_bad": -0.0644,
+      "log_good": -0.064
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5873,
+      "good": 0.602,
+      "ratio": 1.025,
+      "suggested_scalar": 0.0067,
+      "log_bad": -0.5322,
+      "log_good": -0.5075
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.1873,
+      "good": 0.2101,
+      "ratio": 1.1217,
+      "suggested_scalar": 0.031,
+      "log_bad": -1.675,
+      "log_good": -1.5602
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.423,
+      "good": 2.5125,
+      "ratio": 1.0369,
+      "suggested_scalar": 0.0098,
+      "log_bad": 0.885,
+      "log_good": 0.9213
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 299.0,
+      "good": 257.0,
+      "ratio": 0.8595,
+      "suggested_scalar": -0.0408,
+      "log_bad": 5.7004,
+      "log_good": 5.5491
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 15.0,
+      "good": 18.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0492,
+      "log_bad": 2.7081,
+      "log_good": 2.8904
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0664,
+      "good": 0.1042,
+      "ratio": 1.5693,
+      "suggested_scalar": 0.1215,
+      "log_bad": -2.7121,
+      "log_good": -2.2614
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8826,
+      "good": 5.9069,
+      "ratio": 1.0041,
+      "suggested_scalar": 0.0011,
+      "log_bad": 1.772,
+      "log_good": 1.7761
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 37.0,
+      "good": 41.0,
+      "ratio": 1.1081,
+      "suggested_scalar": 0.0277,
+      "log_bad": 3.6109,
+      "log_good": 3.7136
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3815,
+      "good": 1.4266,
+      "ratio": 1.0326,
+      "suggested_scalar": 0.0087,
+      "log_bad": 0.3232,
+      "log_good": 0.3553
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9121,
+      "good": 5.639,
+      "ratio": 0.9538,
+      "suggested_scalar": -0.0128,
+      "log_bad": 1.777,
+      "log_good": 1.7297
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7871,
+      "good": 0.7929,
+      "ratio": 1.0074,
+      "suggested_scalar": 0.002,
+      "log_bad": -0.2394,
+      "log_good": -0.2321
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1698,
+      "good": 0.1373,
+      "ratio": 0.8086,
+      "suggested_scalar": -0.0573,
+      "log_bad": -1.7731,
+      "log_good": -1.9856
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.1708,
+      "good": 4.8196,
+      "ratio": 1.1556,
+      "suggested_scalar": 0.039,
+      "log_bad": 1.4281,
+      "log_good": 1.5727
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 265.0,
+      "good": 219.0,
+      "ratio": 0.8264,
+      "suggested_scalar": -0.0514,
+      "log_bad": 5.5797,
+      "log_good": 5.3891
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0776,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5921,
+      "good": 0.5028,
+      "ratio": 0.8492,
+      "suggested_scalar": -0.0441,
+      "log_bad": -0.5241,
+      "log_good": -0.6876
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 97.0,
+      "good": 81.0,
+      "ratio": 0.8351,
+      "suggested_scalar": -0.0486,
+      "log_bad": 4.5747,
+      "log_good": 4.3944
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 899.0,
+      "good": 803.0,
+      "ratio": 0.8932,
+      "suggested_scalar": -0.0304,
+      "log_bad": 6.8013,
+      "log_good": 6.6884
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 129.0,
+      "good": 111.0,
+      "ratio": 0.8605,
+      "suggested_scalar": -0.0405,
+      "log_bad": 4.8598,
+      "log_good": 4.7095
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.01,
+      "good": 0.0039,
+      "ratio": 0.39,
+      "suggested_scalar": -0.2539,
+      "log_bad": -4.6052,
+      "log_good": -5.5468
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2093,
+      "good": 0.2317,
+      "ratio": 1.107,
+      "suggested_scalar": 0.0274,
+      "log_bad": -1.564,
+      "log_good": -1.4623
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 41.0,
+      "good": 34.0,
+      "ratio": 0.8293,
+      "suggested_scalar": -0.0505,
+      "log_bad": 3.7136,
+      "log_good": 3.5264
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.2962,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 97.0,
+      "good": 81.0,
+      "ratio": 0.8351,
+      "suggested_scalar": -0.0486,
+      "log_bad": 4.5747,
+      "log_good": 4.3944
+    },
+    "brevity.mean_sample_size": {
+      "bad": 97.0,
+      "good": 81.0,
+      "ratio": 0.8351,
+      "suggested_scalar": -0.0486,
+      "log_bad": 4.5747,
+      "log_good": 4.3944
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 301.0,
+      "good": 259.0,
+      "ratio": 0.8605,
+      "suggested_scalar": -0.0405,
+      "log_bad": 5.7071,
+      "log_good": 5.5568
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 136.0,
+      "good": 117.0,
+      "ratio": 0.8603,
+      "suggested_scalar": -0.0406,
+      "log_bad": 4.9127,
+      "log_good": 4.7622
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 223.0,
+      "good": 186.0,
+      "ratio": 0.8341,
+      "suggested_scalar": -0.0489,
+      "log_bad": 5.4072,
+      "log_good": 5.2257
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.9982,
+      "good": 1.9026,
+      "ratio": 0.9522,
+      "suggested_scalar": -0.0132,
+      "log_bad": 0.6922,
+      "log_good": 0.6432
+    },
+    "halstead.mean_effort": {
+      "bad": 29024.6371,
+      "good": 26961.1796,
+      "ratio": 0.9289,
+      "suggested_scalar": -0.0199,
+      "log_bad": 10.2759,
+      "log_good": 10.2022
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8958,
+      "good": 0.8894,
+      "ratio": 0.9929,
+      "suggested_scalar": -0.0019,
+      "log_bad": -0.11,
+      "log_good": -0.1172
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 75.0,
+      "good": 59.0,
+      "ratio": 0.7867,
+      "suggested_scalar": -0.0647,
+      "log_bad": 4.3175,
+      "log_good": 4.0775
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 142.0,
+      "good": 129.0,
+      "ratio": 0.9085,
+      "suggested_scalar": -0.0259,
+      "log_bad": 4.9558,
+      "log_good": 4.8598
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.547,
+      "good": 0.5,
+      "ratio": 0.9141,
+      "suggested_scalar": -0.0242,
+      "log_bad": -0.6033,
+      "log_good": -0.6931
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.6838,
+      "good": 7.8725,
+      "ratio": 1.0246,
+      "suggested_scalar": 0.0065,
+      "log_bad": 2.0391,
+      "log_good": 2.0634
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1698,
+      "good": 0.1373,
+      "ratio": 0.8086,
+      "suggested_scalar": -0.0573,
+      "log_bad": -1.7731,
+      "log_good": -1.9856
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.2212,
+      "good": 2.9179,
+      "ratio": 0.9058,
+      "suggested_scalar": -0.0267,
+      "log_bad": 1.1698,
+      "log_good": 1.0709
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 300.0,
+      "good": 258.0,
+      "ratio": 0.86,
+      "suggested_scalar": -0.0407,
+      "log_bad": 5.7038,
+      "log_good": 5.553
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 7.0,
+      "good": 4.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -0.1509,
+      "log_bad": 1.9459,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 22.0,
+      "good": 16.0,
+      "ratio": 0.7273,
+      "suggested_scalar": -0.0859,
+      "log_bad": 3.091,
+      "log_good": 2.7726
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1612.4798,
+      "good": 1497.8433,
+      "ratio": 0.9289,
+      "suggested_scalar": -0.0199,
+      "log_bad": 7.3855,
+      "log_good": 7.3118
+    },
+    "readability.mean_total_lines": {
+      "bad": 44.0,
+      "good": 44.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7842,
+      "log_good": 3.7842
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 1776.2936,
+      "good": 1508.4965,
+      "ratio": 0.8492,
+      "suggested_scalar": -0.0441,
+      "log_bad": 7.4823,
+      "log_good": 7.3189
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 662.0,
+      "good": 558.0,
+      "ratio": 0.8429,
+      "suggested_scalar": -0.0461,
+      "log_bad": 6.4953,
+      "log_good": 6.3244
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.25,
+      "good": 30.6591,
+      "ratio": 0.8698,
+      "suggested_scalar": -0.0376,
+      "log_bad": 3.5625,
+      "log_good": 3.4229
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1636,
+      "good": 1.1972,
+      "ratio": 1.0289,
+      "suggested_scalar": 0.0077,
+      "log_bad": 0.1515,
+      "log_good": 0.18
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 5.0,
+      "good": 3.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.1377,
+      "log_bad": 1.6094,
+      "log_good": 1.0986
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.0907,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.917,
+      "good": 0.9269,
+      "ratio": 1.0108,
+      "suggested_scalar": 0.0029,
+      "log_bad": -0.0866,
+      "log_good": -0.0759
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9681,
+      "good": 0.9743,
+      "ratio": 1.0064,
+      "suggested_scalar": 0.0017,
+      "log_bad": -0.0324,
+      "log_good": -0.026
+    },
+    "halstead.mean_length": {
+      "bad": 271.0,
+      "good": 240.0,
+      "ratio": 0.8856,
+      "suggested_scalar": -0.0328,
+      "log_bad": 5.6021,
+      "log_good": 5.4806
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.6667,
+      "good": 18.0,
+      "ratio": 2.3478,
+      "suggested_scalar": 0.2301,
+      "log_bad": 2.0369,
+      "log_good": 2.8904
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5999,
+      "good": 6.3399,
+      "ratio": 0.9606,
+      "suggested_scalar": -0.0108,
+      "log_bad": 1.8871,
+      "log_good": 1.8469
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0848,
+      "good": 0.0836,
+      "ratio": 0.9858,
+      "suggested_scalar": -0.0038,
+      "log_bad": -2.4675,
+      "log_good": -2.4817
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 16.34,
+      "good": 17.8729,
+      "ratio": 1.0938,
+      "suggested_scalar": 0.0242,
+      "log_bad": 2.7936,
+      "log_good": 2.8833
+    },
+    "branching.mean_branch_count": {
+      "bad": 10.0,
+      "good": 5.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.1869,
+      "log_bad": 2.3026,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 64.0,
+      "good": 51.0,
+      "ratio": 0.7969,
+      "suggested_scalar": -0.0612,
+      "log_bad": 4.1589,
+      "log_good": 3.9318
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8161,
+      "good": 0.8172,
+      "ratio": 1.0013,
+      "suggested_scalar": 0.0004,
+      "log_bad": -0.2032,
+      "log_good": -0.2019
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 44.0,
+      "good": 44.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7842,
+      "log_good": 3.7842
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.does_not_catch_general_exception": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.4486,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0132,
+      "good": 0.0241,
+      "ratio": 1.8258,
+      "suggested_scalar": 0.3896,
+      "log_bad": -4.3275,
+      "log_good": -3.7255
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.25,
+      "ratio": 1.25,
+      "suggested_scalar": 0.1444,
+      "log_bad": 0.0,
+      "log_good": 0.2231
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.6818,
+      "good": 0.7097,
+      "ratio": 1.0409,
+      "suggested_scalar": 0.026,
+      "log_bad": -0.383,
+      "log_good": -0.3429
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0132,
+      "good": 0.0241,
+      "ratio": 1.8258,
+      "suggested_scalar": 0.3896,
+      "log_bad": -4.3275,
+      "log_good": -3.7255
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 3.9857,
+      "good": 4.0675,
+      "ratio": 1.0205,
+      "suggested_scalar": 0.0131,
+      "log_bad": 1.3827,
+      "log_good": 1.403
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 99.0,
+      "good": 80.0,
+      "ratio": 0.8081,
+      "suggested_scalar": -0.1379,
+      "log_bad": 4.5951,
+      "log_good": 4.382
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6377,
+      "good": 0.5272,
+      "ratio": 0.8267,
+      "suggested_scalar": -0.1232,
+      "log_bad": -0.4499,
+      "log_good": -0.6402
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 13.0,
+      "ratio": 0.8125,
+      "suggested_scalar": -0.1344,
+      "log_bad": 2.7726,
+      "log_good": 2.5649
+    },
+    "heaps.mean_beta": {
+      "bad": 0.8412,
+      "good": 0.7698,
+      "ratio": 0.9151,
+      "suggested_scalar": -0.0574,
+      "log_bad": -0.1729,
+      "log_good": -0.2616
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 10.6061,
+      "good": 10.5161,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0055,
+      "log_bad": 2.3614,
+      "log_good": 2.3529
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 303.0,
+      "good": 332.0,
+      "ratio": 1.0957,
+      "suggested_scalar": 0.0592,
+      "log_bad": 5.7137,
+      "log_good": 5.8051
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0455,
+      "good": 1.0,
+      "ratio": 21.978,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.09,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8545,
+      "good": 0.9209,
+      "ratio": 1.0777,
+      "suggested_scalar": 0.0484,
+      "log_bad": -0.1572,
+      "log_good": -0.0824
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 112.0,
+      "good": 124.0,
+      "ratio": 1.1071,
+      "suggested_scalar": 0.0659,
+      "log_bad": 4.7185,
+      "log_good": 4.8203
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.184,
+      "good": 98.601,
+      "ratio": 0.9745,
+      "suggested_scalar": -0.0167,
+      "log_bad": 4.6169,
+      "log_good": 4.5911
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4073,
+      "good": 0.5257,
+      "ratio": 1.2907,
+      "suggested_scalar": 0.1652,
+      "log_bad": -0.8982,
+      "log_good": -0.643
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 18.6824,
+      "good": 24.791,
+      "ratio": 1.327,
+      "suggested_scalar": 0.1831,
+      "log_bad": 2.9276,
+      "log_good": 3.2105
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2115.0,
+      "good": 2139.0,
+      "ratio": 1.0113,
+      "suggested_scalar": 0.0073,
+      "log_bad": 7.6568,
+      "log_good": 7.6681
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1364,
+      "good": 0.1774,
+      "ratio": 1.3006,
+      "suggested_scalar": 0.1701,
+      "log_bad": -1.9922,
+      "log_good": -1.7293
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.5606,
+      "good": 0.6129,
+      "ratio": 1.0933,
+      "suggested_scalar": 0.0577,
+      "log_bad": -0.5787,
+      "log_good": -0.4896
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 4.5909,
+      "good": 5.3548,
+      "ratio": 1.1664,
+      "suggested_scalar": 0.0996,
+      "log_bad": 1.5241,
+      "log_good": 1.678
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 9.0,
+      "good": 10.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0682,
+      "log_bad": 2.1972,
+      "log_good": 2.3026
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 23.5115,
+      "good": 22.8304,
+      "ratio": 0.971,
+      "suggested_scalar": -0.019,
+      "log_bad": 3.1575,
+      "log_good": 3.1281
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 51.0,
+      "good": 60.0,
+      "ratio": 1.1765,
+      "suggested_scalar": 0.1052,
+      "log_bad": 3.9318,
+      "log_good": 4.0943
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9204,
+      "good": 0.9435,
+      "ratio": 1.0251,
+      "suggested_scalar": 0.016,
+      "log_bad": -0.0829,
+      "log_good": -0.0582
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 23.0,
+      "ratio": 0.8846,
+      "suggested_scalar": -0.0794,
+      "log_bad": 3.2581,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6671,
+      "good": 0.6882,
+      "ratio": 1.0316,
+      "suggested_scalar": 0.0202,
+      "log_bad": -0.4048,
+      "log_good": -0.3737
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2126,
+      "good": 0.3455,
+      "ratio": 1.6251,
+      "suggested_scalar": 0.3143,
+      "log_bad": -1.5483,
+      "log_good": -1.0628
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0043,
+      "good": 3.2069,
+      "ratio": 1.0674,
+      "suggested_scalar": 0.0422,
+      "log_bad": 1.1,
+      "log_good": 1.1653
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 301.0,
+      "good": 330.0,
+      "ratio": 1.0963,
+      "suggested_scalar": 0.0595,
+      "log_bad": 5.7071,
+      "log_good": 5.7991
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 17.0,
+      "good": 20.0,
+      "ratio": 1.1765,
+      "suggested_scalar": 0.1052,
+      "log_bad": 2.8332,
+      "log_good": 2.9957
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0033,
+      "good": 0.003,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0617,
+      "log_bad": -5.7138,
+      "log_good": -5.8091
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0,
+      "good": 5.9069,
+      "ratio": 0.9845,
+      "suggested_scalar": -0.0101,
+      "log_bad": 1.7918,
+      "log_good": 1.7761
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 50.0,
+      "good": 50.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.912,
+      "log_good": 3.912
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4322,
+      "good": 1.4879,
+      "ratio": 1.0389,
+      "suggested_scalar": 0.0247,
+      "log_bad": 0.3592,
+      "log_good": 0.3974
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8865,
+      "good": 5.7251,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.018,
+      "log_bad": 1.7727,
+      "log_good": 1.7449
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.6643,
+      "good": 0.6886,
+      "ratio": 1.0366,
+      "suggested_scalar": 0.0233,
+      "log_bad": -0.409,
+      "log_good": -0.3731
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.0959,
+      "good": 0.0882,
+      "ratio": 0.9197,
+      "suggested_scalar": -0.0542,
+      "log_bad": -2.3444,
+      "log_good": -2.4281
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.3223,
+      "good": 4.9791,
+      "ratio": 1.152,
+      "suggested_scalar": 0.0916,
+      "log_bad": 1.4638,
+      "log_good": 1.6052
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 260.0,
+      "good": 259.0,
+      "ratio": 0.9962,
+      "suggested_scalar": -0.0025,
+      "log_bad": 5.5607,
+      "log_good": 5.5568
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 11.0,
+      "good": 17.0,
+      "ratio": 1.5455,
+      "suggested_scalar": 0.2818,
+      "log_bad": 2.3979,
+      "log_good": 2.8332
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6187,
+      "good": 0.5795,
+      "ratio": 0.9366,
+      "suggested_scalar": -0.0424,
+      "log_bad": -0.4801,
+      "log_good": -0.5456
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 110.0,
+      "good": 101.0,
+      "ratio": 0.9182,
+      "suggested_scalar": -0.0552,
+      "log_bad": 4.7005,
+      "log_good": 4.6151
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 860.0,
+      "good": 911.0,
+      "ratio": 1.0593,
+      "suggested_scalar": 0.0373,
+      "log_bad": 6.7569,
+      "log_good": 6.8145
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 129.0,
+      "good": 114.0,
+      "ratio": 0.8837,
+      "suggested_scalar": -0.08,
+      "log_bad": 4.8598,
+      "log_good": 4.7362
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0033,
+      "good": 0.003,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0617,
+      "log_bad": -5.7138,
+      "log_good": -5.8091
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2244,
+      "good": 0.2289,
+      "ratio": 1.0201,
+      "suggested_scalar": 0.0129,
+      "log_bad": -1.4943,
+      "log_good": -1.4745
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 37.0,
+      "good": 54.0,
+      "ratio": 1.4595,
+      "suggested_scalar": 0.2447,
+      "log_bad": 3.6109,
+      "log_good": 3.989
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1444,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 110.0,
+      "good": 101.0,
+      "ratio": 0.9182,
+      "suggested_scalar": -0.0552,
+      "log_bad": 4.7005,
+      "log_good": 4.6151
+    },
+    "brevity.mean_sample_size": {
+      "bad": 110.0,
+      "good": 101.0,
+      "ratio": 0.9182,
+      "suggested_scalar": -0.0552,
+      "log_bad": 4.7005,
+      "log_good": 4.6151
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 303.0,
+      "good": 332.0,
+      "ratio": 1.0957,
+      "suggested_scalar": 0.0592,
+      "log_bad": 5.7137,
+      "log_good": 5.8051
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 142.0,
+      "good": 158.0,
+      "ratio": 1.1127,
+      "suggested_scalar": 0.0691,
+      "log_bad": 4.9558,
+      "log_good": 5.0626
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 216.0,
+      "good": 211.0,
+      "ratio": 0.9769,
+      "suggested_scalar": -0.0152,
+      "log_bad": 5.3753,
+      "log_good": 5.3519
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 0.9407,
+      "good": 1.1992,
+      "ratio": 1.2748,
+      "suggested_scalar": 0.1571,
+      "log_bad": -0.0611,
+      "log_good": 0.1817
+    },
+    "halstead.mean_effort": {
+      "bad": 42642.2013,
+      "good": 39986.1952,
+      "ratio": 0.9377,
+      "suggested_scalar": -0.0416,
+      "log_bad": 10.6606,
+      "log_good": 10.5963
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.868,
+      "good": 0.8599,
+      "ratio": 0.9907,
+      "suggested_scalar": -0.0061,
+      "log_bad": -0.1416,
+      "log_good": -0.1509
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 73.0,
+      "good": 57.0,
+      "ratio": 0.7808,
+      "suggested_scalar": -0.1601,
+      "log_bad": 4.2905,
+      "log_good": 4.0431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 151.0,
+      "good": 161.0,
+      "ratio": 1.0662,
+      "suggested_scalar": 0.0415,
+      "log_bad": 5.0173,
+      "log_good": 5.0814
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.6161,
+      "good": 0.5161,
+      "ratio": 0.8377,
+      "suggested_scalar": -0.1146,
+      "log_bad": -0.4843,
+      "log_good": -0.6615
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.6786,
+      "good": 7.3468,
+      "ratio": 0.9568,
+      "suggested_scalar": -0.0286,
+      "log_bad": 2.0384,
+      "log_good": 1.9943
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.0959,
+      "good": 0.0882,
+      "ratio": 0.9197,
+      "suggested_scalar": -0.0542,
+      "log_bad": -2.3444,
+      "log_good": -2.4281
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.0864,
+      "good": 4.7001,
+      "ratio": 1.1502,
+      "suggested_scalar": 0.0906,
+      "log_bad": 1.4077,
+      "log_good": 1.5476
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 302.0,
+      "good": 331.0,
+      "ratio": 1.096,
+      "suggested_scalar": 0.0593,
+      "log_bad": 5.7104,
+      "log_good": 5.8021
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 23.0,
+      "good": 43.0,
+      "ratio": 1.8696,
+      "suggested_scalar": 0.405,
+      "log_bad": 3.1355,
+      "log_good": 3.7612
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2369.0112,
+      "good": 2221.4553,
+      "ratio": 0.9377,
+      "suggested_scalar": -0.0416,
+      "log_bad": 7.7702,
+      "log_good": 7.7059
+    },
+    "readability.mean_total_lines": {
+      "bad": 66.0,
+      "good": 62.0,
+      "ratio": 0.9394,
+      "suggested_scalar": -0.0405,
+      "log_bad": 4.1897,
+      "log_good": 4.1271
+    },
+    "indentation.mean_max_depth": {
+      "bad": 20.0,
+      "good": 16.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1444,
+      "log_bad": 2.9957,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 1856.2199,
+      "good": 1738.5302,
+      "ratio": 0.9366,
+      "suggested_scalar": -0.0424,
+      "log_bad": 7.5263,
+      "log_good": 7.4608
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 704.0,
+      "good": 667.0,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.0349,
+      "log_bad": 6.5568,
+      "log_good": 6.5028
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.9091,
+      "good": 33.4032,
+      "ratio": 1.0807,
+      "suggested_scalar": 0.0502,
+      "log_bad": 3.4311,
+      "log_good": 3.5087
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1938,
+      "good": 1.2151,
+      "ratio": 1.0178,
+      "suggested_scalar": 0.0114,
+      "log_bad": 0.1771,
+      "log_good": 0.1948
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.7111,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9115,
+      "good": 0.834,
+      "ratio": 0.915,
+      "suggested_scalar": -0.0575,
+      "log_bad": -0.0927,
+      "log_good": -0.1815
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9936,
+      "good": 0.9886,
+      "ratio": 0.995,
+      "suggested_scalar": -0.0033,
+      "log_bad": -0.0064,
+      "log_good": -0.0115
+    },
+    "halstead.mean_length": {
+      "bad": 280.0,
+      "good": 275.0,
+      "ratio": 0.9821,
+      "suggested_scalar": -0.0117,
+      "log_bad": 5.6348,
+      "log_good": 5.6168
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.2,
+      "good": 12.75,
+      "ratio": 1.1384,
+      "suggested_scalar": 0.0839,
+      "log_bad": 2.4159,
+      "log_good": 2.5455
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7814,
+      "good": 6.6582,
+      "ratio": 0.9818,
+      "suggested_scalar": -0.0119,
+      "log_bad": 1.9142,
+      "log_good": 1.8958
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0672,
+      "good": 0.0739,
+      "ratio": 1.0997,
+      "suggested_scalar": 0.0615,
+      "log_bad": -2.7001,
+      "log_good": -2.605
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 22.9726,
+      "good": 23.0,
+      "ratio": 1.0012,
+      "suggested_scalar": 0.0008,
+      "log_bad": 3.1343,
+      "log_good": 3.1355
+    },
+    "branching.mean_branch_count": {
+      "bad": 9.0,
+      "good": 11.0,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.1299,
+      "log_bad": 2.1972,
+      "log_good": 2.3979
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 69.0,
+      "good": 64.0,
+      "ratio": 0.9275,
+      "suggested_scalar": -0.0487,
+      "log_bad": 4.2341,
+      "log_good": 4.1589
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8287,
+      "good": 0.7441,
+      "ratio": 0.8979,
+      "suggested_scalar": -0.0697,
+      "log_bad": -0.1879,
+      "log_good": -0.2956
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 66.0,
+      "good": 62.0,
+      "ratio": 0.9394,
+      "suggested_scalar": -0.0405,
+      "log_bad": 4.1897,
+      "log_good": 4.1271
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 22.0,
+      "good": 27.0,
+      "ratio": 1.2273,
+      "suggested_scalar": 0.1326,
+      "log_bad": 3.091,
+      "log_good": 3.2958
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.interface_has_one_or_two_methods": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 12.0,
+      "good": 15.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.6439,
+      "log_bad": 2.4849,
+      "log_good": 2.7081
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0034,
+      "good": 0.0034,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.684,
+      "log_good": -5.684
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.3333,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.83,
+      "log_bad": 0.0,
+      "log_good": 0.2877
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8611,
+      "good": 0.814,
+      "ratio": 0.9453,
+      "suggested_scalar": -0.1623,
+      "log_bad": -0.1495,
+      "log_good": -0.2058
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0034,
+      "good": 0.0034,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.684,
+      "log_good": -5.684
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6538,
+      "good": 4.6404,
+      "ratio": 0.9971,
+      "suggested_scalar": -0.0083,
+      "log_bad": 1.5377,
+      "log_good": 1.5348
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 92.0,
+      "good": 89.0,
+      "ratio": 0.9674,
+      "suggested_scalar": -0.0957,
+      "log_bad": 4.5218,
+      "log_good": 4.4886
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4608,
+      "good": 0.5141,
+      "ratio": 1.1157,
+      "suggested_scalar": 0.3158,
+      "log_bad": -0.7748,
+      "log_good": -0.6653
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 13.0,
+      "good": 14.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.2138,
+      "log_bad": 2.5649,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6604,
+      "good": 0.657,
+      "ratio": 0.9949,
+      "suggested_scalar": -0.0149,
+      "log_bad": -0.4149,
+      "log_good": -0.4201
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.3611,
+      "good": 0.2791,
+      "ratio": 0.7729,
+      "suggested_scalar": -0.7432,
+      "log_bad": -1.0186,
+      "log_good": -1.2762
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 295.0,
+      "good": 298.0,
+      "ratio": 1.0102,
+      "suggested_scalar": 0.0292,
+      "log_bad": 5.687,
+      "log_good": 5.6971
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -1.1699,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.25,
+      "good": 0.2558,
+      "ratio": 1.0232,
+      "suggested_scalar": 0.0662,
+      "log_bad": -1.3863,
+      "log_good": -1.3634
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.933,
+      "good": 0.9123,
+      "ratio": 0.9778,
+      "suggested_scalar": -0.0647,
+      "log_bad": -0.0694,
+      "log_good": -0.0918
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 147.0,
+      "good": 145.0,
+      "ratio": 0.9864,
+      "suggested_scalar": -0.0395,
+      "log_bad": 4.9904,
+      "log_good": 4.9767
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 110.5907,
+      "good": 110.1432,
+      "ratio": 0.996,
+      "suggested_scalar": -0.0117,
+      "log_bad": 4.7058,
+      "log_good": 4.7018
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5408,
+      "good": 0.5589,
+      "ratio": 1.0335,
+      "suggested_scalar": 0.095,
+      "log_bad": -0.6147,
+      "log_good": -0.5818
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.2351,
+      "good": 11.2837,
+      "ratio": 1.2218,
+      "suggested_scalar": 0.5781,
+      "log_bad": 2.223,
+      "log_good": 2.4234
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1246.0,
+      "good": 1352.0,
+      "ratio": 1.0851,
+      "suggested_scalar": 0.2356,
+      "log_bad": 7.1277,
+      "log_good": 7.2093
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0556,
+      "good": 0.093,
+      "ratio": 1.6727,
+      "suggested_scalar": 1.4843,
+      "log_bad": -2.8896,
+      "log_good": -2.3752
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8611,
+      "good": 0.814,
+      "ratio": 0.9453,
+      "suggested_scalar": -0.1623,
+      "log_bad": -0.1495,
+      "log_good": -0.2058
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.1944,
+      "good": 6.9302,
+      "ratio": 0.8457,
+      "suggested_scalar": -0.4835,
+      "log_bad": 2.1035,
+      "log_good": 1.9359
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.2307,
+      "good": 0.2012,
+      "ratio": 0.8721,
+      "suggested_scalar": -0.3948,
+      "log_bad": -1.4666,
+      "log_good": -1.6035
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 95.0,
+      "good": 95.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.5539,
+      "log_good": 4.5539
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9296,
+      "good": 0.9173,
+      "ratio": 0.9868,
+      "suggested_scalar": -0.0384,
+      "log_bad": -0.073,
+      "log_good": -0.0863
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5955,
+      "good": 0.6265,
+      "ratio": 1.0521,
+      "suggested_scalar": 0.1464,
+      "log_bad": -0.5184,
+      "log_good": -0.4676
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3549,
+      "good": 0.3716,
+      "ratio": 1.0471,
+      "suggested_scalar": 0.1327,
+      "log_bad": -1.0359,
+      "log_good": -0.9899
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4722,
+      "good": 2.6772,
+      "ratio": 1.0829,
+      "suggested_scalar": 0.2299,
+      "log_bad": 0.9051,
+      "log_good": 0.9848
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 293.0,
+      "good": 296.0,
+      "ratio": 1.0102,
+      "suggested_scalar": 0.0294,
+      "log_bad": 5.6802,
+      "log_good": 5.6904
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0034,
+      "good": 0.0067,
+      "ratio": 1.9706,
+      "suggested_scalar": 1.9573,
+      "log_bad": -5.684,
+      "log_good": -5.0056
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.6724,
+      "good": 5.6147,
+      "ratio": 0.9898,
+      "suggested_scalar": -0.0295,
+      "log_bad": 1.7356,
+      "log_good": 1.7254
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 52.0,
+      "good": 50.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.1132,
+      "log_bad": 3.9512,
+      "log_good": 3.912
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9374,
+      "good": 0.9294,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0247,
+      "log_bad": -0.0646,
+      "log_good": -0.0732
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7041,
+      "good": 5.7992,
+      "ratio": 1.0167,
+      "suggested_scalar": 0.0477,
+      "log_bad": 1.7412,
+      "log_good": 1.7577
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8204,
+      "good": 0.8265,
+      "ratio": 1.0074,
+      "suggested_scalar": 0.0214,
+      "log_bad": -0.198,
+      "log_good": -0.1906
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1628,
+      "good": 0.1887,
+      "ratio": 1.1591,
+      "suggested_scalar": 0.426,
+      "log_bad": -1.8152,
+      "log_good": -1.6676
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.0389,
+      "good": 3.3591,
+      "ratio": 1.1054,
+      "suggested_scalar": 0.2891,
+      "log_bad": 1.1115,
+      "log_good": 1.2117
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 221.0,
+      "good": 227.0,
+      "ratio": 1.0271,
+      "suggested_scalar": 0.0773,
+      "log_bad": 5.3982,
+      "log_good": 5.425
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6371,
+      "good": 0.6389,
+      "ratio": 1.0028,
+      "suggested_scalar": 0.0081,
+      "log_bad": -0.4508,
+      "log_good": -0.448
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 92.0,
+      "good": 89.0,
+      "ratio": 0.9674,
+      "suggested_scalar": -0.0957,
+      "log_bad": 4.5218,
+      "log_good": 4.4886
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 776.0,
+      "good": 815.0,
+      "ratio": 1.0503,
+      "suggested_scalar": 0.1415,
+      "log_bad": 6.6542,
+      "log_good": 6.7032
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 163.0,
+      "good": 165.0,
+      "ratio": 1.0123,
+      "suggested_scalar": 0.0352,
+      "log_bad": 5.0938,
+      "log_good": 5.1059
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2339,
+      "good": 0.2047,
+      "ratio": 0.8752,
+      "suggested_scalar": -0.3848,
+      "log_bad": -1.4529,
+      "log_good": -1.5862
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 45.0,
+      "good": 53.0,
+      "ratio": 1.1778,
+      "suggested_scalar": 0.4721,
+      "log_bad": 3.8067,
+      "log_good": 3.9703
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 92.0,
+      "good": 89.0,
+      "ratio": 0.9674,
+      "suggested_scalar": -0.0957,
+      "log_bad": 4.5218,
+      "log_good": 4.4886
+    },
+    "brevity.mean_sample_size": {
+      "bad": 92.0,
+      "good": 89.0,
+      "ratio": 0.9674,
+      "suggested_scalar": -0.0957,
+      "log_bad": 4.5218,
+      "log_good": 4.4886
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 295.0,
+      "good": 298.0,
+      "ratio": 1.0102,
+      "suggested_scalar": 0.0292,
+      "log_bad": 5.687,
+      "log_good": 5.6971
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 117.0,
+      "good": 114.0,
+      "ratio": 0.9744,
+      "suggested_scalar": -0.0749,
+      "log_bad": 4.7622,
+      "log_good": 4.7362
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 180.0,
+      "good": 184.0,
+      "ratio": 1.0222,
+      "suggested_scalar": 0.0634,
+      "log_bad": 5.193,
+      "log_good": 5.2149
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.5675,
+      "good": 2.42,
+      "ratio": 0.9426,
+      "suggested_scalar": -0.1707,
+      "log_bad": 0.9429,
+      "log_good": 0.8838
+    },
+    "halstead.mean_effort": {
+      "bad": 46075.5965,
+      "good": 48836.5532,
+      "ratio": 1.0599,
+      "suggested_scalar": 0.1679,
+      "log_bad": 10.738,
+      "log_good": 10.7962
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8744,
+      "good": 0.8955,
+      "ratio": 1.0241,
+      "suggested_scalar": 0.0688,
+      "log_bad": -0.1342,
+      "log_good": -0.1104
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 71.0,
+      "good": 68.0,
+      "ratio": 0.9577,
+      "suggested_scalar": -0.1246,
+      "log_bad": 4.2627,
+      "log_good": 4.2195
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 130.0,
+      "good": 131.0,
+      "ratio": 1.0077,
+      "suggested_scalar": 0.0221,
+      "log_bad": 4.8675,
+      "log_good": 4.8752
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4286,
+      "good": 0.4276,
+      "ratio": 0.9977,
+      "suggested_scalar": -0.0067,
+      "log_bad": -0.8472,
+      "log_good": -0.8496
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.2789,
+      "good": 5.6207,
+      "ratio": 1.0647,
+      "suggested_scalar": 0.181,
+      "log_bad": 1.6637,
+      "log_good": 1.7265
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1628,
+      "good": 0.1887,
+      "ratio": 1.1591,
+      "suggested_scalar": 0.426,
+      "log_bad": -1.8152,
+      "log_good": -1.6676
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.2778,
+      "good": 2.7721,
+      "ratio": 0.8457,
+      "suggested_scalar": -0.4835,
+      "log_bad": 1.1872,
+      "log_good": 1.0196
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 294.0,
+      "good": 297.0,
+      "ratio": 1.0102,
+      "suggested_scalar": 0.0293,
+      "log_bad": 5.6836,
+      "log_good": 5.6937
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 32.0,
+      "good": 41.0,
+      "ratio": 1.2813,
+      "suggested_scalar": 0.7151,
+      "log_bad": 3.4657,
+      "log_good": 3.7136
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2559.7554,
+      "good": 2713.1418,
+      "ratio": 1.0599,
+      "suggested_scalar": 0.1679,
+      "log_bad": 7.8477,
+      "log_good": 7.9059
+    },
+    "readability.mean_total_lines": {
+      "bad": 36.0,
+      "good": 43.0,
+      "ratio": 1.1944,
+      "suggested_scalar": 0.5127,
+      "log_bad": 3.5835,
+      "log_good": 3.7612
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1911.4037,
+      "good": 1916.8171,
+      "ratio": 1.0028,
+      "suggested_scalar": 0.0082,
+      "log_bad": 7.5556,
+      "log_good": 7.5584
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 504.0,
+      "good": 505.0,
+      "ratio": 1.002,
+      "suggested_scalar": 0.0057,
+      "log_bad": 6.2226,
+      "log_good": 6.2246
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 33.4167,
+      "good": 30.2093,
+      "ratio": 0.904,
+      "suggested_scalar": -0.2912,
+      "log_bad": 3.5091,
+      "log_good": 3.4081
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0393,
+      "good": 1.0598,
+      "ratio": 1.0197,
+      "suggested_scalar": 0.0564,
+      "log_bad": 0.0385,
+      "log_good": 0.0581
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -1.1699,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 21.0,
+      "good": 20.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.1408,
+      "log_bad": 3.0445,
+      "log_good": 2.9957
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 9.0,
+      "good": 11.0,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.579,
+      "log_bad": 2.1972,
+      "log_good": 2.3979
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8552,
+      "good": 0.8194,
+      "ratio": 0.9581,
+      "suggested_scalar": -0.1234,
+      "log_bad": -0.1564,
+      "log_good": -0.1992
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9503,
+      "good": 0.9705,
+      "ratio": 1.0213,
+      "suggested_scalar": 0.0607,
+      "log_bad": -0.051,
+      "log_good": -0.0299
+    },
+    "halstead.mean_length": {
+      "bad": 293.0,
+      "good": 296.0,
+      "ratio": 1.0102,
+      "suggested_scalar": 0.0294,
+      "log_bad": 5.6802,
+      "log_good": 5.6904
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.3333,
+      "good": 4.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.4663,
+      "log_good": 1.4663
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5236,
+      "good": 6.4757,
+      "ratio": 0.9927,
+      "suggested_scalar": -0.0213,
+      "log_bad": 1.8754,
+      "log_good": 1.8681
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0939,
+      "good": 0.0843,
+      "ratio": 0.8978,
+      "suggested_scalar": -0.3112,
+      "log_bad": -2.3655,
+      "log_good": -2.4734
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 24.1056,
+      "good": 25.4779,
+      "ratio": 1.0569,
+      "suggested_scalar": 0.1598,
+      "log_bad": 3.1824,
+      "log_good": 3.2378
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 63.0,
+      "good": 62.0,
+      "ratio": 0.9841,
+      "suggested_scalar": -0.0462,
+      "log_bad": 4.1431,
+      "log_good": 4.1271
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.75,
+      "good": 0.712,
+      "ratio": 0.9493,
+      "suggested_scalar": -0.15,
+      "log_bad": -0.2877,
+      "log_good": -0.3397
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 36.0,
+      "good": 43.0,
+      "ratio": 1.1944,
+      "suggested_scalar": 0.5127,
+      "log_bad": 3.5835,
+      "log_good": 3.7612
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "scope_and_assignment.uses_const_by_default": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 32.0,
+      "good": 32.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4657,
+      "log_good": 3.4657
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0099,
+      "good": 0.01,
+      "ratio": 1.0101,
+      "suggested_scalar": 0.0051,
+      "log_bad": -4.6152,
+      "log_good": -4.6052
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.4,
+      "good": 1.4,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.3365,
+      "log_good": 0.3365
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9245,
+      "good": 0.9184,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0033,
+      "log_bad": -0.0785,
+      "log_good": -0.0851
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0099,
+      "good": 0.01,
+      "ratio": 1.0101,
+      "suggested_scalar": 0.0051,
+      "log_bad": -4.6152,
+      "log_good": -4.6052
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8862,
+      "good": 4.9146,
+      "ratio": 1.0058,
+      "suggested_scalar": 0.0029,
+      "log_bad": 1.5864,
+      "log_good": 1.5922
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 75.0,
+      "good": 73.0,
+      "ratio": 0.9733,
+      "suggested_scalar": -0.0136,
+      "log_bad": 4.3175,
+      "log_good": 4.2905
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.44,
+      "good": 0.44,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.821,
+      "log_good": -0.821
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6066,
+      "good": 0.6116,
+      "ratio": 1.0082,
+      "suggested_scalar": 0.0041,
+      "log_bad": -0.4999,
+      "log_good": -0.4917
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.0377,
+      "good": 2.0,
+      "ratio": 0.9815,
+      "suggested_scalar": -0.0094,
+      "log_bad": 0.7118,
+      "log_good": 0.6931
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 302.0,
+      "good": 299.0,
+      "ratio": 0.9901,
+      "suggested_scalar": -0.005,
+      "log_bad": 5.7104,
+      "log_good": 5.7004
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0036,
+      "good": 0.0036,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.6268,
+      "log_good": -5.6268
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0115,
+      "good": 1.0058,
+      "ratio": 0.9944,
+      "suggested_scalar": -0.0028,
+      "log_bad": 0.0114,
+      "log_good": 0.0058
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 101.0,
+      "good": 100.0,
+      "ratio": 0.9901,
+      "suggested_scalar": -0.005,
+      "log_bad": 4.6151,
+      "log_good": 4.6052
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 89.353,
+      "good": 88.0688,
+      "ratio": 0.9856,
+      "suggested_scalar": -0.0073,
+      "log_bad": 4.4926,
+      "log_good": 4.4781
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.3854,
+      "good": 0.3993,
+      "ratio": 1.0361,
+      "suggested_scalar": 0.0179,
+      "log_bad": -0.9535,
+      "log_good": -0.918
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 20.6468,
+      "good": 20.2984,
+      "ratio": 0.9831,
+      "suggested_scalar": -0.0086,
+      "log_bad": 3.0276,
+      "log_good": 3.0105
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1378.0,
+      "good": 1375.0,
+      "ratio": 0.9978,
+      "suggested_scalar": -0.0011,
+      "log_bad": 7.2284,
+      "log_good": 7.2262
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0189,
+      "good": 1.0,
+      "ratio": 52.9101,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.9686,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8868,
+      "good": 0.898,
+      "ratio": 1.0126,
+      "suggested_scalar": 0.0063,
+      "log_bad": -0.1201,
+      "log_good": -0.1076
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.6981,
+      "good": 6.102,
+      "ratio": 1.0709,
+      "suggested_scalar": 0.0345,
+      "log_bad": 1.7401,
+      "log_good": 1.8086
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.1873,
+      "good": 2.2857,
+      "ratio": 1.045,
+      "suggested_scalar": 0.0222,
+      "log_bad": 0.7827,
+      "log_good": 0.8267
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 55.0,
+      "good": 54.0,
+      "ratio": 0.9818,
+      "suggested_scalar": -0.0092,
+      "log_bad": 4.0073,
+      "log_good": 3.989
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9299,
+      "good": 0.9374,
+      "ratio": 1.0081,
+      "suggested_scalar": 0.004,
+      "log_bad": -0.0727,
+      "log_good": -0.0646
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 21.0,
+      "ratio": 0.913,
+      "suggested_scalar": -0.0458,
+      "log_bad": 3.1355,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5914,
+      "good": 0.5942,
+      "ratio": 1.0047,
+      "suggested_scalar": 0.0024,
+      "log_bad": -0.5253,
+      "log_good": -0.5205
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.17,
+      "good": 0.1818,
+      "ratio": 1.0694,
+      "suggested_scalar": 0.0338,
+      "log_bad": -1.772,
+      "log_good": -1.7048
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4476,
+      "good": 2.4642,
+      "ratio": 1.0068,
+      "suggested_scalar": 0.0034,
+      "log_bad": 0.8951,
+      "log_good": 0.9019
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 300.0,
+      "good": 297.0,
+      "ratio": 0.99,
+      "suggested_scalar": -0.0051,
+      "log_bad": 5.7038,
+      "log_good": 5.6937
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0298,
+      "good": 0.0301,
+      "ratio": 1.0101,
+      "suggested_scalar": 0.005,
+      "log_bad": -3.5132,
+      "log_good": -3.5032
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0661,
+      "good": 6.0661,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8027,
+      "log_good": 1.8027
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.5284,
+      "good": 1.5348,
+      "ratio": 1.0042,
+      "suggested_scalar": 0.0021,
+      "log_bad": 0.4242,
+      "log_good": 0.4284
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0495,
+      "good": 0.05,
+      "ratio": 1.0101,
+      "suggested_scalar": 0.0051,
+      "log_bad": -3.0058,
+      "log_good": -2.9957
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4074,
+      "good": 5.391,
+      "ratio": 0.997,
+      "suggested_scalar": -0.0015,
+      "log_bad": 1.6878,
+      "log_good": 1.6847
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8055,
+      "good": 0.8102,
+      "ratio": 1.0058,
+      "suggested_scalar": 0.0029,
+      "log_bad": -0.2163,
+      "log_good": -0.2105
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1452,
+      "good": 0.1552,
+      "ratio": 1.0689,
+      "suggested_scalar": 0.0336,
+      "log_bad": -1.9296,
+      "log_good": -1.863
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.5439,
+      "good": 4.5054,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0043,
+      "log_bad": 1.5138,
+      "log_good": 1.5053
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 270.0,
+      "good": 266.0,
+      "ratio": 0.9852,
+      "suggested_scalar": -0.0075,
+      "log_bad": 5.5984,
+      "log_good": 5.5835
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 13.0,
+      "good": 14.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0373,
+      "log_bad": 2.5649,
+      "log_good": 2.6391
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6042,
+      "good": 0.5963,
+      "ratio": 0.9869,
+      "suggested_scalar": -0.0066,
+      "log_bad": -0.5039,
+      "log_good": -0.517
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 74.0,
+      "good": 73.0,
+      "ratio": 0.9865,
+      "suggested_scalar": -0.0069,
+      "log_bad": 4.3041,
+      "log_good": 4.2905
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 795.0,
+      "good": 796.0,
+      "ratio": 1.0013,
+      "suggested_scalar": 0.0006,
+      "log_bad": 6.6783,
+      "log_good": 6.6796
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 121.0,
+      "good": 118.0,
+      "ratio": 0.9752,
+      "suggested_scalar": -0.0127,
+      "log_bad": 4.7958,
+      "log_good": 4.7707
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0033,
+      "good": 0.0067,
+      "ratio": 2.0303,
+      "suggested_scalar": 0.3569,
+      "log_bad": -5.7138,
+      "log_good": -5.0056
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2517,
+      "good": 0.2609,
+      "ratio": 1.0366,
+      "suggested_scalar": 0.0181,
+      "log_bad": -1.3795,
+      "log_good": -1.3436
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 37.0,
+      "good": 40.0,
+      "ratio": 1.0811,
+      "suggested_scalar": 0.0393,
+      "log_bad": 3.6109,
+      "log_good": 3.6889
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 74.0,
+      "good": 73.0,
+      "ratio": 0.9865,
+      "suggested_scalar": -0.0069,
+      "log_bad": 4.3041,
+      "log_good": 4.2905
+    },
+    "brevity.mean_sample_size": {
+      "bad": 74.0,
+      "good": 73.0,
+      "ratio": 0.9865,
+      "suggested_scalar": -0.0069,
+      "log_bad": 4.3041,
+      "log_good": 4.2905
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 302.0,
+      "good": 299.0,
+      "ratio": 0.9901,
+      "suggested_scalar": -0.005,
+      "log_bad": 5.7104,
+      "log_good": 5.7004
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 170.0,
+      "good": 171.0,
+      "ratio": 1.0059,
+      "suggested_scalar": 0.003,
+      "log_bad": 5.1358,
+      "log_good": 5.1417
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 222.0,
+      "good": 219.0,
+      "ratio": 0.9865,
+      "suggested_scalar": -0.0069,
+      "log_bad": 5.4027,
+      "log_good": 5.3891
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0166,
+      "good": 0.0167,
+      "ratio": 1.006,
+      "suggested_scalar": 0.003,
+      "log_bad": -4.0984,
+      "log_good": -4.0923
+    },
+    "heaps.mean_k": {
+      "bad": 2.5551,
+      "good": 2.4975,
+      "ratio": 0.9775,
+      "suggested_scalar": -0.0115,
+      "log_bad": 0.9381,
+      "log_good": 0.9153
+    },
+    "halstead.mean_effort": {
+      "bad": 48504.1106,
+      "good": 42623.0129,
+      "ratio": 0.8788,
+      "suggested_scalar": -0.0651,
+      "log_bad": 10.7894,
+      "log_good": 10.6601
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8708,
+      "good": 0.8709,
+      "ratio": 1.0001,
+      "suggested_scalar": 0.0001,
+      "log_bad": -0.1383,
+      "log_good": -0.1382
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 52.0,
+      "good": 52.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9512,
+      "log_good": 3.9512
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 170.0,
+      "good": 171.0,
+      "ratio": 1.0059,
+      "suggested_scalar": 0.003,
+      "log_bad": 5.1358,
+      "log_good": 5.1417
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4356,
+      "good": 0.44,
+      "ratio": 1.0101,
+      "suggested_scalar": 0.0051,
+      "log_bad": -0.831,
+      "log_good": -0.821
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.8713,
+      "good": 7.96,
+      "ratio": 1.0113,
+      "suggested_scalar": 0.0056,
+      "log_bad": 2.0632,
+      "log_good": 2.0744
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1452,
+      "good": 0.1552,
+      "ratio": 1.0689,
+      "suggested_scalar": 0.0336,
+      "log_bad": -1.9296,
+      "log_good": -1.863
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.2167,
+      "good": 3.4086,
+      "ratio": 1.0597,
+      "suggested_scalar": 0.0292,
+      "log_bad": 1.1684,
+      "log_good": 1.2263
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 301.0,
+      "good": 298.0,
+      "ratio": 0.99,
+      "suggested_scalar": -0.005,
+      "log_bad": 5.7071,
+      "log_good": 5.6971
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 21.0,
+      "good": 23.0,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.0458,
+      "log_bad": 3.0445,
+      "log_good": 3.1355
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2694.6728,
+      "good": 2367.9452,
+      "ratio": 0.8788,
+      "suggested_scalar": -0.0651,
+      "log_bad": 7.899,
+      "log_good": 7.7698
+    },
+    "readability.mean_total_lines": {
+      "bad": 53.0,
+      "good": 49.0,
+      "ratio": 0.9245,
+      "suggested_scalar": -0.0395,
+      "log_bad": 3.9703,
+      "log_good": 3.8918
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1812.5862,
+      "good": 1788.8593,
+      "ratio": 0.9869,
+      "suggested_scalar": -0.0066,
+      "log_bad": 7.5025,
+      "log_good": 7.4893
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 563.0,
+      "good": 558.0,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.0045,
+      "log_bad": 6.3333,
+      "log_good": 6.3244
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 24.8302,
+      "good": 26.8776,
+      "ratio": 1.0825,
+      "suggested_scalar": 0.0399,
+      "log_bad": 3.2121,
+      "log_good": 3.2913
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3203,
+      "good": 1.3306,
+      "ratio": 1.0078,
+      "suggested_scalar": 0.0039,
+      "log_bad": 0.2779,
+      "log_good": 0.2856
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 20.0,
+      "good": 21.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0246,
+      "log_bad": 2.9957,
+      "log_good": 3.0445
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9222,
+      "good": 0.9135,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.0048,
+      "log_bad": -0.081,
+      "log_good": -0.0905
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9811,
+      "good": 0.9789,
+      "ratio": 0.9978,
+      "suggested_scalar": -0.0011,
+      "log_bad": -0.0191,
+      "log_good": -0.0213
+    },
+    "halstead.mean_length": {
+      "bad": 291.0,
+      "good": 289.0,
+      "ratio": 0.9931,
+      "suggested_scalar": -0.0035,
+      "log_bad": 5.6733,
+      "log_good": 5.6664
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.6,
+      "good": 9.8,
+      "ratio": 0.9245,
+      "suggested_scalar": -0.0395,
+      "log_bad": 2.3609,
+      "log_good": 2.2824
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2095,
+      "good": 6.1898,
+      "ratio": 0.9968,
+      "suggested_scalar": -0.0016,
+      "log_bad": 1.8261,
+      "log_good": 1.8229
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1234,
+      "good": 0.1244,
+      "ratio": 1.0081,
+      "suggested_scalar": 0.0041,
+      "log_bad": -2.0923,
+      "log_good": -2.0843
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 26.7596,
+      "good": 23.8269,
+      "ratio": 0.8904,
+      "suggested_scalar": -0.0585,
+      "log_bad": 3.2869,
+      "log_good": 3.1708
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 44.0,
+      "good": 44.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7842,
+      "log_good": 3.7842
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8333,
+      "good": 0.8174,
+      "ratio": 0.9809,
+      "suggested_scalar": -0.0097,
+      "log_bad": -0.1824,
+      "log_good": -0.2016
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 53.0,
+      "good": 49.0,
+      "ratio": 0.9245,
+      "suggested_scalar": -0.0395,
+      "log_bad": 3.9703,
+      "log_good": 3.8918
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    }
+  },
+  "code_smells.no_auto_ptr": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.086,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0056,
+      "good": 0.0043,
+      "ratio": 0.7679,
+      "suggested_scalar": -0.0675,
+      "log_bad": -5.185,
+      "log_good": -5.4491
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8033,
+      "good": 0.8167,
+      "ratio": 1.0167,
+      "suggested_scalar": 0.0042,
+      "log_bad": -0.219,
+      "log_good": -0.2025
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0056,
+      "good": 0.0043,
+      "ratio": 0.7679,
+      "suggested_scalar": -0.0675,
+      "log_bad": -5.185,
+      "log_good": -5.4491
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5705,
+      "good": 4.5148,
+      "ratio": 0.9878,
+      "suggested_scalar": -0.0031,
+      "log_bad": 1.5196,
+      "log_good": 1.5074
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 115.0,
+      "good": 81.0,
+      "ratio": 0.7043,
+      "suggested_scalar": -0.0896,
+      "log_bad": 4.7449,
+      "log_good": 4.3944
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5026,
+      "good": 0.3293,
+      "ratio": 0.6552,
+      "suggested_scalar": -0.1081,
+      "log_bad": -0.688,
+      "log_good": -1.1108
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 22.0,
+      "good": 20.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0244,
+      "log_bad": 3.091,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7417,
+      "good": 0.6125,
+      "ratio": 0.8258,
+      "suggested_scalar": -0.0489,
+      "log_bad": -0.2988,
+      "log_good": -0.4902
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.5902,
+      "good": 4.2667,
+      "ratio": 0.9295,
+      "suggested_scalar": -0.0187,
+      "log_bad": 1.5239,
+      "log_good": 1.4508
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 533.0,
+      "good": 462.0,
+      "ratio": 0.8668,
+      "suggested_scalar": -0.0365,
+      "log_bad": 6.2785,
+      "log_good": 6.1356
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0466,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0004,
+      "good": 1.0,
+      "ratio": 2.5e3,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.824,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1475,
+      "good": 0.0833,
+      "ratio": 0.5647,
+      "suggested_scalar": -0.1461,
+      "log_bad": -1.9139,
+      "log_good": -2.4853
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0331,
+      "good": 1.0862,
+      "ratio": 1.0514,
+      "suggested_scalar": 0.0128,
+      "log_bad": 0.0326,
+      "log_good": 0.0827
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 167.0,
+      "good": 126.0,
+      "ratio": 0.7545,
+      "suggested_scalar": -0.072,
+      "log_bad": 5.118,
+      "log_good": 4.8363
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.6364,
+      "good": 106.052,
+      "ratio": 1.0135,
+      "suggested_scalar": 0.0034,
+      "log_bad": 4.6505,
+      "log_good": 4.6639
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6109,
+      "good": 0.6833,
+      "ratio": 1.1185,
+      "suggested_scalar": 0.0286,
+      "log_bad": -0.4928,
+      "log_good": -0.3808
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.7005,
+      "good": 9.6097,
+      "ratio": 1.1045,
+      "suggested_scalar": 0.0254,
+      "log_bad": 2.1634,
+      "log_good": 2.2628
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2253.0,
+      "good": 1952.0,
+      "ratio": 0.8664,
+      "suggested_scalar": -0.0367,
+      "log_bad": 7.72,
+      "log_good": 7.5766
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0984,
+      "good": 0.0833,
+      "ratio": 0.8465,
+      "suggested_scalar": -0.0426,
+      "log_bad": -2.3187,
+      "log_good": -2.4853
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7869,
+      "good": 0.8,
+      "ratio": 1.0166,
+      "suggested_scalar": 0.0042,
+      "log_bad": -0.2397,
+      "log_good": -0.2231
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.3509,
+      "good": 8.25,
+      "ratio": 0.8823,
+      "suggested_scalar": -0.032,
+      "log_bad": 2.2355,
+      "log_good": 2.1102
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 26.0,
+      "good": 25.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.01,
+      "log_bad": 3.2581,
+      "log_good": 3.2189
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 14.6025,
+      "good": 12.7289,
+      "ratio": 0.8717,
+      "suggested_scalar": -0.0351,
+      "log_bad": 2.6812,
+      "log_good": 2.5439
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 113.0,
+      "good": 74.0,
+      "ratio": 0.6549,
+      "suggested_scalar": -0.1082,
+      "log_bad": 4.7274,
+      "log_good": 4.3041
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9567,
+      "good": 0.9411,
+      "ratio": 0.9837,
+      "suggested_scalar": -0.0042,
+      "log_bad": -0.0443,
+      "log_good": -0.0607
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 27.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0269,
+      "log_bad": 3.4012,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6369,
+      "good": 0.668,
+      "ratio": 1.0488,
+      "suggested_scalar": 0.0122,
+      "log_bad": -0.4511,
+      "log_good": -0.4035
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4331,
+      "good": 0.4783,
+      "ratio": 1.1044,
+      "suggested_scalar": 0.0254,
+      "log_bad": -0.8368,
+      "log_good": -0.7375
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7543,
+      "good": 3.0123,
+      "ratio": 1.0937,
+      "suggested_scalar": 0.0229,
+      "log_bad": 1.0132,
+      "log_good": 1.1027
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 531.0,
+      "good": 460.0,
+      "ratio": 0.8663,
+      "suggested_scalar": -0.0367,
+      "log_bad": 6.2748,
+      "log_good": 6.1312
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.045,
+      "good": 0.0455,
+      "ratio": 1.0111,
+      "suggested_scalar": 0.0028,
+      "log_bad": -3.1011,
+      "log_good": -3.09
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 5.8329,
+      "ratio": 0.9835,
+      "suggested_scalar": -0.0043,
+      "log_bad": 1.7801,
+      "log_good": 1.7635
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 21.0,
+      "good": 22.0,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.0119,
+      "log_bad": 3.0445,
+      "log_good": 3.091
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.367,
+      "good": 1.5383,
+      "ratio": 1.1253,
+      "suggested_scalar": 0.0302,
+      "log_bad": 0.3126,
+      "log_good": 0.4307
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8616,
+      "good": 5.4631,
+      "ratio": 0.932,
+      "suggested_scalar": -0.018,
+      "log_bad": 1.7684,
+      "log_good": 1.698
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7706,
+      "good": 0.774,
+      "ratio": 1.0044,
+      "suggested_scalar": 0.0011,
+      "log_bad": -0.2606,
+      "log_good": -0.2562
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1644,
+      "good": 0.1781,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.0205,
+      "log_bad": -1.8055,
+      "log_good": -1.7254
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.9497,
+      "good": 3.1,
+      "ratio": 1.051,
+      "suggested_scalar": 0.0127,
+      "log_bad": 1.0817,
+      "log_good": 1.1314
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.2808,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 380.0,
+      "good": 323.0,
+      "ratio": 0.85,
+      "suggested_scalar": -0.0415,
+      "log_bad": 5.9402,
+      "log_good": 5.7777
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 12.0,
+      "good": 13.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.0205,
+      "log_bad": 2.4849,
+      "log_good": 2.5649
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.166,
+      "good": 0.9383,
+      "ratio": 0.8047,
+      "suggested_scalar": -0.0555,
+      "log_bad": 0.1536,
+      "log_good": -0.0637
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 120.0,
+      "good": 85.0,
+      "ratio": 0.7083,
+      "suggested_scalar": -0.0881,
+      "log_bad": 4.7875,
+      "log_good": 4.4427
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1064.0,
+      "good": 848.0,
+      "ratio": 0.797,
+      "suggested_scalar": -0.058,
+      "log_bad": 6.9698,
+      "log_good": 6.7429
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 218.0,
+      "good": 175.0,
+      "ratio": 0.8028,
+      "suggested_scalar": -0.0562,
+      "log_bad": 5.3845,
+      "log_good": 5.1648
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0131,
+      "good": 0.0152,
+      "ratio": 1.1603,
+      "suggested_scalar": 0.038,
+      "log_bad": -4.3351,
+      "log_good": -4.1865
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2364,
+      "good": 0.2619,
+      "ratio": 1.1079,
+      "suggested_scalar": 0.0262,
+      "log_bad": -1.4422,
+      "log_good": -1.3398
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 88.0,
+      "good": 92.0,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.0114,
+      "log_bad": 4.4773,
+      "log_good": 4.5218
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 120.0,
+      "good": 85.0,
+      "ratio": 0.7083,
+      "suggested_scalar": -0.0881,
+      "log_bad": 4.7875,
+      "log_good": 4.4427
+    },
+    "brevity.mean_sample_size": {
+      "bad": 120.0,
+      "good": 85.0,
+      "ratio": 0.7083,
+      "suggested_scalar": -0.0881,
+      "log_bad": 4.7875,
+      "log_good": 4.4427
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 533.0,
+      "good": 462.0,
+      "ratio": 0.8668,
+      "suggested_scalar": -0.0365,
+      "log_bad": 6.2785,
+      "log_good": 6.1356
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 289.0,
+      "good": 266.0,
+      "ratio": 0.9204,
+      "suggested_scalar": -0.0212,
+      "log_bad": 5.6664,
+      "log_good": 5.5835
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 295.0,
+      "good": 238.0,
+      "ratio": 0.8068,
+      "suggested_scalar": -0.0549,
+      "log_bad": 5.687,
+      "log_good": 5.4723
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0056,
+      "good": 1.0,
+      "ratio": 178.5714,
+      "suggested_scalar": 1.3254,
+      "log_bad": -5.185,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.2049,
+      "good": 1.9851,
+      "ratio": 1.6475,
+      "suggested_scalar": 0.1276,
+      "log_bad": 0.1864,
+      "log_good": 0.6857
+    },
+    "halstead.mean_effort": {
+      "bad": 134571.8648,
+      "good": 123151.5863,
+      "ratio": 0.9151,
+      "suggested_scalar": -0.0227,
+      "log_bad": 11.8099,
+      "log_good": 11.7212
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8487,
+      "good": 0.8524,
+      "ratio": 1.0044,
+      "suggested_scalar": 0.0011,
+      "log_bad": -0.164,
+      "log_good": -0.1597
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 85.0,
+      "good": 54.0,
+      "ratio": 0.6353,
+      "suggested_scalar": -0.116,
+      "log_bad": 4.4427,
+      "log_good": 3.989
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 293.0,
+      "good": 269.0,
+      "ratio": 0.9181,
+      "suggested_scalar": -0.0218,
+      "log_bad": 5.6802,
+      "log_good": 5.5947
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4012,
+      "good": 0.3175,
+      "ratio": 0.7914,
+      "suggested_scalar": -0.0598,
+      "log_bad": -0.9133,
+      "log_good": -1.1473
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.3713,
+      "good": 6.7302,
+      "ratio": 1.0563,
+      "suggested_scalar": 0.014,
+      "log_bad": 1.8518,
+      "log_good": 1.9066
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1644,
+      "good": 0.1781,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.0205,
+      "log_bad": -1.8055,
+      "log_good": -1.7254
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.7404,
+      "good": 3.3,
+      "ratio": 0.8823,
+      "suggested_scalar": -0.032,
+      "log_bad": 1.3192,
+      "log_good": 1.1939
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 532.0,
+      "good": 461.0,
+      "ratio": 0.8665,
+      "suggested_scalar": -0.0366,
+      "log_bad": 6.2766,
+      "log_good": 6.1334
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 0.3544,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 79.0,
+      "good": 83.0,
+      "ratio": 1.0506,
+      "suggested_scalar": 0.0126,
+      "log_bad": 4.3694,
+      "log_good": 4.4188
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 7476.2147,
+      "good": 6841.7548,
+      "ratio": 0.9151,
+      "suggested_scalar": -0.0227,
+      "log_bad": 8.9195,
+      "log_good": 8.8308
+    },
+    "readability.mean_total_lines": {
+      "bad": 57.0,
+      "good": 56.0,
+      "ratio": 0.9825,
+      "suggested_scalar": -0.0045,
+      "log_bad": 4.0431,
+      "log_good": 4.0254
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 3498.0454,
+      "good": 2814.8934,
+      "ratio": 0.8047,
+      "suggested_scalar": -0.0555,
+      "log_bad": 8.16,
+      "log_good": 7.9427
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 818.0,
+      "good": 648.0,
+      "ratio": 0.7922,
+      "suggested_scalar": -0.0596,
+      "log_bad": 6.7069,
+      "log_good": 6.4739
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 36.8947,
+      "good": 32.25,
+      "ratio": 0.8741,
+      "suggested_scalar": -0.0344,
+      "log_bad": 3.6081,
+      "log_good": 3.4735
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0958,
+      "good": 1.0923,
+      "ratio": 0.9968,
+      "suggested_scalar": -0.0008,
+      "log_bad": 0.0915,
+      "log_good": 0.0883
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0466,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 6.0,
+      "good": 3.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.1772,
+      "log_bad": 1.7918,
+      "log_good": 1.0986
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 9.0,
+      "good": 5.0,
+      "ratio": 0.5556,
+      "suggested_scalar": -0.1503,
+      "log_bad": 2.1972,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7921,
+      "good": 0.743,
+      "ratio": 0.938,
+      "suggested_scalar": -0.0164,
+      "log_bad": -0.2331,
+      "log_good": -0.2971
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9736,
+      "good": 0.9562,
+      "ratio": 0.9821,
+      "suggested_scalar": -0.0046,
+      "log_bad": -0.0268,
+      "log_good": -0.0448
+    },
+    "halstead.mean_length": {
+      "bad": 511.0,
+      "good": 444.0,
+      "ratio": 0.8689,
+      "suggested_scalar": -0.0359,
+      "log_bad": 6.2364,
+      "log_good": 6.0958
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9069,
+      "good": 6.4094,
+      "ratio": 0.928,
+      "suggested_scalar": -0.0191,
+      "log_bad": 1.9325,
+      "log_good": 1.8578
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1286,
+      "good": 0.1364,
+      "ratio": 1.0607,
+      "suggested_scalar": 0.0151,
+      "log_bad": -2.051,
+      "log_good": -1.9922
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 38.4706,
+      "good": 43.75,
+      "ratio": 1.1372,
+      "suggested_scalar": 0.0329,
+      "log_bad": 3.6499,
+      "log_good": 3.7785
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0466,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 67.0,
+      "good": 40.0,
+      "ratio": 0.597,
+      "suggested_scalar": -0.1319,
+      "log_bad": 4.2047,
+      "log_good": 3.6889
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7017,
+      "good": 0.6134,
+      "ratio": 0.8742,
+      "suggested_scalar": -0.0344,
+      "log_bad": -0.3542,
+      "log_good": -0.4887
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 61.0,
+      "good": 60.0,
+      "ratio": 0.9836,
+      "suggested_scalar": -0.0042,
+      "log_bad": 4.1109,
+      "log_good": 4.0943
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.no_util_or_meaningless_class_names": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.9022,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0247,
+      "good": 0.0245,
+      "ratio": 0.9919,
+      "suggested_scalar": -0.0255,
+      "log_bad": -3.701,
+      "log_good": -3.7091
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7857,
+      "good": 0.8378,
+      "ratio": 1.0663,
+      "suggested_scalar": 0.2014,
+      "log_bad": -0.2412,
+      "log_good": -0.177
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0247,
+      "good": 0.0245,
+      "ratio": 0.9919,
+      "suggested_scalar": -0.0255,
+      "log_bad": -3.701,
+      "log_good": -3.7091
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8725,
+      "good": 4.86,
+      "ratio": 0.9974,
+      "suggested_scalar": -0.0081,
+      "log_bad": 1.5836,
+      "log_good": 1.581
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 114.0,
+      "good": 96.0,
+      "ratio": 0.8421,
+      "suggested_scalar": -0.539,
+      "log_bad": 4.7362,
+      "log_good": 4.5643
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5764,
+      "good": 0.5288,
+      "ratio": 0.9174,
+      "suggested_scalar": -0.2703,
+      "log_bad": -0.551,
+      "log_good": -0.6371
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7411,
+      "good": 0.7123,
+      "ratio": 0.9611,
+      "suggested_scalar": -0.1243,
+      "log_bad": -0.2996,
+      "log_good": -0.3393
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.2381,
+      "good": 3.6216,
+      "ratio": 1.1184,
+      "suggested_scalar": 0.351,
+      "log_bad": 1.175,
+      "log_good": 1.2869
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 364.0,
+      "good": 326.0,
+      "ratio": 0.8956,
+      "suggested_scalar": -0.3458,
+      "log_bad": 5.8972,
+      "log_good": 5.7869
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2619,
+      "good": 0.2162,
+      "ratio": 0.8255,
+      "suggested_scalar": -0.6014,
+      "log_bad": -1.3398,
+      "log_good": -1.5316
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9195,
+      "good": 0.9449,
+      "ratio": 1.0276,
+      "suggested_scalar": 0.0855,
+      "log_bad": -0.0839,
+      "log_good": -0.0567
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 143.0,
+      "good": 125.0,
+      "ratio": 0.8741,
+      "suggested_scalar": -0.4219,
+      "log_bad": 4.9628,
+      "log_good": 4.8283
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 94.6383,
+      "good": 92.5411,
+      "ratio": 0.9778,
+      "suggested_scalar": -0.0703,
+      "log_bad": 4.5501,
+      "log_good": 4.5277
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4904,
+      "good": 0.5231,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.2024,
+      "log_bad": -0.7125,
+      "log_good": -0.648
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.0885,
+      "good": 10.7055,
+      "ratio": 1.0612,
+      "suggested_scalar": 0.1862,
+      "log_bad": 2.3114,
+      "log_good": 2.3708
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1749.0,
+      "good": 1573.0,
+      "ratio": 0.8994,
+      "suggested_scalar": -0.3326,
+      "log_bad": 7.4668,
+      "log_good": 7.3607
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0714,
+      "good": 0.1351,
+      "ratio": 1.8922,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.6395,
+      "log_good": -2.0017
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7619,
+      "good": 0.8108,
+      "ratio": 1.0642,
+      "suggested_scalar": 0.1951,
+      "log_bad": -0.2719,
+      "log_good": -0.2097
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.6667,
+      "good": 8.8108,
+      "ratio": 1.0166,
+      "suggested_scalar": 0.0517,
+      "log_bad": 2.1595,
+      "log_good": 2.176
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 10.2766,
+      "good": 10.3974,
+      "ratio": 1.0118,
+      "suggested_scalar": 0.0367,
+      "log_bad": 2.3299,
+      "log_good": 2.3416
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 86.0,
+      "good": 69.0,
+      "ratio": 0.8023,
+      "suggested_scalar": -0.6907,
+      "log_bad": 4.4543,
+      "log_good": 4.2341
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.932,
+      "good": 0.9402,
+      "ratio": 1.0088,
+      "suggested_scalar": 0.0275,
+      "log_bad": -0.0704,
+      "log_good": -0.0617
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 27.0,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.1141,
+      "log_bad": 3.3322,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5832,
+      "good": 0.5912,
+      "ratio": 1.0137,
+      "suggested_scalar": 0.0427,
+      "log_bad": -0.5392,
+      "log_good": -0.5256
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2928,
+      "good": 0.3179,
+      "ratio": 1.0857,
+      "suggested_scalar": 0.2579,
+      "log_bad": -1.2283,
+      "log_good": -1.146
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3992,
+      "good": 2.4463,
+      "ratio": 1.0196,
+      "suggested_scalar": 0.061,
+      "log_bad": 0.8751,
+      "log_good": 0.8946
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 362.0,
+      "good": 324.0,
+      "ratio": 0.895,
+      "suggested_scalar": -0.3478,
+      "log_bad": 5.8916,
+      "log_good": 5.7807
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0357,
+      "good": 0.0399,
+      "ratio": 1.1176,
+      "suggested_scalar": 0.3488,
+      "log_bad": -3.3326,
+      "log_good": -3.2214
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.1085,
+      "good": 6.1085,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8097,
+      "log_good": 1.8097
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 43.0,
+      "good": 42.0,
+      "ratio": 0.9767,
+      "suggested_scalar": -0.0738,
+      "log_bad": 3.7612,
+      "log_good": 3.7377
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.327,
+      "good": 1.3972,
+      "ratio": 1.0529,
+      "suggested_scalar": 0.1617,
+      "log_bad": 0.2829,
+      "log_good": 0.3345
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.007,
+      "good": 0.008,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.4188,
+      "log_bad": -4.9618,
+      "log_good": -4.8283
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9422,
+      "good": 5.745,
+      "ratio": 0.9668,
+      "suggested_scalar": -0.1058,
+      "log_bad": 1.7821,
+      "log_good": 1.7483
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7977,
+      "good": 0.7956,
+      "ratio": 0.9974,
+      "suggested_scalar": -0.0083,
+      "log_bad": -0.226,
+      "log_good": -0.2287
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1923,
+      "good": 0.1957,
+      "ratio": 1.0177,
+      "suggested_scalar": 0.055,
+      "log_bad": -1.6487,
+      "log_good": -1.6312
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1762,
+      "good": 3.2719,
+      "ratio": 1.0301,
+      "suggested_scalar": 0.0931,
+      "log_bad": 1.1557,
+      "log_good": 1.1854
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 298.0,
+      "good": 263.0,
+      "ratio": 0.8826,
+      "suggested_scalar": -0.3918,
+      "log_bad": 5.6971,
+      "log_good": 5.5722
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7448,
+      "good": 0.6431,
+      "ratio": 0.8635,
+      "suggested_scalar": -0.4604,
+      "log_bad": -0.2946,
+      "log_good": -0.4415
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 115.0,
+      "good": 97.0,
+      "ratio": 0.8435,
+      "suggested_scalar": -0.5338,
+      "log_bad": 4.7449,
+      "log_good": 4.5747
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1060.0,
+      "good": 949.0,
+      "ratio": 0.8953,
+      "suggested_scalar": -0.3469,
+      "log_bad": 6.966,
+      "log_good": 6.8554
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 147.0,
+      "good": 127.0,
+      "ratio": 0.8639,
+      "suggested_scalar": -0.4587,
+      "log_bad": 4.9904,
+      "log_good": 4.8442
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2445,
+      "good": 0.2515,
+      "ratio": 1.0286,
+      "suggested_scalar": 0.0885,
+      "log_bad": -1.4085,
+      "log_good": -1.3803
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 60.0,
+      "good": 59.0,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0527,
+      "log_bad": 4.0943,
+      "log_good": 4.0775
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 115.0,
+      "good": 97.0,
+      "ratio": 0.8435,
+      "suggested_scalar": -0.5338,
+      "log_bad": 4.7449,
+      "log_good": 4.5747
+    },
+    "brevity.mean_sample_size": {
+      "bad": 115.0,
+      "good": 97.0,
+      "ratio": 0.8435,
+      "suggested_scalar": -0.5338,
+      "log_bad": 4.7449,
+      "log_good": 4.5747
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 364.0,
+      "good": 326.0,
+      "ratio": 0.8956,
+      "suggested_scalar": -0.3458,
+      "log_bad": 5.8972,
+      "log_good": 5.7869
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 182.0,
+      "good": 165.0,
+      "ratio": 0.9066,
+      "suggested_scalar": -0.3075,
+      "log_bad": 5.204,
+      "log_good": 5.1059
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 245.0,
+      "good": 214.0,
+      "ratio": 0.8735,
+      "suggested_scalar": -0.4243,
+      "log_bad": 5.5013,
+      "log_good": 5.366
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0082,
+      "good": 0.0092,
+      "ratio": 1.122,
+      "suggested_scalar": 0.3609,
+      "log_bad": -4.8036,
+      "log_good": -4.6886
+    },
+    "heaps.mean_k": {
+      "bad": 1.5397,
+      "good": 1.7685,
+      "ratio": 1.1486,
+      "suggested_scalar": 0.4345,
+      "log_bad": 0.4316,
+      "log_good": 0.5701
+    },
+    "halstead.mean_effort": {
+      "bad": 53468.6356,
+      "good": 47941.2469,
+      "ratio": 0.8966,
+      "suggested_scalar": -0.3422,
+      "log_bad": 10.8869,
+      "log_good": 10.7777
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.868,
+      "good": 0.8705,
+      "ratio": 1.0029,
+      "suggested_scalar": 0.009,
+      "log_bad": -0.1416,
+      "log_good": -0.1387
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 86.0,
+      "good": 69.0,
+      "ratio": 0.8023,
+      "suggested_scalar": -0.6907,
+      "log_bad": 4.4543,
+      "log_good": 4.2341
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 180.0,
+      "good": 166.0,
+      "ratio": 0.9222,
+      "suggested_scalar": -0.2539,
+      "log_bad": 5.193,
+      "log_good": 5.112
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5315,
+      "good": 0.488,
+      "ratio": 0.9182,
+      "suggested_scalar": -0.2678,
+      "log_bad": -0.6321,
+      "log_good": -0.7174
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.4126,
+      "good": 7.592,
+      "ratio": 1.0242,
+      "suggested_scalar": 0.075,
+      "log_bad": 2.0032,
+      "log_good": 2.0271
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1923,
+      "good": 0.1957,
+      "ratio": 1.0177,
+      "suggested_scalar": 0.055,
+      "log_bad": -1.6487,
+      "log_good": -1.6312
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.5778,
+      "good": 4.7822,
+      "ratio": 1.0447,
+      "suggested_scalar": 0.137,
+      "log_bad": 1.5212,
+      "log_good": 1.5649
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 363.0,
+      "good": 325.0,
+      "ratio": 0.8953,
+      "suggested_scalar": -0.3468,
+      "log_bad": 5.8944,
+      "log_good": 5.7838
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 42.0,
+      "good": 42.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7377,
+      "log_good": 3.7377
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2970.4798,
+      "good": 2663.4026,
+      "ratio": 0.8966,
+      "suggested_scalar": -0.3422,
+      "log_bad": 7.9965,
+      "log_good": 7.8874
+    },
+    "readability.mean_total_lines": {
+      "bad": 42.0,
+      "good": 37.0,
+      "ratio": 0.881,
+      "suggested_scalar": -0.3975,
+      "log_bad": 3.7377,
+      "log_good": 3.6109
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2234.355,
+      "good": 1929.394,
+      "ratio": 0.8635,
+      "suggested_scalar": -0.4602,
+      "log_bad": 7.7117,
+      "log_good": 7.565
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 729.0,
+      "good": 643.0,
+      "ratio": 0.882,
+      "suggested_scalar": -0.3937,
+      "log_bad": 6.5917,
+      "log_good": 6.4661
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 40.2143,
+      "good": 41.1622,
+      "ratio": 1.0236,
+      "suggested_scalar": 0.0731,
+      "log_bad": 3.6942,
+      "log_good": 3.7175
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2222,
+      "good": 1.2453,
+      "ratio": 1.0189,
+      "suggested_scalar": 0.0587,
+      "log_bad": 0.2007,
+      "log_good": 0.2194
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 28.0,
+      "good": 27.0,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.1141,
+      "log_bad": 3.3322,
+      "log_good": 3.2958
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 11.0,
+      "good": 8.0,
+      "ratio": 0.7273,
+      "suggested_scalar": -0.9987,
+      "log_bad": 2.3979,
+      "log_good": 2.0794
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8591,
+      "good": 0.8403,
+      "ratio": 0.9781,
+      "suggested_scalar": -0.0694,
+      "log_bad": -0.1519,
+      "log_good": -0.174
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9703,
+      "good": 0.954,
+      "ratio": 0.9832,
+      "suggested_scalar": -0.0531,
+      "log_bad": -0.0301,
+      "log_good": -0.0471
+    },
+    "halstead.mean_length": {
+      "bad": 327.0,
+      "good": 293.0,
+      "ratio": 0.896,
+      "suggested_scalar": -0.3443,
+      "log_bad": 5.79,
+      "log_good": 5.6802
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.6667,
+      "good": 5.6667,
+      "ratio": 0.85,
+      "suggested_scalar": -0.5097,
+      "log_bad": 1.8971,
+      "log_good": 1.7346
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8455,
+      "good": 6.5999,
+      "ratio": 0.9641,
+      "suggested_scalar": -0.1146,
+      "log_bad": 1.9236,
+      "log_good": 1.8871
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1045,
+      "good": 0.1052,
+      "ratio": 1.0067,
+      "suggested_scalar": 0.0209,
+      "log_bad": -2.2586,
+      "log_good": -2.2519
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 23.9302,
+      "good": 24.8478,
+      "ratio": 1.0383,
+      "suggested_scalar": 0.118,
+      "log_bad": 3.1751,
+      "log_good": 3.2128
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 1.602,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 76.0,
+      "good": 61.0,
+      "ratio": 0.8026,
+      "suggested_scalar": -0.6895,
+      "log_bad": 4.3307,
+      "log_good": 4.1109
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7551,
+      "good": 0.7243,
+      "ratio": 0.9592,
+      "suggested_scalar": -0.1306,
+      "log_bad": -0.2809,
+      "log_good": -0.3225
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 42.0,
+      "good": 37.0,
+      "ratio": 0.881,
+      "suggested_scalar": -0.3975,
+      "log_bad": 3.7377,
+      "log_good": 3.6109
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "scope_and_assignment.declared_close_to_use": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0196,
+      "good": 0.023,
+      "ratio": 1.1735,
+      "suggested_scalar": 0.1456,
+      "log_bad": -3.9322,
+      "log_good": -3.7723
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9359,
+      "good": 0.9516,
+      "ratio": 1.0168,
+      "suggested_scalar": 0.0151,
+      "log_bad": -0.0662,
+      "log_good": -0.0496
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0196,
+      "good": 0.023,
+      "ratio": 1.1735,
+      "suggested_scalar": 0.1456,
+      "log_bad": -3.9322,
+      "log_good": -3.7723
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5171,
+      "good": 4.5563,
+      "ratio": 1.0087,
+      "suggested_scalar": 0.0079,
+      "log_bad": 1.5079,
+      "log_good": 1.5165
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 142.0,
+      "good": 107.0,
+      "ratio": 0.7535,
+      "suggested_scalar": -0.2576,
+      "log_bad": 4.9558,
+      "log_good": 4.6728
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5243,
+      "good": 0.4875,
+      "ratio": 0.9298,
+      "suggested_scalar": -0.0662,
+      "log_bad": -0.6457,
+      "log_good": -0.7185
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 24.0,
+      "good": 23.0,
+      "ratio": 0.9583,
+      "suggested_scalar": -0.0387,
+      "log_bad": 3.1781,
+      "log_good": 3.1355
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6595,
+      "good": 0.636,
+      "ratio": 0.9644,
+      "suggested_scalar": -0.033,
+      "log_bad": -0.4163,
+      "log_good": -0.4526
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.0513,
+      "good": 5.129,
+      "ratio": 1.0154,
+      "suggested_scalar": 0.0139,
+      "log_bad": 1.6196,
+      "log_good": 1.6349
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 511.0,
+      "good": 391.0,
+      "ratio": 0.7652,
+      "suggested_scalar": -0.2436,
+      "log_bad": 6.2364,
+      "log_good": 5.9687
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1154,
+      "good": 1.0,
+      "ratio": 8.6655,
+      "suggested_scalar": 1.9655,
+      "log_bad": -2.1594,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0004,
+      "good": 0.0005,
+      "ratio": 1.25,
+      "suggested_scalar": 0.2031,
+      "log_bad": -7.824,
+      "log_good": -7.6009
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9186,
+      "good": 0.9035,
+      "ratio": 0.9836,
+      "suggested_scalar": -0.0151,
+      "log_bad": -0.0849,
+      "log_good": -0.1015
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 205.0,
+      "good": 139.0,
+      "ratio": 0.678,
+      "suggested_scalar": -0.3537,
+      "log_bad": 5.323,
+      "log_good": 4.9345
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.3426,
+      "good": 101.495,
+      "ratio": 1.0015,
+      "suggested_scalar": 0.0014,
+      "log_bad": 4.6185,
+      "log_good": 4.62
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.3804,
+      "good": 0.3718,
+      "ratio": 0.9774,
+      "suggested_scalar": -0.0208,
+      "log_bad": -0.9665,
+      "log_good": -0.9894
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 12.2228,
+      "good": 12.92,
+      "ratio": 1.057,
+      "suggested_scalar": 0.0505,
+      "log_bad": 2.5033,
+      "log_good": 2.5588
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2522.0,
+      "good": 1846.0,
+      "ratio": 0.732,
+      "suggested_scalar": -0.284,
+      "log_bad": 7.8328,
+      "log_good": 7.5208
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1538,
+      "good": 0.1129,
+      "ratio": 0.7341,
+      "suggested_scalar": -0.2814,
+      "log_bad": -1.8721,
+      "log_good": -2.1813
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.859,
+      "good": 0.8548,
+      "ratio": 0.9951,
+      "suggested_scalar": -0.0045,
+      "log_bad": -0.152,
+      "log_good": -0.1569
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.4058,
+      "good": 6.3065,
+      "ratio": 0.8516,
+      "suggested_scalar": -0.1463,
+      "log_bad": 2.0023,
+      "log_good": 1.8416
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 6.023,
+      "good": 6.5317,
+      "ratio": 1.0845,
+      "suggested_scalar": 0.0738,
+      "log_bad": 1.7956,
+      "log_good": 1.8767
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 186.0,
+      "good": 122.0,
+      "ratio": 0.6559,
+      "suggested_scalar": -0.3839,
+      "log_bad": 5.2257,
+      "log_good": 4.804
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9448,
+      "good": 0.9446,
+      "ratio": 0.9998,
+      "suggested_scalar": -0.0002,
+      "log_bad": -0.0568,
+      "log_good": -0.057
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 36.0,
+      "good": 31.0,
+      "ratio": 0.8611,
+      "suggested_scalar": -0.1361,
+      "log_bad": 3.5835,
+      "log_good": 3.434
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6019,
+      "good": 0.5764,
+      "ratio": 0.9576,
+      "suggested_scalar": -0.0394,
+      "log_bad": -0.5077,
+      "log_good": -0.551
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.1493,
+      "good": 0.1671,
+      "ratio": 1.1192,
+      "suggested_scalar": 0.1025,
+      "log_bad": -1.9018,
+      "log_good": -1.7892
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.512,
+      "good": 2.3606,
+      "ratio": 0.9397,
+      "suggested_scalar": -0.0566,
+      "log_bad": 0.9211,
+      "log_good": 0.8589
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 509.0,
+      "good": 389.0,
+      "ratio": 0.7642,
+      "suggested_scalar": -0.2447,
+      "log_bad": 6.2324,
+      "log_good": 5.9636
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 41.0,
+      "good": 34.0,
+      "ratio": 0.8293,
+      "suggested_scalar": -0.1704,
+      "log_bad": 3.7136,
+      "log_good": 3.5264
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0176,
+      "good": 0.023,
+      "ratio": 1.3068,
+      "suggested_scalar": 0.2436,
+      "log_bad": -4.0399,
+      "log_good": -3.7723
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.1497,
+      "good": 6.0875,
+      "ratio": 0.9899,
+      "suggested_scalar": -0.0093,
+      "log_bad": 1.8164,
+      "log_good": 1.8062
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 17.0,
+      "good": 15.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.1139,
+      "log_bad": 2.8332,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.4904,
+      "good": 0.5999,
+      "ratio": 1.2233,
+      "suggested_scalar": 0.1835,
+      "log_bad": -0.7125,
+      "log_good": -0.511
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.3339,
+      "good": 6.02,
+      "ratio": 0.9504,
+      "suggested_scalar": -0.0463,
+      "log_bad": 1.8459,
+      "log_good": 1.7951
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7345,
+      "good": 0.7485,
+      "ratio": 1.0191,
+      "suggested_scalar": 0.0172,
+      "log_bad": -0.3086,
+      "log_good": -0.2897
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1702,
+      "good": 0.1842,
+      "ratio": 1.0823,
+      "suggested_scalar": 0.072,
+      "log_bad": -1.7708,
+      "log_good": -1.6917
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.4961,
+      "good": 3.5944,
+      "ratio": 1.0281,
+      "suggested_scalar": 0.0252,
+      "log_bad": 1.2516,
+      "log_good": 1.2794
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 14.0,
+      "good": 8.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -0.5094,
+      "log_bad": 2.6391,
+      "log_good": 2.0794
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 468.0,
+      "good": 354.0,
+      "ratio": 0.7564,
+      "suggested_scalar": -0.2541,
+      "log_bad": 6.1485,
+      "log_good": 5.8693
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 8.0,
+      "good": 7.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.1215,
+      "log_bad": 2.0794,
+      "log_good": 1.9459
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0772,
+      "good": 0.7843,
+      "ratio": 0.7281,
+      "suggested_scalar": -0.2888,
+      "log_bad": 0.0744,
+      "log_good": -0.243
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 145.0,
+      "good": 114.0,
+      "ratio": 0.7862,
+      "suggested_scalar": -0.2189,
+      "log_bad": 4.9767,
+      "log_good": 4.7362
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1389.0,
+      "good": 969.0,
+      "ratio": 0.6976,
+      "suggested_scalar": -0.3278,
+      "log_bad": 7.2363,
+      "log_good": 6.8763
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 213.0,
+      "good": 144.0,
+      "ratio": 0.6761,
+      "suggested_scalar": -0.3563,
+      "log_bad": 5.3613,
+      "log_good": 4.9698
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0117,
+      "good": 0.0153,
+      "ratio": 1.3077,
+      "suggested_scalar": 0.2442,
+      "log_bad": -4.4482,
+      "log_good": -4.1799
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1957,
+      "good": 0.2302,
+      "ratio": 1.1763,
+      "suggested_scalar": 0.1478,
+      "log_bad": -1.6312,
+      "log_good": -1.4688
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 73.0,
+      "good": 52.0,
+      "ratio": 0.7123,
+      "suggested_scalar": -0.3088,
+      "log_bad": 4.2905,
+      "log_good": 3.9512
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 145.0,
+      "good": 114.0,
+      "ratio": 0.7862,
+      "suggested_scalar": -0.2189,
+      "log_bad": 4.9767,
+      "log_good": 4.7362
+    },
+    "brevity.mean_sample_size": {
+      "bad": 145.0,
+      "good": 114.0,
+      "ratio": 0.7862,
+      "suggested_scalar": -0.2189,
+      "log_bad": 4.9767,
+      "log_good": 4.7362
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 511.0,
+      "good": 391.0,
+      "ratio": 0.7652,
+      "suggested_scalar": -0.2436,
+      "log_bad": 6.2364,
+      "log_good": 5.9687
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 244.0,
+      "good": 206.0,
+      "ratio": 0.8443,
+      "suggested_scalar": -0.1541,
+      "log_bad": 5.4972,
+      "log_good": 5.3279
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 389.0,
+      "good": 297.0,
+      "ratio": 0.7635,
+      "suggested_scalar": -0.2456,
+      "log_bad": 5.9636,
+      "log_good": 5.6937
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0274,
+      "good": 0.0205,
+      "ratio": 0.7482,
+      "suggested_scalar": -0.2641,
+      "log_bad": -3.5972,
+      "log_good": -3.8873
+    },
+    "heaps.mean_k": {
+      "bad": 2.6246,
+      "good": 2.6771,
+      "ratio": 1.02,
+      "suggested_scalar": 0.018,
+      "log_bad": 0.9649,
+      "log_good": 0.9847
+    },
+    "halstead.mean_effort": {
+      "bad": 116889.4619,
+      "good": 69097.1981,
+      "ratio": 0.5911,
+      "suggested_scalar": -0.4785,
+      "log_bad": 11.669,
+      "log_good": 11.1433
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8822,
+      "good": 0.881,
+      "ratio": 0.9986,
+      "suggested_scalar": -0.0012,
+      "log_bad": -0.1253,
+      "log_good": -0.1267
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 106.0,
+      "good": 76.0,
+      "ratio": 0.717,
+      "suggested_scalar": -0.3028,
+      "log_bad": 4.6634,
+      "log_good": 4.3307
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 239.0,
+      "good": 205.0,
+      "ratio": 0.8577,
+      "suggested_scalar": -0.1397,
+      "log_bad": 5.4765,
+      "log_good": 5.323
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.439,
+      "good": 0.4892,
+      "ratio": 1.1144,
+      "suggested_scalar": 0.0986,
+      "log_bad": -0.8233,
+      "log_good": -0.715
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.7756,
+      "good": 6.9712,
+      "ratio": 1.0289,
+      "suggested_scalar": 0.0259,
+      "log_bad": 1.9133,
+      "log_good": 1.9418
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1702,
+      "good": 0.1842,
+      "ratio": 1.0823,
+      "suggested_scalar": 0.072,
+      "log_bad": -1.7708,
+      "log_good": -1.6917
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.2785,
+      "good": 2.9746,
+      "ratio": 0.9073,
+      "suggested_scalar": -0.0885,
+      "log_bad": 1.1874,
+      "log_good": 1.0901
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 510.0,
+      "good": 390.0,
+      "ratio": 0.7647,
+      "suggested_scalar": -0.2442,
+      "log_bad": 6.2344,
+      "log_good": 5.9661
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 11.0,
+      "good": 9.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.1827,
+      "log_bad": 2.3979,
+      "log_good": 2.1972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 35.0,
+      "good": 30.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.1403,
+      "log_bad": 3.5553,
+      "log_good": 3.4012
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6493.859,
+      "good": 3838.7332,
+      "ratio": 0.5911,
+      "suggested_scalar": -0.4785,
+      "log_bad": 8.7786,
+      "log_good": 8.2529
+    },
+    "readability.mean_total_lines": {
+      "bad": 69.0,
+      "good": 62.0,
+      "ratio": 0.8986,
+      "suggested_scalar": -0.0974,
+      "log_bad": 4.2341,
+      "log_good": 4.1271
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 3231.6857,
+      "good": 2352.772,
+      "ratio": 0.728,
+      "suggested_scalar": -0.2889,
+      "log_bad": 8.0808,
+      "log_good": 7.7633
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1004.0,
+      "good": 782.0,
+      "ratio": 0.7789,
+      "suggested_scalar": -0.2275,
+      "log_bad": 6.9117,
+      "log_good": 6.6619
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 27.5652,
+      "good": 28.5161,
+      "ratio": 1.0345,
+      "suggested_scalar": 0.0309,
+      "log_bad": 3.3166,
+      "log_good": 3.3505
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1581,
+      "good": 1.1695,
+      "ratio": 1.0098,
+      "suggested_scalar": 0.0089,
+      "log_bad": 0.1468,
+      "log_good": 0.1566
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 21.0,
+      "good": 22.0,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.0423,
+      "log_bad": 3.0445,
+      "log_good": 3.091
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 9.0,
+      "good": 1.0,
+      "ratio": 0.1111,
+      "suggested_scalar": -2.0,
+      "log_bad": 2.1972,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9252,
+      "good": 0.9153,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.0098,
+      "log_bad": -0.0777,
+      "log_good": -0.0885
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9809,
+      "good": 0.9875,
+      "ratio": 1.0067,
+      "suggested_scalar": 0.0061,
+      "log_bad": -0.0193,
+      "log_good": -0.0126
+    },
+    "halstead.mean_length": {
+      "bad": 452.0,
+      "good": 349.0,
+      "ratio": 0.7721,
+      "suggested_scalar": -0.2354,
+      "log_bad": 6.1137,
+      "log_good": 5.8551
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 29.6667,
+      "good": 23.6667,
+      "ratio": 0.7978,
+      "suggested_scalar": -0.2057,
+      "log_bad": 3.39,
+      "log_good": 3.1641
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.1799,
+      "good": 6.8329,
+      "ratio": 0.9517,
+      "suggested_scalar": -0.0451,
+      "log_bad": 1.9713,
+      "log_good": 1.9217
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0968,
+      "good": 0.1117,
+      "ratio": 1.1539,
+      "suggested_scalar": 0.1303,
+      "log_bad": -2.3351,
+      "log_good": -2.1919
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 36.1698,
+      "good": 29.3684,
+      "ratio": 0.812,
+      "suggested_scalar": -0.1896,
+      "log_bad": 3.5882,
+      "log_good": 3.3799
+    },
+    "branching.mean_branch_count": {
+      "bad": 12.0,
+      "good": 7.0,
+      "ratio": 0.5833,
+      "suggested_scalar": -0.4906,
+      "log_bad": 2.4849,
+      "log_good": 1.9459
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 90.0,
+      "good": 68.0,
+      "ratio": 0.7556,
+      "suggested_scalar": -0.2551,
+      "log_bad": 4.4998,
+      "log_good": 4.2195
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8123,
+      "good": 0.8249,
+      "ratio": 1.0155,
+      "suggested_scalar": 0.014,
+      "log_bad": -0.2079,
+      "log_good": -0.1925
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 78.0,
+      "good": 62.0,
+      "ratio": 0.7949,
+      "suggested_scalar": -0.209,
+      "log_bad": 4.3567,
+      "log_good": 4.1271
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "consistency.consistent_function_style": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 31.0,
+      "good": 36.0,
+      "ratio": 1.1613,
+      "suggested_scalar": 0.0594,
+      "log_bad": 3.434,
+      "log_good": 3.5835
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0292,
+      "good": 0.0293,
+      "ratio": 1.0034,
+      "suggested_scalar": 0.0014,
+      "log_bad": -3.5336,
+      "log_good": -3.5302
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1333,
+      "good": 1.1053,
+      "ratio": 0.9753,
+      "suggested_scalar": -0.0099,
+      "log_bad": 0.1251,
+      "log_good": 0.1001
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8627,
+      "good": 0.7722,
+      "ratio": 0.8951,
+      "suggested_scalar": -0.044,
+      "log_bad": -0.1477,
+      "log_good": -0.2585
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0292,
+      "good": 0.0293,
+      "ratio": 1.0034,
+      "suggested_scalar": 0.0014,
+      "log_bad": -3.5336,
+      "log_good": -3.5302
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8349,
+      "good": 4.7483,
+      "ratio": 0.9821,
+      "suggested_scalar": -0.0072,
+      "log_bad": 1.5759,
+      "log_good": 1.5578
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 129.0,
+      "good": 132.0,
+      "ratio": 1.0233,
+      "suggested_scalar": 0.0091,
+      "log_bad": 4.8598,
+      "log_good": 4.8828
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5449,
+      "good": 0.5401,
+      "ratio": 0.9912,
+      "suggested_scalar": -0.0035,
+      "log_bad": -0.6072,
+      "log_good": -0.616
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6216,
+      "good": 0.6253,
+      "ratio": 1.006,
+      "suggested_scalar": 0.0024,
+      "log_bad": -0.4755,
+      "log_good": -0.4695
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.4902,
+      "good": 3.3165,
+      "ratio": 0.9502,
+      "suggested_scalar": -0.0203,
+      "log_bad": 1.25,
+      "log_good": 1.1989
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 617.0,
+      "good": 615.0,
+      "ratio": 0.9968,
+      "suggested_scalar": -0.0013,
+      "log_bad": 6.4249,
+      "log_good": 6.4216
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.161,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0459,
+      "good": 1.0317,
+      "ratio": 0.9864,
+      "suggested_scalar": -0.0054,
+      "log_bad": 0.0449,
+      "log_good": 0.0312
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 176.0,
+      "good": 182.0,
+      "ratio": 1.0341,
+      "suggested_scalar": 0.0133,
+      "log_bad": 5.1705,
+      "log_good": 5.204
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 96.217,
+      "good": 99.8402,
+      "ratio": 1.0377,
+      "suggested_scalar": 0.0147,
+      "log_bad": 4.5666,
+      "log_good": 4.6036
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5633,
+      "good": 0.5505,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.0091,
+      "log_bad": -0.5739,
+      "log_good": -0.5969
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.2271,
+      "good": 13.5845,
+      "ratio": 1.027,
+      "suggested_scalar": 0.0106,
+      "log_bad": 2.5823,
+      "log_good": 2.6089
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2050.0,
+      "good": 2218.0,
+      "ratio": 1.082,
+      "suggested_scalar": 0.0313,
+      "log_bad": 7.6256,
+      "log_good": 7.7044
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1176,
+      "good": 0.0506,
+      "ratio": 0.4303,
+      "suggested_scalar": -0.3349,
+      "log_bad": -2.1405,
+      "log_good": -2.9838
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8235,
+      "good": 0.7342,
+      "ratio": 0.8916,
+      "suggested_scalar": -0.0456,
+      "log_bad": -0.1942,
+      "log_good": -0.309
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 12.098,
+      "good": 7.7848,
+      "ratio": 0.6435,
+      "suggested_scalar": -0.1751,
+      "log_bad": 2.493,
+      "log_good": 2.0522
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2753,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.5832,
+      "good": 2.3176,
+      "ratio": 0.6468,
+      "suggested_scalar": -0.173,
+      "log_bad": 1.2763,
+      "log_good": 0.8405
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 152.0,
+      "good": 161.0,
+      "ratio": 1.0592,
+      "suggested_scalar": 0.0228,
+      "log_bad": 5.0239,
+      "log_good": 5.0814
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9493,
+      "good": 0.9524,
+      "ratio": 1.0033,
+      "suggested_scalar": 0.0013,
+      "log_bad": -0.052,
+      "log_good": -0.0488
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 33.0,
+      "good": 32.0,
+      "ratio": 0.9697,
+      "suggested_scalar": -0.0122,
+      "log_bad": 3.4965,
+      "log_good": 3.4657
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.581,
+      "good": 0.6091,
+      "ratio": 1.0484,
+      "suggested_scalar": 0.0188,
+      "log_bad": -0.543,
+      "log_good": -0.4958
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3106,
+      "good": 0.31,
+      "ratio": 0.9981,
+      "suggested_scalar": -0.0008,
+      "log_bad": -1.1692,
+      "log_good": -1.1712
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3865,
+      "good": 2.5582,
+      "ratio": 1.0719,
+      "suggested_scalar": 0.0276,
+      "log_bad": 0.8698,
+      "log_good": 0.9393
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 615.0,
+      "good": 613.0,
+      "ratio": 0.9967,
+      "suggested_scalar": -0.0013,
+      "log_bad": 6.4216,
+      "log_good": 6.4184
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 9.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.0797,
+      "log_bad": 2.3979,
+      "log_good": 2.1972
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.034,
+      "good": 0.0244,
+      "ratio": 0.7176,
+      "suggested_scalar": -0.1318,
+      "log_bad": -3.3814,
+      "log_good": -3.7132
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0661,
+      "good": 6.0661,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8027,
+      "log_good": 1.8027
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 22.0,
+      "good": 20.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0379,
+      "log_bad": 3.091,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6311,
+      "good": 0.5478,
+      "ratio": 0.868,
+      "suggested_scalar": -0.0562,
+      "log_bad": -0.4603,
+      "log_good": -0.6018
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7872,
+      "good": 5.8718,
+      "ratio": 1.0146,
+      "suggested_scalar": 0.0058,
+      "log_bad": 1.7556,
+      "log_good": 1.7702
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.797,
+      "good": 0.7828,
+      "ratio": 0.9822,
+      "suggested_scalar": -0.0071,
+      "log_bad": -0.2269,
+      "log_good": -0.2449
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2273,
+      "good": 0.1771,
+      "ratio": 0.7791,
+      "suggested_scalar": -0.0991,
+      "log_bad": -1.4815,
+      "log_good": -1.731
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6369,
+      "good": 3.6857,
+      "ratio": 1.0134,
+      "suggested_scalar": 0.0053,
+      "log_bad": 1.2911,
+      "log_good": 1.3045
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 493.0,
+      "good": 491.0,
+      "ratio": 0.9959,
+      "suggested_scalar": -0.0016,
+      "log_bad": 6.2005,
+      "log_good": 6.1964
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 28.0,
+      "good": 23.0,
+      "ratio": 0.8214,
+      "suggested_scalar": -0.0781,
+      "log_bad": 3.3322,
+      "log_good": 3.1355
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.1592,
+      "good": 1.2116,
+      "ratio": 1.0452,
+      "suggested_scalar": 0.0176,
+      "log_bad": 0.1477,
+      "log_good": 0.1919
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 140.0,
+      "good": 141.0,
+      "ratio": 1.0071,
+      "suggested_scalar": 0.0028,
+      "log_bad": 4.9416,
+      "log_good": 4.9488
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1098.0,
+      "good": 1147.0,
+      "ratio": 1.0446,
+      "suggested_scalar": 0.0173,
+      "log_bad": 7.0012,
+      "log_good": 7.0449
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 151.0,
+      "good": 170.0,
+      "ratio": 1.1258,
+      "suggested_scalar": 0.0471,
+      "log_bad": 5.0173,
+      "log_good": 5.1358
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0065,
+      "good": 1.0,
+      "ratio": 153.8462,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.036,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2723,
+      "good": 0.2634,
+      "ratio": 0.9673,
+      "suggested_scalar": -0.0132,
+      "log_bad": -1.3009,
+      "log_good": -1.3341
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 97.0,
+      "good": 96.0,
+      "ratio": 0.9897,
+      "suggested_scalar": -0.0041,
+      "log_bad": 4.5747,
+      "log_good": 4.5643
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 15.0,
+      "good": 19.0,
+      "ratio": 1.2667,
+      "suggested_scalar": 0.0939,
+      "log_bad": 2.7081,
+      "log_good": 2.9444
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 140.0,
+      "good": 141.0,
+      "ratio": 1.0071,
+      "suggested_scalar": 0.0028,
+      "log_bad": 4.9416,
+      "log_good": 4.9488
+    },
+    "brevity.mean_sample_size": {
+      "bad": 140.0,
+      "good": 141.0,
+      "ratio": 1.0071,
+      "suggested_scalar": 0.0028,
+      "log_bad": 4.9416,
+      "log_good": 4.9488
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 617.0,
+      "good": 615.0,
+      "ratio": 0.9968,
+      "suggested_scalar": -0.0013,
+      "log_bad": 6.4249,
+      "log_good": 6.4216
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 356.0,
+      "good": 342.0,
+      "ratio": 0.9607,
+      "suggested_scalar": -0.0159,
+      "log_bad": 5.8749,
+      "log_good": 5.8348
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 366.0,
+      "good": 372.0,
+      "ratio": 1.0164,
+      "suggested_scalar": 0.0065,
+      "log_bad": 5.9026,
+      "log_good": 5.9189
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0211,
+      "good": 0.0211,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.8585,
+      "log_good": -3.8585
+    },
+    "heaps.mean_k": {
+      "bad": 2.5169,
+      "good": 2.5162,
+      "ratio": 0.9997,
+      "suggested_scalar": -0.0001,
+      "log_bad": 0.923,
+      "log_good": 0.9227
+    },
+    "halstead.mean_effort": {
+      "bad": 90253.7757,
+      "good": 98869.4803,
+      "ratio": 1.0955,
+      "suggested_scalar": 0.0362,
+      "log_bad": 11.4104,
+      "log_good": 11.5016
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8118,
+      "good": 0.8224,
+      "ratio": 1.0131,
+      "suggested_scalar": 0.0052,
+      "log_bad": -0.2085,
+      "log_good": -0.1955
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 96.0,
+      "good": 100.0,
+      "ratio": 1.0417,
+      "suggested_scalar": 0.0162,
+      "log_bad": 4.5643,
+      "log_good": 4.6052
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 345.0,
+      "good": 346.0,
+      "ratio": 1.0029,
+      "suggested_scalar": 0.0011,
+      "log_bad": 5.8435,
+      "log_good": 5.8464
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5284,
+      "good": 0.5165,
+      "ratio": 0.9775,
+      "suggested_scalar": -0.009,
+      "log_bad": -0.6379,
+      "log_good": -0.6607
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.2386,
+      "good": 6.3022,
+      "ratio": 1.0102,
+      "suggested_scalar": 0.004,
+      "log_bad": 1.8308,
+      "log_good": 1.8409
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2273,
+      "good": 0.1771,
+      "ratio": 0.7791,
+      "suggested_scalar": -0.0991,
+      "log_bad": -1.4815,
+      "log_good": -1.731
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.0358,
+      "good": 4.2295,
+      "ratio": 0.7007,
+      "suggested_scalar": -0.1412,
+      "log_bad": 1.7977,
+      "log_good": 1.4421
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 616.0,
+      "good": 614.0,
+      "ratio": 0.9968,
+      "suggested_scalar": -0.0013,
+      "log_bad": 6.4232,
+      "log_good": 6.42
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 69.0,
+      "good": 68.0,
+      "ratio": 0.9855,
+      "suggested_scalar": -0.0058,
+      "log_bad": 4.2341,
+      "log_good": 4.2195
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5014.0986,
+      "good": 5492.7489,
+      "ratio": 1.0955,
+      "suggested_scalar": 0.0362,
+      "log_bad": 8.52,
+      "log_good": 8.6112
+    },
+    "readability.mean_total_lines": {
+      "bad": 51.0,
+      "good": 79.0,
+      "ratio": 1.549,
+      "suggested_scalar": 0.1738,
+      "log_bad": 3.9318,
+      "log_good": 4.3694
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 6.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1143,
+      "log_bad": 2.0794,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 3477.5687,
+      "good": 3634.9074,
+      "ratio": 1.0452,
+      "suggested_scalar": 0.0176,
+      "log_bad": 8.1541,
+      "log_good": 8.1983
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 859.0,
+      "good": 867.0,
+      "ratio": 1.0093,
+      "suggested_scalar": 0.0037,
+      "log_bad": 6.7558,
+      "log_good": 6.765
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 38.902,
+      "good": 26.8608,
+      "ratio": 0.6905,
+      "suggested_scalar": -0.1471,
+      "log_bad": 3.661,
+      "log_good": 3.2907
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1624,
+      "good": 1.1713,
+      "ratio": 1.0077,
+      "suggested_scalar": 0.003,
+      "log_bad": 0.1505,
+      "log_good": 0.1581
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.161,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 40.0,
+      "good": 38.0,
+      "ratio": 0.95,
+      "suggested_scalar": -0.0204,
+      "log_bad": 3.6889,
+      "log_good": 3.6376
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.86,
+      "good": 0.8615,
+      "ratio": 1.0017,
+      "suggested_scalar": 0.0007,
+      "log_bad": -0.1508,
+      "log_good": -0.1491
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9918,
+      "good": 0.9933,
+      "ratio": 1.0015,
+      "suggested_scalar": 0.0006,
+      "log_bad": -0.0082,
+      "log_good": -0.0067
+    },
+    "halstead.mean_length": {
+      "bad": 496.0,
+      "good": 516.0,
+      "ratio": 1.0403,
+      "suggested_scalar": 0.0157,
+      "log_bad": 6.2066,
+      "log_good": 6.2461
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.2,
+      "good": 4.8947,
+      "ratio": 1.1654,
+      "suggested_scalar": 0.0608,
+      "log_bad": 1.4351,
+      "log_good": 1.5882
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.1293,
+      "good": 7.1396,
+      "ratio": 1.0014,
+      "suggested_scalar": 0.0006,
+      "log_bad": 1.9642,
+      "log_good": 1.9657
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1737,
+      "good": 0.1542,
+      "ratio": 0.8877,
+      "suggested_scalar": -0.0473,
+      "log_bad": -1.7504,
+      "log_good": -1.8695
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.9531,
+      "good": 27.2,
+      "ratio": 1.048,
+      "suggested_scalar": 0.0186,
+      "log_bad": 3.2563,
+      "log_good": 3.3032
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 4.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.161,
+      "log_bad": 1.7918,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 93.0,
+      "good": 94.0,
+      "ratio": 1.0108,
+      "suggested_scalar": 0.0042,
+      "log_bad": 4.5326,
+      "log_good": 4.5433
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.735,
+      "good": 0.7419,
+      "ratio": 1.0094,
+      "suggested_scalar": 0.0037,
+      "log_bad": -0.3079,
+      "log_good": -0.2985
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 51.0,
+      "good": 79.0,
+      "ratio": 1.549,
+      "suggested_scalar": 0.1738,
+      "log_bad": 3.9318,
+      "log_good": 4.3694
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_raw_sql_string_concatenation": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_using_namespace_directives": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.013,
+      "good": 0.0072,
+      "ratio": 0.5538,
+      "suggested_scalar": -0.5653,
+      "log_bad": -4.3428,
+      "log_good": -4.9337
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8387,
+      "good": 0.8305,
+      "ratio": 0.9902,
+      "suggested_scalar": -0.0094,
+      "log_bad": -0.1759,
+      "log_good": -0.1857
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.013,
+      "good": 0.0072,
+      "ratio": 0.5538,
+      "suggested_scalar": -0.5653,
+      "log_bad": -4.3428,
+      "log_good": -4.9337
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5351,
+      "good": 4.5335,
+      "ratio": 0.9996,
+      "suggested_scalar": -0.0003,
+      "log_bad": 1.5118,
+      "log_good": 1.5115
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 110.0,
+      "good": 86.0,
+      "ratio": 0.7818,
+      "suggested_scalar": -0.2355,
+      "log_bad": 4.7005,
+      "log_good": 4.4543
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3486,
+      "good": 0.2813,
+      "ratio": 0.8069,
+      "suggested_scalar": -0.2052,
+      "log_bad": -1.0538,
+      "log_good": -1.2683
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 23.0,
+      "good": 22.0,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.0425,
+      "log_bad": 3.1355,
+      "log_good": 3.091
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6194,
+      "good": 0.5767,
+      "ratio": 0.9311,
+      "suggested_scalar": -0.0683,
+      "log_bad": -0.479,
+      "log_good": -0.5504
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.2581,
+      "good": 6.4746,
+      "ratio": 1.0346,
+      "suggested_scalar": 0.0325,
+      "log_bad": 1.8339,
+      "log_good": 1.8679
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 537.0,
+      "good": 552.0,
+      "ratio": 1.0279,
+      "suggested_scalar": 0.0264,
+      "log_bad": 6.286,
+      "log_good": 6.3135
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0013,
+      "good": 0.0014,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0709,
+      "log_bad": -6.6454,
+      "log_good": -6.5713
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1129,
+      "good": 0.0847,
+      "ratio": 0.7502,
+      "suggested_scalar": -0.2749,
+      "log_bad": -2.1813,
+      "log_good": -2.4686
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0344,
+      "good": 1.1214,
+      "ratio": 1.0841,
+      "suggested_scalar": 0.0773,
+      "log_bad": 0.0338,
+      "log_good": 0.1146
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 186.0,
+      "good": 183.0,
+      "ratio": 0.9839,
+      "suggested_scalar": -0.0156,
+      "log_bad": 5.2257,
+      "log_good": 5.2095
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.3775,
+      "good": 103.5199,
+      "ratio": 0.9918,
+      "suggested_scalar": -0.0079,
+      "log_bad": 4.648,
+      "log_good": 4.6398
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6287,
+      "good": 0.7078,
+      "ratio": 1.1258,
+      "suggested_scalar": 0.1134,
+      "log_bad": -0.4641,
+      "log_good": -0.3456
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.5399,
+      "good": 8.1989,
+      "ratio": 0.9601,
+      "suggested_scalar": -0.039,
+      "log_bad": 2.1447,
+      "log_good": 2.104
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2288.0,
+      "good": 2144.0,
+      "ratio": 0.9371,
+      "suggested_scalar": -0.0622,
+      "log_bad": 7.7354,
+      "log_good": 7.6704
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2419,
+      "good": 0.2203,
+      "ratio": 0.9107,
+      "suggested_scalar": -0.0895,
+      "log_bad": -1.4192,
+      "log_good": -1.5128
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8387,
+      "good": 0.8305,
+      "ratio": 0.9902,
+      "suggested_scalar": -0.0094,
+      "log_bad": -0.1759,
+      "log_good": -0.1857
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.2586,
+      "good": 10.0364,
+      "ratio": 1.084,
+      "suggested_scalar": 0.0772,
+      "log_bad": 2.2256,
+      "log_good": 2.3062
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 34.0,
+      "good": 34.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5264,
+      "log_good": 3.5264
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 20.8366,
+      "good": 25.9104,
+      "ratio": 1.2435,
+      "suggested_scalar": 0.2085,
+      "log_bad": 3.0367,
+      "log_good": 3.2546
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 133.0,
+      "good": 130.0,
+      "ratio": 0.9774,
+      "suggested_scalar": -0.0218,
+      "log_bad": 4.8903,
+      "log_good": 4.8675
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9214,
+      "good": 0.921,
+      "ratio": 0.9996,
+      "suggested_scalar": -0.0004,
+      "log_bad": -0.0819,
+      "log_good": -0.0823
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 38.0,
+      "good": 34.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.1064,
+      "log_bad": 3.6376,
+      "log_good": 3.5264
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6346,
+      "good": 0.6632,
+      "ratio": 1.0451,
+      "suggested_scalar": 0.0422,
+      "log_bad": -0.4548,
+      "log_good": -0.4107
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4056,
+      "good": 0.5036,
+      "ratio": 1.2416,
+      "suggested_scalar": 0.207,
+      "log_bad": -0.9024,
+      "log_good": -0.686
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7368,
+      "good": 2.9695,
+      "ratio": 1.085,
+      "suggested_scalar": 0.0781,
+      "log_bad": 1.0068,
+      "log_good": 1.0884
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 535.0,
+      "good": 550.0,
+      "ratio": 1.028,
+      "suggested_scalar": 0.0265,
+      "log_bad": 6.2823,
+      "log_good": 6.3099
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0056,
+      "good": 0.0453,
+      "ratio": 8.0893,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.185,
+      "log_good": -3.0944
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.858,
+      "ratio": 0.9917,
+      "suggested_scalar": -0.008,
+      "log_bad": 1.7761,
+      "log_good": 1.7678
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2223,
+      "good": 1.2343,
+      "ratio": 1.0098,
+      "suggested_scalar": 0.0093,
+      "log_bad": 0.2007,
+      "log_good": 0.2105
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8968,
+      "good": 5.5468,
+      "ratio": 0.9406,
+      "suggested_scalar": -0.0585,
+      "log_bad": 1.7744,
+      "log_good": 1.7132
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7678,
+      "good": 0.7739,
+      "ratio": 1.0079,
+      "suggested_scalar": 0.0076,
+      "log_bad": -0.2642,
+      "log_good": -0.2563
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1733,
+      "good": 0.1806,
+      "ratio": 1.0421,
+      "suggested_scalar": 0.0395,
+      "log_bad": -1.7527,
+      "log_good": -1.7115
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.9223,
+      "good": 2.8634,
+      "ratio": 0.9798,
+      "suggested_scalar": -0.0195,
+      "log_bad": 1.0724,
+      "log_good": 1.052
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 407.0,
+      "good": 371.0,
+      "ratio": 0.9115,
+      "suggested_scalar": -0.0886,
+      "log_bad": 6.0088,
+      "log_good": 5.9162
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.146,
+      "good": 1.1289,
+      "ratio": 0.9851,
+      "suggested_scalar": -0.0144,
+      "log_bad": 0.1363,
+      "log_good": 0.1212
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 109.0,
+      "good": 90.0,
+      "ratio": 0.8257,
+      "suggested_scalar": -0.1832,
+      "log_bad": 4.6913,
+      "log_good": 4.4998
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 965.0,
+      "good": 883.0,
+      "ratio": 0.915,
+      "suggested_scalar": -0.085,
+      "log_bad": 6.8721,
+      "log_good": 6.7833
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 219.0,
+      "good": 215.0,
+      "ratio": 0.9817,
+      "suggested_scalar": -0.0176,
+      "log_bad": 5.3891,
+      "log_good": 5.3706
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2384,
+      "good": 0.2609,
+      "ratio": 1.0944,
+      "suggested_scalar": 0.0863,
+      "log_bad": -1.4338,
+      "log_good": -1.3436
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 111.0,
+      "good": 112.0,
+      "ratio": 1.009,
+      "suggested_scalar": 0.0086,
+      "log_bad": 4.7095,
+      "log_good": 4.7185
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 109.0,
+      "good": 90.0,
+      "ratio": 0.8257,
+      "suggested_scalar": -0.1832,
+      "log_bad": 4.6913,
+      "log_good": 4.4998
+    },
+    "brevity.mean_sample_size": {
+      "bad": 109.0,
+      "good": 90.0,
+      "ratio": 0.8257,
+      "suggested_scalar": -0.1832,
+      "log_bad": 4.6913,
+      "log_good": 4.4998
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 537.0,
+      "good": 552.0,
+      "ratio": 1.0279,
+      "suggested_scalar": 0.0264,
+      "log_bad": 6.286,
+      "log_good": 6.3135
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 274.0,
+      "good": 301.0,
+      "ratio": 1.0985,
+      "suggested_scalar": 0.0899,
+      "log_bad": 5.6131,
+      "log_good": 5.7071
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 310.0,
+      "good": 273.0,
+      "ratio": 0.8806,
+      "suggested_scalar": -0.1216,
+      "log_bad": 5.7366,
+      "log_good": 5.6095
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.3749,
+      "good": 2.5039,
+      "ratio": 1.0543,
+      "suggested_scalar": 0.0506,
+      "log_bad": 0.865,
+      "log_good": 0.9178
+    },
+    "halstead.mean_effort": {
+      "bad": 198696.3826,
+      "good": 238041.8226,
+      "ratio": 1.198,
+      "suggested_scalar": 0.1728,
+      "log_bad": 12.1995,
+      "log_good": 12.3802
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8713,
+      "good": 0.8544,
+      "ratio": 0.9806,
+      "suggested_scalar": -0.0187,
+      "log_bad": -0.1378,
+      "log_good": -0.1574
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 72.0,
+      "good": 52.0,
+      "ratio": 0.7222,
+      "suggested_scalar": -0.3113,
+      "log_bad": 4.2767,
+      "log_good": 3.9512
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 288.0,
+      "good": 312.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.0766,
+      "log_bad": 5.663,
+      "log_good": 5.743
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3118,
+      "good": 0.235,
+      "ratio": 0.7537,
+      "suggested_scalar": -0.2705,
+      "log_bad": -1.1654,
+      "log_good": -1.4482
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.1882,
+      "good": 4.8251,
+      "ratio": 0.93,
+      "suggested_scalar": -0.0694,
+      "log_bad": 1.6464,
+      "log_good": 1.5738
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1733,
+      "good": 0.1806,
+      "ratio": 1.0421,
+      "suggested_scalar": 0.0395,
+      "log_bad": -1.7527,
+      "log_good": -1.7115
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.8573,
+      "good": 4.1758,
+      "ratio": 1.0826,
+      "suggested_scalar": 0.0759,
+      "log_bad": 1.35,
+      "log_good": 1.4293
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 536.0,
+      "good": 551.0,
+      "ratio": 1.028,
+      "suggested_scalar": 0.0264,
+      "log_bad": 6.2841,
+      "log_good": 6.3117
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 89.0,
+      "good": 98.0,
+      "ratio": 1.1011,
+      "suggested_scalar": 0.0922,
+      "log_bad": 4.4886,
+      "log_good": 4.585
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 11038.6879,
+      "good": 13224.5457,
+      "ratio": 1.198,
+      "suggested_scalar": 0.1728,
+      "log_bad": 9.3092,
+      "log_good": 9.4898
+    },
+    "readability.mean_total_lines": {
+      "bad": 58.0,
+      "good": 55.0,
+      "ratio": 0.9483,
+      "suggested_scalar": -0.0508,
+      "log_bad": 4.0604,
+      "log_good": 4.0073
+    },
+    "indentation.mean_max_depth": {
+      "bad": 20.0,
+      "good": 23.0,
+      "ratio": 1.15,
+      "suggested_scalar": 0.1337,
+      "log_bad": 2.9957,
+      "log_good": 3.1355
+    },
+    "halstead.mean_volume": {
+      "bad": 3438.1494,
+      "good": 3386.6415,
+      "ratio": 0.985,
+      "suggested_scalar": -0.0144,
+      "log_bad": 8.1427,
+      "log_good": 8.1276
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 836.0,
+      "good": 722.0,
+      "ratio": 0.8636,
+      "suggested_scalar": -0.1403,
+      "log_bad": 6.7286,
+      "log_good": 6.582
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 36.8276,
+      "good": 36.3091,
+      "ratio": 0.9859,
+      "suggested_scalar": -0.0136,
+      "log_bad": 3.6062,
+      "log_good": 3.5921
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1,
+      "good": 1.1008,
+      "ratio": 1.0007,
+      "suggested_scalar": 0.0007,
+      "log_bad": 0.0953,
+      "log_good": 0.096
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.3219,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7813,
+      "good": 0.7358,
+      "ratio": 0.9418,
+      "suggested_scalar": -0.0574,
+      "log_bad": -0.2468,
+      "log_good": -0.3068
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9204,
+      "good": 0.9287,
+      "ratio": 1.009,
+      "suggested_scalar": 0.0086,
+      "log_bad": -0.0829,
+      "log_good": -0.074
+    },
+    "halstead.mean_length": {
+      "bad": 507.0,
+      "good": 527.0,
+      "ratio": 1.0394,
+      "suggested_scalar": 0.037,
+      "log_bad": 6.2285,
+      "log_good": 6.2672
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7682,
+      "good": 6.4919,
+      "ratio": 0.9592,
+      "suggested_scalar": -0.0399,
+      "log_bad": 1.9122,
+      "log_good": 1.8706
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.12,
+      "good": 0.1405,
+      "ratio": 1.1708,
+      "suggested_scalar": 0.1509,
+      "log_bad": -2.1203,
+      "log_good": -1.9625
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 57.7917,
+      "good": 70.2885,
+      "ratio": 1.2162,
+      "suggested_scalar": 0.1873,
+      "log_bad": 4.0568,
+      "log_good": 4.2526
+    },
+    "branching.mean_branch_count": {
+      "bad": 15.0,
+      "good": 13.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.1369,
+      "log_bad": 2.7081,
+      "log_good": 2.5649
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 58.0,
+      "good": 43.0,
+      "ratio": 0.7414,
+      "suggested_scalar": -0.2863,
+      "log_bad": 4.0604,
+      "log_good": 3.7612
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6419,
+      "good": 0.5897,
+      "ratio": 0.9187,
+      "suggested_scalar": -0.0811,
+      "log_bad": -0.4433,
+      "log_good": -0.5281
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 62.0,
+      "good": 59.0,
+      "ratio": 0.9516,
+      "suggested_scalar": -0.0474,
+      "log_bad": 4.1271,
+      "log_good": 4.0775
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.uses_data_class_over_pair_triple": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 21.0,
+      "good": 22.0,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.0847,
+      "log_bad": 3.0445,
+      "log_good": 3.091
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 2.0,
+      "good": 6.0,
+      "ratio": 3.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.6931,
+      "log_good": 1.7918
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0072,
+      "good": 0.0078,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.1457,
+      "log_bad": -4.9337,
+      "log_good": -4.8536
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6,
+      "good": 1.5,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.1175,
+      "log_bad": 0.47,
+      "log_good": 0.4055
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8857,
+      "good": 0.9167,
+      "ratio": 1.035,
+      "suggested_scalar": 0.0626,
+      "log_bad": -0.1214,
+      "log_good": -0.087
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0072,
+      "good": 0.0078,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.1457,
+      "log_bad": -4.9337,
+      "log_good": -4.8536
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7043,
+      "good": 4.7436,
+      "ratio": 1.0084,
+      "suggested_scalar": 0.0151,
+      "log_bad": 1.5485,
+      "log_good": 1.5568
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 104.0,
+      "good": 87.0,
+      "ratio": 0.8365,
+      "suggested_scalar": -0.3249,
+      "log_bad": 4.6444,
+      "log_good": 4.4659
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5001,
+      "good": 0.4828,
+      "ratio": 0.9654,
+      "suggested_scalar": -0.0641,
+      "log_bad": -0.6929,
+      "log_good": -0.7282
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 15.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.1175,
+      "log_bad": 2.7726,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6102,
+      "good": 0.6122,
+      "ratio": 1.0033,
+      "suggested_scalar": 0.006,
+      "log_bad": -0.494,
+      "log_good": -0.4907
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.7143,
+      "good": 4.4444,
+      "ratio": 0.7778,
+      "suggested_scalar": -0.4575,
+      "log_bad": 1.743,
+      "log_good": 1.4916
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 414.0,
+      "good": 386.0,
+      "ratio": 0.9324,
+      "suggested_scalar": -0.1275,
+      "log_bad": 6.0259,
+      "log_good": 5.9558
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1429,
+      "good": 0.1111,
+      "ratio": 0.7775,
+      "suggested_scalar": -0.4582,
+      "log_bad": -1.9456,
+      "log_good": -2.1973
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0028,
+      "good": 0.0022,
+      "ratio": 0.7857,
+      "suggested_scalar": -0.439,
+      "log_bad": -5.8781,
+      "log_good": -6.1193
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.962,
+      "good": 0.9632,
+      "ratio": 1.0012,
+      "suggested_scalar": 0.0023,
+      "log_bad": -0.0387,
+      "log_good": -0.0375
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 166.0,
+      "good": 149.0,
+      "ratio": 0.8976,
+      "suggested_scalar": -0.1967,
+      "log_bad": 5.112,
+      "log_good": 5.0039
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 98.0271,
+      "good": 92.3685,
+      "ratio": 0.9423,
+      "suggested_scalar": -0.1082,
+      "log_bad": 4.5852,
+      "log_good": 4.5258
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5908,
+      "good": 0.5844,
+      "ratio": 0.9892,
+      "suggested_scalar": -0.0198,
+      "log_bad": -0.5263,
+      "log_good": -0.5372
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.8653,
+      "good": 18.7592,
+      "ratio": 1.7265,
+      "suggested_scalar": 0.9942,
+      "log_bad": 2.3856,
+      "log_good": 2.9317
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1769.0,
+      "good": 1858.0,
+      "ratio": 1.0503,
+      "suggested_scalar": 0.0894,
+      "log_bad": 7.4782,
+      "log_good": 7.5273
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1143,
+      "good": 0.0833,
+      "ratio": 0.7288,
+      "suggested_scalar": -0.576,
+      "log_bad": -2.1689,
+      "log_good": -2.4853
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8571,
+      "good": 0.8889,
+      "ratio": 1.0371,
+      "suggested_scalar": 0.0663,
+      "log_bad": -0.1542,
+      "log_good": -0.1178
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 11.8286,
+      "good": 10.7222,
+      "ratio": 0.9065,
+      "suggested_scalar": -0.1788,
+      "log_bad": 2.4705,
+      "log_good": 2.3723
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 11.2327,
+      "good": 16.6914,
+      "ratio": 1.486,
+      "suggested_scalar": 0.721,
+      "log_bad": 2.4188,
+      "log_good": 2.8149
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 95.0,
+      "good": 70.0,
+      "ratio": 0.7368,
+      "suggested_scalar": -0.5559,
+      "log_bad": 4.5539,
+      "log_good": 4.2485
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9514,
+      "good": 0.9362,
+      "ratio": 0.984,
+      "suggested_scalar": -0.0293,
+      "log_bad": -0.0498,
+      "log_good": -0.0659
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 20.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.3319,
+      "log_bad": 3.1781,
+      "log_good": 2.9957
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6003,
+      "good": 0.6399,
+      "ratio": 1.066,
+      "suggested_scalar": 0.1163,
+      "log_bad": -0.5103,
+      "log_good": -0.4464
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4005,
+      "good": 0.3672,
+      "ratio": 0.9169,
+      "suggested_scalar": -0.158,
+      "log_bad": -0.915,
+      "log_good": -1.0018
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5021,
+      "good": 2.7773,
+      "ratio": 1.11,
+      "suggested_scalar": 0.19,
+      "log_bad": 0.9171,
+      "log_good": 1.0215
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 412.0,
+      "good": 384.0,
+      "ratio": 0.932,
+      "suggested_scalar": -0.1281,
+      "log_bad": 6.021,
+      "log_good": 5.9506
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0242,
+      "good": 0.044,
+      "ratio": 1.8182,
+      "suggested_scalar": 1.0883,
+      "log_bad": -3.7214,
+      "log_good": -3.1236
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 5.858,
+      "ratio": 0.9877,
+      "suggested_scalar": -0.0225,
+      "log_bad": 1.7801,
+      "log_good": 1.7678
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 50.0,
+      "good": 57.0,
+      "ratio": 1.14,
+      "suggested_scalar": 0.2385,
+      "log_bad": 3.912,
+      "log_good": 4.0431
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3596,
+      "good": 1.4498,
+      "ratio": 1.0663,
+      "suggested_scalar": 0.1169,
+      "log_bad": 0.3072,
+      "log_good": 0.3714
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.881,
+      "good": 5.7694,
+      "ratio": 0.981,
+      "suggested_scalar": -0.0349,
+      "log_bad": 1.7717,
+      "log_good": 1.7526
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7932,
+      "good": 0.8098,
+      "ratio": 1.0209,
+      "suggested_scalar": 0.0377,
+      "log_bad": -0.2317,
+      "log_good": -0.211
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1463,
+      "good": 0.2174,
+      "ratio": 1.486,
+      "suggested_scalar": 0.7211,
+      "log_bad": -1.9221,
+      "log_good": -1.526
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.2963,
+      "good": 4.3312,
+      "ratio": 1.314,
+      "suggested_scalar": 0.4971,
+      "log_bad": 1.1928,
+      "log_good": 1.4658
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 316.0,
+      "good": 296.0,
+      "ratio": 0.9367,
+      "suggested_scalar": -0.119,
+      "log_bad": 5.7557,
+      "log_good": 5.6904
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 8.0,
+      "good": 5.0,
+      "ratio": 0.625,
+      "suggested_scalar": -0.8556,
+      "log_bad": 2.0794,
+      "log_good": 1.6094
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8599,
+      "good": 0.7774,
+      "ratio": 0.9041,
+      "suggested_scalar": -0.1836,
+      "log_bad": -0.1509,
+      "log_good": -0.2518
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 110.0,
+      "good": 94.0,
+      "ratio": 0.8545,
+      "suggested_scalar": -0.2862,
+      "log_bad": 4.7005,
+      "log_good": 4.5433
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 981.0,
+      "good": 1075.0,
+      "ratio": 1.0958,
+      "suggested_scalar": 0.1666,
+      "log_bad": 6.8886,
+      "log_good": 6.9801
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 171.0,
+      "good": 169.0,
+      "ratio": 0.9883,
+      "suggested_scalar": -0.0214,
+      "log_bad": 5.1417,
+      "log_good": 5.1299
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0024,
+      "good": 0.0026,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.1457,
+      "log_bad": -6.0323,
+      "log_good": -5.9522
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.285,
+      "good": 0.2927,
+      "ratio": 1.027,
+      "suggested_scalar": 0.0485,
+      "log_bad": -1.2553,
+      "log_good": -1.2286
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 81.0,
+      "good": 73.0,
+      "ratio": 0.9012,
+      "suggested_scalar": -0.1893,
+      "log_bad": 4.3944,
+      "log_good": 4.2905
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.4062,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 110.0,
+      "good": 94.0,
+      "ratio": 0.8545,
+      "suggested_scalar": -0.2862,
+      "log_bad": 4.7005,
+      "log_good": 4.5433
+    },
+    "brevity.mean_sample_size": {
+      "bad": 110.0,
+      "good": 94.0,
+      "ratio": 0.8545,
+      "suggested_scalar": -0.2862,
+      "log_bad": 4.7005,
+      "log_good": 4.5433
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 414.0,
+      "good": 386.0,
+      "ratio": 0.9324,
+      "suggested_scalar": -0.1275,
+      "log_bad": 6.0259,
+      "log_good": 5.9558
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 201.0,
+      "good": 177.0,
+      "ratio": 0.8806,
+      "suggested_scalar": -0.2315,
+      "log_bad": 5.3033,
+      "log_good": 5.1761
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 250.0,
+      "good": 233.0,
+      "ratio": 0.932,
+      "suggested_scalar": -0.1282,
+      "log_bad": 5.5215,
+      "log_good": 5.451
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0048,
+      "good": 0.0052,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.1457,
+      "log_bad": -5.3391,
+      "log_good": -5.2591
+    },
+    "heaps.mean_k": {
+      "bad": 2.8365,
+      "good": 2.3449,
+      "ratio": 0.8267,
+      "suggested_scalar": -0.3465,
+      "log_bad": 1.0426,
+      "log_good": 0.8522
+    },
+    "halstead.mean_effort": {
+      "bad": 66168.5173,
+      "good": 58830.8056,
+      "ratio": 0.8891,
+      "suggested_scalar": -0.214,
+      "log_bad": 11.1,
+      "log_good": 10.9824
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8672,
+      "good": 0.8802,
+      "ratio": 1.015,
+      "suggested_scalar": 0.0271,
+      "log_bad": -0.1425,
+      "log_good": -0.1276
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 80.0,
+      "good": 67.0,
+      "ratio": 0.8375,
+      "suggested_scalar": -0.3228,
+      "log_bad": 4.382,
+      "log_good": 4.2047
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 214.0,
+      "good": 193.0,
+      "ratio": 0.9019,
+      "suggested_scalar": -0.188,
+      "log_bad": 5.366,
+      "log_good": 5.2627
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4398,
+      "good": 0.4228,
+      "ratio": 0.9613,
+      "suggested_scalar": -0.0718,
+      "log_bad": -0.8214,
+      "log_good": -0.8609
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.9096,
+      "good": 7.2148,
+      "ratio": 1.2209,
+      "suggested_scalar": 0.3633,
+      "log_bad": 1.7766,
+      "log_good": 1.9761
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1463,
+      "good": 0.2174,
+      "ratio": 1.486,
+      "suggested_scalar": 0.7211,
+      "log_bad": -1.9221,
+      "log_good": -1.526
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.5007,
+      "good": 5.0694,
+      "ratio": 0.9216,
+      "suggested_scalar": -0.1486,
+      "log_bad": 1.7049,
+      "log_good": 1.6232
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 413.0,
+      "good": 385.0,
+      "ratio": 0.9322,
+      "suggested_scalar": -0.1278,
+      "log_bad": 6.0234,
+      "log_good": 5.9532
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 69.0,
+      "good": 53.0,
+      "ratio": 0.7681,
+      "suggested_scalar": -0.4803,
+      "log_bad": 4.2341,
+      "log_good": 3.9703
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3676.0287,
+      "good": 3268.3781,
+      "ratio": 0.8891,
+      "suggested_scalar": -0.214,
+      "log_bad": 8.2096,
+      "log_good": 8.092
+    },
+    "readability.mean_total_lines": {
+      "bad": 35.0,
+      "good": 36.0,
+      "ratio": 1.0286,
+      "suggested_scalar": 0.0513,
+      "log_bad": 3.5553,
+      "log_good": 3.5835
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2579.6693,
+      "good": 2332.3455,
+      "ratio": 0.9041,
+      "suggested_scalar": -0.1835,
+      "log_bad": 7.8554,
+      "log_good": 7.7546
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 707.0,
+      "good": 669.0,
+      "ratio": 0.9463,
+      "suggested_scalar": -0.1006,
+      "log_bad": 6.561,
+      "log_good": 6.5058
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 49.1429,
+      "good": 50.3333,
+      "ratio": 1.0242,
+      "suggested_scalar": 0.0436,
+      "log_bad": 3.8947,
+      "log_good": 3.9187
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1442,
+      "good": 1.2244,
+      "ratio": 1.0701,
+      "suggested_scalar": 0.1233,
+      "log_bad": 0.1347,
+      "log_good": 0.2025
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 30.0,
+      "good": 23.0,
+      "ratio": 0.7667,
+      "suggested_scalar": -0.4837,
+      "log_bad": 3.4012,
+      "log_good": 3.1355
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.4062,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7816,
+      "good": 0.8209,
+      "ratio": 1.0503,
+      "suggested_scalar": 0.0893,
+      "log_bad": -0.2464,
+      "log_good": -0.1974
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9796,
+      "good": 0.9796,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0206,
+      "log_good": -0.0206
+    },
+    "halstead.mean_length": {
+      "bad": 385.0,
+      "good": 362.0,
+      "ratio": 0.9403,
+      "suggested_scalar": -0.1121,
+      "log_bad": 5.9532,
+      "log_good": 5.8916
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.6,
+      "good": 6.25,
+      "ratio": 0.947,
+      "suggested_scalar": -0.0992,
+      "log_bad": 1.8871,
+      "log_good": 1.8326
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7814,
+      "good": 6.5546,
+      "ratio": 0.9666,
+      "suggested_scalar": -0.0619,
+      "log_bad": 1.9142,
+      "log_good": 1.8802
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1141,
+      "good": 0.0953,
+      "ratio": 0.8352,
+      "suggested_scalar": -0.3278,
+      "log_bad": -2.1707,
+      "log_good": -2.3507
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.65,
+      "good": 25.2239,
+      "ratio": 0.9834,
+      "suggested_scalar": -0.0305,
+      "log_bad": 3.2445,
+      "log_good": 3.2278
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.5237,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 73.0,
+      "good": 63.0,
+      "ratio": 0.863,
+      "suggested_scalar": -0.2682,
+      "log_bad": 4.2905,
+      "log_good": 4.1431
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.676,
+      "good": 0.6867,
+      "ratio": 1.0158,
+      "suggested_scalar": 0.0286,
+      "log_bad": -0.3916,
+      "log_good": -0.3759
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 35.0,
+      "good": 36.0,
+      "ratio": 1.0286,
+      "suggested_scalar": 0.0513,
+      "log_bad": 3.5553,
+      "log_good": 3.5835
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.uses_optional_for_nullable_param": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 38.0,
+      "good": 48.0,
+      "ratio": 1.2632,
+      "suggested_scalar": 0.1182,
+      "log_bad": 3.6376,
+      "log_good": 3.8712
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0415,
+      "good": 0.0426,
+      "ratio": 1.0265,
+      "suggested_scalar": 0.0132,
+      "log_bad": -3.1821,
+      "log_good": -3.1559
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.2,
+      "good": 1.2,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1823,
+      "log_good": 0.1823
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.94,
+      "good": 0.9231,
+      "ratio": 0.982,
+      "suggested_scalar": -0.0092,
+      "log_bad": -0.0619,
+      "log_good": -0.08
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0415,
+      "good": 0.0426,
+      "ratio": 1.0265,
+      "suggested_scalar": 0.0132,
+      "log_bad": -3.1821,
+      "log_good": -3.1559
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4722,
+      "good": 4.547,
+      "ratio": 1.0167,
+      "suggested_scalar": 0.0084,
+      "log_bad": 1.4979,
+      "log_good": 1.5145
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 81.0,
+      "good": 77.0,
+      "ratio": 0.9506,
+      "suggested_scalar": -0.0256,
+      "log_bad": 4.3944,
+      "log_good": 4.3438
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5243,
+      "good": 0.4977,
+      "ratio": 0.9493,
+      "suggested_scalar": -0.0263,
+      "log_bad": -0.6457,
+      "log_good": -0.6978
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 14.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0676,
+      "log_bad": 2.7726,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.667,
+      "good": 0.6321,
+      "ratio": 0.9477,
+      "suggested_scalar": -0.0272,
+      "log_bad": -0.405,
+      "log_good": -0.4587
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.36,
+      "good": 3.2308,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0198,
+      "log_bad": 1.2119,
+      "log_good": 1.1727
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 458.0,
+      "good": 469.0,
+      "ratio": 1.024,
+      "suggested_scalar": 0.012,
+      "log_bad": 6.1269,
+      "log_good": 6.1506
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 0.0192,
+      "ratio": 0.0192,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -3.9528
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0189,
+      "good": 1.0451,
+      "ratio": 1.0257,
+      "suggested_scalar": 0.0128,
+      "log_bad": 0.0187,
+      "log_good": 0.0441
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 180.0,
+      "good": 182.0,
+      "ratio": 1.0111,
+      "suggested_scalar": 0.0056,
+      "log_bad": 5.193,
+      "log_good": 5.204
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 102.4376,
+      "good": 102.6281,
+      "ratio": 1.0019,
+      "suggested_scalar": 0.0009,
+      "log_bad": 4.6293,
+      "log_good": 4.6311
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5689,
+      "good": 0.6026,
+      "ratio": 1.0592,
+      "suggested_scalar": 0.0291,
+      "log_bad": -0.5641,
+      "log_good": -0.5065
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.3855,
+      "good": 10.9481,
+      "ratio": 0.9616,
+      "suggested_scalar": -0.0198,
+      "log_bad": 2.4323,
+      "log_good": 2.3932
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2131.0,
+      "good": 2089.0,
+      "ratio": 0.9803,
+      "suggested_scalar": -0.0101,
+      "log_bad": 7.6643,
+      "log_good": 7.6444
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.38,
+      "good": 0.4231,
+      "ratio": 1.1134,
+      "suggested_scalar": 0.0544,
+      "log_bad": -0.9676,
+      "log_good": -0.8601
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.94,
+      "good": 0.9231,
+      "ratio": 0.982,
+      "suggested_scalar": -0.0092,
+      "log_bad": -0.0619,
+      "log_good": -0.08
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.16,
+      "good": 9.1961,
+      "ratio": 1.0039,
+      "suggested_scalar": 0.002,
+      "log_bad": 2.2148,
+      "log_good": 2.2188
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.3504,
+      "good": 5.5621,
+      "ratio": 1.0396,
+      "suggested_scalar": 0.0196,
+      "log_bad": 1.6772,
+      "log_good": 1.716
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 155.0,
+      "good": 149.0,
+      "ratio": 0.9613,
+      "suggested_scalar": -0.02,
+      "log_bad": 5.0434,
+      "log_good": 5.0039
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9229,
+      "good": 0.9092,
+      "ratio": 0.9852,
+      "suggested_scalar": -0.0076,
+      "log_bad": -0.0802,
+      "log_good": -0.0952
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 28.0,
+      "ratio": 1.037,
+      "suggested_scalar": 0.0184,
+      "log_bad": 3.2958,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6349,
+      "good": 0.6424,
+      "ratio": 1.0118,
+      "suggested_scalar": 0.0059,
+      "log_bad": -0.4543,
+      "log_good": -0.4425
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4232,
+      "good": 0.4647,
+      "ratio": 1.0981,
+      "suggested_scalar": 0.0473,
+      "log_bad": -0.8599,
+      "log_good": -0.7664
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7391,
+      "good": 2.7965,
+      "ratio": 1.021,
+      "suggested_scalar": 0.0105,
+      "log_bad": 1.0076,
+      "log_good": 1.0284
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 456.0,
+      "good": 467.0,
+      "ratio": 1.0241,
+      "suggested_scalar": 0.0121,
+      "log_bad": 6.1225,
+      "log_good": 6.1463
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0568,
+      "good": 0.0469,
+      "ratio": 0.8257,
+      "suggested_scalar": -0.0969,
+      "log_bad": -2.8682,
+      "log_good": -3.0597
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7549,
+      "good": 5.6724,
+      "ratio": 0.9857,
+      "suggested_scalar": -0.0073,
+      "log_bad": 1.7501,
+      "log_good": 1.7356
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 20.0,
+      "good": 28.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.1702,
+      "log_bad": 2.9957,
+      "log_good": 3.3322
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6816,
+      "good": 0.7942,
+      "ratio": 1.1652,
+      "suggested_scalar": 0.0774,
+      "log_bad": -0.3833,
+      "log_good": -0.2304
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9333,
+      "good": 5.8808,
+      "ratio": 0.9912,
+      "suggested_scalar": -0.0045,
+      "log_bad": 1.7806,
+      "log_good": 1.7717
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7771,
+      "good": 0.8016,
+      "ratio": 1.0315,
+      "suggested_scalar": 0.0157,
+      "log_bad": -0.2522,
+      "log_good": -0.2211
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.3507,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2857,
+      "good": 0.2778,
+      "ratio": 0.9723,
+      "suggested_scalar": -0.0142,
+      "log_bad": -1.2528,
+      "log_good": -1.2809
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.3742,
+      "good": 3.3088,
+      "ratio": 0.9806,
+      "suggested_scalar": -0.0099,
+      "log_bad": 1.2162,
+      "log_good": 1.1966
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 333.0,
+      "good": 325.0,
+      "ratio": 0.976,
+      "suggested_scalar": -0.0123,
+      "log_bad": 5.8081,
+      "log_good": 5.7838
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 5.0,
+      "good": 7.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.1702,
+      "log_bad": 1.6094,
+      "log_good": 1.9459
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7587,
+      "good": 0.7771,
+      "ratio": 1.0243,
+      "suggested_scalar": 0.0121,
+      "log_bad": -0.2761,
+      "log_good": -0.2522
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 113.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.7274,
+      "log_good": 4.7274
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1097.0,
+      "good": 1101.0,
+      "ratio": 1.0036,
+      "suggested_scalar": 0.0018,
+      "log_bad": 7.0003,
+      "log_good": 7.004
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 169.0,
+      "good": 165.0,
+      "ratio": 0.9763,
+      "suggested_scalar": -0.0121,
+      "log_bad": 5.1299,
+      "log_good": 5.1059
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0109,
+      "good": 0.0107,
+      "ratio": 0.9817,
+      "suggested_scalar": -0.0094,
+      "log_bad": -4.519,
+      "log_good": -4.5375
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1878,
+      "good": 0.209,
+      "ratio": 1.1129,
+      "suggested_scalar": 0.0541,
+      "log_bad": -1.6724,
+      "log_good": -1.5654
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 80.0,
+      "good": 84.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0247,
+      "log_bad": 4.382,
+      "log_good": 4.4308
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 113.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.7274,
+      "log_good": 4.7274
+    },
+    "brevity.mean_sample_size": {
+      "bad": 113.0,
+      "good": 113.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.7274,
+      "log_good": 4.7274
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 458.0,
+      "good": 469.0,
+      "ratio": 1.024,
+      "suggested_scalar": 0.012,
+      "log_bad": 6.1269,
+      "log_good": 6.1506
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 176.0,
+      "good": 189.0,
+      "ratio": 1.0739,
+      "suggested_scalar": 0.0361,
+      "log_bad": 5.1705,
+      "log_good": 5.2417
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 277.0,
+      "good": 270.0,
+      "ratio": 0.9747,
+      "suggested_scalar": -0.013,
+      "log_bad": 5.624,
+      "log_good": 5.5984
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.1816,
+      "good": 2.482,
+      "ratio": 1.1377,
+      "suggested_scalar": 0.0653,
+      "log_bad": 0.7801,
+      "log_good": 0.9091
+    },
+    "halstead.mean_effort": {
+      "bad": 96161.2599,
+      "good": 109901.5308,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.0676,
+      "log_bad": 11.4738,
+      "log_good": 11.6073
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3507,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.87,
+      "good": 0.8623,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.0045,
+      "log_bad": -0.1393,
+      "log_good": -0.1482
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 54.0,
+      "good": 49.0,
+      "ratio": 0.9074,
+      "suggested_scalar": -0.0492,
+      "log_bad": 3.989,
+      "log_good": 3.8918
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 190.0,
+      "good": 207.0,
+      "ratio": 1.0895,
+      "suggested_scalar": 0.0434,
+      "log_bad": 5.247,
+      "log_good": 5.3327
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4056,
+      "good": 0.4176,
+      "ratio": 1.0296,
+      "suggested_scalar": 0.0148,
+      "log_bad": -0.9024,
+      "log_good": -0.8732
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0944,
+      "good": 6.0495,
+      "ratio": 0.9926,
+      "suggested_scalar": -0.0037,
+      "log_bad": 1.8074,
+      "log_good": 1.8
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2857,
+      "good": 0.2778,
+      "ratio": 0.9723,
+      "suggested_scalar": -0.0142,
+      "log_bad": -1.2528,
+      "log_good": -1.2809
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.3732,
+      "good": 4.3927,
+      "ratio": 1.0045,
+      "suggested_scalar": 0.0023,
+      "log_bad": 1.4755,
+      "log_good": 1.4799
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 457.0,
+      "good": 468.0,
+      "ratio": 1.0241,
+      "suggested_scalar": 0.012,
+      "log_bad": 6.1247,
+      "log_good": 6.1485
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 70.0,
+      "good": 75.0,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.0349,
+      "log_bad": 4.2485,
+      "log_good": 4.3175
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5342.2922,
+      "good": 6105.6406,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.0676,
+      "log_bad": 8.5834,
+      "log_good": 8.717
+    },
+    "readability.mean_total_lines": {
+      "bad": 50.0,
+      "good": 51.0,
+      "ratio": 1.02,
+      "suggested_scalar": 0.01,
+      "log_bad": 3.912,
+      "log_good": 3.9318
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2276.0062,
+      "good": 2331.2446,
+      "ratio": 1.0243,
+      "suggested_scalar": 0.0121,
+      "log_bad": 7.7302,
+      "log_good": 7.7542
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 778.0,
+      "good": 747.0,
+      "ratio": 0.9602,
+      "suggested_scalar": -0.0206,
+      "log_bad": 6.6567,
+      "log_good": 6.6161
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 41.14,
+      "good": 39.0196,
+      "ratio": 0.9485,
+      "suggested_scalar": -0.0268,
+      "log_bad": 3.717,
+      "log_good": 3.6641
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1241,
+      "good": 1.1214,
+      "ratio": 0.9976,
+      "suggested_scalar": -0.0012,
+      "log_bad": 0.117,
+      "log_good": 0.1146
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7898,
+      "good": 0.7692,
+      "ratio": 0.9739,
+      "suggested_scalar": -0.0134,
+      "log_bad": -0.236,
+      "log_good": -0.2624
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9749,
+      "good": 0.9662,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.0045,
+      "log_bad": -0.0254,
+      "log_good": -0.0344
+    },
+    "halstead.mean_length": {
+      "bad": 359.0,
+      "good": 372.0,
+      "ratio": 1.0362,
+      "suggested_scalar": 0.018,
+      "log_bad": 5.8833,
+      "log_good": 5.9189
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8202,
+      "good": 6.8202,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9199,
+      "log_good": 1.9199
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.2052,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0827,
+      "good": 0.0905,
+      "ratio": 1.0943,
+      "suggested_scalar": 0.0456,
+      "log_bad": -2.4925,
+      "log_good": -2.4024
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 42.25,
+      "good": 47.1429,
+      "ratio": 1.1158,
+      "suggested_scalar": 0.0554,
+      "log_bad": 3.7436,
+      "log_good": 3.8532
+    },
+    "branching.mean_branch_count": {
+      "bad": 19.0,
+      "good": 22.0,
+      "ratio": 1.1579,
+      "suggested_scalar": 0.0742,
+      "log_bad": 2.9444,
+      "log_good": 3.091
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 73.0,
+      "good": 76.0,
+      "ratio": 1.0411,
+      "suggested_scalar": 0.0204,
+      "log_bad": 4.2905,
+      "log_good": 4.3307
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7112,
+      "good": 0.6889,
+      "ratio": 0.9686,
+      "suggested_scalar": -0.0161,
+      "log_bad": -0.3408,
+      "log_good": -0.3727
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 50.0,
+      "good": 52.0,
+      "ratio": 1.04,
+      "suggested_scalar": 0.0198,
+      "log_bad": 3.912,
+      "log_good": 3.9512
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.uses_appropriate_dispatcher": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0025,
+      "good": 0.0027,
+      "ratio": 1.08,
+      "suggested_scalar": 0.1401,
+      "log_bad": -5.9915,
+      "log_good": -5.9145
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8723,
+      "good": 0.8085,
+      "ratio": 0.9269,
+      "suggested_scalar": -0.1383,
+      "log_bad": -0.1366,
+      "log_good": -0.2126
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0025,
+      "good": 0.0027,
+      "ratio": 1.08,
+      "suggested_scalar": 0.1401,
+      "log_bad": -5.9915,
+      "log_good": -5.9145
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5926,
+      "good": 4.549,
+      "ratio": 0.9905,
+      "suggested_scalar": -0.0174,
+      "log_bad": 1.5244,
+      "log_good": 1.5149
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 124.0,
+      "good": 114.0,
+      "ratio": 0.9194,
+      "suggested_scalar": -0.1531,
+      "log_bad": 4.8203,
+      "log_good": 4.7362
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6369,
+      "good": 0.6202,
+      "ratio": 0.9738,
+      "suggested_scalar": -0.0484,
+      "log_bad": -0.4511,
+      "log_good": -0.4777
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 15.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.2279,
+      "log_bad": 2.8332,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7413,
+      "good": 0.7292,
+      "ratio": 0.9837,
+      "suggested_scalar": -0.03,
+      "log_bad": -0.2993,
+      "log_good": -0.3158
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.9574,
+      "good": 6.9362,
+      "ratio": 0.997,
+      "suggested_scalar": -0.0056,
+      "log_bad": 1.9398,
+      "log_good": 1.9368
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 395.0,
+      "good": 370.0,
+      "ratio": 0.9367,
+      "suggested_scalar": -0.119,
+      "log_bad": 5.9789,
+      "log_good": 5.9135
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2979,
+      "good": 0.2979,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.211,
+      "log_good": -1.211
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.873,
+      "good": 0.8937,
+      "ratio": 1.0237,
+      "suggested_scalar": 0.0427,
+      "log_bad": -0.1358,
+      "log_good": -0.1124
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 180.0,
+      "good": 157.0,
+      "ratio": 0.8722,
+      "suggested_scalar": -0.2489,
+      "log_bad": 5.193,
+      "log_good": 5.0562
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 95.33,
+      "good": 93.3126,
+      "ratio": 0.9788,
+      "suggested_scalar": -0.0389,
+      "log_bad": 4.5573,
+      "log_good": 4.536
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4848,
+      "good": 0.4824,
+      "ratio": 0.995,
+      "suggested_scalar": -0.009,
+      "log_bad": -0.724,
+      "log_good": -0.729
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.5691,
+      "good": 14.2114,
+      "ratio": 1.0473,
+      "suggested_scalar": 0.0842,
+      "log_bad": 2.6078,
+      "log_good": 2.654
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2087.0,
+      "good": 1952.0,
+      "ratio": 0.9353,
+      "suggested_scalar": -0.1217,
+      "log_bad": 7.6435,
+      "log_good": 7.5766
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1277,
+      "good": 0.0426,
+      "ratio": 0.3336,
+      "suggested_scalar": -1.9986,
+      "log_bad": -2.0581,
+      "log_good": -3.1559
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8085,
+      "good": 0.7447,
+      "ratio": 0.9211,
+      "suggested_scalar": -0.1496,
+      "log_bad": -0.2126,
+      "log_good": -0.2948
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.4043,
+      "good": 7.8723,
+      "ratio": 0.9367,
+      "suggested_scalar": -0.119,
+      "log_bad": 2.1287,
+      "log_good": 2.0634
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 29.6152,
+      "good": 29.7193,
+      "ratio": 1.0035,
+      "suggested_scalar": 0.0064,
+      "log_bad": 3.3883,
+      "log_good": 3.3918
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 94.0,
+      "good": 79.0,
+      "ratio": 0.8404,
+      "suggested_scalar": -0.3165,
+      "log_bad": 4.5433,
+      "log_good": 4.3694
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9452,
+      "good": 0.9403,
+      "ratio": 0.9948,
+      "suggested_scalar": -0.0095,
+      "log_bad": -0.0564,
+      "log_good": -0.0616
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 25.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0714,
+      "log_bad": 3.2581,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6009,
+      "good": 0.6009,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.5093,
+      "log_good": -0.5093
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3053,
+      "good": 0.3125,
+      "ratio": 1.0236,
+      "suggested_scalar": 0.0424,
+      "log_bad": -1.1865,
+      "log_good": -1.1632
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5054,
+      "good": 2.5058,
+      "ratio": 1.0002,
+      "suggested_scalar": 0.0003,
+      "log_bad": 0.9184,
+      "log_good": 0.9186
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 393.0,
+      "good": 368.0,
+      "ratio": 0.9364,
+      "suggested_scalar": -0.1197,
+      "log_bad": 5.9738,
+      "log_good": 5.9081
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0329,
+      "good": 0.0351,
+      "ratio": 1.0669,
+      "suggested_scalar": 0.1178,
+      "log_bad": -3.4143,
+      "log_good": -3.3496
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 5.8826,
+      "ratio": 0.9919,
+      "suggested_scalar": -0.0148,
+      "log_bad": 1.7801,
+      "log_good": 1.772
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 58.0,
+      "good": 50.0,
+      "ratio": 0.8621,
+      "suggested_scalar": -0.2702,
+      "log_bad": 4.0604,
+      "log_good": 3.912
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4681,
+      "good": 1.5075,
+      "ratio": 1.0268,
+      "suggested_scalar": 0.0482,
+      "log_bad": 0.384,
+      "log_good": 0.4105
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0056,
+      "good": 0.0064,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.2431,
+      "log_bad": -5.185,
+      "log_good": -5.0515
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.1995,
+      "good": 6.0354,
+      "ratio": 0.9735,
+      "suggested_scalar": -0.0488,
+      "log_bad": 1.8245,
+      "log_good": 1.7976
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7744,
+      "good": 0.7733,
+      "ratio": 0.9986,
+      "suggested_scalar": -0.0026,
+      "log_bad": -0.2557,
+      "log_good": -0.2571
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1296,
+      "good": 0.1296,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.0433,
+      "log_good": -2.0433
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6836,
+      "good": 3.7698,
+      "ratio": 1.0234,
+      "suggested_scalar": 0.0421,
+      "log_bad": 1.3039,
+      "log_good": 1.327
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 321.0,
+      "good": 298.0,
+      "ratio": 0.9283,
+      "suggested_scalar": -0.1353,
+      "log_bad": 5.7714,
+      "log_good": 5.6971
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8994,
+      "good": 0.8245,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.1583,
+      "log_bad": -0.106,
+      "log_good": -0.193
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 125.0,
+      "good": 114.0,
+      "ratio": 0.912,
+      "suggested_scalar": -0.1677,
+      "log_bad": 4.8283,
+      "log_good": 4.7362
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1180.0,
+      "good": 1064.0,
+      "ratio": 0.9017,
+      "suggested_scalar": -0.1884,
+      "log_bad": 7.0733,
+      "log_good": 6.9698
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 193.0,
+      "good": 170.0,
+      "ratio": 0.8808,
+      "suggested_scalar": -0.231,
+      "log_bad": 5.2627,
+      "log_good": 5.1358
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0025,
+      "good": 0.0027,
+      "ratio": 1.08,
+      "suggested_scalar": 0.1401,
+      "log_bad": -5.9915,
+      "log_good": -5.9145
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2532,
+      "good": 0.2622,
+      "ratio": 1.0355,
+      "suggested_scalar": 0.0636,
+      "log_bad": -1.3736,
+      "log_good": -1.3386
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 67.0,
+      "good": 61.0,
+      "ratio": 0.9104,
+      "suggested_scalar": -0.1708,
+      "log_bad": 4.2047,
+      "log_good": 4.1109
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 125.0,
+      "good": 114.0,
+      "ratio": 0.912,
+      "suggested_scalar": -0.1677,
+      "log_bad": 4.8283,
+      "log_good": 4.7362
+    },
+    "brevity.mean_sample_size": {
+      "bad": 125.0,
+      "good": 114.0,
+      "ratio": 0.912,
+      "suggested_scalar": -0.1677,
+      "log_bad": 4.8283,
+      "log_good": 4.7362
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 395.0,
+      "good": 370.0,
+      "ratio": 0.9367,
+      "suggested_scalar": -0.119,
+      "log_bad": 5.9789,
+      "log_good": 5.9135
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 174.0,
+      "good": 176.0,
+      "ratio": 1.0115,
+      "suggested_scalar": 0.0208,
+      "log_bad": 5.1591,
+      "log_good": 5.1705
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 270.0,
+      "good": 252.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.1256,
+      "log_bad": 5.5984,
+      "log_good": 5.5294
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.763,
+      "good": 1.8144,
+      "ratio": 1.0292,
+      "suggested_scalar": 0.0523,
+      "log_bad": 0.567,
+      "log_good": 0.5958
+    },
+    "halstead.mean_effort": {
+      "bad": 69080.1477,
+      "good": 59058.4342,
+      "ratio": 0.8549,
+      "suggested_scalar": -0.2853,
+      "log_bad": 11.143,
+      "log_good": 10.9863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.89,
+      "good": 0.8833,
+      "ratio": 0.9925,
+      "suggested_scalar": -0.0138,
+      "log_bad": -0.1165,
+      "log_good": -0.1241
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 98.0,
+      "good": 89.0,
+      "ratio": 0.9082,
+      "suggested_scalar": -0.1754,
+      "log_bad": 4.585,
+      "log_good": 4.4886
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 195.0,
+      "good": 192.0,
+      "ratio": 0.9846,
+      "suggested_scalar": -0.0282,
+      "log_bad": 5.273,
+      "log_good": 5.2575
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5222,
+      "good": 0.5414,
+      "ratio": 1.0368,
+      "suggested_scalar": 0.0657,
+      "log_bad": -0.6497,
+      "log_good": -0.6136
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.5556,
+      "good": 6.7771,
+      "ratio": 1.0338,
+      "suggested_scalar": 0.0605,
+      "log_bad": 1.8803,
+      "log_good": 1.9135
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1296,
+      "good": 0.1296,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.0433,
+      "log_good": -2.0433
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.2667,
+      "good": 4.1799,
+      "ratio": 0.9797,
+      "suggested_scalar": -0.0374,
+      "log_bad": 1.4508,
+      "log_good": 1.4303
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 394.0,
+      "good": 369.0,
+      "ratio": 0.9365,
+      "suggested_scalar": -0.1193,
+      "log_bad": 5.9764,
+      "log_good": 5.9108
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 48.0,
+      "good": 45.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.1175,
+      "log_bad": 3.8712,
+      "log_good": 3.8067
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3837.786,
+      "good": 3281.0241,
+      "ratio": 0.8549,
+      "suggested_scalar": -0.2853,
+      "log_bad": 8.2527,
+      "log_good": 8.0959
+    },
+    "readability.mean_total_lines": {
+      "bad": 47.0,
+      "good": 47.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8501,
+      "log_good": 3.8501
+    },
+    "indentation.mean_max_depth": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "halstead.mean_volume": {
+      "bad": 2698.2282,
+      "good": 2473.5062,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.1583,
+      "log_bad": 7.9004,
+      "log_good": 7.8134
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 833.0,
+      "good": 779.0,
+      "ratio": 0.9352,
+      "suggested_scalar": -0.122,
+      "log_bad": 6.725,
+      "log_good": 6.658
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 43.1702,
+      "good": 40.2128,
+      "ratio": 0.9315,
+      "suggested_scalar": -0.1292,
+      "log_bad": 3.7652,
+      "log_good": 3.6942
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2172,
+      "good": 1.2474,
+      "ratio": 1.0248,
+      "suggested_scalar": 0.0446,
+      "log_bad": 0.1966,
+      "log_good": 0.2211
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 29.0,
+      "good": 28.0,
+      "ratio": 0.9655,
+      "suggested_scalar": -0.0639,
+      "log_bad": 3.3673,
+      "log_good": 3.3322
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8505,
+      "good": 0.849,
+      "ratio": 0.9982,
+      "suggested_scalar": -0.0032,
+      "log_bad": -0.1619,
+      "log_good": -0.1637
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9759,
+      "good": 0.9764,
+      "ratio": 1.0005,
+      "suggested_scalar": 0.0009,
+      "log_bad": -0.0244,
+      "log_good": -0.0239
+    },
+    "halstead.mean_length": {
+      "bad": 388.0,
+      "good": 362.0,
+      "ratio": 0.933,
+      "suggested_scalar": -0.1263,
+      "log_bad": 5.961,
+      "log_good": 5.8916
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9658,
+      "good": 6.8329,
+      "ratio": 0.9809,
+      "suggested_scalar": -0.0351,
+      "log_bad": 1.941,
+      "log_good": 1.9217
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0835,
+      "good": 0.0905,
+      "ratio": 1.0838,
+      "suggested_scalar": 0.1466,
+      "log_bad": -2.4829,
+      "log_good": -2.4024
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.602,
+      "good": 23.8764,
+      "ratio": 0.9326,
+      "suggested_scalar": -0.127,
+      "log_bad": 3.2427,
+      "log_good": 3.1729
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 2.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.7918,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 94.0,
+      "good": 85.0,
+      "ratio": 0.9043,
+      "suggested_scalar": -0.1832,
+      "log_bad": 4.5433,
+      "log_good": 4.4427
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7519,
+      "good": 0.7579,
+      "ratio": 1.008,
+      "suggested_scalar": 0.0145,
+      "log_bad": -0.2852,
+      "log_good": -0.2772
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 47.0,
+      "good": 47.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8501,
+      "log_good": 3.8501
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.does_not_spawn_unbounded_goroutines": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2426,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0153,
+      "good": 0.0131,
+      "ratio": 0.8562,
+      "suggested_scalar": -0.0543,
+      "log_bad": -4.1799,
+      "log_good": -4.3351
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.5,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1419,
+      "log_bad": 0.0,
+      "log_good": 0.4055
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8864,
+      "good": 0.8776,
+      "ratio": 0.9901,
+      "suggested_scalar": -0.0035,
+      "log_bad": -0.1206,
+      "log_good": -0.1306
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0153,
+      "good": 0.0131,
+      "ratio": 0.8562,
+      "suggested_scalar": -0.0543,
+      "log_bad": -4.1799,
+      "log_good": -4.3351
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8096,
+      "good": 4.7927,
+      "ratio": 0.9965,
+      "suggested_scalar": -0.0012,
+      "log_bad": 1.5706,
+      "log_good": 1.5671
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 104.0,
+      "good": 102.0,
+      "ratio": 0.9808,
+      "suggested_scalar": -0.0068,
+      "log_bad": 4.6444,
+      "log_good": 4.625
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6024,
+      "good": 0.53,
+      "ratio": 0.8798,
+      "suggested_scalar": -0.0448,
+      "log_bad": -0.5068,
+      "log_good": -0.6349
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 19.0,
+      "ratio": 0.95,
+      "suggested_scalar": -0.018,
+      "log_bad": 2.9957,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7871,
+      "good": 0.7111,
+      "ratio": 0.9034,
+      "suggested_scalar": -0.0355,
+      "log_bad": -0.2394,
+      "log_good": -0.3409
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.9545,
+      "good": 1.0408,
+      "ratio": 1.0904,
+      "suggested_scalar": 0.0303,
+      "log_bad": -0.0466,
+      "log_good": 0.04
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 262.0,
+      "good": 306.0,
+      "ratio": 1.1679,
+      "suggested_scalar": 0.0543,
+      "log_bad": 5.5683,
+      "log_good": 5.7236
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.001,
+      "good": 0.0008,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0781,
+      "log_bad": -6.9078,
+      "log_good": -7.1309
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1136,
+      "good": 0.0612,
+      "ratio": 0.5387,
+      "suggested_scalar": -0.2165,
+      "log_bad": -2.1751,
+      "log_good": -2.7936
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.7971,
+      "good": 0.8749,
+      "ratio": 1.0976,
+      "suggested_scalar": 0.0326,
+      "log_bad": -0.2268,
+      "log_good": -0.1336
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 116.0,
+      "good": 119.0,
+      "ratio": 1.0259,
+      "suggested_scalar": 0.0089,
+      "log_bad": 4.7536,
+      "log_good": 4.7791
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 113.2939,
+      "good": 113.2192,
+      "ratio": 0.9993,
+      "suggested_scalar": -0.0002,
+      "log_bad": 4.73,
+      "log_good": 4.7293
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.2989,
+      "good": 0.3279,
+      "ratio": 1.097,
+      "suggested_scalar": 0.0324,
+      "log_bad": -1.2076,
+      "log_good": -1.115
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.687,
+      "good": 10.2143,
+      "ratio": 1.1758,
+      "suggested_scalar": 0.0567,
+      "log_bad": 2.1618,
+      "log_good": 2.3238
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1054.0,
+      "good": 1203.0,
+      "ratio": 1.1414,
+      "suggested_scalar": 0.0463,
+      "log_bad": 6.9603,
+      "log_good": 7.0926
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0909,
+      "good": 0.102,
+      "ratio": 1.1221,
+      "suggested_scalar": 0.0403,
+      "log_bad": -2.398,
+      "log_good": -2.2828
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8409,
+      "good": 0.8367,
+      "ratio": 0.995,
+      "suggested_scalar": -0.0018,
+      "log_bad": -0.1733,
+      "log_good": -0.1783
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.9545,
+      "good": 6.2449,
+      "ratio": 1.0488,
+      "suggested_scalar": 0.0167,
+      "log_bad": 1.7841,
+      "log_good": 1.8318
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.9979,
+      "good": 0.9779,
+      "ratio": 0.98,
+      "suggested_scalar": -0.0071,
+      "log_bad": -0.0021,
+      "log_good": -0.0223
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 87.0,
+      "good": 91.0,
+      "ratio": 1.046,
+      "suggested_scalar": 0.0157,
+      "log_bad": 4.4659,
+      "log_good": 4.5109
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9284,
+      "good": 0.9386,
+      "ratio": 1.011,
+      "suggested_scalar": 0.0038,
+      "log_bad": -0.0743,
+      "log_good": -0.0634
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 32.0,
+      "ratio": 1.1034,
+      "suggested_scalar": 0.0345,
+      "log_bad": 3.3673,
+      "log_good": 3.4657
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.4725,
+      "good": 0.5079,
+      "ratio": 1.0749,
+      "suggested_scalar": 0.0253,
+      "log_bad": -0.7497,
+      "log_good": -0.6775
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.0962,
+      "good": 0.1151,
+      "ratio": 1.1965,
+      "suggested_scalar": 0.0628,
+      "log_bad": -2.3413,
+      "log_good": -2.162
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.8957,
+      "good": 2.0321,
+      "ratio": 1.072,
+      "suggested_scalar": 0.0243,
+      "log_bad": 0.6396,
+      "log_good": 0.7091
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 260.0,
+      "good": 304.0,
+      "ratio": 1.1692,
+      "suggested_scalar": 0.0547,
+      "log_bad": 5.5607,
+      "log_good": 5.717
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 24.0,
+      "good": 26.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.028,
+      "log_bad": 3.1781,
+      "log_good": 3.2581
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0076,
+      "good": 0.0098,
+      "ratio": 1.2895,
+      "suggested_scalar": 0.089,
+      "log_bad": -4.8796,
+      "log_good": -4.6254
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.9773,
+      "ratio": 1.0039,
+      "suggested_scalar": 0.0014,
+      "log_bad": 1.7841,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 28.0,
+      "good": 27.0,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.0127,
+      "log_bad": 3.3322,
+      "log_good": 3.2958
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8654,
+      "good": 0.8394,
+      "ratio": 0.97,
+      "suggested_scalar": -0.0107,
+      "log_bad": -0.1446,
+      "log_good": -0.1751
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.0597,
+      "good": 5.9385,
+      "ratio": 0.98,
+      "suggested_scalar": -0.0071,
+      "log_bad": 1.8017,
+      "log_good": 1.7815
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8078,
+      "good": 0.8018,
+      "ratio": 0.9926,
+      "suggested_scalar": -0.0026,
+      "log_bad": -0.2134,
+      "log_good": -0.2209
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1698,
+      "good": 0.1552,
+      "ratio": 0.914,
+      "suggested_scalar": -0.0315,
+      "log_bad": -1.7731,
+      "log_good": -1.863
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.9474,
+      "good": 3.196,
+      "ratio": 1.0843,
+      "suggested_scalar": 0.0283,
+      "log_bad": 1.0809,
+      "log_good": 1.1619
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 247.0,
+      "good": 286.0,
+      "ratio": 1.1579,
+      "suggested_scalar": 0.0513,
+      "log_bad": 5.5094,
+      "log_good": 5.656
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 5.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.3207,
+      "log_bad": 0.6931,
+      "log_good": 1.6094
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.545,
+      "good": 0.6383,
+      "ratio": 1.1712,
+      "suggested_scalar": 0.0553,
+      "log_bad": -0.607,
+      "log_good": -0.4489
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 104.0,
+      "good": 100.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0137,
+      "log_bad": 4.6444,
+      "log_good": 4.6052
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 586.0,
+      "good": 632.0,
+      "ratio": 1.0785,
+      "suggested_scalar": 0.0265,
+      "log_bad": 6.3733,
+      "log_good": 6.4489
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 127.0,
+      "good": 136.0,
+      "ratio": 1.0709,
+      "suggested_scalar": 0.024,
+      "log_bad": 4.8442,
+      "log_good": 4.9127
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.187,
+      "good": 0.1863,
+      "ratio": 0.9963,
+      "suggested_scalar": -0.0013,
+      "log_bad": -1.6766,
+      "log_good": -1.6804
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 32.0,
+      "good": 39.0,
+      "ratio": 1.2188,
+      "suggested_scalar": 0.0692,
+      "log_bad": 3.4657,
+      "log_good": 3.6636
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 104.0,
+      "good": 100.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0137,
+      "log_bad": 4.6444,
+      "log_good": 4.6052
+    },
+    "brevity.mean_sample_size": {
+      "bad": 104.0,
+      "good": 100.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0137,
+      "log_bad": 4.6444,
+      "log_good": 4.6052
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 262.0,
+      "good": 306.0,
+      "ratio": 1.1679,
+      "suggested_scalar": 0.0543,
+      "log_bad": 5.5683,
+      "log_good": 5.7236
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 115.0,
+      "good": 145.0,
+      "ratio": 1.2609,
+      "suggested_scalar": 0.0811,
+      "log_bad": 4.7449,
+      "log_good": 4.9767
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 215.0,
+      "good": 244.0,
+      "ratio": 1.1349,
+      "suggested_scalar": 0.0443,
+      "log_bad": 5.3706,
+      "log_good": 5.4972
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0033,
+      "ratio": 0.0033,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.7138
+    },
+    "heaps.mean_k": {
+      "bad": 1.4875,
+      "good": 1.9417,
+      "ratio": 1.3053,
+      "suggested_scalar": 0.0933,
+      "log_bad": 0.3971,
+      "log_good": 0.6636
+    },
+    "halstead.mean_effort": {
+      "bad": 40142.4237,
+      "good": 59528.7099,
+      "ratio": 1.4829,
+      "suggested_scalar": 0.1379,
+      "log_bad": 10.6002,
+      "log_good": 10.9942
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.9044,
+      "good": 0.8938,
+      "ratio": 0.9883,
+      "suggested_scalar": -0.0041,
+      "log_bad": -0.1005,
+      "log_good": -0.1123
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 75.0,
+      "good": 70.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0241,
+      "log_bad": 4.3175,
+      "log_good": 4.2485
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 117.0,
+      "good": 151.0,
+      "ratio": 1.2906,
+      "suggested_scalar": 0.0893,
+      "log_bad": 4.7622,
+      "log_good": 5.0173
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5517,
+      "good": 0.4874,
+      "ratio": 0.8835,
+      "suggested_scalar": -0.0434,
+      "log_bad": -0.5948,
+      "log_good": -0.7187
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.0517,
+      "good": 5.3109,
+      "ratio": 1.0513,
+      "suggested_scalar": 0.0175,
+      "log_bad": 1.6197,
+      "log_good": 1.6698
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1698,
+      "good": 0.1552,
+      "ratio": 0.914,
+      "suggested_scalar": -0.0315,
+      "log_bad": -1.7731,
+      "log_good": -1.863
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.3818,
+      "good": 2.498,
+      "ratio": 1.0488,
+      "suggested_scalar": 0.0167,
+      "log_bad": 0.8679,
+      "log_good": 0.9155
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 261.0,
+      "good": 305.0,
+      "ratio": 1.1686,
+      "suggested_scalar": 0.0545,
+      "log_bad": 5.5645,
+      "log_good": 5.7203
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.3845,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 12.0,
+      "good": 17.0,
+      "ratio": 1.4167,
+      "suggested_scalar": 0.1219,
+      "log_bad": 2.4849,
+      "log_good": 2.8332
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2230.1346,
+      "good": 3307.1506,
+      "ratio": 1.4829,
+      "suggested_scalar": 0.1379,
+      "log_bad": 7.7098,
+      "log_good": 8.1038
+    },
+    "readability.mean_total_lines": {
+      "bad": 44.0,
+      "good": 49.0,
+      "ratio": 1.1136,
+      "suggested_scalar": 0.0377,
+      "log_bad": 3.7842,
+      "log_good": 3.8918
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1634.9073,
+      "good": 1914.9861,
+      "ratio": 1.1713,
+      "suggested_scalar": 0.0553,
+      "log_bad": 7.3993,
+      "log_good": 7.5575
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 556.0,
+      "good": 592.0,
+      "ratio": 1.0647,
+      "suggested_scalar": 0.022,
+      "log_bad": 6.3208,
+      "log_good": 6.3835
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 22.7045,
+      "good": 23.3673,
+      "ratio": 1.0292,
+      "suggested_scalar": 0.0101,
+      "log_bad": 3.1226,
+      "log_good": 3.1513
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0342,
+      "good": 1.0316,
+      "ratio": 0.9975,
+      "suggested_scalar": -0.0009,
+      "log_bad": 0.0336,
+      "log_good": 0.0311
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 3.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.1788,
+      "log_bad": 1.6094,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9514,
+      "good": 0.9406,
+      "ratio": 0.9886,
+      "suggested_scalar": -0.004,
+      "log_bad": -0.0498,
+      "log_good": -0.0612
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9833,
+      "good": 0.9732,
+      "ratio": 0.9897,
+      "suggested_scalar": -0.0036,
+      "log_bad": -0.0168,
+      "log_good": -0.0272
+    },
+    "halstead.mean_length": {
+      "bad": 244.0,
+      "good": 287.0,
+      "ratio": 1.1762,
+      "suggested_scalar": 0.0568,
+      "log_bad": 5.4972,
+      "log_good": 5.6595
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 14.5,
+      "good": 17.0,
+      "ratio": 1.1724,
+      "suggested_scalar": 0.0557,
+      "log_bad": 2.6741,
+      "log_good": 2.8332
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7004,
+      "good": 6.6439,
+      "ratio": 0.9916,
+      "suggested_scalar": -0.003,
+      "log_bad": 1.9022,
+      "log_good": 1.8937
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1093,
+      "good": 0.1205,
+      "ratio": 1.1025,
+      "suggested_scalar": 0.0341,
+      "log_bad": -2.2137,
+      "log_good": -2.1161
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 24.5533,
+      "good": 31.0857,
+      "ratio": 1.266,
+      "suggested_scalar": 0.0826,
+      "log_bad": 3.2008,
+      "log_good": 3.4367
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0781,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 64.0,
+      "good": 58.0,
+      "ratio": 0.9063,
+      "suggested_scalar": -0.0345,
+      "log_bad": 4.1589,
+      "log_good": 4.0604
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8512,
+      "good": 0.8402,
+      "ratio": 0.9871,
+      "suggested_scalar": -0.0046,
+      "log_bad": -0.1611,
+      "log_good": -0.1741
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 44.0,
+      "good": 49.0,
+      "ratio": 1.1136,
+      "suggested_scalar": 0.0377,
+      "log_bad": 3.7842,
+      "log_good": 3.8918
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.uses_optionals_not_sentinel_values": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 18.0,
+      "good": 14.0,
+      "ratio": 0.7778,
+      "suggested_scalar": -0.0788,
+      "log_bad": 2.8904,
+      "log_good": 2.6391
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1272,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.037,
+      "good": 0.021,
+      "ratio": 0.5676,
+      "suggested_scalar": -0.1776,
+      "log_bad": -3.2968,
+      "log_good": -3.8632
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 0.4,
+      "ratio": 0.4,
+      "suggested_scalar": -0.2874,
+      "log_bad": 0.0,
+      "log_good": -0.9163
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8868,
+      "good": 0.8333,
+      "ratio": 0.9397,
+      "suggested_scalar": -0.0195,
+      "log_bad": -0.1201,
+      "log_good": -0.1824
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.037,
+      "good": 0.021,
+      "ratio": 0.5676,
+      "suggested_scalar": -0.1776,
+      "log_bad": -3.2968,
+      "log_good": -3.8632
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4479,
+      "good": 4.3667,
+      "ratio": 0.9817,
+      "suggested_scalar": -0.0058,
+      "log_bad": 1.4924,
+      "log_good": 1.474
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 95.0,
+      "good": 67.0,
+      "ratio": 0.7053,
+      "suggested_scalar": -0.1095,
+      "log_bad": 4.5539,
+      "log_good": 4.2047
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4714,
+      "good": 0.5412,
+      "ratio": 1.1481,
+      "suggested_scalar": 0.0433,
+      "log_bad": -0.752,
+      "log_good": -0.614
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 15.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.0393,
+      "log_bad": 2.8332,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6947,
+      "good": 0.7387,
+      "ratio": 1.0633,
+      "suggested_scalar": 0.0193,
+      "log_bad": -0.3643,
+      "log_good": -0.3029
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.2075,
+      "good": 4.9167,
+      "ratio": 0.9442,
+      "suggested_scalar": -0.018,
+      "log_bad": 1.6501,
+      "log_good": 1.5926
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 351.0,
+      "good": 238.0,
+      "ratio": 0.6781,
+      "suggested_scalar": -0.1218,
+      "log_bad": 5.8608,
+      "log_good": 5.4723
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0017,
+      "good": 1.0,
+      "ratio": 588.2353,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.3771,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1887,
+      "good": 1.0,
+      "ratio": 5.2994,
+      "suggested_scalar": 0.523,
+      "log_bad": -1.6676,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0023,
+      "good": 0.0055,
+      "ratio": 2.3913,
+      "suggested_scalar": 0.2734,
+      "log_bad": -6.0748,
+      "log_good": -5.203
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9327,
+      "good": 0.9242,
+      "ratio": 0.9909,
+      "suggested_scalar": -0.0029,
+      "log_bad": -0.0697,
+      "log_good": -0.0788
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 128.0,
+      "good": 85.0,
+      "ratio": 0.6641,
+      "suggested_scalar": -0.1284,
+      "log_bad": 4.852,
+      "log_good": 4.4427
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 105.1153,
+      "good": 102.5472,
+      "ratio": 0.9756,
+      "suggested_scalar": -0.0078,
+      "log_bad": 4.6551,
+      "log_good": 4.6303
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5486,
+      "good": 0.4008,
+      "ratio": 0.7306,
+      "suggested_scalar": -0.0984,
+      "log_bad": -0.6004,
+      "log_good": -0.9143
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.6384,
+      "good": 12.2331,
+      "ratio": 1.2692,
+      "suggested_scalar": 0.0748,
+      "log_bad": 2.2658,
+      "log_good": 2.5041
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1743.0,
+      "good": 1265.0,
+      "ratio": 0.7258,
+      "suggested_scalar": -0.1005,
+      "log_bad": 7.4634,
+      "log_good": 7.1428
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0566,
+      "good": 0.125,
+      "ratio": 2.2085,
+      "suggested_scalar": 0.2485,
+      "log_bad": -2.8717,
+      "log_good": -2.0794
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8491,
+      "good": 0.7917,
+      "ratio": 0.9324,
+      "suggested_scalar": -0.022,
+      "log_bad": -0.1636,
+      "log_good": -0.2336
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.6226,
+      "good": 4.9583,
+      "ratio": 0.7487,
+      "suggested_scalar": -0.0908,
+      "log_bad": 1.8905,
+      "log_good": 1.6011
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 8.2022,
+      "good": 9.4931,
+      "ratio": 1.1574,
+      "suggested_scalar": 0.0458,
+      "log_bad": 2.1044,
+      "log_good": 2.2506
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 70.0,
+      "good": 40.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -0.1755,
+      "log_bad": 4.2485,
+      "log_good": 3.6889
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9456,
+      "good": 0.9294,
+      "ratio": 0.9829,
+      "suggested_scalar": -0.0054,
+      "log_bad": -0.0559,
+      "log_good": -0.0732
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 21.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0419,
+      "log_bad": 3.1781,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6317,
+      "good": 0.6055,
+      "ratio": 0.9585,
+      "suggested_scalar": -0.0133,
+      "log_bad": -0.4593,
+      "log_good": -0.5017
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.384,
+      "good": 0.1992,
+      "ratio": 0.5187,
+      "suggested_scalar": -0.2058,
+      "log_bad": -0.9571,
+      "log_good": -1.6134
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.715,
+      "good": 2.5351,
+      "ratio": 0.9337,
+      "suggested_scalar": -0.0215,
+      "log_bad": 0.9988,
+      "log_good": 0.9302
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 349.0,
+      "good": 236.0,
+      "ratio": 0.6762,
+      "suggested_scalar": -0.1227,
+      "log_bad": 5.8551,
+      "log_good": 5.4638
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 9.0,
+      "good": 11.0,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.0629,
+      "log_bad": 2.1972,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0712,
+      "good": 0.0882,
+      "ratio": 1.2388,
+      "suggested_scalar": 0.0672,
+      "log_bad": -2.6423,
+      "log_good": -2.4281
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.7279,
+      "ratio": 0.982,
+      "suggested_scalar": -0.0057,
+      "log_bad": 1.7635,
+      "log_good": 1.7453
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 40.0,
+      "good": 30.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0902,
+      "log_bad": 3.6889,
+      "log_good": 3.4012
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3986,
+      "good": 1.546,
+      "ratio": 1.1054,
+      "suggested_scalar": 0.0314,
+      "log_bad": 0.3355,
+      "log_good": 0.4357
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8406,
+      "good": 5.5064,
+      "ratio": 0.9428,
+      "suggested_scalar": -0.0185,
+      "log_bad": 1.7648,
+      "log_good": 1.7059
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7626,
+      "good": 0.7624,
+      "ratio": 0.9997,
+      "suggested_scalar": -0.0001,
+      "log_bad": -0.271,
+      "log_good": -0.2713
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1167,
+      "good": 0.1579,
+      "ratio": 1.353,
+      "suggested_scalar": 0.0948,
+      "log_bad": -2.1481,
+      "log_good": -1.8458
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1046,
+      "good": 3.4976,
+      "ratio": 1.1266,
+      "suggested_scalar": 0.0374,
+      "log_bad": 1.1329,
+      "log_good": 1.2521
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 270.0,
+      "good": 209.0,
+      "ratio": 0.7741,
+      "suggested_scalar": -0.0803,
+      "log_bad": 5.5984,
+      "log_good": 5.3423
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6876,
+      "good": 0.4226,
+      "ratio": 0.6146,
+      "suggested_scalar": -0.1527,
+      "log_bad": -0.3745,
+      "log_good": -0.8613
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 98.0,
+      "good": 74.0,
+      "ratio": 0.7551,
+      "suggested_scalar": -0.0881,
+      "log_bad": 4.585,
+      "log_good": 4.3041
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 838.0,
+      "good": 591.0,
+      "ratio": 0.7053,
+      "suggested_scalar": -0.1095,
+      "log_bad": 6.731,
+      "log_good": 6.3818
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 166.0,
+      "good": 100.0,
+      "ratio": 0.6024,
+      "suggested_scalar": -0.1589,
+      "log_bad": 5.112,
+      "log_good": 4.6052
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0114,
+      "good": 0.0168,
+      "ratio": 1.4737,
+      "suggested_scalar": 0.1216,
+      "log_bad": -4.4741,
+      "log_good": -4.0864
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1453,
+      "good": 0.2269,
+      "ratio": 1.5616,
+      "suggested_scalar": 0.1398,
+      "log_bad": -1.929,
+      "log_good": -1.4832
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 63.0,
+      "good": 33.0,
+      "ratio": 0.5238,
+      "suggested_scalar": -0.2028,
+      "log_bad": 4.1431,
+      "log_good": 3.4965
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.07,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 98.0,
+      "good": 74.0,
+      "ratio": 0.7551,
+      "suggested_scalar": -0.0881,
+      "log_bad": 4.585,
+      "log_good": 4.3041
+    },
+    "brevity.mean_sample_size": {
+      "bad": 98.0,
+      "good": 74.0,
+      "ratio": 0.7551,
+      "suggested_scalar": -0.0881,
+      "log_bad": 4.585,
+      "log_good": 4.3041
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 351.0,
+      "good": 238.0,
+      "ratio": 0.6781,
+      "suggested_scalar": -0.1218,
+      "log_bad": 5.8608,
+      "log_good": 5.4723
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 164.0,
+      "good": 111.0,
+      "ratio": 0.6768,
+      "suggested_scalar": -0.1224,
+      "log_bad": 5.0999,
+      "log_good": 4.7095
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 221.0,
+      "good": 175.0,
+      "ratio": 0.7919,
+      "suggested_scalar": -0.0732,
+      "log_bad": 5.3982,
+      "log_good": 5.1648
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.5858,
+      "good": 1.3815,
+      "ratio": 0.8712,
+      "suggested_scalar": -0.0433,
+      "log_bad": 0.4611,
+      "log_good": 0.3232
+    },
+    "halstead.mean_effort": {
+      "bad": 57878.3922,
+      "good": 28939.2016,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2174,
+      "log_bad": 10.9661,
+      "log_good": 10.273
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.883,
+      "good": 0.8868,
+      "ratio": 1.0043,
+      "suggested_scalar": 0.0013,
+      "log_bad": -0.1244,
+      "log_good": -0.1201
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 71.0,
+      "good": 46.0,
+      "ratio": 0.6479,
+      "suggested_scalar": -0.1361,
+      "log_bad": 4.2627,
+      "log_good": 3.8286
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 148.0,
+      "good": 109.0,
+      "ratio": 0.7365,
+      "suggested_scalar": -0.0959,
+      "log_bad": 4.9972,
+      "log_good": 4.6913
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4844,
+      "good": 0.5412,
+      "ratio": 1.1173,
+      "suggested_scalar": 0.0348,
+      "log_bad": -0.7248,
+      "log_good": -0.614
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.5469,
+      "good": 6.9529,
+      "ratio": 1.062,
+      "suggested_scalar": 0.0189,
+      "log_bad": 1.879,
+      "log_good": 1.9392
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1167,
+      "good": 0.1579,
+      "ratio": 1.353,
+      "suggested_scalar": 0.0948,
+      "log_bad": -2.1481,
+      "log_good": -1.8458
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.3194,
+      "good": 3.2432,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0073,
+      "log_bad": 1.1998,
+      "log_good": 1.1766
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 350.0,
+      "good": 237.0,
+      "ratio": 0.6771,
+      "suggested_scalar": -0.1223,
+      "log_bad": 5.8579,
+      "log_good": 5.4681
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 55.0,
+      "good": 20.0,
+      "ratio": 0.3636,
+      "suggested_scalar": -0.3173,
+      "log_bad": 4.0073,
+      "log_good": 2.9957
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3215.4662,
+      "good": 1607.7334,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2174,
+      "log_bad": 8.0757,
+      "log_good": 7.3826
+    },
+    "readability.mean_total_lines": {
+      "bad": 53.0,
+      "good": 48.0,
+      "ratio": 0.9057,
+      "suggested_scalar": -0.0311,
+      "log_bad": 3.9703,
+      "log_good": 3.8712
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2062.9347,
+      "good": 1267.8126,
+      "ratio": 0.6146,
+      "suggested_scalar": -0.1527,
+      "log_bad": 7.6319,
+      "log_good": 7.145
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 642.0,
+      "good": 499.0,
+      "ratio": 0.7773,
+      "suggested_scalar": -0.079,
+      "log_bad": 6.4646,
+      "log_good": 6.2126
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.7547,
+      "good": 25.1667,
+      "ratio": 0.7925,
+      "suggested_scalar": -0.0729,
+      "log_bad": 3.458,
+      "log_good": 3.2255
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1229,
+      "good": 1.1732,
+      "ratio": 1.0448,
+      "suggested_scalar": 0.0137,
+      "log_bad": 0.1159,
+      "log_good": 0.1597
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 11.0,
+      "good": 3.0,
+      "ratio": 0.2727,
+      "suggested_scalar": -0.4075,
+      "log_bad": 2.3979,
+      "log_good": 1.0986
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 10.0,
+      "good": 1.0,
+      "ratio": 0.1,
+      "suggested_scalar": -0.7221,
+      "log_bad": 2.3026,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7963,
+      "good": 0.9043,
+      "ratio": 1.1356,
+      "suggested_scalar": 0.0399,
+      "log_bad": -0.2278,
+      "log_good": -0.1006
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9847,
+      "good": 0.9892,
+      "ratio": 1.0046,
+      "suggested_scalar": 0.0014,
+      "log_bad": -0.0154,
+      "log_good": -0.0109
+    },
+    "halstead.mean_length": {
+      "bad": 314.0,
+      "good": 209.0,
+      "ratio": 0.6656,
+      "suggested_scalar": -0.1277,
+      "log_bad": 5.7494,
+      "log_good": 5.3423
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.5,
+      "good": 6.8,
+      "ratio": 0.9067,
+      "suggested_scalar": -0.0307,
+      "log_bad": 2.0149,
+      "log_good": 1.9169
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6147,
+      "good": 6.2095,
+      "ratio": 0.9387,
+      "suggested_scalar": -0.0198,
+      "log_bad": 1.8893,
+      "log_good": 1.8261
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0941,
+      "good": 0.0877,
+      "ratio": 0.932,
+      "suggested_scalar": -0.0221,
+      "log_bad": -2.3634,
+      "log_good": -2.4338
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 28.0563,
+      "good": 22.8261,
+      "ratio": 0.8136,
+      "suggested_scalar": -0.0647,
+      "log_bad": 3.3342,
+      "log_good": 3.1279
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 6.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2174,
+      "log_bad": 1.0986,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 62.0,
+      "good": 46.0,
+      "ratio": 0.7419,
+      "suggested_scalar": -0.0936,
+      "log_bad": 4.1271,
+      "log_good": 3.8286
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7149,
+      "good": 0.8114,
+      "ratio": 1.135,
+      "suggested_scalar": 0.0397,
+      "log_bad": -0.3356,
+      "log_good": -0.209
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 53.0,
+      "good": 48.0,
+      "ratio": 0.9057,
+      "suggested_scalar": -0.0311,
+      "log_bad": 3.9703,
+      "log_good": 3.8712
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 21.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.1055,
+      "log_bad": 2.7081,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_finalize_override": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 8.0,
+      "good": 13.0,
+      "ratio": 1.625,
+      "suggested_scalar": 1.0678,
+      "log_bad": 2.0794,
+      "log_good": 2.5649
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0029,
+      "good": 0.0072,
+      "ratio": 2.4828,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.843,
+      "log_good": -4.9337
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.2857,
+      "good": 0.2857,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.2528,
+      "log_good": -1.2528
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8182,
+      "good": 0.7846,
+      "ratio": 0.9589,
+      "suggested_scalar": -0.0922,
+      "log_bad": -0.2006,
+      "log_good": -0.2426
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0029,
+      "good": 0.0072,
+      "ratio": 2.4828,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.843,
+      "log_good": -4.9337
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4983,
+      "good": 4.4716,
+      "ratio": 0.9941,
+      "suggested_scalar": -0.0131,
+      "log_bad": 1.5037,
+      "log_good": 1.4977
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 103.0,
+      "good": 116.0,
+      "ratio": 1.1262,
+      "suggested_scalar": 0.2614,
+      "log_bad": 4.6347,
+      "log_good": 4.7536
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5225,
+      "good": 0.5344,
+      "ratio": 1.0228,
+      "suggested_scalar": 0.0495,
+      "log_bad": -0.6491,
+      "log_good": -0.6266
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 19.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.1189,
+      "log_bad": 2.8904,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7816,
+      "good": 0.7808,
+      "ratio": 0.999,
+      "suggested_scalar": -0.0023,
+      "log_bad": -0.2464,
+      "log_good": -0.2474
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.2545,
+      "good": 6.6308,
+      "ratio": 1.0602,
+      "suggested_scalar": 0.1285,
+      "log_bad": 1.8333,
+      "log_good": 1.8917
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 347.0,
+      "good": 415.0,
+      "ratio": 1.196,
+      "suggested_scalar": 0.3936,
+      "log_bad": 5.8493,
+      "log_good": 6.0283
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0011,
+      "good": 0.0005,
+      "ratio": 0.4545,
+      "suggested_scalar": -1.7341,
+      "log_bad": -6.8124,
+      "log_good": -7.6009
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0909,
+      "good": 0.0923,
+      "ratio": 1.0154,
+      "suggested_scalar": 0.0336,
+      "log_bad": -2.398,
+      "log_good": -2.3827
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9105,
+      "good": 0.9222,
+      "ratio": 1.0129,
+      "suggested_scalar": 0.0281,
+      "log_bad": -0.0938,
+      "log_good": -0.081
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 111.0,
+      "good": 138.0,
+      "ratio": 1.2432,
+      "suggested_scalar": 0.4788,
+      "log_bad": 4.7095,
+      "log_good": 4.9273
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 108.4534,
+      "good": 106.8065,
+      "ratio": 0.9848,
+      "suggested_scalar": -0.0337,
+      "log_bad": 4.6863,
+      "log_good": 4.671
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4711,
+      "good": 0.4855,
+      "ratio": 1.0306,
+      "suggested_scalar": 0.0662,
+      "log_bad": -0.7527,
+      "log_good": -0.7226
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 14.9126,
+      "good": 16.2285,
+      "ratio": 1.0882,
+      "suggested_scalar": 0.186,
+      "log_bad": 2.7022,
+      "log_good": 2.7868
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1841.0,
+      "good": 2183.0,
+      "ratio": 1.1858,
+      "suggested_scalar": 0.3747,
+      "log_bad": 7.5181,
+      "log_good": 7.6885
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1273,
+      "good": 0.1846,
+      "ratio": 1.4501,
+      "suggested_scalar": 0.8174,
+      "log_bad": -2.0612,
+      "log_good": -1.6896
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7273,
+      "good": 0.7077,
+      "ratio": 0.9731,
+      "suggested_scalar": -0.0601,
+      "log_bad": -0.3184,
+      "log_good": -0.3457
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.3091,
+      "good": 6.3846,
+      "ratio": 1.012,
+      "suggested_scalar": 0.0262,
+      "log_bad": 1.842,
+      "log_good": 1.8539
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 17.6807,
+      "good": 21.8021,
+      "ratio": 1.2331,
+      "suggested_scalar": 0.4608,
+      "log_bad": 2.8725,
+      "log_good": 3.082
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 75.0,
+      "good": 88.0,
+      "ratio": 1.1733,
+      "suggested_scalar": 0.3516,
+      "log_bad": 4.3175,
+      "log_good": 4.4773
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9514,
+      "good": 0.9504,
+      "ratio": 0.9989,
+      "suggested_scalar": -0.0023,
+      "log_bad": -0.0498,
+      "log_good": -0.0509
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 31.0,
+      "good": 33.0,
+      "ratio": 1.0645,
+      "suggested_scalar": 0.1375,
+      "log_bad": 3.434,
+      "log_good": 3.4965
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6323,
+      "good": 0.6386,
+      "ratio": 1.01,
+      "suggested_scalar": 0.0218,
+      "log_bad": -0.4584,
+      "log_good": -0.4485
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2957,
+      "good": 0.3366,
+      "ratio": 1.1383,
+      "suggested_scalar": 0.2849,
+      "log_bad": -1.2184,
+      "log_good": -1.0889
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7194,
+      "good": 2.7668,
+      "ratio": 1.0174,
+      "suggested_scalar": 0.038,
+      "log_bad": 1.0004,
+      "log_good": 1.0177
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 345.0,
+      "good": 413.0,
+      "ratio": 1.1971,
+      "suggested_scalar": 0.3957,
+      "log_bad": 5.8435,
+      "log_good": 6.0234
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0,
+      "good": 6.0661,
+      "ratio": 1.011,
+      "suggested_scalar": 0.0241,
+      "log_bad": 1.7918,
+      "log_good": 1.8027
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 28.0,
+      "good": 37.0,
+      "ratio": 1.3214,
+      "suggested_scalar": 0.613,
+      "log_bad": 3.3322,
+      "log_good": 3.6109
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1569,
+      "good": 1.2441,
+      "ratio": 1.0754,
+      "suggested_scalar": 0.1598,
+      "log_bad": 0.1457,
+      "log_good": 0.2184
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7225,
+      "good": 5.8547,
+      "ratio": 1.0231,
+      "suggested_scalar": 0.0502,
+      "log_bad": 1.7444,
+      "log_good": 1.7672
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7497,
+      "good": 0.7371,
+      "ratio": 0.9832,
+      "suggested_scalar": -0.0373,
+      "log_bad": -0.2881,
+      "log_good": -0.305
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1791,
+      "good": 0.1558,
+      "ratio": 0.8699,
+      "suggested_scalar": -0.3065,
+      "log_bad": -1.7198,
+      "log_good": -1.8592
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.8617,
+      "good": 4.0285,
+      "ratio": 1.0432,
+      "suggested_scalar": 0.093,
+      "log_bad": 1.3511,
+      "log_good": 1.3934
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 277.0,
+      "good": 326.0,
+      "ratio": 1.1769,
+      "suggested_scalar": 0.3582,
+      "log_bad": 5.624,
+      "log_good": 5.7869
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 10.0,
+      "good": 14.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.74,
+      "log_bad": 2.3026,
+      "log_good": 2.6391
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7467,
+      "good": 0.9075,
+      "ratio": 1.2153,
+      "suggested_scalar": 0.4289,
+      "log_bad": -0.2921,
+      "log_good": -0.0971
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 108.0,
+      "good": 123.0,
+      "ratio": 1.1389,
+      "suggested_scalar": 0.286,
+      "log_bad": 4.6821,
+      "log_good": 4.8122
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 816.0,
+      "good": 974.0,
+      "ratio": 1.1936,
+      "suggested_scalar": 0.3893,
+      "log_bad": 6.7044,
+      "log_good": 6.8814
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 142.0,
+      "good": 166.0,
+      "ratio": 1.169,
+      "suggested_scalar": 0.3434,
+      "log_bad": 4.9558,
+      "log_good": 5.112
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2334,
+      "good": 0.2337,
+      "ratio": 1.0013,
+      "suggested_scalar": 0.0028,
+      "log_bad": -1.455,
+      "log_good": -1.4537
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 48.0,
+      "good": 60.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.4908,
+      "log_bad": 3.8712,
+      "log_good": 4.0943
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 108.0,
+      "good": 123.0,
+      "ratio": 1.1389,
+      "suggested_scalar": 0.286,
+      "log_bad": 4.6821,
+      "log_good": 4.8122
+    },
+    "brevity.mean_sample_size": {
+      "bad": 108.0,
+      "good": 123.0,
+      "ratio": 1.1389,
+      "suggested_scalar": 0.286,
+      "log_bad": 4.6821,
+      "log_good": 4.8122
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 347.0,
+      "good": 415.0,
+      "ratio": 1.196,
+      "suggested_scalar": 0.3936,
+      "log_bad": 5.8493,
+      "log_good": 6.0283
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 173.0,
+      "good": 205.0,
+      "ratio": 1.185,
+      "suggested_scalar": 0.3733,
+      "log_bad": 5.1533,
+      "log_good": 5.323
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 231.0,
+      "good": 273.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.3674,
+      "log_bad": 5.4424,
+      "log_good": 5.6095
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0806,
+      "good": 1.2078,
+      "ratio": 1.1177,
+      "suggested_scalar": 0.2447,
+      "log_bad": 0.0775,
+      "log_good": 0.1888
+    },
+    "halstead.mean_effort": {
+      "bad": 68474.8731,
+      "good": 89846.409,
+      "ratio": 1.3121,
+      "suggested_scalar": 0.5974,
+      "log_bad": 11.1342,
+      "log_good": 11.4059
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8472,
+      "good": 0.8433,
+      "ratio": 0.9954,
+      "suggested_scalar": -0.0101,
+      "log_bad": -0.1658,
+      "log_good": -0.1704
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 72.0,
+      "good": 83.0,
+      "ratio": 1.1528,
+      "suggested_scalar": 0.3127,
+      "log_bad": 4.2767,
+      "log_good": 4.4188
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 193.0,
+      "good": 231.0,
+      "ratio": 1.1969,
+      "suggested_scalar": 0.3953,
+      "log_bad": 5.2627,
+      "log_good": 5.4424
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5135,
+      "good": 0.5217,
+      "ratio": 1.016,
+      "suggested_scalar": 0.0348,
+      "log_bad": -0.6665,
+      "log_good": -0.6507
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.3514,
+      "good": 7.058,
+      "ratio": 0.9601,
+      "suggested_scalar": -0.0896,
+      "log_bad": 1.9949,
+      "log_good": 1.9542
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1791,
+      "good": 0.1558,
+      "ratio": 0.8699,
+      "suggested_scalar": -0.3065,
+      "log_bad": -1.7198,
+      "log_good": -1.8592
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.7562,
+      "good": 2.9385,
+      "ratio": 1.0661,
+      "suggested_scalar": 0.1409,
+      "log_bad": 1.0139,
+      "log_good": 1.0779
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 346.0,
+      "good": 414.0,
+      "ratio": 1.1965,
+      "suggested_scalar": 0.3946,
+      "log_bad": 5.8464,
+      "log_good": 6.0259
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 34.0,
+      "good": 52.0,
+      "ratio": 1.5294,
+      "suggested_scalar": 0.9345,
+      "log_bad": 3.5264,
+      "log_good": 3.9512
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3804.1596,
+      "good": 4991.4672,
+      "ratio": 1.3121,
+      "suggested_scalar": 0.5974,
+      "log_bad": 8.2439,
+      "log_good": 8.5155
+    },
+    "readability.mean_total_lines": {
+      "bad": 55.0,
+      "good": 65.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.3674,
+      "log_bad": 4.0073,
+      "log_good": 4.1744
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2239.9777,
+      "good": 2722.6185,
+      "ratio": 1.2155,
+      "suggested_scalar": 0.4292,
+      "log_bad": 7.7142,
+      "log_good": 7.9093
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 677.0,
+      "good": 789.0,
+      "ratio": 1.1654,
+      "suggested_scalar": 0.3367,
+      "log_bad": 6.5177,
+      "log_good": 6.6708
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.1818,
+      "good": 32.3692,
+      "ratio": 1.0058,
+      "suggested_scalar": 0.0128,
+      "log_bad": 3.4714,
+      "log_good": 3.4772
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0872,
+      "good": 1.1058,
+      "ratio": 1.0171,
+      "suggested_scalar": 0.0373,
+      "log_bad": 0.0836,
+      "log_good": 0.1006
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 35.0,
+      "good": 38.0,
+      "ratio": 1.0857,
+      "suggested_scalar": 0.1809,
+      "log_bad": 3.5553,
+      "log_good": 3.6376
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.401,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8773,
+      "good": 0.8405,
+      "ratio": 0.9581,
+      "suggested_scalar": -0.0942,
+      "log_bad": -0.1309,
+      "log_good": -0.1738
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9888,
+      "good": 0.9724,
+      "ratio": 0.9834,
+      "suggested_scalar": -0.0368,
+      "log_bad": -0.0113,
+      "log_good": -0.028
+    },
+    "halstead.mean_length": {
+      "bad": 335.0,
+      "good": 397.0,
+      "ratio": 1.1851,
+      "suggested_scalar": 0.3735,
+      "log_bad": 5.8141,
+      "log_good": 5.9839
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.0,
+      "good": 7.7143,
+      "ratio": 1.102,
+      "suggested_scalar": 0.2137,
+      "log_bad": 1.9459,
+      "log_good": 2.0431
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7549,
+      "good": 6.9425,
+      "ratio": 1.0278,
+      "suggested_scalar": 0.0602,
+      "log_bad": 1.9103,
+      "log_good": 1.9377
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0942,
+      "good": 0.094,
+      "ratio": 0.9979,
+      "suggested_scalar": -0.0047,
+      "log_bad": -2.3623,
+      "log_good": -2.3645
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.5694,
+      "good": 33.0,
+      "ratio": 1.0795,
+      "suggested_scalar": 0.1683,
+      "log_bad": 3.42,
+      "log_good": 3.4965
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 12.0,
+      "ratio": 1.7143,
+      "suggested_scalar": 1.1854,
+      "log_bad": 1.9459,
+      "log_good": 2.4849
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 57.0,
+      "good": 72.0,
+      "ratio": 1.2632,
+      "suggested_scalar": 0.5138,
+      "log_bad": 4.0431,
+      "log_good": 4.2767
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7922,
+      "good": 0.7802,
+      "ratio": 0.9849,
+      "suggested_scalar": -0.0336,
+      "log_bad": -0.2329,
+      "log_good": -0.2482
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 55.0,
+      "good": 65.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.3674,
+      "log_bad": 4.0073,
+      "log_good": 4.1744
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 21.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.339,
+      "log_bad": 2.8904,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "variable_naming.name_is_single_letter": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 18.0,
+      "good": 61.0,
+      "ratio": 3.3889,
+      "suggested_scalar": 2.0,
+      "log_bad": 2.8904,
+      "log_good": 4.1109
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 34.3333,
+      "good": 34.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5361,
+      "log_good": 3.5361
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0018,
+      "good": 0.0018,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.32,
+      "log_good": -6.32
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.35,
+      "good": 2.35,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.8544,
+      "log_good": 0.8544
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7926,
+      "good": 0.8415,
+      "ratio": 1.0617,
+      "suggested_scalar": 0.0981,
+      "log_bad": -0.2324,
+      "log_good": -0.1726
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0018,
+      "good": 0.0018,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.32,
+      "log_good": -6.32
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6226,
+      "good": 4.6957,
+      "ratio": 1.0158,
+      "suggested_scalar": 0.0257,
+      "log_bad": 1.531,
+      "log_good": 1.5466
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 79.3333,
+      "good": 93.0,
+      "ratio": 1.1723,
+      "suggested_scalar": 0.2605,
+      "log_bad": 4.3737,
+      "log_good": 4.5326
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.2597,
+      "good": 0.3654,
+      "ratio": 1.407,
+      "suggested_scalar": 0.5595,
+      "log_bad": -1.3482,
+      "log_good": -1.0068
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.6667,
+      "good": 18.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9267,
+      "log_good": 2.9267
+    },
+    "heaps.mean_beta": {
+      "bad": 0.4228,
+      "good": 0.4934,
+      "ratio": 1.167,
+      "suggested_scalar": 0.253,
+      "log_bad": -0.8609,
+      "log_good": -0.7064
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.7576,
+      "good": 2.8053,
+      "ratio": 1.0173,
+      "suggested_scalar": 0.0281,
+      "log_bad": 1.0144,
+      "log_good": 1.0315
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 553.0,
+      "good": 543.0,
+      "ratio": 0.9819,
+      "suggested_scalar": -0.0299,
+      "log_bad": 6.3154,
+      "log_good": 6.2971
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0223,
+      "good": 0.0214,
+      "ratio": 0.9596,
+      "suggested_scalar": -0.0675,
+      "log_bad": -3.8032,
+      "log_good": -3.8444
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0007,
+      "good": 0.0004,
+      "ratio": 0.5714,
+      "suggested_scalar": -0.917,
+      "log_bad": -7.2644,
+      "log_good": -7.824
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.264,
+      "good": 1.1078,
+      "ratio": 0.8764,
+      "suggested_scalar": -0.2161,
+      "log_bad": 0.2343,
+      "log_good": 0.1024
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 180.6667,
+      "good": 176.6667,
+      "ratio": 0.9779,
+      "suggested_scalar": -0.0367,
+      "log_bad": 5.1967,
+      "log_good": 5.1743
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 107.0166,
+      "good": 92.3228,
+      "ratio": 0.8627,
+      "suggested_scalar": -0.242,
+      "log_bad": 4.673,
+      "log_good": 4.5253
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7205,
+      "good": 0.6096,
+      "ratio": 0.8461,
+      "suggested_scalar": -0.2739,
+      "log_bad": -0.3278,
+      "log_good": -0.495
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 14.211,
+      "good": 14.9722,
+      "ratio": 1.0536,
+      "suggested_scalar": 0.0855,
+      "log_bad": 2.654,
+      "log_good": 2.7062
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1672.3333,
+      "good": 2457.6667,
+      "ratio": 1.4696,
+      "suggested_scalar": 0.6309,
+      "log_bad": 7.422,
+      "log_good": 7.807
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0653,
+      "good": 0.0635,
+      "ratio": 0.9724,
+      "suggested_scalar": -0.0458,
+      "log_bad": -2.7288,
+      "log_good": -2.7567
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7662,
+      "good": 0.8154,
+      "ratio": 1.0642,
+      "suggested_scalar": 0.102,
+      "log_bad": -0.2663,
+      "log_good": -0.2041
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.1428,
+      "good": 8.7202,
+      "ratio": 0.9538,
+      "suggested_scalar": -0.0775,
+      "log_bad": 2.213,
+      "log_good": 2.1656
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.4503,
+      "good": 2.5016,
+      "ratio": 1.0209,
+      "suggested_scalar": 0.034,
+      "log_bad": 0.8962,
+      "log_good": 0.9169
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 161.0,
+      "good": 142.6667,
+      "ratio": 0.8861,
+      "suggested_scalar": -0.1981,
+      "log_bad": 5.0814,
+      "log_good": 4.9605
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.8888,
+      "good": 0.9471,
+      "ratio": 1.0656,
+      "suggested_scalar": 0.1041,
+      "log_bad": -0.1179,
+      "log_good": -0.0544
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.3333,
+      "good": 27.6667,
+      "ratio": 0.9432,
+      "suggested_scalar": -0.0959,
+      "log_bad": 3.3787,
+      "log_good": 3.3202
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6202,
+      "good": 0.6831,
+      "ratio": 1.1014,
+      "suggested_scalar": 0.1583,
+      "log_bad": -0.4777,
+      "log_good": -0.3811
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5045,
+      "good": 0.4124,
+      "ratio": 0.8174,
+      "suggested_scalar": -0.3303,
+      "log_bad": -0.6842,
+      "log_good": -0.8858
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6469,
+      "good": 3.1568,
+      "ratio": 1.1926,
+      "suggested_scalar": 0.2887,
+      "log_bad": 0.9734,
+      "log_good": 1.1496
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 551.0,
+      "good": 541.0,
+      "ratio": 0.9819,
+      "suggested_scalar": -0.03,
+      "log_bad": 6.3117,
+      "log_good": 6.2934
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 10.3333,
+      "good": 10.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3354,
+      "log_good": 2.3354
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0104,
+      "good": 0.0106,
+      "ratio": 1.0192,
+      "suggested_scalar": 0.0312,
+      "log_bad": -4.5659,
+      "log_good": -4.5469
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8822,
+      "good": 5.9216,
+      "ratio": 1.0067,
+      "suggested_scalar": 0.0109,
+      "log_bad": 1.7719,
+      "log_good": 1.7786
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 13.3333,
+      "good": 13.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5903,
+      "log_good": 2.5903
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.5175,
+      "good": 0.6615,
+      "ratio": 1.2783,
+      "suggested_scalar": 0.4023,
+      "log_bad": -0.6587,
+      "log_good": -0.4132
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.2302,
+      "good": 5.5029,
+      "ratio": 1.0521,
+      "suggested_scalar": 0.0833,
+      "log_bad": 1.6544,
+      "log_good": 1.7053
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7858,
+      "good": 0.7929,
+      "ratio": 1.009,
+      "suggested_scalar": 0.0147,
+      "log_bad": -0.2411,
+      "log_good": -0.2321
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1404,
+      "good": 0.1369,
+      "ratio": 0.9751,
+      "suggested_scalar": -0.0414,
+      "log_bad": -1.9633,
+      "log_good": -1.9885
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.7679,
+      "good": 3.8687,
+      "ratio": 1.0268,
+      "suggested_scalar": 0.0433,
+      "log_bad": 1.3265,
+      "log_good": 1.3529
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 18.6667,
+      "good": 18.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9267,
+      "log_good": 2.9267
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 348.0,
+      "good": 375.3333,
+      "ratio": 1.0785,
+      "suggested_scalar": 0.1239,
+      "log_bad": 5.8522,
+      "log_good": 5.9278
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 13.3333,
+      "good": 13.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5903,
+      "log_good": 2.5903
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.1357,
+      "good": 1.1581,
+      "ratio": 1.0197,
+      "suggested_scalar": 0.032,
+      "log_bad": 0.1272,
+      "log_good": 0.1468
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 83.3333,
+      "good": 96.6667,
+      "ratio": 1.16,
+      "suggested_scalar": 0.2432,
+      "log_bad": 4.4228,
+      "log_good": 4.5713
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 636.6667,
+      "good": 1435.6667,
+      "ratio": 2.255,
+      "suggested_scalar": 1.3325,
+      "log_bad": 6.4562,
+      "log_good": 7.2694
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 218.3333,
+      "good": 215.6667,
+      "ratio": 0.9878,
+      "suggested_scalar": -0.0201,
+      "log_bad": 5.386,
+      "log_good": 5.3737
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0057,
+      "good": 0.0057,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.1673,
+      "log_good": -5.1673
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.209,
+      "good": 0.2049,
+      "ratio": 0.9804,
+      "suggested_scalar": -0.0325,
+      "log_bad": -1.5654,
+      "log_good": -1.5852
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 92.6667,
+      "good": 79.6667,
+      "ratio": 0.8597,
+      "suggested_scalar": -0.2477,
+      "log_bad": 4.529,
+      "log_good": 4.3779
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 9.3333,
+      "good": 9.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.2336,
+      "log_good": 2.2336
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 83.3333,
+      "good": 96.6667,
+      "ratio": 1.16,
+      "suggested_scalar": 0.2432,
+      "log_bad": 4.4228,
+      "log_good": 4.5713
+    },
+    "brevity.mean_sample_size": {
+      "bad": 83.3333,
+      "good": 96.6667,
+      "ratio": 1.16,
+      "suggested_scalar": 0.2432,
+      "log_bad": 4.4228,
+      "log_good": 4.5713
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 553.0,
+      "good": 543.0,
+      "ratio": 0.9819,
+      "suggested_scalar": -0.0299,
+      "log_bad": 6.3154,
+      "log_good": 6.2971
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 294.6667,
+      "good": 290.0,
+      "ratio": 0.9842,
+      "suggested_scalar": -0.0262,
+      "log_bad": 5.6858,
+      "log_good": 5.6699
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 244.6667,
+      "good": 288.3333,
+      "ratio": 1.1785,
+      "suggested_scalar": 0.2691,
+      "log_bad": 5.4999,
+      "log_good": 5.6641
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0319,
+      "good": 0.0325,
+      "ratio": 1.0188,
+      "suggested_scalar": 0.0305,
+      "log_bad": -3.4451,
+      "log_good": -3.4265
+    },
+    "heaps.mean_k": {
+      "bad": 6.1722,
+      "good": 4.5565,
+      "ratio": 0.7382,
+      "suggested_scalar": -0.4973,
+      "log_bad": 1.8201,
+      "log_good": 1.5166
+    },
+    "halstead.mean_effort": {
+      "bad": 217892.8959,
+      "good": 159429.2861,
+      "ratio": 0.7317,
+      "suggested_scalar": -0.5119,
+      "log_bad": 12.2918,
+      "log_good": 11.9794
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.82,
+      "good": 0.8344,
+      "ratio": 1.0176,
+      "suggested_scalar": 0.0285,
+      "log_bad": -0.1985,
+      "log_good": -0.181
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 50.0,
+      "good": 65.3333,
+      "ratio": 1.3067,
+      "suggested_scalar": 0.4383,
+      "log_bad": 3.912,
+      "log_good": 4.1795
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 321.6667,
+      "good": 315.6667,
+      "ratio": 0.9813,
+      "suggested_scalar": -0.0309,
+      "log_bad": 5.7735,
+      "log_good": 5.7547
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.2554,
+      "good": 0.3468,
+      "ratio": 1.3579,
+      "suggested_scalar": 0.5013,
+      "log_bad": -1.3649,
+      "log_good": -1.059
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 3.5063,
+      "good": 8.1439,
+      "ratio": 2.3226,
+      "suggested_scalar": 1.3809,
+      "log_bad": 1.2546,
+      "log_good": 2.0973
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1404,
+      "good": 0.1369,
+      "ratio": 0.9751,
+      "suggested_scalar": -0.0414,
+      "log_bad": -1.9633,
+      "log_good": -1.9885
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.9473,
+      "good": 3.7854,
+      "ratio": 0.959,
+      "suggested_scalar": -0.0686,
+      "log_bad": 1.373,
+      "log_good": 1.3312
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 552.0,
+      "good": 542.0,
+      "ratio": 0.9819,
+      "suggested_scalar": -0.03,
+      "log_bad": 6.3135,
+      "log_good": 6.2953
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 0.3333,
+      "good": 0.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.0987,
+      "log_good": -1.0987
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 78.0,
+      "good": 60.0,
+      "ratio": 0.7692,
+      "suggested_scalar": -0.4299,
+      "log_bad": 4.3567,
+      "log_good": 4.0943
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 12105.1609,
+      "good": 8857.1826,
+      "ratio": 0.7317,
+      "suggested_scalar": -0.5119,
+      "log_bad": 9.4014,
+      "log_good": 9.089
+    },
+    "readability.mean_total_lines": {
+      "bad": 60.6667,
+      "good": 62.3333,
+      "ratio": 1.0275,
+      "suggested_scalar": 0.0444,
+      "log_bad": 4.1054,
+      "log_good": 4.1325
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 3406.9817,
+      "good": 3474.2881,
+      "ratio": 1.0198,
+      "suggested_scalar": 0.0321,
+      "log_bad": 8.1336,
+      "log_good": 8.1531
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 629.3333,
+      "good": 778.0,
+      "ratio": 1.2362,
+      "suggested_scalar": 0.3475,
+      "log_bad": 6.4447,
+      "log_good": 6.6567
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 25.6166,
+      "good": 37.501,
+      "ratio": 1.4639,
+      "suggested_scalar": 0.6245,
+      "log_bad": 3.2432,
+      "log_good": 3.6244
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0702,
+      "good": 1.2489,
+      "ratio": 1.167,
+      "suggested_scalar": 0.253,
+      "log_bad": 0.0678,
+      "log_good": 0.2223
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 26.3333,
+      "good": 26.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2708,
+      "log_good": 3.2708
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7774,
+      "good": 0.8408,
+      "ratio": 1.0816,
+      "suggested_scalar": 0.1285,
+      "log_bad": -0.2518,
+      "log_good": -0.1734
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9185,
+      "good": 0.9542,
+      "ratio": 1.0389,
+      "suggested_scalar": 0.0625,
+      "log_bad": -0.085,
+      "log_good": -0.0469
+    },
+    "halstead.mean_length": {
+      "bad": 540.0,
+      "good": 531.3333,
+      "ratio": 0.984,
+      "suggested_scalar": -0.0265,
+      "log_bad": 6.2916,
+      "log_good": 6.2754
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.2083,
+      "good": 7.375,
+      "ratio": 1.0231,
+      "suggested_scalar": 0.0375,
+      "log_bad": 1.9752,
+      "log_good": 1.9981
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.379,
+      "good": 6.5948,
+      "ratio": 1.0338,
+      "suggested_scalar": 0.0545,
+      "log_bad": 1.853,
+      "log_good": 1.8863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1755,
+      "good": 0.1173,
+      "ratio": 0.6684,
+      "suggested_scalar": -0.6602,
+      "log_bad": -1.7401,
+      "log_good": -2.143
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 63.6677,
+      "good": 45.6129,
+      "ratio": 0.7164,
+      "suggested_scalar": -0.5465,
+      "log_bad": 4.1537,
+      "log_good": 3.8202
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 46.0,
+      "good": 61.0,
+      "ratio": 1.3261,
+      "suggested_scalar": 0.4625,
+      "log_bad": 3.8286,
+      "log_good": 4.1109
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6221,
+      "good": 0.7236,
+      "ratio": 1.1632,
+      "suggested_scalar": 0.2477,
+      "log_bad": -0.4747,
+      "log_good": -0.3235
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 61.3333,
+      "good": 63.0,
+      "ratio": 1.0272,
+      "suggested_scalar": 0.0439,
+      "log_bad": 4.1163,
+      "log_good": 4.1431
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 5.3333,
+      "good": 5.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.674,
+      "log_good": 1.674
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.6667,
+      "good": 18.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9267,
+      "log_good": 2.9267
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.does_not_declare_unused_mut": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 10.0,
+      "good": 8.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1097,
+      "log_bad": 2.3026,
+      "log_good": 2.0794
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.2,
+      "good": 1.4,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.0758,
+      "log_bad": 0.1823,
+      "log_good": 0.3365
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7778,
+      "good": 0.7857,
+      "ratio": 1.0102,
+      "suggested_scalar": 0.005,
+      "log_bad": -0.2513,
+      "log_good": -0.2412
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7532,
+      "good": 4.63,
+      "ratio": 0.9741,
+      "suggested_scalar": -0.0129,
+      "log_bad": 1.5588,
+      "log_good": 1.5326
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 97.0,
+      "good": 88.0,
+      "ratio": 0.9072,
+      "suggested_scalar": -0.0479,
+      "log_bad": 4.5747,
+      "log_good": 4.4773
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4567,
+      "good": 0.4167,
+      "ratio": 0.9124,
+      "suggested_scalar": -0.0451,
+      "log_bad": -0.7837,
+      "log_good": -0.8754
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 21.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.024,
+      "log_bad": 2.9957,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6907,
+      "good": 0.6698,
+      "ratio": 0.9697,
+      "suggested_scalar": -0.0151,
+      "log_bad": -0.37,
+      "log_good": -0.4008
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.3778,
+      "good": 4.0,
+      "ratio": 1.1842,
+      "suggested_scalar": 0.0831,
+      "log_bad": 1.2172,
+      "log_good": 1.3863
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 365.0,
+      "good": 341.0,
+      "ratio": 0.9342,
+      "suggested_scalar": -0.0334,
+      "log_bad": 5.8999,
+      "log_good": 5.8319
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1111,
+      "good": 0.0952,
+      "ratio": 0.8569,
+      "suggested_scalar": -0.0759,
+      "log_bad": -2.1973,
+      "log_good": -2.3518
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9425,
+      "good": 0.9331,
+      "ratio": 0.99,
+      "suggested_scalar": -0.0049,
+      "log_bad": -0.0592,
+      "log_good": -0.0692
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 117.0,
+      "good": 105.0,
+      "ratio": 0.8974,
+      "suggested_scalar": -0.0532,
+      "log_bad": 4.7622,
+      "log_good": 4.654
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 112.1829,
+      "good": 112.4371,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0011,
+      "log_bad": 4.7201,
+      "log_good": 4.7224
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5137,
+      "good": 0.5206,
+      "ratio": 1.0134,
+      "suggested_scalar": 0.0066,
+      "log_bad": -0.6661,
+      "log_good": -0.6528
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 6.8575,
+      "good": 4.1292,
+      "ratio": 0.6021,
+      "suggested_scalar": -0.2493,
+      "log_bad": 1.9253,
+      "log_good": 1.4181
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1385.0,
+      "good": 1209.0,
+      "ratio": 0.8729,
+      "suggested_scalar": -0.0668,
+      "log_bad": 7.2335,
+      "log_good": 7.0975
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1556,
+      "good": 0.0952,
+      "ratio": 0.6118,
+      "suggested_scalar": -0.2415,
+      "log_bad": -1.8605,
+      "log_good": -2.3518
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7556,
+      "good": 0.7619,
+      "ratio": 1.0083,
+      "suggested_scalar": 0.0041,
+      "log_bad": -0.2802,
+      "log_good": -0.2719
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.1111,
+      "good": 8.119,
+      "ratio": 1.001,
+      "suggested_scalar": 0.0005,
+      "log_bad": 2.0932,
+      "log_good": 2.0942
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 10.0,
+      "good": 6.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.2511,
+      "log_bad": 2.3026,
+      "log_good": 1.7918
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 7.0795,
+      "good": 7.619,
+      "ratio": 1.0762,
+      "suggested_scalar": 0.0361,
+      "log_bad": 1.9572,
+      "log_good": 2.0306
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 82.0,
+      "good": 72.0,
+      "ratio": 0.878,
+      "suggested_scalar": -0.0639,
+      "log_bad": 4.4067,
+      "log_good": 4.2767
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9178,
+      "good": 0.9048,
+      "ratio": 0.9858,
+      "suggested_scalar": -0.007,
+      "log_bad": -0.0858,
+      "log_good": -0.1
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 34.0,
+      "good": 34.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5264,
+      "log_good": 3.5264
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.556,
+      "good": 0.5608,
+      "ratio": 1.0086,
+      "suggested_scalar": 0.0042,
+      "log_bad": -0.587,
+      "log_good": -0.5784
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2397,
+      "good": 0.2743,
+      "ratio": 1.1443,
+      "suggested_scalar": 0.0663,
+      "log_bad": -1.4284,
+      "log_good": -1.2935
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.252,
+      "good": 2.2768,
+      "ratio": 1.011,
+      "suggested_scalar": 0.0054,
+      "log_bad": 0.8118,
+      "log_good": 0.8228
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 363.0,
+      "good": 339.0,
+      "ratio": 0.9339,
+      "suggested_scalar": -0.0336,
+      "log_bad": 5.8944,
+      "log_good": 5.826
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 17.0,
+      "good": 13.0,
+      "ratio": 0.7647,
+      "suggested_scalar": -0.1319,
+      "log_bad": 2.8332,
+      "log_good": 2.5649
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0521,
+      "good": 0.0381,
+      "ratio": 0.7313,
+      "suggested_scalar": -0.1538,
+      "log_bad": -2.9546,
+      "log_good": -3.2675
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0444,
+      "good": 5.9069,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.0113,
+      "log_bad": 1.7991,
+      "log_good": 1.7761
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 23.0,
+      "good": 27.0,
+      "ratio": 1.1739,
+      "suggested_scalar": 0.0788,
+      "log_bad": 3.1355,
+      "log_good": 3.2958
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2244,
+      "good": 1.113,
+      "ratio": 0.909,
+      "suggested_scalar": -0.0469,
+      "log_bad": 0.2025,
+      "log_good": 0.1071
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0171,
+      "good": 1.0,
+      "ratio": 58.4795,
+      "suggested_scalar": 2.0,
+      "log_bad": -4.0687,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8995,
+      "good": 5.8235,
+      "ratio": 0.9871,
+      "suggested_scalar": -0.0064,
+      "log_bad": 1.7749,
+      "log_good": 1.7619
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7864,
+      "good": 0.7838,
+      "ratio": 0.9967,
+      "suggested_scalar": -0.0016,
+      "log_bad": -0.2403,
+      "log_good": -0.2436
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1509,
+      "good": 0.125,
+      "ratio": 0.8284,
+      "suggested_scalar": -0.0926,
+      "log_bad": -1.8911,
+      "log_good": -2.0794
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.6187,
+      "good": 2.032,
+      "ratio": 0.776,
+      "suggested_scalar": -0.1247,
+      "log_bad": 0.9627,
+      "log_good": 0.709
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 311.0,
+      "good": 285.0,
+      "ratio": 0.9164,
+      "suggested_scalar": -0.0429,
+      "log_bad": 5.7398,
+      "log_good": 5.6525
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0896,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7832,
+      "good": 0.7062,
+      "ratio": 0.9017,
+      "suggested_scalar": -0.0509,
+      "log_bad": -0.2444,
+      "log_good": -0.3479
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 96.0,
+      "good": 88.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0428,
+      "log_bad": 4.5643,
+      "log_good": 4.4773
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 599.0,
+      "good": 464.0,
+      "ratio": 0.7746,
+      "suggested_scalar": -0.1255,
+      "log_bad": 6.3953,
+      "log_good": 6.1399
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 150.0,
+      "good": 132.0,
+      "ratio": 0.88,
+      "suggested_scalar": -0.0628,
+      "log_bad": 5.0106,
+      "log_good": 4.8828
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0137,
+      "good": 0.0176,
+      "ratio": 1.2847,
+      "suggested_scalar": 0.1231,
+      "log_bad": -4.2904,
+      "log_good": -4.0399
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2082,
+      "good": 0.217,
+      "ratio": 1.0423,
+      "suggested_scalar": 0.0203,
+      "log_bad": -1.5693,
+      "log_good": -1.5279
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 69.0,
+      "good": 66.0,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.0219,
+      "log_bad": 4.2341,
+      "log_good": 4.1897
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 96.0,
+      "good": 88.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0428,
+      "log_bad": 4.5643,
+      "log_good": 4.4773
+    },
+    "brevity.mean_sample_size": {
+      "bad": 96.0,
+      "good": 88.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0428,
+      "log_bad": 4.5643,
+      "log_good": 4.4773
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 365.0,
+      "good": 341.0,
+      "ratio": 0.9342,
+      "suggested_scalar": -0.0334,
+      "log_bad": 5.8999,
+      "log_good": 5.8319
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 177.0,
+      "good": 173.0,
+      "ratio": 0.9774,
+      "suggested_scalar": -0.0112,
+      "log_bad": 5.1761,
+      "log_good": 5.1533
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 246.0,
+      "good": 229.0,
+      "ratio": 0.9309,
+      "suggested_scalar": -0.0352,
+      "log_bad": 5.5053,
+      "log_good": 5.4337
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0027,
+      "good": 0.0029,
+      "ratio": 1.0741,
+      "suggested_scalar": 0.0351,
+      "log_bad": -5.9145,
+      "log_good": -5.843
+    },
+    "heaps.mean_k": {
+      "bad": 1.7311,
+      "good": 1.8631,
+      "ratio": 1.0763,
+      "suggested_scalar": 0.0361,
+      "log_bad": 0.5488,
+      "log_good": 0.6222
+    },
+    "halstead.mean_effort": {
+      "bad": 95101.6012,
+      "good": 88043.4884,
+      "ratio": 0.9258,
+      "suggested_scalar": -0.0379,
+      "log_bad": 11.4627,
+      "log_good": 11.3856
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8959,
+      "good": 0.9015,
+      "ratio": 1.0063,
+      "suggested_scalar": 0.0031,
+      "log_bad": -0.1099,
+      "log_good": -0.1037
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 63.0,
+      "good": 54.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0758,
+      "log_bad": 4.1431,
+      "log_good": 3.989
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 206.0,
+      "good": 196.0,
+      "ratio": 0.9515,
+      "suggested_scalar": -0.0245,
+      "log_bad": 5.3279,
+      "log_good": 5.2781
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4444,
+      "good": 0.4095,
+      "ratio": 0.9215,
+      "suggested_scalar": -0.0402,
+      "log_bad": -0.811,
+      "log_good": -0.8928
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.1197,
+      "good": 4.419,
+      "ratio": 0.8631,
+      "suggested_scalar": -0.0723,
+      "log_bad": 1.6331,
+      "log_good": 1.4859
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1509,
+      "good": 0.125,
+      "ratio": 0.8284,
+      "suggested_scalar": -0.0926,
+      "log_bad": -1.8911,
+      "log_good": -2.0794
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.2444,
+      "good": 3.2476,
+      "ratio": 1.001,
+      "suggested_scalar": 0.0005,
+      "log_bad": 1.1769,
+      "log_good": 1.1779
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 364.0,
+      "good": 340.0,
+      "ratio": 0.9341,
+      "suggested_scalar": -0.0335,
+      "log_bad": 5.8972,
+      "log_good": 5.8289
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.3407,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 35.0,
+      "good": 39.0,
+      "ratio": 1.1143,
+      "suggested_scalar": 0.0532,
+      "log_bad": 3.5553,
+      "log_good": 3.6636
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5283.4223,
+      "good": 4891.3049,
+      "ratio": 0.9258,
+      "suggested_scalar": -0.0379,
+      "log_bad": 8.5723,
+      "log_good": 8.4952
+    },
+    "readability.mean_total_lines": {
+      "bad": 45.0,
+      "good": 42.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0339,
+      "log_bad": 3.8067,
+      "log_good": 3.7377
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2349.569,
+      "good": 2118.6936,
+      "ratio": 0.9017,
+      "suggested_scalar": -0.0508,
+      "log_bad": 7.762,
+      "log_good": 7.6586
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 615.0,
+      "good": 531.0,
+      "ratio": 0.8634,
+      "suggested_scalar": -0.0722,
+      "log_bad": 6.4216,
+      "log_good": 6.2748
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 29.5111,
+      "good": 27.5476,
+      "ratio": 0.9335,
+      "suggested_scalar": -0.0338,
+      "log_bad": 3.3848,
+      "log_good": 3.3159
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0215,
+      "good": 1.0184,
+      "ratio": 0.997,
+      "suggested_scalar": -0.0015,
+      "log_bad": 0.0213,
+      "log_good": 0.0182
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 14.0,
+      "good": 12.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0758,
+      "log_bad": 2.6391,
+      "log_good": 2.4849
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1097,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8875,
+      "good": 0.8632,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.0136,
+      "log_bad": -0.1193,
+      "log_good": -0.1471
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9943,
+      "good": 0.9894,
+      "ratio": 0.9951,
+      "suggested_scalar": -0.0024,
+      "log_bad": -0.0057,
+      "log_good": -0.0107
+    },
+    "halstead.mean_length": {
+      "bad": 356.0,
+      "good": 328.0,
+      "ratio": 0.9213,
+      "suggested_scalar": -0.0403,
+      "log_bad": 5.8749,
+      "log_good": 5.793
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 8.4,
+      "good": 7.4,
+      "ratio": 0.881,
+      "suggested_scalar": -0.0623,
+      "log_bad": 2.1282,
+      "log_good": 2.0015
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.585,
+      "good": 6.4594,
+      "ratio": 0.9809,
+      "suggested_scalar": -0.0095,
+      "log_bad": 1.8848,
+      "log_good": 1.8655
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1282,
+      "good": 0.1436,
+      "ratio": 1.1201,
+      "suggested_scalar": 0.0558,
+      "log_bad": -2.0542,
+      "log_good": -1.9407
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 40.4762,
+      "good": 41.5556,
+      "ratio": 1.0267,
+      "suggested_scalar": 0.0129,
+      "log_bad": 3.7007,
+      "log_good": 3.727
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 4.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -0.2751,
+      "log_bad": 1.9459,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 52.0,
+      "good": 43.0,
+      "ratio": 0.8269,
+      "suggested_scalar": -0.0934,
+      "log_bad": 3.9512,
+      "log_good": 3.7612
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7195,
+      "good": 0.7118,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.0053,
+      "log_bad": -0.3292,
+      "log_good": -0.34
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 45.0,
+      "good": 42.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0339,
+      "log_bad": 3.8067,
+      "log_good": 3.7377
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 9.0,
+      "ratio": 0.6429,
+      "suggested_scalar": -0.2172,
+      "log_bad": 2.6391,
+      "log_good": 2.1972
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.3407,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.catches_typed_exception": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.async_method_has_await": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.1824,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0085,
+      "good": 0.0088,
+      "ratio": 1.0353,
+      "suggested_scalar": 0.0091,
+      "log_bad": -4.7677,
+      "log_good": -4.733
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.6,
+      "good": 0.5,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.048,
+      "log_bad": -0.5108,
+      "log_good": -0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8,
+      "good": 0.84,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0128,
+      "log_bad": -0.2231,
+      "log_good": -0.1744
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0085,
+      "good": 0.0088,
+      "ratio": 1.0353,
+      "suggested_scalar": 0.0091,
+      "log_bad": -4.7677,
+      "log_good": -4.733
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4995,
+      "good": 4.5148,
+      "ratio": 1.0034,
+      "suggested_scalar": 0.0009,
+      "log_bad": 1.504,
+      "log_good": 1.5074
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 125.0,
+      "good": 99.0,
+      "ratio": 0.792,
+      "suggested_scalar": -0.0614,
+      "log_bad": 4.8283,
+      "log_good": 4.5951
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.7431,
+      "good": 0.5946,
+      "ratio": 0.8002,
+      "suggested_scalar": -0.0587,
+      "log_bad": -0.2969,
+      "log_good": -0.5199
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 17.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.015,
+      "log_bad": 2.8904,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.8706,
+      "good": 0.8049,
+      "ratio": 0.9245,
+      "suggested_scalar": -0.0206,
+      "log_bad": -0.1386,
+      "log_good": -0.217
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 8.08,
+      "good": 8.72,
+      "ratio": 1.0792,
+      "suggested_scalar": 0.0201,
+      "log_bad": 2.0894,
+      "log_good": 2.1656
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 353.0,
+      "good": 339.0,
+      "ratio": 0.9603,
+      "suggested_scalar": -0.0106,
+      "log_bad": 5.8665,
+      "log_good": 5.826
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0587,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 0.0005,
+      "ratio": 0.0005,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -7.6009
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1,
+      "good": 0.06,
+      "ratio": 0.6,
+      "suggested_scalar": -0.1344,
+      "log_bad": -2.3026,
+      "log_good": -2.8134
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0005,
+      "good": 0.0005,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.6009,
+      "log_good": -7.6009
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8232,
+      "good": 0.9136,
+      "ratio": 1.1098,
+      "suggested_scalar": 0.0274,
+      "log_bad": -0.1946,
+      "log_good": -0.0904
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 144.0,
+      "good": 125.0,
+      "ratio": 0.8681,
+      "suggested_scalar": -0.0372,
+      "log_bad": 4.9698,
+      "log_good": 4.8283
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 96.4571,
+      "good": 86.9931,
+      "ratio": 0.9019,
+      "suggested_scalar": -0.0272,
+      "log_bad": 4.5691,
+      "log_good": 4.4658
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.3523,
+      "good": 0.5059,
+      "ratio": 1.436,
+      "suggested_scalar": 0.0952,
+      "log_bad": -1.0433,
+      "log_good": -0.6814
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 14.523,
+      "good": 16.4458,
+      "ratio": 1.1324,
+      "suggested_scalar": 0.0327,
+      "log_bad": 2.6757,
+      "log_good": 2.8001
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2074.0,
+      "good": 2051.0,
+      "ratio": 0.9889,
+      "suggested_scalar": -0.0029,
+      "log_bad": 7.6372,
+      "log_good": 7.6261
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.06,
+      "good": 0.02,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.2891,
+      "log_bad": -2.8134,
+      "log_good": -3.912
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.72,
+      "good": 0.76,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.0142,
+      "log_bad": -0.3285,
+      "log_good": -0.2744
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.06,
+      "good": 6.78,
+      "ratio": 0.9603,
+      "suggested_scalar": -0.0106,
+      "log_bad": 1.9544,
+      "log_good": 1.914
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 9.0,
+      "good": 10.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0277,
+      "log_bad": 2.1972,
+      "log_good": 2.3026
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 16.9536,
+      "good": 19.6416,
+      "ratio": 1.1586,
+      "suggested_scalar": 0.0387,
+      "log_bad": 2.8305,
+      "log_good": 2.9776
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 74.0,
+      "good": 41.0,
+      "ratio": 0.5541,
+      "suggested_scalar": -0.1554,
+      "log_bad": 4.3041,
+      "log_good": 3.7136
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9443,
+      "good": 0.947,
+      "ratio": 1.0029,
+      "suggested_scalar": 0.0008,
+      "log_bad": -0.0573,
+      "log_good": -0.0545
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6119,
+      "good": 0.6611,
+      "ratio": 1.0804,
+      "suggested_scalar": 0.0203,
+      "log_bad": -0.4912,
+      "log_good": -0.4139
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.1852,
+      "good": 0.3234,
+      "ratio": 1.7462,
+      "suggested_scalar": 0.1467,
+      "log_bad": -1.6863,
+      "log_good": -1.1289
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5764,
+      "good": 2.9511,
+      "ratio": 1.1454,
+      "suggested_scalar": 0.0357,
+      "log_bad": 0.9464,
+      "log_good": 1.0822
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 351.0,
+      "good": 337.0,
+      "ratio": 0.9601,
+      "suggested_scalar": -0.0107,
+      "log_bad": 5.8608,
+      "log_good": 5.8201
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0182,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0057,
+      "good": 1.0,
+      "ratio": 175.4386,
+      "suggested_scalar": 1.3597,
+      "log_bad": -5.1673,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0875,
+      "good": 6.1293,
+      "ratio": 1.0069,
+      "suggested_scalar": 0.0018,
+      "log_bad": 1.8062,
+      "log_good": 1.8131
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 57.0,
+      "good": 70.0,
+      "ratio": 1.2281,
+      "suggested_scalar": 0.0541,
+      "log_bad": 4.0431,
+      "log_good": 4.2485
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4164,
+      "good": 1.4464,
+      "ratio": 1.0212,
+      "suggested_scalar": 0.0055,
+      "log_bad": 0.3481,
+      "log_good": 0.3691
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.2354,
+      "good": 5.8368,
+      "ratio": 0.9361,
+      "suggested_scalar": -0.0174,
+      "log_bad": 1.8302,
+      "log_good": 1.7642
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7391,
+      "good": 0.7366,
+      "ratio": 0.9966,
+      "suggested_scalar": -0.0009,
+      "log_bad": -0.3023,
+      "log_good": -0.3057
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1525,
+      "good": 0.1525,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.8806,
+      "log_good": -1.8806
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.8109,
+      "good": 4.0553,
+      "ratio": 1.0641,
+      "suggested_scalar": 0.0164,
+      "log_bad": 1.3379,
+      "log_good": 1.4
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 311.0,
+      "good": 271.0,
+      "ratio": 0.8714,
+      "suggested_scalar": -0.0362,
+      "log_bad": 5.7398,
+      "log_good": 5.6021
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 10.0,
+      "good": 13.0,
+      "ratio": 1.3,
+      "suggested_scalar": 0.069,
+      "log_bad": 2.3026,
+      "log_good": 2.5649
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7802,
+      "good": 0.727,
+      "ratio": 0.9318,
+      "suggested_scalar": -0.0186,
+      "log_bad": -0.2482,
+      "log_good": -0.3188
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 131.0,
+      "good": 102.0,
+      "ratio": 0.7786,
+      "suggested_scalar": -0.0658,
+      "log_bad": 4.8752,
+      "log_good": 4.625
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1018.0,
+      "good": 1028.0,
+      "ratio": 1.0098,
+      "suggested_scalar": 0.0026,
+      "log_bad": 6.9256,
+      "log_good": 6.9354
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 165.0,
+      "good": 147.0,
+      "ratio": 0.8909,
+      "suggested_scalar": -0.0304,
+      "log_bad": 5.1059,
+      "log_good": 4.9904
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2295,
+      "good": 0.2684,
+      "ratio": 1.1695,
+      "suggested_scalar": 0.0412,
+      "log_bad": -1.4719,
+      "log_good": -1.3153
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 42.0,
+      "good": 57.0,
+      "ratio": 1.3571,
+      "suggested_scalar": 0.0804,
+      "log_bad": 3.7377,
+      "log_good": 4.0431
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0587,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 131.0,
+      "good": 102.0,
+      "ratio": 0.7786,
+      "suggested_scalar": -0.0658,
+      "log_bad": 4.8752,
+      "log_good": 4.625
+    },
+    "brevity.mean_sample_size": {
+      "bad": 131.0,
+      "good": 102.0,
+      "ratio": 0.7786,
+      "suggested_scalar": -0.0658,
+      "log_bad": 4.8752,
+      "log_good": 4.625
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 353.0,
+      "good": 339.0,
+      "ratio": 0.9603,
+      "suggested_scalar": -0.0106,
+      "log_bad": 5.8665,
+      "log_good": 5.826
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 153.0,
+      "good": 163.0,
+      "ratio": 1.0654,
+      "suggested_scalar": 0.0167,
+      "log_bad": 5.0304,
+      "log_good": 5.0938
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 270.0,
+      "good": 224.0,
+      "ratio": 0.8296,
+      "suggested_scalar": -0.0491,
+      "log_bad": 5.5984,
+      "log_good": 5.4116
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 0.8755,
+      "good": 1.0832,
+      "ratio": 1.2372,
+      "suggested_scalar": 0.056,
+      "log_bad": -0.133,
+      "log_good": 0.0799
+    },
+    "halstead.mean_effort": {
+      "bad": 45883.1383,
+      "good": 51298.4919,
+      "ratio": 1.118,
+      "suggested_scalar": 0.0294,
+      "log_bad": 10.7339,
+      "log_good": 10.8454
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8865,
+      "good": 0.8748,
+      "ratio": 0.9868,
+      "suggested_scalar": -0.0035,
+      "log_bad": -0.1205,
+      "log_good": -0.1338
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 101.0,
+      "good": 75.0,
+      "ratio": 0.7426,
+      "suggested_scalar": -0.0783,
+      "log_bad": 4.6151,
+      "log_good": 4.3175
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 171.0,
+      "good": 182.0,
+      "ratio": 1.0643,
+      "suggested_scalar": 0.0164,
+      "log_bad": 5.1417,
+      "log_good": 5.204
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.6597,
+      "good": 0.552,
+      "ratio": 0.8367,
+      "suggested_scalar": -0.0469,
+      "log_bad": -0.416,
+      "log_good": -0.5942
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.0694,
+      "good": 8.224,
+      "ratio": 1.1633,
+      "suggested_scalar": 0.0398,
+      "log_bad": 1.9558,
+      "log_good": 2.1071
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1525,
+      "good": 0.1525,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.8806,
+      "log_good": -1.8806
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.824,
+      "good": 4.5302,
+      "ratio": 1.1847,
+      "suggested_scalar": 0.0446,
+      "log_bad": 1.3413,
+      "log_good": 1.5108
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 352.0,
+      "good": 338.0,
+      "ratio": 0.9602,
+      "suggested_scalar": -0.0107,
+      "log_bad": 5.8636,
+      "log_good": 5.823
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1824,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 25.0,
+      "good": 43.0,
+      "ratio": 1.72,
+      "suggested_scalar": 0.1427,
+      "log_bad": 3.2189,
+      "log_good": 3.7612
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2549.0632,
+      "good": 2849.9162,
+      "ratio": 1.118,
+      "suggested_scalar": 0.0294,
+      "log_bad": 7.8435,
+      "log_good": 7.955
+    },
+    "readability.mean_total_lines": {
+      "bad": 50.0,
+      "good": 50.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.912,
+      "log_good": 3.912
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2340.5035,
+      "good": 2181.0583,
+      "ratio": 0.9319,
+      "suggested_scalar": -0.0186,
+      "log_bad": 7.7581,
+      "log_good": 7.6876
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 805.0,
+      "good": 695.0,
+      "ratio": 0.8634,
+      "suggested_scalar": -0.0387,
+      "log_bad": 6.6908,
+      "log_good": 6.5439
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 40.1,
+      "good": 39.76,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0022,
+      "log_bad": 3.6914,
+      "log_good": 3.6829
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.22,
+      "good": 1.3352,
+      "ratio": 1.0944,
+      "suggested_scalar": 0.0237,
+      "log_bad": 0.1989,
+      "log_good": 0.2891
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0587,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 25.0,
+      "good": 27.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.0203,
+      "log_bad": 3.2189,
+      "log_good": 3.2958
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 3.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.1344,
+      "log_bad": 1.6094,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9196,
+      "good": 0.8413,
+      "ratio": 0.9149,
+      "suggested_scalar": -0.0234,
+      "log_bad": -0.0838,
+      "log_good": -0.1728
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9895,
+      "good": 0.9821,
+      "ratio": 0.9925,
+      "suggested_scalar": -0.002,
+      "log_bad": -0.0106,
+      "log_good": -0.0181
+    },
+    "halstead.mean_length": {
+      "bad": 336.0,
+      "good": 329.0,
+      "ratio": 0.9792,
+      "suggested_scalar": -0.0055,
+      "log_bad": 5.8171,
+      "log_good": 5.7961
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 8.0,
+      "good": 10.25,
+      "ratio": 1.2813,
+      "suggested_scalar": 0.0652,
+      "log_bad": 2.0794,
+      "log_good": 2.3273
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.0334,
+      "good": 6.6724,
+      "ratio": 0.9487,
+      "suggested_scalar": -0.0139,
+      "log_bad": 1.9507,
+      "log_good": 1.898
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0741,
+      "good": 0.0796,
+      "ratio": 1.0742,
+      "suggested_scalar": 0.0188,
+      "log_bad": -2.6023,
+      "log_good": -2.5307
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 19.604,
+      "good": 23.52,
+      "ratio": 1.1998,
+      "suggested_scalar": 0.0479,
+      "log_bad": 2.9757,
+      "log_good": 3.1579
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.2891,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 95.0,
+      "good": 69.0,
+      "ratio": 0.7263,
+      "suggested_scalar": -0.0841,
+      "log_bad": 4.5539,
+      "log_good": 4.2341
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8444,
+      "good": 0.7455,
+      "ratio": 0.8829,
+      "suggested_scalar": -0.0328,
+      "log_bad": -0.1691,
+      "log_good": -0.2937
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 50.0,
+      "good": 50.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.912,
+      "log_good": 3.912
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 23.0,
+      "ratio": 1.2105,
+      "suggested_scalar": 0.0503,
+      "log_bad": 2.9444,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "documentation.function_has_docstring": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 37.0,
+      "good": 40.0,
+      "ratio": 1.0811,
+      "suggested_scalar": 0.0349,
+      "log_bad": 3.6109,
+      "log_good": 3.6889
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0083,
+      "good": 0.0312,
+      "ratio": 3.759,
+      "suggested_scalar": 0.5931,
+      "log_bad": -4.7915,
+      "log_good": -3.4673
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.625,
+      "good": 1.7,
+      "ratio": 1.0462,
+      "suggested_scalar": 0.0202,
+      "log_bad": 0.4855,
+      "log_good": 0.5306
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8413,
+      "good": 0.7931,
+      "ratio": 0.9427,
+      "suggested_scalar": -0.0264,
+      "log_bad": -0.1728,
+      "log_good": -0.2318
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0083,
+      "good": 0.0312,
+      "ratio": 3.759,
+      "suggested_scalar": 0.5931,
+      "log_bad": -4.7915,
+      "log_good": -3.4673
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6678,
+      "good": 4.753,
+      "ratio": 1.0183,
+      "suggested_scalar": 0.0081,
+      "log_bad": 1.5407,
+      "log_good": 1.5588
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 75.0,
+      "good": 100.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1288,
+      "log_bad": 4.3175,
+      "log_good": 4.6052
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3039,
+      "good": 0.4513,
+      "ratio": 1.485,
+      "suggested_scalar": 0.1771,
+      "log_bad": -1.1911,
+      "log_good": -0.7956
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 22.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0427,
+      "log_bad": 2.9957,
+      "log_good": 3.091
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5227,
+      "good": 0.6057,
+      "ratio": 1.1588,
+      "suggested_scalar": 0.066,
+      "log_bad": -0.6487,
+      "log_good": -0.5014
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.4603,
+      "good": 2.8276,
+      "ratio": 0.8172,
+      "suggested_scalar": -0.0904,
+      "log_bad": 1.2414,
+      "log_good": 1.0394
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 481.0,
+      "good": 801.0,
+      "ratio": 1.6653,
+      "suggested_scalar": 0.2284,
+      "log_bad": 6.1759,
+      "log_good": 6.6859
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0006,
+      "good": 0.0003,
+      "ratio": 0.5,
+      "suggested_scalar": -0.3105,
+      "log_bad": -7.4186,
+      "log_good": -8.1117
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 0.0115,
+      "ratio": 0.0115,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -4.4654
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0017,
+      "good": 0.001,
+      "ratio": 0.5882,
+      "suggested_scalar": -0.2377,
+      "log_bad": -6.3771,
+      "log_good": -6.9078
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0884,
+      "good": 1.0944,
+      "ratio": 1.0055,
+      "suggested_scalar": 0.0025,
+      "log_bad": 0.0847,
+      "log_good": 0.0902
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 170.0,
+      "good": 319.0,
+      "ratio": 1.8765,
+      "suggested_scalar": 0.2819,
+      "log_bad": 5.1358,
+      "log_good": 5.7652
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 105.6006,
+      "good": 106.2248,
+      "ratio": 1.0059,
+      "suggested_scalar": 0.0026,
+      "log_bad": 4.6597,
+      "log_good": 4.6656
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7396,
+      "good": 0.665,
+      "ratio": 0.8991,
+      "suggested_scalar": -0.0476,
+      "log_bad": -0.3016,
+      "log_good": -0.408
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 12.7493,
+      "good": 10.8393,
+      "ratio": 0.8502,
+      "suggested_scalar": -0.0727,
+      "log_bad": 2.5455,
+      "log_good": 2.3832
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1812.0,
+      "good": 2995.0,
+      "ratio": 1.6529,
+      "suggested_scalar": 0.2251,
+      "log_bad": 7.5022,
+      "log_good": 8.0047
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0635,
+      "good": 0.1494,
+      "ratio": 2.3528,
+      "suggested_scalar": 0.3832,
+      "log_bad": -2.7567,
+      "log_good": -1.9011
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7937,
+      "good": 0.7701,
+      "ratio": 0.9703,
+      "suggested_scalar": -0.0135,
+      "log_bad": -0.231,
+      "log_good": -0.2612
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.6349,
+      "good": 9.314,
+      "ratio": 1.2199,
+      "suggested_scalar": 0.089,
+      "log_bad": 2.0327,
+      "log_good": 2.2315
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3105,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3105,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.3278,
+      "good": 2.0737,
+      "ratio": 0.6231,
+      "suggested_scalar": -0.2118,
+      "log_bad": 1.2023,
+      "log_good": 0.7293
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 129.0,
+      "good": 255.0,
+      "ratio": 1.9767,
+      "suggested_scalar": 0.3052,
+      "log_bad": 4.8598,
+      "log_good": 5.5413
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3105,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9575,
+      "good": 0.9619,
+      "ratio": 1.0046,
+      "suggested_scalar": 0.0021,
+      "log_bad": -0.0434,
+      "log_good": -0.0388
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 37.0,
+      "ratio": 1.2333,
+      "suggested_scalar": 0.0939,
+      "log_bad": 3.4012,
+      "log_good": 3.6109
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.676,
+      "good": 0.6404,
+      "ratio": 0.9473,
+      "suggested_scalar": -0.0242,
+      "log_bad": -0.3916,
+      "log_good": -0.4457
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5491,
+      "good": 0.4368,
+      "ratio": 0.7955,
+      "suggested_scalar": -0.1025,
+      "log_bad": -0.5995,
+      "log_good": -0.8283
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0869,
+      "good": 2.7809,
+      "ratio": 0.9009,
+      "suggested_scalar": -0.0468,
+      "log_bad": 1.1272,
+      "log_good": 1.0228
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 479.0,
+      "good": 799.0,
+      "ratio": 1.6681,
+      "suggested_scalar": 0.2292,
+      "log_bad": 6.1717,
+      "log_good": 6.6834
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 14.0,
+      "good": 19.0,
+      "ratio": 1.3571,
+      "suggested_scalar": 0.1368,
+      "log_bad": 2.6391,
+      "log_good": 2.9444
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0187,
+      "good": 0.0175,
+      "ratio": 0.9358,
+      "suggested_scalar": -0.0297,
+      "log_bad": -3.9792,
+      "log_good": -4.0456
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8074,
+      "good": 6.0224,
+      "ratio": 1.037,
+      "suggested_scalar": 0.0163,
+      "log_bad": 1.7591,
+      "log_good": 1.7955
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 41.0,
+      "good": 62.0,
+      "ratio": 1.5122,
+      "suggested_scalar": 0.1852,
+      "log_bad": 3.7136,
+      "log_good": 4.1271
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.797,
+      "good": 0.7634,
+      "ratio": 0.9578,
+      "suggested_scalar": -0.0193,
+      "log_bad": -0.2269,
+      "log_good": -0.27
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.2823,
+      "good": 5.9283,
+      "ratio": 1.1223,
+      "suggested_scalar": 0.0517,
+      "log_bad": 1.6644,
+      "log_good": 1.7797
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8038,
+      "good": 0.7892,
+      "ratio": 0.9818,
+      "suggested_scalar": -0.0082,
+      "log_bad": -0.2184,
+      "log_good": -0.2367
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.137,
+      "good": 0.1714,
+      "ratio": 1.2511,
+      "suggested_scalar": 0.1003,
+      "log_bad": -1.9878,
+      "log_good": -1.7638
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.5706,
+      "good": 3.2923,
+      "ratio": 0.9221,
+      "suggested_scalar": -0.0363,
+      "log_bad": 1.2727,
+      "log_good": 1.1916
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 5.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.4104,
+      "log_bad": 0.6931,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 296.0,
+      "good": 554.0,
+      "ratio": 1.8716,
+      "suggested_scalar": 0.2807,
+      "log_bad": 5.6904,
+      "log_good": 6.3172
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 7.0,
+      "good": 11.0,
+      "ratio": 1.5714,
+      "suggested_scalar": 0.2024,
+      "log_bad": 1.9459,
+      "log_good": 2.3979
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9426,
+      "good": 1.2668,
+      "ratio": 1.3439,
+      "suggested_scalar": 0.1324,
+      "log_bad": -0.0591,
+      "log_good": 0.2365
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 81.0,
+      "good": 145.0,
+      "ratio": 1.7901,
+      "suggested_scalar": 0.2608,
+      "log_bad": 4.3944,
+      "log_good": 4.9767
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 992.0,
+      "good": 1698.0,
+      "ratio": 1.7117,
+      "suggested_scalar": 0.2407,
+      "log_bad": 6.8997,
+      "log_good": 7.4372
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 174.0,
+      "good": 208.0,
+      "ratio": 1.1954,
+      "suggested_scalar": 0.0799,
+      "log_bad": 5.1591,
+      "log_good": 5.3375
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0083,
+      "good": 0.0037,
+      "ratio": 0.4458,
+      "suggested_scalar": -0.3619,
+      "log_bad": -4.7915,
+      "log_good": -5.5994
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.3056,
+      "good": 0.2434,
+      "ratio": 0.7965,
+      "suggested_scalar": -0.1019,
+      "log_bad": -1.1855,
+      "log_good": -1.413
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 88.0,
+      "good": 135.0,
+      "ratio": 1.5341,
+      "suggested_scalar": 0.1917,
+      "log_bad": 4.4773,
+      "log_good": 4.9053
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 8.0,
+      "good": 10.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0999,
+      "log_bad": 2.0794,
+      "log_good": 2.3026
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 81.0,
+      "good": 145.0,
+      "ratio": 1.7901,
+      "suggested_scalar": 0.2608,
+      "log_bad": 4.3944,
+      "log_good": 4.9767
+    },
+    "brevity.mean_sample_size": {
+      "bad": 81.0,
+      "good": 145.0,
+      "ratio": 1.7901,
+      "suggested_scalar": 0.2608,
+      "log_bad": 4.3944,
+      "log_good": 4.9767
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 481.0,
+      "good": 801.0,
+      "ratio": 1.6653,
+      "suggested_scalar": 0.2284,
+      "log_bad": 6.1759,
+      "log_good": 6.6859
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 258.0,
+      "good": 394.0,
+      "ratio": 1.5271,
+      "suggested_scalar": 0.1896,
+      "log_bad": 5.553,
+      "log_good": 5.9764
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 213.0,
+      "good": 403.0,
+      "ratio": 1.892,
+      "suggested_scalar": 0.2856,
+      "log_bad": 5.3613,
+      "log_good": 5.9989
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0042,
+      "good": 0.0062,
+      "ratio": 1.4762,
+      "suggested_scalar": 0.1744,
+      "log_bad": -5.4727,
+      "log_good": -5.0832
+    },
+    "heaps.mean_k": {
+      "bad": 3.2878,
+      "good": 2.8682,
+      "ratio": 0.8724,
+      "suggested_scalar": -0.0612,
+      "log_bad": 1.1902,
+      "log_good": 1.0537
+    },
+    "halstead.mean_effort": {
+      "bad": 164017.2538,
+      "good": 232119.0402,
+      "ratio": 1.4152,
+      "suggested_scalar": 0.1555,
+      "log_bad": 12.0077,
+      "log_good": 12.355
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8332,
+      "good": 0.8257,
+      "ratio": 0.991,
+      "suggested_scalar": -0.004,
+      "log_bad": -0.1825,
+      "log_good": -0.1915
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 45.0,
+      "good": 63.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.1507,
+      "log_bad": 3.8067,
+      "log_good": 4.1431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 280.0,
+      "good": 364.0,
+      "ratio": 1.3,
+      "suggested_scalar": 0.1175,
+      "log_bad": 5.6348,
+      "log_good": 5.8972
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.2471,
+      "good": 0.279,
+      "ratio": 1.1291,
+      "suggested_scalar": 0.0544,
+      "log_bad": -1.398,
+      "log_good": -1.2765
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.8353,
+      "good": 5.3229,
+      "ratio": 0.9122,
+      "suggested_scalar": -0.0412,
+      "log_bad": 1.7639,
+      "log_good": 1.672
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.137,
+      "good": 0.1714,
+      "ratio": 1.2511,
+      "suggested_scalar": 0.1003,
+      "log_bad": -1.9878,
+      "log_good": -1.7638
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.4193,
+      "good": 4.2256,
+      "ratio": 1.2358,
+      "suggested_scalar": 0.0948,
+      "log_bad": 1.2294,
+      "log_good": 1.4412
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 480.0,
+      "good": 800.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.2288,
+      "log_bad": 6.1738,
+      "log_good": 6.6846
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0999,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 80.0,
+      "good": 104.0,
+      "ratio": 1.3,
+      "suggested_scalar": 0.1175,
+      "log_bad": 4.382,
+      "log_good": 4.6444
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 9112.0697,
+      "good": 12895.5022,
+      "ratio": 1.4152,
+      "suggested_scalar": 0.1555,
+      "log_bad": 9.1174,
+      "log_good": 9.4646
+    },
+    "readability.mean_total_lines": {
+      "bad": 63.0,
+      "good": 86.0,
+      "ratio": 1.3651,
+      "suggested_scalar": 0.1394,
+      "log_bad": 4.1431,
+      "log_good": 4.4543
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 6.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1288,
+      "log_bad": 2.0794,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2827.8837,
+      "good": 3800.2857,
+      "ratio": 1.3439,
+      "suggested_scalar": 0.1324,
+      "log_bad": 7.9473,
+      "log_good": 8.2428
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 587.0,
+      "good": 1077.0,
+      "ratio": 1.8348,
+      "suggested_scalar": 0.2718,
+      "log_bad": 6.375,
+      "log_good": 6.9819
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 27.6032,
+      "good": 33.4535,
+      "ratio": 1.2119,
+      "suggested_scalar": 0.0861,
+      "log_bad": 3.3179,
+      "log_good": 3.5102
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.105,
+      "good": 1.0775,
+      "ratio": 0.9751,
+      "suggested_scalar": -0.0113,
+      "log_bad": 0.0998,
+      "log_good": 0.0746
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 38.0,
+      "good": 57.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1816,
+      "log_bad": 3.6376,
+      "log_good": 4.0431
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7297,
+      "good": 0.8123,
+      "ratio": 1.1132,
+      "suggested_scalar": 0.048,
+      "log_bad": -0.3151,
+      "log_good": -0.2079
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 8.0,
+      "ratio": 4.0,
+      "suggested_scalar": 0.6209,
+      "log_bad": 0.6931,
+      "log_good": 2.0794
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9807,
+      "good": 0.9718,
+      "ratio": 0.9909,
+      "suggested_scalar": -0.0041,
+      "log_bad": -0.0195,
+      "log_good": -0.0286
+    },
+    "halstead.mean_length": {
+      "bad": 454.0,
+      "good": 572.0,
+      "ratio": 1.2599,
+      "suggested_scalar": 0.1035,
+      "log_bad": 6.1181,
+      "log_good": 6.3491
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.875,
+      "good": 8.4,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.0289,
+      "log_bad": 2.0637,
+      "log_good": 2.1282
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.3399,
+      "good": 7.1799,
+      "ratio": 1.1325,
+      "suggested_scalar": 0.0557,
+      "log_bad": 1.8469,
+      "log_good": 1.9713
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1424,
+      "good": 0.1316,
+      "ratio": 0.9242,
+      "suggested_scalar": -0.0353,
+      "log_bad": -1.9491,
+      "log_good": -2.028
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 58.0,
+      "good": 61.0794,
+      "ratio": 1.0531,
+      "suggested_scalar": 0.0232,
+      "log_bad": 4.0604,
+      "log_good": 4.1122
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 13.0,
+      "ratio": 3.25,
+      "suggested_scalar": 0.5279,
+      "log_bad": 1.3863,
+      "log_good": 2.5649
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 42.0,
+      "good": 89.0,
+      "ratio": 2.119,
+      "suggested_scalar": 0.3363,
+      "log_bad": 3.7377,
+      "log_good": 4.4886
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5869,
+      "good": 0.665,
+      "ratio": 1.1331,
+      "suggested_scalar": 0.056,
+      "log_bad": -0.5329,
+      "log_good": -0.408
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 63.0,
+      "good": 87.0,
+      "ratio": 1.381,
+      "suggested_scalar": 0.1446,
+      "log_bad": 4.1431,
+      "log_good": 4.4659
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_primitive_wrapper_constructors": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0113,
+      "good": 0.0193,
+      "ratio": 1.708,
+      "suggested_scalar": 1.3847,
+      "log_bad": -4.483,
+      "log_good": -3.9477
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.2857,
+      "good": 1.2857,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2513,
+      "log_good": 0.2513
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7627,
+      "good": 0.7636,
+      "ratio": 1.0012,
+      "suggested_scalar": 0.0031,
+      "log_bad": -0.2709,
+      "log_good": -0.2697
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0113,
+      "good": 0.0193,
+      "ratio": 1.708,
+      "suggested_scalar": 1.3847,
+      "log_bad": -4.483,
+      "log_good": -3.9477
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6151,
+      "good": 4.6427,
+      "ratio": 1.006,
+      "suggested_scalar": 0.0154,
+      "log_bad": 1.5293,
+      "log_good": 1.5353
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 78.0,
+      "good": 76.0,
+      "ratio": 0.9744,
+      "suggested_scalar": -0.0672,
+      "log_bad": 4.3567,
+      "log_good": 4.3307
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4,
+      "good": 0.4066,
+      "ratio": 1.0165,
+      "suggested_scalar": 0.0423,
+      "log_bad": -0.9163,
+      "log_good": -0.8999
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5704,
+      "good": 0.5975,
+      "ratio": 1.0475,
+      "suggested_scalar": 0.1201,
+      "log_bad": -0.5614,
+      "log_good": -0.515
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.9661,
+      "good": 4.0,
+      "ratio": 1.0085,
+      "suggested_scalar": 0.022,
+      "log_bad": 1.3778,
+      "log_good": 1.3863
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 443.0,
+      "good": 414.0,
+      "ratio": 0.9345,
+      "suggested_scalar": -0.1751,
+      "log_bad": 6.0936,
+      "log_good": 6.0259
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 7.0,
+      "good": 6.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.3987,
+      "log_bad": 1.9459,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0006,
+      "good": 0.0012,
+      "ratio": 2.0,
+      "suggested_scalar": 1.793,
+      "log_bad": -7.4186,
+      "log_good": -6.7254
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0006,
+      "good": 0.0006,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.4186,
+      "log_good": -7.4186
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1028,
+      "good": 1.0838,
+      "ratio": 0.9828,
+      "suggested_scalar": -0.045,
+      "log_bad": 0.0979,
+      "log_good": 0.0805
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 106.0,
+      "good": 91.0,
+      "ratio": 0.8585,
+      "suggested_scalar": -0.3947,
+      "log_bad": 4.6634,
+      "log_good": 4.5109
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 98.3273,
+      "good": 93.19,
+      "ratio": 0.9478,
+      "suggested_scalar": -0.1388,
+      "log_bad": 4.5883,
+      "log_good": 4.5346
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6742,
+      "good": 0.6513,
+      "ratio": 0.966,
+      "suggested_scalar": -0.0894,
+      "log_bad": -0.3942,
+      "log_good": -0.4288
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.6515,
+      "good": 17.4266,
+      "ratio": 1.2765,
+      "suggested_scalar": 0.6315,
+      "log_bad": 2.6138,
+      "log_good": 2.858
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1731.0,
+      "good": 1691.0,
+      "ratio": 0.9769,
+      "suggested_scalar": -0.0605,
+      "log_bad": 7.4565,
+      "log_good": 7.4331
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2034,
+      "good": 0.2182,
+      "ratio": 1.0728,
+      "suggested_scalar": 0.1817,
+      "log_bad": -1.5926,
+      "log_good": -1.5223
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6949,
+      "good": 0.6909,
+      "ratio": 0.9942,
+      "suggested_scalar": -0.0149,
+      "log_bad": -0.364,
+      "log_good": -0.3698
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.5085,
+      "good": 7.5273,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0065,
+      "log_bad": 2.016,
+      "log_good": 2.0185
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 11.7277,
+      "good": 12.0727,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.075,
+      "log_bad": 2.462,
+      "log_good": 2.4909
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 68.0,
+      "good": 60.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.3238,
+      "log_bad": 4.2195,
+      "log_good": 4.0943
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9441,
+      "good": 0.9251,
+      "ratio": 0.9799,
+      "suggested_scalar": -0.0526,
+      "log_bad": -0.0575,
+      "log_good": -0.0779
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6719,
+      "good": 0.673,
+      "ratio": 1.0016,
+      "suggested_scalar": 0.0042,
+      "log_bad": -0.3976,
+      "log_good": -0.396
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4898,
+      "good": 0.4733,
+      "ratio": 0.9663,
+      "suggested_scalar": -0.0886,
+      "log_bad": -0.7138,
+      "log_good": -0.748
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0475,
+      "good": 3.0579,
+      "ratio": 1.0034,
+      "suggested_scalar": 0.0088,
+      "log_bad": 1.1143,
+      "log_good": 1.1177
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 441.0,
+      "good": 412.0,
+      "ratio": 0.9342,
+      "suggested_scalar": -0.176,
+      "log_bad": 6.089,
+      "log_good": 6.021
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 34.0,
+      "good": 33.0,
+      "ratio": 0.9706,
+      "suggested_scalar": -0.0772,
+      "log_bad": 3.5264,
+      "log_good": 3.4965
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0023,
+      "good": 0.0024,
+      "ratio": 1.0435,
+      "suggested_scalar": 0.1101,
+      "log_bad": -6.0748,
+      "log_good": -6.0323
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.858,
+      "good": 5.8329,
+      "ratio": 0.9957,
+      "suggested_scalar": -0.0111,
+      "log_bad": 1.7678,
+      "log_good": 1.7635
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 13.0,
+      "good": 6.0,
+      "ratio": 0.4615,
+      "suggested_scalar": -2.0,
+      "log_bad": 2.5649,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2737,
+      "good": 1.1669,
+      "ratio": 0.9161,
+      "suggested_scalar": -0.2265,
+      "log_bad": 0.2419,
+      "log_good": 0.1544
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.3345,
+      "good": 5.3406,
+      "ratio": 1.0011,
+      "suggested_scalar": 0.003,
+      "log_bad": 1.6742,
+      "log_good": 1.6753
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7878,
+      "good": 0.796,
+      "ratio": 1.0104,
+      "suggested_scalar": 0.0268,
+      "log_bad": -0.2385,
+      "log_good": -0.2282
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1324,
+      "good": 0.1406,
+      "ratio": 1.0619,
+      "suggested_scalar": 0.1554,
+      "log_bad": -2.0219,
+      "log_good": -1.9618
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6948,
+      "good": 4.1745,
+      "ratio": 1.1298,
+      "suggested_scalar": 0.3158,
+      "log_bad": 1.3069,
+      "log_good": 1.429
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 293.0,
+      "good": 279.0,
+      "ratio": 0.9522,
+      "suggested_scalar": -0.1266,
+      "log_bad": 5.6802,
+      "log_good": 5.6312
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 23.0,
+      "good": 14.0,
+      "ratio": 0.6087,
+      "suggested_scalar": -1.2841,
+      "log_bad": 3.1355,
+      "log_good": 2.6391
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8737,
+      "good": 0.7893,
+      "ratio": 0.9034,
+      "suggested_scalar": -0.2628,
+      "log_bad": -0.135,
+      "log_good": -0.2366
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 78.0,
+      "good": 75.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.1015,
+      "log_bad": 4.3567,
+      "log_good": 4.3175
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 646.0,
+      "good": 641.0,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.0201,
+      "log_bad": 6.4708,
+      "log_good": 6.463
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 145.0,
+      "good": 132.0,
+      "ratio": 0.9103,
+      "suggested_scalar": -0.243,
+      "log_bad": 4.9767,
+      "log_good": 4.8828
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0023,
+      "good": 0.0024,
+      "ratio": 1.0435,
+      "suggested_scalar": 0.1101,
+      "log_bad": -6.0748,
+      "log_good": -6.0323
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2393,
+      "good": 0.2415,
+      "ratio": 1.0092,
+      "suggested_scalar": 0.0237,
+      "log_bad": -1.43,
+      "log_good": -1.4209
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 73.0,
+      "good": 71.0,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.0719,
+      "log_bad": 4.2905,
+      "log_good": 4.2627
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 78.0,
+      "good": 75.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.1015,
+      "log_bad": 4.3567,
+      "log_good": 4.3175
+    },
+    "brevity.mean_sample_size": {
+      "bad": 78.0,
+      "good": 75.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.1015,
+      "log_bad": 4.3567,
+      "log_good": 4.3175
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 443.0,
+      "good": 414.0,
+      "ratio": 0.9345,
+      "suggested_scalar": -0.1751,
+      "log_bad": 6.0936,
+      "log_good": 6.0259
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 252.0,
+      "good": 245.0,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.0729,
+      "log_bad": 5.5294,
+      "log_good": 5.5013
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 217.0,
+      "good": 215.0,
+      "ratio": 0.9908,
+      "suggested_scalar": -0.024,
+      "log_bad": 5.3799,
+      "log_good": 5.3706
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.511,
+      "good": 2.2163,
+      "ratio": 0.8826,
+      "suggested_scalar": -0.3229,
+      "log_bad": 0.9207,
+      "log_good": 0.7958
+    },
+    "halstead.mean_effort": {
+      "bad": 100600.6355,
+      "good": 86116.5875,
+      "ratio": 0.856,
+      "suggested_scalar": -0.4021,
+      "log_bad": 11.5189,
+      "log_good": 11.3635
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8487,
+      "good": 0.8574,
+      "ratio": 1.0103,
+      "suggested_scalar": 0.0264,
+      "log_bad": -0.164,
+      "log_good": -0.1539
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 51.0,
+      "good": 49.0,
+      "ratio": 0.9608,
+      "suggested_scalar": -0.1035,
+      "log_bad": 3.9318,
+      "log_good": 3.8918
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 272.0,
+      "good": 247.0,
+      "ratio": 0.9081,
+      "suggested_scalar": -0.2494,
+      "log_bad": 5.6058,
+      "log_good": 5.5094
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3868,
+      "good": 0.4066,
+      "ratio": 1.0512,
+      "suggested_scalar": 0.1291,
+      "log_bad": -0.9498,
+      "log_good": -0.8999
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0943,
+      "good": 7.044,
+      "ratio": 1.1558,
+      "suggested_scalar": 0.3746,
+      "log_bad": 1.8074,
+      "log_good": 1.9522
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1324,
+      "good": 0.1406,
+      "ratio": 1.0619,
+      "suggested_scalar": 0.1554,
+      "log_bad": -2.0219,
+      "log_good": -1.9618
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.9285,
+      "good": 6.3844,
+      "ratio": 1.2954,
+      "suggested_scalar": 0.6695,
+      "log_bad": 1.595,
+      "log_good": 1.8539
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 442.0,
+      "good": 413.0,
+      "ratio": 0.9344,
+      "suggested_scalar": -0.1755,
+      "log_bad": 6.0913,
+      "log_good": 6.0234
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 68.0,
+      "good": 62.0,
+      "ratio": 0.9118,
+      "suggested_scalar": -0.2389,
+      "log_bad": 4.2195,
+      "log_good": 4.1271
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5588.9242,
+      "good": 4784.2549,
+      "ratio": 0.856,
+      "suggested_scalar": -0.4021,
+      "log_bad": 8.6285,
+      "log_good": 8.4731
+    },
+    "readability.mean_total_lines": {
+      "bad": 59.0,
+      "good": 55.0,
+      "ratio": 0.9322,
+      "suggested_scalar": -0.1816,
+      "log_bad": 4.0775,
+      "log_good": 4.0073
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 2621.0127,
+      "good": 2367.9645,
+      "ratio": 0.9035,
+      "suggested_scalar": -0.2626,
+      "log_bad": 7.8713,
+      "log_good": 7.7698
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 568.0,
+      "good": 553.0,
+      "ratio": 0.9736,
+      "suggested_scalar": -0.0692,
+      "log_bad": 6.3421,
+      "log_good": 6.3154
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 28.1864,
+      "good": 29.5818,
+      "ratio": 1.0495,
+      "suggested_scalar": 0.125,
+      "log_bad": 3.3388,
+      "log_good": 3.3872
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1925,
+      "good": 1.253,
+      "ratio": 1.0507,
+      "suggested_scalar": 0.128,
+      "log_bad": 0.1761,
+      "log_good": 0.2255
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 7.0,
+      "good": 6.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.3987,
+      "log_bad": 1.9459,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 18.0,
+      "good": 15.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.4716,
+      "log_bad": 2.8904,
+      "log_good": 2.7081
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7679,
+      "good": 0.7778,
+      "ratio": 1.0129,
+      "suggested_scalar": 0.0331,
+      "log_bad": -0.2641,
+      "log_good": -0.2513
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9893,
+      "good": 0.9858,
+      "ratio": 0.9965,
+      "suggested_scalar": -0.0092,
+      "log_bad": -0.0108,
+      "log_good": -0.0143
+    },
+    "halstead.mean_length": {
+      "bad": 417.0,
+      "good": 379.0,
+      "ratio": 0.9089,
+      "suggested_scalar": -0.2472,
+      "log_bad": 6.0331,
+      "log_good": 5.9375
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.7143,
+      "good": 9.1429,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.1568,
+      "log_bad": 2.2736,
+      "log_good": 2.213
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2854,
+      "good": 6.2288,
+      "ratio": 0.991,
+      "suggested_scalar": -0.0234,
+      "log_bad": 1.8382,
+      "log_good": 1.8292
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1456,
+      "good": 0.1449,
+      "ratio": 0.9952,
+      "suggested_scalar": -0.0125,
+      "log_bad": -1.9269,
+      "log_good": -1.9317
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 38.3824,
+      "good": 36.3673,
+      "ratio": 0.9475,
+      "suggested_scalar": -0.1395,
+      "log_bad": 3.6476,
+      "log_good": 3.5937
+    },
+    "branching.mean_branch_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 41.0,
+      "good": 37.0,
+      "ratio": 0.9024,
+      "suggested_scalar": -0.2655,
+      "log_bad": 3.7136,
+      "log_good": 3.6109
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6636,
+      "good": 0.6698,
+      "ratio": 1.0093,
+      "suggested_scalar": 0.0241,
+      "log_bad": -0.4101,
+      "log_good": -0.4008
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 59.0,
+      "good": 55.0,
+      "ratio": 0.9322,
+      "suggested_scalar": -0.1816,
+      "log_bad": 4.0775,
+      "log_good": 4.0073
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.does_not_accept_box_ref_parameter": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.5778,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0176,
+      "good": 0.0156,
+      "ratio": 0.8864,
+      "suggested_scalar": -1.0102,
+      "log_bad": -4.0399,
+      "log_good": -4.1605
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7381,
+      "good": 0.6977,
+      "ratio": 0.9453,
+      "suggested_scalar": -0.4714,
+      "log_bad": -0.3037,
+      "log_good": -0.36
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0176,
+      "good": 0.0156,
+      "ratio": 0.8864,
+      "suggested_scalar": -1.0102,
+      "log_bad": -4.0399,
+      "log_good": -4.1605
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.9448,
+      "good": 4.9389,
+      "ratio": 0.9988,
+      "suggested_scalar": -0.01,
+      "log_bad": 1.5983,
+      "log_good": 1.5971
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 91.0,
+      "good": 89.0,
+      "ratio": 0.978,
+      "suggested_scalar": -0.1861,
+      "log_bad": 4.5109,
+      "log_good": 4.4886
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.545,
+      "good": 0.5168,
+      "ratio": 0.9483,
+      "suggested_scalar": -0.445,
+      "log_bad": -0.607,
+      "log_good": -0.6601
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 21.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.4086,
+      "log_bad": 2.9957,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6297,
+      "good": 0.6146,
+      "ratio": 0.976,
+      "suggested_scalar": -0.2033,
+      "log_bad": -0.4625,
+      "log_good": -0.4868
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.9048,
+      "good": 2.4186,
+      "ratio": 1.2697,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.6444,
+      "log_good": 0.8832
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 397.0,
+      "good": 385.0,
+      "ratio": 0.9698,
+      "suggested_scalar": -0.257,
+      "log_bad": 5.9839,
+      "log_good": 5.9532
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0038,
+      "good": 0.0031,
+      "ratio": 0.8158,
+      "suggested_scalar": -1.7051,
+      "log_bad": -5.5728,
+      "log_good": -5.7764
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.119,
+      "good": 0.1163,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.1922,
+      "log_bad": -2.1286,
+      "log_good": -2.1516
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0508,
+      "good": 1.0248,
+      "ratio": 0.9753,
+      "suggested_scalar": -0.2098,
+      "log_bad": 0.0496,
+      "log_good": 0.0245
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 127.0,
+      "good": 121.0,
+      "ratio": 0.9528,
+      "suggested_scalar": -0.4053,
+      "log_bad": 4.8442,
+      "log_good": 4.7958
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 106.1894,
+      "good": 106.6249,
+      "ratio": 1.0041,
+      "suggested_scalar": 0.0343,
+      "log_bad": 4.6652,
+      "log_good": 4.6693
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6717,
+      "good": 0.6563,
+      "ratio": 0.9771,
+      "suggested_scalar": -0.1942,
+      "log_bad": -0.3979,
+      "log_good": -0.4211
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 5.132,
+      "good": 4.8912,
+      "ratio": 0.9531,
+      "suggested_scalar": -0.4025,
+      "log_bad": 1.6355,
+      "log_good": 1.5874
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1305.0,
+      "good": 1281.0,
+      "ratio": 0.9816,
+      "suggested_scalar": -0.1555,
+      "log_bad": 7.174,
+      "log_good": 7.1554
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0714,
+      "good": 0.0698,
+      "ratio": 0.9776,
+      "suggested_scalar": -0.1898,
+      "log_bad": -2.6395,
+      "log_good": -2.6621
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7143,
+      "good": 0.6744,
+      "ratio": 0.9441,
+      "suggested_scalar": -0.4814,
+      "log_bad": -0.3365,
+      "log_good": -0.3939
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.925,
+      "good": 9.3902,
+      "ratio": 0.9461,
+      "suggested_scalar": -0.4639,
+      "log_bad": 2.2951,
+      "log_good": 2.2397
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.5147,
+      "good": 6.8015,
+      "ratio": 1.2333,
+      "suggested_scalar": 1.7564,
+      "log_bad": 1.7074,
+      "log_good": 1.9171
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 80.0,
+      "good": 73.0,
+      "ratio": 0.9125,
+      "suggested_scalar": -0.7669,
+      "log_bad": 4.382,
+      "log_good": 4.2905
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9176,
+      "good": 0.9191,
+      "ratio": 1.0016,
+      "suggested_scalar": 0.0137,
+      "log_bad": -0.086,
+      "log_good": -0.0844
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 29.0,
+      "ratio": 1.0741,
+      "suggested_scalar": 0.5985,
+      "log_bad": 3.2958,
+      "log_good": 3.3673
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5801,
+      "good": 0.5894,
+      "ratio": 1.016,
+      "suggested_scalar": 0.1332,
+      "log_bad": -0.5446,
+      "log_good": -0.5287
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5215,
+      "good": 0.4961,
+      "ratio": 0.9513,
+      "suggested_scalar": -0.4182,
+      "log_bad": -0.651,
+      "log_good": -0.701
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3814,
+      "good": 2.4354,
+      "ratio": 1.0227,
+      "suggested_scalar": 0.1878,
+      "log_bad": 0.8677,
+      "log_good": 0.8901
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 395.0,
+      "good": 383.0,
+      "ratio": 0.9696,
+      "suggested_scalar": -0.2584,
+      "log_bad": 5.9789,
+      "log_good": 5.948
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0327,
+      "good": 0.0312,
+      "ratio": 0.9541,
+      "suggested_scalar": -0.3933,
+      "log_bad": -3.4204,
+      "log_good": -3.4673
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8826,
+      "good": 5.9773,
+      "ratio": 1.0161,
+      "suggested_scalar": 0.1337,
+      "log_bad": 1.772,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 46.0,
+      "good": 47.0,
+      "ratio": 1.0217,
+      "suggested_scalar": 0.1801,
+      "log_bad": 3.8286,
+      "log_good": 3.8501
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0057,
+      "good": 1.0269,
+      "ratio": 1.0211,
+      "suggested_scalar": 0.1747,
+      "log_bad": 0.0057,
+      "log_good": 0.0265
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6572,
+      "good": 5.6932,
+      "ratio": 1.0064,
+      "suggested_scalar": 0.0531,
+      "log_bad": 1.7329,
+      "log_good": 1.7393
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8406,
+      "good": 0.8263,
+      "ratio": 0.983,
+      "suggested_scalar": -0.1437,
+      "log_bad": -0.1736,
+      "log_good": -0.1908
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1765,
+      "good": 0.1569,
+      "ratio": 0.889,
+      "suggested_scalar": -0.9858,
+      "log_bad": -1.7344,
+      "log_good": -1.8521
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.2654,
+      "good": 2.2116,
+      "ratio": 0.9763,
+      "suggested_scalar": -0.2013,
+      "log_bad": 0.8178,
+      "log_good": 0.7937
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 257.0,
+      "good": 260.0,
+      "ratio": 1.0117,
+      "suggested_scalar": 0.0972,
+      "log_bad": 5.5491,
+      "log_good": 5.5607
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 9.0,
+      "good": 8.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.9864,
+      "log_bad": 2.1972,
+      "log_good": 2.0794
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7896,
+      "good": 0.762,
+      "ratio": 0.965,
+      "suggested_scalar": -0.298,
+      "log_bad": -0.2362,
+      "log_good": -0.2718
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 92.0,
+      "good": 92.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.5218,
+      "log_good": 4.5218
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 676.0,
+      "good": 630.0,
+      "ratio": 0.932,
+      "suggested_scalar": -0.5902,
+      "log_bad": 6.5162,
+      "log_good": 6.4457
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 132.0,
+      "good": 126.0,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.3896,
+      "log_bad": 4.8828,
+      "log_good": 4.8363
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0227,
+      "good": 0.0208,
+      "ratio": 0.9163,
+      "suggested_scalar": -0.7321,
+      "log_bad": -3.7854,
+      "log_good": -3.8728
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2393,
+      "good": 0.239,
+      "ratio": 0.9987,
+      "suggested_scalar": -0.0105,
+      "log_bad": -1.43,
+      "log_good": -1.4313
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 79.0,
+      "good": 79.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3694,
+      "log_good": 4.3694
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 10.0,
+      "good": 9.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.8824,
+      "log_bad": 2.3026,
+      "log_good": 2.1972
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 92.0,
+      "good": 92.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.5218,
+      "log_good": 4.5218
+    },
+    "brevity.mean_sample_size": {
+      "bad": 92.0,
+      "good": 92.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.5218,
+      "log_good": 4.5218
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 397.0,
+      "good": 385.0,
+      "ratio": 0.9698,
+      "suggested_scalar": -0.257,
+      "log_bad": 5.9839,
+      "log_good": 5.9532
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 227.0,
+      "good": 218.0,
+      "ratio": 0.9604,
+      "suggested_scalar": -0.3388,
+      "log_bad": 5.425,
+      "log_good": 5.3845
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 209.0,
+      "good": 211.0,
+      "ratio": 1.0096,
+      "suggested_scalar": 0.0798,
+      "log_bad": 5.3423,
+      "log_good": 5.3519
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.2007,
+      "good": 2.3261,
+      "ratio": 1.057,
+      "suggested_scalar": 0.4641,
+      "log_bad": 0.7888,
+      "log_good": 0.8442
+    },
+    "halstead.mean_effort": {
+      "bad": 65957.3122,
+      "good": 69606.6873,
+      "ratio": 1.0553,
+      "suggested_scalar": 0.451,
+      "log_bad": 11.0968,
+      "log_good": 11.1506
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8672,
+      "good": 0.8727,
+      "ratio": 1.0063,
+      "suggested_scalar": 0.0529,
+      "log_bad": -0.1425,
+      "log_good": -0.1362
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 64.0,
+      "good": 60.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.5405,
+      "log_bad": 4.1589,
+      "log_good": 4.0943
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 232.0,
+      "good": 227.0,
+      "ratio": 0.9784,
+      "suggested_scalar": -0.1825,
+      "log_bad": 5.4467,
+      "log_good": 5.425
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4724,
+      "good": 0.4793,
+      "ratio": 1.0146,
+      "suggested_scalar": 0.1214,
+      "log_bad": -0.7499,
+      "log_good": -0.7354
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.3228,
+      "good": 5.2066,
+      "ratio": 0.9782,
+      "suggested_scalar": -0.1849,
+      "log_bad": 1.672,
+      "log_good": 1.6499
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1765,
+      "good": 0.1569,
+      "ratio": 0.889,
+      "suggested_scalar": -0.9858,
+      "log_bad": -1.7344,
+      "log_good": -1.8521
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.2053,
+      "good": 3.9956,
+      "ratio": 0.9501,
+      "suggested_scalar": -0.4284,
+      "log_bad": 1.4363,
+      "log_good": 1.3852
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 396.0,
+      "good": 384.0,
+      "ratio": 0.9697,
+      "suggested_scalar": -0.2577,
+      "log_bad": 5.9814,
+      "log_good": 5.9506
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 10.0,
+      "good": 9.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.8824,
+      "log_bad": 2.3026,
+      "log_good": 2.1972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 68.0,
+      "good": 67.0,
+      "ratio": 0.9853,
+      "suggested_scalar": -0.1241,
+      "log_bad": 4.2195,
+      "log_good": 4.2047
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3664.2951,
+      "good": 3867.0382,
+      "ratio": 1.0553,
+      "suggested_scalar": 0.451,
+      "log_bad": 8.2064,
+      "log_good": 8.2602
+    },
+    "readability.mean_total_lines": {
+      "bad": 40.0,
+      "good": 41.0,
+      "ratio": 1.025,
+      "suggested_scalar": 0.2068,
+      "log_bad": 3.6889,
+      "log_good": 3.7136
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2368.8372,
+      "good": 2285.9339,
+      "ratio": 0.965,
+      "suggested_scalar": -0.2983,
+      "log_bad": 7.7702,
+      "log_good": 7.7345
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 548.0,
+      "good": 526.0,
+      "ratio": 0.9599,
+      "suggested_scalar": -0.3431,
+      "log_bad": 6.3063,
+      "log_good": 6.2653
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.5,
+      "good": 29.122,
+      "ratio": 0.9548,
+      "suggested_scalar": -0.3872,
+      "log_bad": 3.4177,
+      "log_good": 3.3715
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0706,
+      "good": 1.0719,
+      "ratio": 1.0012,
+      "suggested_scalar": 0.0102,
+      "log_bad": 0.0682,
+      "log_good": 0.0694
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7354,
+      "good": 0.7423,
+      "ratio": 1.0094,
+      "suggested_scalar": 0.0782,
+      "log_bad": -0.3073,
+      "log_good": -0.298
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9734,
+      "good": 0.972,
+      "ratio": 0.9986,
+      "suggested_scalar": -0.0121,
+      "log_bad": -0.027,
+      "log_good": -0.0284
+    },
+    "halstead.mean_length": {
+      "bad": 364.0,
+      "good": 353.0,
+      "ratio": 0.9698,
+      "suggested_scalar": -0.257,
+      "log_bad": 5.8972,
+      "log_good": 5.8665
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.8,
+      "good": 5.3333,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.8823,
+      "log_bad": 1.5686,
+      "log_good": 1.674
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5236,
+      "good": 6.5236,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8754,
+      "log_good": 1.8754
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1742,
+      "good": 0.1707,
+      "ratio": 0.9799,
+      "suggested_scalar": -0.17,
+      "log_bad": -1.7476,
+      "log_good": -1.7678
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.8438,
+      "good": 30.45,
+      "ratio": 1.0936,
+      "suggested_scalar": 0.7493,
+      "log_bad": 3.3266,
+      "log_good": 3.4161
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 60.0,
+      "good": 58.0,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.2839,
+      "log_bad": 4.0943,
+      "log_good": 4.0604
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.622,
+      "good": 0.6256,
+      "ratio": 1.0058,
+      "suggested_scalar": 0.0483,
+      "log_bad": -0.4748,
+      "log_good": -0.469
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 42.0,
+      "good": 43.0,
+      "ratio": 1.0238,
+      "suggested_scalar": 0.1971,
+      "log_bad": 3.7377,
+      "log_good": 3.7612
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_namespace_trespassing": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 15.0,
+      "good": 20.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1098,
+      "log_bad": 2.7081,
+      "log_good": 2.9957
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2646,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0371,
+      "good": 0.0435,
+      "ratio": 1.1725,
+      "suggested_scalar": 0.0607,
+      "log_bad": -3.2941,
+      "log_good": -3.135
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.25,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0852,
+      "log_bad": 0.0,
+      "log_good": 0.2231
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7347,
+      "good": 0.7692,
+      "ratio": 1.047,
+      "suggested_scalar": 0.0175,
+      "log_bad": -0.3083,
+      "log_good": -0.2624
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0371,
+      "good": 0.0435,
+      "ratio": 1.1725,
+      "suggested_scalar": 0.0607,
+      "log_bad": -3.2941,
+      "log_good": -3.135
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8667,
+      "good": 4.8692,
+      "ratio": 1.0005,
+      "suggested_scalar": 0.0002,
+      "log_bad": 1.5824,
+      "log_good": 1.5829
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 98.0,
+      "good": 72.0,
+      "ratio": 0.7347,
+      "suggested_scalar": -0.1177,
+      "log_bad": 4.585,
+      "log_good": 4.2767
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5911,
+      "good": 0.4727,
+      "ratio": 0.7997,
+      "suggested_scalar": -0.0853,
+      "log_bad": -0.5258,
+      "log_good": -0.7493
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 24.0,
+      "good": 22.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0332,
+      "log_bad": 3.1781,
+      "log_good": 3.091
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7345,
+      "good": 0.5946,
+      "ratio": 0.8095,
+      "suggested_scalar": -0.0806,
+      "log_bad": -0.3086,
+      "log_good": -0.5199
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.7959,
+      "good": 2.2692,
+      "ratio": 1.2635,
+      "suggested_scalar": 0.0893,
+      "log_bad": 0.5855,
+      "log_good": 0.8194
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 377.0,
+      "good": 391.0,
+      "ratio": 1.0371,
+      "suggested_scalar": 0.0139,
+      "log_bad": 5.9322,
+      "log_good": 5.9687
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.102,
+      "good": 0.0192,
+      "ratio": 0.1882,
+      "suggested_scalar": -0.6374,
+      "log_bad": -2.2828,
+      "log_good": -3.9528
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8883,
+      "good": 0.9787,
+      "ratio": 1.1018,
+      "suggested_scalar": 0.037,
+      "log_bad": -0.1184,
+      "log_good": -0.0215
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 162.0,
+      "good": 148.0,
+      "ratio": 0.9136,
+      "suggested_scalar": -0.0345,
+      "log_bad": 5.0876,
+      "log_good": 4.9972
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 108.6101,
+      "good": 107.9812,
+      "ratio": 0.9942,
+      "suggested_scalar": -0.0022,
+      "log_bad": 4.6878,
+      "log_good": 4.682
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5372,
+      "good": 0.5513,
+      "ratio": 1.0262,
+      "suggested_scalar": 0.0099,
+      "log_bad": -0.6214,
+      "log_good": -0.5955
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.8055,
+      "good": 9.4184,
+      "ratio": 1.2066,
+      "suggested_scalar": 0.0717,
+      "log_bad": 2.0548,
+      "log_good": 2.2427
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1553.0,
+      "good": 1503.0,
+      "ratio": 0.9678,
+      "suggested_scalar": -0.0125,
+      "log_bad": 7.3479,
+      "log_good": 7.3152
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.102,
+      "good": 0.0769,
+      "ratio": 0.7539,
+      "suggested_scalar": -0.1078,
+      "log_bad": -2.2828,
+      "log_good": -2.5652
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7143,
+      "good": 0.75,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0186,
+      "log_bad": -0.3365,
+      "log_good": -0.2877
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.5682,
+      "good": 7.6667,
+      "ratio": 0.8948,
+      "suggested_scalar": -0.0424,
+      "log_bad": 2.1481,
+      "log_good": 2.0369
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.6726,
+      "good": 1.3891,
+      "ratio": 0.8305,
+      "suggested_scalar": -0.0709,
+      "log_bad": 0.5144,
+      "log_good": 0.3287
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 107.0,
+      "good": 100.0,
+      "ratio": 0.9346,
+      "suggested_scalar": -0.0258,
+      "log_bad": 4.6728,
+      "log_good": 4.6052
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9511,
+      "good": 0.9548,
+      "ratio": 1.0039,
+      "suggested_scalar": 0.0015,
+      "log_bad": -0.0501,
+      "log_good": -0.0463
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 28.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3322,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5821,
+      "good": 0.5749,
+      "ratio": 0.9876,
+      "suggested_scalar": -0.0048,
+      "log_bad": -0.5411,
+      "log_good": -0.5536
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3547,
+      "good": 0.3676,
+      "ratio": 1.0364,
+      "suggested_scalar": 0.0136,
+      "log_bad": -1.0365,
+      "log_good": -1.0008
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3929,
+      "good": 2.3521,
+      "ratio": 0.9829,
+      "suggested_scalar": -0.0066,
+      "log_bad": 0.8725,
+      "log_good": 0.8553
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 375.0,
+      "good": 389.0,
+      "ratio": 1.0373,
+      "suggested_scalar": 0.014,
+      "log_bad": 5.9269,
+      "log_good": 5.9636
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 15.0,
+      "good": 20.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1098,
+      "log_bad": 2.7081,
+      "log_good": 2.9957
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0318,
+      "good": 0.0153,
+      "ratio": 0.4811,
+      "suggested_scalar": -0.2792,
+      "log_bad": -3.4483,
+      "log_good": -4.1799
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0444,
+      "good": 6.0444,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7991,
+      "log_good": 1.7991
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 55.0,
+      "good": 47.0,
+      "ratio": 0.8545,
+      "suggested_scalar": -0.06,
+      "log_bad": 4.0073,
+      "log_good": 3.8501
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9243,
+      "good": 0.9564,
+      "ratio": 1.0347,
+      "suggested_scalar": 0.013,
+      "log_bad": -0.0787,
+      "log_good": -0.0446
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.0442,
+      "good": 5.7102,
+      "ratio": 0.9447,
+      "suggested_scalar": -0.0217,
+      "log_bad": 1.7991,
+      "log_good": 1.7423
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8052,
+      "good": 0.8056,
+      "ratio": 1.0005,
+      "suggested_scalar": 0.0002,
+      "log_bad": -0.2167,
+      "log_good": -0.2162
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1552,
+      "good": 0.1475,
+      "ratio": 0.9504,
+      "suggested_scalar": -0.0194,
+      "log_bad": -1.863,
+      "log_good": -1.9139
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.7938,
+      "good": 3.0689,
+      "ratio": 1.0985,
+      "suggested_scalar": 0.0358,
+      "log_bad": 1.0274,
+      "log_good": 1.1213
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2646,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 296.0,
+      "good": 291.0,
+      "ratio": 0.9831,
+      "suggested_scalar": -0.0065,
+      "log_bad": 5.6904,
+      "log_good": 5.6733
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 6.0,
+      "ratio": 6.0,
+      "suggested_scalar": 0.6839,
+      "log_bad": 0.0,
+      "log_good": 1.7918
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6196,
+      "good": 0.6047,
+      "ratio": 0.976,
+      "suggested_scalar": -0.0093,
+      "log_bad": -0.4787,
+      "log_good": -0.503
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 117.0,
+      "good": 102.0,
+      "ratio": 0.8718,
+      "suggested_scalar": -0.0524,
+      "log_bad": 4.7622,
+      "log_good": 4.625
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 892.0,
+      "good": 858.0,
+      "ratio": 0.9619,
+      "suggested_scalar": -0.0148,
+      "log_bad": 6.7935,
+      "log_good": 6.7546
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 127.0,
+      "good": 111.0,
+      "ratio": 0.874,
+      "suggested_scalar": -0.0514,
+      "log_bad": 4.8442,
+      "log_good": 4.7095
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2308,
+      "good": 0.2302,
+      "ratio": 0.9974,
+      "suggested_scalar": -0.001,
+      "log_bad": -1.4662,
+      "log_good": -1.4688
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 70.0,
+      "good": 59.0,
+      "ratio": 0.8429,
+      "suggested_scalar": -0.0653,
+      "log_bad": 4.2485,
+      "log_good": 4.0775
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0852,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 117.0,
+      "good": 102.0,
+      "ratio": 0.8718,
+      "suggested_scalar": -0.0524,
+      "log_bad": 4.7622,
+      "log_good": 4.625
+    },
+    "brevity.mean_sample_size": {
+      "bad": 117.0,
+      "good": 102.0,
+      "ratio": 0.8718,
+      "suggested_scalar": -0.0524,
+      "log_bad": 4.7622,
+      "log_good": 4.625
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 377.0,
+      "good": 391.0,
+      "ratio": 1.0371,
+      "suggested_scalar": 0.0139,
+      "log_bad": 5.9322,
+      "log_good": 5.9687
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 168.0,
+      "good": 208.0,
+      "ratio": 1.2381,
+      "suggested_scalar": 0.0815,
+      "log_bad": 5.124,
+      "log_good": 5.3375
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 244.0,
+      "good": 234.0,
+      "ratio": 0.959,
+      "suggested_scalar": -0.016,
+      "log_bad": 5.4972,
+      "log_good": 5.4553
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0053,
+      "good": 1.0,
+      "ratio": 188.6792,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.24,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.5959,
+      "good": 2.8674,
+      "ratio": 1.7967,
+      "suggested_scalar": 0.2236,
+      "log_bad": 0.4674,
+      "log_good": 1.0534
+    },
+    "halstead.mean_effort": {
+      "bad": 47211.83,
+      "good": 64065.6967,
+      "ratio": 1.357,
+      "suggested_scalar": 0.1165,
+      "log_bad": 10.7624,
+      "log_good": 11.0677
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8798,
+      "good": 0.8558,
+      "ratio": 0.9727,
+      "suggested_scalar": -0.0106,
+      "log_bad": -0.1281,
+      "log_good": -0.1557
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 70.0,
+      "good": 44.0,
+      "ratio": 0.6286,
+      "suggested_scalar": -0.1772,
+      "log_bad": 4.2485,
+      "log_good": 3.7842
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 154.0,
+      "good": 183.0,
+      "ratio": 1.1883,
+      "suggested_scalar": 0.0659,
+      "log_bad": 5.037,
+      "log_good": 5.2095
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4938,
+      "good": 0.4459,
+      "ratio": 0.903,
+      "suggested_scalar": -0.0389,
+      "log_bad": -0.7056,
+      "log_good": -0.8077
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.5062,
+      "good": 5.7973,
+      "ratio": 1.0529,
+      "suggested_scalar": 0.0197,
+      "log_bad": 1.7059,
+      "log_good": 1.7574
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1552,
+      "good": 0.1475,
+      "ratio": 0.9504,
+      "suggested_scalar": -0.0194,
+      "log_bad": -1.863,
+      "log_good": -1.9139
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.6214,
+      "good": 3.5038,
+      "ratio": 0.9675,
+      "suggested_scalar": -0.0126,
+      "log_bad": 1.2869,
+      "log_good": 1.2538
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 376.0,
+      "good": 390.0,
+      "ratio": 1.0372,
+      "suggested_scalar": 0.014,
+      "log_bad": 5.9296,
+      "log_good": 5.9661
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1548,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 54.0,
+      "good": 45.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0696,
+      "log_bad": 3.989,
+      "log_good": 3.8067
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2622.8794,
+      "good": 3559.2054,
+      "ratio": 1.357,
+      "suggested_scalar": 0.1165,
+      "log_bad": 7.872,
+      "log_good": 8.1773
+    },
+    "readability.mean_total_lines": {
+      "bad": 44.0,
+      "good": 51.0,
+      "ratio": 1.1591,
+      "suggested_scalar": 0.0563,
+      "log_bad": 3.7842,
+      "log_good": 3.9318
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1858.7335,
+      "good": 1813.958,
+      "ratio": 0.9759,
+      "suggested_scalar": -0.0093,
+      "log_bad": 7.5277,
+      "log_good": 7.5033
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 649.0,
+      "good": 639.0,
+      "ratio": 0.9846,
+      "suggested_scalar": -0.0059,
+      "log_bad": 6.4754,
+      "log_good": 6.4599
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 26.3864,
+      "good": 27.7255,
+      "ratio": 1.0507,
+      "suggested_scalar": 0.0189,
+      "log_bad": 3.2728,
+      "log_good": 3.3224
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0583,
+      "good": 1.0765,
+      "ratio": 1.0172,
+      "suggested_scalar": 0.0065,
+      "log_bad": 0.0567,
+      "log_good": 0.0737
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 34.0,
+      "good": 33.0,
+      "ratio": 0.9706,
+      "suggested_scalar": -0.0114,
+      "log_bad": 3.5264,
+      "log_good": 3.4965
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 1.0,
+      "ratio": 0.2,
+      "suggested_scalar": -0.6143,
+      "log_bad": 1.6094,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8176,
+      "good": 0.8454,
+      "ratio": 1.034,
+      "suggested_scalar": 0.0128,
+      "log_bad": -0.2014,
+      "log_good": -0.1679
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0696,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9922,
+      "good": 0.9837,
+      "ratio": 0.9914,
+      "suggested_scalar": -0.0033,
+      "log_bad": -0.0078,
+      "log_good": -0.0164
+    },
+    "halstead.mean_length": {
+      "bad": 281.0,
+      "good": 294.0,
+      "ratio": 1.0463,
+      "suggested_scalar": 0.0173,
+      "log_bad": 5.6384,
+      "log_good": 5.6836
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.8,
+      "good": 12.25,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0852,
+      "log_bad": 2.2824,
+      "log_good": 2.5055
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8704,
+      "good": 6.6724,
+      "ratio": 0.9712,
+      "suggested_scalar": -0.0112,
+      "log_bad": 1.9272,
+      "log_good": 1.898
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1083,
+      "good": 0.1386,
+      "ratio": 1.2798,
+      "suggested_scalar": 0.0942,
+      "log_bad": -2.2229,
+      "log_good": -1.9762
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.4,
+      "good": 35.3182,
+      "ratio": 1.3905,
+      "suggested_scalar": 0.1258,
+      "log_bad": 3.2347,
+      "log_good": 3.5644
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0852,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 80.0,
+      "good": 66.0,
+      "ratio": 0.825,
+      "suggested_scalar": -0.0734,
+      "log_bad": 4.382,
+      "log_good": 4.1897
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7131,
+      "good": 0.7479,
+      "ratio": 1.0488,
+      "suggested_scalar": 0.0182,
+      "log_bad": -0.3381,
+      "log_good": -0.2905
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 49.0,
+      "good": 52.0,
+      "ratio": 1.0612,
+      "suggested_scalar": 0.0227,
+      "log_bad": 3.8918,
+      "log_good": 3.9512
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.io_bound_uses_async_await_not_task_run": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 13.0,
+      "good": 19.0,
+      "ratio": 1.4615,
+      "suggested_scalar": 0.1283,
+      "log_bad": 2.5649,
+      "log_good": 2.9444
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0026,
+      "good": 0.0027,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0128,
+      "log_bad": -5.9522,
+      "log_good": -5.9145
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.4,
+      "good": 1.4,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.3365,
+      "log_good": 0.3365
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7321,
+      "good": 0.8039,
+      "ratio": 1.0981,
+      "suggested_scalar": 0.0316,
+      "log_bad": -0.3118,
+      "log_good": -0.2183
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0026,
+      "good": 0.0027,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0128,
+      "log_bad": -5.9522,
+      "log_good": -5.9145
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4525,
+      "good": 4.5794,
+      "ratio": 1.0285,
+      "suggested_scalar": 0.0095,
+      "log_bad": 1.4935,
+      "log_good": 1.5216
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 96.0,
+      "good": 107.0,
+      "ratio": 1.1146,
+      "suggested_scalar": 0.0367,
+      "log_bad": 4.5643,
+      "log_good": 4.6728
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5005,
+      "good": 0.5714,
+      "ratio": 1.1417,
+      "suggested_scalar": 0.0448,
+      "log_bad": -0.6921,
+      "log_good": -0.5597
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7335,
+      "good": 0.7678,
+      "ratio": 1.0468,
+      "suggested_scalar": 0.0155,
+      "log_bad": -0.3099,
+      "log_good": -0.2642
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 9.1429,
+      "good": 8.3922,
+      "ratio": 0.9179,
+      "suggested_scalar": -0.029,
+      "log_bad": 2.213,
+      "log_good": 2.1273
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 383.0,
+      "good": 364.0,
+      "ratio": 0.9504,
+      "suggested_scalar": -0.0172,
+      "log_bad": 5.948,
+      "log_good": 5.8972
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.1138,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0005,
+      "good": 0.0005,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.6009,
+      "log_good": -7.6009
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0714,
+      "good": 0.0784,
+      "ratio": 1.098,
+      "suggested_scalar": 0.0316,
+      "log_bad": -2.6395,
+      "log_good": -2.5459
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9973,
+      "good": 0.9308,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0233,
+      "log_bad": -0.0027,
+      "log_good": -0.0717
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 138.0,
+      "good": 135.0,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.0074,
+      "log_bad": 4.9273,
+      "log_good": 4.9053
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 88.5319,
+      "good": 81.4123,
+      "ratio": 0.9196,
+      "suggested_scalar": -0.0283,
+      "log_bad": 4.4834,
+      "log_good": 4.3995
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6099,
+      "good": 0.5372,
+      "ratio": 0.8808,
+      "suggested_scalar": -0.0429,
+      "log_bad": -0.4945,
+      "log_good": -0.6214
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 22.2426,
+      "good": 23.9685,
+      "ratio": 1.0776,
+      "suggested_scalar": 0.0253,
+      "log_bad": 3.102,
+      "log_good": 3.1767
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2193.0,
+      "good": 2157.0,
+      "ratio": 0.9836,
+      "suggested_scalar": -0.0056,
+      "log_bad": 7.693,
+      "log_good": 7.6765
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0179,
+      "good": 0.0196,
+      "ratio": 1.095,
+      "suggested_scalar": 0.0307,
+      "log_bad": -4.023,
+      "log_good": -3.9322
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6429,
+      "good": 0.7255,
+      "ratio": 1.1285,
+      "suggested_scalar": 0.0409,
+      "log_bad": -0.4418,
+      "log_good": -0.3209
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.8393,
+      "good": 7.1373,
+      "ratio": 1.0436,
+      "suggested_scalar": 0.0144,
+      "log_bad": 1.9227,
+      "log_good": 1.9653
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 22.1224,
+      "good": 18.356,
+      "ratio": 0.8297,
+      "suggested_scalar": -0.0631,
+      "log_bad": 3.0966,
+      "log_good": 2.91
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 41.0,
+      "good": 36.0,
+      "ratio": 0.878,
+      "suggested_scalar": -0.044,
+      "log_bad": 3.7136,
+      "log_good": 3.5835
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9507,
+      "good": 0.9482,
+      "ratio": 0.9974,
+      "suggested_scalar": -0.0009,
+      "log_bad": -0.0506,
+      "log_good": -0.0532
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 26.0,
+      "ratio": 1.04,
+      "suggested_scalar": 0.0133,
+      "log_bad": 3.2189,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6886,
+      "good": 0.6657,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0114,
+      "log_bad": -0.3731,
+      "log_good": -0.4069
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4619,
+      "good": 0.3757,
+      "ratio": 0.8134,
+      "suggested_scalar": -0.0698,
+      "log_bad": -0.7724,
+      "log_good": -0.979
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.2108,
+      "good": 2.9917,
+      "ratio": 0.9318,
+      "suggested_scalar": -0.0239,
+      "log_bad": 1.1665,
+      "log_good": 1.0958
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 381.0,
+      "good": 362.0,
+      "ratio": 0.9501,
+      "suggested_scalar": -0.0173,
+      "log_bad": 5.9428,
+      "log_good": 5.8916
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 14.0,
+      "ratio": 1.2727,
+      "suggested_scalar": 0.0815,
+      "log_bad": 2.3979,
+      "log_good": 2.6391
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 0.0165,
+      "ratio": 0.0165,
+      "suggested_scalar": -1.3879,
+      "log_bad": 0.0,
+      "log_good": -4.1044
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0224,
+      "good": 6.0661,
+      "ratio": 1.0073,
+      "suggested_scalar": 0.0024,
+      "log_bad": 1.7955,
+      "log_good": 1.8027
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 77.0,
+      "good": 73.0,
+      "ratio": 0.9481,
+      "suggested_scalar": -0.018,
+      "log_bad": 4.3438,
+      "log_good": 4.2905
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.5291,
+      "good": 1.6077,
+      "ratio": 1.0514,
+      "suggested_scalar": 0.0169,
+      "log_bad": 0.4247,
+      "log_good": 0.4748
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6801,
+      "good": 5.8775,
+      "ratio": 1.0348,
+      "suggested_scalar": 0.0116,
+      "log_bad": 1.737,
+      "log_good": 1.7711
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7393,
+      "good": 0.7549,
+      "ratio": 1.0211,
+      "suggested_scalar": 0.0071,
+      "log_bad": -0.3021,
+      "log_good": -0.2812
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1111,
+      "good": 0.15,
+      "ratio": 1.3501,
+      "suggested_scalar": 0.1015,
+      "log_bad": -2.1973,
+      "log_good": -1.8971
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.7162,
+      "good": 4.8958,
+      "ratio": 1.0381,
+      "suggested_scalar": 0.0126,
+      "log_bad": 1.551,
+      "log_good": 1.5884
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 272.0,
+      "good": 280.0,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.0098,
+      "log_bad": 5.6058,
+      "log_good": 5.6348
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 18.0,
+      "good": 16.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0398,
+      "log_bad": 2.8904,
+      "log_good": 2.7726
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8297,
+      "good": 0.8135,
+      "ratio": 0.9805,
+      "suggested_scalar": -0.0067,
+      "log_bad": -0.1867,
+      "log_good": -0.2064
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 98.0,
+      "good": 108.0,
+      "ratio": 1.102,
+      "suggested_scalar": 0.0329,
+      "log_bad": 4.585,
+      "log_good": 4.6821
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 996.0,
+      "good": 1067.0,
+      "ratio": 1.0713,
+      "suggested_scalar": 0.0233,
+      "log_bad": 6.9037,
+      "log_good": 6.9726
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 168.0,
+      "good": 168.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.124,
+      "log_good": 5.124
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0131,
+      "good": 0.0027,
+      "ratio": 0.2061,
+      "suggested_scalar": -0.5341,
+      "log_bad": -4.3351,
+      "log_good": -5.9145
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2507,
+      "good": 0.294,
+      "ratio": 1.1727,
+      "suggested_scalar": 0.0539,
+      "log_bad": -1.3835,
+      "log_good": -1.2242
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 70.0,
+      "good": 66.0,
+      "ratio": 0.9429,
+      "suggested_scalar": -0.0199,
+      "log_bad": 4.2485,
+      "log_good": 4.1897
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 98.0,
+      "good": 108.0,
+      "ratio": 1.102,
+      "suggested_scalar": 0.0329,
+      "log_bad": 4.585,
+      "log_good": 4.6821
+    },
+    "brevity.mean_sample_size": {
+      "bad": 98.0,
+      "good": 108.0,
+      "ratio": 1.102,
+      "suggested_scalar": 0.0329,
+      "log_bad": 4.585,
+      "log_good": 4.6821
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 383.0,
+      "good": 364.0,
+      "ratio": 0.9504,
+      "suggested_scalar": -0.0172,
+      "log_bad": 5.948,
+      "log_good": 5.8972
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 186.0,
+      "good": 168.0,
+      "ratio": 0.9032,
+      "suggested_scalar": -0.0344,
+      "log_bad": 5.2257,
+      "log_good": 5.124
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 219.0,
+      "good": 234.0,
+      "ratio": 1.0685,
+      "suggested_scalar": 0.0224,
+      "log_bad": 5.3891,
+      "log_good": 5.4553
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0027,
+      "ratio": 0.0027,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.9145
+    },
+    "heaps.mean_k": {
+      "bad": 1.4129,
+      "good": 1.2427,
+      "ratio": 0.8795,
+      "suggested_scalar": -0.0434,
+      "log_bad": 0.3456,
+      "log_good": 0.2173
+    },
+    "halstead.mean_effort": {
+      "bad": 73621.7357,
+      "good": 65800.7127,
+      "ratio": 0.8938,
+      "suggested_scalar": -0.038,
+      "log_bad": 11.2067,
+      "log_good": 11.0944
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8587,
+      "good": 0.8701,
+      "ratio": 1.0133,
+      "suggested_scalar": 0.0045,
+      "log_bad": -0.1523,
+      "log_good": -0.1391
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 71.0,
+      "good": 81.0,
+      "ratio": 1.1408,
+      "suggested_scalar": 0.0446,
+      "log_bad": 4.2627,
+      "log_good": 4.3944
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 210.0,
+      "good": 194.0,
+      "ratio": 0.9238,
+      "suggested_scalar": -0.0268,
+      "log_bad": 5.3471,
+      "log_good": 5.2679
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4638,
+      "good": 0.5333,
+      "ratio": 1.1498,
+      "suggested_scalar": 0.0472,
+      "log_bad": -0.7683,
+      "log_good": -0.6287
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.2174,
+      "good": 7.9037,
+      "ratio": 1.0951,
+      "suggested_scalar": 0.0307,
+      "log_bad": 1.9765,
+      "log_good": 2.0673
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1111,
+      "good": 0.15,
+      "ratio": 1.3501,
+      "suggested_scalar": 0.1015,
+      "log_bad": -2.1973,
+      "log_good": -1.8971
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.1847,
+      "good": 5.7415,
+      "ratio": 1.1074,
+      "suggested_scalar": 0.0345,
+      "log_bad": 1.6457,
+      "log_good": 1.7477
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 382.0,
+      "good": 363.0,
+      "ratio": 0.9503,
+      "suggested_scalar": -0.0173,
+      "log_bad": 5.9454,
+      "log_good": 5.8944
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 67.0,
+      "good": 54.0,
+      "ratio": 0.806,
+      "suggested_scalar": -0.0729,
+      "log_bad": 4.2047,
+      "log_good": 3.989
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4090.0964,
+      "good": 3655.5952,
+      "ratio": 0.8938,
+      "suggested_scalar": -0.038,
+      "log_bad": 8.3163,
+      "log_good": 8.204
+    },
+    "readability.mean_total_lines": {
+      "bad": 56.0,
+      "good": 51.0,
+      "ratio": 0.9107,
+      "suggested_scalar": -0.0316,
+      "log_bad": 4.0254,
+      "log_good": 3.9318
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2489.1158,
+      "good": 2440.411,
+      "ratio": 0.9804,
+      "suggested_scalar": -0.0067,
+      "log_bad": 7.8197,
+      "log_good": 7.7999
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 683.0,
+      "good": 721.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.0183,
+      "log_bad": 6.5265,
+      "log_good": 6.5806
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 37.9286,
+      "good": 41.1176,
+      "ratio": 1.0841,
+      "suggested_scalar": 0.0273,
+      "log_bad": 3.6357,
+      "log_good": 3.7164
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3163,
+      "good": 1.3969,
+      "ratio": 1.0612,
+      "suggested_scalar": 0.0201,
+      "log_bad": 0.2748,
+      "log_good": 0.3343
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.1138,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 33.0,
+      "good": 33.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4965,
+      "log_good": 3.4965
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7537,
+      "good": 0.8071,
+      "ratio": 1.0709,
+      "suggested_scalar": 0.0231,
+      "log_bad": -0.2828,
+      "log_good": -0.2143
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9608,
+      "good": 0.97,
+      "ratio": 1.0096,
+      "suggested_scalar": 0.0032,
+      "log_bad": -0.04,
+      "log_good": -0.0305
+    },
+    "halstead.mean_length": {
+      "bad": 378.0,
+      "good": 362.0,
+      "ratio": 0.9577,
+      "suggested_scalar": -0.0146,
+      "log_bad": 5.9349,
+      "log_good": 5.8916
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 8.8,
+      "good": 8.2,
+      "ratio": 0.9318,
+      "suggested_scalar": -0.0239,
+      "log_bad": 2.1748,
+      "log_good": 2.1041
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6147,
+      "good": 6.7549,
+      "ratio": 1.0212,
+      "suggested_scalar": 0.0071,
+      "log_bad": 1.8893,
+      "log_good": 1.9103
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.085,
+      "good": 0.0779,
+      "ratio": 0.9165,
+      "suggested_scalar": -0.0295,
+      "log_bad": -2.4651,
+      "log_good": -2.5523
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.5775,
+      "good": 26.963,
+      "ratio": 0.9116,
+      "suggested_scalar": -0.0313,
+      "log_bad": 3.387,
+      "log_good": 3.2945
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 64.0,
+      "good": 72.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0398,
+      "log_bad": 4.1589,
+      "log_good": 4.2767
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6804,
+      "good": 0.7179,
+      "ratio": 1.0551,
+      "suggested_scalar": 0.0181,
+      "log_bad": -0.3851,
+      "log_good": -0.3314
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 56.0,
+      "good": 51.0,
+      "ratio": 0.9107,
+      "suggested_scalar": -0.0316,
+      "log_bad": 4.0254,
+      "log_good": 3.9318
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.no_exceptions_for_control_flow": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 31.0,
+      "good": 53.0,
+      "ratio": 1.7097,
+      "suggested_scalar": 0.1632,
+      "log_bad": 3.434,
+      "log_good": 3.9703
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.211,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0213,
+      "good": 0.0138,
+      "ratio": 0.6479,
+      "suggested_scalar": -0.1321,
+      "log_bad": -3.849,
+      "log_good": -4.2831
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.1818,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0508,
+      "log_bad": 0.0,
+      "log_good": 0.167
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8947,
+      "good": 0.8082,
+      "ratio": 0.9033,
+      "suggested_scalar": -0.0309,
+      "log_bad": -0.1113,
+      "log_good": -0.2129
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0213,
+      "good": 0.0138,
+      "ratio": 0.6479,
+      "suggested_scalar": -0.1321,
+      "log_bad": -3.849,
+      "log_good": -4.2831
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6586,
+      "good": 4.767,
+      "ratio": 1.0233,
+      "suggested_scalar": 0.007,
+      "log_bad": 1.5387,
+      "log_good": 1.5617
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 106.0,
+      "good": 96.0,
+      "ratio": 0.9057,
+      "suggested_scalar": -0.0302,
+      "log_bad": 4.6634,
+      "log_good": 4.5643
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.541,
+      "good": 0.4794,
+      "ratio": 0.8861,
+      "suggested_scalar": -0.0368,
+      "log_bad": -0.6143,
+      "log_good": -0.7352
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 18.0,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.0174,
+      "log_bad": 2.8332,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6426,
+      "good": 0.5542,
+      "ratio": 0.8624,
+      "suggested_scalar": -0.045,
+      "log_bad": -0.4422,
+      "log_good": -0.5902
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.5088,
+      "good": 3.7671,
+      "ratio": 0.6838,
+      "suggested_scalar": -0.1157,
+      "log_bad": 1.7063,
+      "log_good": 1.3263
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 469.0,
+      "good": 650.0,
+      "ratio": 1.3859,
+      "suggested_scalar": 0.0993,
+      "log_bad": 6.1506,
+      "log_good": 6.477
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0014,
+      "good": 1.0,
+      "ratio": 714.2857,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.5713,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0351,
+      "good": 1.0,
+      "ratio": 28.49,
+      "suggested_scalar": 1.0195,
+      "log_bad": -3.3496,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0444,
+      "good": 1.1537,
+      "ratio": 1.1047,
+      "suggested_scalar": 0.0303,
+      "log_bad": 0.0434,
+      "log_good": 0.143
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 151.0,
+      "good": 204.0,
+      "ratio": 1.351,
+      "suggested_scalar": 0.0916,
+      "log_bad": 5.0173,
+      "log_good": 5.3181
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 92.0151,
+      "good": 91.264,
+      "ratio": 0.9918,
+      "suggested_scalar": -0.0025,
+      "log_bad": 4.522,
+      "log_good": 4.5138
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6453,
+      "good": 0.7273,
+      "ratio": 1.1271,
+      "suggested_scalar": 0.0364,
+      "log_bad": -0.438,
+      "log_good": -0.3184
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 16.8672,
+      "good": 25.4045,
+      "ratio": 1.5061,
+      "suggested_scalar": 0.1247,
+      "log_bad": 2.8254,
+      "log_good": 3.2349
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2178.0,
+      "good": 2722.0,
+      "ratio": 1.2498,
+      "suggested_scalar": 0.0679,
+      "log_bad": 7.6862,
+      "log_good": 7.9091
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2456,
+      "good": 0.1233,
+      "ratio": 0.502,
+      "suggested_scalar": -0.2097,
+      "log_bad": -1.4041,
+      "log_good": -2.0931
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8421,
+      "good": 0.7808,
+      "ratio": 0.9272,
+      "suggested_scalar": -0.023,
+      "log_bad": -0.1719,
+      "log_good": -0.2474
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.5273,
+      "good": 8.9041,
+      "ratio": 1.0442,
+      "suggested_scalar": 0.0132,
+      "log_bad": 2.1433,
+      "log_good": 2.1865
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.211,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 7.899,
+      "good": 4.9184,
+      "ratio": 0.6227,
+      "suggested_scalar": -0.1442,
+      "log_bad": 2.0667,
+      "log_good": 1.593
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 108.0,
+      "good": 162.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1234,
+      "log_bad": 4.6821,
+      "log_good": 5.0876
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9549,
+      "good": 0.9583,
+      "ratio": 1.0036,
+      "suggested_scalar": 0.0011,
+      "log_bad": -0.0461,
+      "log_good": -0.0426
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 31.0,
+      "good": 25.0,
+      "ratio": 0.8065,
+      "suggested_scalar": -0.0655,
+      "log_bad": 3.434,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6414,
+      "good": 0.68,
+      "ratio": 1.0602,
+      "suggested_scalar": 0.0178,
+      "log_bad": -0.4441,
+      "log_good": -0.3857
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4454,
+      "good": 0.5417,
+      "ratio": 1.2162,
+      "suggested_scalar": 0.0596,
+      "log_bad": -0.8088,
+      "log_good": -0.613
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7887,
+      "good": 3.1251,
+      "ratio": 1.1206,
+      "suggested_scalar": 0.0347,
+      "log_bad": 1.0256,
+      "log_good": 1.1395
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 467.0,
+      "good": 648.0,
+      "ratio": 1.3876,
+      "suggested_scalar": 0.0997,
+      "log_bad": 6.1463,
+      "log_good": 6.4739
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 30.0,
+      "good": 14.0,
+      "ratio": 0.4667,
+      "suggested_scalar": -0.232,
+      "log_bad": 3.4012,
+      "log_good": 2.6391
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.032,
+      "good": 0.0262,
+      "ratio": 0.8187,
+      "suggested_scalar": -0.0609,
+      "log_bad": -3.442,
+      "log_good": -3.642
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.8826,
+      "ratio": 1.0085,
+      "suggested_scalar": 0.0026,
+      "log_bad": 1.7635,
+      "log_good": 1.772
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 42.0,
+      "good": 40.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0148,
+      "log_bad": 3.7377,
+      "log_good": 3.6889
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9072,
+      "good": 0.7904,
+      "ratio": 0.8713,
+      "suggested_scalar": -0.0419,
+      "log_bad": -0.0974,
+      "log_good": -0.2352
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6895,
+      "good": 5.5559,
+      "ratio": 0.9765,
+      "suggested_scalar": -0.0072,
+      "log_bad": 1.7386,
+      "log_good": 1.7149
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7987,
+      "good": 0.8103,
+      "ratio": 1.0145,
+      "suggested_scalar": 0.0044,
+      "log_bad": -0.2248,
+      "log_good": -0.2104
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1618,
+      "good": 0.131,
+      "ratio": 0.8096,
+      "suggested_scalar": -0.0643,
+      "log_bad": -1.8214,
+      "log_good": -2.0326
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.107,
+      "good": 5.0403,
+      "ratio": 1.2272,
+      "suggested_scalar": 0.0623,
+      "log_bad": 1.4127,
+      "log_good": 1.6175
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 342.0,
+      "good": 408.0,
+      "ratio": 1.193,
+      "suggested_scalar": 0.0537,
+      "log_bad": 5.8348,
+      "log_good": 6.0113
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 13.0,
+      "ratio": 13.0,
+      "suggested_scalar": 0.7807,
+      "log_bad": 0.0,
+      "log_good": 2.5649
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9486,
+      "good": 1.2599,
+      "ratio": 1.3282,
+      "suggested_scalar": 0.0864,
+      "log_bad": -0.0528,
+      "log_good": 0.231
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 109.0,
+      "good": 116.0,
+      "ratio": 1.0642,
+      "suggested_scalar": 0.0189,
+      "log_bad": 4.6913,
+      "log_good": 4.7536
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1205.0,
+      "good": 1588.0,
+      "ratio": 1.3178,
+      "suggested_scalar": 0.084,
+      "log_bad": 7.0942,
+      "log_good": 7.3702
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 149.0,
+      "good": 184.0,
+      "ratio": 1.2349,
+      "suggested_scalar": 0.0642,
+      "log_bad": 5.0039,
+      "log_good": 5.2149
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0192,
+      "good": 0.0138,
+      "ratio": 0.7188,
+      "suggested_scalar": -0.1005,
+      "log_bad": -3.9528,
+      "log_good": -4.2831
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2751,
+      "good": 0.2754,
+      "ratio": 1.0011,
+      "suggested_scalar": 0.0003,
+      "log_bad": -1.2906,
+      "log_good": -1.2895
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 106.0,
+      "good": 118.0,
+      "ratio": 1.1132,
+      "suggested_scalar": 0.0326,
+      "log_bad": 4.6634,
+      "log_good": 4.7707
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 11.0,
+      "ratio": 5.5,
+      "suggested_scalar": 0.5188,
+      "log_bad": 0.6931,
+      "log_good": 2.3979
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 109.0,
+      "good": 116.0,
+      "ratio": 1.0642,
+      "suggested_scalar": 0.0189,
+      "log_bad": 4.6913,
+      "log_good": 4.7536
+    },
+    "brevity.mean_sample_size": {
+      "bad": 109.0,
+      "good": 116.0,
+      "ratio": 1.0642,
+      "suggested_scalar": 0.0189,
+      "log_bad": 4.6913,
+      "log_good": 4.7536
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 469.0,
+      "good": 650.0,
+      "ratio": 1.3859,
+      "suggested_scalar": 0.0993,
+      "log_bad": 6.1506,
+      "log_good": 6.477
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 265.0,
+      "good": 380.0,
+      "ratio": 1.434,
+      "suggested_scalar": 0.1097,
+      "log_bad": 5.5797,
+      "log_good": 5.9402
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 272.0,
+      "good": 295.0,
+      "ratio": 1.0846,
+      "suggested_scalar": 0.0247,
+      "log_bad": 5.6058,
+      "log_good": 5.687
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.2706,
+      "good": 3.3312,
+      "ratio": 1.4671,
+      "suggested_scalar": 0.1167,
+      "log_bad": 0.82,
+      "log_good": 1.2033
+    },
+    "halstead.mean_effort": {
+      "bad": 87635.0661,
+      "good": 122443.2041,
+      "ratio": 1.3972,
+      "suggested_scalar": 0.1018,
+      "log_bad": 11.3809,
+      "log_good": 11.7154
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8406,
+      "good": 0.8101,
+      "ratio": 0.9637,
+      "suggested_scalar": -0.0112,
+      "log_bad": -0.1736,
+      "log_good": -0.2106
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 75.0,
+      "good": 71.0,
+      "ratio": 0.9467,
+      "suggested_scalar": -0.0167,
+      "log_bad": 4.3175,
+      "log_good": 4.2627
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 274.0,
+      "good": 390.0,
+      "ratio": 1.4234,
+      "suggested_scalar": 0.1074,
+      "log_bad": 5.6131,
+      "log_good": 5.9661
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4768,
+      "good": 0.3971,
+      "ratio": 0.8328,
+      "suggested_scalar": -0.0557,
+      "log_bad": -0.7407,
+      "log_good": -0.9236
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.9801,
+      "good": 7.7843,
+      "ratio": 0.9755,
+      "suggested_scalar": -0.0076,
+      "log_bad": 2.077,
+      "log_good": 2.0521
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1618,
+      "good": 0.131,
+      "ratio": 0.8096,
+      "suggested_scalar": -0.0643,
+      "log_bad": -1.8214,
+      "log_good": -2.0326
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.5874,
+      "good": 5.1913,
+      "ratio": 1.1316,
+      "suggested_scalar": 0.0376,
+      "log_bad": 1.5233,
+      "log_good": 1.647
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 468.0,
+      "good": 649.0,
+      "ratio": 1.3868,
+      "suggested_scalar": 0.0995,
+      "log_bad": 6.1485,
+      "log_good": 6.4754
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 7.0,
+      "good": 10.0,
+      "ratio": 1.4286,
+      "suggested_scalar": 0.1086,
+      "log_bad": 1.9459,
+      "log_good": 2.3026
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 83.0,
+      "good": 111.0,
+      "ratio": 1.3373,
+      "suggested_scalar": 0.0885,
+      "log_bad": 4.4188,
+      "log_good": 4.7095
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4868.6148,
+      "good": 6802.4002,
+      "ratio": 1.3972,
+      "suggested_scalar": 0.1018,
+      "log_bad": 8.4906,
+      "log_good": 8.825
+    },
+    "readability.mean_total_lines": {
+      "bad": 55.0,
+      "good": 73.0,
+      "ratio": 1.3273,
+      "suggested_scalar": 0.0862,
+      "log_bad": 4.0073,
+      "log_good": 4.2905
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 9.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0321,
+      "log_bad": 2.3026,
+      "log_good": 2.1972
+    },
+    "halstead.mean_volume": {
+      "bad": 2845.9104,
+      "good": 3779.7685,
+      "ratio": 1.3281,
+      "suggested_scalar": 0.0864,
+      "log_bad": 7.9536,
+      "log_good": 8.2374
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 781.0,
+      "good": 871.0,
+      "ratio": 1.1152,
+      "suggested_scalar": 0.0332,
+      "log_bad": 6.6606,
+      "log_good": 6.7696
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.8545,
+      "good": 36.1096,
+      "ratio": 1.0071,
+      "suggested_scalar": 0.0022,
+      "log_bad": 3.5795,
+      "log_good": 3.5866
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2549,
+      "good": 1.2593,
+      "ratio": 1.0035,
+      "suggested_scalar": 0.0011,
+      "log_bad": 0.2271,
+      "log_good": 0.2306
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 34.0,
+      "good": 32.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0185,
+      "log_bad": 3.5264,
+      "log_good": 3.4657
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.211,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7573,
+      "good": 0.7279,
+      "ratio": 0.9612,
+      "suggested_scalar": -0.0121,
+      "log_bad": -0.278,
+      "log_good": -0.3176
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.211,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9718,
+      "good": 0.9703,
+      "ratio": 0.9985,
+      "suggested_scalar": -0.0005,
+      "log_bad": -0.0286,
+      "log_good": -0.0301
+    },
+    "halstead.mean_length": {
+      "bad": 423.0,
+      "good": 574.0,
+      "ratio": 1.357,
+      "suggested_scalar": 0.0929,
+      "log_bad": 6.0474,
+      "log_good": 6.3526
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 29.0,
+      "good": 6.3636,
+      "ratio": 0.2194,
+      "suggested_scalar": -0.4616,
+      "log_bad": 3.3673,
+      "log_good": 1.8506
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7682,
+      "good": 6.858,
+      "ratio": 1.0133,
+      "suggested_scalar": 0.004,
+      "log_bad": 1.9122,
+      "log_good": 1.9254
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1217,
+      "good": 0.1397,
+      "ratio": 1.1479,
+      "suggested_scalar": 0.042,
+      "log_bad": -2.1062,
+      "log_good": -1.9683
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.7933,
+      "good": 32.3944,
+      "ratio": 1.052,
+      "suggested_scalar": 0.0154,
+      "log_bad": 3.4273,
+      "log_good": 3.478
+    },
+    "branching.mean_branch_count": {
+      "bad": 14.0,
+      "good": 9.0,
+      "ratio": 0.6429,
+      "suggested_scalar": -0.1345,
+      "log_bad": 2.6391,
+      "log_good": 2.1972
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 72.0,
+      "good": 81.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0358,
+      "log_bad": 4.2767,
+      "log_good": 4.3944
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6103,
+      "good": 0.6,
+      "ratio": 0.9831,
+      "suggested_scalar": -0.0052,
+      "log_bad": -0.4938,
+      "log_good": -0.5108
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 57.0,
+      "good": 73.0,
+      "ratio": 1.2807,
+      "suggested_scalar": 0.0753,
+      "log_bad": 4.0431,
+      "log_good": 4.2905
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 22.0,
+      "good": 24.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0265,
+      "log_bad": 3.091,
+      "log_good": 3.1781
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.uses_copied_on_copy_types": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6667,
+      "good": 1.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.5108,
+      "log_good": 0.5108
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7381,
+      "good": 0.7317,
+      "ratio": 0.9913,
+      "suggested_scalar": -0.0587,
+      "log_bad": -0.3037,
+      "log_good": -0.3124
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5356,
+      "good": 4.4899,
+      "ratio": 0.9899,
+      "suggested_scalar": -0.0682,
+      "log_bad": 1.512,
+      "log_good": 1.5018
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 72.0,
+      "good": 70.0,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.1897,
+      "log_bad": 4.2767,
+      "log_good": 4.2485
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4173,
+      "good": 0.42,
+      "ratio": 1.0065,
+      "suggested_scalar": 0.0434,
+      "log_bad": -0.8739,
+      "log_good": -0.8675
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6005,
+      "good": 0.6118,
+      "ratio": 1.0188,
+      "suggested_scalar": 0.1256,
+      "log_bad": -0.51,
+      "log_good": -0.4913
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.7619,
+      "good": 6.7317,
+      "ratio": 0.9955,
+      "suggested_scalar": -0.0301,
+      "log_bad": 1.9113,
+      "log_good": 1.9068
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 359.0,
+      "good": 335.0,
+      "ratio": 0.9331,
+      "suggested_scalar": -0.466,
+      "log_bad": 5.8833,
+      "log_good": 5.8141
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0952,
+      "good": 0.0732,
+      "ratio": 0.7689,
+      "suggested_scalar": -1.77,
+      "log_bad": -2.3518,
+      "log_good": -2.6146
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0015,
+      "good": 0.0016,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.4347,
+      "log_bad": -6.5023,
+      "log_good": -6.4378
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0664,
+      "good": 1.0549,
+      "ratio": 0.9892,
+      "suggested_scalar": -0.073,
+      "log_bad": 0.0643,
+      "log_good": 0.0534
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 114.0,
+      "good": 103.0,
+      "ratio": 0.9035,
+      "suggested_scalar": -0.6835,
+      "log_bad": 4.7362,
+      "log_good": 4.6347
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 109.0472,
+      "good": 109.1074,
+      "ratio": 1.0006,
+      "suggested_scalar": 0.0037,
+      "log_bad": 4.6918,
+      "log_good": 4.6923
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6564,
+      "good": 0.6587,
+      "ratio": 1.0035,
+      "suggested_scalar": 0.0236,
+      "log_bad": -0.421,
+      "log_good": -0.4175
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.1269,
+      "good": 10.628,
+      "ratio": 1.0495,
+      "suggested_scalar": 0.3253,
+      "log_bad": 2.3152,
+      "log_good": 2.3635
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1364.0,
+      "good": 1293.0,
+      "ratio": 0.9479,
+      "suggested_scalar": -0.3601,
+      "log_bad": 7.2182,
+      "log_good": 7.1647
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7143,
+      "good": 0.7073,
+      "ratio": 0.9902,
+      "suggested_scalar": -0.0663,
+      "log_bad": -0.3365,
+      "log_good": -0.3463
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.5476,
+      "good": 8.1707,
+      "ratio": 0.9559,
+      "suggested_scalar": -0.3037,
+      "log_bad": 2.1457,
+      "log_good": 2.1006
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 19.0,
+      "good": 17.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.7492,
+      "log_bad": 2.9444,
+      "log_good": 2.8332
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 15.61,
+      "good": 15.9524,
+      "ratio": 1.0219,
+      "suggested_scalar": 0.1461,
+      "log_bad": 2.7479,
+      "log_good": 2.7696
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 74.0,
+      "good": 70.0,
+      "ratio": 0.9459,
+      "suggested_scalar": -0.3743,
+      "log_bad": 4.3041,
+      "log_good": 4.2485
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9301,
+      "good": 0.9215,
+      "ratio": 0.9908,
+      "suggested_scalar": -0.0626,
+      "log_bad": -0.0725,
+      "log_good": -0.0818
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 24.0,
+      "ratio": 1.0435,
+      "suggested_scalar": 0.2867,
+      "log_bad": 3.1355,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6386,
+      "good": 0.6365,
+      "ratio": 0.9967,
+      "suggested_scalar": -0.0222,
+      "log_bad": -0.4485,
+      "log_good": -0.4518
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.521,
+      "good": 0.5135,
+      "ratio": 0.9856,
+      "suggested_scalar": -0.0977,
+      "log_bad": -0.652,
+      "log_good": -0.6665
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7667,
+      "good": 2.7511,
+      "ratio": 0.9944,
+      "suggested_scalar": -0.0381,
+      "log_bad": 1.0177,
+      "log_good": 1.012
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 357.0,
+      "good": 333.0,
+      "ratio": 0.9328,
+      "suggested_scalar": -0.4687,
+      "log_bad": 5.8777,
+      "log_good": 5.8081
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0362,
+      "good": 0.0269,
+      "ratio": 0.7431,
+      "suggested_scalar": -2.0,
+      "log_bad": -3.3187,
+      "log_good": -3.6156
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8826,
+      "good": 5.8329,
+      "ratio": 0.9916,
+      "suggested_scalar": -0.0571,
+      "log_bad": 1.772,
+      "log_good": 1.7635
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 21.0,
+      "good": 16.0,
+      "ratio": 0.7619,
+      "suggested_scalar": -1.8316,
+      "log_bad": 3.0445,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2851,
+      "good": 1.225,
+      "ratio": 0.9532,
+      "suggested_scalar": -0.3226,
+      "log_bad": 0.2508,
+      "log_good": 0.2029
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.3017,
+      "good": 5.2769,
+      "ratio": 0.9953,
+      "suggested_scalar": -0.0316,
+      "log_bad": 1.668,
+      "log_good": 1.6633
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.771,
+      "good": 0.7698,
+      "ratio": 0.9984,
+      "suggested_scalar": -0.0105,
+      "log_bad": -0.2601,
+      "log_good": -0.2616
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.125,
+      "good": 0.1277,
+      "ratio": 1.0216,
+      "suggested_scalar": 0.1439,
+      "log_bad": -2.0794,
+      "log_good": -2.0581
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1823,
+      "good": 3.2601,
+      "ratio": 1.0244,
+      "suggested_scalar": 0.1627,
+      "log_bad": 1.1576,
+      "log_good": 1.1818
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 227.0,
+      "good": 216.0,
+      "ratio": 0.9515,
+      "suggested_scalar": -0.3346,
+      "log_bad": 5.425,
+      "log_good": 5.3753
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7157,
+      "good": 0.662,
+      "ratio": 0.925,
+      "suggested_scalar": -0.5253,
+      "log_bad": -0.3345,
+      "log_good": -0.4125
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 74.0,
+      "good": 72.0,
+      "ratio": 0.973,
+      "suggested_scalar": -0.1845,
+      "log_bad": 4.3041,
+      "log_good": 4.2767
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 587.0,
+      "good": 556.0,
+      "ratio": 0.9472,
+      "suggested_scalar": -0.3654,
+      "log_bad": 6.375,
+      "log_good": 6.3208
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 130.0,
+      "good": 117.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.7097,
+      "log_bad": 4.8675,
+      "log_good": 4.7622
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0167,
+      "good": 0.0179,
+      "ratio": 1.0719,
+      "suggested_scalar": 0.4674,
+      "log_bad": -4.0923,
+      "log_good": -4.023
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2618,
+      "good": 0.2567,
+      "ratio": 0.9805,
+      "suggested_scalar": -0.1325,
+      "log_bad": -1.3402,
+      "log_good": -1.3598
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 60.0,
+      "good": 58.0,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.2283,
+      "log_bad": 4.0943,
+      "log_good": 4.0604
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 74.0,
+      "good": 72.0,
+      "ratio": 0.973,
+      "suggested_scalar": -0.1845,
+      "log_bad": 4.3041,
+      "log_good": 4.2767
+    },
+    "brevity.mean_sample_size": {
+      "bad": 74.0,
+      "good": 72.0,
+      "ratio": 0.973,
+      "suggested_scalar": -0.1845,
+      "log_bad": 4.3041,
+      "log_good": 4.2767
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 359.0,
+      "good": 335.0,
+      "ratio": 0.9331,
+      "suggested_scalar": -0.466,
+      "log_bad": 5.8833,
+      "log_good": 5.8141
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 209.0,
+      "good": 195.0,
+      "ratio": 0.933,
+      "suggested_scalar": -0.467,
+      "log_bad": 5.3423,
+      "log_good": 5.273
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 183.0,
+      "good": 172.0,
+      "ratio": 0.9399,
+      "suggested_scalar": -0.4175,
+      "log_bad": 5.2095,
+      "log_good": 5.1475
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.248,
+      "good": 2.201,
+      "ratio": 0.9791,
+      "suggested_scalar": -0.1423,
+      "log_bad": 0.81,
+      "log_good": 0.7889
+    },
+    "halstead.mean_effort": {
+      "bad": 65509.4935,
+      "good": 60612.7462,
+      "ratio": 0.9253,
+      "suggested_scalar": -0.5233,
+      "log_bad": 11.09,
+      "log_good": 11.0123
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8538,
+      "good": 0.8553,
+      "ratio": 1.0018,
+      "suggested_scalar": 0.0118,
+      "log_bad": -0.1581,
+      "log_good": -0.1563
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 49.0,
+      "good": 46.0,
+      "ratio": 0.9388,
+      "suggested_scalar": -0.4255,
+      "log_bad": 3.8918,
+      "log_good": 3.8286
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 218.0,
+      "good": 207.0,
+      "ratio": 0.9495,
+      "suggested_scalar": -0.3487,
+      "log_bad": 5.3845,
+      "log_good": 5.3327
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3772,
+      "good": 0.4078,
+      "ratio": 1.0811,
+      "suggested_scalar": 0.5254,
+      "log_bad": -0.975,
+      "log_good": -0.897
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.1491,
+      "good": 5.3981,
+      "ratio": 1.0484,
+      "suggested_scalar": 0.3181,
+      "log_bad": 1.6388,
+      "log_good": 1.686
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.125,
+      "good": 0.1277,
+      "ratio": 1.0216,
+      "suggested_scalar": 0.1439,
+      "log_bad": -2.0794,
+      "log_good": -2.0581
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.6857,
+      "good": 3.554,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.2451,
+      "log_bad": 1.3045,
+      "log_good": 1.2681
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 358.0,
+      "good": 334.0,
+      "ratio": 0.933,
+      "suggested_scalar": -0.4674,
+      "log_bad": 5.8805,
+      "log_good": 5.8111
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 56.0,
+      "good": 54.0,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.245,
+      "log_bad": 4.0254,
+      "log_good": 3.989
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3639.4163,
+      "good": 3367.3748,
+      "ratio": 0.9253,
+      "suggested_scalar": -0.5233,
+      "log_bad": 8.1996,
+      "log_good": 8.1219
+    },
+    "readability.mean_total_lines": {
+      "bad": 42.0,
+      "good": 41.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.1623,
+      "log_bad": 3.7377,
+      "log_good": 3.7136
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2147.1339,
+      "good": 1985.8877,
+      "ratio": 0.9249,
+      "suggested_scalar": -0.5258,
+      "log_bad": 7.6719,
+      "log_good": 7.5938
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 493.0,
+      "good": 470.0,
+      "ratio": 0.9533,
+      "suggested_scalar": -0.3218,
+      "log_bad": 6.2005,
+      "log_good": 6.1527
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.1905,
+      "good": 30.2439,
+      "ratio": 0.9697,
+      "suggested_scalar": -0.2076,
+      "log_bad": 3.4401,
+      "log_good": 3.4093
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0533,
+      "good": 1.0571,
+      "ratio": 1.0036,
+      "suggested_scalar": 0.0243,
+      "log_bad": 0.0519,
+      "log_good": 0.0555
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 32.0,
+      "good": 30.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.4347,
+      "log_bad": 3.4657,
+      "log_good": 3.4012
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -1.9377,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7533,
+      "good": 0.75,
+      "ratio": 0.9956,
+      "suggested_scalar": -0.0296,
+      "log_bad": -0.2833,
+      "log_good": -0.2877
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9869,
+      "good": 0.9755,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0783,
+      "log_bad": -0.0132,
+      "log_good": -0.0248
+    },
+    "halstead.mean_length": {
+      "bad": 348.0,
+      "good": 324.0,
+      "ratio": 0.931,
+      "suggested_scalar": -0.4813,
+      "log_bad": 5.8522,
+      "log_good": 5.7807
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.0,
+      "good": 6.8333,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.1623,
+      "log_bad": 1.9459,
+      "log_good": 1.9218
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2095,
+      "good": 6.1699,
+      "ratio": 0.9936,
+      "suggested_scalar": -0.0431,
+      "log_bad": 1.8261,
+      "log_good": 1.8197
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1539,
+      "good": 0.1515,
+      "ratio": 0.9844,
+      "suggested_scalar": -0.1059,
+      "log_bad": -1.8715,
+      "log_good": -1.8872
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.5102,
+      "good": 30.5217,
+      "ratio": 1.0004,
+      "suggested_scalar": 0.0025,
+      "log_bad": 3.4181,
+      "log_good": 3.4184
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 43.0,
+      "good": 42.0,
+      "ratio": 0.9767,
+      "suggested_scalar": -0.1585,
+      "log_bad": 3.7612,
+      "log_good": 3.7377
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6721,
+      "good": 0.6628,
+      "ratio": 0.9862,
+      "suggested_scalar": -0.0939,
+      "log_bad": -0.3973,
+      "log_good": -0.4113
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 42.0,
+      "good": 41.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.1623,
+      "log_bad": 3.7377,
+      "log_good": 3.7136
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.function_name_is_not_single_word": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 26.0,
+      "good": 26.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2581,
+      "log_good": 3.2581
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0036,
+      "good": 0.0036,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.6268,
+      "log_good": -5.6268
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8056,
+      "good": 0.8056,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2162,
+      "log_good": -0.2162
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0036,
+      "good": 0.0036,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.6268,
+      "log_good": -5.6268
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5323,
+      "good": 4.6244,
+      "ratio": 1.0203,
+      "suggested_scalar": 0.0245,
+      "log_bad": 1.5112,
+      "log_good": 1.5313
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 49.0,
+      "good": 49.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8918,
+      "log_good": 3.8918
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3506,
+      "good": 0.3506,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.0481,
+      "log_good": -1.0481
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "heaps.mean_beta": {
+      "bad": 0.521,
+      "good": 0.521,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.652,
+      "log_good": -0.652
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.6667,
+      "good": 2.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9808,
+      "log_good": 0.9808
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 279.0,
+      "good": 279.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.6312,
+      "log_good": 5.6312
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1164,
+      "good": 1.1164,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1101,
+      "log_good": 0.1101
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 77.0,
+      "good": 77.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3438,
+      "log_good": 4.3438
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 110.8729,
+      "good": 85.0035,
+      "ratio": 0.7667,
+      "suggested_scalar": -0.3241,
+      "log_bad": 4.7084,
+      "log_good": 4.4427
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.777,
+      "good": 0.777,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2523,
+      "log_good": -0.2523
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 6.3259,
+      "good": 32.5947,
+      "ratio": 5.1526,
+      "suggested_scalar": 2.0,
+      "log_bad": 1.8447,
+      "log_good": 3.4841
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 856.0,
+      "good": 1049.0,
+      "ratio": 1.2255,
+      "suggested_scalar": 0.248,
+      "log_bad": 6.7523,
+      "log_good": 6.9556
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7778,
+      "good": 0.7778,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2513,
+      "log_good": -0.2513
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.75,
+      "good": 7.75,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0477,
+      "log_good": 2.0477
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 68.0,
+      "good": 68.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2195,
+      "log_good": 4.2195
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9264,
+      "good": 0.9264,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0764,
+      "log_good": -0.0764
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6227,
+      "good": 0.6644,
+      "ratio": 1.067,
+      "suggested_scalar": 0.0791,
+      "log_bad": -0.4737,
+      "log_good": -0.4089
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5704,
+      "good": 0.5704,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.5614,
+      "log_good": -0.5614
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6502,
+      "good": 2.9801,
+      "ratio": 1.1245,
+      "suggested_scalar": 0.1431,
+      "log_bad": 0.9746,
+      "log_good": 1.092
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 277.0,
+      "good": 277.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.624,
+      "log_good": 5.624
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0287,
+      "good": 0.0287,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.5509,
+      "log_good": -3.5509
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.3923,
+      "good": 5.3923,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.685,
+      "log_good": 1.685
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6277,
+      "good": 0.6277,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.4657,
+      "log_good": -0.4657
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 4.8479,
+      "good": 4.8479,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.5785,
+      "log_good": 1.5785
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8405,
+      "good": 0.8576,
+      "ratio": 1.0203,
+      "suggested_scalar": 0.0246,
+      "log_bad": -0.1738,
+      "log_good": -0.1536
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2174,
+      "good": 0.2174,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.526,
+      "log_good": -1.526
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.5151,
+      "good": 5.7092,
+      "ratio": 2.27,
+      "suggested_scalar": 1.0,
+      "log_bad": 0.9223,
+      "log_good": 1.7421
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 169.0,
+      "good": 169.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.1299,
+      "log_good": 5.1299
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5147,
+      "good": 0.5147,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.6642,
+      "log_good": -0.6642
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 51.0,
+      "good": 51.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9318,
+      "log_good": 3.9318
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 350.0,
+      "good": 543.0,
+      "ratio": 1.5514,
+      "suggested_scalar": 0.5357,
+      "log_bad": 5.8579,
+      "log_good": 6.2971
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 85.0,
+      "good": 85.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.4427,
+      "log_good": 4.4427
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.3047,
+      "good": 0.3047,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.1884,
+      "log_good": -1.1884
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 61.0,
+      "good": 61.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.1109,
+      "log_good": 4.1109
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 51.0,
+      "good": 51.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9318,
+      "log_good": 3.9318
+    },
+    "brevity.mean_sample_size": {
+      "bad": 51.0,
+      "good": 51.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9318,
+      "log_good": 3.9318
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 279.0,
+      "good": 279.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.6312,
+      "log_good": 5.6312
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 157.0,
+      "good": 157.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.0562,
+      "log_good": 5.0562
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 123.0,
+      "good": 123.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.8122,
+      "log_good": 4.8122
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.5891,
+      "good": 2.5891,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9513,
+      "log_good": 0.9513
+    },
+    "halstead.mean_effort": {
+      "bad": 34861.6457,
+      "good": 34861.6457,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 10.4591,
+      "log_good": 10.4591
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8546,
+      "good": 0.8546,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1571,
+      "log_good": -0.1571
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 32.0,
+      "good": 32.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4657,
+      "log_good": 3.4657
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 190.0,
+      "good": 190.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.247,
+      "log_good": 5.247
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3506,
+      "good": 0.3506,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.0481,
+      "log_good": -1.0481
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.5455,
+      "good": 7.0519,
+      "ratio": 1.5514,
+      "suggested_scalar": 0.5357,
+      "log_bad": 1.5141,
+      "log_good": 1.9533
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2174,
+      "good": 0.2174,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.526,
+      "log_good": -1.526
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.1,
+      "good": 9.381,
+      "ratio": 3.0261,
+      "suggested_scalar": 1.3508,
+      "log_bad": 1.1314,
+      "log_good": 2.2387
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 278.0,
+      "good": 278.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.6276,
+      "log_good": 5.6276
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 50.0,
+      "good": 50.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.912,
+      "log_good": 3.912
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1936.7581,
+      "good": 1936.7581,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 7.5688,
+      "log_good": 7.5688
+    },
+    "readability.mean_total_lines": {
+      "bad": 36.0,
+      "good": 36.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5835,
+      "log_good": 3.5835
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1544.0452,
+      "good": 1544.0452,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 7.3422,
+      "log_good": 7.3422
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 323.0,
+      "good": 352.0,
+      "ratio": 1.0898,
+      "suggested_scalar": 0.1049,
+      "log_bad": 5.7777,
+      "log_good": 5.8636
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 22.5,
+      "good": 27.8611,
+      "ratio": 1.2383,
+      "suggested_scalar": 0.2607,
+      "log_bad": 3.1135,
+      "log_good": 3.3272
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0413,
+      "good": 1.3471,
+      "ratio": 1.2937,
+      "suggested_scalar": 0.3141,
+      "log_bad": 0.0405,
+      "log_good": 0.298
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7041,
+      "good": 0.7041,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3508,
+      "log_good": -0.3508
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9727,
+      "good": 0.9727,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0277,
+      "log_good": -0.0277
+    },
+    "halstead.mean_length": {
+      "bad": 275.0,
+      "good": 275.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.6168,
+      "log_good": 5.6168
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 3.75,
+      "good": 3.75,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3218,
+      "log_good": 1.3218
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.6724,
+      "good": 5.6724,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7356,
+      "log_good": 1.7356
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1834,
+      "good": 0.1497,
+      "ratio": 0.8162,
+      "suggested_scalar": -0.2477,
+      "log_bad": -1.6961,
+      "log_good": -1.8991
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 22.5781,
+      "good": 22.5781,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.117,
+      "log_good": 3.117
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5041,
+      "good": 0.5041,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.685,
+      "log_good": -0.685
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 36.0,
+      "good": 36.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.5835,
+      "log_good": 3.5835
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 10.0,
+      "good": 19.0,
+      "ratio": 1.9,
+      "suggested_scalar": 0.783,
+      "log_bad": 2.3026,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.does_not_swallow_errors_silently": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 16.0,
+      "good": 17.0,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.021,
+      "log_bad": 2.7726,
+      "log_good": 2.8332
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.1165,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.24,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0062,
+      "good": 0.0077,
+      "ratio": 1.2419,
+      "suggested_scalar": 0.075,
+      "log_bad": -5.0832,
+      "log_good": -4.8665
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 1.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1404,
+      "log_bad": 0.4055,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7358,
+      "good": 0.7857,
+      "ratio": 1.0678,
+      "suggested_scalar": 0.0227,
+      "log_bad": -0.3068,
+      "log_good": -0.2412
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0062,
+      "good": 0.0102,
+      "ratio": 1.6452,
+      "suggested_scalar": 0.1724,
+      "log_bad": -5.0832,
+      "log_good": -4.5854
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6146,
+      "good": 4.6806,
+      "ratio": 1.0143,
+      "suggested_scalar": 0.0049,
+      "log_bad": 1.5292,
+      "log_good": 1.5434
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 69.0,
+      "good": 83.0,
+      "ratio": 1.2029,
+      "suggested_scalar": 0.064,
+      "log_bad": 4.2341,
+      "log_good": 4.4188
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4524,
+      "good": 0.4375,
+      "ratio": 0.9671,
+      "suggested_scalar": -0.0116,
+      "log_bad": -0.7932,
+      "log_good": -0.8267
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 19.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.0187,
+      "log_bad": 2.8904,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5726,
+      "good": 0.5839,
+      "ratio": 1.0197,
+      "suggested_scalar": 0.0068,
+      "log_bad": -0.5576,
+      "log_good": -0.538
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.3585,
+      "good": 3.6786,
+      "ratio": 1.0953,
+      "suggested_scalar": 0.0315,
+      "log_bad": 1.2115,
+      "log_good": 1.3025
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 325.0,
+      "good": 392.0,
+      "ratio": 1.2062,
+      "suggested_scalar": 0.0649,
+      "log_bad": 5.7838,
+      "log_good": 5.9713
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 7.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.1165,
+      "log_bad": 1.6094,
+      "log_good": 1.9459
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0008,
+      "good": 0.0018,
+      "ratio": 2.25,
+      "suggested_scalar": 0.2808,
+      "log_bad": -7.1309,
+      "log_good": -6.32
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 0.0179,
+      "ratio": 0.0179,
+      "suggested_scalar": -1.3929,
+      "log_bad": 0.0,
+      "log_good": -4.023
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0015,
+      "good": 0.0024,
+      "ratio": 1.6,
+      "suggested_scalar": 0.1627,
+      "log_bad": -6.5023,
+      "log_good": -6.0323
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0499,
+      "good": 1.052,
+      "ratio": 1.002,
+      "suggested_scalar": 0.0007,
+      "log_bad": 0.0487,
+      "log_good": 0.0507
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 84.0,
+      "good": 111.0,
+      "ratio": 1.3214,
+      "suggested_scalar": 0.0965,
+      "log_bad": 4.4308,
+      "log_good": 4.7095
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 102.5519,
+      "good": 98.6227,
+      "ratio": 0.9617,
+      "suggested_scalar": -0.0135,
+      "log_bad": 4.6304,
+      "log_good": 4.5913
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5741,
+      "good": 0.6215,
+      "ratio": 1.0826,
+      "suggested_scalar": 0.0275,
+      "log_bad": -0.555,
+      "log_good": -0.4756
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 14.3481,
+      "good": 13.5205,
+      "ratio": 0.9423,
+      "suggested_scalar": -0.0206,
+      "log_bad": 2.6636,
+      "log_good": 2.6042
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1315.0,
+      "good": 1651.0,
+      "ratio": 1.2555,
+      "suggested_scalar": 0.0788,
+      "log_bad": 7.1816,
+      "log_good": 7.4091
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2642,
+      "good": 0.1786,
+      "ratio": 0.676,
+      "suggested_scalar": -0.1356,
+      "log_bad": -1.331,
+      "log_good": -1.7226
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6038,
+      "good": 0.6786,
+      "ratio": 1.1239,
+      "suggested_scalar": 0.0404,
+      "log_bad": -0.5045,
+      "log_good": -0.3877
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.1321,
+      "good": 7.0,
+      "ratio": 1.1415,
+      "suggested_scalar": 0.0458,
+      "log_bad": 1.8135,
+      "log_good": 1.9459
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 6.0,
+      "good": 11.0,
+      "ratio": 1.8333,
+      "suggested_scalar": 0.2099,
+      "log_bad": 1.7918,
+      "log_good": 2.3979
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 4.6451,
+      "good": 5.8253,
+      "ratio": 1.2541,
+      "suggested_scalar": 0.0784,
+      "log_bad": 1.5358,
+      "log_good": 1.7622
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 57.0,
+      "good": 74.0,
+      "ratio": 1.2982,
+      "suggested_scalar": 0.0904,
+      "log_bad": 4.0431,
+      "log_good": 4.3041
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9565,
+      "good": 0.9547,
+      "ratio": 0.9981,
+      "suggested_scalar": -0.0007,
+      "log_bad": -0.0445,
+      "log_good": -0.0464
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 32.0,
+      "ratio": 1.28,
+      "suggested_scalar": 0.0855,
+      "log_bad": 3.2189,
+      "log_good": 3.4657
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6304,
+      "good": 0.6372,
+      "ratio": 1.0108,
+      "suggested_scalar": 0.0037,
+      "log_bad": -0.4614,
+      "log_good": -0.4507
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4087,
+      "good": 0.4667,
+      "ratio": 1.1419,
+      "suggested_scalar": 0.0459,
+      "log_bad": -0.8948,
+      "log_good": -0.7621
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7058,
+      "good": 2.7563,
+      "ratio": 1.0187,
+      "suggested_scalar": 0.0064,
+      "log_bad": 0.9954,
+      "log_good": 1.0139
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 323.0,
+      "good": 390.0,
+      "ratio": 1.2074,
+      "suggested_scalar": 0.0653,
+      "log_bad": 5.7777,
+      "log_good": 5.9661
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 11.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0301,
+      "log_bad": 2.4849,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0092,
+      "good": 0.0128,
+      "ratio": 1.3913,
+      "suggested_scalar": 0.1143,
+      "log_bad": -4.6886,
+      "log_good": -4.3583
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8074,
+      "good": 5.858,
+      "ratio": 1.0087,
+      "suggested_scalar": 0.003,
+      "log_bad": 1.7591,
+      "log_good": 1.7678
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 5.0,
+      "good": 9.0,
+      "ratio": 1.8,
+      "suggested_scalar": 0.2035,
+      "log_bad": 1.6094,
+      "log_good": 2.1972
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3495,
+      "good": 1.4289,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.0198,
+      "log_bad": 0.2997,
+      "log_good": 0.3569
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.2,
+      "good": 5.4633,
+      "ratio": 1.0506,
+      "suggested_scalar": 0.0171,
+      "log_bad": 1.6487,
+      "log_good": 1.6981
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7946,
+      "good": 0.799,
+      "ratio": 1.0055,
+      "suggested_scalar": 0.0019,
+      "log_bad": -0.2299,
+      "log_good": -0.2244
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1311,
+      "good": 0.1515,
+      "ratio": 1.1556,
+      "suggested_scalar": 0.0501,
+      "log_bad": -2.0318,
+      "log_good": -1.8872
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.7879,
+      "good": 3.677,
+      "ratio": 0.9707,
+      "suggested_scalar": -0.0103,
+      "log_bad": 1.3318,
+      "log_good": 1.3021
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 235.0,
+      "good": 278.0,
+      "ratio": 1.183,
+      "suggested_scalar": 0.0582,
+      "log_bad": 5.4596,
+      "log_good": 5.6276
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 17.0,
+      "good": 20.0,
+      "ratio": 1.1765,
+      "suggested_scalar": 0.0563,
+      "log_bad": 2.8332,
+      "log_good": 2.9957
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6414,
+      "good": 0.782,
+      "ratio": 1.2192,
+      "suggested_scalar": 0.0686,
+      "log_bad": -0.4441,
+      "log_good": -0.2459
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 73.0,
+      "good": 89.0,
+      "ratio": 1.2192,
+      "suggested_scalar": 0.0686,
+      "log_bad": 4.2905,
+      "log_good": 4.4886
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 580.0,
+      "good": 809.0,
+      "ratio": 1.3948,
+      "suggested_scalar": 0.1152,
+      "log_bad": 6.363,
+      "log_good": 6.6958
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 107.0,
+      "good": 134.0,
+      "ratio": 1.2523,
+      "suggested_scalar": 0.0779,
+      "log_bad": 4.6728,
+      "log_good": 4.8978
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0031,
+      "good": 1.0,
+      "ratio": 322.5806,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.7764,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2615,
+      "good": 0.2551,
+      "ratio": 0.9755,
+      "suggested_scalar": -0.0086,
+      "log_bad": -1.3413,
+      "log_good": -1.3661
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 49.0,
+      "good": 72.0,
+      "ratio": 1.4694,
+      "suggested_scalar": 0.1332,
+      "log_bad": 3.8918,
+      "log_good": 4.2767
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.24,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 73.0,
+      "good": 89.0,
+      "ratio": 1.2192,
+      "suggested_scalar": 0.0686,
+      "log_bad": 4.2905,
+      "log_good": 4.4886
+    },
+    "brevity.mean_sample_size": {
+      "bad": 73.0,
+      "good": 89.0,
+      "ratio": 1.2192,
+      "suggested_scalar": 0.0686,
+      "log_bad": 4.2905,
+      "log_good": 4.4886
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 325.0,
+      "good": 392.0,
+      "ratio": 1.2062,
+      "suggested_scalar": 0.0649,
+      "log_bad": 5.7838,
+      "log_good": 5.9713
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 192.0,
+      "good": 225.0,
+      "ratio": 1.1719,
+      "suggested_scalar": 0.0549,
+      "log_bad": 5.2575,
+      "log_good": 5.4161
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 187.0,
+      "good": 220.0,
+      "ratio": 1.1765,
+      "suggested_scalar": 0.0563,
+      "log_bad": 5.2311,
+      "log_good": 5.3936
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.5004,
+      "good": 2.5195,
+      "ratio": 1.0076,
+      "suggested_scalar": 0.0026,
+      "log_bad": 0.9165,
+      "log_good": 0.9241
+    },
+    "halstead.mean_effort": {
+      "bad": 58490.857,
+      "good": 98624.61,
+      "ratio": 1.6862,
+      "suggested_scalar": 0.1809,
+      "log_bad": 10.9766,
+      "log_good": 11.4991
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8401,
+      "good": 0.8437,
+      "ratio": 1.0043,
+      "suggested_scalar": 0.0015,
+      "log_bad": -0.1742,
+      "log_good": -0.17
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 44.0,
+      "good": 51.0,
+      "ratio": 1.1591,
+      "suggested_scalar": 0.0511,
+      "log_bad": 3.7842,
+      "log_good": 3.9318
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 208.0,
+      "good": 234.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0408,
+      "log_bad": 5.3375,
+      "log_good": 5.4553
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4524,
+      "good": 0.4234,
+      "ratio": 0.9359,
+      "suggested_scalar": -0.0229,
+      "log_bad": -0.7932,
+      "log_good": -0.8594
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.9048,
+      "good": 7.2883,
+      "ratio": 1.0555,
+      "suggested_scalar": 0.0187,
+      "log_bad": 1.9322,
+      "log_good": 1.9863
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1311,
+      "good": 0.1515,
+      "ratio": 1.1556,
+      "suggested_scalar": 0.0501,
+      "log_bad": -2.0318,
+      "log_good": -1.8872
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.0589,
+      "good": 4.2634,
+      "ratio": 1.3938,
+      "suggested_scalar": 0.115,
+      "log_bad": 1.1181,
+      "log_good": 1.4501
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 324.0,
+      "good": 391.0,
+      "ratio": 1.2068,
+      "suggested_scalar": 0.0651,
+      "log_bad": 5.7807,
+      "log_good": 5.9687
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 44.0,
+      "good": 70.0,
+      "ratio": 1.5909,
+      "suggested_scalar": 0.1608,
+      "log_bad": 3.7842,
+      "log_good": 4.2485
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3249.4921,
+      "good": 5479.145,
+      "ratio": 1.6862,
+      "suggested_scalar": 0.1809,
+      "log_bad": 8.0863,
+      "log_good": 8.6087
+    },
+    "readability.mean_total_lines": {
+      "bad": 53.0,
+      "good": 56.0,
+      "ratio": 1.0566,
+      "suggested_scalar": 0.0191,
+      "log_bad": 3.9703,
+      "log_good": 4.0254
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 10.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0773,
+      "log_bad": 2.0794,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 1924.1852,
+      "good": 2346.0145,
+      "ratio": 1.2192,
+      "suggested_scalar": 0.0686,
+      "log_bad": 7.5623,
+      "log_good": 7.7605
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 486.0,
+      "good": 599.0,
+      "ratio": 1.2325,
+      "suggested_scalar": 0.0724,
+      "log_bad": 6.1862,
+      "log_good": 6.3953
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 23.6604,
+      "good": 28.3036,
+      "ratio": 1.1962,
+      "suggested_scalar": 0.062,
+      "log_bad": 3.1638,
+      "log_good": 3.343
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1591,
+      "good": 1.1951,
+      "ratio": 1.0311,
+      "suggested_scalar": 0.0106,
+      "log_bad": 0.1476,
+      "log_good": 0.1782
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 7.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.1165,
+      "log_bad": 1.6094,
+      "log_good": 1.9459
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 20.0,
+      "good": 32.0,
+      "ratio": 1.6,
+      "suggested_scalar": 0.1627,
+      "log_bad": 2.9957,
+      "log_good": 3.4657
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8128,
+      "good": 0.7482,
+      "ratio": 0.9205,
+      "suggested_scalar": -0.0287,
+      "log_bad": -0.2073,
+      "log_good": -0.2901
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.982,
+      "good": 0.9805,
+      "ratio": 0.9985,
+      "suggested_scalar": -0.0005,
+      "log_bad": -0.0182,
+      "log_good": -0.0197
+    },
+    "halstead.mean_length": {
+      "bad": 315.0,
+      "good": 368.0,
+      "ratio": 1.1683,
+      "suggested_scalar": 0.0538,
+      "log_bad": 5.7526,
+      "log_good": 5.9081
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.5,
+      "good": 11.0,
+      "ratio": 1.1579,
+      "suggested_scalar": 0.0508,
+      "log_bad": 2.2513,
+      "log_good": 2.3979
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.1898,
+      "good": 6.4757,
+      "ratio": 1.0462,
+      "suggested_scalar": 0.0156,
+      "log_bad": 1.8229,
+      "log_good": 1.8681
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.146,
+      "good": 0.1363,
+      "ratio": 0.9336,
+      "suggested_scalar": -0.0238,
+      "log_bad": -1.9241,
+      "log_good": -1.9929
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.3977,
+      "good": 42.0392,
+      "ratio": 1.383,
+      "suggested_scalar": 0.1123,
+      "log_bad": 3.4144,
+      "log_good": 3.7386
+    },
+    "branching.mean_branch_count": {
+      "bad": 14.0,
+      "good": 10.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.1165,
+      "log_bad": 2.6391,
+      "log_good": 2.3026
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 38.0,
+      "good": 47.0,
+      "ratio": 1.2368,
+      "suggested_scalar": 0.0736,
+      "log_bad": 3.6376,
+      "log_good": 3.8501
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.738,
+      "good": 0.6727,
+      "ratio": 0.9115,
+      "suggested_scalar": -0.0321,
+      "log_bad": -0.3038,
+      "log_good": -0.3965
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 53.0,
+      "good": 56.0,
+      "ratio": 1.0566,
+      "suggested_scalar": 0.0191,
+      "log_bad": 3.9703,
+      "log_good": 4.0254
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 20.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0178,
+      "log_bad": 2.9444,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_array_delete": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 12.0,
+      "good": 15.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.1103,
+      "log_bad": 2.4849,
+      "log_good": 2.7081
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 13.0,
+      "good": 19.0,
+      "ratio": 1.4615,
+      "suggested_scalar": 0.1876,
+      "log_bad": 2.5649,
+      "log_good": 2.9444
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7018,
+      "good": 0.7451,
+      "ratio": 1.0617,
+      "suggested_scalar": 0.0296,
+      "log_bad": -0.3541,
+      "log_good": -0.2942
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5758,
+      "good": 4.6784,
+      "ratio": 1.0224,
+      "suggested_scalar": 0.011,
+      "log_bad": 1.5208,
+      "log_good": 1.543
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 77.0,
+      "good": 65.0,
+      "ratio": 0.8442,
+      "suggested_scalar": -0.0838,
+      "log_bad": 4.3438,
+      "log_good": 4.1744
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.35,
+      "good": 0.3131,
+      "ratio": 0.8946,
+      "suggested_scalar": -0.0551,
+      "log_bad": -1.0498,
+      "log_good": -1.1612
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 16.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0582,
+      "log_bad": 2.8904,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6024,
+      "good": 0.5231,
+      "ratio": 0.8684,
+      "suggested_scalar": -0.0698,
+      "log_bad": -0.5068,
+      "log_good": -0.648
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.2105,
+      "good": 1.5294,
+      "ratio": 0.6919,
+      "suggested_scalar": -0.1821,
+      "log_bad": 0.7932,
+      "log_good": 0.4249
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 384.0,
+      "good": 386.0,
+      "ratio": 1.0052,
+      "suggested_scalar": 0.0026,
+      "log_bad": 5.9506,
+      "log_good": 5.9558
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1103,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0019,
+      "good": 0.0025,
+      "ratio": 1.3158,
+      "suggested_scalar": 0.1357,
+      "log_bad": -6.2659,
+      "log_good": -5.9915
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0175,
+      "good": 1.0,
+      "ratio": 57.1429,
+      "suggested_scalar": 2.0,
+      "log_bad": -4.0456,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0847,
+      "good": 1.1897,
+      "ratio": 1.0968,
+      "suggested_scalar": 0.0457,
+      "log_bad": 0.0813,
+      "log_good": 0.1737
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 102.0,
+      "good": 99.0,
+      "ratio": 0.9706,
+      "suggested_scalar": -0.0148,
+      "log_bad": 4.625,
+      "log_good": 4.5951
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.4101,
+      "good": 97.5153,
+      "ratio": 0.934,
+      "suggested_scalar": -0.0338,
+      "log_bad": 4.6483,
+      "log_good": 4.58
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7154,
+      "good": 0.6883,
+      "ratio": 0.9621,
+      "suggested_scalar": -0.0191,
+      "log_bad": -0.3349,
+      "log_good": -0.3735
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 29.1681,
+      "good": 33.3537,
+      "ratio": 1.1435,
+      "suggested_scalar": 0.0663,
+      "log_bad": 3.3731,
+      "log_good": 3.5072
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1567.0,
+      "good": 1572.0,
+      "ratio": 1.0032,
+      "suggested_scalar": 0.0016,
+      "log_bad": 7.3569,
+      "log_good": 7.3601
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1053,
+      "good": 1.0,
+      "ratio": 9.4967,
+      "suggested_scalar": 1.1128,
+      "log_bad": -2.2509,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6491,
+      "good": 0.7255,
+      "ratio": 1.1177,
+      "suggested_scalar": 0.055,
+      "log_bad": -0.4322,
+      "log_good": -0.3209
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.7368,
+      "good": 7.5686,
+      "ratio": 1.1235,
+      "suggested_scalar": 0.0576,
+      "log_bad": 1.9076,
+      "log_good": 2.024
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.6223,
+      "good": 1.6609,
+      "ratio": 0.6334,
+      "suggested_scalar": -0.2258,
+      "log_bad": 0.9641,
+      "log_good": 0.5074
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 75.0,
+      "good": 64.0,
+      "ratio": 0.8533,
+      "suggested_scalar": -0.0784,
+      "log_bad": 4.3175,
+      "log_good": 4.1589
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9078,
+      "good": 0.8941,
+      "ratio": 0.9849,
+      "suggested_scalar": -0.0075,
+      "log_bad": -0.0967,
+      "log_good": -0.1119
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 23.0,
+      "ratio": 0.8214,
+      "suggested_scalar": -0.0972,
+      "log_bad": 3.3322,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6713,
+      "good": 0.6978,
+      "ratio": 1.0395,
+      "suggested_scalar": 0.0191,
+      "log_bad": -0.3985,
+      "log_good": -0.3598
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5602,
+      "good": 0.5339,
+      "ratio": 0.9531,
+      "suggested_scalar": -0.0238,
+      "log_bad": -0.5795,
+      "log_good": -0.6275
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0427,
+      "good": 3.3095,
+      "ratio": 1.0877,
+      "suggested_scalar": 0.0416,
+      "log_bad": 1.1127,
+      "log_good": 1.1968
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 382.0,
+      "good": 384.0,
+      "ratio": 1.0052,
+      "suggested_scalar": 0.0026,
+      "log_bad": 5.9454,
+      "log_good": 5.9506
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 38.0,
+      "good": 34.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.055,
+      "log_bad": 3.6376,
+      "log_good": 3.5264
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0365,
+      "good": 0.0466,
+      "ratio": 1.2767,
+      "suggested_scalar": 0.1208,
+      "log_bad": -3.3104,
+      "log_good": -3.0662
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7004,
+      "good": 5.7004,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7405,
+      "log_good": 1.7405
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 15.0,
+      "good": 20.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1422,
+      "log_bad": 2.7081,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0961,
+      "good": 1.2855,
+      "ratio": 1.1728,
+      "suggested_scalar": 0.0788,
+      "log_bad": 0.0918,
+      "log_good": 0.2511
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.3569,
+      "good": 5.0665,
+      "ratio": 0.9458,
+      "suggested_scalar": -0.0276,
+      "log_bad": 1.6784,
+      "log_good": 1.6227
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8027,
+      "good": 0.8207,
+      "ratio": 1.0224,
+      "suggested_scalar": 0.011,
+      "log_bad": -0.2198,
+      "log_good": -0.1976
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1493,
+      "good": 0.2031,
+      "ratio": 1.3603,
+      "suggested_scalar": 0.1521,
+      "log_bad": -1.9018,
+      "log_good": -1.5941
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 5.4008,
+      "good": 5.7753,
+      "ratio": 1.0693,
+      "suggested_scalar": 0.0331,
+      "log_bad": 1.6865,
+      "log_good": 1.7536
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 252.0,
+      "good": 232.0,
+      "ratio": 0.9206,
+      "suggested_scalar": -0.0409,
+      "log_bad": 5.5294,
+      "log_good": 5.4467
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 23.0,
+      "good": 28.0,
+      "ratio": 1.2174,
+      "suggested_scalar": 0.0972,
+      "log_bad": 3.1355,
+      "log_good": 3.3322
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7833,
+      "good": 0.7508,
+      "ratio": 0.9585,
+      "suggested_scalar": -0.0209,
+      "log_bad": -0.2442,
+      "log_good": -0.2866
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 75.0,
+      "good": 62.0,
+      "ratio": 0.8267,
+      "suggested_scalar": -0.0941,
+      "log_bad": 4.3175,
+      "log_good": 4.1271
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 759.0,
+      "good": 833.0,
+      "ratio": 1.0975,
+      "suggested_scalar": 0.046,
+      "log_bad": 6.632,
+      "log_good": 6.725
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 135.0,
+      "good": 130.0,
+      "ratio": 0.963,
+      "suggested_scalar": -0.0187,
+      "log_bad": 4.9053,
+      "log_good": 4.8675
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0052,
+      "good": 0.013,
+      "ratio": 2.5,
+      "suggested_scalar": 0.453,
+      "log_bad": -5.2591,
+      "log_good": -4.3428
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2396,
+      "good": 0.272,
+      "ratio": 1.1352,
+      "suggested_scalar": 0.0627,
+      "log_bad": -1.4288,
+      "log_good": -1.302
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 85.0,
+      "good": 56.0,
+      "ratio": 0.6588,
+      "suggested_scalar": -0.2063,
+      "log_bad": 4.4427,
+      "log_good": 4.0254
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.2525,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 75.0,
+      "good": 62.0,
+      "ratio": 0.8267,
+      "suggested_scalar": -0.0941,
+      "log_bad": 4.3175,
+      "log_good": 4.1271
+    },
+    "brevity.mean_sample_size": {
+      "bad": 75.0,
+      "good": 62.0,
+      "ratio": 0.8267,
+      "suggested_scalar": -0.0941,
+      "log_bad": 4.3175,
+      "log_good": 4.1271
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 384.0,
+      "good": 386.0,
+      "ratio": 1.0052,
+      "suggested_scalar": 0.0026,
+      "log_bad": 5.9506,
+      "log_good": 5.9558
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 226.0,
+      "good": 240.0,
+      "ratio": 1.0619,
+      "suggested_scalar": 0.0297,
+      "log_bad": 5.4205,
+      "log_good": 5.4806
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 194.0,
+      "good": 176.0,
+      "ratio": 0.9072,
+      "suggested_scalar": -0.0481,
+      "log_bad": 5.2679,
+      "log_good": 5.1705
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.3914,
+      "good": 2.7258,
+      "ratio": 1.1398,
+      "suggested_scalar": 0.0647,
+      "log_bad": 0.8719,
+      "log_good": 1.0028
+    },
+    "halstead.mean_effort": {
+      "bad": 90644.591,
+      "good": 80173.4885,
+      "ratio": 0.8845,
+      "suggested_scalar": -0.0607,
+      "log_bad": 11.4147,
+      "log_good": 11.2919
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.86,
+      "good": 0.8509,
+      "ratio": 0.9894,
+      "suggested_scalar": -0.0053,
+      "log_bad": -0.1508,
+      "log_good": -0.1615
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 49.0,
+      "good": 42.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0762,
+      "log_bad": 3.8918,
+      "log_good": 3.7377
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 240.0,
+      "good": 244.0,
+      "ratio": 1.0167,
+      "suggested_scalar": 0.0082,
+      "log_bad": 5.4806,
+      "log_good": 5.4972
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3431,
+      "good": 0.3131,
+      "ratio": 0.9126,
+      "suggested_scalar": -0.0452,
+      "log_bad": -1.0697,
+      "log_good": -1.1612
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.4412,
+      "good": 8.4141,
+      "ratio": 1.1307,
+      "suggested_scalar": 0.0607,
+      "log_bad": 2.007,
+      "log_good": 2.1299
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1493,
+      "good": 0.2031,
+      "ratio": 1.3603,
+      "suggested_scalar": 0.1521,
+      "log_bad": -1.9018,
+      "log_good": -1.5941
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.7337,
+      "good": 5.2497,
+      "ratio": 1.406,
+      "suggested_scalar": 0.1685,
+      "log_bad": 1.3174,
+      "log_good": 1.6582
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 383.0,
+      "good": 385.0,
+      "ratio": 1.0052,
+      "suggested_scalar": 0.0026,
+      "log_bad": 5.948,
+      "log_good": 5.9532
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 84.0,
+      "good": 53.0,
+      "ratio": 0.631,
+      "suggested_scalar": -0.2277,
+      "log_bad": 4.4308,
+      "log_good": 3.9703
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5035.8106,
+      "good": 4454.0827,
+      "ratio": 0.8845,
+      "suggested_scalar": -0.0607,
+      "log_bad": 8.5243,
+      "log_good": 8.4016
+    },
+    "readability.mean_total_lines": {
+      "bad": 57.0,
+      "good": 51.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.055,
+      "log_bad": 4.0431,
+      "log_good": 3.9318
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 4.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.2004,
+      "log_bad": 1.7918,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2350.045,
+      "good": 2252.3656,
+      "ratio": 0.9584,
+      "suggested_scalar": -0.021,
+      "log_bad": 7.7622,
+      "log_good": 7.7197
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 515.0,
+      "good": 475.0,
+      "ratio": 0.9223,
+      "suggested_scalar": -0.04,
+      "log_bad": 6.2442,
+      "log_good": 6.1633
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 26.3158,
+      "good": 29.5686,
+      "ratio": 1.1236,
+      "suggested_scalar": 0.0576,
+      "log_bad": 3.2702,
+      "log_good": 3.3867
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1299,
+      "good": 1.2014,
+      "ratio": 1.0633,
+      "suggested_scalar": 0.0303,
+      "log_bad": 0.1221,
+      "log_good": 0.1835
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1103,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 23.0,
+      "good": 35.0,
+      "ratio": 1.5217,
+      "suggested_scalar": 0.2076,
+      "log_bad": 3.1355,
+      "log_good": 3.5553
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6667,
+      "good": 0.7716,
+      "ratio": 1.1573,
+      "suggested_scalar": 0.0722,
+      "log_bad": -0.4054,
+      "log_good": -0.2593
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9592,
+      "good": 0.9619,
+      "ratio": 1.0028,
+      "suggested_scalar": 0.0014,
+      "log_bad": -0.0417,
+      "log_good": -0.0388
+    },
+    "halstead.mean_length": {
+      "bad": 375.0,
+      "good": 374.0,
+      "ratio": 0.9973,
+      "suggested_scalar": -0.0013,
+      "log_bad": 5.9269,
+      "log_good": 5.9243
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 19.6667,
+      "good": 11.2,
+      "ratio": 0.5695,
+      "suggested_scalar": -0.2783,
+      "log_bad": 2.9789,
+      "log_good": 2.4159
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2288,
+      "good": 5.9542,
+      "ratio": 0.9559,
+      "suggested_scalar": -0.0223,
+      "log_bad": 1.8292,
+      "log_good": 1.7841
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1442,
+      "good": 0.1527,
+      "ratio": 1.0589,
+      "suggested_scalar": 0.0283,
+      "log_bad": -1.9366,
+      "log_good": -1.8793
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 38.5714,
+      "good": 35.5952,
+      "ratio": 0.9228,
+      "suggested_scalar": -0.0397,
+      "log_bad": 3.6525,
+      "log_good": 3.5722
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 1.0,
+      "ratio": 0.1667,
+      "suggested_scalar": -0.8858,
+      "log_bad": 1.7918,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 35.0,
+      "good": 31.0,
+      "ratio": 0.8857,
+      "suggested_scalar": -0.06,
+      "log_bad": 3.5553,
+      "log_good": 3.434
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5619,
+      "good": 0.6818,
+      "ratio": 1.2134,
+      "suggested_scalar": 0.0956,
+      "log_bad": -0.5764,
+      "log_good": -0.383
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 57.0,
+      "good": 51.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.055,
+      "log_bad": 4.0431,
+      "log_good": 3.9318
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 23.0,
+      "good": 25.0,
+      "ratio": 1.087,
+      "suggested_scalar": 0.0412,
+      "log_bad": 3.1355,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.no_static_only_container_classes": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 2.0,
+      "good": 20.0,
+      "ratio": 10.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.6931,
+      "log_good": 2.9957
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0165,
+      "good": 0.0164,
+      "ratio": 0.9939,
+      "suggested_scalar": -0.0053,
+      "log_bad": -4.1044,
+      "log_good": -4.1105
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7857,
+      "good": 0.7692,
+      "ratio": 0.979,
+      "suggested_scalar": -0.0184,
+      "log_bad": -0.2412,
+      "log_good": -0.2624
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0165,
+      "good": 0.0164,
+      "ratio": 0.9939,
+      "suggested_scalar": -0.0053,
+      "log_bad": -4.1044,
+      "log_good": -4.1105
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8596,
+      "good": 4.996,
+      "ratio": 1.0281,
+      "suggested_scalar": 0.024,
+      "log_bad": 1.581,
+      "log_good": 1.6086
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 76.0,
+      "good": 74.0,
+      "ratio": 0.9737,
+      "suggested_scalar": -0.0232,
+      "log_bad": 4.3307,
+      "log_good": 4.3041
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.395,
+      "good": 0.3917,
+      "ratio": 0.9916,
+      "suggested_scalar": -0.0073,
+      "log_bad": -0.9289,
+      "log_good": -0.9373
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "heaps.mean_beta": {
+      "bad": 0.543,
+      "good": 0.5328,
+      "ratio": 0.9812,
+      "suggested_scalar": -0.0165,
+      "log_bad": -0.6106,
+      "log_good": -0.6296
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.0476,
+      "good": 1.2821,
+      "ratio": 0.4207,
+      "suggested_scalar": -0.7521,
+      "log_bad": 1.1144,
+      "log_good": 0.2485
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 425.0,
+      "good": 426.0,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.002,
+      "log_bad": 6.0521,
+      "log_good": 6.0544
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 7.0,
+      "good": 6.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.1339,
+      "log_bad": 1.9459,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0008,
+      "good": 0.0008,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.1309,
+      "log_good": -7.1309
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0008,
+      "good": 0.0008,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.1309,
+      "log_good": -7.1309
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.142,
+      "good": 1.1417,
+      "ratio": 0.9997,
+      "suggested_scalar": -0.0002,
+      "log_bad": 0.1328,
+      "log_good": 0.1325
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 107.0,
+      "good": 105.0,
+      "ratio": 0.9813,
+      "suggested_scalar": -0.0164,
+      "log_bad": 4.6728,
+      "log_good": 4.654
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 94.0561,
+      "good": 95.1747,
+      "ratio": 1.0119,
+      "suggested_scalar": 0.0103,
+      "log_bad": 4.5439,
+      "log_good": 4.5557
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6533,
+      "good": 0.6729,
+      "ratio": 1.03,
+      "suggested_scalar": 0.0257,
+      "log_bad": -0.4257,
+      "log_good": -0.3962
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.8021,
+      "good": 11.3981,
+      "ratio": 0.9658,
+      "suggested_scalar": -0.0303,
+      "log_bad": 2.4683,
+      "log_good": 2.4334
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1291.0,
+      "good": 1256.0,
+      "ratio": 0.9729,
+      "suggested_scalar": -0.0239,
+      "log_bad": 7.1632,
+      "log_good": 7.1357
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0476,
+      "good": 0.0513,
+      "ratio": 1.0777,
+      "suggested_scalar": 0.065,
+      "log_bad": -3.0449,
+      "log_good": -2.9701
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7619,
+      "good": 0.7692,
+      "ratio": 1.0096,
+      "suggested_scalar": 0.0083,
+      "log_bad": -0.2719,
+      "log_good": -0.2624
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.119,
+      "good": 10.9231,
+      "ratio": 1.0795,
+      "suggested_scalar": 0.0664,
+      "log_bad": 2.3144,
+      "log_good": 2.3909
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.712,
+      "good": 2.1512,
+      "ratio": 0.7932,
+      "suggested_scalar": -0.2012,
+      "log_bad": 0.9977,
+      "log_good": 0.766
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 76.0,
+      "good": 76.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3307,
+      "log_good": 4.3307
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9408,
+      "good": 0.9341,
+      "ratio": 0.9929,
+      "suggested_scalar": -0.0062,
+      "log_bad": -0.061,
+      "log_good": -0.0682
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 26.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2581,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.598,
+      "good": 0.6019,
+      "ratio": 1.0065,
+      "suggested_scalar": 0.0056,
+      "log_bad": -0.5142,
+      "log_good": -0.5077
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4326,
+      "good": 0.4528,
+      "ratio": 1.0467,
+      "suggested_scalar": 0.0396,
+      "log_bad": -0.8379,
+      "log_good": -0.7923
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4875,
+      "good": 2.512,
+      "ratio": 1.0098,
+      "suggested_scalar": 0.0085,
+      "log_bad": 0.9113,
+      "log_good": 0.9211
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 423.0,
+      "good": 424.0,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.0021,
+      "log_bad": 6.0474,
+      "log_good": 6.0497
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0224,
+      "good": 6.0224,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7955,
+      "log_good": 1.7955
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.2923,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2135,
+      "good": 1.1576,
+      "ratio": 0.9539,
+      "suggested_scalar": -0.041,
+      "log_bad": 0.1935,
+      "log_good": 0.1463
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.2286,
+      "good": 5.231,
+      "ratio": 1.0005,
+      "suggested_scalar": 0.0004,
+      "log_bad": 1.6541,
+      "log_good": 1.6546
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8069,
+      "good": 0.8296,
+      "ratio": 1.0281,
+      "suggested_scalar": 0.0241,
+      "log_bad": -0.2146,
+      "log_good": -0.1868
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1923,
+      "good": 0.1875,
+      "ratio": 0.975,
+      "suggested_scalar": -0.022,
+      "log_bad": -1.6487,
+      "log_good": -1.674
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.4354,
+      "good": 3.3761,
+      "ratio": 0.9827,
+      "suggested_scalar": -0.0151,
+      "log_bad": 1.2341,
+      "log_good": 1.2167
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 296.0,
+      "good": 289.0,
+      "ratio": 0.9764,
+      "suggested_scalar": -0.0208,
+      "log_bad": 5.6904,
+      "log_good": 5.6664
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 26.0,
+      "good": 25.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0341,
+      "log_bad": 3.2581,
+      "log_good": 3.2189
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8226,
+      "good": 0.8196,
+      "ratio": 0.9964,
+      "suggested_scalar": -0.0032,
+      "log_bad": -0.1953,
+      "log_good": -0.1989
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 75.0,
+      "good": 73.0,
+      "ratio": 0.9733,
+      "suggested_scalar": -0.0235,
+      "log_bad": 4.3175,
+      "log_good": 4.2905
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 568.0,
+      "good": 546.0,
+      "ratio": 0.9613,
+      "suggested_scalar": -0.0343,
+      "log_bad": 6.3421,
+      "log_good": 6.3026
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 129.0,
+      "good": 117.0,
+      "ratio": 0.907,
+      "suggested_scalar": -0.0848,
+      "log_bad": 4.8598,
+      "log_good": 4.7622
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0071,
+      "good": 0.007,
+      "ratio": 0.9859,
+      "suggested_scalar": -0.0123,
+      "log_bad": -4.9477,
+      "log_good": -4.9618
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2353,
+      "good": 0.2347,
+      "ratio": 0.9975,
+      "suggested_scalar": -0.0022,
+      "log_bad": -1.4469,
+      "log_good": -1.4494
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 71.0,
+      "good": 72.0,
+      "ratio": 1.0141,
+      "suggested_scalar": 0.0121,
+      "log_bad": 4.2627,
+      "log_good": 4.2767
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 75.0,
+      "good": 73.0,
+      "ratio": 0.9733,
+      "suggested_scalar": -0.0235,
+      "log_bad": 4.3175,
+      "log_good": 4.2905
+    },
+    "brevity.mean_sample_size": {
+      "bad": 75.0,
+      "good": 73.0,
+      "ratio": 0.9733,
+      "suggested_scalar": -0.0235,
+      "log_bad": 4.3175,
+      "log_good": 4.2905
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 425.0,
+      "good": 426.0,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.002,
+      "log_bad": 6.0521,
+      "log_good": 6.0544
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 283.0,
+      "good": 278.0,
+      "ratio": 0.9823,
+      "suggested_scalar": -0.0155,
+      "log_bad": 5.6454,
+      "log_good": 5.6276
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 218.0,
+      "good": 211.0,
+      "ratio": 0.9679,
+      "suggested_scalar": -0.0283,
+      "log_bad": 5.3845,
+      "log_good": 5.3519
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.8537,
+      "good": 2.9468,
+      "ratio": 1.0326,
+      "suggested_scalar": 0.0279,
+      "log_bad": 1.0486,
+      "log_good": 1.0807
+    },
+    "halstead.mean_effort": {
+      "bad": 82774.4181,
+      "good": 77917.7732,
+      "ratio": 0.9413,
+      "suggested_scalar": -0.0525,
+      "log_bad": 11.3239,
+      "log_good": 11.2634
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8394,
+      "good": 0.8451,
+      "ratio": 1.0068,
+      "suggested_scalar": 0.0059,
+      "log_bad": -0.1751,
+      "log_good": -0.1683
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 50.0,
+      "good": 48.0,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0355,
+      "log_bad": 3.912,
+      "log_good": 3.8712
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 266.0,
+      "good": 279.0,
+      "ratio": 1.0489,
+      "suggested_scalar": 0.0414,
+      "log_bad": 5.5835,
+      "log_good": 5.6312
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3832,
+      "good": 0.381,
+      "ratio": 0.9943,
+      "suggested_scalar": -0.005,
+      "log_bad": -0.9592,
+      "log_good": -0.965
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.3084,
+      "good": 5.2,
+      "ratio": 0.9796,
+      "suggested_scalar": -0.0179,
+      "log_bad": 1.6693,
+      "log_good": 1.6487
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1923,
+      "good": 0.1875,
+      "ratio": 0.975,
+      "suggested_scalar": -0.022,
+      "log_bad": -1.6487,
+      "log_good": -1.674
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.3834,
+      "good": 6.607,
+      "ratio": 1.035,
+      "suggested_scalar": 0.0299,
+      "log_bad": 1.8537,
+      "log_good": 1.8881
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 424.0,
+      "good": 425.0,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.002,
+      "log_bad": 6.0497,
+      "log_good": 6.0521
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 56.0,
+      "good": 57.0,
+      "ratio": 1.0179,
+      "suggested_scalar": 0.0154,
+      "log_bad": 4.0254,
+      "log_good": 4.0431
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4598.5788,
+      "good": 4328.7652,
+      "ratio": 0.9413,
+      "suggested_scalar": -0.0525,
+      "log_bad": 8.4335,
+      "log_good": 8.373
+    },
+    "readability.mean_total_lines": {
+      "bad": 42.0,
+      "good": 39.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.0644,
+      "log_bad": 3.7377,
+      "log_good": 3.6636
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 4.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.3522,
+      "log_bad": 1.7918,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2467.9314,
+      "good": 2458.9435,
+      "ratio": 0.9964,
+      "suggested_scalar": -0.0032,
+      "log_bad": 7.8111,
+      "log_good": 7.8075
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 519.0,
+      "good": 500.0,
+      "ratio": 0.9634,
+      "suggested_scalar": -0.0324,
+      "log_bad": 6.2519,
+      "log_good": 6.2146
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 29.5,
+      "good": 30.9744,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0424,
+      "log_bad": 3.3844,
+      "log_good": 3.4332
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2117,
+      "good": 1.1888,
+      "ratio": 0.9811,
+      "suggested_scalar": -0.0166,
+      "log_bad": 0.192,
+      "log_good": 0.1729
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 7.0,
+      "good": 6.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.1339,
+      "log_bad": 1.9459,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 28.0,
+      "good": 28.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3322,
+      "log_good": 3.3322
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8108,
+      "good": 0.8028,
+      "ratio": 0.9901,
+      "suggested_scalar": -0.0086,
+      "log_bad": -0.2097,
+      "log_good": -0.2196
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9902,
+      "good": 0.9896,
+      "ratio": 0.9994,
+      "suggested_scalar": -0.0005,
+      "log_bad": -0.0098,
+      "log_good": -0.0105
+    },
+    "halstead.mean_length": {
+      "bad": 395.0,
+      "good": 396.0,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0022,
+      "log_bad": 5.9789,
+      "log_good": 5.9814
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2288,
+      "good": 6.1898,
+      "ratio": 0.9937,
+      "suggested_scalar": -0.0055,
+      "log_bad": 1.8292,
+      "log_good": 1.8229
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.2192,
+      "good": 0.2213,
+      "ratio": 1.0096,
+      "suggested_scalar": 0.0083,
+      "log_bad": -1.5178,
+      "log_good": -1.5082
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 33.54,
+      "good": 31.6875,
+      "ratio": 0.9448,
+      "suggested_scalar": -0.0494,
+      "log_bad": 3.5127,
+      "log_good": 3.4559
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 41.0,
+      "good": 40.0,
+      "ratio": 0.9756,
+      "suggested_scalar": -0.0214,
+      "log_bad": 3.7136,
+      "log_good": 3.6889
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6743,
+      "good": 0.6588,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0202,
+      "log_bad": -0.3941,
+      "log_good": -0.4173
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 42.0,
+      "good": 39.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.0644,
+      "log_bad": 3.7377,
+      "log_good": 3.6636
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "dependencies.import_count_under_10": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 25.0,
+      "good": 36.0,
+      "ratio": 1.44,
+      "suggested_scalar": 0.111,
+      "log_bad": 3.2189,
+      "log_good": 3.5835
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1234,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0055,
+      "good": 0.006,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0265,
+      "log_bad": -5.203,
+      "log_good": -5.116
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3333,
+      "good": 1.1111,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0555,
+      "log_bad": 0.2877,
+      "log_good": 0.1054
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8333,
+      "good": 0.8209,
+      "ratio": 0.9851,
+      "suggested_scalar": -0.0046,
+      "log_bad": -0.1824,
+      "log_good": -0.1974
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0055,
+      "good": 0.006,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0265,
+      "log_bad": -5.203,
+      "log_good": -5.116
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7246,
+      "good": 4.7791,
+      "ratio": 1.0115,
+      "suggested_scalar": 0.0035,
+      "log_bad": 1.5528,
+      "log_good": 1.5643
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 94.0,
+      "good": 95.0,
+      "ratio": 1.0106,
+      "suggested_scalar": 0.0032,
+      "log_bad": 4.5433,
+      "log_good": 4.5539
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4239,
+      "good": 0.4291,
+      "ratio": 1.0123,
+      "suggested_scalar": 0.0037,
+      "log_bad": -0.8583,
+      "log_good": -0.8461
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 21.0,
+      "ratio": 1.2353,
+      "suggested_scalar": 0.0643,
+      "log_bad": 2.8332,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7468,
+      "good": 0.5569,
+      "ratio": 0.7457,
+      "suggested_scalar": -0.0893,
+      "log_bad": -0.292,
+      "log_good": -0.5854
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.6389,
+      "good": 3.194,
+      "ratio": 0.8777,
+      "suggested_scalar": -0.0397,
+      "log_bad": 1.2917,
+      "log_good": 1.1613
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 543.0,
+      "good": 500.0,
+      "ratio": 0.9208,
+      "suggested_scalar": -0.0251,
+      "log_bad": 6.2971,
+      "log_good": 6.2146
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1234,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 0.0149,
+      "ratio": 0.0149,
+      "suggested_scalar": -1.2802,
+      "log_bad": 0.0,
+      "log_good": -4.2064
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 0.0014,
+      "ratio": 0.0014,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.5713
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0886,
+      "good": 1.0354,
+      "ratio": 0.9511,
+      "suggested_scalar": -0.0152,
+      "log_bad": 0.0849,
+      "log_good": 0.0348
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 202.0,
+      "good": 169.0,
+      "ratio": 0.8366,
+      "suggested_scalar": -0.0543,
+      "log_bad": 5.3083,
+      "log_good": 5.1299
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 94.6184,
+      "good": 88.484,
+      "ratio": 0.9352,
+      "suggested_scalar": -0.0204,
+      "log_bad": 4.5499,
+      "log_good": 4.4828
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.69,
+      "good": 0.6613,
+      "ratio": 0.9584,
+      "suggested_scalar": -0.0129,
+      "log_bad": -0.3711,
+      "log_good": -0.4135
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 16.866,
+      "good": 25.1651,
+      "ratio": 1.4921,
+      "suggested_scalar": 0.1218,
+      "log_bad": 2.8253,
+      "log_good": 3.2255
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2244.0,
+      "good": 2148.0,
+      "ratio": 0.9572,
+      "suggested_scalar": -0.0133,
+      "log_bad": 7.716,
+      "log_good": 7.6723
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 0.0299,
+      "ratio": 0.0299,
+      "suggested_scalar": -1.0683,
+      "log_bad": 0.0,
+      "log_good": -3.5099
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8194,
+      "good": 0.806,
+      "ratio": 0.9836,
+      "suggested_scalar": -0.005,
+      "log_bad": -0.1992,
+      "log_good": -0.2157
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.5417,
+      "good": 7.5758,
+      "ratio": 1.0045,
+      "suggested_scalar": 0.0014,
+      "log_bad": 2.0204,
+      "log_good": 2.025
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.1474,
+      "good": 2.3952,
+      "ratio": 0.4653,
+      "suggested_scalar": -0.2328,
+      "log_bad": 1.6385,
+      "log_good": 0.8735
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 121.0,
+      "good": 122.0,
+      "ratio": 1.0083,
+      "suggested_scalar": 0.0025,
+      "log_bad": 4.7958,
+      "log_good": 4.804
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9482,
+      "good": 0.9639,
+      "ratio": 1.0166,
+      "suggested_scalar": 0.005,
+      "log_bad": -0.0532,
+      "log_good": -0.0368
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 28.0,
+      "ratio": 1.037,
+      "suggested_scalar": 0.0111,
+      "log_bad": 3.2958,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6876,
+      "good": 0.6578,
+      "ratio": 0.9567,
+      "suggested_scalar": -0.0135,
+      "log_bad": -0.3745,
+      "log_good": -0.4189
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4935,
+      "good": 0.4478,
+      "ratio": 0.9074,
+      "suggested_scalar": -0.0296,
+      "log_bad": -0.7062,
+      "log_good": -0.8034
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.2011,
+      "good": 2.9224,
+      "ratio": 0.9129,
+      "suggested_scalar": -0.0277,
+      "log_bad": 1.1635,
+      "log_good": 1.0724
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 541.0,
+      "good": 498.0,
+      "ratio": 0.9205,
+      "suggested_scalar": -0.0252,
+      "log_bad": 6.2934,
+      "log_good": 6.2106
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 15.0,
+      "ratio": 1.3636,
+      "suggested_scalar": 0.0944,
+      "log_bad": 2.3979,
+      "log_good": 2.7081
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0442,
+      "good": 0.028,
+      "ratio": 0.6335,
+      "suggested_scalar": -0.1389,
+      "log_bad": -3.119,
+      "log_good": -3.5756
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8074,
+      "good": 5.9773,
+      "ratio": 1.0293,
+      "suggested_scalar": 0.0088,
+      "log_bad": 1.7591,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 81.0,
+      "good": 47.0,
+      "ratio": 0.5802,
+      "suggested_scalar": -0.1657,
+      "log_bad": 4.3944,
+      "log_good": 3.8501
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9715,
+      "good": 0.8529,
+      "ratio": 0.8779,
+      "suggested_scalar": -0.0396,
+      "log_bad": -0.0289,
+      "log_good": -0.1591
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5804,
+      "good": 5.5077,
+      "ratio": 0.987,
+      "suggested_scalar": -0.004,
+      "log_bad": 1.7193,
+      "log_good": 1.7061
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8135,
+      "good": 0.7995,
+      "ratio": 0.9828,
+      "suggested_scalar": -0.0053,
+      "log_bad": -0.2064,
+      "log_good": -0.2238
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1,
+      "good": 0.1625,
+      "ratio": 1.625,
+      "suggested_scalar": 0.1478,
+      "log_bad": -2.3026,
+      "log_good": -1.8171
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.1068,
+      "good": 5.0165,
+      "ratio": 1.2215,
+      "suggested_scalar": 0.0609,
+      "log_bad": 1.4126,
+      "log_good": 1.6127
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 0.4898,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 342.0,
+      "good": 349.0,
+      "ratio": 1.0205,
+      "suggested_scalar": 0.0062,
+      "log_bad": 5.8348,
+      "log_good": 5.8551
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 7.0,
+      "good": 10.0,
+      "ratio": 1.4286,
+      "suggested_scalar": 0.1086,
+      "log_bad": 1.9459,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.1208,
+      "good": 1.0315,
+      "ratio": 0.9203,
+      "suggested_scalar": -0.0253,
+      "log_bad": 0.114,
+      "log_good": 0.031
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 100.0,
+      "good": 104.0,
+      "ratio": 1.04,
+      "suggested_scalar": 0.0119,
+      "log_bad": 4.6052,
+      "log_good": 4.6444
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1244.0,
+      "good": 1315.0,
+      "ratio": 1.0571,
+      "suggested_scalar": 0.0169,
+      "log_bad": 7.1261,
+      "log_good": 7.1816
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 198.0,
+      "good": 170.0,
+      "ratio": 0.8586,
+      "suggested_scalar": -0.0464,
+      "log_bad": 5.2883,
+      "log_good": 5.1358
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2891,
+      "good": 0.276,
+      "ratio": 0.9547,
+      "suggested_scalar": -0.0141,
+      "log_bad": -1.241,
+      "log_good": -1.2874
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 88.0,
+      "good": 89.0,
+      "ratio": 1.0114,
+      "suggested_scalar": 0.0034,
+      "log_bad": 4.4773,
+      "log_good": 4.4886
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 9.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1234,
+      "log_bad": 1.7918,
+      "log_good": 2.1972
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 100.0,
+      "good": 104.0,
+      "ratio": 1.04,
+      "suggested_scalar": 0.0119,
+      "log_bad": 4.6052,
+      "log_good": 4.6444
+    },
+    "brevity.mean_sample_size": {
+      "bad": 100.0,
+      "good": 104.0,
+      "ratio": 1.04,
+      "suggested_scalar": 0.0119,
+      "log_bad": 4.6052,
+      "log_good": 4.6444
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 543.0,
+      "good": 500.0,
+      "ratio": 0.9208,
+      "suggested_scalar": -0.0251,
+      "log_bad": 6.2971,
+      "log_good": 6.2146
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 275.0,
+      "good": 283.0,
+      "ratio": 1.0291,
+      "suggested_scalar": 0.0087,
+      "log_bad": 5.6168,
+      "log_good": 5.6454
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 256.0,
+      "good": 258.0,
+      "ratio": 1.0078,
+      "suggested_scalar": 0.0024,
+      "log_bad": 5.5452,
+      "log_good": 5.553
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0018,
+      "good": 0.01,
+      "ratio": 5.5556,
+      "suggested_scalar": 0.5219,
+      "log_bad": -6.32,
+      "log_good": -4.6052
+    },
+    "heaps.mean_k": {
+      "bad": 1.0878,
+      "good": 3.21,
+      "ratio": 2.9509,
+      "suggested_scalar": 0.3293,
+      "log_bad": 0.0842,
+      "log_good": 1.1663
+    },
+    "halstead.mean_effort": {
+      "bad": 134148.8568,
+      "good": 109920.5484,
+      "ratio": 0.8194,
+      "suggested_scalar": -0.0606,
+      "log_bad": 11.8067,
+      "log_good": 11.6075
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8399,
+      "good": 0.822,
+      "ratio": 0.9787,
+      "suggested_scalar": -0.0066,
+      "log_bad": -0.1745,
+      "log_good": -0.196
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 67.0,
+      "good": 67.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2047,
+      "log_good": 4.2047
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 315.0,
+      "good": 301.0,
+      "ratio": 0.9556,
+      "suggested_scalar": -0.0138,
+      "log_bad": 5.7526,
+      "log_good": 5.7071
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3416,
+      "good": 0.3964,
+      "ratio": 1.1604,
+      "suggested_scalar": 0.0453,
+      "log_bad": -1.0741,
+      "log_good": -0.9253
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.1584,
+      "good": 7.7811,
+      "ratio": 1.2635,
+      "suggested_scalar": 0.0712,
+      "log_bad": 1.8178,
+      "log_good": 2.0517
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1,
+      "good": 0.1625,
+      "ratio": 1.625,
+      "suggested_scalar": 0.1478,
+      "log_bad": -2.3026,
+      "log_good": -1.8171
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.0167,
+      "good": 5.8739,
+      "ratio": 1.9471,
+      "suggested_scalar": 0.2028,
+      "log_bad": 1.1042,
+      "log_good": 1.7705
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 542.0,
+      "good": 499.0,
+      "ratio": 0.9207,
+      "suggested_scalar": -0.0252,
+      "log_bad": 6.2953,
+      "log_good": 6.2126
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 7.0,
+      "ratio": 7.0,
+      "suggested_scalar": 0.5922,
+      "log_bad": 0.0,
+      "log_good": 1.9459
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 68.0,
+      "good": 74.0,
+      "ratio": 1.0882,
+      "suggested_scalar": 0.0257,
+      "log_bad": 4.2195,
+      "log_good": 4.3041
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 7452.7143,
+      "good": 6106.6971,
+      "ratio": 0.8194,
+      "suggested_scalar": -0.0606,
+      "log_bad": 8.9163,
+      "log_good": 8.7171
+    },
+    "readability.mean_total_lines": {
+      "bad": 72.0,
+      "good": 66.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0265,
+      "log_bad": 4.2767,
+      "log_good": 4.1897
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 6.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0876,
+      "log_bad": 2.0794,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 3362.5041,
+      "good": 3094.402,
+      "ratio": 0.9203,
+      "suggested_scalar": -0.0253,
+      "log_bad": 8.1204,
+      "log_good": 8.0373
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 701.0,
+      "good": 735.0,
+      "ratio": 1.0485,
+      "suggested_scalar": 0.0144,
+      "log_bad": 6.5525,
+      "log_good": 6.5999
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.0556,
+      "good": 31.1667,
+      "ratio": 1.037,
+      "suggested_scalar": 0.011,
+      "log_bad": 3.403,
+      "log_good": 3.4394
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.236,
+      "good": 1.3081,
+      "ratio": 1.0583,
+      "suggested_scalar": 0.0173,
+      "log_bad": 0.2119,
+      "log_good": 0.2686
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1234,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 63.0,
+      "good": 42.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1234,
+      "log_bad": 4.1431,
+      "log_good": 3.7377
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8012,
+      "good": 0.788,
+      "ratio": 0.9835,
+      "suggested_scalar": -0.0051,
+      "log_bad": -0.2216,
+      "log_good": -0.2383
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9444,
+      "good": 0.9763,
+      "ratio": 1.0338,
+      "suggested_scalar": 0.0101,
+      "log_bad": -0.0572,
+      "log_good": -0.024
+    },
+    "halstead.mean_length": {
+      "bad": 513.0,
+      "good": 471.0,
+      "ratio": 0.9181,
+      "suggested_scalar": -0.026,
+      "log_bad": 6.2403,
+      "log_good": 6.1549
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.3333,
+      "good": 7.4444,
+      "ratio": 0.7976,
+      "suggested_scalar": -0.0688,
+      "log_bad": 2.2336,
+      "log_good": 2.0075
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6439,
+      "good": 6.7004,
+      "ratio": 1.0085,
+      "suggested_scalar": 0.0026,
+      "log_bad": 1.8937,
+      "log_good": 1.9022
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1225,
+      "good": 0.1318,
+      "ratio": 1.0759,
+      "suggested_scalar": 0.0223,
+      "log_bad": -2.0996,
+      "log_good": -2.0265
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 39.8955,
+      "good": 35.5224,
+      "ratio": 0.8904,
+      "suggested_scalar": -0.0353,
+      "log_bad": 3.6863,
+      "log_good": 3.5702
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.211,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 69.0,
+      "good": 67.0,
+      "ratio": 0.971,
+      "suggested_scalar": -0.009,
+      "log_bad": 4.2341,
+      "log_good": 4.2047
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6563,
+      "good": 0.655,
+      "ratio": 0.998,
+      "suggested_scalar": -0.0006,
+      "log_bad": -0.4211,
+      "log_good": -0.4231
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 72.0,
+      "good": 67.0,
+      "ratio": 0.9306,
+      "suggested_scalar": -0.0219,
+      "log_bad": 4.2767,
+      "log_good": 4.2047
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 20.0,
+      "good": 25.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0679,
+      "log_bad": 2.9957,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.methods_use_camel_case": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "documentation.file_has_no_commented_out_code": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 51.0,
+      "good": 44.0,
+      "ratio": 0.8627,
+      "suggested_scalar": -0.0454,
+      "log_bad": 3.9318,
+      "log_good": 3.7842
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0167,
+      "good": 0.0128,
+      "ratio": 0.7665,
+      "suggested_scalar": -0.0818,
+      "log_bad": -4.0923,
+      "log_good": -4.3583
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8625,
+      "good": 0.8592,
+      "ratio": 0.9962,
+      "suggested_scalar": -0.0012,
+      "log_bad": -0.1479,
+      "log_good": -0.1518
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0167,
+      "good": 0.0128,
+      "ratio": 0.7665,
+      "suggested_scalar": -0.0818,
+      "log_bad": -4.0923,
+      "log_good": -4.3583
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7406,
+      "good": 4.7014,
+      "ratio": 0.9917,
+      "suggested_scalar": -0.0026,
+      "log_bad": 1.5562,
+      "log_good": 1.5479
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 130.0,
+      "good": 106.0,
+      "ratio": 0.8154,
+      "suggested_scalar": -0.0628,
+      "log_bad": 4.8675,
+      "log_good": 4.6634
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5321,
+      "good": 0.4666,
+      "ratio": 0.8769,
+      "suggested_scalar": -0.0404,
+      "log_bad": -0.6309,
+      "log_good": -0.7623
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6153,
+      "good": 0.5232,
+      "ratio": 0.8503,
+      "suggested_scalar": -0.0499,
+      "log_bad": -0.4856,
+      "log_good": -0.6478
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.775,
+      "good": 4.5352,
+      "ratio": 1.2014,
+      "suggested_scalar": 0.0564,
+      "log_bad": 1.3284,
+      "log_good": 1.5119
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 659.0,
+      "good": 626.0,
+      "ratio": 0.9499,
+      "suggested_scalar": -0.0158,
+      "log_bad": 6.4907,
+      "log_good": 6.4394
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0017,
+      "good": 0.0009,
+      "ratio": 0.5294,
+      "suggested_scalar": -0.1956,
+      "log_bad": -6.3771,
+      "log_good": -7.0131
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.3125,
+      "good": 1.0,
+      "ratio": 3.2,
+      "suggested_scalar": 0.3578,
+      "log_bad": -1.1632,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0009,
+      "good": 0.0004,
+      "ratio": 0.4444,
+      "suggested_scalar": -0.2494,
+      "log_bad": -7.0131,
+      "log_good": -7.824
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0756,
+      "good": 1.0605,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0043,
+      "log_bad": 0.0729,
+      "log_good": 0.0587
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 208.0,
+      "good": 206.0,
+      "ratio": 0.9904,
+      "suggested_scalar": -0.003,
+      "log_bad": 5.3375,
+      "log_good": 5.3279
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 99.5396,
+      "good": 103.2937,
+      "ratio": 1.0377,
+      "suggested_scalar": 0.0114,
+      "log_bad": 4.6006,
+      "log_good": 4.6376
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6505,
+      "good": 0.6464,
+      "ratio": 0.9937,
+      "suggested_scalar": -0.0019,
+      "log_bad": -0.43,
+      "log_good": -0.4363
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 6.1047,
+      "good": 7.1898,
+      "ratio": 1.1777,
+      "suggested_scalar": 0.0503,
+      "log_bad": 1.8091,
+      "log_good": 1.9727
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2290.0,
+      "good": 2240.0,
+      "ratio": 0.9782,
+      "suggested_scalar": -0.0068,
+      "log_bad": 7.7363,
+      "log_good": 7.7142
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1,
+      "good": 0.1127,
+      "ratio": 1.127,
+      "suggested_scalar": 0.0368,
+      "log_bad": -2.3026,
+      "log_good": -2.183
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8375,
+      "good": 0.8169,
+      "ratio": 0.9754,
+      "suggested_scalar": -0.0077,
+      "log_bad": -0.1773,
+      "log_good": -0.2022
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 11.9818,
+      "good": 8.8169,
+      "ratio": 0.7359,
+      "suggested_scalar": -0.0943,
+      "log_bad": 2.4834,
+      "log_good": 2.1767
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 4.7744,
+      "good": 5.7135,
+      "ratio": 1.1967,
+      "suggested_scalar": 0.0552,
+      "log_bad": 1.5633,
+      "log_good": 1.7428
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 150.0,
+      "good": 158.0,
+      "ratio": 1.0533,
+      "suggested_scalar": 0.016,
+      "log_bad": 5.0106,
+      "log_good": 5.0626
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9575,
+      "good": 0.9529,
+      "ratio": 0.9952,
+      "suggested_scalar": -0.0015,
+      "log_bad": -0.0434,
+      "log_good": -0.0482
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 35.0,
+      "good": 37.0,
+      "ratio": 1.0571,
+      "suggested_scalar": 0.0171,
+      "log_bad": 3.5553,
+      "log_good": 3.6109
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5834,
+      "good": 0.5982,
+      "ratio": 1.0254,
+      "suggested_scalar": 0.0077,
+      "log_bad": -0.5389,
+      "log_good": -0.5138
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4155,
+      "good": 0.4519,
+      "ratio": 1.0876,
+      "suggested_scalar": 0.0258,
+      "log_bad": -0.8783,
+      "log_good": -0.7943
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4004,
+      "good": 2.4889,
+      "ratio": 1.0369,
+      "suggested_scalar": 0.0111,
+      "log_bad": 0.8756,
+      "log_good": 0.9118
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 657.0,
+      "good": 624.0,
+      "ratio": 0.9498,
+      "suggested_scalar": -0.0159,
+      "log_bad": 6.4877,
+      "log_good": 6.4362
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 30.0,
+      "good": 20.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1247,
+      "log_bad": 3.4012,
+      "log_good": 2.9957
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0243,
+      "good": 0.016,
+      "ratio": 0.6584,
+      "suggested_scalar": -0.1285,
+      "log_bad": -3.7173,
+      "log_good": -4.1352
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.2095,
+      "good": 6.0875,
+      "ratio": 0.9804,
+      "suggested_scalar": -0.0061,
+      "log_bad": 1.8261,
+      "log_good": 1.8062
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 52.0,
+      "good": 42.0,
+      "ratio": 0.8077,
+      "suggested_scalar": -0.0657,
+      "log_bad": 3.9512,
+      "log_good": 3.7377
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9877,
+      "good": 0.9099,
+      "ratio": 0.9212,
+      "suggested_scalar": -0.0252,
+      "log_bad": -0.0124,
+      "log_good": -0.0944
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.891,
+      "good": 5.8819,
+      "ratio": 0.9985,
+      "suggested_scalar": -0.0005,
+      "log_bad": 1.7734,
+      "log_good": 1.7719
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7635,
+      "good": 0.7723,
+      "ratio": 1.0115,
+      "suggested_scalar": 0.0035,
+      "log_bad": -0.2698,
+      "log_good": -0.2584
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1209,
+      "good": 0.1446,
+      "ratio": 1.196,
+      "suggested_scalar": 0.0551,
+      "log_bad": -2.1128,
+      "log_good": -1.9338
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.4708,
+      "good": 2.6814,
+      "ratio": 1.0852,
+      "suggested_scalar": 0.0252,
+      "log_bad": 0.9045,
+      "log_good": 0.9863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 490.0,
+      "good": 439.0,
+      "ratio": 0.8959,
+      "suggested_scalar": -0.0338,
+      "log_bad": 6.1944,
+      "log_good": 6.0845
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 8.0,
+      "good": 6.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0885,
+      "log_bad": 2.0794,
+      "log_good": 1.7918
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.367,
+      "good": 1.2178,
+      "ratio": 0.8909,
+      "suggested_scalar": -0.0355,
+      "log_bad": 0.3126,
+      "log_good": 0.197
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 136.0,
+      "good": 134.0,
+      "ratio": 0.9853,
+      "suggested_scalar": -0.0046,
+      "log_bad": 4.9127,
+      "log_good": 4.8978
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1108.0,
+      "good": 1124.0,
+      "ratio": 1.0144,
+      "suggested_scalar": 0.0044,
+      "log_bad": 7.0103,
+      "log_good": 7.0246
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 209.0,
+      "good": 175.0,
+      "ratio": 0.8373,
+      "suggested_scalar": -0.0546,
+      "log_bad": 5.3423,
+      "log_good": 5.1648
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0061,
+      "good": 0.0112,
+      "ratio": 1.8361,
+      "suggested_scalar": 0.1869,
+      "log_bad": -5.0995,
+      "log_good": -4.4918
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2549,
+      "good": 0.2572,
+      "ratio": 1.009,
+      "suggested_scalar": 0.0028,
+      "log_bad": -1.3669,
+      "log_good": -1.3579
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 127.0,
+      "good": 111.0,
+      "ratio": 0.874,
+      "suggested_scalar": -0.0414,
+      "log_bad": 4.8442,
+      "log_good": 4.7095
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0686,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 136.0,
+      "good": 134.0,
+      "ratio": 0.9853,
+      "suggested_scalar": -0.0046,
+      "log_bad": 4.9127,
+      "log_good": 4.8978
+    },
+    "brevity.mean_sample_size": {
+      "bad": 136.0,
+      "good": 134.0,
+      "ratio": 0.9853,
+      "suggested_scalar": -0.0046,
+      "log_bad": 4.9127,
+      "log_good": 4.8978
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 659.0,
+      "good": 626.0,
+      "ratio": 0.9499,
+      "suggested_scalar": -0.0158,
+      "log_bad": 6.4907,
+      "log_good": 6.4394
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 391.0,
+      "good": 362.0,
+      "ratio": 0.9258,
+      "suggested_scalar": -0.0237,
+      "log_bad": 5.9687,
+      "log_good": 5.8916
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 357.0,
+      "good": 332.0,
+      "ratio": 0.93,
+      "suggested_scalar": -0.0223,
+      "log_bad": 5.8777,
+      "log_good": 5.8051
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0015,
+      "good": 1.0,
+      "ratio": 666.6667,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.5023,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.6313,
+      "good": 4.9724,
+      "ratio": 1.8897,
+      "suggested_scalar": 0.1958,
+      "log_bad": 0.9675,
+      "log_good": 1.6039
+    },
+    "halstead.mean_effort": {
+      "bad": 157890.9179,
+      "good": 171412.056,
+      "ratio": 1.0856,
+      "suggested_scalar": 0.0253,
+      "log_bad": 11.9697,
+      "log_good": 12.0518
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8312,
+      "good": 0.8324,
+      "ratio": 1.0014,
+      "suggested_scalar": 0.0004,
+      "log_bad": -0.1849,
+      "log_good": -0.1834
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 95.0,
+      "good": 69.0,
+      "ratio": 0.7263,
+      "suggested_scalar": -0.0984,
+      "log_bad": 4.5539,
+      "log_good": 4.2341
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 375.0,
+      "good": 368.0,
+      "ratio": 0.9813,
+      "suggested_scalar": -0.0058,
+      "log_bad": 5.9269,
+      "log_good": 5.9081
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4471,
+      "good": 0.4272,
+      "ratio": 0.9555,
+      "suggested_scalar": -0.014,
+      "log_bad": -0.805,
+      "log_good": -0.8505
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.3269,
+      "good": 5.4563,
+      "ratio": 1.0243,
+      "suggested_scalar": 0.0074,
+      "log_bad": 1.6728,
+      "log_good": 1.6968
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1209,
+      "good": 0.1446,
+      "ratio": 1.196,
+      "suggested_scalar": 0.0551,
+      "log_bad": -2.1128,
+      "log_good": -1.9338
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.9484,
+      "good": 3.8417,
+      "ratio": 0.7764,
+      "suggested_scalar": -0.0779,
+      "log_bad": 1.5991,
+      "log_good": 1.3459
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 658.0,
+      "good": 625.0,
+      "ratio": 0.9498,
+      "suggested_scalar": -0.0158,
+      "log_bad": 6.4892,
+      "log_good": 6.4378
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 12.0,
+      "good": 8.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1247,
+      "log_bad": 2.4849,
+      "log_good": 2.0794
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 106.0,
+      "good": 97.0,
+      "ratio": 0.9151,
+      "suggested_scalar": -0.0273,
+      "log_bad": 4.6634,
+      "log_good": 4.5747
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 8771.7177,
+      "good": 9522.892,
+      "ratio": 1.0856,
+      "suggested_scalar": 0.0253,
+      "log_bad": 9.0793,
+      "log_good": 9.1615
+    },
+    "readability.mean_total_lines": {
+      "bad": 55.0,
+      "good": 71.0,
+      "ratio": 1.2909,
+      "suggested_scalar": 0.0785,
+      "log_bad": 4.0073,
+      "log_good": 4.2627
+    },
+    "indentation.mean_max_depth": {
+      "bad": 9.0,
+      "good": 10.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0324,
+      "log_bad": 2.1972,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 4101.0628,
+      "good": 3653.2608,
+      "ratio": 0.8908,
+      "suggested_scalar": -0.0356,
+      "log_bad": 8.319,
+      "log_good": 8.2034
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 954.0,
+      "good": 900.0,
+      "ratio": 0.9434,
+      "suggested_scalar": -0.0179,
+      "log_bad": 6.8607,
+      "log_good": 6.8024
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 26.9273,
+      "good": 30.3803,
+      "ratio": 1.1282,
+      "suggested_scalar": 0.0371,
+      "log_bad": 3.2931,
+      "log_good": 3.4138
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1245,
+      "good": 1.1181,
+      "ratio": 0.9943,
+      "suggested_scalar": -0.0018,
+      "log_bad": 0.1173,
+      "log_good": 0.1116
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 40.0,
+      "good": 35.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0411,
+      "log_bad": 3.6889,
+      "log_good": 3.5553
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 25.0,
+      "good": 1.0,
+      "ratio": 0.04,
+      "suggested_scalar": -0.9901,
+      "log_bad": 3.2189,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7837,
+      "good": 0.779,
+      "ratio": 0.994,
+      "suggested_scalar": -0.0019,
+      "log_bad": -0.2437,
+      "log_good": -0.2497
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9885,
+      "good": 0.9262,
+      "ratio": 0.937,
+      "suggested_scalar": -0.02,
+      "log_bad": -0.0116,
+      "log_good": -0.0767
+    },
+    "halstead.mean_length": {
+      "bad": 584.0,
+      "good": 543.0,
+      "ratio": 0.9298,
+      "suggested_scalar": -0.0224,
+      "log_bad": 6.3699,
+      "log_good": 6.2971
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 18.5,
+      "good": 13.4,
+      "ratio": 0.7243,
+      "suggested_scalar": -0.0992,
+      "log_bad": 2.9178,
+      "log_good": 2.5953
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.0875,
+      "good": 7.0661,
+      "ratio": 0.997,
+      "suggested_scalar": -0.0009,
+      "log_bad": 1.9583,
+      "log_good": 1.9553
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1709,
+      "good": 0.1616,
+      "ratio": 0.9456,
+      "suggested_scalar": -0.0172,
+      "log_bad": -1.7667,
+      "log_good": -1.8226
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 38.5,
+      "good": 46.9203,
+      "ratio": 1.2187,
+      "suggested_scalar": 0.0608,
+      "log_bad": 3.6507,
+      "log_good": 3.8485
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 93.0,
+      "good": 88.0,
+      "ratio": 0.9462,
+      "suggested_scalar": -0.017,
+      "log_bad": 4.5326,
+      "log_good": 4.4773
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6443,
+      "good": 0.6657,
+      "ratio": 1.0332,
+      "suggested_scalar": 0.0101,
+      "log_bad": -0.4396,
+      "log_good": -0.4069
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 80.0,
+      "good": 71.0,
+      "ratio": 0.8875,
+      "suggested_scalar": -0.0367,
+      "log_bad": 4.382,
+      "log_good": 4.2627
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.classes_use_studly_caps": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "file_structure.line_length_under_120": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 27.0,
+      "good": 32.0,
+      "ratio": 1.1852,
+      "suggested_scalar": 0.0477,
+      "log_bad": 3.2958,
+      "log_good": 3.4657
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.0944,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0267,
+      "good": 0.0243,
+      "ratio": 0.9101,
+      "suggested_scalar": -0.0264,
+      "log_bad": -3.6231,
+      "log_good": -3.7173
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.6667,
+      "good": 2.4167,
+      "ratio": 0.9063,
+      "suggested_scalar": -0.0276,
+      "log_bad": 0.9808,
+      "log_good": 0.8824
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8378,
+      "good": 0.8784,
+      "ratio": 1.0485,
+      "suggested_scalar": 0.0133,
+      "log_bad": -0.177,
+      "log_good": -0.1297
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0267,
+      "good": 0.0243,
+      "ratio": 0.9101,
+      "suggested_scalar": -0.0264,
+      "log_bad": -3.6231,
+      "log_good": -3.7173
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.824,
+      "good": 4.6761,
+      "ratio": 0.9693,
+      "suggested_scalar": -0.0087,
+      "log_bad": 1.5736,
+      "log_good": 1.5425
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 141.0,
+      "good": 130.0,
+      "ratio": 0.922,
+      "suggested_scalar": -0.0228,
+      "log_bad": 4.9488,
+      "log_good": 4.8675
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4214,
+      "good": 0.3914,
+      "ratio": 0.9288,
+      "suggested_scalar": -0.0207,
+      "log_bad": -0.8642,
+      "log_good": -0.938
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 22.0,
+      "good": 21.0,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.013,
+      "log_bad": 3.091,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5703,
+      "good": 0.5566,
+      "ratio": 0.976,
+      "suggested_scalar": -0.0068,
+      "log_bad": -0.5616,
+      "log_good": -0.5859
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.5405,
+      "good": 3.973,
+      "ratio": 1.5639,
+      "suggested_scalar": 0.1254,
+      "log_bad": 0.9324,
+      "log_good": 1.3795
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 749.0,
+      "good": 741.0,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.003,
+      "log_bad": 6.6187,
+      "log_good": 6.608
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0008,
+      "good": 1.0,
+      "ratio": 1250.0,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.1309,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0831,
+      "good": 1.0983,
+      "ratio": 1.014,
+      "suggested_scalar": 0.0039,
+      "log_bad": 0.0798,
+      "log_good": 0.0938
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 233.0,
+      "good": 236.0,
+      "ratio": 1.0129,
+      "suggested_scalar": 0.0036,
+      "log_bad": 5.451,
+      "log_good": 5.4638
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 82.9159,
+      "good": 95.6971,
+      "ratio": 1.1541,
+      "suggested_scalar": 0.0402,
+      "log_bad": 4.4178,
+      "log_good": 4.5612
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5989,
+      "good": 0.6297,
+      "ratio": 1.0514,
+      "suggested_scalar": 0.0141,
+      "log_bad": -0.5127,
+      "log_good": -0.4625
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 18.2195,
+      "good": 13.0497,
+      "ratio": 0.7162,
+      "suggested_scalar": -0.0936,
+      "log_bad": 2.9025,
+      "log_good": 2.5688
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2631.0,
+      "good": 2795.0,
+      "ratio": 1.0623,
+      "suggested_scalar": 0.017,
+      "log_bad": 7.8751,
+      "log_good": 7.9356
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1351,
+      "good": 0.0676,
+      "ratio": 0.5004,
+      "suggested_scalar": -0.1942,
+      "log_bad": -2.0017,
+      "log_good": -2.6941
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8108,
+      "good": 0.8649,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.0181,
+      "log_bad": -0.2097,
+      "log_good": -0.1451
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 20.2432,
+      "good": 10.0135,
+      "ratio": 0.4947,
+      "suggested_scalar": -0.1974,
+      "log_bad": 3.0078,
+      "log_good": 2.3039
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.2213,
+      "good": 3.0804,
+      "ratio": 2.5222,
+      "suggested_scalar": 0.2595,
+      "log_bad": 0.1999,
+      "log_good": 1.1251
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 213.0,
+      "good": 216.0,
+      "ratio": 1.0141,
+      "suggested_scalar": 0.0039,
+      "log_bad": 5.3613,
+      "log_good": 5.3753
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9648,
+      "good": 0.9668,
+      "ratio": 1.0021,
+      "suggested_scalar": 0.0006,
+      "log_bad": -0.0358,
+      "log_good": -0.0338
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 35.0,
+      "good": 34.0,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.0081,
+      "log_bad": 3.5553,
+      "log_good": 3.5264
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6222,
+      "good": 0.654,
+      "ratio": 1.0511,
+      "suggested_scalar": 0.014,
+      "log_bad": -0.4745,
+      "log_good": -0.4246
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4043,
+      "good": 0.4032,
+      "ratio": 0.9973,
+      "suggested_scalar": -0.0008,
+      "log_bad": -0.9056,
+      "log_good": -0.9083
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6469,
+      "good": 2.8904,
+      "ratio": 1.092,
+      "suggested_scalar": 0.0247,
+      "log_bad": 0.9734,
+      "log_good": 1.0614
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 747.0,
+      "good": 739.0,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.003,
+      "log_bad": 6.6161,
+      "log_good": 6.6053
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 8.0,
+      "good": 20.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.257,
+      "log_bad": 2.0794,
+      "log_good": 2.9957
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0441,
+      "good": 0.0567,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.0705,
+      "log_bad": -3.1213,
+      "log_good": -2.87
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.8826,
+      "ratio": 0.9959,
+      "suggested_scalar": -0.0012,
+      "log_bad": 1.7761,
+      "log_good": 1.772
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.447,
+      "good": 0.443,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.0025,
+      "log_bad": -0.8052,
+      "log_good": -0.8142
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8383,
+      "good": 5.7935,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.0022,
+      "log_bad": 1.7644,
+      "log_good": 1.7567
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8167,
+      "good": 0.7949,
+      "ratio": 0.9733,
+      "suggested_scalar": -0.0076,
+      "log_bad": -0.2025,
+      "log_good": -0.2295
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1957,
+      "good": 0.1685,
+      "ratio": 0.861,
+      "suggested_scalar": -0.042,
+      "log_bad": -1.6312,
+      "log_good": -1.7808
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.2684,
+      "good": 3.6124,
+      "ratio": 0.8463,
+      "suggested_scalar": -0.0468,
+      "log_bad": 1.4512,
+      "log_good": 1.2844
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 531.0,
+      "good": 523.0,
+      "ratio": 0.9849,
+      "suggested_scalar": -0.0043,
+      "log_bad": 6.2748,
+      "log_good": 6.2596
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 13.0,
+      "good": 8.0,
+      "ratio": 0.6154,
+      "suggested_scalar": -0.1362,
+      "log_bad": 2.5649,
+      "log_good": 2.0794
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.6231,
+      "good": 1.5894,
+      "ratio": 0.9792,
+      "suggested_scalar": -0.0059,
+      "log_bad": 0.4843,
+      "log_good": 0.4634
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 145.0,
+      "good": 135.0,
+      "ratio": 0.931,
+      "suggested_scalar": -0.02,
+      "log_bad": 4.9767,
+      "log_good": 4.9053
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1480.0,
+      "good": 1408.0,
+      "ratio": 0.9514,
+      "suggested_scalar": -0.014,
+      "log_bad": 7.2998,
+      "log_good": 7.2499
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 253.0,
+      "good": 255.0,
+      "ratio": 1.0079,
+      "suggested_scalar": 0.0022,
+      "log_bad": 5.5334,
+      "log_good": 5.5413
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.004,
+      "good": 0.004,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.5215,
+      "log_good": -5.5215
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2924,
+      "good": 0.3023,
+      "ratio": 1.0339,
+      "suggested_scalar": 0.0093,
+      "log_bad": -1.2296,
+      "log_good": -1.1963
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 104.0,
+      "good": 114.0,
+      "ratio": 1.0962,
+      "suggested_scalar": 0.0257,
+      "log_bad": 4.6444,
+      "log_good": 4.7362
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 145.0,
+      "good": 135.0,
+      "ratio": 0.931,
+      "suggested_scalar": -0.02,
+      "log_bad": 4.9767,
+      "log_good": 4.9053
+    },
+    "brevity.mean_sample_size": {
+      "bad": 145.0,
+      "good": 135.0,
+      "ratio": 0.931,
+      "suggested_scalar": -0.02,
+      "log_bad": 4.9767,
+      "log_good": 4.9053
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 749.0,
+      "good": 741.0,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.003,
+      "log_bad": 6.6187,
+      "log_good": 6.608
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 402.0,
+      "good": 391.0,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.0078,
+      "log_bad": 5.9965,
+      "log_good": 5.9687
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 404.0,
+      "good": 388.0,
+      "ratio": 0.9604,
+      "suggested_scalar": -0.0113,
+      "log_bad": 6.0014,
+      "log_good": 5.961
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0053,
+      "good": 0.0054,
+      "ratio": 1.0189,
+      "suggested_scalar": 0.0052,
+      "log_bad": -5.24,
+      "log_good": -5.2214
+    },
+    "heaps.mean_k": {
+      "bad": 3.3186,
+      "good": 3.4218,
+      "ratio": 1.0311,
+      "suggested_scalar": 0.0086,
+      "log_bad": 1.1995,
+      "log_good": 1.2302
+    },
+    "halstead.mean_effort": {
+      "bad": 203379.8866,
+      "good": 215313.4779,
+      "ratio": 1.0587,
+      "suggested_scalar": 0.016,
+      "log_bad": 12.2228,
+      "log_good": 12.2799
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8131,
+      "good": 0.8187,
+      "ratio": 1.0069,
+      "suggested_scalar": 0.0019,
+      "log_bad": -0.2069,
+      "log_good": -0.2
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 106.0,
+      "good": 96.0,
+      "ratio": 0.9057,
+      "suggested_scalar": -0.0278,
+      "log_bad": 4.6634,
+      "log_good": 4.5643
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 429.0,
+      "good": 424.0,
+      "ratio": 0.9883,
+      "suggested_scalar": -0.0033,
+      "log_bad": 6.0615,
+      "log_good": 6.0497
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.412,
+      "good": 0.3686,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.0312,
+      "log_bad": -0.8867,
+      "log_good": -0.998
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.3519,
+      "good": 5.9661,
+      "ratio": 0.9393,
+      "suggested_scalar": -0.0176,
+      "log_bad": 1.8488,
+      "log_good": 1.7861
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1957,
+      "good": 0.1685,
+      "ratio": 0.861,
+      "suggested_scalar": -0.042,
+      "log_bad": -1.6312,
+      "log_good": -1.7808
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 9.3991,
+      "good": 4.5919,
+      "ratio": 0.4885,
+      "suggested_scalar": -0.2009,
+      "log_bad": 2.2406,
+      "log_good": 1.5243
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 748.0,
+      "good": 740.0,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.003,
+      "log_bad": 6.6174,
+      "log_good": 6.6067
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0807,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 86.0,
+      "good": 82.0,
+      "ratio": 0.9535,
+      "suggested_scalar": -0.0134,
+      "log_bad": 4.4543,
+      "log_good": 4.4067
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 11298.8826,
+      "good": 11961.8599,
+      "ratio": 1.0587,
+      "suggested_scalar": 0.016,
+      "log_bad": 9.3325,
+      "log_good": 9.3895
+    },
+    "readability.mean_total_lines": {
+      "bad": 37.0,
+      "good": 74.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1944,
+      "log_bad": 3.6109,
+      "log_good": 4.3041
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1137,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 4869.174,
+      "good": 4768.1877,
+      "ratio": 0.9793,
+      "suggested_scalar": -0.0059,
+      "log_bad": 8.4907,
+      "log_good": 8.4697
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 994.0,
+      "good": 967.0,
+      "ratio": 0.9728,
+      "suggested_scalar": -0.0077,
+      "log_bad": 6.9017,
+      "log_good": 6.8742
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 69.8649,
+      "good": 36.5676,
+      "ratio": 0.5234,
+      "suggested_scalar": -0.1816,
+      "log_bad": 4.2466,
+      "log_good": 3.5992
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2219,
+      "good": 1.1935,
+      "ratio": 0.9768,
+      "suggested_scalar": -0.0066,
+      "log_bad": 0.2004,
+      "log_good": 0.1769
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 41.0,
+      "good": 40.0,
+      "ratio": 0.9756,
+      "suggested_scalar": -0.0069,
+      "log_bad": 3.7136,
+      "log_good": 3.6889
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.838,
+      "good": 0.8432,
+      "ratio": 1.0062,
+      "suggested_scalar": 0.0017,
+      "log_bad": -0.1767,
+      "log_good": -0.1706
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9886,
+      "good": 0.9895,
+      "ratio": 1.0009,
+      "suggested_scalar": 0.0003,
+      "log_bad": -0.0115,
+      "log_good": -0.0106
+    },
+    "halstead.mean_length": {
+      "bad": 682.0,
+      "good": 679.0,
+      "ratio": 0.9956,
+      "suggested_scalar": -0.0012,
+      "log_bad": 6.525,
+      "log_good": 6.5206
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 3.25,
+      "good": 6.8333,
+      "ratio": 2.1026,
+      "suggested_scalar": 0.2084,
+      "log_bad": 1.1787,
+      "log_good": 1.9218
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.1799,
+      "good": 7.0768,
+      "ratio": 0.9856,
+      "suggested_scalar": -0.0041,
+      "log_bad": 1.9713,
+      "log_good": 1.9568
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1528,
+      "good": 0.1399,
+      "ratio": 0.9156,
+      "suggested_scalar": -0.0247,
+      "log_bad": -1.8786,
+      "log_good": -1.9668
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 41.7689,
+      "good": 45.1563,
+      "ratio": 1.0811,
+      "suggested_scalar": 0.0219,
+      "log_bad": 3.7322,
+      "log_good": 3.8101
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 96.0,
+      "good": 87.0,
+      "ratio": 0.9063,
+      "suggested_scalar": -0.0276,
+      "log_bad": 4.5643,
+      "log_good": 4.4659
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7426,
+      "good": 0.7062,
+      "ratio": 0.951,
+      "suggested_scalar": -0.0141,
+      "log_bad": -0.2976,
+      "log_good": -0.3479
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 37.0,
+      "good": 74.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1944,
+      "log_bad": 3.6109,
+      "log_good": 4.3041
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_comparison_to_true_false": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 40.0,
+      "good": 40.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6889,
+      "log_good": 3.6889
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.042,
+      "good": 0.0617,
+      "ratio": 1.469,
+      "suggested_scalar": 0.4293,
+      "log_bad": -3.1701,
+      "log_good": -2.7855
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.7143,
+      "good": 0.7143,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3365,
+      "log_good": -0.3365
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.86,
+      "good": 0.9048,
+      "ratio": 1.0521,
+      "suggested_scalar": 0.0567,
+      "log_bad": -0.1508,
+      "log_good": -0.1
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.049,
+      "good": 0.0617,
+      "ratio": 1.2592,
+      "suggested_scalar": 0.2572,
+      "log_bad": -3.0159,
+      "log_good": -2.7855
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6079,
+      "good": 4.6256,
+      "ratio": 1.0038,
+      "suggested_scalar": 0.0043,
+      "log_bad": 1.5278,
+      "log_good": 1.5316
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 79.0,
+      "good": 68.0,
+      "ratio": 0.8608,
+      "suggested_scalar": -0.1674,
+      "log_bad": 4.3694,
+      "log_good": 4.2195
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3836,
+      "good": 0.383,
+      "ratio": 0.9984,
+      "suggested_scalar": -0.0017,
+      "log_bad": -0.9582,
+      "log_good": -0.9597
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 16.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.1315,
+      "log_bad": 2.8904,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.594,
+      "good": 0.6113,
+      "ratio": 1.0291,
+      "suggested_scalar": 0.032,
+      "log_bad": -0.5209,
+      "log_good": -0.4922
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.6,
+      "good": 2.9524,
+      "ratio": 0.8201,
+      "suggested_scalar": -0.2214,
+      "log_bad": 1.2809,
+      "log_good": 1.0826
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 429.0,
+      "good": 389.0,
+      "ratio": 0.9068,
+      "suggested_scalar": -0.1093,
+      "log_bad": 6.0615,
+      "log_good": 5.9636
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0498,
+      "good": 1.0219,
+      "ratio": 0.9734,
+      "suggested_scalar": -0.0301,
+      "log_bad": 0.0486,
+      "log_good": 0.0217
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 138.0,
+      "good": 143.0,
+      "ratio": 1.0362,
+      "suggested_scalar": 0.0397,
+      "log_bad": 4.9273,
+      "log_good": 4.9628
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 110.9515,
+      "good": 110.0797,
+      "ratio": 0.9921,
+      "suggested_scalar": -0.0088,
+      "log_bad": 4.7091,
+      "log_good": 4.7012
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6799,
+      "good": 0.6211,
+      "ratio": 0.9135,
+      "suggested_scalar": -0.101,
+      "log_bad": -0.3858,
+      "log_good": -0.4763
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.5346,
+      "good": 8.3058,
+      "ratio": 0.8711,
+      "suggested_scalar": -0.154,
+      "log_bad": 2.2549,
+      "log_good": 2.117
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1866.0,
+      "good": 1594.0,
+      "ratio": 0.8542,
+      "suggested_scalar": -0.1759,
+      "log_bad": 7.5316,
+      "log_good": 7.374
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.32,
+      "good": 0.2619,
+      "ratio": 0.8184,
+      "suggested_scalar": -0.2236,
+      "log_bad": -1.1394,
+      "log_good": -1.3398
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.84,
+      "good": 0.9048,
+      "ratio": 1.0771,
+      "suggested_scalar": 0.0829,
+      "log_bad": -0.1744,
+      "log_good": -0.1
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.58,
+      "good": 9.2619,
+      "ratio": 1.0795,
+      "suggested_scalar": 0.0854,
+      "log_bad": 2.1494,
+      "log_good": 2.2259
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 4.0,
+      "good": 7.0,
+      "ratio": 1.75,
+      "suggested_scalar": 0.6247,
+      "log_bad": 1.3863,
+      "log_good": 1.9459
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 7.2,
+      "good": 5.3787,
+      "ratio": 0.747,
+      "suggested_scalar": -0.3255,
+      "log_bad": 1.9741,
+      "log_good": 1.6824
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 115.0,
+      "good": 118.0,
+      "ratio": 1.0261,
+      "suggested_scalar": 0.0287,
+      "log_bad": 4.7449,
+      "log_good": 4.7707
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 1.2263,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9298,
+      "good": 0.9366,
+      "ratio": 1.0073,
+      "suggested_scalar": 0.0081,
+      "log_bad": -0.0728,
+      "log_good": -0.0655
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 23.0,
+      "ratio": 0.8846,
+      "suggested_scalar": -0.1369,
+      "log_bad": 3.2581,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6426,
+      "good": 0.6292,
+      "ratio": 0.9791,
+      "suggested_scalar": -0.0235,
+      "log_bad": -0.4422,
+      "log_good": -0.4633
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5457,
+      "good": 0.4935,
+      "ratio": 0.9043,
+      "suggested_scalar": -0.1122,
+      "log_bad": -0.6057,
+      "log_good": -0.7062
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7976,
+      "good": 2.6971,
+      "ratio": 0.9641,
+      "suggested_scalar": -0.0408,
+      "log_bad": 1.0288,
+      "log_good": 0.9922
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 427.0,
+      "good": 387.0,
+      "ratio": 0.9063,
+      "suggested_scalar": -0.1098,
+      "log_bad": 6.0568,
+      "log_good": 5.9584
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 9.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.224,
+      "log_bad": 2.3979,
+      "log_good": 2.1972
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0536,
+      "good": 0.0463,
+      "ratio": 0.8638,
+      "suggested_scalar": -0.1634,
+      "log_bad": -2.9262,
+      "log_good": -3.0726
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7814,
+      "good": 5.7279,
+      "ratio": 0.9907,
+      "suggested_scalar": -0.0104,
+      "log_bad": 1.7546,
+      "log_good": 1.7453
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 14.0,
+      "good": 16.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.1491,
+      "log_bad": 2.6391,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.811,
+      "good": 0.8334,
+      "ratio": 1.0276,
+      "suggested_scalar": 0.0304,
+      "log_bad": -0.2095,
+      "log_good": -0.1822
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6952,
+      "good": 5.588,
+      "ratio": 0.9812,
+      "suggested_scalar": -0.0212,
+      "log_bad": 1.7396,
+      "log_good": 1.7206
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.797,
+      "good": 0.8075,
+      "ratio": 1.0132,
+      "suggested_scalar": 0.0146,
+      "log_bad": -0.2269,
+      "log_good": -0.2138
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 6.0,
+      "ratio": 6.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 1.7918
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2754,
+      "good": 0.3115,
+      "ratio": 1.1311,
+      "suggested_scalar": 0.1375,
+      "log_bad": -1.2895,
+      "log_good": -1.1664
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.0878,
+      "good": 2.882,
+      "ratio": 0.9334,
+      "suggested_scalar": -0.077,
+      "log_bad": 1.1275,
+      "log_good": 1.0585
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.7737,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 277.0,
+      "good": 262.0,
+      "ratio": 0.9458,
+      "suggested_scalar": -0.0621,
+      "log_bad": 5.624,
+      "log_good": 5.5683
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7018,
+      "good": 0.5945,
+      "ratio": 0.8471,
+      "suggested_scalar": -0.1852,
+      "log_bad": -0.3541,
+      "log_good": -0.52
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 97.0,
+      "good": 89.0,
+      "ratio": 0.9175,
+      "suggested_scalar": -0.0961,
+      "log_bad": 4.5747,
+      "log_good": 4.4886
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 841.0,
+      "good": 788.0,
+      "ratio": 0.937,
+      "suggested_scalar": -0.0727,
+      "log_bad": 6.7346,
+      "log_good": 6.6695
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 156.0,
+      "good": 133.0,
+      "ratio": 0.8526,
+      "suggested_scalar": -0.178,
+      "log_bad": 5.0499,
+      "log_good": 4.8903
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0163,
+      "good": 0.018,
+      "ratio": 1.1043,
+      "suggested_scalar": 0.1107,
+      "log_bad": -4.1166,
+      "log_good": -4.0174
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1981,
+      "good": 0.2031,
+      "ratio": 1.0252,
+      "suggested_scalar": 0.0278,
+      "log_bad": -1.619,
+      "log_good": -1.5941
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 83.0,
+      "good": 68.0,
+      "ratio": 0.8193,
+      "suggested_scalar": -0.2225,
+      "log_bad": 4.4188,
+      "log_good": 4.2195
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 97.0,
+      "good": 89.0,
+      "ratio": 0.9175,
+      "suggested_scalar": -0.0961,
+      "log_bad": 4.5747,
+      "log_good": 4.4886
+    },
+    "brevity.mean_sample_size": {
+      "bad": 97.0,
+      "good": 89.0,
+      "ratio": 0.9175,
+      "suggested_scalar": -0.0961,
+      "log_bad": 4.5747,
+      "log_good": 4.4886
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 429.0,
+      "good": 389.0,
+      "ratio": 0.9068,
+      "suggested_scalar": -0.1093,
+      "log_bad": 6.0615,
+      "log_good": 5.9636
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 198.0,
+      "good": 173.0,
+      "ratio": 0.8737,
+      "suggested_scalar": -0.1507,
+      "log_bad": 5.2883,
+      "log_good": 5.1533
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 220.0,
+      "good": 215.0,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.0257,
+      "log_bad": 5.3936,
+      "log_good": 5.3706
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0023,
+      "good": 0.0026,
+      "ratio": 1.1304,
+      "suggested_scalar": 0.1369,
+      "log_bad": -6.0748,
+      "log_good": -5.9522
+    },
+    "heaps.mean_k": {
+      "bad": 2.9319,
+      "good": 2.7087,
+      "ratio": 0.9239,
+      "suggested_scalar": -0.0884,
+      "log_bad": 1.0757,
+      "log_good": 0.9965
+    },
+    "halstead.mean_effort": {
+      "bad": 80563.7452,
+      "good": 60623.4868,
+      "ratio": 0.7525,
+      "suggested_scalar": -0.3174,
+      "log_bad": 11.2968,
+      "log_good": 11.0124
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.4526,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8629,
+      "good": 0.8629,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1475,
+      "log_good": -0.1475
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 53.0,
+      "good": 45.0,
+      "ratio": 0.8491,
+      "suggested_scalar": -0.1826,
+      "log_bad": 3.9703,
+      "log_good": 3.8067
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 178.0,
+      "good": 160.0,
+      "ratio": 0.8989,
+      "suggested_scalar": -0.119,
+      "log_bad": 5.1818,
+      "log_good": 5.0752
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.413,
+      "good": 0.3706,
+      "ratio": 0.8973,
+      "suggested_scalar": -0.1209,
+      "log_bad": -0.8843,
+      "log_good": -0.9926
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0942,
+      "good": 5.5105,
+      "ratio": 0.9042,
+      "suggested_scalar": -0.1124,
+      "log_bad": 1.8073,
+      "log_good": 1.7067
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2754,
+      "good": 0.3115,
+      "ratio": 1.1311,
+      "suggested_scalar": 0.1375,
+      "log_bad": -1.2895,
+      "log_good": -1.1664
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.7798,
+      "good": 4.0769,
+      "ratio": 1.0786,
+      "suggested_scalar": 0.0845,
+      "log_bad": 1.3297,
+      "log_good": 1.4053
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.4526,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 428.0,
+      "good": 388.0,
+      "ratio": 0.9065,
+      "suggested_scalar": -0.1095,
+      "log_bad": 6.0591,
+      "log_good": 5.961
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 83.0,
+      "good": 66.0,
+      "ratio": 0.7952,
+      "suggested_scalar": -0.2558,
+      "log_bad": 4.4188,
+      "log_good": 4.1897
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4475.7636,
+      "good": 3367.9715,
+      "ratio": 0.7525,
+      "suggested_scalar": -0.3174,
+      "log_bad": 8.4064,
+      "log_good": 8.1221
+    },
+    "readability.mean_total_lines": {
+      "bad": 50.0,
+      "good": 42.0,
+      "ratio": 0.84,
+      "suggested_scalar": -0.1946,
+      "log_bad": 3.912,
+      "log_good": 3.7377
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 2105.4628,
+      "good": 1783.6266,
+      "ratio": 0.8471,
+      "suggested_scalar": -0.1852,
+      "log_bad": 7.6523,
+      "log_good": 7.4864
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 667.0,
+      "good": 591.0,
+      "ratio": 0.8861,
+      "suggested_scalar": -0.135,
+      "log_bad": 6.5028,
+      "log_good": 6.3818
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.82,
+      "good": 36.4524,
+      "ratio": 1.0177,
+      "suggested_scalar": 0.0195,
+      "log_bad": 3.5785,
+      "log_good": 3.596
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0304,
+      "good": 1.0326,
+      "ratio": 1.0021,
+      "suggested_scalar": 0.0024,
+      "log_bad": 0.0299,
+      "log_good": 0.0321
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7004,
+      "good": 0.7481,
+      "ratio": 1.0681,
+      "suggested_scalar": 0.0735,
+      "log_bad": -0.3561,
+      "log_good": -0.2902
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 13.0,
+      "good": 17.0,
+      "ratio": 1.3077,
+      "suggested_scalar": 0.2994,
+      "log_bad": 2.5649,
+      "log_good": 2.8332
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9366,
+      "good": 0.9389,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0027,
+      "log_bad": -0.0655,
+      "log_good": -0.063
+    },
+    "halstead.mean_length": {
+      "bad": 334.0,
+      "good": 293.0,
+      "ratio": 0.8772,
+      "suggested_scalar": -0.1462,
+      "log_bad": 5.8111,
+      "log_good": 5.6802
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.2857,
+      "good": 6.1429,
+      "ratio": 0.8431,
+      "suggested_scalar": -0.1904,
+      "log_bad": 1.9859,
+      "log_good": 1.8153
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5999,
+      "good": 6.4757,
+      "ratio": 0.9812,
+      "suggested_scalar": -0.0212,
+      "log_bad": 1.8871,
+      "log_good": 1.8681
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.4526,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1065,
+      "good": 0.1087,
+      "ratio": 1.0207,
+      "suggested_scalar": 0.0228,
+      "log_bad": -2.2396,
+      "log_good": -2.2192
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 38.2642,
+      "good": 33.9889,
+      "ratio": 0.8883,
+      "suggested_scalar": -0.1323,
+      "log_bad": 3.6445,
+      "log_good": 3.526
+    },
+    "branching.mean_branch_count": {
+      "bad": 16.0,
+      "good": 11.0,
+      "ratio": 0.6875,
+      "suggested_scalar": -0.4182,
+      "log_bad": 2.7726,
+      "log_good": 2.3979
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 57.0,
+      "good": 53.0,
+      "ratio": 0.9298,
+      "suggested_scalar": -0.0812,
+      "log_bad": 4.0431,
+      "log_good": 3.9703
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6227,
+      "good": 0.6837,
+      "ratio": 1.098,
+      "suggested_scalar": 0.1043,
+      "log_bad": -0.4737,
+      "log_good": -0.3802
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 50.0,
+      "good": 42.0,
+      "ratio": 0.84,
+      "suggested_scalar": -0.1946,
+      "log_bad": 3.912,
+      "log_good": 3.7377
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.async_functions_contain_await": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 18.0,
+      "good": 29.0,
+      "ratio": 1.6111,
+      "suggested_scalar": 0.1467,
+      "log_bad": 2.8904,
+      "log_good": 3.3673
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 14.0,
+      "good": 12.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0474,
+      "log_bad": 2.6391,
+      "log_good": 2.4849
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0184,
+      "good": 0.0216,
+      "ratio": 1.1739,
+      "suggested_scalar": 0.0493,
+      "log_bad": -3.9954,
+      "log_good": -3.8351
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.8,
+      "good": 0.5,
+      "ratio": 0.625,
+      "suggested_scalar": -0.1446,
+      "log_bad": -0.2231,
+      "log_good": -0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.85,
+      "good": 0.7667,
+      "ratio": 0.902,
+      "suggested_scalar": -0.0317,
+      "log_bad": -0.1625,
+      "log_good": -0.2657
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0184,
+      "good": 0.0216,
+      "ratio": 1.1739,
+      "suggested_scalar": 0.0493,
+      "log_bad": -3.9954,
+      "log_good": -3.8351
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8886,
+      "good": 4.8473,
+      "ratio": 0.9916,
+      "suggested_scalar": -0.0026,
+      "log_bad": 1.5869,
+      "log_good": 1.5784
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 100.0,
+      "good": 96.0,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0126,
+      "log_bad": 4.6052,
+      "log_good": 4.5643
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5459,
+      "good": 0.4243,
+      "ratio": 0.7772,
+      "suggested_scalar": -0.0775,
+      "log_bad": -0.6053,
+      "log_good": -0.8573
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 21.0,
+      "ratio": 1.1053,
+      "suggested_scalar": 0.0308,
+      "log_bad": 2.9444,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6769,
+      "good": 0.6384,
+      "ratio": 0.9431,
+      "suggested_scalar": -0.018,
+      "log_bad": -0.3902,
+      "log_good": -0.4488
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.8333,
+      "good": 2.1333,
+      "ratio": 1.1636,
+      "suggested_scalar": 0.0466,
+      "log_bad": 0.6061,
+      "log_good": 0.7577
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 434.0,
+      "good": 464.0,
+      "ratio": 1.0691,
+      "suggested_scalar": 0.0206,
+      "log_bad": 6.073,
+      "log_good": 6.1399
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0686,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0016,
+      "good": 0.001,
+      "ratio": 0.625,
+      "suggested_scalar": -0.1446,
+      "log_bad": -6.4378,
+      "log_good": -6.9078
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0667,
+      "good": 1.0,
+      "ratio": 14.9925,
+      "suggested_scalar": 0.8328,
+      "log_bad": -2.7076,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 0.0015,
+      "ratio": 0.0015,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.5023
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.996,
+      "good": 0.9852,
+      "ratio": 0.9892,
+      "suggested_scalar": -0.0034,
+      "log_bad": -0.004,
+      "log_good": -0.0149
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 133.0,
+      "good": 134.0,
+      "ratio": 1.0075,
+      "suggested_scalar": 0.0023,
+      "log_bad": 4.8903,
+      "log_good": 4.8978
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 96.4272,
+      "good": 92.1675,
+      "ratio": 0.9558,
+      "suggested_scalar": -0.0139,
+      "log_bad": 4.5688,
+      "log_good": 4.5236
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5843,
+      "good": 0.6177,
+      "ratio": 1.0572,
+      "suggested_scalar": 0.0171,
+      "log_bad": -0.5373,
+      "log_good": -0.4818
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 18.5522,
+      "good": 16.8476,
+      "ratio": 0.9081,
+      "suggested_scalar": -0.0296,
+      "log_bad": 2.9206,
+      "log_good": 2.8242
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1924.0,
+      "good": 2006.0,
+      "ratio": 1.0426,
+      "suggested_scalar": 0.0128,
+      "log_bad": 7.5622,
+      "log_good": 7.6039
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1333,
+      "good": 0.1667,
+      "ratio": 1.2506,
+      "suggested_scalar": 0.0688,
+      "log_bad": -2.0152,
+      "log_good": -1.7916
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8167,
+      "good": 0.7333,
+      "ratio": 0.8979,
+      "suggested_scalar": -0.0331,
+      "log_bad": -0.2025,
+      "log_good": -0.3102
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.2333,
+      "good": 7.7333,
+      "ratio": 1.0691,
+      "suggested_scalar": 0.0206,
+      "log_bad": 1.9787,
+      "log_good": 2.0455
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.7056,
+      "good": 2.9156,
+      "ratio": 1.0776,
+      "suggested_scalar": 0.023,
+      "log_bad": 0.9953,
+      "log_good": 1.0701
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 87.0,
+      "good": 70.0,
+      "ratio": 0.8046,
+      "suggested_scalar": -0.0669,
+      "log_bad": 4.4659,
+      "log_good": 4.2485
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9297,
+      "good": 0.9291,
+      "ratio": 0.9994,
+      "suggested_scalar": -0.0002,
+      "log_bad": -0.0729,
+      "log_good": -0.0735
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 33.0,
+      "ratio": 1.1786,
+      "suggested_scalar": 0.0505,
+      "log_bad": 3.3322,
+      "log_good": 3.4965
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6331,
+      "good": 0.6351,
+      "ratio": 1.0032,
+      "suggested_scalar": 0.001,
+      "log_bad": -0.4571,
+      "log_good": -0.454
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3727,
+      "good": 0.4329,
+      "ratio": 1.1615,
+      "suggested_scalar": 0.0461,
+      "log_bad": -0.987,
+      "log_good": -0.8372
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7252,
+      "good": 2.7404,
+      "ratio": 1.0056,
+      "suggested_scalar": 0.0017,
+      "log_bad": 1.0025,
+      "log_good": 1.0081
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 432.0,
+      "good": 462.0,
+      "ratio": 1.0694,
+      "suggested_scalar": 0.0207,
+      "log_bad": 6.0684,
+      "log_good": 6.1356
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 15.0,
+      "good": 20.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0885,
+      "log_bad": 2.7081,
+      "log_good": 2.9957
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0438,
+      "good": 0.0366,
+      "ratio": 0.8356,
+      "suggested_scalar": -0.0552,
+      "log_bad": -3.1281,
+      "log_good": -3.3077
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9773,
+      "good": 6.0444,
+      "ratio": 1.0112,
+      "suggested_scalar": 0.0034,
+      "log_bad": 1.788,
+      "log_good": 1.7991
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 28.0,
+      "good": 35.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0686,
+      "log_bad": 3.3322,
+      "log_good": 3.5553
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2643,
+      "good": 1.4731,
+      "ratio": 1.1652,
+      "suggested_scalar": 0.047,
+      "log_bad": 0.2345,
+      "log_good": 0.3874
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8593,
+      "good": 5.8237,
+      "ratio": 0.9939,
+      "suggested_scalar": -0.0019,
+      "log_bad": 1.768,
+      "log_good": 1.7619
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8179,
+      "good": 0.8019,
+      "ratio": 0.9804,
+      "suggested_scalar": -0.0061,
+      "log_bad": -0.201,
+      "log_good": -0.2208
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1304,
+      "good": 0.2,
+      "ratio": 1.5337,
+      "suggested_scalar": 0.1316,
+      "log_bad": -2.0371,
+      "log_good": -1.6094
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.3072,
+      "good": 4.1046,
+      "ratio": 0.953,
+      "suggested_scalar": -0.0148,
+      "log_bad": 1.4603,
+      "log_good": 1.4121
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.3379,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 335.0,
+      "good": 342.0,
+      "ratio": 1.0209,
+      "suggested_scalar": 0.0064,
+      "log_bad": 5.8141,
+      "log_good": 5.8348
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 19.0,
+      "good": 22.0,
+      "ratio": 1.1579,
+      "suggested_scalar": 0.0451,
+      "log_bad": 2.9444,
+      "log_good": 3.091
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.877,
+      "good": 0.9241,
+      "ratio": 1.0537,
+      "suggested_scalar": 0.0161,
+      "log_bad": -0.1312,
+      "log_good": -0.0789
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 102.0,
+      "good": 99.0,
+      "ratio": 0.9706,
+      "suggested_scalar": -0.0092,
+      "log_bad": 4.625,
+      "log_good": 4.5951
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1020.0,
+      "good": 1054.0,
+      "ratio": 1.0333,
+      "suggested_scalar": 0.0101,
+      "log_bad": 6.9276,
+      "log_good": 6.9603
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 151.0,
+      "good": 155.0,
+      "ratio": 1.0265,
+      "suggested_scalar": 0.008,
+      "log_bad": 5.0173,
+      "log_good": 5.0434
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0046,
+      "good": 0.0022,
+      "ratio": 0.4783,
+      "suggested_scalar": -0.2269,
+      "log_bad": -5.3817,
+      "log_good": -6.1193
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2535,
+      "good": 0.2371,
+      "ratio": 0.9353,
+      "suggested_scalar": -0.0206,
+      "log_bad": -1.3724,
+      "log_good": -1.4393
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 86.0,
+      "good": 97.0,
+      "ratio": 1.1279,
+      "suggested_scalar": 0.037,
+      "log_bad": 4.4543,
+      "log_good": 4.5747
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0686,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 102.0,
+      "good": 99.0,
+      "ratio": 0.9706,
+      "suggested_scalar": -0.0092,
+      "log_bad": 4.625,
+      "log_good": 4.5951
+    },
+    "brevity.mean_sample_size": {
+      "bad": 102.0,
+      "good": 99.0,
+      "ratio": 0.9706,
+      "suggested_scalar": -0.0092,
+      "log_bad": 4.625,
+      "log_good": 4.5951
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 434.0,
+      "good": 464.0,
+      "ratio": 1.0691,
+      "suggested_scalar": 0.0206,
+      "log_bad": 6.073,
+      "log_good": 6.1399
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 235.0,
+      "good": 260.0,
+      "ratio": 1.1064,
+      "suggested_scalar": 0.0311,
+      "log_bad": 5.4596,
+      "log_good": 5.5607
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 266.0,
+      "good": 274.0,
+      "ratio": 1.0301,
+      "suggested_scalar": 0.0091,
+      "log_bad": 5.5835,
+      "log_good": 5.6131
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0065,
+      "ratio": 0.0065,
+      "suggested_scalar": -1.549,
+      "log_bad": 0.0,
+      "log_good": -5.036
+    },
+    "heaps.mean_k": {
+      "bad": 1.7651,
+      "good": 2.1056,
+      "ratio": 1.1929,
+      "suggested_scalar": 0.0543,
+      "log_bad": 0.5682,
+      "log_good": 0.7446
+    },
+    "halstead.mean_effort": {
+      "bad": 77248.1159,
+      "good": 112540.9288,
+      "ratio": 1.4569,
+      "suggested_scalar": 0.1157,
+      "log_bad": 11.2548,
+      "log_good": 11.6311
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8781,
+      "good": 0.8785,
+      "ratio": 1.0005,
+      "suggested_scalar": 0.0001,
+      "log_bad": -0.13,
+      "log_good": -0.1295
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 72.0,
+      "good": 63.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0411,
+      "log_bad": 4.2767,
+      "log_good": 4.1431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 245.0,
+      "good": 266.0,
+      "ratio": 1.0857,
+      "suggested_scalar": 0.0253,
+      "log_bad": 5.5013,
+      "log_good": 5.5835
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4511,
+      "good": 0.3806,
+      "ratio": 0.8437,
+      "suggested_scalar": -0.0523,
+      "log_bad": -0.7961,
+      "log_good": -0.966
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.6692,
+      "good": 7.8657,
+      "ratio": 1.0256,
+      "suggested_scalar": 0.0078,
+      "log_bad": 2.0372,
+      "log_good": 2.0625
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1304,
+      "good": 0.2,
+      "ratio": 1.5337,
+      "suggested_scalar": 0.1316,
+      "log_bad": -2.0371,
+      "log_good": -1.6094
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.3299,
+      "good": 4.3055,
+      "ratio": 0.8078,
+      "suggested_scalar": -0.0657,
+      "log_bad": 1.6733,
+      "log_good": 1.4599
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 433.0,
+      "good": 463.0,
+      "ratio": 1.0693,
+      "suggested_scalar": 0.0206,
+      "log_bad": 6.0707,
+      "log_good": 6.1377
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 64.0,
+      "good": 80.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0686,
+      "log_bad": 4.1589,
+      "log_good": 4.382
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4291.562,
+      "good": 6252.2738,
+      "ratio": 1.4569,
+      "suggested_scalar": 0.1157,
+      "log_bad": 8.3644,
+      "log_good": 8.7407
+    },
+    "readability.mean_total_lines": {
+      "bad": 60.0,
+      "good": 60.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0943,
+      "log_good": 4.0943
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2630.9671,
+      "good": 2772.2692,
+      "ratio": 1.0537,
+      "suggested_scalar": 0.0161,
+      "log_bad": 7.8751,
+      "log_good": 7.9274
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 706.0,
+      "good": 732.0,
+      "ratio": 1.0368,
+      "suggested_scalar": 0.0111,
+      "log_bad": 6.5596,
+      "log_good": 6.5958
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.8167,
+      "good": 32.1833,
+      "ratio": 1.0443,
+      "suggested_scalar": 0.0133,
+      "log_bad": 3.4281,
+      "log_good": 3.4714
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2183,
+      "good": 1.2626,
+      "ratio": 1.0364,
+      "suggested_scalar": 0.011,
+      "log_bad": 0.1975,
+      "log_good": 0.2332
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0686,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 12.0,
+      "good": 9.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0885,
+      "log_bad": 2.4849,
+      "log_good": 2.1972
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 1.0,
+      "ratio": 0.25,
+      "suggested_scalar": -0.4264,
+      "log_bad": 1.3863,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.809,
+      "good": 0.7661,
+      "ratio": 0.947,
+      "suggested_scalar": -0.0168,
+      "log_bad": -0.212,
+      "log_good": -0.2664
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9923,
+      "good": 0.9675,
+      "ratio": 0.975,
+      "suggested_scalar": -0.0078,
+      "log_bad": -0.0077,
+      "log_good": -0.033
+    },
+    "halstead.mean_length": {
+      "bad": 396.0,
+      "good": 421.0,
+      "ratio": 1.0631,
+      "suggested_scalar": 0.0188,
+      "log_bad": 5.9814,
+      "log_good": 6.0426
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.8,
+      "good": 15.25,
+      "ratio": 1.412,
+      "suggested_scalar": 0.1061,
+      "log_bad": 2.3795,
+      "log_good": 2.7246
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6724,
+      "good": 6.6294,
+      "ratio": 0.9936,
+      "suggested_scalar": -0.002,
+      "log_bad": 1.898,
+      "log_good": 1.8915
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1225,
+      "good": 0.1296,
+      "ratio": 1.058,
+      "suggested_scalar": 0.0173,
+      "log_bad": -2.0996,
+      "log_good": -2.0433
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.3611,
+      "good": 40.5952,
+      "ratio": 1.3826,
+      "suggested_scalar": 0.0997,
+      "log_bad": 3.3797,
+      "log_good": 3.7036
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 10.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0686,
+      "log_bad": 2.0794,
+      "log_good": 2.3026
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 60.0,
+      "good": 51.0,
+      "ratio": 0.85,
+      "suggested_scalar": -0.05,
+      "log_bad": 4.0943,
+      "log_good": 3.9318
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6767,
+      "good": 0.646,
+      "ratio": 0.9546,
+      "suggested_scalar": -0.0143,
+      "log_bad": -0.3905,
+      "log_good": -0.437
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 60.0,
+      "good": 60.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0943,
+      "log_good": 4.0943
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 23.0,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.028,
+      "log_bad": 3.0445,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "variable_naming.name_is_too_long": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 81.0,
+      "good": 64.0,
+      "ratio": 0.7901,
+      "suggested_scalar": -0.1082,
+      "log_bad": 4.3944,
+      "log_good": 4.1589
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 31.0,
+      "good": 38.6667,
+      "ratio": 1.2473,
+      "suggested_scalar": 0.1015,
+      "log_bad": 3.434,
+      "log_good": 3.655
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.004,
+      "good": 0.0032,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1025,
+      "log_bad": -5.5215,
+      "log_good": -5.7446
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1414,
+      "good": 1.0769,
+      "ratio": 0.9435,
+      "suggested_scalar": -0.0267,
+      "log_bad": 0.1323,
+      "log_good": 0.0741
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8649,
+      "good": 0.8364,
+      "ratio": 0.967,
+      "suggested_scalar": -0.0154,
+      "log_bad": -0.1451,
+      "log_good": -0.1786
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0098,
+      "good": 0.0083,
+      "ratio": 0.8469,
+      "suggested_scalar": -0.0763,
+      "log_bad": -4.6254,
+      "log_good": -4.7915
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7042,
+      "good": 4.715,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0011,
+      "log_bad": 1.5485,
+      "log_good": 1.5507
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 94.0,
+      "good": 89.6667,
+      "ratio": 0.9539,
+      "suggested_scalar": -0.0217,
+      "log_bad": 4.5433,
+      "log_good": 4.4961
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4998,
+      "good": 0.4158,
+      "ratio": 0.8319,
+      "suggested_scalar": -0.0845,
+      "log_bad": -0.6935,
+      "log_good": -0.8776
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.3333,
+      "good": 18.0,
+      "ratio": 1.102,
+      "suggested_scalar": 0.0446,
+      "log_bad": 2.7932,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5892,
+      "good": 0.5307,
+      "ratio": 0.9007,
+      "suggested_scalar": -0.048,
+      "log_bad": -0.529,
+      "log_good": -0.6336
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.2652,
+      "good": 2.431,
+      "ratio": 0.7445,
+      "suggested_scalar": -0.1355,
+      "log_bad": 1.1833,
+      "log_good": 0.8883
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 404.3333,
+      "good": 476.6667,
+      "ratio": 1.1789,
+      "suggested_scalar": 0.0756,
+      "log_bad": 6.0022,
+      "log_good": 6.1668
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.3333,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0484,
+      "log_bad": 1.0986,
+      "log_good": 1.204
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0001,
+      "good": 0.0002,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3183,
+      "log_bad": -9.2103,
+      "log_good": -8.5172
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0213,
+      "good": 0.0284,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1321,
+      "log_bad": -3.849,
+      "log_good": -3.5614
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0002,
+      "good": 0.0003,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1862,
+      "log_bad": -8.5172,
+      "log_good": -8.1117
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9393,
+      "good": 1.0599,
+      "ratio": 1.1284,
+      "suggested_scalar": 0.0555,
+      "log_bad": -0.0626,
+      "log_good": 0.0582
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 137.6667,
+      "good": 161.0,
+      "ratio": 1.1695,
+      "suggested_scalar": 0.0719,
+      "log_bad": 4.9248,
+      "log_good": 5.0814
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 77.8706,
+      "ratio": 77.8706,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 4.355
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5321,
+      "good": 0.637,
+      "ratio": 1.1971,
+      "suggested_scalar": 0.0826,
+      "log_bad": -0.6309,
+      "log_good": -0.451
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 309.5298,
+      "good": 24.0116,
+      "ratio": 0.0776,
+      "suggested_scalar": -1.174,
+      "log_bad": 5.7351,
+      "log_good": 3.1785
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 3556.6667,
+      "good": 2186.3333,
+      "ratio": 0.6147,
+      "suggested_scalar": -0.2235,
+      "log_bad": 8.1766,
+      "log_good": 7.69
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0707,
+      "good": 0.0863,
+      "ratio": 1.2207,
+      "suggested_scalar": 0.0916,
+      "log_bad": -2.6493,
+      "log_good": -2.4499
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8378,
+      "good": 0.8118,
+      "ratio": 0.969,
+      "suggested_scalar": -0.0145,
+      "log_bad": -0.177,
+      "log_good": -0.2085
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.6278,
+      "good": 9.049,
+      "ratio": 1.3653,
+      "suggested_scalar": 0.143,
+      "log_bad": 1.8913,
+      "log_good": 2.2027
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 4.5,
+      "good": 5.5,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.0922,
+      "log_bad": 1.5041,
+      "log_good": 1.7047
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.5762,
+      "good": 1.8619,
+      "ratio": 0.5206,
+      "suggested_scalar": -0.2997,
+      "log_bad": 1.2743,
+      "log_good": 0.6216
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 90.3333,
+      "good": 117.3333,
+      "ratio": 1.2989,
+      "suggested_scalar": 0.1201,
+      "log_bad": 4.5035,
+      "log_good": 4.765
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9522,
+      "good": 0.9496,
+      "ratio": 0.9973,
+      "suggested_scalar": -0.0013,
+      "log_bad": -0.049,
+      "log_good": -0.0517
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.6667,
+      "good": 25.0,
+      "ratio": 1.0135,
+      "suggested_scalar": 0.0062,
+      "log_bad": 3.2055,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.7081,
+      "good": 0.6635,
+      "ratio": 0.937,
+      "suggested_scalar": -0.0299,
+      "log_bad": -0.3452,
+      "log_good": -0.4102
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3359,
+      "good": 0.4395,
+      "ratio": 1.3084,
+      "suggested_scalar": 0.1235,
+      "log_bad": -1.0909,
+      "log_good": -0.8221
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.4278,
+      "good": 2.9799,
+      "ratio": 0.8693,
+      "suggested_scalar": -0.0643,
+      "log_bad": 1.2319,
+      "log_good": 1.0919
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 402.3333,
+      "good": 474.6667,
+      "ratio": 1.1798,
+      "suggested_scalar": 0.0759,
+      "log_bad": 5.9973,
+      "log_good": 6.1626
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 20.0,
+      "good": 13.3333,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1862,
+      "log_bad": 2.9957,
+      "log_good": 2.5903
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0348,
+      "good": 0.0292,
+      "ratio": 0.8391,
+      "suggested_scalar": -0.0806,
+      "log_bad": -3.3581,
+      "log_good": -3.5336
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9862,
+      "good": 5.9747,
+      "ratio": 0.9981,
+      "suggested_scalar": -0.0009,
+      "log_bad": 1.7895,
+      "log_good": 1.7875
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 17.3333,
+      "good": 18.6667,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.034,
+      "log_bad": 2.8526,
+      "log_good": 2.9267
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9087,
+      "good": 0.931,
+      "ratio": 1.0245,
+      "suggested_scalar": 0.0111,
+      "log_bad": -0.0957,
+      "log_good": -0.0715
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7126,
+      "good": 5.5761,
+      "ratio": 0.9761,
+      "suggested_scalar": -0.0111,
+      "log_bad": 1.7427,
+      "log_good": 1.7185
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7855,
+      "good": 0.7891,
+      "ratio": 1.0046,
+      "suggested_scalar": 0.0021,
+      "log_bad": -0.2414,
+      "log_good": -0.2369
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2046,
+      "good": 0.214,
+      "ratio": 1.0459,
+      "suggested_scalar": 0.0206,
+      "log_bad": -1.5867,
+      "log_good": -1.5418
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 17.5408,
+      "good": 4.8969,
+      "ratio": 0.2792,
+      "suggested_scalar": -0.586,
+      "log_bad": 2.8645,
+      "log_good": 1.5886
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.6667,
+      "good": 2.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9808,
+      "log_good": 0.9808
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 306.3333,
+      "good": 330.6667,
+      "ratio": 1.0794,
+      "suggested_scalar": 0.0351,
+      "log_bad": 5.7247,
+      "log_good": 5.8011
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 11.3333,
+      "good": 12.6667,
+      "ratio": 1.1177,
+      "suggested_scalar": 0.0511,
+      "log_bad": 2.4277,
+      "log_good": 2.539
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8374,
+      "good": 0.9825,
+      "ratio": 1.1733,
+      "suggested_scalar": 0.0734,
+      "log_bad": -0.1775,
+      "log_good": -0.0177
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 102.6667,
+      "good": 99.0,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.0167,
+      "log_bad": 4.6315,
+      "log_good": 4.5951
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 2712.3333,
+      "good": 1316.3333,
+      "ratio": 0.4853,
+      "suggested_scalar": -0.332,
+      "log_bad": 7.9056,
+      "log_good": 7.1826
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 144.3333,
+      "good": 168.3333,
+      "ratio": 1.1663,
+      "suggested_scalar": 0.0706,
+      "log_bad": 4.9721,
+      "log_good": 5.1259
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0015,
+      "good": 0.002,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1321,
+      "log_bad": -6.5023,
+      "log_good": -6.2146
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2645,
+      "good": 0.2732,
+      "ratio": 1.0329,
+      "suggested_scalar": 0.0149,
+      "log_bad": -1.3299,
+      "log_good": -1.2976
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 65.6667,
+      "good": 91.6667,
+      "ratio": 1.3959,
+      "suggested_scalar": 0.1532,
+      "log_bad": 4.1846,
+      "log_good": 4.5182
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 10.3333,
+      "good": 13.0,
+      "ratio": 1.2581,
+      "suggested_scalar": 0.1054,
+      "log_bad": 2.3354,
+      "log_good": 2.5649
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 102.6667,
+      "good": 99.0,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.0167,
+      "log_bad": 4.6315,
+      "log_good": 4.5951
+    },
+    "brevity.mean_sample_size": {
+      "bad": 102.6667,
+      "good": 99.0,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.0167,
+      "log_bad": 4.6315,
+      "log_good": 4.5951
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 404.3333,
+      "good": 476.6667,
+      "ratio": 1.1789,
+      "suggested_scalar": 0.0756,
+      "log_bad": 6.0022,
+      "log_good": 6.1668
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 210.0,
+      "good": 251.6667,
+      "ratio": 1.1984,
+      "suggested_scalar": 0.0831,
+      "log_bad": 5.3471,
+      "log_good": 5.5281
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 247.0,
+      "good": 254.6667,
+      "ratio": 1.031,
+      "suggested_scalar": 0.014,
+      "log_bad": 5.5094,
+      "log_good": 5.54
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.007,
+      "good": 0.006,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0708,
+      "log_bad": -4.9618,
+      "log_good": -5.116
+    },
+    "heaps.mean_k": {
+      "bad": 3.2329,
+      "good": 4.0233,
+      "ratio": 1.2445,
+      "suggested_scalar": 0.1004,
+      "log_bad": 1.1734,
+      "log_good": 1.3921
+    },
+    "halstead.mean_effort": {
+      "bad": 66543.6623,
+      "good": 101969.231,
+      "ratio": 1.5324,
+      "suggested_scalar": 0.196,
+      "log_bad": 11.1056,
+      "log_good": 11.5324
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8556,
+      "good": 0.8423,
+      "ratio": 0.9845,
+      "suggested_scalar": -0.0072,
+      "log_bad": -0.156,
+      "log_good": -0.1716
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 69.3333,
+      "good": 64.6667,
+      "ratio": 0.9327,
+      "suggested_scalar": -0.032,
+      "log_bad": 4.2389,
+      "log_good": 4.1692
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 238.6667,
+      "good": 285.0,
+      "ratio": 1.1941,
+      "suggested_scalar": 0.0815,
+      "log_bad": 5.4751,
+      "log_good": 5.6525
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4888,
+      "good": 0.3882,
+      "ratio": 0.7942,
+      "suggested_scalar": -0.1058,
+      "log_bad": -0.7158,
+      "log_good": -0.9462
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 20.0863,
+      "good": 8.2708,
+      "ratio": 0.4118,
+      "suggested_scalar": -0.4075,
+      "log_bad": 3.0,
+      "log_good": 2.1127
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2046,
+      "good": 0.214,
+      "ratio": 1.0459,
+      "suggested_scalar": 0.0206,
+      "log_bad": -1.5867,
+      "log_good": -1.5418
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 14.7647,
+      "good": 6.2215,
+      "ratio": 0.4214,
+      "suggested_scalar": -0.3969,
+      "log_bad": 2.6922,
+      "log_good": 1.828
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 403.3333,
+      "good": 475.6667,
+      "ratio": 1.1793,
+      "suggested_scalar": 0.0758,
+      "log_bad": 5.9998,
+      "log_good": 6.1647
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 2.3333,
+      "ratio": 1.1666,
+      "suggested_scalar": 0.0708,
+      "log_bad": 0.6931,
+      "log_good": 0.8473
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 47.3333,
+      "good": 75.6667,
+      "ratio": 1.5986,
+      "suggested_scalar": 0.2154,
+      "log_bad": 3.8572,
+      "log_good": 4.3263
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3696.8701,
+      "good": 5664.9573,
+      "ratio": 1.5324,
+      "suggested_scalar": 0.196,
+      "log_bad": 8.2152,
+      "log_good": 8.6421
+    },
+    "readability.mean_total_lines": {
+      "bad": 61.0,
+      "good": 52.0,
+      "ratio": 0.8525,
+      "suggested_scalar": -0.0733,
+      "log_bad": 4.1109,
+      "log_good": 3.9512
+    },
+    "indentation.mean_max_depth": {
+      "bad": 7.6667,
+      "good": 4.6667,
+      "ratio": 0.6087,
+      "suggested_scalar": -0.228,
+      "log_bad": 2.0369,
+      "log_good": 1.5405
+    },
+    "halstead.mean_volume": {
+      "bad": 2512.138,
+      "good": 2947.6091,
+      "ratio": 1.1733,
+      "suggested_scalar": 0.0734,
+      "log_bad": 7.8289,
+      "log_good": 7.9887
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1038.3333,
+      "good": 730.0,
+      "ratio": 0.703,
+      "suggested_scalar": -0.1618,
+      "log_bad": 6.9454,
+      "log_good": 6.593
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 56.2013,
+      "good": 39.7625,
+      "ratio": 0.7075,
+      "suggested_scalar": -0.1589,
+      "log_bad": 4.0289,
+      "log_good": 3.6829
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 2.9633,
+      "good": 1.4158,
+      "ratio": 0.4778,
+      "suggested_scalar": -0.3392,
+      "log_bad": 1.0863,
+      "log_good": 0.3477
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.3333,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0484,
+      "log_bad": 1.0986,
+      "log_good": 1.204
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 18.6667,
+      "good": 21.3333,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.0613,
+      "log_bad": 2.9267,
+      "log_good": 3.0603
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8501,
+      "good": 0.7771,
+      "ratio": 0.9141,
+      "suggested_scalar": -0.0412,
+      "log_bad": -0.1624,
+      "log_good": -0.2522
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9651,
+      "good": 0.9454,
+      "ratio": 0.9796,
+      "suggested_scalar": -0.0095,
+      "log_bad": -0.0355,
+      "log_good": -0.0561
+    },
+    "halstead.mean_length": {
+      "bad": 383.0,
+      "good": 453.3333,
+      "ratio": 1.1836,
+      "suggested_scalar": 0.0774,
+      "log_bad": 5.948,
+      "log_good": 6.1166
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.0741,
+      "good": 4.7692,
+      "ratio": 0.6742,
+      "suggested_scalar": -0.1811,
+      "log_bad": 1.9564,
+      "log_good": 1.5622
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6794,
+      "good": 6.624,
+      "ratio": 0.9917,
+      "suggested_scalar": -0.0038,
+      "log_bad": 1.899,
+      "log_good": 1.8907
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0588,
+      "good": 0.1123,
+      "ratio": 1.9099,
+      "suggested_scalar": 0.2971,
+      "log_bad": -2.8336,
+      "log_good": -2.1866
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.7798,
+      "good": 32.7829,
+      "ratio": 1.2717,
+      "suggested_scalar": 0.1104,
+      "log_bad": 3.2496,
+      "log_good": 3.4899
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.3333,
+      "good": 4.6667,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.034,
+      "log_bad": 1.4663,
+      "log_good": 1.5405
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 66.6667,
+      "good": 61.3333,
+      "ratio": 0.92,
+      "suggested_scalar": -0.0383,
+      "log_bad": 4.1997,
+      "log_good": 4.1163
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7379,
+      "good": 0.6457,
+      "ratio": 0.8751,
+      "suggested_scalar": -0.0613,
+      "log_bad": -0.3039,
+      "log_good": -0.4374
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 61.6667,
+      "good": 52.6667,
+      "ratio": 0.8541,
+      "suggested_scalar": -0.0724,
+      "log_bad": 4.1217,
+      "log_good": 3.964
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 61.6667,
+      "good": 22.3333,
+      "ratio": 0.3622,
+      "suggested_scalar": -0.4664,
+      "log_bad": 4.1217,
+      "log_good": 3.1061
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_primitive_obsession": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 26.0,
+      "good": 28.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0242,
+      "log_bad": 3.2581,
+      "log_good": 3.3322
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 4.0,
+      "good": 2.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2265,
+      "log_bad": 1.3863,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0089,
+      "good": 0.0279,
+      "ratio": 3.1348,
+      "suggested_scalar": 0.3734,
+      "log_bad": -4.7217,
+      "log_good": -3.5791
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.3333,
+      "good": 1.625,
+      "ratio": 0.6964,
+      "suggested_scalar": -0.1182,
+      "log_bad": 0.8473,
+      "log_good": 0.4855
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9048,
+      "good": 0.8235,
+      "ratio": 0.9101,
+      "suggested_scalar": -0.0308,
+      "log_bad": -0.1,
+      "log_good": -0.1942
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0089,
+      "good": 0.0279,
+      "ratio": 3.1348,
+      "suggested_scalar": 0.3734,
+      "log_bad": -4.7217,
+      "log_good": -3.5791
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7345,
+      "good": 4.8027,
+      "ratio": 1.0144,
+      "suggested_scalar": 0.0047,
+      "log_bad": 1.5549,
+      "log_good": 1.5692
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 131.0,
+      "good": 80.0,
+      "ratio": 0.6107,
+      "suggested_scalar": -0.1612,
+      "log_bad": 4.8752,
+      "log_good": 4.382
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5544,
+      "good": 0.4729,
+      "ratio": 0.853,
+      "suggested_scalar": -0.052,
+      "log_bad": -0.5899,
+      "log_good": -0.7489
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 23.0,
+      "good": 21.0,
+      "ratio": 0.913,
+      "suggested_scalar": -0.0297,
+      "log_bad": 3.1355,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6847,
+      "good": 0.5813,
+      "ratio": 0.849,
+      "suggested_scalar": -0.0535,
+      "log_bad": -0.3788,
+      "log_good": -0.5425
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.5238,
+      "good": 3.3333,
+      "ratio": 1.3207,
+      "suggested_scalar": 0.0909,
+      "log_bad": 0.9258,
+      "log_good": 1.204
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 449.0,
+      "good": 502.0,
+      "ratio": 1.118,
+      "suggested_scalar": 0.0365,
+      "log_bad": 6.107,
+      "log_good": 6.2186
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2143,
+      "good": 1.0,
+      "ratio": 4.6664,
+      "suggested_scalar": 0.5034,
+      "log_bad": -1.5404,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0022,
+      "good": 1.0,
+      "ratio": 454.5455,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.1193,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9038,
+      "good": 1.0181,
+      "ratio": 1.1265,
+      "suggested_scalar": 0.0389,
+      "log_bad": -0.1011,
+      "log_good": 0.0179
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 184.0,
+      "good": 179.0,
+      "ratio": 0.9728,
+      "suggested_scalar": -0.009,
+      "log_bad": 5.2149,
+      "log_good": 5.1874
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 95.1468,
+      "good": 105.0442,
+      "ratio": 1.104,
+      "suggested_scalar": 0.0323,
+      "log_bad": 4.5554,
+      "log_good": 4.6544
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4531,
+      "good": 0.6946,
+      "ratio": 1.533,
+      "suggested_scalar": 0.1396,
+      "log_bad": -0.7916,
+      "log_good": -0.3644
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.9509,
+      "good": 10.2741,
+      "ratio": 0.8597,
+      "suggested_scalar": -0.0494,
+      "log_bad": 2.4808,
+      "log_good": 2.3296
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1862.0,
+      "good": 1993.0,
+      "ratio": 1.0704,
+      "suggested_scalar": 0.0222,
+      "log_bad": 7.5294,
+      "log_good": 7.5974
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1667,
+      "good": 0.1176,
+      "ratio": 0.7055,
+      "suggested_scalar": -0.114,
+      "log_bad": -1.7916,
+      "log_good": -2.1405
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.881,
+      "good": 0.7843,
+      "ratio": 0.8902,
+      "suggested_scalar": -0.038,
+      "log_bad": -0.1267,
+      "log_good": -0.243
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 13.6061,
+      "good": 9.8431,
+      "ratio": 0.7234,
+      "suggested_scalar": -0.1058,
+      "log_bad": 2.6105,
+      "log_good": 2.2868
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 11.0,
+      "ratio": 11.0,
+      "suggested_scalar": 0.7837,
+      "log_bad": 0.0,
+      "log_good": 2.3979
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.5351,
+      "good": 2.3007,
+      "ratio": 1.4987,
+      "suggested_scalar": 0.1322,
+      "log_bad": 0.4286,
+      "log_good": 0.8332
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 164.0,
+      "good": 145.0,
+      "ratio": 0.8841,
+      "suggested_scalar": -0.0402,
+      "log_bad": 5.0999,
+      "log_good": 4.9767
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9502,
+      "good": 0.9486,
+      "ratio": 0.9983,
+      "suggested_scalar": -0.0006,
+      "log_bad": -0.0511,
+      "log_good": -0.0528
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 29.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3673,
+      "log_good": 3.3673
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5661,
+      "good": 0.6242,
+      "ratio": 1.1026,
+      "suggested_scalar": 0.0319,
+      "log_bad": -0.569,
+      "log_good": -0.4713
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2595,
+      "good": 0.504,
+      "ratio": 1.9422,
+      "suggested_scalar": 0.217,
+      "log_bad": -1.349,
+      "log_good": -0.6852
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3045,
+      "good": 2.6609,
+      "ratio": 1.1547,
+      "suggested_scalar": 0.047,
+      "log_bad": 0.8349,
+      "log_good": 0.9787
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 447.0,
+      "good": 500.0,
+      "ratio": 1.1186,
+      "suggested_scalar": 0.0366,
+      "log_bad": 6.1026,
+      "log_good": 6.2146
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 10.0,
+      "good": 12.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0596,
+      "log_bad": 2.3026,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0223,
+      "good": 0.0558,
+      "ratio": 2.5022,
+      "suggested_scalar": 0.2998,
+      "log_bad": -3.8032,
+      "log_good": -2.886
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0444,
+      "good": 6.0224,
+      "ratio": 0.9964,
+      "suggested_scalar": -0.0012,
+      "log_bad": 1.7991,
+      "log_good": 1.7955
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 20.0,
+      "good": 23.0,
+      "ratio": 1.15,
+      "suggested_scalar": 0.0457,
+      "log_bad": 2.9957,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.496,
+      "good": 0.8739,
+      "ratio": 1.7619,
+      "suggested_scalar": 0.1851,
+      "log_bad": -0.7012,
+      "log_good": -0.1348
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9961,
+      "good": 5.6839,
+      "ratio": 0.9479,
+      "suggested_scalar": -0.0175,
+      "log_bad": 1.7911,
+      "log_good": 1.7376
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7833,
+      "good": 0.7975,
+      "ratio": 1.0181,
+      "suggested_scalar": 0.0059,
+      "log_bad": -0.2442,
+      "log_good": -0.2263
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.125,
+      "good": 0.1905,
+      "ratio": 1.524,
+      "suggested_scalar": 0.1377,
+      "log_bad": -2.0794,
+      "log_good": -1.6581
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.457,
+      "good": 3.2053,
+      "ratio": 0.9272,
+      "suggested_scalar": -0.0247,
+      "log_bad": 1.2404,
+      "log_good": 1.1648
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 366.0,
+      "good": 340.0,
+      "ratio": 0.929,
+      "suggested_scalar": -0.0241,
+      "log_bad": 5.9026,
+      "log_good": 5.8289
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 13.0,
+      "good": 9.0,
+      "ratio": 0.6923,
+      "suggested_scalar": -0.1202,
+      "log_bad": 2.5649,
+      "log_good": 2.1972
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9542,
+      "good": 0.8661,
+      "ratio": 0.9077,
+      "suggested_scalar": -0.0317,
+      "log_bad": -0.0469,
+      "log_good": -0.1438
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 138.0,
+      "good": 113.0,
+      "ratio": 0.8188,
+      "suggested_scalar": -0.0653,
+      "log_bad": 4.9273,
+      "log_good": 4.7274
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1140.0,
+      "good": 1114.0,
+      "ratio": 0.9772,
+      "suggested_scalar": -0.0075,
+      "log_bad": 7.0388,
+      "log_good": 7.0157
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 192.0,
+      "good": 148.0,
+      "ratio": 0.7708,
+      "suggested_scalar": -0.0851,
+      "log_bad": 5.2575,
+      "log_good": 4.9972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2205,
+      "good": 0.255,
+      "ratio": 1.1565,
+      "suggested_scalar": 0.0475,
+      "log_bad": -1.5119,
+      "log_good": -1.3665
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 57.0,
+      "good": 107.0,
+      "ratio": 1.8772,
+      "suggested_scalar": 0.2058,
+      "log_bad": 4.0431,
+      "log_good": 4.6728
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 8.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.094,
+      "log_bad": 1.7918,
+      "log_good": 2.0794
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 138.0,
+      "good": 113.0,
+      "ratio": 0.8188,
+      "suggested_scalar": -0.0653,
+      "log_bad": 4.9273,
+      "log_good": 4.7274
+    },
+    "brevity.mean_sample_size": {
+      "bad": 138.0,
+      "good": 113.0,
+      "ratio": 0.8188,
+      "suggested_scalar": -0.0653,
+      "log_bad": 4.9273,
+      "log_good": 4.7274
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 449.0,
+      "good": 502.0,
+      "ratio": 1.118,
+      "suggested_scalar": 0.0365,
+      "log_bad": 6.107,
+      "log_good": 6.2186
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 222.0,
+      "good": 261.0,
+      "ratio": 1.1757,
+      "suggested_scalar": 0.0529,
+      "log_bad": 5.4027,
+      "log_good": 5.5645
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 302.0,
+      "good": 260.0,
+      "ratio": 0.8609,
+      "suggested_scalar": -0.0489,
+      "log_bad": 5.7104,
+      "log_good": 5.5607
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0045,
+      "good": 0.004,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0385,
+      "log_bad": -5.4037,
+      "log_good": -5.5215
+    },
+    "heaps.mean_k": {
+      "bad": 2.178,
+      "good": 3.2598,
+      "ratio": 1.4967,
+      "suggested_scalar": 0.1318,
+      "log_bad": 0.7784,
+      "log_good": 1.1817
+    },
+    "halstead.mean_effort": {
+      "bad": 78132.2275,
+      "good": 109332.912,
+      "ratio": 1.3993,
+      "suggested_scalar": 0.1098,
+      "log_bad": 11.2662,
+      "log_good": 11.6022
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8435,
+      "good": 0.8334,
+      "ratio": 0.988,
+      "suggested_scalar": -0.0039,
+      "log_bad": -0.1702,
+      "log_good": -0.1822
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 102.0,
+      "good": 51.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2265,
+      "log_bad": 4.625,
+      "log_good": 3.9318
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 215.0,
+      "good": 263.0,
+      "ratio": 1.2233,
+      "suggested_scalar": 0.0659,
+      "log_bad": 5.3706,
+      "log_good": 5.5722
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5109,
+      "good": 0.4022,
+      "ratio": 0.7872,
+      "suggested_scalar": -0.0782,
+      "log_bad": -0.6716,
+      "log_good": -0.9108
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.1957,
+      "good": 6.2235,
+      "ratio": 1.0045,
+      "suggested_scalar": 0.0015,
+      "log_bad": 1.8239,
+      "log_good": 1.8283
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.125,
+      "good": 0.1905,
+      "ratio": 1.524,
+      "suggested_scalar": 0.1377,
+      "log_bad": -2.0794,
+      "log_good": -1.6581
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.6218,
+      "good": 4.2777,
+      "ratio": 0.7609,
+      "suggested_scalar": -0.0893,
+      "log_bad": 1.7267,
+      "log_good": 1.4534
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 448.0,
+      "good": 501.0,
+      "ratio": 1.1183,
+      "suggested_scalar": 0.0365,
+      "log_bad": 6.1048,
+      "log_good": 6.2166
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.094,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 35.0,
+      "good": 92.0,
+      "ratio": 2.6286,
+      "suggested_scalar": 0.3159,
+      "log_bad": 3.5553,
+      "log_good": 4.5218
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4340.6793,
+      "good": 6074.0507,
+      "ratio": 1.3993,
+      "suggested_scalar": 0.1098,
+      "log_bad": 8.3758,
+      "log_good": 8.7118
+    },
+    "readability.mean_total_lines": {
+      "bad": 33.0,
+      "good": 51.0,
+      "ratio": 1.5455,
+      "suggested_scalar": 0.1423,
+      "log_bad": 3.4965,
+      "log_good": 3.9318
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2862.6032,
+      "good": 2598.3124,
+      "ratio": 0.9077,
+      "suggested_scalar": -0.0317,
+      "log_bad": 7.9595,
+      "log_good": 7.8626
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 808.0,
+      "good": 749.0,
+      "ratio": 0.927,
+      "suggested_scalar": -0.0248,
+      "log_bad": 6.6946,
+      "log_good": 6.6187
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.7273,
+      "good": 37.8039,
+      "ratio": 1.0581,
+      "suggested_scalar": 0.0185,
+      "log_bad": 3.5759,
+      "log_good": 3.6324
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.157,
+      "good": 1.0851,
+      "ratio": 0.9379,
+      "suggested_scalar": -0.021,
+      "log_bad": 0.1458,
+      "log_good": 0.0817
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 13.0,
+      "good": 17.0,
+      "ratio": 1.3077,
+      "suggested_scalar": 0.0877,
+      "log_bad": 2.5649,
+      "log_good": 2.8332
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 9.0,
+      "good": 1.0,
+      "ratio": 0.1111,
+      "suggested_scalar": -0.7181,
+      "log_bad": 2.1972,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9044,
+      "good": 0.7294,
+      "ratio": 0.8065,
+      "suggested_scalar": -0.0703,
+      "log_bad": -0.1005,
+      "log_good": -0.3155
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2265,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9859,
+      "good": 0.9697,
+      "ratio": 0.9836,
+      "suggested_scalar": -0.0054,
+      "log_bad": -0.0142,
+      "log_good": -0.0308
+    },
+    "halstead.mean_length": {
+      "bad": 407.0,
+      "good": 411.0,
+      "ratio": 1.0098,
+      "suggested_scalar": 0.0032,
+      "log_bad": 6.0088,
+      "log_good": 6.0186
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.6667,
+      "good": 6.25,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0211,
+      "log_bad": 1.8971,
+      "log_good": 1.8326
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.1085,
+      "good": 6.8202,
+      "ratio": 0.9594,
+      "suggested_scalar": -0.0135,
+      "log_bad": 1.9613,
+      "log_good": 1.9199
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1199,
+      "good": 0.1311,
+      "ratio": 1.0934,
+      "suggested_scalar": 0.0292,
+      "log_bad": -2.1211,
+      "log_good": -2.0318
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.2941,
+      "good": 42.0784,
+      "ratio": 1.5417,
+      "suggested_scalar": 0.1415,
+      "log_bad": 3.3067,
+      "log_good": 3.7395
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 6.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0504,
+      "log_bad": 1.9459,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 94.0,
+      "good": 72.0,
+      "ratio": 0.766,
+      "suggested_scalar": -0.0871,
+      "log_bad": 4.5433,
+      "log_good": 4.2767
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8113,
+      "good": 0.5885,
+      "ratio": 0.7254,
+      "suggested_scalar": -0.1049,
+      "log_bad": -0.2091,
+      "log_good": -0.5302
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 42.0,
+      "good": 51.0,
+      "ratio": 1.2143,
+      "suggested_scalar": 0.0635,
+      "log_bad": 3.7377,
+      "log_good": 3.9318
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 15.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0211,
+      "log_bad": 2.7726,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.no_empty_rescue_block": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 11.0,
+      "good": 21.0,
+      "ratio": 1.9091,
+      "suggested_scalar": 0.294,
+      "log_bad": 2.3979,
+      "log_good": 3.0445
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 0.0198,
+      "ratio": 0.0198,
+      "suggested_scalar": -1.7835,
+      "log_bad": 0.0,
+      "log_good": -3.9221
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8108,
+      "good": 0.8864,
+      "ratio": 1.0932,
+      "suggested_scalar": 0.0405,
+      "log_bad": -0.2097,
+      "log_good": -0.1206
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 0.0198,
+      "ratio": 0.0198,
+      "suggested_scalar": -1.7835,
+      "log_bad": 0.0,
+      "log_good": -3.9221
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4755,
+      "good": 4.6007,
+      "ratio": 1.028,
+      "suggested_scalar": 0.0125,
+      "log_bad": 1.4986,
+      "log_good": 1.5262
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 51.0,
+      "good": 72.0,
+      "ratio": 1.4118,
+      "suggested_scalar": 0.1568,
+      "log_bad": 3.9318,
+      "log_good": 4.2767
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4776,
+      "good": 0.417,
+      "ratio": 0.8731,
+      "suggested_scalar": -0.0617,
+      "log_bad": -0.739,
+      "log_good": -0.8747
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 12.0,
+      "good": 15.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.1015,
+      "log_bad": 2.4849,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6596,
+      "good": 0.5852,
+      "ratio": 0.8872,
+      "suggested_scalar": -0.0544,
+      "log_bad": -0.4161,
+      "log_good": -0.5358
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.0541,
+      "good": 4.2727,
+      "ratio": 1.0539,
+      "suggested_scalar": 0.0239,
+      "log_bad": 1.3997,
+      "log_good": 1.4522
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 170.0,
+      "good": 405.0,
+      "ratio": 2.3824,
+      "suggested_scalar": 0.3948,
+      "log_bad": 5.1358,
+      "log_good": 6.0039
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3152,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0009,
+      "good": 0.0005,
+      "ratio": 0.5556,
+      "suggested_scalar": -0.2673,
+      "log_bad": -7.0131,
+      "log_good": -7.6009
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.027,
+      "good": 1.0,
+      "ratio": 37.037,
+      "suggested_scalar": 1.6425,
+      "log_bad": -3.6119,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9359,
+      "good": 1.1301,
+      "ratio": 1.2075,
+      "suggested_scalar": 0.0857,
+      "log_bad": -0.0662,
+      "log_good": 0.1223
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 67.0,
+      "good": 152.0,
+      "ratio": 2.2687,
+      "suggested_scalar": 0.3725,
+      "log_bad": 4.2047,
+      "log_good": 5.0239
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 83.7839,
+      "good": 91.0601,
+      "ratio": 1.0868,
+      "suggested_scalar": 0.0379,
+      "log_bad": 4.4282,
+      "log_good": 4.5115
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5207,
+      "good": 0.698,
+      "ratio": 1.3405,
+      "suggested_scalar": 0.1333,
+      "log_bad": -0.6526,
+      "log_good": -0.3595
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 20.0285,
+      "good": 19.1612,
+      "ratio": 0.9567,
+      "suggested_scalar": -0.0201,
+      "log_bad": 2.9972,
+      "log_good": 2.9529
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1073.0,
+      "good": 1901.0,
+      "ratio": 1.7717,
+      "suggested_scalar": 0.2601,
+      "log_bad": 6.9782,
+      "log_good": 7.5501
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2432,
+      "good": 0.2727,
+      "ratio": 1.1213,
+      "suggested_scalar": 0.0521,
+      "log_bad": -1.4139,
+      "log_good": -1.2994
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7568,
+      "good": 0.8409,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0479,
+      "log_bad": -0.2787,
+      "log_good": -0.1733
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 4.7222,
+      "good": 9.2045,
+      "ratio": 1.9492,
+      "suggested_scalar": 0.3035,
+      "log_bad": 1.5523,
+      "log_good": 2.2197
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.9971,
+      "good": 3.1983,
+      "ratio": 0.8002,
+      "suggested_scalar": -0.1014,
+      "log_bad": 1.3856,
+      "log_good": 1.1626
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 54.0,
+      "good": 131.0,
+      "ratio": 2.4259,
+      "suggested_scalar": 0.403,
+      "log_bad": 3.989,
+      "log_good": 4.8752
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9215,
+      "good": 0.909,
+      "ratio": 0.9864,
+      "suggested_scalar": -0.0062,
+      "log_bad": -0.0818,
+      "log_good": -0.0954
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 15.0,
+      "good": 20.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1308,
+      "log_bad": 2.7081,
+      "log_good": 2.9957
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6309,
+      "good": 0.6839,
+      "ratio": 1.084,
+      "suggested_scalar": 0.0367,
+      "log_bad": -0.4606,
+      "log_good": -0.3799
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2798,
+      "good": 0.531,
+      "ratio": 1.8978,
+      "suggested_scalar": 0.2913,
+      "log_bad": -1.2737,
+      "log_good": -0.633
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7096,
+      "good": 3.1631,
+      "ratio": 1.1674,
+      "suggested_scalar": 0.0704,
+      "log_bad": 0.9968,
+      "log_good": 1.1516
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 168.0,
+      "good": 403.0,
+      "ratio": 2.3988,
+      "suggested_scalar": 0.3979,
+      "log_bad": 5.124,
+      "log_good": 5.9989
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 14.0,
+      "good": 19.0,
+      "ratio": 1.3571,
+      "suggested_scalar": 0.1389,
+      "log_bad": 2.6391,
+      "log_good": 2.9444
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0824,
+      "good": 0.0667,
+      "ratio": 0.8095,
+      "suggested_scalar": -0.0961,
+      "log_bad": -2.4962,
+      "log_good": -2.7076
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7004,
+      "good": 5.8329,
+      "ratio": 1.0232,
+      "suggested_scalar": 0.0104,
+      "log_bad": 1.7405,
+      "log_good": 1.7635
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 13.0,
+      "good": 21.0,
+      "ratio": 1.6154,
+      "suggested_scalar": 0.2181,
+      "log_bad": 2.5649,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7098,
+      "good": 0.5794,
+      "ratio": 0.8163,
+      "suggested_scalar": -0.0923,
+      "log_bad": -0.3428,
+      "log_good": -0.5458
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.0758,
+      "good": 5.419,
+      "ratio": 1.0676,
+      "suggested_scalar": 0.0298,
+      "log_bad": 1.6245,
+      "log_good": 1.6899
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7851,
+      "good": 0.7887,
+      "ratio": 1.0046,
+      "suggested_scalar": 0.0021,
+      "log_bad": -0.2419,
+      "log_good": -0.2374
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.119,
+      "good": 0.102,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0701,
+      "log_bad": -2.1286,
+      "log_good": -2.2828
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.4753,
+      "good": 4.3773,
+      "ratio": 0.9781,
+      "suggested_scalar": -0.0101,
+      "log_bad": 1.4986,
+      "log_good": 1.4764
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 141.0,
+      "good": 249.0,
+      "ratio": 1.766,
+      "suggested_scalar": 0.2586,
+      "log_bad": 4.9488,
+      "log_good": 5.5175
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 12.0,
+      "ratio": 12.0,
+      "suggested_scalar": 1.13,
+      "log_bad": 0.0,
+      "log_good": 2.4849
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.312,
+      "good": 0.6602,
+      "ratio": 2.116,
+      "suggested_scalar": 0.3408,
+      "log_bad": -1.1648,
+      "log_good": -0.4152
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 53.0,
+      "good": 84.0,
+      "ratio": 1.5849,
+      "suggested_scalar": 0.2094,
+      "log_bad": 3.9703,
+      "log_good": 4.4308
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 644.0,
+      "good": 1178.0,
+      "ratio": 1.8292,
+      "suggested_scalar": 0.2746,
+      "log_bad": 6.4677,
+      "log_good": 7.0716
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 72.0,
+      "good": 118.0,
+      "ratio": 1.6389,
+      "suggested_scalar": 0.2246,
+      "log_bad": 4.2767,
+      "log_good": 4.7707
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 0.0123,
+      "ratio": 0.0123,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -4.3982
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2941,
+      "good": 0.2716,
+      "ratio": 0.9235,
+      "suggested_scalar": -0.0362,
+      "log_bad": -1.2238,
+      "log_good": -1.3034
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 34.0,
+      "good": 73.0,
+      "ratio": 2.1471,
+      "suggested_scalar": 0.3475,
+      "log_bad": 3.5264,
+      "log_good": 4.2905
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 53.0,
+      "good": 84.0,
+      "ratio": 1.5849,
+      "suggested_scalar": 0.2094,
+      "log_bad": 3.9703,
+      "log_good": 4.4308
+    },
+    "brevity.mean_sample_size": {
+      "bad": 53.0,
+      "good": 84.0,
+      "ratio": 1.5849,
+      "suggested_scalar": 0.2094,
+      "log_bad": 3.9703,
+      "log_good": 4.4308
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 170.0,
+      "good": 405.0,
+      "ratio": 2.3824,
+      "suggested_scalar": 0.3948,
+      "log_bad": 5.1358,
+      "log_good": 6.0039
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 76.0,
+      "good": 218.0,
+      "ratio": 2.8684,
+      "suggested_scalar": 0.4792,
+      "log_bad": 4.3307,
+      "log_good": 5.3845
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 115.0,
+      "good": 195.0,
+      "ratio": 1.6957,
+      "suggested_scalar": 0.2401,
+      "log_bad": 4.7449,
+      "log_good": 5.273
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0059,
+      "good": 0.0025,
+      "ratio": 0.4237,
+      "suggested_scalar": -0.3905,
+      "log_bad": -5.1328,
+      "log_good": -5.9915
+    },
+    "heaps.mean_k": {
+      "bad": 1.8689,
+      "good": 2.5634,
+      "ratio": 1.3716,
+      "suggested_scalar": 0.1437,
+      "log_bad": 0.6254,
+      "log_good": 0.9413
+    },
+    "halstead.mean_effort": {
+      "bad": 14039.2527,
+      "good": 44943.1575,
+      "ratio": 3.2012,
+      "suggested_scalar": 0.5291,
+      "log_bad": 9.5496,
+      "log_good": 10.7132
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8862,
+      "good": 0.8477,
+      "ratio": 0.9566,
+      "suggested_scalar": -0.0202,
+      "log_bad": -0.1208,
+      "log_good": -0.1652
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 36.0,
+      "good": 52.0,
+      "ratio": 1.4444,
+      "suggested_scalar": 0.1672,
+      "log_bad": 3.5835,
+      "log_good": 3.9512
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 93.0,
+      "good": 203.0,
+      "ratio": 2.1828,
+      "suggested_scalar": 0.355,
+      "log_bad": 4.5326,
+      "log_good": 5.3132
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4776,
+      "good": 0.3684,
+      "ratio": 0.7714,
+      "suggested_scalar": -0.1181,
+      "log_bad": -0.739,
+      "log_good": -0.9986
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 9.6119,
+      "good": 7.75,
+      "ratio": 0.8063,
+      "suggested_scalar": -0.0979,
+      "log_bad": 2.263,
+      "log_good": 2.0477
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.119,
+      "good": 0.102,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0701,
+      "log_bad": -2.1286,
+      "log_good": -2.2828
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.1792,
+      "good": 4.542,
+      "ratio": 1.4287,
+      "suggested_scalar": 0.1622,
+      "log_bad": 1.1566,
+      "log_good": 1.5134
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 169.0,
+      "good": 404.0,
+      "ratio": 2.3905,
+      "suggested_scalar": 0.3963,
+      "log_bad": 5.1299,
+      "log_good": 6.0014
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 15.0,
+      "ratio": 15.0,
+      "suggested_scalar": 1.2314,
+      "log_bad": 0.0,
+      "log_good": 2.7081
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 20.0,
+      "good": 60.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.4996,
+      "log_bad": 2.9957,
+      "log_good": 4.0943
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 779.9585,
+      "good": 2496.8421,
+      "ratio": 3.2012,
+      "suggested_scalar": 0.5291,
+      "log_bad": 6.6592,
+      "log_good": 7.8228
+    },
+    "readability.mean_total_lines": {
+      "bad": 36.0,
+      "good": 44.0,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.0913,
+      "log_bad": 3.5835,
+      "log_good": 3.7842
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 6.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1308,
+      "log_bad": 2.0794,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 935.9502,
+      "good": 1980.5459,
+      "ratio": 2.1161,
+      "suggested_scalar": 0.3409,
+      "log_bad": 6.8416,
+      "log_good": 7.5911
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 396.0,
+      "good": 601.0,
+      "ratio": 1.5177,
+      "suggested_scalar": 0.1897,
+      "log_bad": 5.9814,
+      "log_good": 6.3986
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 27.9444,
+      "good": 42.0,
+      "ratio": 1.503,
+      "suggested_scalar": 0.1853,
+      "log_bad": 3.3302,
+      "log_good": 3.7377
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3978,
+      "good": 1.2581,
+      "ratio": 0.9001,
+      "suggested_scalar": -0.0479,
+      "log_bad": 0.3349,
+      "log_good": 0.2296
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3152,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 10.0,
+      "good": 28.0,
+      "ratio": 2.8,
+      "suggested_scalar": 0.4682,
+      "log_bad": 2.3026,
+      "log_good": 3.3322
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8582,
+      "good": 0.759,
+      "ratio": 0.8844,
+      "suggested_scalar": -0.0559,
+      "log_bad": -0.1529,
+      "log_good": -0.2758
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.987,
+      "good": 0.986,
+      "ratio": 0.999,
+      "suggested_scalar": -0.0005,
+      "log_bad": -0.0131,
+      "log_good": -0.0141
+    },
+    "halstead.mean_length": {
+      "bad": 165.0,
+      "good": 321.0,
+      "ratio": 1.9455,
+      "suggested_scalar": 0.3026,
+      "log_bad": 5.1059,
+      "log_good": 5.7714
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.25,
+      "good": 12.0,
+      "ratio": 1.1707,
+      "suggested_scalar": 0.0717,
+      "log_bad": 2.3273,
+      "log_good": 2.4849
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.7279,
+      "good": 6.3923,
+      "ratio": 1.116,
+      "suggested_scalar": 0.0499,
+      "log_bad": 1.7453,
+      "log_good": 1.8551
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0708,
+      "good": 0.1149,
+      "ratio": 1.6229,
+      "suggested_scalar": 0.2202,
+      "log_bad": -2.6479,
+      "log_good": -2.1637
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 15.0,
+      "good": 22.6923,
+      "ratio": 1.5128,
+      "suggested_scalar": 0.1882,
+      "log_bad": 2.7081,
+      "log_good": 3.122
+    },
+    "branching.mean_branch_count": {
+      "bad": 9.0,
+      "good": 12.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1308,
+      "log_bad": 2.1972,
+      "log_good": 2.4849
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 32.0,
+      "good": 56.0,
+      "ratio": 1.75,
+      "suggested_scalar": 0.2545,
+      "log_bad": 3.4657,
+      "log_good": 4.0254
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7043,
+      "good": 0.6256,
+      "ratio": 0.8883,
+      "suggested_scalar": -0.0539,
+      "log_bad": -0.3506,
+      "log_good": -0.469
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 37.0,
+      "good": 44.0,
+      "ratio": 1.1892,
+      "suggested_scalar": 0.0788,
+      "log_bad": 3.6109,
+      "log_good": 3.7842
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.uses_pattern_matching_over_conditionals": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 20.0,
+      "good": 28.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.1464,
+      "log_bad": 2.9957,
+      "log_good": 3.3322
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0177,
+      "good": 0.0294,
+      "ratio": 1.661,
+      "suggested_scalar": 0.2209,
+      "log_bad": -4.0342,
+      "log_good": -3.5268
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3333,
+      "good": 1.2727,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.0202,
+      "log_bad": 0.2877,
+      "log_good": 0.2411
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8226,
+      "good": 0.72,
+      "ratio": 0.8753,
+      "suggested_scalar": -0.058,
+      "log_bad": -0.1953,
+      "log_good": -0.3285
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0177,
+      "good": 0.0294,
+      "ratio": 1.661,
+      "suggested_scalar": 0.2209,
+      "log_bad": -4.0342,
+      "log_good": -3.5268
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.3881,
+      "good": 4.7554,
+      "ratio": 1.0837,
+      "suggested_scalar": 0.035,
+      "log_bad": 1.4789,
+      "log_good": 1.5593
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 91.0,
+      "good": 68.0,
+      "ratio": 0.7473,
+      "suggested_scalar": -0.1268,
+      "log_bad": 4.5109,
+      "log_good": 4.2195
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4447,
+      "good": 0.4028,
+      "ratio": 0.9058,
+      "suggested_scalar": -0.0431,
+      "log_bad": -0.8104,
+      "log_good": -0.9093
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 23.0,
+      "ratio": 1.15,
+      "suggested_scalar": 0.0608,
+      "log_bad": 2.9957,
+      "log_good": 3.1355
+    },
+    "heaps.mean_beta": {
+      "bad": 0.611,
+      "good": 0.5471,
+      "ratio": 0.8954,
+      "suggested_scalar": -0.0481,
+      "log_bad": -0.4927,
+      "log_good": -0.6031
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.2581,
+      "good": 2.4,
+      "ratio": 0.4564,
+      "suggested_scalar": -0.3414,
+      "log_bad": 1.6598,
+      "log_good": 0.8755
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 396.0,
+      "good": 544.0,
+      "ratio": 1.3737,
+      "suggested_scalar": 0.1382,
+      "log_bad": 5.9814,
+      "log_good": 6.2989
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0484,
+      "good": 1.0,
+      "ratio": 20.6612,
+      "suggested_scalar": 1.318,
+      "log_bad": -3.0283,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0469,
+      "good": 1.1366,
+      "ratio": 1.0857,
+      "suggested_scalar": 0.0358,
+      "log_bad": 0.0458,
+      "log_good": 0.128
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 135.0,
+      "good": 195.0,
+      "ratio": 1.4444,
+      "suggested_scalar": 0.16,
+      "log_bad": 4.9053,
+      "log_good": 5.273
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 110.7995,
+      "good": 103.8987,
+      "ratio": 0.9377,
+      "suggested_scalar": -0.028,
+      "log_bad": 4.7077,
+      "log_good": 4.6434
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6633,
+      "good": 0.7753,
+      "ratio": 1.1689,
+      "suggested_scalar": 0.0679,
+      "log_bad": -0.4105,
+      "log_good": -0.2545
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.7613,
+      "good": 9.7064,
+      "ratio": 1.1079,
+      "suggested_scalar": 0.0446,
+      "log_bad": 2.1703,
+      "log_good": 2.2728
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1667.0,
+      "good": 1976.0,
+      "ratio": 1.1854,
+      "suggested_scalar": 0.074,
+      "log_bad": 7.4188,
+      "log_good": 7.5888
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2581,
+      "good": 0.04,
+      "ratio": 0.155,
+      "suggested_scalar": -0.8115,
+      "log_bad": -1.3544,
+      "log_good": -3.2189
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6613,
+      "good": 0.7,
+      "ratio": 1.0585,
+      "suggested_scalar": 0.0248,
+      "log_bad": -0.4135,
+      "log_good": -0.3567
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.7119,
+      "good": 10.88,
+      "ratio": 1.621,
+      "suggested_scalar": 0.2102,
+      "log_bad": 1.9039,
+      "log_good": 2.3869
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 8.0302,
+      "good": 0.96,
+      "ratio": 0.1195,
+      "suggested_scalar": -0.9245,
+      "log_bad": 2.0832,
+      "log_good": -0.0408
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 111.0,
+      "good": 159.0,
+      "ratio": 1.4324,
+      "suggested_scalar": 0.1564,
+      "log_bad": 4.7095,
+      "log_good": 5.0689
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9376,
+      "good": 0.9429,
+      "ratio": 1.0057,
+      "suggested_scalar": 0.0025,
+      "log_bad": -0.0644,
+      "log_good": -0.0588
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 25.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0171,
+      "log_bad": 3.2581,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6377,
+      "good": 0.6705,
+      "ratio": 1.0514,
+      "suggested_scalar": 0.0218,
+      "log_bad": -0.4499,
+      "log_good": -0.3997
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5051,
+      "good": 0.6384,
+      "ratio": 1.2639,
+      "suggested_scalar": 0.1019,
+      "log_bad": -0.683,
+      "log_good": -0.4488
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7599,
+      "good": 3.0353,
+      "ratio": 1.0998,
+      "suggested_scalar": 0.0414,
+      "log_bad": 1.0152,
+      "log_good": 1.1103
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 394.0,
+      "good": 542.0,
+      "ratio": 1.3756,
+      "suggested_scalar": 0.1388,
+      "log_bad": 5.9764,
+      "log_good": 6.2953
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 24.0,
+      "good": 8.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.4782,
+      "log_bad": 3.1781,
+      "log_good": 2.0794
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0227,
+      "good": 0.0496,
+      "ratio": 2.185,
+      "suggested_scalar": 0.3402,
+      "log_bad": -3.7854,
+      "log_good": -3.0038
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.858,
+      "good": 6.0444,
+      "ratio": 1.0318,
+      "suggested_scalar": 0.0136,
+      "log_bad": 1.7678,
+      "log_good": 1.7991
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 23.0,
+      "good": 36.0,
+      "ratio": 1.5652,
+      "suggested_scalar": 0.195,
+      "log_bad": 3.1355,
+      "log_good": 3.5835
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7196,
+      "good": 0.6901,
+      "ratio": 0.959,
+      "suggested_scalar": -0.0182,
+      "log_bad": -0.3291,
+      "log_good": -0.3709
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6129,
+      "good": 5.5485,
+      "ratio": 0.9885,
+      "suggested_scalar": -0.005,
+      "log_bad": 1.7251,
+      "log_good": 1.7135
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7491,
+      "good": 0.7867,
+      "ratio": 1.0502,
+      "suggested_scalar": 0.0213,
+      "log_bad": -0.2889,
+      "log_good": -0.2399
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1143,
+      "good": 0.1228,
+      "ratio": 1.0744,
+      "suggested_scalar": 0.0312,
+      "log_bad": -2.1689,
+      "log_good": -2.0972
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.9599,
+      "good": 3.1155,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0223,
+      "log_bad": 1.0852,
+      "log_good": 1.1364
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.2223,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 264.0,
+      "good": 299.0,
+      "ratio": 1.1326,
+      "suggested_scalar": 0.0542,
+      "log_bad": 5.5759,
+      "log_good": 5.7004
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 5.0,
+      "good": 10.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.3017,
+      "log_bad": 1.6094,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7723,
+      "good": 0.8928,
+      "ratio": 1.156,
+      "suggested_scalar": 0.0631,
+      "log_bad": -0.2584,
+      "log_good": -0.1134
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 91.0,
+      "good": 106.0,
+      "ratio": 1.1648,
+      "suggested_scalar": 0.0664,
+      "log_bad": 4.5109,
+      "log_good": 4.6634
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 781.0,
+      "good": 1191.0,
+      "ratio": 1.525,
+      "suggested_scalar": 0.1837,
+      "log_bad": 6.6606,
+      "log_good": 7.0825
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 137.0,
+      "good": 145.0,
+      "ratio": 1.0584,
+      "suggested_scalar": 0.0247,
+      "log_bad": 4.92,
+      "log_good": 4.9767
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0101,
+      "good": 1.0,
+      "ratio": 99.0099,
+      "suggested_scalar": 2.0,
+      "log_bad": -4.5952,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1944,
+      "good": 0.239,
+      "ratio": 1.2294,
+      "suggested_scalar": 0.0899,
+      "log_bad": -1.6378,
+      "log_good": -1.4313
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 74.0,
+      "good": 103.0,
+      "ratio": 1.3919,
+      "suggested_scalar": 0.1439,
+      "log_bad": 4.3041,
+      "log_good": 4.6347
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 11.0,
+      "ratio": 3.6667,
+      "suggested_scalar": 0.5655,
+      "log_bad": 1.0986,
+      "log_good": 2.3979
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 91.0,
+      "good": 106.0,
+      "ratio": 1.1648,
+      "suggested_scalar": 0.0664,
+      "log_bad": 4.5109,
+      "log_good": 4.6634
+    },
+    "brevity.mean_sample_size": {
+      "bad": 91.0,
+      "good": 106.0,
+      "ratio": 1.1648,
+      "suggested_scalar": 0.0664,
+      "log_bad": 4.5109,
+      "log_good": 4.6634
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 396.0,
+      "good": 544.0,
+      "ratio": 1.3737,
+      "suggested_scalar": 0.1382,
+      "log_bad": 5.9814,
+      "log_good": 6.2989
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 211.0,
+      "good": 306.0,
+      "ratio": 1.4502,
+      "suggested_scalar": 0.1618,
+      "log_bad": 5.3519,
+      "log_good": 5.7236
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 207.0,
+      "good": 225.0,
+      "ratio": 1.087,
+      "suggested_scalar": 0.0363,
+      "log_bad": 5.3327,
+      "log_good": 5.4161
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0076,
+      "good": 0.0092,
+      "ratio": 1.2105,
+      "suggested_scalar": 0.0832,
+      "log_bad": -4.8796,
+      "log_good": -4.6886
+    },
+    "heaps.mean_k": {
+      "bad": 2.4286,
+      "good": 3.6629,
+      "ratio": 1.5082,
+      "suggested_scalar": 0.1789,
+      "log_bad": 0.8873,
+      "log_good": 1.2983
+    },
+    "halstead.mean_effort": {
+      "bad": 63479.632,
+      "good": 112901.2004,
+      "ratio": 1.7785,
+      "suggested_scalar": 0.2506,
+      "log_bad": 11.0585,
+      "log_good": 11.6343
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8625,
+      "good": 0.8247,
+      "ratio": 0.9562,
+      "suggested_scalar": -0.0195,
+      "log_bad": -0.1479,
+      "log_good": -0.1927
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 65.0,
+      "good": 43.0,
+      "ratio": 0.6615,
+      "suggested_scalar": -0.1798,
+      "log_bad": 4.1744,
+      "log_good": 3.7612
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 219.0,
+      "good": 295.0,
+      "ratio": 1.347,
+      "suggested_scalar": 0.1297,
+      "log_bad": 5.3891,
+      "log_good": 5.687
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4148,
+      "good": 0.359,
+      "ratio": 0.8655,
+      "suggested_scalar": -0.0629,
+      "log_bad": -0.88,
+      "log_good": -1.0244
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.7852,
+      "good": 6.1077,
+      "ratio": 1.0557,
+      "suggested_scalar": 0.0236,
+      "log_bad": 1.7553,
+      "log_good": 1.8096
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1143,
+      "good": 0.1228,
+      "ratio": 1.0744,
+      "suggested_scalar": 0.0312,
+      "log_bad": -2.1689,
+      "log_good": -2.0972
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.9033,
+      "good": 4.8692,
+      "ratio": 1.6771,
+      "suggested_scalar": 0.2251,
+      "log_bad": 1.0658,
+      "log_good": 1.5829
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 395.0,
+      "good": 543.0,
+      "ratio": 1.3747,
+      "suggested_scalar": 0.1385,
+      "log_bad": 5.9789,
+      "log_good": 6.2971
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 69.0,
+      "good": 103.0,
+      "ratio": 1.4928,
+      "suggested_scalar": 0.1744,
+      "log_bad": 4.2341,
+      "log_good": 4.6347
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3526.6462,
+      "good": 6272.2889,
+      "ratio": 1.7785,
+      "suggested_scalar": 0.2506,
+      "log_bad": 8.1681,
+      "log_good": 8.7439
+    },
+    "readability.mean_total_lines": {
+      "bad": 59.0,
+      "good": 50.0,
+      "ratio": 0.8475,
+      "suggested_scalar": -0.072,
+      "log_bad": 4.0775,
+      "log_good": 3.912
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 4.0,
+      "ratio": 0.4,
+      "suggested_scalar": -0.3988,
+      "log_bad": 2.3026,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2316.7749,
+      "good": 2678.4837,
+      "ratio": 1.1561,
+      "suggested_scalar": 0.0631,
+      "log_bad": 7.7479,
+      "log_good": 7.893
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 604.0,
+      "good": 651.0,
+      "ratio": 1.0778,
+      "suggested_scalar": 0.0326,
+      "log_bad": 6.4036,
+      "log_good": 6.4785
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 23.5763,
+      "good": 38.32,
+      "ratio": 1.6254,
+      "suggested_scalar": 0.2114,
+      "log_bad": 3.1602,
+      "log_good": 3.646
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0546,
+      "good": 1.0862,
+      "ratio": 1.03,
+      "suggested_scalar": 0.0128,
+      "log_bad": 0.0532,
+      "log_good": 0.0827
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 31.0,
+      "good": 27.0,
+      "ratio": 0.871,
+      "suggested_scalar": -0.0601,
+      "log_bad": 3.434,
+      "log_good": 3.2958
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.4782,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7386,
+      "good": 0.6555,
+      "ratio": 0.8875,
+      "suggested_scalar": -0.0519,
+      "log_bad": -0.303,
+      "log_good": -0.4224
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 5.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.3988,
+      "log_bad": 0.6931,
+      "log_good": 1.6094
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9681,
+      "good": 0.9549,
+      "ratio": 0.9864,
+      "suggested_scalar": -0.006,
+      "log_bad": -0.0324,
+      "log_good": -0.0461
+    },
+    "halstead.mean_length": {
+      "bad": 356.0,
+      "good": 440.0,
+      "ratio": 1.236,
+      "suggested_scalar": 0.0922,
+      "log_bad": 5.8749,
+      "log_good": 6.0868
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 20.0,
+      "good": 3.9091,
+      "ratio": 0.1955,
+      "suggested_scalar": -0.7105,
+      "log_bad": 2.9957,
+      "log_good": 1.3633
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5078,
+      "good": 6.7279,
+      "ratio": 1.0338,
+      "suggested_scalar": 0.0145,
+      "log_bad": 1.873,
+      "log_good": 1.9063
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1268,
+      "good": 0.1551,
+      "ratio": 1.2232,
+      "suggested_scalar": 0.0877,
+      "log_bad": -2.0651,
+      "log_good": -1.8637
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.4,
+      "good": 42.1512,
+      "ratio": 1.5384,
+      "suggested_scalar": 0.1875,
+      "log_bad": 3.3105,
+      "log_good": 3.7413
+    },
+    "branching.mean_branch_count": {
+      "bad": 16.0,
+      "good": 2.0,
+      "ratio": 0.125,
+      "suggested_scalar": -0.905,
+      "log_bad": 2.7726,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 56.0,
+      "good": 70.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0971,
+      "log_bad": 4.0254,
+      "log_good": 4.2485
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6425,
+      "good": 0.5422,
+      "ratio": 0.8439,
+      "suggested_scalar": -0.0739,
+      "log_bad": -0.4424,
+      "log_good": -0.6121
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 62.0,
+      "good": 50.0,
+      "ratio": 0.8065,
+      "suggested_scalar": -0.0936,
+      "log_bad": 4.1271,
+      "log_good": 3.912
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "scope_and_assignment.used_only_once": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 29.0,
+      "good": 23.0,
+      "ratio": 0.7931,
+      "suggested_scalar": -0.7316,
+      "log_bad": 3.3673,
+      "log_good": 3.1355
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0265,
+      "good": 0.0281,
+      "ratio": 1.0604,
+      "suggested_scalar": 0.185,
+      "log_bad": -3.6306,
+      "log_good": -3.572
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6154,
+      "good": 1.6154,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.4796,
+      "log_good": 0.4796
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9216,
+      "good": 0.8605,
+      "ratio": 0.9337,
+      "suggested_scalar": -0.2165,
+      "log_bad": -0.0816,
+      "log_good": -0.1502
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0265,
+      "good": 0.0281,
+      "ratio": 1.0604,
+      "suggested_scalar": 0.185,
+      "log_bad": -3.6306,
+      "log_good": -3.572
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7585,
+      "good": 4.8384,
+      "ratio": 1.0168,
+      "suggested_scalar": 0.0526,
+      "log_bad": 1.5599,
+      "log_good": 1.5766
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 107.0,
+      "good": 87.0,
+      "ratio": 0.8131,
+      "suggested_scalar": -0.6531,
+      "log_bad": 4.6728,
+      "log_good": 4.4659
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5331,
+      "good": 0.5691,
+      "ratio": 1.0675,
+      "suggested_scalar": 0.2063,
+      "log_bad": -0.629,
+      "log_good": -0.5637
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6304,
+      "good": 0.6307,
+      "ratio": 1.0005,
+      "suggested_scalar": 0.0015,
+      "log_bad": -0.4614,
+      "log_good": -0.4609
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.0196,
+      "good": 3.1163,
+      "ratio": 1.032,
+      "suggested_scalar": 0.0995,
+      "log_bad": 1.1051,
+      "log_good": 1.1366
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 453.0,
+      "good": 392.0,
+      "ratio": 0.8653,
+      "suggested_scalar": -0.4565,
+      "log_bad": 6.1159,
+      "log_good": 5.9713
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0006,
+      "good": 0.0008,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.908,
+      "log_bad": -7.4186,
+      "log_good": -7.1309
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9518,
+      "good": 1.0083,
+      "ratio": 1.0594,
+      "suggested_scalar": 0.182,
+      "log_bad": -0.0494,
+      "log_good": 0.0083
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 151.0,
+      "good": 110.0,
+      "ratio": 0.7285,
+      "suggested_scalar": -0.9999,
+      "log_bad": 5.0173,
+      "log_good": 4.7005
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 103.1957,
+      "good": 104.3181,
+      "ratio": 1.0109,
+      "suggested_scalar": 0.0341,
+      "log_bad": 4.6366,
+      "log_good": 4.6474
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.427,
+      "good": 0.5217,
+      "ratio": 1.2218,
+      "suggested_scalar": 0.6322,
+      "log_bad": -0.851,
+      "log_good": -0.6507
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 14.2586,
+      "good": 16.0288,
+      "ratio": 1.1241,
+      "suggested_scalar": 0.3694,
+      "log_bad": 2.6574,
+      "log_good": 2.7744
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1713.0,
+      "good": 1313.0,
+      "ratio": 0.7665,
+      "suggested_scalar": -0.8394,
+      "log_bad": 7.446,
+      "log_good": 7.1801
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.902,
+      "good": 0.8372,
+      "ratio": 0.9282,
+      "suggested_scalar": -0.2353,
+      "log_bad": -0.1031,
+      "log_good": -0.1777
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.8824,
+      "good": 9.1163,
+      "ratio": 1.0263,
+      "suggested_scalar": 0.082,
+      "log_bad": 2.1841,
+      "log_good": 2.2101
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.3133,
+      "good": 2.4749,
+      "ratio": 1.8845,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.2725,
+      "log_good": 0.9062
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 133.0,
+      "good": 92.0,
+      "ratio": 0.6917,
+      "suggested_scalar": -1.1633,
+      "log_bad": 4.8903,
+      "log_good": 4.5218
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9493,
+      "good": 0.9424,
+      "ratio": 0.9927,
+      "suggested_scalar": -0.023,
+      "log_bad": -0.052,
+      "log_good": -0.0593
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5727,
+      "good": 0.5377,
+      "ratio": 0.9389,
+      "suggested_scalar": -0.199,
+      "log_bad": -0.5574,
+      "log_good": -0.6205
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2151,
+      "good": 0.2872,
+      "ratio": 1.3352,
+      "suggested_scalar": 0.9124,
+      "log_bad": -1.5367,
+      "log_good": -1.2476
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3402,
+      "good": 2.1631,
+      "ratio": 0.9243,
+      "suggested_scalar": -0.2484,
+      "log_bad": 0.8502,
+      "log_good": 0.7715
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 451.0,
+      "good": 390.0,
+      "ratio": 0.8647,
+      "suggested_scalar": -0.4587,
+      "log_bad": 6.1115,
+      "log_good": 5.9661
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 10.0,
+      "good": 9.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.3325,
+      "log_bad": 2.3026,
+      "log_good": 2.1972
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0375,
+      "good": 0.0434,
+      "ratio": 1.1573,
+      "suggested_scalar": 0.4612,
+      "log_bad": -3.2834,
+      "log_good": -3.1373
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0,
+      "good": 6.0224,
+      "ratio": 1.0037,
+      "suggested_scalar": 0.0118,
+      "log_bad": 1.7918,
+      "log_good": 1.7955
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.642,
+      "good": 0.8007,
+      "ratio": 1.2472,
+      "suggested_scalar": 0.6972,
+      "log_bad": -0.4432,
+      "log_good": -0.2223
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8574,
+      "good": 5.6775,
+      "ratio": 0.9693,
+      "suggested_scalar": -0.0985,
+      "log_bad": 1.7677,
+      "log_good": 1.7365
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7931,
+      "good": 0.8034,
+      "ratio": 1.013,
+      "suggested_scalar": 0.0407,
+      "log_bad": -0.2318,
+      "log_good": -0.2189
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1053,
+      "good": 0.1224,
+      "ratio": 1.1624,
+      "suggested_scalar": 0.475,
+      "log_bad": -2.2509,
+      "log_good": -2.1005
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.7761,
+      "good": 4.0036,
+      "ratio": 1.0602,
+      "suggested_scalar": 0.1846,
+      "log_bad": 1.3287,
+      "log_good": 1.3872
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 387.0,
+      "good": 317.0,
+      "ratio": 0.8191,
+      "suggested_scalar": -0.6298,
+      "log_bad": 5.9584,
+      "log_good": 5.7589
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 20.0,
+      "good": 21.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.154,
+      "log_bad": 2.9957,
+      "log_good": 3.0445
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8786,
+      "good": 0.7109,
+      "ratio": 0.8091,
+      "suggested_scalar": -0.6685,
+      "log_bad": -0.1294,
+      "log_good": -0.3412
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 117.0,
+      "good": 100.0,
+      "ratio": 0.8547,
+      "suggested_scalar": -0.4955,
+      "log_bad": 4.7622,
+      "log_good": 4.6052
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 894.0,
+      "good": 611.0,
+      "ratio": 0.6834,
+      "suggested_scalar": -1.2013,
+      "log_bad": 6.7957,
+      "log_good": 6.4151
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 151.0,
+      "good": 104.0,
+      "ratio": 0.6887,
+      "suggested_scalar": -1.1769,
+      "log_bad": 5.0173,
+      "log_good": 4.6444
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2914,
+      "good": 0.2934,
+      "ratio": 1.0069,
+      "suggested_scalar": 0.0216,
+      "log_bad": -1.2331,
+      "log_good": -1.2262
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 60.0,
+      "good": 62.0,
+      "ratio": 1.0333,
+      "suggested_scalar": 0.1035,
+      "log_bad": 4.0943,
+      "log_good": 4.1271
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 117.0,
+      "good": 100.0,
+      "ratio": 0.8547,
+      "suggested_scalar": -0.4955,
+      "log_bad": 4.7622,
+      "log_good": 4.6052
+    },
+    "brevity.mean_sample_size": {
+      "bad": 117.0,
+      "good": 100.0,
+      "ratio": 0.8547,
+      "suggested_scalar": -0.4955,
+      "log_bad": 4.7622,
+      "log_good": 4.6052
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 453.0,
+      "good": 392.0,
+      "ratio": 0.8653,
+      "suggested_scalar": -0.4565,
+      "log_bad": 6.1159,
+      "log_good": 5.9713
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 240.0,
+      "good": 224.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.2178,
+      "log_bad": 5.4806,
+      "log_good": 5.4116
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 319.0,
+      "good": 249.0,
+      "ratio": 0.7806,
+      "suggested_scalar": -0.7819,
+      "log_bad": 5.7652,
+      "log_good": 5.5175
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.7044,
+      "good": 2.5647,
+      "ratio": 0.9483,
+      "suggested_scalar": -0.1674,
+      "log_bad": 0.9949,
+      "log_good": 0.9418
+    },
+    "halstead.mean_effort": {
+      "bad": 67166.3732,
+      "good": 49903.1746,
+      "ratio": 0.743,
+      "suggested_scalar": -0.9377,
+      "log_bad": 11.1149,
+      "log_good": 10.8178
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8526,
+      "good": 0.8545,
+      "ratio": 1.0022,
+      "suggested_scalar": 0.007,
+      "log_bad": -0.1595,
+      "log_good": -0.1572
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 80.0,
+      "good": 60.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.908,
+      "log_bad": 4.382,
+      "log_good": 4.0943
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 240.0,
+      "good": 227.0,
+      "ratio": 0.9458,
+      "suggested_scalar": -0.1758,
+      "log_bad": 5.4806,
+      "log_good": 5.425
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5099,
+      "good": 0.5545,
+      "ratio": 1.0875,
+      "suggested_scalar": 0.2647,
+      "log_bad": -0.6735,
+      "log_good": -0.5897
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.9205,
+      "good": 5.5545,
+      "ratio": 0.9382,
+      "suggested_scalar": -0.2014,
+      "log_bad": 1.7784,
+      "log_good": 1.7146
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1053,
+      "good": 0.1224,
+      "ratio": 1.1624,
+      "suggested_scalar": 0.475,
+      "log_bad": -2.2509,
+      "log_good": -2.1005
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.9321,
+      "good": 4.1284,
+      "ratio": 1.0499,
+      "suggested_scalar": 0.1538,
+      "log_bad": 1.3692,
+      "log_good": 1.4179
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 452.0,
+      "good": 391.0,
+      "ratio": 0.865,
+      "suggested_scalar": -0.4576,
+      "log_bad": 6.1137,
+      "log_good": 5.9687
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 13.0,
+      "good": 12.0,
+      "ratio": 0.9231,
+      "suggested_scalar": -0.2526,
+      "log_bad": 2.5649,
+      "log_good": 2.4849
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 33.0,
+      "good": 39.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.5273,
+      "log_bad": 3.4965,
+      "log_good": 3.6636
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3731.4652,
+      "good": 2772.3986,
+      "ratio": 0.743,
+      "suggested_scalar": -0.9377,
+      "log_bad": 8.2246,
+      "log_good": 7.9275
+    },
+    "readability.mean_total_lines": {
+      "bad": 51.0,
+      "good": 43.0,
+      "ratio": 0.8431,
+      "suggested_scalar": -0.5385,
+      "log_bad": 3.9318,
+      "log_good": 3.7612
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 1.2798,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2635.9136,
+      "good": 2132.6143,
+      "ratio": 0.8091,
+      "suggested_scalar": -0.6688,
+      "log_bad": 7.877,
+      "log_good": 7.6651
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 732.0,
+      "good": 607.0,
+      "ratio": 0.8292,
+      "suggested_scalar": -0.591,
+      "log_bad": 6.5958,
+      "log_good": 6.4085
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.4314,
+      "good": 29.3488,
+      "ratio": 0.905,
+      "suggested_scalar": -0.3152,
+      "log_bad": 3.4791,
+      "log_good": 3.3793
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1185,
+      "good": 1.1024,
+      "ratio": 0.9856,
+      "suggested_scalar": -0.0458,
+      "log_bad": 0.112,
+      "log_good": 0.0975
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9147,
+      "good": 0.877,
+      "ratio": 0.9588,
+      "suggested_scalar": -0.1328,
+      "log_bad": -0.0892,
+      "log_good": -0.1312
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9877,
+      "good": 0.9889,
+      "ratio": 1.0012,
+      "suggested_scalar": 0.0038,
+      "log_bad": -0.0124,
+      "log_good": -0.0112
+    },
+    "halstead.mean_length": {
+      "bad": 391.0,
+      "good": 331.0,
+      "ratio": 0.8465,
+      "suggested_scalar": -0.5258,
+      "log_bad": 5.9687,
+      "log_good": 5.8021
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.0,
+      "good": 3.3846,
+      "ratio": 0.8461,
+      "suggested_scalar": -0.5273,
+      "log_bad": 1.3863,
+      "log_good": 1.2192
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8704,
+      "good": 6.6439,
+      "ratio": 0.967,
+      "suggested_scalar": -0.1058,
+      "log_bad": 1.9272,
+      "log_good": 1.8937
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1403,
+      "good": 0.1709,
+      "ratio": 1.2181,
+      "suggested_scalar": 0.6227,
+      "log_bad": -1.964,
+      "log_good": -1.7667
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.4812,
+      "good": 23.4,
+      "ratio": 0.9183,
+      "suggested_scalar": -0.2689,
+      "log_bad": 3.2379,
+      "log_good": 3.1527
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 77.0,
+      "good": 61.0,
+      "ratio": 0.7922,
+      "suggested_scalar": -0.7352,
+      "log_bad": 4.3438,
+      "log_good": 4.1109
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8119,
+      "good": 0.751,
+      "ratio": 0.925,
+      "suggested_scalar": -0.2461,
+      "log_bad": -0.2084,
+      "log_good": -0.2863
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 51.0,
+      "good": 43.0,
+      "ratio": 0.8431,
+      "suggested_scalar": -0.5385,
+      "log_bad": 3.9318,
+      "log_good": 3.7612
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_runblocking_in_coroutines": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 30.0,
+      "good": 22.0,
+      "ratio": 0.7333,
+      "suggested_scalar": -0.0816,
+      "log_bad": 3.4012,
+      "log_good": 3.091
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0028,
+      "good": 1.0,
+      "ratio": 357.1429,
+      "suggested_scalar": 1.5467,
+      "log_bad": -5.8781,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9318,
+      "good": 0.907,
+      "ratio": 0.9734,
+      "suggested_scalar": -0.0071,
+      "log_bad": -0.0706,
+      "log_good": -0.0976
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0028,
+      "good": 1.0,
+      "ratio": 357.1429,
+      "suggested_scalar": 1.5467,
+      "log_bad": -5.8781,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5966,
+      "good": 4.6077,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.0006,
+      "log_bad": 1.5253,
+      "log_good": 1.5277
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 118.0,
+      "good": 120.0,
+      "ratio": 1.0169,
+      "suggested_scalar": 0.0044,
+      "log_bad": 4.7707,
+      "log_good": 4.7875
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6147,
+      "good": 0.7047,
+      "ratio": 1.1464,
+      "suggested_scalar": 0.036,
+      "log_bad": -0.4866,
+      "log_good": -0.35
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 14.0,
+      "ratio": 0.7778,
+      "suggested_scalar": -0.0661,
+      "log_bad": 2.8904,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7367,
+      "good": 0.7955,
+      "ratio": 1.0798,
+      "suggested_scalar": 0.0202,
+      "log_bad": -0.3056,
+      "log_good": -0.2288
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.2955,
+      "good": 5.4884,
+      "ratio": 0.8718,
+      "suggested_scalar": -0.0361,
+      "log_bad": 1.8398,
+      "log_good": 1.7026
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 358.0,
+      "good": 306.0,
+      "ratio": 0.8547,
+      "suggested_scalar": -0.0413,
+      "log_bad": 5.8805,
+      "log_good": 5.7236
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.048,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0005,
+      "good": 1.0,
+      "ratio": 2.0e3,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.6009,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1818,
+      "good": 0.2326,
+      "ratio": 1.2794,
+      "suggested_scalar": 0.0648,
+      "log_bad": -1.7048,
+      "log_good": -1.4584
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8565,
+      "good": 0.8043,
+      "ratio": 0.9391,
+      "suggested_scalar": -0.0165,
+      "log_bad": -0.1549,
+      "log_good": -0.2178
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 146.0,
+      "good": 129.0,
+      "ratio": 0.8836,
+      "suggested_scalar": -0.0326,
+      "log_bad": 4.9836,
+      "log_good": 4.8598
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 95.0812,
+      "good": 98.3941,
+      "ratio": 1.0348,
+      "suggested_scalar": 0.009,
+      "log_bad": 4.5547,
+      "log_good": 4.589
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4258,
+      "good": 0.318,
+      "ratio": 0.7468,
+      "suggested_scalar": -0.0768,
+      "log_bad": -0.8538,
+      "log_good": -1.1457
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 12.1222,
+      "good": 11.0608,
+      "ratio": 0.9124,
+      "suggested_scalar": -0.0241,
+      "log_bad": 2.495,
+      "log_good": 2.4034
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1902.0,
+      "good": 1585.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.048,
+      "log_bad": 7.5507,
+      "log_good": 7.3683
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0227,
+      "good": 1.0,
+      "ratio": 44.0529,
+      "suggested_scalar": 0.996,
+      "log_bad": -3.7854,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8409,
+      "good": 0.8372,
+      "ratio": 0.9956,
+      "suggested_scalar": -0.0012,
+      "log_bad": -0.1733,
+      "log_good": -0.1777
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.1364,
+      "good": 7.1163,
+      "ratio": 0.8746,
+      "suggested_scalar": -0.0352,
+      "log_bad": 2.0963,
+      "log_good": 1.9624
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 19.5718,
+      "good": 12.1103,
+      "ratio": 0.6188,
+      "suggested_scalar": -0.1263,
+      "log_bad": 2.9741,
+      "log_good": 2.4941
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 85.0,
+      "good": 77.0,
+      "ratio": 0.9059,
+      "suggested_scalar": -0.026,
+      "log_bad": 4.4427,
+      "log_good": 4.3438
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9509,
+      "good": 0.9325,
+      "ratio": 0.9806,
+      "suggested_scalar": -0.0051,
+      "log_bad": -0.0503,
+      "log_good": -0.0699
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 26.0,
+      "ratio": 0.8966,
+      "suggested_scalar": -0.0287,
+      "log_bad": 3.3673,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5931,
+      "good": 0.5438,
+      "ratio": 0.9169,
+      "suggested_scalar": -0.0228,
+      "log_bad": -0.5224,
+      "log_good": -0.6092
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.191,
+      "good": 0.1316,
+      "ratio": 0.689,
+      "suggested_scalar": -0.098,
+      "log_bad": -1.6555,
+      "log_good": -2.028
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4574,
+      "good": 2.1923,
+      "ratio": 0.8921,
+      "suggested_scalar": -0.03,
+      "log_bad": 0.8991,
+      "log_good": 0.785
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 356.0,
+      "good": 304.0,
+      "ratio": 0.8539,
+      "suggested_scalar": -0.0415,
+      "log_bad": 5.8749,
+      "log_good": 5.717
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 34.0,
+      "ratio": 34.0,
+      "suggested_scalar": 0.9279,
+      "log_bad": 0.0,
+      "log_good": 3.5264
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0307,
+      "good": 0.0294,
+      "ratio": 0.9577,
+      "suggested_scalar": -0.0114,
+      "log_bad": -3.4835,
+      "log_good": -3.5268
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9773,
+      "good": 5.9069,
+      "ratio": 0.9882,
+      "suggested_scalar": -0.0031,
+      "log_bad": 1.788,
+      "log_good": 1.7761
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 31.0,
+      "good": 30.0,
+      "ratio": 0.9677,
+      "suggested_scalar": -0.0086,
+      "log_bad": 3.434,
+      "log_good": 3.4012
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3981,
+      "good": 1.3689,
+      "ratio": 0.9791,
+      "suggested_scalar": -0.0056,
+      "log_bad": 0.3351,
+      "log_good": 0.314
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.1336,
+      "good": 6.1344,
+      "ratio": 1.0001,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8138,
+      "log_good": 1.8139
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.769,
+      "good": 0.7801,
+      "ratio": 1.0144,
+      "suggested_scalar": 0.0038,
+      "log_bad": -0.2627,
+      "log_good": -0.2483
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1852,
+      "good": 0.1569,
+      "ratio": 0.8472,
+      "suggested_scalar": -0.0436,
+      "log_bad": -1.6863,
+      "log_good": -1.8521
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.4817,
+      "good": 3.3258,
+      "ratio": 0.9552,
+      "suggested_scalar": -0.0121,
+      "log_bad": 1.2475,
+      "log_good": 1.2017
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 318.0,
+      "good": 283.0,
+      "ratio": 0.8899,
+      "suggested_scalar": -0.0307,
+      "log_bad": 5.7621,
+      "log_good": 5.6454
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.0885,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8007,
+      "good": 0.6999,
+      "ratio": 0.8741,
+      "suggested_scalar": -0.0354,
+      "log_bad": -0.2223,
+      "log_good": -0.3568
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 121.0,
+      "good": 120.0,
+      "ratio": 0.9917,
+      "suggested_scalar": -0.0022,
+      "log_bad": 4.7958,
+      "log_good": 4.7875
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 992.0,
+      "good": 852.0,
+      "ratio": 0.8589,
+      "suggested_scalar": -0.04,
+      "log_bad": 6.8997,
+      "log_good": 6.7476
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 164.0,
+      "good": 149.0,
+      "ratio": 0.9085,
+      "suggested_scalar": -0.0252,
+      "log_bad": 5.0999,
+      "log_good": 5.0039
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0028,
+      "good": 0.0033,
+      "ratio": 1.1786,
+      "suggested_scalar": 0.0432,
+      "log_bad": -5.8781,
+      "log_good": -5.7138
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2346,
+      "good": 0.2451,
+      "ratio": 1.0448,
+      "suggested_scalar": 0.0115,
+      "log_bad": -1.4499,
+      "log_good": -1.4061
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 59.0,
+      "good": 40.0,
+      "ratio": 0.678,
+      "suggested_scalar": -0.1023,
+      "log_bad": 4.0775,
+      "log_good": 3.6889
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 121.0,
+      "good": 120.0,
+      "ratio": 0.9917,
+      "suggested_scalar": -0.0022,
+      "log_bad": 4.7958,
+      "log_good": 4.7875
+    },
+    "brevity.mean_sample_size": {
+      "bad": 121.0,
+      "good": 120.0,
+      "ratio": 0.9917,
+      "suggested_scalar": -0.0022,
+      "log_bad": 4.7958,
+      "log_good": 4.7875
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 358.0,
+      "good": 306.0,
+      "ratio": 0.8547,
+      "suggested_scalar": -0.0413,
+      "log_bad": 5.8805,
+      "log_good": 5.7236
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 157.0,
+      "good": 135.0,
+      "ratio": 0.8599,
+      "suggested_scalar": -0.0397,
+      "log_bad": 5.0562,
+      "log_good": 4.9053
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 264.0,
+      "good": 248.0,
+      "ratio": 0.9394,
+      "suggested_scalar": -0.0165,
+      "log_bad": 5.5759,
+      "log_good": 5.5134
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0028,
+      "good": 0.0033,
+      "ratio": 1.1786,
+      "suggested_scalar": 0.0432,
+      "log_bad": -5.8781,
+      "log_good": -5.7138
+    },
+    "heaps.mean_k": {
+      "bad": 1.8706,
+      "good": 1.4689,
+      "ratio": 0.7853,
+      "suggested_scalar": -0.0636,
+      "log_bad": 0.6263,
+      "log_good": 0.3845
+    },
+    "halstead.mean_effort": {
+      "bad": 64180.4144,
+      "good": 43267.114,
+      "ratio": 0.6741,
+      "suggested_scalar": -0.1038,
+      "log_bad": 11.0695,
+      "log_good": 10.6751
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8865,
+      "good": 0.8882,
+      "ratio": 1.0019,
+      "suggested_scalar": 0.0005,
+      "log_bad": -0.1205,
+      "log_good": -0.1186
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 89.0,
+      "good": 94.0,
+      "ratio": 1.0562,
+      "suggested_scalar": 0.0144,
+      "log_bad": 4.4886,
+      "log_good": 4.5433
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 185.0,
+      "good": 155.0,
+      "ratio": 0.8378,
+      "suggested_scalar": -0.0466,
+      "log_bad": 5.2204,
+      "log_good": 5.0434
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5616,
+      "good": 0.6589,
+      "ratio": 1.1733,
+      "suggested_scalar": 0.042,
+      "log_bad": -0.577,
+      "log_good": -0.4172
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.7945,
+      "good": 6.6047,
+      "ratio": 0.9721,
+      "suggested_scalar": -0.0075,
+      "log_bad": 1.9161,
+      "log_good": 1.8878
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1852,
+      "good": 0.1569,
+      "ratio": 0.8472,
+      "suggested_scalar": -0.0436,
+      "log_bad": -1.6863,
+      "log_good": -1.8521
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.2698,
+      "good": 3.5608,
+      "ratio": 0.834,
+      "suggested_scalar": -0.0478,
+      "log_bad": 1.4516,
+      "log_good": 1.27
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 357.0,
+      "good": 305.0,
+      "ratio": 0.8543,
+      "suggested_scalar": -0.0414,
+      "log_bad": 5.8777,
+      "log_good": 5.7203
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 30.0,
+      "good": 19.0,
+      "ratio": 0.6333,
+      "suggested_scalar": -0.1202,
+      "log_bad": 3.4012,
+      "log_good": 2.9444
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3565.5786,
+      "good": 2403.7286,
+      "ratio": 0.6741,
+      "suggested_scalar": -0.1038,
+      "log_bad": 8.1791,
+      "log_good": 7.7848
+    },
+    "readability.mean_total_lines": {
+      "bad": 44.0,
+      "good": 43.0,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.006,
+      "log_bad": 3.7842,
+      "log_good": 3.7612
+    },
+    "indentation.mean_max_depth": {
+      "bad": 20.0,
+      "good": 16.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0587,
+      "log_bad": 2.9957,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2402.0424,
+      "good": 2099.6947,
+      "ratio": 0.8741,
+      "suggested_scalar": -0.0354,
+      "log_bad": 7.7841,
+      "log_good": 7.6495
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 774.0,
+      "good": 723.0,
+      "ratio": 0.9341,
+      "suggested_scalar": -0.0179,
+      "log_bad": 6.6516,
+      "log_good": 6.5834
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 41.9091,
+      "good": 35.6279,
+      "ratio": 0.8501,
+      "suggested_scalar": -0.0427,
+      "log_bad": 3.7355,
+      "log_good": 3.5731
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2234,
+      "good": 1.1964,
+      "ratio": 0.9779,
+      "suggested_scalar": -0.0059,
+      "log_bad": 0.2016,
+      "log_good": 0.1793
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.048,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 19.0,
+      "good": 21.0,
+      "ratio": 1.1053,
+      "suggested_scalar": 0.0263,
+      "log_bad": 2.9444,
+      "log_good": 3.0445
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 8.0,
+      "good": 10.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0587,
+      "log_bad": 2.0794,
+      "log_good": 2.3026
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9057,
+      "good": 0.9329,
+      "ratio": 1.03,
+      "suggested_scalar": 0.0078,
+      "log_bad": -0.099,
+      "log_good": -0.0695
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9713,
+      "good": 0.9838,
+      "ratio": 1.0129,
+      "suggested_scalar": 0.0034,
+      "log_bad": -0.0291,
+      "log_good": -0.0163
+    },
+    "halstead.mean_length": {
+      "bad": 349.0,
+      "good": 304.0,
+      "ratio": 0.8711,
+      "suggested_scalar": -0.0363,
+      "log_bad": 5.8551,
+      "log_good": 5.717
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 34.0,
+      "ratio": 34.0,
+      "suggested_scalar": 0.9279,
+      "log_bad": 0.0,
+      "log_good": 3.5264
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9189,
+      "good": 6.9069,
+      "ratio": 0.9983,
+      "suggested_scalar": -0.0005,
+      "log_bad": 1.9343,
+      "log_good": 1.9325
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0827,
+      "good": 0.0853,
+      "ratio": 1.0314,
+      "suggested_scalar": 0.0081,
+      "log_bad": -2.4925,
+      "log_good": -2.4616
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 26.7191,
+      "good": 20.6064,
+      "ratio": 0.7712,
+      "suggested_scalar": -0.0684,
+      "log_bad": 3.2854,
+      "log_good": 3.0256
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 82.0,
+      "good": 85.0,
+      "ratio": 1.0366,
+      "suggested_scalar": 0.0095,
+      "log_bad": 4.4067,
+      "log_good": 4.4427
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7765,
+      "good": 0.8387,
+      "ratio": 1.0801,
+      "suggested_scalar": 0.0203,
+      "log_bad": -0.253,
+      "log_good": -0.1759
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 44.0,
+      "good": 43.0,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.006,
+      "log_bad": 3.7842,
+      "log_good": 3.7612
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.input_parameters_before_output_parameters": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 10.0,
+      "good": 13.0,
+      "ratio": 1.3,
+      "suggested_scalar": 1.1092,
+      "log_bad": 2.3026,
+      "log_good": 2.5649
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8621,
+      "good": 0.8511,
+      "ratio": 0.9872,
+      "suggested_scalar": -0.0543,
+      "log_bad": -0.1484,
+      "log_good": -0.1612
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.3565,
+      "good": 4.6287,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.2562,
+      "log_bad": 1.4717,
+      "log_good": 1.5323
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 98.0,
+      "good": 96.0,
+      "ratio": 0.9796,
+      "suggested_scalar": -0.0872,
+      "log_bad": 4.585,
+      "log_good": 4.5643
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3928,
+      "good": 0.3519,
+      "ratio": 0.8959,
+      "suggested_scalar": -0.4649,
+      "log_bad": -0.9345,
+      "log_good": -1.0444
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 20.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.2169,
+      "log_bad": 2.9444,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6276,
+      "good": 0.5662,
+      "ratio": 0.9022,
+      "suggested_scalar": -0.4353,
+      "log_bad": -0.4659,
+      "log_good": -0.5688
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.8448,
+      "good": 4.6383,
+      "ratio": 0.6776,
+      "suggested_scalar": -1.6452,
+      "log_bad": 1.9235,
+      "log_good": 1.5343
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 561.0,
+      "good": 554.0,
+      "ratio": 0.9875,
+      "suggested_scalar": -0.0531,
+      "log_bad": 6.3297,
+      "log_good": 6.3172
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1724,
+      "good": 0.1915,
+      "ratio": 1.1108,
+      "suggested_scalar": 0.4442,
+      "log_bad": -1.7579,
+      "log_good": -1.6529
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1074,
+      "good": 1.1448,
+      "ratio": 1.0338,
+      "suggested_scalar": 0.1404,
+      "log_bad": 0.102,
+      "log_good": 0.1352
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 220.0,
+      "good": 213.0,
+      "ratio": 0.9682,
+      "suggested_scalar": -0.1367,
+      "log_bad": 5.3936,
+      "log_good": 5.3613
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.7184,
+      "good": 99.0892,
+      "ratio": 0.9742,
+      "suggested_scalar": -0.1107,
+      "log_bad": 4.6222,
+      "log_good": 4.596
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6304,
+      "good": 0.6311,
+      "ratio": 1.0011,
+      "suggested_scalar": 0.0047,
+      "log_bad": -0.4614,
+      "log_good": -0.4603
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.9277,
+      "good": 7.5954,
+      "ratio": 0.9581,
+      "suggested_scalar": -0.181,
+      "log_bad": 2.0704,
+      "log_good": 2.0275
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2322.0,
+      "good": 1960.0,
+      "ratio": 0.8441,
+      "suggested_scalar": -0.7165,
+      "log_bad": 7.7502,
+      "log_good": 7.5807
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1897,
+      "good": 0.2128,
+      "ratio": 1.1218,
+      "suggested_scalar": 0.4858,
+      "log_bad": -1.6623,
+      "log_good": -1.5474
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8448,
+      "good": 0.8085,
+      "ratio": 0.957,
+      "suggested_scalar": -0.1857,
+      "log_bad": -0.1687,
+      "log_good": -0.2126
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.3889,
+      "good": 12.5909,
+      "ratio": 1.212,
+      "suggested_scalar": 0.8127,
+      "log_bad": 2.3407,
+      "log_good": 2.533
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 59.7863,
+      "good": 37.2522,
+      "ratio": 0.6231,
+      "suggested_scalar": -2.0,
+      "log_bad": 4.0908,
+      "log_good": 3.6177
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 199.0,
+      "good": 192.0,
+      "ratio": 0.9648,
+      "suggested_scalar": -0.1514,
+      "log_bad": 5.2933,
+      "log_good": 5.2575
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9076,
+      "good": 0.9061,
+      "ratio": 0.9983,
+      "suggested_scalar": -0.007,
+      "log_bad": -0.097,
+      "log_good": -0.0986
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 24.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1781,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6701,
+      "good": 0.6286,
+      "ratio": 0.9381,
+      "suggested_scalar": -0.2703,
+      "log_bad": -0.4003,
+      "log_good": -0.4643
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4526,
+      "good": 0.4438,
+      "ratio": 0.9806,
+      "suggested_scalar": -0.083,
+      "log_bad": -0.7927,
+      "log_good": -0.8124
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0313,
+      "good": 2.6923,
+      "ratio": 0.8882,
+      "suggested_scalar": -0.5014,
+      "log_bad": 1.109,
+      "log_good": 0.9904
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 559.0,
+      "good": 552.0,
+      "ratio": 0.9875,
+      "suggested_scalar": -0.0533,
+      "log_bad": 6.3261,
+      "log_good": 6.3135
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0357,
+      "good": 0.0433,
+      "ratio": 1.2129,
+      "suggested_scalar": 0.816,
+      "log_bad": -3.3326,
+      "log_good": -3.1396
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.858,
+      "good": 5.8826,
+      "ratio": 1.0042,
+      "suggested_scalar": 0.0177,
+      "log_bad": 1.7678,
+      "log_good": 1.772
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.5368,
+      "good": 0.5496,
+      "ratio": 1.0238,
+      "suggested_scalar": 0.0996,
+      "log_bad": -0.6221,
+      "log_good": -0.5986
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7661,
+      "good": 5.6652,
+      "ratio": 0.9825,
+      "suggested_scalar": -0.0746,
+      "log_bad": 1.752,
+      "log_good": 1.7343
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7437,
+      "good": 0.7868,
+      "ratio": 1.058,
+      "suggested_scalar": 0.2382,
+      "log_bad": -0.2961,
+      "log_good": -0.2398
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.0938,
+      "good": 0.1132,
+      "ratio": 1.2068,
+      "suggested_scalar": 0.7948,
+      "log_bad": -2.3666,
+      "log_good": -2.1786
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.8156,
+      "good": 2.756,
+      "ratio": 0.9788,
+      "suggested_scalar": -0.0905,
+      "log_bad": 1.0352,
+      "log_good": 1.0138
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 373.0,
+      "good": 372.0,
+      "ratio": 0.9973,
+      "suggested_scalar": -0.0113,
+      "log_bad": 5.9216,
+      "log_good": 5.9189
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.2061,
+      "good": 1.1985,
+      "ratio": 0.9937,
+      "suggested_scalar": -0.0267,
+      "log_bad": 0.1874,
+      "log_good": 0.1811
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 99.0,
+      "good": 97.0,
+      "ratio": 0.9798,
+      "suggested_scalar": -0.0863,
+      "log_bad": 4.5951,
+      "log_good": 4.5747
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1051.0,
+      "good": 976.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.313,
+      "log_bad": 6.9575,
+      "log_good": 6.8835
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 258.0,
+      "good": 250.0,
+      "ratio": 0.969,
+      "suggested_scalar": -0.1332,
+      "log_bad": 5.553,
+      "log_good": 5.5215
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2103,
+      "good": 0.2437,
+      "ratio": 1.1588,
+      "suggested_scalar": 0.6232,
+      "log_bad": -1.5592,
+      "log_good": -1.4118
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 83.0,
+      "good": 84.0,
+      "ratio": 1.012,
+      "suggested_scalar": 0.0506,
+      "log_bad": 4.4188,
+      "log_good": 4.4308
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 99.0,
+      "good": 97.0,
+      "ratio": 0.9798,
+      "suggested_scalar": -0.0863,
+      "log_bad": 4.5951,
+      "log_good": 4.5747
+    },
+    "brevity.mean_sample_size": {
+      "bad": 99.0,
+      "good": 97.0,
+      "ratio": 0.9798,
+      "suggested_scalar": -0.0863,
+      "log_bad": 4.5951,
+      "log_good": 4.5747
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 561.0,
+      "good": 554.0,
+      "ratio": 0.9875,
+      "suggested_scalar": -0.0531,
+      "log_bad": 6.3297,
+      "log_good": 6.3172
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 289.0,
+      "good": 292.0,
+      "ratio": 1.0104,
+      "suggested_scalar": 0.0437,
+      "log_bad": 5.6664,
+      "log_good": 5.6768
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 290.0,
+      "good": 288.0,
+      "ratio": 0.9931,
+      "suggested_scalar": -0.0293,
+      "log_bad": 5.6699,
+      "log_good": 5.663
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.1253,
+      "good": 3.027,
+      "ratio": 1.4243,
+      "suggested_scalar": 1.4952,
+      "log_bad": 0.7539,
+      "log_good": 1.1076
+    },
+    "halstead.mean_effort": {
+      "bad": 151379.6013,
+      "good": 149807.8969,
+      "ratio": 0.9896,
+      "suggested_scalar": -0.0441,
+      "log_bad": 11.9275,
+      "log_good": 11.9171
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8698,
+      "good": 0.8584,
+      "ratio": 0.9869,
+      "suggested_scalar": -0.0558,
+      "log_bad": -0.1395,
+      "log_good": -0.1527
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 74.0,
+      "good": 72.0,
+      "ratio": 0.973,
+      "suggested_scalar": -0.1158,
+      "log_bad": 4.3041,
+      "log_good": 4.2767
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 289.0,
+      "good": 296.0,
+      "ratio": 1.0242,
+      "suggested_scalar": 0.1012,
+      "log_bad": 5.6664,
+      "log_good": 5.6904
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3,
+      "good": 0.3005,
+      "ratio": 1.0017,
+      "suggested_scalar": 0.007,
+      "log_bad": -1.204,
+      "log_good": -1.2023
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.7773,
+      "good": 4.5822,
+      "ratio": 0.9592,
+      "suggested_scalar": -0.1763,
+      "log_bad": 1.5639,
+      "log_good": 1.5222
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.0938,
+      "good": 0.1132,
+      "ratio": 1.2068,
+      "suggested_scalar": 0.7948,
+      "log_bad": -2.3666,
+      "log_good": -2.1786
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.1556,
+      "good": 5.0364,
+      "ratio": 1.212,
+      "suggested_scalar": 0.8127,
+      "log_bad": 1.4245,
+      "log_good": 1.6167
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 560.0,
+      "good": 553.0,
+      "ratio": 0.9875,
+      "suggested_scalar": -0.0532,
+      "log_bad": 6.3279,
+      "log_good": 6.3154
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 67.0,
+      "good": 65.0,
+      "ratio": 0.9701,
+      "suggested_scalar": -0.1281,
+      "log_bad": 4.2047,
+      "log_good": 4.1744
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 8409.9779,
+      "good": 8322.6609,
+      "ratio": 0.9896,
+      "suggested_scalar": -0.0441,
+      "log_bad": 9.0372,
+      "log_good": 9.0267
+    },
+    "readability.mean_total_lines": {
+      "bad": 54.0,
+      "good": 44.0,
+      "ratio": 0.8148,
+      "suggested_scalar": -0.8658,
+      "log_bad": 3.989,
+      "log_good": 3.7842
+    },
+    "indentation.mean_max_depth": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "halstead.mean_volume": {
+      "bad": 3618.2463,
+      "good": 3595.3895,
+      "ratio": 0.9937,
+      "suggested_scalar": -0.0268,
+      "log_bad": 8.1937,
+      "log_good": 8.1874
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 766.0,
+      "good": 728.0,
+      "ratio": 0.9504,
+      "suggested_scalar": -0.2151,
+      "log_bad": 6.6412,
+      "log_good": 6.5903
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 40.2593,
+      "good": 42.0455,
+      "ratio": 1.0444,
+      "suggested_scalar": 0.1835,
+      "log_bad": 3.6953,
+      "log_good": 3.7388
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1179,
+      "good": 1.1225,
+      "ratio": 1.0041,
+      "suggested_scalar": 0.0174,
+      "log_bad": 0.1115,
+      "log_good": 0.1156
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.7708,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 10.0,
+      "good": 9.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.4454,
+      "log_bad": 2.3026,
+      "log_good": 2.1972
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8204,
+      "good": 0.8253,
+      "ratio": 1.006,
+      "suggested_scalar": 0.0252,
+      "log_bad": -0.198,
+      "log_good": -0.192
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9423,
+      "good": 0.9258,
+      "ratio": 0.9825,
+      "suggested_scalar": -0.0747,
+      "log_bad": -0.0594,
+      "log_good": -0.0771
+    },
+    "halstead.mean_length": {
+      "bad": 547.0,
+      "good": 546.0,
+      "ratio": 0.9982,
+      "suggested_scalar": -0.0077,
+      "log_bad": 6.3044,
+      "log_good": 6.3026
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6294,
+      "good": 6.5999,
+      "ratio": 0.9956,
+      "suggested_scalar": -0.0189,
+      "log_bad": 1.8915,
+      "log_good": 1.8871
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1251,
+      "good": 0.1491,
+      "ratio": 1.1918,
+      "suggested_scalar": 0.742,
+      "log_bad": -2.0786,
+      "log_good": -1.9031
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 41.8378,
+      "good": 41.6667,
+      "ratio": 0.9959,
+      "suggested_scalar": -0.0173,
+      "log_bad": 3.7338,
+      "log_good": 3.7297
+    },
+    "branching.mean_branch_count": {
+      "bad": 11.0,
+      "good": 10.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.4029,
+      "log_bad": 2.3979,
+      "log_good": 2.3026
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 66.0,
+      "good": 64.0,
+      "ratio": 0.9697,
+      "suggested_scalar": -0.1301,
+      "log_bad": 4.1897,
+      "log_good": 4.1589
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7138,
+      "good": 0.7083,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.0327,
+      "log_bad": -0.3372,
+      "log_good": -0.3449
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 58.0,
+      "good": 47.0,
+      "ratio": 0.8103,
+      "suggested_scalar": -0.8891,
+      "log_bad": 4.0604,
+      "log_good": 3.8501
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.interface_named_with_er_suffix": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0049,
+      "good": 0.0087,
+      "ratio": 1.7755,
+      "suggested_scalar": 1.0147,
+      "log_bad": -5.3185,
+      "log_good": -4.7444
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 1.5,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.4055,
+      "log_good": 0.4055
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.84,
+      "good": 0.8462,
+      "ratio": 1.0074,
+      "suggested_scalar": 0.013,
+      "log_bad": -0.1744,
+      "log_good": -0.167
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0049,
+      "good": 0.0087,
+      "ratio": 1.7755,
+      "suggested_scalar": 1.0147,
+      "log_bad": -5.3185,
+      "log_good": -4.7444
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6451,
+      "good": 4.6555,
+      "ratio": 1.0022,
+      "suggested_scalar": 0.004,
+      "log_bad": 1.5358,
+      "log_good": 1.538
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 70.0,
+      "good": 75.0,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.1219,
+      "log_bad": 4.2485,
+      "log_good": 4.3175
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4574,
+      "good": 0.4756,
+      "ratio": 1.0398,
+      "suggested_scalar": 0.069,
+      "log_bad": -0.7822,
+      "log_good": -0.7432
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 17.0,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.1072,
+      "log_bad": 2.7726,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.726,
+      "good": 0.7208,
+      "ratio": 0.9928,
+      "suggested_scalar": -0.0127,
+      "log_bad": -0.3202,
+      "log_good": -0.3274
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.28,
+      "good": 0.2692,
+      "ratio": 0.9614,
+      "suggested_scalar": -0.0695,
+      "log_bad": -1.273,
+      "log_good": -1.3123
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 204.0,
+      "good": 231.0,
+      "ratio": 1.1324,
+      "suggested_scalar": 0.2197,
+      "log_bad": 5.3181,
+      "log_good": 5.4424
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.24,
+      "good": 0.2692,
+      "ratio": 1.1217,
+      "suggested_scalar": 0.2029,
+      "log_bad": -1.4271,
+      "log_good": -1.3123
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.7943,
+      "good": 0.8143,
+      "ratio": 1.0252,
+      "suggested_scalar": 0.044,
+      "log_bad": -0.2303,
+      "log_good": -0.2054
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 94.0,
+      "good": 108.0,
+      "ratio": 1.1489,
+      "suggested_scalar": 0.2454,
+      "log_bad": 4.5433,
+      "log_good": 4.6821
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 98.8209,
+      "good": 109.6171,
+      "ratio": 1.1093,
+      "suggested_scalar": 0.1833,
+      "log_bad": 4.5933,
+      "log_good": 4.697
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4187,
+      "good": 0.3826,
+      "ratio": 0.9138,
+      "suggested_scalar": -0.1594,
+      "log_bad": -0.8706,
+      "log_good": -0.9608
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 51.35,
+      "good": 16.5617,
+      "ratio": 0.3225,
+      "suggested_scalar": -2.0,
+      "log_bad": 3.9387,
+      "log_good": 2.8071
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1131.0,
+      "good": 1086.0,
+      "ratio": 0.9602,
+      "suggested_scalar": -0.0718,
+      "log_bad": 7.0309,
+      "log_good": 6.9903
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.04,
+      "good": 0.0385,
+      "ratio": 0.9625,
+      "suggested_scalar": -0.0676,
+      "log_bad": -3.2189,
+      "log_good": -3.2571
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.84,
+      "good": 0.8462,
+      "ratio": 1.0074,
+      "suggested_scalar": 0.013,
+      "log_bad": -0.1744,
+      "log_good": -0.167
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.16,
+      "good": 8.8846,
+      "ratio": 1.0888,
+      "suggested_scalar": 0.1504,
+      "log_bad": 2.0992,
+      "log_good": 2.1843
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.2016,
+      "good": 0.1967,
+      "ratio": 0.9757,
+      "suggested_scalar": -0.0435,
+      "log_bad": -1.6015,
+      "log_good": -1.6261
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 66.0,
+      "good": 75.0,
+      "ratio": 1.1364,
+      "suggested_scalar": 0.2259,
+      "log_bad": 4.1897,
+      "log_good": 4.3175
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9137,
+      "good": 0.893,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.0405,
+      "log_bad": -0.0903,
+      "log_good": -0.1132
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6198,
+      "good": 0.5727,
+      "ratio": 0.924,
+      "suggested_scalar": -0.1397,
+      "log_bad": -0.4784,
+      "log_good": -0.5574
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2178,
+      "good": 0.2009,
+      "ratio": 0.9224,
+      "suggested_scalar": -0.1428,
+      "log_bad": -1.5242,
+      "log_good": -1.6049
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6302,
+      "good": 2.3405,
+      "ratio": 0.8899,
+      "suggested_scalar": -0.2063,
+      "log_bad": 0.9671,
+      "log_good": 0.8504
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 202.0,
+      "good": 229.0,
+      "ratio": 1.1337,
+      "suggested_scalar": 0.2217,
+      "log_bad": 5.3083,
+      "log_good": 5.4337
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0147,
+      "good": 0.013,
+      "ratio": 0.8844,
+      "suggested_scalar": -0.2172,
+      "log_bad": -4.2199,
+      "log_good": -4.3428
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7004,
+      "good": 5.7004,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7405,
+      "log_good": 1.7405
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 28.0,
+      "good": 33.0,
+      "ratio": 1.1786,
+      "suggested_scalar": 0.2904,
+      "log_bad": 3.3322,
+      "log_good": 3.4965
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8787,
+      "good": 0.888,
+      "ratio": 1.0106,
+      "suggested_scalar": 0.0186,
+      "log_bad": -0.1293,
+      "log_good": -0.1188
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.674,
+      "good": 5.7753,
+      "ratio": 1.0179,
+      "suggested_scalar": 0.0313,
+      "log_bad": 1.7359,
+      "log_good": 1.7536
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8149,
+      "good": 0.8167,
+      "ratio": 1.0022,
+      "suggested_scalar": 0.0039,
+      "log_bad": -0.2047,
+      "log_good": -0.2025
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1935,
+      "good": 0.1875,
+      "ratio": 0.969,
+      "suggested_scalar": -0.0557,
+      "log_bad": -1.6425,
+      "log_good": -1.674
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 7.1659,
+      "good": 4.0696,
+      "ratio": 0.5679,
+      "suggested_scalar": -1.0,
+      "log_bad": 1.9693,
+      "log_good": 1.4035
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 178.0,
+      "good": 204.0,
+      "ratio": 1.1461,
+      "suggested_scalar": 0.241,
+      "log_bad": 5.1818,
+      "log_good": 5.3181
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.4086,
+      "good": 0.4651,
+      "ratio": 1.1383,
+      "suggested_scalar": 0.2289,
+      "log_bad": -0.895,
+      "log_good": -0.7655
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 71.0,
+      "good": 77.0,
+      "ratio": 1.0845,
+      "suggested_scalar": 0.1434,
+      "log_bad": 4.2627,
+      "log_good": 4.3438
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 749.0,
+      "good": 660.0,
+      "ratio": 0.8812,
+      "suggested_scalar": -0.2236,
+      "log_bad": 6.6187,
+      "log_good": 6.4922
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 113.0,
+      "good": 129.0,
+      "ratio": 1.1416,
+      "suggested_scalar": 0.2341,
+      "log_bad": 4.7274,
+      "log_good": 4.8598
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2451,
+      "good": 0.2381,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.0512,
+      "log_bad": -1.4061,
+      "log_good": -1.4351
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 35.0,
+      "good": 36.0,
+      "ratio": 1.0286,
+      "suggested_scalar": 0.0498,
+      "log_bad": 3.5553,
+      "log_good": 3.5835
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 71.0,
+      "good": 77.0,
+      "ratio": 1.0845,
+      "suggested_scalar": 0.1434,
+      "log_bad": 4.2627,
+      "log_good": 4.3438
+    },
+    "brevity.mean_sample_size": {
+      "bad": 71.0,
+      "good": 77.0,
+      "ratio": 1.0845,
+      "suggested_scalar": 0.1434,
+      "log_bad": 4.2627,
+      "log_good": 4.3438
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 204.0,
+      "good": 231.0,
+      "ratio": 1.1324,
+      "suggested_scalar": 0.2197,
+      "log_bad": 5.3181,
+      "log_good": 5.4424
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 81.0,
+      "good": 90.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.1862,
+      "log_bad": 4.3944,
+      "log_good": 4.4998
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 153.0,
+      "good": 178.0,
+      "ratio": 1.1634,
+      "suggested_scalar": 0.2675,
+      "log_bad": 5.0304,
+      "log_good": 5.1818
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.8057,
+      "good": 1.8524,
+      "ratio": 1.0259,
+      "suggested_scalar": 0.0451,
+      "log_bad": 0.5909,
+      "log_good": 0.6165
+    },
+    "halstead.mean_effort": {
+      "bad": 29683.242,
+      "good": 34997.6559,
+      "ratio": 1.179,
+      "suggested_scalar": 0.2911,
+      "log_bad": 10.2983,
+      "log_good": 10.463
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.9226,
+      "good": 0.9216,
+      "ratio": 0.9989,
+      "suggested_scalar": -0.0019,
+      "log_bad": -0.0806,
+      "log_good": -0.0816
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 49.0,
+      "good": 54.0,
+      "ratio": 1.102,
+      "suggested_scalar": 0.1717,
+      "log_bad": 3.8918,
+      "log_good": 3.989
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 87.0,
+      "good": 95.0,
+      "ratio": 1.092,
+      "suggested_scalar": 0.1555,
+      "log_bad": 4.4659,
+      "log_good": 4.5539
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4574,
+      "good": 0.4444,
+      "ratio": 0.9716,
+      "suggested_scalar": -0.051,
+      "log_bad": -0.7822,
+      "log_good": -0.811
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.9681,
+      "good": 6.1111,
+      "ratio": 0.7669,
+      "suggested_scalar": -0.469,
+      "log_bad": 2.0754,
+      "log_good": 1.8101
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1935,
+      "good": 0.1875,
+      "ratio": 0.969,
+      "suggested_scalar": -0.0557,
+      "log_bad": -1.6425,
+      "log_good": -1.674
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.8656,
+      "good": 3.5538,
+      "ratio": 0.6059,
+      "suggested_scalar": -0.8856,
+      "log_bad": 1.7691,
+      "log_good": 1.268
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 203.0,
+      "good": 230.0,
+      "ratio": 1.133,
+      "suggested_scalar": 0.2207,
+      "log_bad": 5.3132,
+      "log_good": 5.4381
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 20.0,
+      "good": 21.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0862,
+      "log_bad": 2.9957,
+      "log_good": 3.0445
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1649.069,
+      "good": 1944.3142,
+      "ratio": 1.179,
+      "suggested_scalar": 0.2911,
+      "log_bad": 7.408,
+      "log_good": 7.5727
+    },
+    "readability.mean_total_lines": {
+      "bad": 25.0,
+      "good": 26.0,
+      "ratio": 1.04,
+      "suggested_scalar": 0.0693,
+      "log_bad": 3.2189,
+      "log_good": 3.2581
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1225.8566,
+      "good": 1395.2554,
+      "ratio": 1.1382,
+      "suggested_scalar": 0.2288,
+      "log_bad": 7.1114,
+      "log_good": 7.2408
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 430.0,
+      "good": 464.0,
+      "ratio": 1.0791,
+      "suggested_scalar": 0.1345,
+      "log_bad": 6.0638,
+      "log_good": 6.1399
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 43.92,
+      "good": 40.4615,
+      "ratio": 0.9213,
+      "suggested_scalar": -0.145,
+      "log_bad": 3.7824,
+      "log_good": 3.7004
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1789,
+      "good": 1.0426,
+      "ratio": 0.8844,
+      "suggested_scalar": -0.2172,
+      "log_bad": 0.1646,
+      "log_good": 0.0417
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 12.0,
+      "good": 13.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.1415,
+      "log_bad": 2.4849,
+      "log_good": 2.5649
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 7.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.2725,
+      "log_bad": 1.7918,
+      "log_good": 1.9459
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8876,
+      "good": 0.8971,
+      "ratio": 1.0107,
+      "suggested_scalar": 0.0188,
+      "log_bad": -0.1192,
+      "log_good": -0.1086
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9771,
+      "good": 0.9764,
+      "ratio": 0.9993,
+      "suggested_scalar": -0.0013,
+      "log_bad": -0.0232,
+      "log_good": -0.0239
+    },
+    "halstead.mean_length": {
+      "bad": 200.0,
+      "good": 224.0,
+      "ratio": 1.12,
+      "suggested_scalar": 0.2003,
+      "log_bad": 5.2983,
+      "log_good": 5.4116
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.5,
+      "good": 4.5,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.5041,
+      "log_good": 1.5041
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.1497,
+      "good": 6.2668,
+      "ratio": 1.019,
+      "suggested_scalar": 0.0333,
+      "log_bad": 1.8164,
+      "log_good": 1.8353
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0717,
+      "good": 0.083,
+      "ratio": 1.1576,
+      "suggested_scalar": 0.2587,
+      "log_bad": -2.6353,
+      "log_good": -2.4889
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 24.2143,
+      "good": 25.0833,
+      "ratio": 1.0359,
+      "suggested_scalar": 0.0623,
+      "log_bad": 3.1869,
+      "log_good": 3.2222
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 43.0,
+      "good": 48.0,
+      "ratio": 1.1163,
+      "suggested_scalar": 0.1944,
+      "log_bad": 3.7612,
+      "log_good": 3.8712
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7712,
+      "good": 0.7978,
+      "ratio": 1.0345,
+      "suggested_scalar": 0.0599,
+      "log_bad": -0.2598,
+      "log_good": -0.2259
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 25.0,
+      "good": 26.0,
+      "ratio": 1.04,
+      "suggested_scalar": 0.0693,
+      "log_bad": 3.2189,
+      "log_good": 3.2581
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 28.0,
+      "good": 19.0,
+      "ratio": 0.6786,
+      "suggested_scalar": -0.6854,
+      "log_bad": 3.3322,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.switch_covers_all_union_members": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 11.0,
+      "good": 16.0,
+      "ratio": 1.4545,
+      "suggested_scalar": 0.2502,
+      "log_bad": 2.3979,
+      "log_good": 2.7726
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.1115,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.1046,
+      "good": 0.0916,
+      "ratio": 0.8757,
+      "suggested_scalar": -0.0886,
+      "log_bad": -2.2576,
+      "log_good": -2.3903
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7167,
+      "good": 0.6575,
+      "ratio": 0.9174,
+      "suggested_scalar": -0.0576,
+      "log_bad": -0.3331,
+      "log_good": -0.4193
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.1046,
+      "good": 0.0916,
+      "ratio": 0.8757,
+      "suggested_scalar": -0.0886,
+      "log_bad": -2.2576,
+      "log_good": -2.3903
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5419,
+      "good": 4.5076,
+      "ratio": 0.9924,
+      "suggested_scalar": -0.0051,
+      "log_bad": 1.5133,
+      "log_good": 1.5058
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 68.0,
+      "good": 69.0,
+      "ratio": 1.0147,
+      "suggested_scalar": 0.0097,
+      "log_bad": 4.2195,
+      "log_good": 4.2341
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4512,
+      "good": 0.3723,
+      "ratio": 0.8251,
+      "suggested_scalar": -0.1283,
+      "log_bad": -0.7958,
+      "log_good": -0.9881
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 15.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.0836,
+      "log_bad": 2.8332,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6327,
+      "good": 0.5664,
+      "ratio": 0.8952,
+      "suggested_scalar": -0.0739,
+      "log_bad": -0.4578,
+      "log_good": -0.5685
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.8333,
+      "good": 3.0959,
+      "ratio": 1.0927,
+      "suggested_scalar": 0.0592,
+      "log_bad": 1.0414,
+      "log_good": 1.1301
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 325.0,
+      "good": 393.0,
+      "ratio": 1.2092,
+      "suggested_scalar": 0.1268,
+      "log_bad": 5.7838,
+      "log_good": 5.9738
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.05,
+      "good": 1.0,
+      "ratio": 20.0,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.9957,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0408,
+      "good": 1.1329,
+      "ratio": 1.0885,
+      "suggested_scalar": 0.0566,
+      "log_bad": 0.04,
+      "log_good": 0.1248
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 82.0,
+      "good": 94.0,
+      "ratio": 1.1463,
+      "suggested_scalar": 0.0912,
+      "log_bad": 4.4067,
+      "log_good": 4.5433
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 99.2128,
+      "good": 98.8252,
+      "ratio": 0.9961,
+      "suggested_scalar": -0.0026,
+      "log_bad": 4.5973,
+      "log_good": 4.5934
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6759,
+      "good": 0.7066,
+      "ratio": 1.0454,
+      "suggested_scalar": 0.0297,
+      "log_bad": -0.3917,
+      "log_good": -0.3473
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.9323,
+      "good": 10.877,
+      "ratio": 0.9116,
+      "suggested_scalar": -0.0618,
+      "log_bad": 2.4792,
+      "log_good": 2.3867
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1541.0,
+      "good": 1833.0,
+      "ratio": 1.1895,
+      "suggested_scalar": 0.1158,
+      "log_bad": 7.3402,
+      "log_good": 7.5137
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.25,
+      "good": 0.2877,
+      "ratio": 1.1508,
+      "suggested_scalar": 0.0938,
+      "log_bad": -1.3863,
+      "log_good": -1.2458
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6833,
+      "good": 0.6438,
+      "ratio": 0.9422,
+      "suggested_scalar": -0.0398,
+      "log_bad": -0.3808,
+      "log_good": -0.4404
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.4167,
+      "good": 5.3836,
+      "ratio": 0.9939,
+      "suggested_scalar": -0.0041,
+      "log_bad": 1.6895,
+      "log_good": 1.6834
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 4.1722,
+      "good": 4.4977,
+      "ratio": 1.078,
+      "suggested_scalar": 0.0502,
+      "log_bad": 1.4284,
+      "log_good": 1.5036
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 57.0,
+      "good": 60.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0342,
+      "log_bad": 4.0431,
+      "log_good": 4.0943
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9658,
+      "good": 0.9524,
+      "ratio": 0.9861,
+      "suggested_scalar": -0.0093,
+      "log_bad": -0.0348,
+      "log_good": -0.0488
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6768,
+      "good": 0.7147,
+      "ratio": 1.056,
+      "suggested_scalar": 0.0364,
+      "log_bad": -0.3904,
+      "log_good": -0.3359
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5015,
+      "good": 0.5473,
+      "ratio": 1.0913,
+      "suggested_scalar": 0.0583,
+      "log_bad": -0.6902,
+      "log_good": -0.6028
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0944,
+      "good": 3.5048,
+      "ratio": 1.1326,
+      "suggested_scalar": 0.0831,
+      "log_bad": 1.1296,
+      "log_good": 1.2541
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 323.0,
+      "good": 391.0,
+      "ratio": 1.2105,
+      "suggested_scalar": 0.1276,
+      "log_bad": 5.7777,
+      "log_good": 5.9687
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 16.0,
+      "good": 19.0,
+      "ratio": 1.1875,
+      "suggested_scalar": 0.1147,
+      "log_bad": 2.7726,
+      "log_good": 2.9444
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0277,
+      "good": 0.0356,
+      "ratio": 1.2852,
+      "suggested_scalar": 0.1675,
+      "log_bad": -3.5863,
+      "log_good": -3.3354
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7004,
+      "good": 5.6147,
+      "ratio": 0.985,
+      "suggested_scalar": -0.0101,
+      "log_bad": 1.7405,
+      "log_good": 1.7254
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 14.0,
+      "good": 18.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.1678,
+      "log_bad": 2.6391,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1889,
+      "good": 1.3049,
+      "ratio": 1.0976,
+      "suggested_scalar": 0.0622,
+      "log_bad": 0.173,
+      "log_good": 0.2661
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.017,
+      "good": 4.938,
+      "ratio": 0.9843,
+      "suggested_scalar": -0.0106,
+      "log_bad": 1.6128,
+      "log_good": 1.597
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7968,
+      "good": 0.8028,
+      "ratio": 1.0075,
+      "suggested_scalar": 0.005,
+      "log_bad": -0.2272,
+      "log_good": -0.2196
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.0909,
+      "good": 0.0875,
+      "ratio": 0.9626,
+      "suggested_scalar": -0.0255,
+      "log_bad": -2.398,
+      "log_good": -2.4361
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.4543,
+      "good": 3.298,
+      "ratio": 0.9548,
+      "suggested_scalar": -0.0309,
+      "log_bad": 1.2396,
+      "log_good": 1.1933
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 210.0,
+      "good": 234.0,
+      "ratio": 1.1143,
+      "suggested_scalar": 0.0722,
+      "log_bad": 5.3471,
+      "log_good": 5.4553
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 9.0,
+      "good": 16.0,
+      "ratio": 1.7778,
+      "suggested_scalar": 0.3841,
+      "log_bad": 2.1972,
+      "log_good": 2.7726
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5053,
+      "good": 0.6251,
+      "ratio": 1.2371,
+      "suggested_scalar": 0.142,
+      "log_bad": -0.6826,
+      "log_good": -0.4698
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 71.0,
+      "good": 69.0,
+      "ratio": 0.9718,
+      "suggested_scalar": -0.0191,
+      "log_bad": 4.2627,
+      "log_good": 4.2341
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 695.0,
+      "good": 809.0,
+      "ratio": 1.164,
+      "suggested_scalar": 0.1014,
+      "log_bad": 6.5439,
+      "log_good": 6.6958
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 99.0,
+      "good": 112.0,
+      "ratio": 1.1313,
+      "suggested_scalar": 0.0824,
+      "log_bad": 4.5951,
+      "log_good": 4.7185
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2215,
+      "good": 0.2392,
+      "ratio": 1.0799,
+      "suggested_scalar": 0.0513,
+      "log_bad": -1.5073,
+      "log_good": -1.4305
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 53.0,
+      "good": 55.0,
+      "ratio": 1.0377,
+      "suggested_scalar": 0.0247,
+      "log_bad": 3.9703,
+      "log_good": 4.0073
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.149,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 71.0,
+      "good": 69.0,
+      "ratio": 0.9718,
+      "suggested_scalar": -0.0191,
+      "log_bad": 4.2627,
+      "log_good": 4.2341
+    },
+    "brevity.mean_sample_size": {
+      "bad": 71.0,
+      "good": 69.0,
+      "ratio": 0.9718,
+      "suggested_scalar": -0.0191,
+      "log_bad": 4.2627,
+      "log_good": 4.2341
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 325.0,
+      "good": 393.0,
+      "ratio": 1.2092,
+      "suggested_scalar": 0.1268,
+      "log_bad": 5.7838,
+      "log_good": 5.9738
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 185.0,
+      "good": 228.0,
+      "ratio": 1.2324,
+      "suggested_scalar": 0.1395,
+      "log_bad": 5.2204,
+      "log_good": 5.4293
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 158.0,
+      "good": 170.0,
+      "ratio": 1.0759,
+      "suggested_scalar": 0.0489,
+      "log_bad": 5.0626,
+      "log_good": 5.1358
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.7923,
+      "good": 2.4317,
+      "ratio": 1.3567,
+      "suggested_scalar": 0.2037,
+      "log_bad": 0.5835,
+      "log_good": 0.8886
+    },
+    "halstead.mean_effort": {
+      "bad": 29093.6621,
+      "good": 39906.7459,
+      "ratio": 1.3717,
+      "suggested_scalar": 0.211,
+      "log_bad": 10.2783,
+      "log_good": 10.5943
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8158,
+      "good": 0.8084,
+      "ratio": 0.9909,
+      "suggested_scalar": -0.0061,
+      "log_bad": -0.2036,
+      "log_good": -0.2127
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 49.0,
+      "good": 50.0,
+      "ratio": 1.0204,
+      "suggested_scalar": 0.0135,
+      "log_bad": 3.8918,
+      "log_good": 3.912
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 150.0,
+      "good": 195.0,
+      "ratio": 1.3,
+      "suggested_scalar": 0.1752,
+      "log_bad": 5.0106,
+      "log_good": 5.273
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4512,
+      "good": 0.3723,
+      "ratio": 0.8251,
+      "suggested_scalar": -0.1283,
+      "log_bad": -0.7958,
+      "log_good": -0.9881
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.4756,
+      "good": 8.6064,
+      "ratio": 1.0154,
+      "suggested_scalar": 0.0102,
+      "log_bad": 2.1372,
+      "log_good": 2.1525
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.0909,
+      "good": 0.0875,
+      "ratio": 0.9626,
+      "suggested_scalar": -0.0255,
+      "log_bad": -2.398,
+      "log_good": -2.4361
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.7381,
+      "good": 4.5777,
+      "ratio": 0.9661,
+      "suggested_scalar": -0.023,
+      "log_bad": 1.5556,
+      "log_good": 1.5212
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 324.0,
+      "good": 392.0,
+      "ratio": 1.2099,
+      "suggested_scalar": 0.1272,
+      "log_bad": 5.7807,
+      "log_good": 5.9713
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.341,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 49.0,
+      "good": 57.0,
+      "ratio": 1.1633,
+      "suggested_scalar": 0.101,
+      "log_bad": 3.8918,
+      "log_good": 4.0431
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1616.3146,
+      "good": 2217.0414,
+      "ratio": 1.3717,
+      "suggested_scalar": 0.211,
+      "log_bad": 7.3879,
+      "log_good": 7.7039
+    },
+    "readability.mean_total_lines": {
+      "bad": 60.0,
+      "good": 73.0,
+      "ratio": 1.2167,
+      "suggested_scalar": 0.1309,
+      "log_bad": 4.0943,
+      "log_good": 4.2905
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 1515.7782,
+      "good": 1875.317,
+      "ratio": 1.2372,
+      "suggested_scalar": 0.1421,
+      "log_bad": 7.3237,
+      "log_good": 7.5365
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 498.0,
+      "good": 523.0,
+      "ratio": 1.0502,
+      "suggested_scalar": 0.0327,
+      "log_bad": 6.2106,
+      "log_good": 6.2596
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 24.55,
+      "good": 24.0137,
+      "ratio": 0.9782,
+      "suggested_scalar": -0.0147,
+      "log_bad": 3.2007,
+      "log_good": 3.1786
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2071,
+      "good": 1.2121,
+      "ratio": 1.0041,
+      "suggested_scalar": 0.0028,
+      "log_bad": 0.1882,
+      "log_good": 0.1924
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.1921,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.7335,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7667,
+      "good": 0.7564,
+      "ratio": 0.9866,
+      "suggested_scalar": -0.009,
+      "log_bad": -0.2657,
+      "log_good": -0.2792
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9748,
+      "good": 0.9268,
+      "ratio": 0.9508,
+      "suggested_scalar": -0.0337,
+      "log_bad": -0.0255,
+      "log_good": -0.076
+    },
+    "halstead.mean_length": {
+      "bad": 249.0,
+      "good": 307.0,
+      "ratio": 1.2329,
+      "suggested_scalar": 0.1398,
+      "log_bad": 5.5175,
+      "log_good": 5.7268
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 12.75,
+      "good": 13.0,
+      "ratio": 1.0196,
+      "suggested_scalar": 0.013,
+      "log_bad": 2.5455,
+      "log_good": 2.5649
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.1497,
+      "good": 6.1085,
+      "ratio": 0.9933,
+      "suggested_scalar": -0.0045,
+      "log_bad": 1.8164,
+      "log_good": 1.8097
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1202,
+      "good": 0.1244,
+      "ratio": 1.0349,
+      "suggested_scalar": 0.0229,
+      "log_bad": -2.1186,
+      "log_good": -2.0843
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 19.1939,
+      "good": 21.28,
+      "ratio": 1.1087,
+      "suggested_scalar": 0.0689,
+      "log_bad": 2.9546,
+      "log_good": 3.0578
+    },
+    "branching.mean_branch_count": {
+      "bad": 15.0,
+      "good": 21.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.2246,
+      "log_bad": 2.7081,
+      "log_good": 3.0445
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 37.0,
+      "good": 35.0,
+      "ratio": 0.9459,
+      "suggested_scalar": -0.0371,
+      "log_bad": 3.6109,
+      "log_good": 3.5553
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6646,
+      "good": 0.6765,
+      "ratio": 1.0179,
+      "suggested_scalar": 0.0118,
+      "log_bad": -0.4086,
+      "log_good": -0.3908
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 60.0,
+      "good": 73.0,
+      "ratio": 1.2167,
+      "suggested_scalar": 0.1309,
+      "log_bad": 4.0943,
+      "log_good": 4.2905
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.nesting_depth_under_4": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 24.0,
+      "good": 47.0,
+      "ratio": 1.9583,
+      "suggested_scalar": 0.1999,
+      "log_bad": 3.1781,
+      "log_good": 3.8501
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0354,
+      "good": 0.0249,
+      "ratio": 0.7034,
+      "suggested_scalar": -0.1046,
+      "log_bad": -3.341,
+      "log_good": -3.6929
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9298,
+      "good": 0.9211,
+      "ratio": 0.9906,
+      "suggested_scalar": -0.0028,
+      "log_bad": -0.0728,
+      "log_good": -0.0822
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0354,
+      "good": 0.0249,
+      "ratio": 0.7034,
+      "suggested_scalar": -0.1046,
+      "log_bad": -3.341,
+      "log_good": -3.6929
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 3.6283,
+      "good": 4.6146,
+      "ratio": 1.2718,
+      "suggested_scalar": 0.0715,
+      "log_bad": 1.2888,
+      "log_good": 1.5292
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 71.0,
+      "good": 76.0,
+      "ratio": 1.0704,
+      "suggested_scalar": 0.0202,
+      "log_bad": 4.2627,
+      "log_good": 4.3307
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3404,
+      "good": 0.3056,
+      "ratio": 0.8978,
+      "suggested_scalar": -0.0321,
+      "log_bad": -1.0776,
+      "log_good": -1.1855
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5549,
+      "good": 0.4748,
+      "ratio": 0.8556,
+      "suggested_scalar": -0.0464,
+      "log_bad": -0.589,
+      "log_good": -0.7449
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 11.2281,
+      "good": 3.2895,
+      "ratio": 0.293,
+      "suggested_scalar": -0.3651,
+      "log_bad": 2.4184,
+      "log_good": 1.1907
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 339.0,
+      "good": 482.0,
+      "ratio": 1.4218,
+      "suggested_scalar": 0.1047,
+      "log_bad": 5.826,
+      "log_good": 6.1779
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2061,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0012,
+      "good": 1.0,
+      "ratio": 833.3333,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.7254,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0035,
+      "good": 0.0018,
+      "ratio": 0.5143,
+      "suggested_scalar": -0.1977,
+      "log_bad": -5.655,
+      "log_good": -6.32
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0689,
+      "good": 1.1625,
+      "ratio": 1.0876,
+      "suggested_scalar": 0.025,
+      "log_bad": 0.0666,
+      "log_good": 0.1506
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 94.0,
+      "good": 131.0,
+      "ratio": 1.3936,
+      "suggested_scalar": 0.0987,
+      "log_bad": 4.5433,
+      "log_good": 4.8752
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 114.0966,
+      "good": 100.6088,
+      "ratio": 0.8818,
+      "suggested_scalar": -0.0374,
+      "log_bad": 4.737,
+      "log_good": 4.6112
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6568,
+      "good": 0.7859,
+      "ratio": 1.1966,
+      "suggested_scalar": 0.0534,
+      "log_bad": -0.4204,
+      "log_good": -0.2409
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 5.2703,
+      "good": 18.2773,
+      "ratio": 3.468,
+      "suggested_scalar": 0.3698,
+      "log_bad": 1.6621,
+      "log_good": 2.9057
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1692.0,
+      "good": 1653.0,
+      "ratio": 0.977,
+      "suggested_scalar": -0.0069,
+      "log_bad": 7.4337,
+      "log_good": 7.4103
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.3158,
+      "good": 0.1579,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2061,
+      "log_bad": -1.1526,
+      "log_good": -1.8458
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6667,
+      "good": 0.8684,
+      "ratio": 1.3025,
+      "suggested_scalar": 0.0786,
+      "log_bad": -0.4054,
+      "log_good": -0.1411
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.9474,
+      "good": 12.6842,
+      "ratio": 2.1327,
+      "suggested_scalar": 0.2252,
+      "log_bad": 1.783,
+      "log_good": 2.5404
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 3.0,
+      "good": 8.0,
+      "ratio": 2.6667,
+      "suggested_scalar": 0.2917,
+      "log_bad": 1.0986,
+      "log_good": 2.0794
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 48.6673,
+      "good": 6.3636,
+      "ratio": 0.1308,
+      "suggested_scalar": -0.605,
+      "log_bad": 3.885,
+      "log_good": 1.8506
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 86.0,
+      "good": 121.0,
+      "ratio": 1.407,
+      "suggested_scalar": 0.1015,
+      "log_bad": 4.4543,
+      "log_good": 4.7958
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.8948,
+      "good": 0.9429,
+      "ratio": 1.0538,
+      "suggested_scalar": 0.0156,
+      "log_bad": -0.1112,
+      "log_good": -0.0588
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 27.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.0229,
+      "log_bad": 3.2189,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.7199,
+      "good": 0.7018,
+      "ratio": 0.9749,
+      "suggested_scalar": -0.0076,
+      "log_bad": -0.3286,
+      "log_good": -0.3541
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4985,
+      "good": 0.5813,
+      "ratio": 1.1661,
+      "suggested_scalar": 0.0457,
+      "log_bad": -0.6962,
+      "log_good": -0.5425
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.5696,
+      "good": 3.3529,
+      "ratio": 0.9393,
+      "suggested_scalar": -0.0186,
+      "log_bad": 1.2725,
+      "log_good": 1.2098
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 337.0,
+      "good": 480.0,
+      "ratio": 1.4243,
+      "suggested_scalar": 0.1052,
+      "log_bad": 5.8201,
+      "log_good": 6.1738
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 28.0,
+      "good": 9.0,
+      "ratio": 0.3214,
+      "suggested_scalar": -0.3375,
+      "log_bad": 3.3322,
+      "log_good": 2.1972
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0029,
+      "good": 0.056,
+      "ratio": 19.3103,
+      "suggested_scalar": 0.8804,
+      "log_bad": -5.843,
+      "log_good": -2.8824
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.5546,
+      "good": 5.5236,
+      "ratio": 0.9944,
+      "suggested_scalar": -0.0017,
+      "log_bad": 1.7146,
+      "log_good": 1.709
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 5.0,
+      "good": 2.0,
+      "ratio": 0.4,
+      "suggested_scalar": -0.2725,
+      "log_bad": 1.6094,
+      "log_good": 0.6931
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.5011,
+      "good": 0.4442,
+      "ratio": 0.8864,
+      "suggested_scalar": -0.0358,
+      "log_bad": -0.6909,
+      "log_good": -0.8115
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.2892,
+      "good": 5.0829,
+      "ratio": 0.961,
+      "suggested_scalar": -0.0118,
+      "log_bad": 1.6657,
+      "log_good": 1.6259
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.6532,
+      "good": 0.8354,
+      "ratio": 1.2789,
+      "suggested_scalar": 0.0732,
+      "log_bad": -0.4259,
+      "log_good": -0.1798
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.0339,
+      "good": 0.2245,
+      "ratio": 6.6224,
+      "suggested_scalar": 0.5622,
+      "log_bad": -3.3843,
+      "log_good": -1.4939
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.2957,
+      "good": 4.2752,
+      "ratio": 1.8623,
+      "suggested_scalar": 0.1849,
+      "log_bad": 0.831,
+      "log_good": 1.4528
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 212.0,
+      "good": 267.0,
+      "ratio": 1.2594,
+      "suggested_scalar": 0.0686,
+      "log_bad": 5.3566,
+      "log_good": 5.5872
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 24.0,
+      "ratio": 24.0,
+      "suggested_scalar": 0.9451,
+      "log_bad": 0.0,
+      "log_good": 3.1781
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.576,
+      "good": 0.9205,
+      "ratio": 1.5981,
+      "suggested_scalar": 0.1394,
+      "log_bad": -0.5516,
+      "log_good": -0.0828
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 65.0,
+      "good": 69.0,
+      "ratio": 1.0615,
+      "suggested_scalar": 0.0178,
+      "log_bad": 4.1744,
+      "log_good": 4.2341
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 514.0,
+      "good": 844.0,
+      "ratio": 1.642,
+      "suggested_scalar": 0.1475,
+      "log_bad": 6.2422,
+      "log_good": 6.7382
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 93.0,
+      "good": 128.0,
+      "ratio": 1.3763,
+      "suggested_scalar": 0.095,
+      "log_bad": 4.5326,
+      "log_good": 4.852
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0383,
+      "good": 1.0,
+      "ratio": 26.1097,
+      "suggested_scalar": 0.9701,
+      "log_bad": -3.2623,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1947,
+      "good": 0.2676,
+      "ratio": 1.3744,
+      "suggested_scalar": 0.0946,
+      "log_bad": -1.6363,
+      "log_good": -1.3183
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 49.0,
+      "good": 79.0,
+      "ratio": 1.6122,
+      "suggested_scalar": 0.142,
+      "log_bad": 3.8918,
+      "log_good": 4.3694
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 21.0,
+      "ratio": 7.0,
+      "suggested_scalar": 0.5787,
+      "log_bad": 1.0986,
+      "log_good": 3.0445
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 65.0,
+      "good": 69.0,
+      "ratio": 1.0615,
+      "suggested_scalar": 0.0178,
+      "log_bad": 4.1744,
+      "log_good": 4.2341
+    },
+    "brevity.mean_sample_size": {
+      "bad": 65.0,
+      "good": 69.0,
+      "ratio": 1.0615,
+      "suggested_scalar": 0.0178,
+      "log_bad": 4.1744,
+      "log_good": 4.2341
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 339.0,
+      "good": 482.0,
+      "ratio": 1.4218,
+      "suggested_scalar": 0.1047,
+      "log_bad": 5.826,
+      "log_good": 6.1779
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 175.0,
+      "good": 276.0,
+      "ratio": 1.5771,
+      "suggested_scalar": 0.1355,
+      "log_bad": 5.1648,
+      "log_good": 5.6204
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 165.0,
+      "good": 182.0,
+      "ratio": 1.103,
+      "suggested_scalar": 0.0292,
+      "log_bad": 5.1059,
+      "log_good": 5.204
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.5209,
+      "good": 3.3498,
+      "ratio": 1.3288,
+      "suggested_scalar": 0.0845,
+      "log_bad": 0.9246,
+      "log_good": 1.2089
+    },
+    "halstead.mean_effort": {
+      "bad": 43671.5602,
+      "good": 97388.1038,
+      "ratio": 2.23,
+      "suggested_scalar": 0.2385,
+      "log_bad": 10.6845,
+      "log_good": 11.4865
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8783,
+      "good": 0.8321,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.0161,
+      "log_bad": -0.1298,
+      "log_good": -0.1838
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 46.0,
+      "good": 49.0,
+      "ratio": 1.0652,
+      "suggested_scalar": 0.0188,
+      "log_bad": 3.8286,
+      "log_good": 3.8918
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 188.0,
+      "good": 314.0,
+      "ratio": 1.6702,
+      "suggested_scalar": 0.1525,
+      "log_bad": 5.2364,
+      "log_good": 5.7494
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3404,
+      "good": 0.2824,
+      "ratio": 0.8296,
+      "suggested_scalar": -0.0555,
+      "log_bad": -1.0776,
+      "log_good": -1.2644
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.4681,
+      "good": 6.4427,
+      "ratio": 1.1782,
+      "suggested_scalar": 0.0488,
+      "log_bad": 1.6989,
+      "log_good": 1.8629
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.0339,
+      "good": 0.2245,
+      "ratio": 6.6224,
+      "suggested_scalar": 0.5622,
+      "log_bad": -3.3843,
+      "log_good": -1.4939
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.3789,
+      "good": 5.0737,
+      "ratio": 2.1328,
+      "suggested_scalar": 0.2252,
+      "log_bad": 0.8666,
+      "log_good": 1.6241
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 338.0,
+      "good": 481.0,
+      "ratio": 1.4231,
+      "suggested_scalar": 0.1049,
+      "log_bad": 5.823,
+      "log_good": 6.1759
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 9.0,
+      "ratio": 1.8,
+      "suggested_scalar": 0.1748,
+      "log_bad": 1.6094,
+      "log_good": 2.1972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 43.0,
+      "good": 66.0,
+      "ratio": 1.5349,
+      "suggested_scalar": 0.1274,
+      "log_bad": 3.7612,
+      "log_good": 4.1897
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2426.1978,
+      "good": 5410.4502,
+      "ratio": 2.23,
+      "suggested_scalar": 0.2385,
+      "log_bad": 7.7941,
+      "log_good": 8.5961
+    },
+    "readability.mean_total_lines": {
+      "bad": 57.0,
+      "good": 38.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1206,
+      "log_bad": 4.0431,
+      "log_good": 3.6376
+    },
+    "indentation.mean_max_depth": {
+      "bad": 26.0,
+      "good": 9.0,
+      "ratio": 0.3462,
+      "suggested_scalar": -0.3155,
+      "log_bad": 3.2581,
+      "log_good": 2.1972
+    },
+    "halstead.mean_volume": {
+      "bad": 1728.0789,
+      "good": 2761.584,
+      "ratio": 1.5981,
+      "suggested_scalar": 0.1394,
+      "log_bad": 7.4548,
+      "log_good": 7.9236
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 474.0,
+      "good": 493.0,
+      "ratio": 1.0401,
+      "suggested_scalar": 0.0117,
+      "log_bad": 6.1612,
+      "log_good": 6.2005
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 28.6491,
+      "good": 42.2105,
+      "ratio": 1.4734,
+      "suggested_scalar": 0.1152,
+      "log_bad": 3.3551,
+      "log_good": 3.7427
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0248,
+      "good": 1.1034,
+      "ratio": 1.0767,
+      "suggested_scalar": 0.022,
+      "log_bad": 0.0245,
+      "log_good": 0.0984
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2061,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 14.0,
+      "good": 6.0,
+      "ratio": 0.4286,
+      "suggested_scalar": -0.252,
+      "log_bad": 2.6391,
+      "log_good": 1.7918
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7972,
+      "good": 0.7528,
+      "ratio": 0.9443,
+      "suggested_scalar": -0.017,
+      "log_bad": -0.2266,
+      "log_good": -0.284
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9856,
+      "good": 0.9836,
+      "ratio": 0.998,
+      "suggested_scalar": -0.0006,
+      "log_bad": -0.0145,
+      "log_good": -0.0165
+    },
+    "halstead.mean_length": {
+      "bad": 281.0,
+      "good": 442.0,
+      "ratio": 1.573,
+      "suggested_scalar": 0.1347,
+      "log_bad": 5.6384,
+      "log_good": 6.0913
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 19.3333,
+      "good": 2.2857,
+      "ratio": 0.1182,
+      "suggested_scalar": -0.6349,
+      "log_bad": 2.9618,
+      "log_good": 0.8267
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.0224,
+      "good": 6.1085,
+      "ratio": 1.0143,
+      "suggested_scalar": 0.0042,
+      "log_bad": 1.7955,
+      "log_good": 1.8097
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1034,
+      "good": 0.167,
+      "ratio": 1.6151,
+      "suggested_scalar": 0.1426,
+      "log_bad": -2.2692,
+      "log_good": -1.7898
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.2717,
+      "good": 35.2653,
+      "ratio": 1.3954,
+      "suggested_scalar": 0.0991,
+      "log_bad": 3.2297,
+      "log_good": 3.5629
+    },
+    "branching.mean_branch_count": {
+      "bad": 18.0,
+      "good": 6.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.3267,
+      "log_bad": 2.8904,
+      "log_good": 1.7918
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 32.0,
+      "good": 37.0,
+      "ratio": 1.1563,
+      "suggested_scalar": 0.0432,
+      "log_bad": 3.4657,
+      "log_good": 3.6109
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.703,
+      "good": 0.5659,
+      "ratio": 0.805,
+      "suggested_scalar": -0.0645,
+      "log_bad": -0.3524,
+      "log_good": -0.5693
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 57.0,
+      "good": 38.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1206,
+      "log_bad": 4.0431,
+      "log_good": 3.6376
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.mutating_method_uses_imperative_verb": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 27.0,
+      "good": 25.0,
+      "ratio": 0.9259,
+      "suggested_scalar": -0.0367,
+      "log_bad": 3.2958,
+      "log_good": 3.2189
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0151,
+      "good": 1.0,
+      "ratio": 66.2252,
+      "suggested_scalar": 2.0,
+      "log_bad": -4.1931,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 1.5,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.4055,
+      "log_good": 0.4055
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8333,
+      "good": 0.7727,
+      "ratio": 0.9273,
+      "suggested_scalar": -0.036,
+      "log_bad": -0.1824,
+      "log_good": -0.2579
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0151,
+      "good": 1.0,
+      "ratio": 66.2252,
+      "suggested_scalar": 2.0,
+      "log_bad": -4.1931,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6774,
+      "good": 4.6238,
+      "ratio": 0.9885,
+      "suggested_scalar": -0.0055,
+      "log_bad": 1.5427,
+      "log_good": 1.5312
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 96.0,
+      "good": 86.0,
+      "ratio": 0.8958,
+      "suggested_scalar": -0.0525,
+      "log_bad": 4.5643,
+      "log_good": 4.4543
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4657,
+      "good": 0.4456,
+      "ratio": 0.9568,
+      "suggested_scalar": -0.021,
+      "log_bad": -0.7642,
+      "log_good": -0.8083
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.0,
+      "good": 19.0,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.0477,
+      "log_bad": 3.0445,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.632,
+      "good": 0.6212,
+      "ratio": 0.9829,
+      "suggested_scalar": -0.0082,
+      "log_bad": -0.4589,
+      "log_good": -0.4761
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.8571,
+      "good": 4.8182,
+      "ratio": 0.992,
+      "suggested_scalar": -0.0038,
+      "log_bad": 1.5804,
+      "log_good": 1.5724
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 332.0,
+      "good": 313.0,
+      "ratio": 0.9428,
+      "suggested_scalar": -0.0281,
+      "log_bad": 5.8051,
+      "log_good": 5.7462
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.119,
+      "good": 0.1591,
+      "ratio": 1.337,
+      "suggested_scalar": 0.1385,
+      "log_bad": -2.1286,
+      "log_good": -1.8382
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0013,
+      "good": 0.0014,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0353,
+      "log_bad": -6.6454,
+      "log_good": -6.5713
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8975,
+      "good": 0.9598,
+      "ratio": 1.0694,
+      "suggested_scalar": 0.032,
+      "log_bad": -0.1081,
+      "log_good": -0.041
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 122.0,
+      "good": 117.0,
+      "ratio": 0.959,
+      "suggested_scalar": -0.02,
+      "log_bad": 4.804,
+      "log_good": 4.7622
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 94.9357,
+      "good": 95.4473,
+      "ratio": 1.0054,
+      "suggested_scalar": 0.0026,
+      "log_bad": 4.5532,
+      "log_good": 4.5586
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5045,
+      "good": 0.5513,
+      "ratio": 1.0928,
+      "suggested_scalar": 0.0423,
+      "log_bad": -0.6842,
+      "log_good": -0.5955
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.122,
+      "good": 7.8527,
+      "ratio": 0.7758,
+      "suggested_scalar": -0.1211,
+      "log_bad": 2.3147,
+      "log_good": 2.0609
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1536.0,
+      "good": 1480.0,
+      "ratio": 0.9635,
+      "suggested_scalar": -0.0177,
+      "log_bad": 7.3369,
+      "log_good": 7.2998
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0714,
+      "good": 0.0682,
+      "ratio": 0.9552,
+      "suggested_scalar": -0.0219,
+      "log_bad": -2.6395,
+      "log_good": -2.6853
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7857,
+      "good": 0.7273,
+      "ratio": 0.9257,
+      "suggested_scalar": -0.0368,
+      "log_bad": -0.2412,
+      "log_good": -0.3184
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.9048,
+      "good": 7.1136,
+      "ratio": 0.8999,
+      "suggested_scalar": -0.0503,
+      "log_bad": 2.0675,
+      "log_good": 1.962
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 8.0272,
+      "good": 7.6942,
+      "ratio": 0.9585,
+      "suggested_scalar": -0.0202,
+      "log_bad": 2.0828,
+      "log_good": 2.0405
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 68.0,
+      "good": 63.0,
+      "ratio": 0.9265,
+      "suggested_scalar": -0.0364,
+      "log_bad": 4.2195,
+      "log_good": 4.1431
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9091,
+      "good": 0.9179,
+      "ratio": 1.0097,
+      "suggested_scalar": 0.0046,
+      "log_bad": -0.0953,
+      "log_good": -0.0857
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 27.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0503,
+      "log_bad": 3.4012,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6211,
+      "good": 0.6291,
+      "ratio": 1.0129,
+      "suggested_scalar": 0.0061,
+      "log_bad": -0.4763,
+      "log_good": -0.4635
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.303,
+      "good": 0.3794,
+      "ratio": 1.2521,
+      "suggested_scalar": 0.1073,
+      "log_bad": -1.194,
+      "log_good": -0.9692
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.6392,
+      "good": 2.6958,
+      "ratio": 1.0214,
+      "suggested_scalar": 0.0101,
+      "log_bad": 0.9705,
+      "log_good": 0.9917
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 330.0,
+      "good": 311.0,
+      "ratio": 0.9424,
+      "suggested_scalar": -0.0283,
+      "log_bad": 5.7991,
+      "log_good": 5.7398
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.1064,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0482,
+      "good": 0.0703,
+      "ratio": 1.4585,
+      "suggested_scalar": 0.18,
+      "log_bad": -3.0324,
+      "log_good": -2.655
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 5.9307,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7801,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 25.0,
+      "good": 27.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.0367,
+      "log_bad": 3.2189,
+      "log_good": 3.2958
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.5174,
+      "good": 1.5452,
+      "ratio": 1.0183,
+      "suggested_scalar": 0.0087,
+      "log_bad": 0.417,
+      "log_good": 0.4352
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8788,
+      "good": 5.6873,
+      "ratio": 0.9674,
+      "suggested_scalar": -0.0158,
+      "log_bad": 1.7714,
+      "log_good": 1.7382
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7887,
+      "good": 0.7796,
+      "ratio": 0.9885,
+      "suggested_scalar": -0.0055,
+      "log_bad": -0.2374,
+      "log_good": -0.249
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1765,
+      "good": 0.1698,
+      "ratio": 0.962,
+      "suggested_scalar": -0.0185,
+      "log_bad": -1.7344,
+      "log_good": -1.7731
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1815,
+      "good": 2.8023,
+      "ratio": 0.8808,
+      "suggested_scalar": -0.0605,
+      "log_bad": 1.1574,
+      "log_good": 1.0304
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 269.0,
+      "good": 234.0,
+      "ratio": 0.8699,
+      "suggested_scalar": -0.0665,
+      "log_bad": 5.5947,
+      "log_good": 5.4553
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6607,
+      "good": 0.6341,
+      "ratio": 0.9597,
+      "suggested_scalar": -0.0196,
+      "log_bad": -0.4145,
+      "log_good": -0.4555
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 90.0,
+      "good": 84.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0329,
+      "log_bad": 4.4998,
+      "log_good": 4.4308
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 814.0,
+      "good": 792.0,
+      "ratio": 0.973,
+      "suggested_scalar": -0.0131,
+      "log_bad": 6.702,
+      "log_good": 6.6746
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 145.0,
+      "good": 141.0,
+      "ratio": 0.9724,
+      "suggested_scalar": -0.0133,
+      "log_bad": 4.9767,
+      "log_good": 4.9488
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.006,
+      "good": 0.0064,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.0308,
+      "log_bad": -5.116,
+      "log_good": -5.0515
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2078,
+      "good": 0.2141,
+      "ratio": 1.0303,
+      "suggested_scalar": 0.0142,
+      "log_bad": -1.5712,
+      "log_good": -1.5413
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 55.0,
+      "good": 54.0,
+      "ratio": 0.9818,
+      "suggested_scalar": -0.0088,
+      "log_bad": 4.0073,
+      "log_good": 3.989
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 90.0,
+      "good": 84.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0329,
+      "log_bad": 4.4998,
+      "log_good": 4.4308
+    },
+    "brevity.mean_sample_size": {
+      "bad": 90.0,
+      "good": 84.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0329,
+      "log_bad": 4.4998,
+      "log_good": 4.4308
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 332.0,
+      "good": 313.0,
+      "ratio": 0.9428,
+      "suggested_scalar": -0.0281,
+      "log_bad": 5.8051,
+      "log_good": 5.7462
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 166.0,
+      "good": 158.0,
+      "ratio": 0.9518,
+      "suggested_scalar": -0.0236,
+      "log_bad": 5.112,
+      "log_good": 5.0626
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 219.0,
+      "good": 194.0,
+      "ratio": 0.8858,
+      "suggested_scalar": -0.0578,
+      "log_bad": 5.3891,
+      "log_good": 5.2679
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0151,
+      "good": 0.016,
+      "ratio": 1.0596,
+      "suggested_scalar": 0.0276,
+      "log_bad": -4.1931,
+      "log_good": -4.1352
+    },
+    "heaps.mean_k": {
+      "bad": 2.4508,
+      "good": 2.417,
+      "ratio": 0.9862,
+      "suggested_scalar": -0.0066,
+      "log_bad": 0.8964,
+      "log_good": 0.8825
+    },
+    "halstead.mean_effort": {
+      "bad": 65318.3383,
+      "good": 61369.3035,
+      "ratio": 0.9395,
+      "suggested_scalar": -0.0297,
+      "log_bad": 11.087,
+      "log_good": 11.0247
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.9056,
+      "good": 0.8897,
+      "ratio": 0.9824,
+      "suggested_scalar": -0.0084,
+      "log_bad": -0.0992,
+      "log_good": -0.1169
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 66.0,
+      "good": 59.0,
+      "ratio": 0.8939,
+      "suggested_scalar": -0.0535,
+      "log_bad": 4.1897,
+      "log_good": 4.0775
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 156.0,
+      "good": 155.0,
+      "ratio": 0.9936,
+      "suggested_scalar": -0.0031,
+      "log_bad": 5.0499,
+      "log_good": 5.0434
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.418,
+      "good": 0.4103,
+      "ratio": 0.9816,
+      "suggested_scalar": -0.0089,
+      "log_bad": -0.8723,
+      "log_good": -0.8909
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.6721,
+      "good": 6.7692,
+      "ratio": 1.0146,
+      "suggested_scalar": 0.0069,
+      "log_bad": 1.8979,
+      "log_good": 1.9124
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1765,
+      "good": 0.1698,
+      "ratio": 0.962,
+      "suggested_scalar": -0.0185,
+      "log_bad": -1.7344,
+      "log_good": -1.7731
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.9214,
+      "good": 3.6618,
+      "ratio": 0.9338,
+      "suggested_scalar": -0.0327,
+      "log_bad": 1.3664,
+      "log_good": 1.298
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 331.0,
+      "good": 312.0,
+      "ratio": 0.9426,
+      "suggested_scalar": -0.0282,
+      "log_bad": 5.8021,
+      "log_good": 5.743
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 39.0,
+      "good": 41.0,
+      "ratio": 1.0513,
+      "suggested_scalar": 0.0239,
+      "log_bad": 3.6636,
+      "log_good": 3.7136
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3628.7966,
+      "good": 3409.4058,
+      "ratio": 0.9395,
+      "suggested_scalar": -0.0297,
+      "log_bad": 8.1967,
+      "log_good": 8.1343
+    },
+    "readability.mean_total_lines": {
+      "bad": 42.0,
+      "good": 44.0,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.0222,
+      "log_bad": 3.7377,
+      "log_good": 3.7842
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 1982.0737,
+      "good": 1902.1744,
+      "ratio": 0.9597,
+      "suggested_scalar": -0.0196,
+      "log_bad": 7.5919,
+      "log_good": 7.5508
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 582.0,
+      "good": 549.0,
+      "ratio": 0.9433,
+      "suggested_scalar": -0.0278,
+      "log_bad": 6.3665,
+      "log_good": 6.3081
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.119,
+      "good": 32.3864,
+      "ratio": 0.9222,
+      "suggested_scalar": -0.0386,
+      "log_bad": 3.5587,
+      "log_good": 3.4777
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2278,
+      "good": 1.2313,
+      "ratio": 1.0029,
+      "suggested_scalar": 0.0014,
+      "log_bad": 0.2052,
+      "log_good": 0.2081
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 7.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.1605,
+      "log_bad": 1.6094,
+      "log_good": 1.9459
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.855,
+      "good": 0.8248,
+      "ratio": 0.9647,
+      "suggested_scalar": -0.0172,
+      "log_bad": -0.1567,
+      "log_good": -0.1926
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9726,
+      "good": 0.9726,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0278,
+      "log_good": -0.0278
+    },
+    "halstead.mean_length": {
+      "bad": 301.0,
+      "good": 296.0,
+      "ratio": 0.9834,
+      "suggested_scalar": -0.008,
+      "log_bad": 5.7071,
+      "log_good": 5.6904
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.0,
+      "good": 4.5,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0562,
+      "log_bad": 1.3863,
+      "log_good": 1.5041
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4919,
+      "good": 6.3923,
+      "ratio": 0.9847,
+      "suggested_scalar": -0.0074,
+      "log_bad": 1.8706,
+      "log_good": 1.8551
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1088,
+      "good": 0.1069,
+      "ratio": 0.9825,
+      "suggested_scalar": -0.0084,
+      "log_bad": -2.2182,
+      "log_good": -2.2359
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 32.9545,
+      "good": 32.2627,
+      "ratio": 0.979,
+      "suggested_scalar": -0.0101,
+      "log_bad": 3.4951,
+      "log_good": 3.4739
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 51.0,
+      "good": 48.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0289,
+      "log_bad": 3.9318,
+      "log_good": 3.8712
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7489,
+      "good": 0.7216,
+      "ratio": 0.9635,
+      "suggested_scalar": -0.0177,
+      "log_bad": -0.2891,
+      "log_good": -0.3263
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 42.0,
+      "good": 44.0,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.0222,
+      "log_bad": 3.7377,
+      "log_good": 3.7842
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "consistency.all_properties_declare_visibility": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "file_structure.single_responsibility": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 61.0,
+      "good": 37.0,
+      "ratio": 0.6066,
+      "suggested_scalar": -0.1348,
+      "log_bad": 4.1109,
+      "log_good": 3.6109
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.2962,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0144,
+      "good": 0.0075,
+      "ratio": 0.5208,
+      "suggested_scalar": -0.1759,
+      "log_bad": -4.2405,
+      "log_good": -4.8929
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3478,
+      "good": 1.0,
+      "ratio": 0.7419,
+      "suggested_scalar": -0.0805,
+      "log_bad": 0.2985,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7708,
+      "good": 0.8667,
+      "ratio": 1.1244,
+      "suggested_scalar": 0.0316,
+      "log_bad": -0.2603,
+      "log_good": -0.1431
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0144,
+      "good": 0.0075,
+      "ratio": 0.5208,
+      "suggested_scalar": -0.1759,
+      "log_bad": -4.2405,
+      "log_good": -4.8929
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6008,
+      "good": 4.735,
+      "ratio": 1.0292,
+      "suggested_scalar": 0.0078,
+      "log_bad": 1.5262,
+      "log_good": 1.555
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 113.0,
+      "good": 79.0,
+      "ratio": 0.6991,
+      "suggested_scalar": -0.0965,
+      "log_bad": 4.7274,
+      "log_good": 4.3694
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5118,
+      "good": 0.4293,
+      "ratio": 0.8388,
+      "suggested_scalar": -0.0474,
+      "log_bad": -0.6698,
+      "log_good": -0.8456
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 20.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0284,
+      "log_bad": 2.8904,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5952,
+      "good": 0.5622,
+      "ratio": 0.9446,
+      "suggested_scalar": -0.0154,
+      "log_bad": -0.5189,
+      "log_good": -0.5759
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.0833,
+      "good": 3.4222,
+      "ratio": 0.8381,
+      "suggested_scalar": -0.0476,
+      "log_bad": 1.4069,
+      "log_good": 1.2303
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 695.0,
+      "good": 400.0,
+      "ratio": 0.5755,
+      "suggested_scalar": -0.1489,
+      "log_bad": 6.5439,
+      "log_good": 5.9915
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1093,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0006,
+      "good": 1.0,
+      "ratio": 1666.6667,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.4186,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0006,
+      "good": 0.0033,
+      "ratio": 5.5,
+      "suggested_scalar": 0.4596,
+      "log_bad": -7.4186,
+      "log_good": -5.7138
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1002,
+      "good": 1.018,
+      "ratio": 0.9253,
+      "suggested_scalar": -0.0209,
+      "log_bad": 0.0955,
+      "log_good": 0.0178
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 239.0,
+      "good": 129.0,
+      "ratio": 0.5397,
+      "suggested_scalar": -0.1662,
+      "log_bad": 5.4765,
+      "log_good": 4.8598
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 90.7517,
+      "good": 103.2598,
+      "ratio": 1.1378,
+      "suggested_scalar": 0.0348,
+      "log_bad": 4.5081,
+      "log_good": 4.6372
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6873,
+      "good": 0.6366,
+      "ratio": 0.9262,
+      "suggested_scalar": -0.0207,
+      "log_bad": -0.375,
+      "log_good": -0.4516
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 33.0051,
+      "good": 17.8995,
+      "ratio": 0.5423,
+      "suggested_scalar": -0.165,
+      "log_bad": 3.4967,
+      "log_good": 2.8848
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 3085.0,
+      "good": 1520.0,
+      "ratio": 0.4927,
+      "suggested_scalar": -0.1908,
+      "log_bad": 8.0343,
+      "log_good": 7.3265
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0938,
+      "good": 0.1556,
+      "ratio": 1.6588,
+      "suggested_scalar": 0.1364,
+      "log_bad": -2.3666,
+      "log_good": -1.8605
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7292,
+      "good": 0.8222,
+      "ratio": 1.1275,
+      "suggested_scalar": 0.0324,
+      "log_bad": -0.3158,
+      "log_good": -0.1958
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.2396,
+      "good": 8.8889,
+      "ratio": 1.2278,
+      "suggested_scalar": 0.0553,
+      "log_bad": 1.9796,
+      "log_good": 2.1848
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 16.0,
+      "good": 1.0,
+      "ratio": 0.0625,
+      "suggested_scalar": -0.7475,
+      "log_bad": 2.7726,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.6181,
+      "good": 3.9773,
+      "ratio": 0.7079,
+      "suggested_scalar": -0.0931,
+      "log_bad": 1.726,
+      "log_good": 1.3806
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 202.0,
+      "good": 103.0,
+      "ratio": 0.5099,
+      "suggested_scalar": -0.1816,
+      "log_bad": 5.3083,
+      "log_good": 4.6347
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9579,
+      "good": 0.9427,
+      "ratio": 0.9841,
+      "suggested_scalar": -0.0043,
+      "log_bad": -0.043,
+      "log_good": -0.059
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 33.0,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.0541,
+      "log_bad": 3.2958,
+      "log_good": 3.4965
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6775,
+      "good": 0.5947,
+      "ratio": 0.8778,
+      "suggested_scalar": -0.0351,
+      "log_bad": -0.3893,
+      "log_good": -0.5197
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.469,
+      "good": 0.3945,
+      "ratio": 0.8412,
+      "suggested_scalar": -0.0466,
+      "log_bad": -0.7572,
+      "log_good": -0.9301
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.1005,
+      "good": 2.4675,
+      "ratio": 0.7958,
+      "suggested_scalar": -0.0616,
+      "log_bad": 1.1316,
+      "log_good": 0.9032
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 693.0,
+      "good": 398.0,
+      "ratio": 0.5743,
+      "suggested_scalar": -0.1495,
+      "log_bad": 6.541,
+      "log_good": 5.9865
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0288,
+      "good": 0.005,
+      "ratio": 0.1736,
+      "suggested_scalar": -0.472,
+      "log_bad": -3.5474,
+      "log_good": -5.2983
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9773,
+      "good": 5.9307,
+      "ratio": 0.9922,
+      "suggested_scalar": -0.0021,
+      "log_bad": 1.788,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 21.0,
+      "good": 25.0,
+      "ratio": 1.1905,
+      "suggested_scalar": 0.047,
+      "log_bad": 3.0445,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7745,
+      "good": 0.7724,
+      "ratio": 0.9973,
+      "suggested_scalar": -0.0007,
+      "log_bad": -0.2555,
+      "log_good": -0.2583
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6071,
+      "good": 5.6373,
+      "ratio": 1.0054,
+      "suggested_scalar": 0.0014,
+      "log_bad": 1.724,
+      "log_good": 1.7294
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7697,
+      "good": 0.7984,
+      "ratio": 1.0373,
+      "suggested_scalar": 0.0099,
+      "log_bad": -0.2618,
+      "log_good": -0.2251
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1273,
+      "good": 0.1509,
+      "ratio": 1.1854,
+      "suggested_scalar": 0.0458,
+      "log_bad": -2.0612,
+      "log_good": -1.8911
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 5.745,
+      "good": 4.2308,
+      "ratio": 0.7364,
+      "suggested_scalar": -0.0825,
+      "log_bad": 1.7483,
+      "log_good": 1.4424
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 473.0,
+      "good": 295.0,
+      "ratio": 0.6237,
+      "suggested_scalar": -0.1273,
+      "log_bad": 6.1591,
+      "log_good": 5.687
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 19.0,
+      "good": 4.0,
+      "ratio": 0.2105,
+      "suggested_scalar": -0.4201,
+      "log_bad": 2.9444,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.4186,
+      "good": 0.7523,
+      "ratio": 0.5303,
+      "suggested_scalar": -0.171,
+      "log_bad": 0.3497,
+      "log_good": -0.2846
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 135.0,
+      "good": 98.0,
+      "ratio": 0.7259,
+      "suggested_scalar": -0.0864,
+      "log_bad": 4.9053,
+      "log_good": 4.585
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1740.0,
+      "good": 826.0,
+      "ratio": 0.4747,
+      "suggested_scalar": -0.2009,
+      "log_bad": 7.4616,
+      "log_good": 6.7166
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 218.0,
+      "good": 116.0,
+      "ratio": 0.5321,
+      "suggested_scalar": -0.1701,
+      "log_bad": 5.3845,
+      "log_good": 4.7536
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0086,
+      "good": 0.005,
+      "ratio": 0.5814,
+      "suggested_scalar": -0.1462,
+      "log_bad": -4.756,
+      "log_good": -5.2983
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2978,
+      "good": 0.2475,
+      "ratio": 0.8311,
+      "suggested_scalar": -0.0499,
+      "log_bad": -1.2113,
+      "log_good": -1.3963
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 120.0,
+      "good": 74.0,
+      "ratio": 0.6167,
+      "suggested_scalar": -0.1303,
+      "log_bad": 4.7875,
+      "log_good": 4.3041
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 23.0,
+      "good": 5.0,
+      "ratio": 0.2174,
+      "suggested_scalar": -0.4114,
+      "log_bad": 3.1355,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 135.0,
+      "good": 98.0,
+      "ratio": 0.7259,
+      "suggested_scalar": -0.0864,
+      "log_bad": 4.9053,
+      "log_good": 4.585
+    },
+    "brevity.mean_sample_size": {
+      "bad": 135.0,
+      "good": 98.0,
+      "ratio": 0.7259,
+      "suggested_scalar": -0.0864,
+      "log_bad": 4.9053,
+      "log_good": 4.585
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 695.0,
+      "good": 400.0,
+      "ratio": 0.5755,
+      "suggested_scalar": -0.1489,
+      "log_bad": 6.5439,
+      "log_good": 5.9915
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 356.0,
+      "good": 226.0,
+      "ratio": 0.6348,
+      "suggested_scalar": -0.1225,
+      "log_bad": 5.8749,
+      "log_good": 5.4205
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 337.0,
+      "good": 219.0,
+      "ratio": 0.6499,
+      "suggested_scalar": -0.1162,
+      "log_bad": 5.8201,
+      "log_good": 5.3891
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0029,
+      "good": 0.005,
+      "ratio": 1.7241,
+      "suggested_scalar": 0.1469,
+      "log_bad": -5.843,
+      "log_good": -5.2983
+    },
+    "heaps.mean_k": {
+      "bad": 2.6929,
+      "good": 3.6247,
+      "ratio": 1.346,
+      "suggested_scalar": 0.0801,
+      "log_bad": 0.9906,
+      "log_good": 1.2878
+    },
+    "halstead.mean_effort": {
+      "bad": 145637.1499,
+      "good": 93900.5699,
+      "ratio": 0.6448,
+      "suggested_scalar": -0.1183,
+      "log_bad": 11.8889,
+      "log_good": 11.45
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.7923,
+      "good": 0.8522,
+      "ratio": 1.0756,
+      "suggested_scalar": 0.0196,
+      "log_bad": -0.2328,
+      "log_good": -0.1599
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 86.0,
+      "good": 46.0,
+      "ratio": 0.5349,
+      "suggested_scalar": -0.1687,
+      "log_bad": 4.4543,
+      "log_good": 3.8286
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 406.0,
+      "good": 242.0,
+      "ratio": 0.5961,
+      "suggested_scalar": -0.1395,
+      "log_bad": 6.0064,
+      "log_good": 5.4889
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.41,
+      "good": 0.4496,
+      "ratio": 1.0966,
+      "suggested_scalar": 0.0249,
+      "log_bad": -0.8916,
+      "log_good": -0.7994
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.2803,
+      "good": 6.4031,
+      "ratio": 0.8795,
+      "suggested_scalar": -0.0346,
+      "log_bad": 1.9852,
+      "log_good": 1.8568
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1273,
+      "good": 0.1509,
+      "ratio": 1.1854,
+      "suggested_scalar": 0.0458,
+      "log_bad": -2.0612,
+      "log_good": -1.8911
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.2982,
+      "good": 4.2614,
+      "ratio": 0.8043,
+      "suggested_scalar": -0.0587,
+      "log_bad": 1.6674,
+      "log_good": 1.4496
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 694.0,
+      "good": 399.0,
+      "ratio": 0.5749,
+      "suggested_scalar": -0.1492,
+      "log_bad": 6.5425,
+      "log_good": 5.989
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 11.0,
+      "good": 8.0,
+      "ratio": 0.7273,
+      "suggested_scalar": -0.0859,
+      "log_bad": 2.3979,
+      "log_good": 2.0794
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 105.0,
+      "good": 54.0,
+      "ratio": 0.5143,
+      "suggested_scalar": -0.1793,
+      "log_bad": 4.654,
+      "log_good": 3.989
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 8090.9528,
+      "good": 5216.6983,
+      "ratio": 0.6448,
+      "suggested_scalar": -0.1183,
+      "log_bad": 8.9985,
+      "log_good": 8.5596
+    },
+    "readability.mean_total_lines": {
+      "bad": 96.0,
+      "good": 45.0,
+      "ratio": 0.4688,
+      "suggested_scalar": -0.2043,
+      "log_bad": 4.5643,
+      "log_good": 3.8067
+    },
+    "indentation.mean_max_depth": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "halstead.mean_volume": {
+      "bad": 4255.7917,
+      "good": 2256.7535,
+      "ratio": 0.5303,
+      "suggested_scalar": -0.171,
+      "log_bad": 8.356,
+      "log_good": 7.7217
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 995.0,
+      "good": 616.0,
+      "ratio": 0.6191,
+      "suggested_scalar": -0.1293,
+      "log_bad": 6.9027,
+      "log_good": 6.4232
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.9896,
+      "good": 32.6,
+      "ratio": 1.052,
+      "suggested_scalar": 0.0137,
+      "log_bad": 3.4337,
+      "log_good": 3.4843
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2853,
+      "good": 1.1176,
+      "ratio": 0.8695,
+      "suggested_scalar": -0.0377,
+      "log_bad": 0.251,
+      "log_good": 0.1112
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1093,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 24.0,
+      "good": 19.0,
+      "ratio": 0.7917,
+      "suggested_scalar": -0.063,
+      "log_bad": 3.1781,
+      "log_good": 2.9444
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.778,
+      "good": 0.8169,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0132,
+      "log_bad": -0.251,
+      "log_good": -0.2022
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9913,
+      "good": 0.9331,
+      "ratio": 0.9413,
+      "suggested_scalar": -0.0163,
+      "log_bad": -0.0087,
+      "log_good": -0.0692
+    },
+    "halstead.mean_length": {
+      "bad": 624.0,
+      "good": 358.0,
+      "ratio": 0.5737,
+      "suggested_scalar": -0.1498,
+      "log_bad": 6.4362,
+      "log_good": 5.8805
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.4783,
+      "good": 8.4,
+      "ratio": 1.8757,
+      "suggested_scalar": 0.1696,
+      "log_bad": 1.4992,
+      "log_good": 2.1282
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.0768,
+      "good": 6.6147,
+      "ratio": 0.9347,
+      "suggested_scalar": -0.0182,
+      "log_bad": 1.9568,
+      "log_good": 1.8893
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1154,
+      "good": 0.1487,
+      "ratio": 1.2886,
+      "suggested_scalar": 0.0683,
+      "log_bad": -2.1594,
+      "log_good": -1.9058
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 34.2209,
+      "good": 41.6087,
+      "ratio": 1.2159,
+      "suggested_scalar": 0.0527,
+      "log_bad": 3.5328,
+      "log_good": 3.7283
+    },
+    "branching.mean_branch_count": {
+      "bad": 9.0,
+      "good": 7.0,
+      "ratio": 0.7778,
+      "suggested_scalar": -0.0678,
+      "log_bad": 2.1972,
+      "log_good": 1.9459
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 98.0,
+      "good": 58.0,
+      "ratio": 0.5918,
+      "suggested_scalar": -0.1414,
+      "log_bad": 4.585,
+      "log_good": 4.0604
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6439,
+      "good": 0.6621,
+      "ratio": 1.0283,
+      "suggested_scalar": 0.0075,
+      "log_bad": -0.4402,
+      "log_good": -0.4123
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 96.0,
+      "good": 45.0,
+      "ratio": 0.4688,
+      "suggested_scalar": -0.2043,
+      "log_bad": 4.5643,
+      "log_good": 3.8067
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 30.0,
+      "good": 22.0,
+      "ratio": 0.7333,
+      "suggested_scalar": -0.0836,
+      "log_bad": 3.4012,
+      "log_good": 3.091
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.uses_attr_accessor_not_manual_getter_setter": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 10.0,
+      "good": 9.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0309,
+      "log_bad": 2.3026,
+      "log_good": 2.1972
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0103,
+      "good": 0.0108,
+      "ratio": 1.0485,
+      "suggested_scalar": 0.0139,
+      "log_bad": -4.5756,
+      "log_good": -4.5282
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.25,
+      "good": 0.2,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0655,
+      "log_bad": -1.3863,
+      "log_good": -1.6094
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.766,
+      "good": 0.8824,
+      "ratio": 1.152,
+      "suggested_scalar": 0.0415,
+      "log_bad": -0.2666,
+      "log_good": -0.1251
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0103,
+      "good": 0.0108,
+      "ratio": 1.0485,
+      "suggested_scalar": 0.0139,
+      "log_bad": -4.5756,
+      "log_good": -4.5282
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4779,
+      "good": 4.5483,
+      "ratio": 1.0157,
+      "suggested_scalar": 0.0046,
+      "log_bad": 1.4992,
+      "log_good": 1.5148
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 44.0,
+      "good": 43.0,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.0067,
+      "log_bad": 3.7842,
+      "log_good": 3.7612
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3788,
+      "good": 0.3433,
+      "ratio": 0.9063,
+      "suggested_scalar": -0.0289,
+      "log_bad": -0.9707,
+      "log_good": -1.0692
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 18.0,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.0168,
+      "log_bad": 2.8332,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.589,
+      "good": 0.6413,
+      "ratio": 1.0888,
+      "suggested_scalar": 0.025,
+      "log_bad": -0.5293,
+      "log_good": -0.4443
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.7234,
+      "good": 3.4706,
+      "ratio": 1.2744,
+      "suggested_scalar": 0.0712,
+      "log_bad": 1.0019,
+      "log_good": 1.2443
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 194.0,
+      "good": 185.0,
+      "ratio": 0.9536,
+      "suggested_scalar": -0.0139,
+      "log_bad": 5.2679,
+      "log_good": 5.2204
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 0.0011,
+      "ratio": 0.0011,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.8124
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0426,
+      "good": 1.0,
+      "ratio": 23.4742,
+      "suggested_scalar": 0.9265,
+      "log_bad": -3.1559,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0021,
+      "good": 0.0056,
+      "ratio": 2.6667,
+      "suggested_scalar": 0.288,
+      "log_bad": -6.1658,
+      "log_good": -5.185
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9661,
+      "good": 0.9208,
+      "ratio": 0.9531,
+      "suggested_scalar": -0.0141,
+      "log_bad": -0.0345,
+      "log_good": -0.0825
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 66.0,
+      "good": 67.0,
+      "ratio": 1.0152,
+      "suggested_scalar": 0.0044,
+      "log_bad": 4.1897,
+      "log_good": 4.2047
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 93.3252,
+      "good": 81.2011,
+      "ratio": 0.8701,
+      "suggested_scalar": -0.0409,
+      "log_bad": 4.5361,
+      "log_good": 4.3969
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.513,
+      "good": 0.4293,
+      "ratio": 0.8368,
+      "suggested_scalar": -0.0523,
+      "log_bad": -0.6675,
+      "log_good": -0.8456
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.0983,
+      "good": 10.135,
+      "ratio": 1.0036,
+      "suggested_scalar": 0.0011,
+      "log_bad": 2.3124,
+      "log_good": 2.316
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 977.0,
+      "good": 889.0,
+      "ratio": 0.9099,
+      "suggested_scalar": -0.0277,
+      "log_bad": 6.8845,
+      "log_good": 6.7901
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7447,
+      "good": 0.8529,
+      "ratio": 1.1453,
+      "suggested_scalar": 0.0398,
+      "log_bad": -0.2948,
+      "log_good": -0.1591
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 4.3111,
+      "good": 5.4412,
+      "ratio": 1.2621,
+      "suggested_scalar": 0.0683,
+      "log_bad": 1.4612,
+      "log_good": 1.694
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.2639,
+      "good": 2.8962,
+      "ratio": 2.2915,
+      "suggested_scalar": 0.2434,
+      "log_bad": 0.2342,
+      "log_good": 1.0634
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 62.0,
+      "good": 65.0,
+      "ratio": 1.0484,
+      "suggested_scalar": 0.0139,
+      "log_bad": 4.1271,
+      "log_good": 4.1744
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.8798,
+      "good": 0.8235,
+      "ratio": 0.936,
+      "suggested_scalar": -0.0194,
+      "log_bad": -0.1281,
+      "log_good": -0.1942
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 17.0,
+      "good": 18.0,
+      "ratio": 1.0588,
+      "suggested_scalar": 0.0168,
+      "log_bad": 2.8332,
+      "log_good": 2.8904
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6325,
+      "good": 0.5917,
+      "ratio": 0.9355,
+      "suggested_scalar": -0.0196,
+      "log_bad": -0.4581,
+      "log_good": -0.5248
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2031,
+      "good": 0.1421,
+      "ratio": 0.6997,
+      "suggested_scalar": -0.1049,
+      "log_bad": -1.5941,
+      "log_good": -1.9512
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7214,
+      "good": 2.449,
+      "ratio": 0.8999,
+      "suggested_scalar": -0.031,
+      "log_bad": 1.0011,
+      "log_good": 0.8957
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 192.0,
+      "good": 183.0,
+      "ratio": 0.9531,
+      "suggested_scalar": -0.0141,
+      "log_bad": 5.2575,
+      "log_good": 5.2095
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 12.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0255,
+      "log_bad": 2.3979,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 0.0378,
+      "ratio": 0.0378,
+      "suggested_scalar": -0.9616,
+      "log_bad": 0.0,
+      "log_good": -3.2754
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.585,
+      "good": 5.6147,
+      "ratio": 1.0053,
+      "suggested_scalar": 0.0016,
+      "log_bad": 1.7201,
+      "log_good": 1.7254
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 4.0,
+      "good": 2.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2035,
+      "log_bad": 1.3863,
+      "log_good": 0.6931
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.3298,
+      "good": 0.1936,
+      "ratio": 0.587,
+      "suggested_scalar": -0.1564,
+      "log_bad": -1.1093,
+      "log_good": -1.642
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.0298,
+      "good": 5.0317,
+      "ratio": 1.0004,
+      "suggested_scalar": 0.0001,
+      "log_bad": 1.6154,
+      "log_good": 1.6158
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8018,
+      "good": 0.8101,
+      "ratio": 1.0104,
+      "suggested_scalar": 0.003,
+      "log_bad": -0.2209,
+      "log_good": -0.2106
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1897,
+      "good": 0.1282,
+      "ratio": 0.6758,
+      "suggested_scalar": -0.115,
+      "log_bad": -1.6623,
+      "log_good": -2.0542
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1778,
+      "good": 3.1836,
+      "ratio": 1.0018,
+      "suggested_scalar": 0.0005,
+      "log_bad": 1.1562,
+      "log_good": 1.158
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 167.0,
+      "good": 165.0,
+      "ratio": 0.988,
+      "suggested_scalar": -0.0035,
+      "log_bad": 5.118,
+      "log_good": 5.1059
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.2821,
+      "good": 0.2912,
+      "ratio": 1.0323,
+      "suggested_scalar": 0.0093,
+      "log_bad": -1.2655,
+      "log_good": -1.2337
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 49.0,
+      "good": 47.0,
+      "ratio": 0.9592,
+      "suggested_scalar": -0.0122,
+      "log_bad": 3.8918,
+      "log_good": 3.8501
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 518.0,
+      "good": 528.0,
+      "ratio": 1.0193,
+      "suggested_scalar": 0.0056,
+      "log_bad": 6.25,
+      "log_good": 6.2691
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 67.0,
+      "good": 65.0,
+      "ratio": 0.9701,
+      "suggested_scalar": -0.0089,
+      "log_bad": 4.2047,
+      "log_good": 4.1744
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.134,
+      "good": 0.2378,
+      "ratio": 1.7746,
+      "suggested_scalar": 0.1684,
+      "log_bad": -2.0099,
+      "log_good": -1.4363
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 30.0,
+      "good": 23.0,
+      "ratio": 0.7667,
+      "suggested_scalar": -0.078,
+      "log_bad": 3.4012,
+      "log_good": 3.1355
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 12.0,
+      "good": 5.0,
+      "ratio": 0.4167,
+      "suggested_scalar": -0.257,
+      "log_bad": 2.4849,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 49.0,
+      "good": 47.0,
+      "ratio": 0.9592,
+      "suggested_scalar": -0.0122,
+      "log_bad": 3.8918,
+      "log_good": 3.8501
+    },
+    "brevity.mean_sample_size": {
+      "bad": 49.0,
+      "good": 47.0,
+      "ratio": 0.9592,
+      "suggested_scalar": -0.0122,
+      "log_bad": 3.8918,
+      "log_good": 3.8501
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 194.0,
+      "good": 185.0,
+      "ratio": 0.9536,
+      "suggested_scalar": -0.0139,
+      "log_bad": 5.2679,
+      "log_good": 5.2204
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 94.0,
+      "good": 103.0,
+      "ratio": 1.0957,
+      "suggested_scalar": 0.0268,
+      "log_bad": 4.5433,
+      "log_good": 4.6347
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 124.0,
+      "good": 128.0,
+      "ratio": 1.0323,
+      "suggested_scalar": 0.0093,
+      "log_bad": 4.8203,
+      "log_good": 4.852
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0054,
+      "ratio": 0.0054,
+      "suggested_scalar": -1.5329,
+      "log_bad": 0.0,
+      "log_good": -5.2214
+    },
+    "heaps.mean_k": {
+      "bad": 2.1678,
+      "good": 1.7875,
+      "ratio": 0.8246,
+      "suggested_scalar": -0.0566,
+      "log_bad": 0.7737,
+      "log_good": 0.5808
+    },
+    "halstead.mean_effort": {
+      "bad": 17848.8029,
+      "good": 20442.9098,
+      "ratio": 1.1453,
+      "suggested_scalar": 0.0398,
+      "log_bad": 9.7897,
+      "log_good": 9.9254
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8958,
+      "good": 0.9059,
+      "ratio": 1.0113,
+      "suggested_scalar": 0.0033,
+      "log_bad": -0.11,
+      "log_good": -0.0988
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 27.0,
+      "good": 25.0,
+      "ratio": 0.9259,
+      "suggested_scalar": -0.0226,
+      "log_bad": 3.2958,
+      "log_good": 3.2189
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 88.0,
+      "good": 96.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0255,
+      "log_bad": 4.4773,
+      "log_good": 4.5643
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3788,
+      "good": 0.3433,
+      "ratio": 0.9063,
+      "suggested_scalar": -0.0289,
+      "log_bad": -0.9707,
+      "log_good": -1.0692
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.8485,
+      "good": 7.8806,
+      "ratio": 1.0041,
+      "suggested_scalar": 0.0012,
+      "log_bad": 2.0603,
+      "log_good": 2.0644
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1897,
+      "good": 0.1282,
+      "ratio": 0.6758,
+      "suggested_scalar": -0.115,
+      "log_bad": -1.6623,
+      "log_good": -2.0542
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.7244,
+      "good": 2.1765,
+      "ratio": 1.2622,
+      "suggested_scalar": 0.0684,
+      "log_bad": 0.5449,
+      "log_good": 0.7777
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 193.0,
+      "good": 184.0,
+      "ratio": 0.9534,
+      "suggested_scalar": -0.014,
+      "log_bad": 5.2627,
+      "log_good": 5.2149
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 6.0,
+      "good": 4.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.119,
+      "log_bad": 1.7918,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 14.0,
+      "good": 8.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -0.1643,
+      "log_bad": 2.6391,
+      "log_good": 2.0794
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 991.6002,
+      "good": 1135.7172,
+      "ratio": 1.1453,
+      "suggested_scalar": 0.0398,
+      "log_bad": 6.8993,
+      "log_good": 7.035
+    },
+    "readability.mean_total_lines": {
+      "bad": 45.0,
+      "good": 34.0,
+      "ratio": 0.7556,
+      "suggested_scalar": -0.0823,
+      "log_bad": 3.8067,
+      "log_good": 3.5264
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.119,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 846.2119,
+      "good": 873.6286,
+      "ratio": 1.0324,
+      "suggested_scalar": 0.0094,
+      "log_bad": 6.7408,
+      "log_good": 6.7727
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 359.0,
+      "good": 363.0,
+      "ratio": 1.0111,
+      "suggested_scalar": 0.0033,
+      "log_bad": 5.8833,
+      "log_good": 5.8944
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 18.0889,
+      "good": 25.0,
+      "ratio": 1.3821,
+      "suggested_scalar": 0.095,
+      "log_bad": 2.8953,
+      "log_good": 3.2189
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.29,
+      "good": 1.4198,
+      "ratio": 1.1006,
+      "suggested_scalar": 0.0281,
+      "log_bad": 0.2546,
+      "log_good": 0.3505
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2035,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2035,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9162,
+      "good": 0.9515,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0111,
+      "log_bad": -0.0875,
+      "log_good": -0.0497
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9651,
+      "good": 0.9569,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0025,
+      "log_bad": -0.0355,
+      "log_good": -0.0441
+    },
+    "halstead.mean_length": {
+      "bad": 155.0,
+      "good": 161.0,
+      "ratio": 1.0387,
+      "suggested_scalar": 0.0111,
+      "log_bad": 5.0434,
+      "log_good": 5.0814
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.75,
+      "good": 7.0,
+      "ratio": 1.4737,
+      "suggested_scalar": 0.1138,
+      "log_bad": 1.5581,
+      "log_good": 1.9459
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.6147,
+      "good": 5.5546,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.0032,
+      "log_bad": 1.7254,
+      "log_good": 1.7146
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0966,
+      "good": 0.1159,
+      "ratio": 1.1998,
+      "suggested_scalar": 0.0535,
+      "log_bad": -2.3372,
+      "log_good": -2.155
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 21.0926,
+      "good": 23.4,
+      "ratio": 1.1094,
+      "suggested_scalar": 0.0305,
+      "log_bad": 3.0489,
+      "log_good": 3.1527
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 25.0,
+      "good": 23.0,
+      "ratio": 0.92,
+      "suggested_scalar": -0.0245,
+      "log_bad": 3.2189,
+      "log_good": 3.1355
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7581,
+      "good": 0.8203,
+      "ratio": 1.082,
+      "suggested_scalar": 0.0232,
+      "log_bad": -0.2769,
+      "log_good": -0.1981
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 47.0,
+      "good": 34.0,
+      "ratio": 0.7234,
+      "suggested_scalar": -0.0951,
+      "log_bad": 3.8501,
+      "log_good": 3.5264
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.protocol_capability_uses_able_ible_ing_suffix": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 7.0,
+      "good": 6.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.1916,
+      "log_bad": 1.9459,
+      "log_good": 1.7918
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0364,
+      "good": 0.0334,
+      "ratio": 0.9176,
+      "suggested_scalar": -0.1069,
+      "log_bad": -3.3132,
+      "log_good": -3.3992
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.6,
+      "good": 0.6,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.5108,
+      "log_good": -0.5108
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.86,
+      "good": 0.8478,
+      "ratio": 0.9858,
+      "suggested_scalar": -0.0178,
+      "log_bad": -0.1508,
+      "log_good": -0.1651
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0364,
+      "good": 0.0334,
+      "ratio": 0.9176,
+      "suggested_scalar": -0.1069,
+      "log_bad": -3.3132,
+      "log_good": -3.3992
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7853,
+      "good": 4.7414,
+      "ratio": 0.9908,
+      "suggested_scalar": -0.0115,
+      "log_bad": 1.5655,
+      "log_good": 1.5563
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 109.0,
+      "good": 84.0,
+      "ratio": 0.7706,
+      "suggested_scalar": -0.3238,
+      "log_bad": 4.6913,
+      "log_good": 4.4308
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4697,
+      "good": 0.3725,
+      "ratio": 0.7931,
+      "suggested_scalar": -0.2881,
+      "log_bad": -0.7557,
+      "log_good": -0.9875
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 17.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.1382,
+      "log_bad": 2.9444,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5658,
+      "good": 0.5596,
+      "ratio": 0.989,
+      "suggested_scalar": -0.0137,
+      "log_bad": -0.5695,
+      "log_good": -0.5805
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.92,
+      "good": 4.2609,
+      "ratio": 1.087,
+      "suggested_scalar": 0.1036,
+      "log_bad": 1.3661,
+      "log_good": 1.4495
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 495.0,
+      "good": 419.0,
+      "ratio": 0.8465,
+      "suggested_scalar": -0.2071,
+      "log_bad": 6.2046,
+      "log_good": 6.0379
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1,
+      "good": 0.0217,
+      "ratio": 0.217,
+      "suggested_scalar": -1.8986,
+      "log_bad": -2.3026,
+      "log_good": -3.8304
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0087,
+      "good": 0.0103,
+      "ratio": 1.1839,
+      "suggested_scalar": 0.2098,
+      "log_bad": -4.7444,
+      "log_good": -4.5756
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0073,
+      "good": 1.055,
+      "ratio": 1.0474,
+      "suggested_scalar": 0.0575,
+      "log_bad": 0.0073,
+      "log_good": 0.0535
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 163.0,
+      "good": 119.0,
+      "ratio": 0.7301,
+      "suggested_scalar": -0.391,
+      "log_bad": 5.0938,
+      "log_good": 4.7791
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 109.2181,
+      "good": 109.1442,
+      "ratio": 0.9993,
+      "suggested_scalar": -0.0008,
+      "log_bad": 4.6933,
+      "log_good": 4.6927
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6842,
+      "good": 0.7033,
+      "ratio": 1.0279,
+      "suggested_scalar": 0.0342,
+      "log_bad": -0.3795,
+      "log_good": -0.352
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.3488,
+      "good": 12.407,
+      "ratio": 1.0932,
+      "suggested_scalar": 0.1108,
+      "log_bad": 2.4291,
+      "log_good": 2.5183
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1964.0,
+      "good": 1651.0,
+      "ratio": 0.8406,
+      "suggested_scalar": -0.2157,
+      "log_bad": 7.5827,
+      "log_good": 7.4091
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2,
+      "good": 0.1957,
+      "ratio": 0.9785,
+      "suggested_scalar": -0.027,
+      "log_bad": -1.6094,
+      "log_good": -1.6312
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.82,
+      "good": 0.8043,
+      "ratio": 0.9809,
+      "suggested_scalar": -0.024,
+      "log_bad": -0.1985,
+      "log_good": -0.2178
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.9,
+      "good": 9.1087,
+      "ratio": 0.9201,
+      "suggested_scalar": -0.1035,
+      "log_bad": 2.2925,
+      "log_good": 2.2092
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 13.7536,
+      "good": 13.4972,
+      "ratio": 0.9814,
+      "suggested_scalar": -0.0234,
+      "log_bad": 2.6213,
+      "log_good": 2.6025
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 100.0,
+      "good": 68.0,
+      "ratio": 0.68,
+      "suggested_scalar": -0.4793,
+      "log_bad": 4.6052,
+      "log_good": 4.2195
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9384,
+      "good": 0.9171,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.0285,
+      "log_bad": -0.0636,
+      "log_good": -0.0865
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 27.0,
+      "ratio": 0.931,
+      "suggested_scalar": -0.0888,
+      "log_bad": 3.3673,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6319,
+      "good": 0.6323,
+      "ratio": 1.0006,
+      "suggested_scalar": 0.0008,
+      "log_bad": -0.459,
+      "log_good": -0.4584
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4888,
+      "good": 0.5036,
+      "ratio": 1.0303,
+      "suggested_scalar": 0.0371,
+      "log_bad": -0.7158,
+      "log_good": -0.686
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7165,
+      "good": 2.7199,
+      "ratio": 1.0013,
+      "suggested_scalar": 0.0016,
+      "log_bad": 0.9993,
+      "log_good": 1.0006
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 493.0,
+      "good": 417.0,
+      "ratio": 0.8458,
+      "suggested_scalar": -0.2081,
+      "log_bad": 6.2005,
+      "log_good": 6.0331
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0586,
+      "good": 0.0692,
+      "ratio": 1.1809,
+      "suggested_scalar": 0.2066,
+      "log_bad": -2.837,
+      "log_good": -2.6708
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9773,
+      "good": 5.8826,
+      "ratio": 0.9842,
+      "suggested_scalar": -0.0198,
+      "log_bad": 1.788,
+      "log_good": 1.772
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 56.0,
+      "good": 44.0,
+      "ratio": 0.7857,
+      "suggested_scalar": -0.2997,
+      "log_bad": 4.0254,
+      "log_good": 3.7842
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1941,
+      "good": 1.2833,
+      "ratio": 1.0747,
+      "suggested_scalar": 0.0895,
+      "log_bad": 0.1774,
+      "log_good": 0.2494
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8716,
+      "good": 5.5366,
+      "ratio": 0.9429,
+      "suggested_scalar": -0.073,
+      "log_bad": 1.7701,
+      "log_good": 1.7114
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8006,
+      "good": 0.806,
+      "ratio": 1.0067,
+      "suggested_scalar": 0.0084,
+      "log_bad": -0.2224,
+      "log_good": -0.2157
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1667,
+      "good": 0.1786,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.0857,
+      "log_bad": -1.7916,
+      "log_good": -1.7226
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.3688,
+      "good": 3.5224,
+      "ratio": 1.0456,
+      "suggested_scalar": 0.0554,
+      "log_bad": 1.2146,
+      "log_good": 1.2591
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 354.0,
+      "good": 297.0,
+      "ratio": 0.839,
+      "suggested_scalar": -0.2182,
+      "log_bad": 5.8693,
+      "log_good": 5.6937
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.2266,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9408,
+      "good": 0.7543,
+      "ratio": 0.8018,
+      "suggested_scalar": -0.2746,
+      "log_bad": -0.061,
+      "log_good": -0.282
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 105.0,
+      "good": 81.0,
+      "ratio": 0.7714,
+      "suggested_scalar": -0.3225,
+      "log_bad": 4.654,
+      "log_good": 4.3944
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 952.0,
+      "good": 744.0,
+      "ratio": 0.7815,
+      "suggested_scalar": -0.3063,
+      "log_bad": 6.8586,
+      "log_good": 6.612
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 178.0,
+      "good": 134.0,
+      "ratio": 0.7528,
+      "suggested_scalar": -0.3528,
+      "log_bad": 5.1818,
+      "log_good": 4.8978
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0182,
+      "good": 0.0215,
+      "ratio": 1.1813,
+      "suggested_scalar": 0.2071,
+      "log_bad": -4.0063,
+      "log_good": -3.8397
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2242,
+      "good": 0.2387,
+      "ratio": 1.0647,
+      "suggested_scalar": 0.0779,
+      "log_bad": -1.4952,
+      "log_good": -1.4325
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 122.0,
+      "good": 107.0,
+      "ratio": 0.877,
+      "suggested_scalar": -0.163,
+      "log_bad": 4.804,
+      "log_good": 4.6728
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 105.0,
+      "good": 81.0,
+      "ratio": 0.7714,
+      "suggested_scalar": -0.3225,
+      "log_bad": 4.654,
+      "log_good": 4.3944
+    },
+    "brevity.mean_sample_size": {
+      "bad": 105.0,
+      "good": 81.0,
+      "ratio": 0.7714,
+      "suggested_scalar": -0.3225,
+      "log_bad": 4.654,
+      "log_good": 4.3944
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 495.0,
+      "good": 419.0,
+      "ratio": 0.8465,
+      "suggested_scalar": -0.2071,
+      "log_bad": 6.2046,
+      "log_good": 6.0379
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 267.0,
+      "good": 243.0,
+      "ratio": 0.9101,
+      "suggested_scalar": -0.117,
+      "log_bad": 5.5872,
+      "log_good": 5.4931
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 278.0,
+      "good": 231.0,
+      "ratio": 0.8309,
+      "suggested_scalar": -0.2301,
+      "log_bad": 5.6276,
+      "log_good": 5.4424
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 3.8086,
+      "good": 3.388,
+      "ratio": 0.8896,
+      "suggested_scalar": -0.1454,
+      "log_bad": 1.3373,
+      "log_good": 1.2202
+    },
+    "halstead.mean_effort": {
+      "bad": 91055.514,
+      "good": 71816.6769,
+      "ratio": 0.7887,
+      "suggested_scalar": -0.295,
+      "log_bad": 11.4192,
+      "log_good": 11.1819
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8745,
+      "good": 0.8733,
+      "ratio": 0.9986,
+      "suggested_scalar": -0.0017,
+      "log_bad": -0.1341,
+      "log_good": -0.1355
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 80.0,
+      "good": 57.0,
+      "ratio": 0.7125,
+      "suggested_scalar": -0.4212,
+      "log_bad": 4.382,
+      "log_good": 4.0431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 239.0,
+      "good": 220.0,
+      "ratio": 0.9205,
+      "suggested_scalar": -0.1029,
+      "log_bad": 5.4765,
+      "log_good": 5.3936
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3865,
+      "good": 0.3697,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.0552,
+      "log_bad": -0.9506,
+      "log_good": -0.9951
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.8405,
+      "good": 6.2521,
+      "ratio": 1.0705,
+      "suggested_scalar": 0.0846,
+      "log_bad": 1.7648,
+      "log_good": 1.8329
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1667,
+      "good": 0.1786,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.0857,
+      "log_bad": -1.7916,
+      "log_good": -1.7226
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.96,
+      "good": 3.6435,
+      "ratio": 0.9201,
+      "suggested_scalar": -0.1035,
+      "log_bad": 1.3762,
+      "log_good": 1.2929
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 494.0,
+      "good": 418.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.2076,
+      "log_bad": 6.2025,
+      "log_good": 6.0355
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 102.0,
+      "good": 90.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.1555,
+      "log_bad": 4.625,
+      "log_good": 4.4998
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5058.6397,
+      "good": 3989.8154,
+      "ratio": 0.7887,
+      "suggested_scalar": -0.295,
+      "log_bad": 8.5289,
+      "log_good": 8.2915
+    },
+    "readability.mean_total_lines": {
+      "bad": 50.0,
+      "good": 46.0,
+      "ratio": 0.92,
+      "suggested_scalar": -0.1036,
+      "log_bad": 3.912,
+      "log_good": 3.8286
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2822.3329,
+      "good": 2262.8804,
+      "ratio": 0.8018,
+      "suggested_scalar": -0.2745,
+      "log_bad": 7.9453,
+      "log_good": 7.7244
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 723.0,
+      "good": 607.0,
+      "ratio": 0.8396,
+      "suggested_scalar": -0.2173,
+      "log_bad": 6.5834,
+      "log_good": 6.4085
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 37.92,
+      "good": 34.6739,
+      "ratio": 0.9144,
+      "suggested_scalar": -0.1112,
+      "log_bad": 3.6355,
+      "log_good": 3.546
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0351,
+      "good": 1.0455,
+      "ratio": 1.01,
+      "suggested_scalar": 0.0124,
+      "log_bad": 0.0345,
+      "log_good": 0.0445
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 1.0,
+      "ratio": 0.2,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.6094,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7119,
+      "good": 0.697,
+      "ratio": 0.9791,
+      "suggested_scalar": -0.0263,
+      "log_bad": -0.3398,
+      "log_good": -0.361
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9457,
+      "good": 0.927,
+      "ratio": 0.9802,
+      "suggested_scalar": -0.0248,
+      "log_bad": -0.0558,
+      "log_good": -0.0758
+    },
+    "halstead.mean_length": {
+      "bad": 417.0,
+      "good": 354.0,
+      "ratio": 0.8489,
+      "suggested_scalar": -0.2035,
+      "log_bad": 6.0331,
+      "log_good": 5.8693
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.8,
+      "good": 10.2,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.071,
+      "log_bad": 2.3795,
+      "log_good": 2.3224
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7142,
+      "good": 6.3399,
+      "ratio": 0.9443,
+      "suggested_scalar": -0.0713,
+      "log_bad": 1.9042,
+      "log_good": 1.8469
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1365,
+      "good": 0.1472,
+      "ratio": 1.0784,
+      "suggested_scalar": 0.0938,
+      "log_bad": -1.9914,
+      "log_good": -1.916
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 32.2625,
+      "good": 31.7368,
+      "ratio": 0.9837,
+      "suggested_scalar": -0.0204,
+      "log_bad": 3.4739,
+      "log_good": 3.4575
+    },
+    "branching.mean_branch_count": {
+      "bad": 10.0,
+      "good": 9.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.1309,
+      "log_bad": 2.3026,
+      "log_good": 2.1972
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 63.0,
+      "good": 44.0,
+      "ratio": 0.6984,
+      "suggested_scalar": -0.4461,
+      "log_bad": 4.1431,
+      "log_good": 3.7842
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5612,
+      "good": 0.5368,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.0552,
+      "log_bad": -0.5777,
+      "log_good": -0.6221
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 50.0,
+      "good": 46.0,
+      "ratio": 0.92,
+      "suggested_scalar": -0.1036,
+      "log_bad": 3.912,
+      "log_good": 3.8286
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.predicate_method_ends_with_question_mark": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.1,
+      "good": 0.1,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -2.3026,
+      "log_good": -2.3026
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7805,
+      "good": 0.775,
+      "ratio": 0.993,
+      "suggested_scalar": -0.0038,
+      "log_bad": -0.2478,
+      "log_good": -0.2549
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6551,
+      "good": 4.6669,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0014,
+      "log_bad": 1.538,
+      "log_good": 1.5405
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 57.0,
+      "good": 53.0,
+      "ratio": 0.9298,
+      "suggested_scalar": -0.0392,
+      "log_bad": 4.0431,
+      "log_good": 3.9703
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4,
+      "good": 0.375,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0348,
+      "log_bad": -0.9163,
+      "log_good": -0.9808
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 17.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.0599,
+      "log_bad": 2.9444,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6394,
+      "good": 0.5841,
+      "ratio": 0.9135,
+      "suggested_scalar": -0.0487,
+      "log_bad": -0.4472,
+      "log_good": -0.5377
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.6829,
+      "good": 2.7,
+      "ratio": 1.0064,
+      "suggested_scalar": 0.0034,
+      "log_bad": 0.9869,
+      "log_good": 0.9933
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 203.0,
+      "good": 212.0,
+      "ratio": 1.0443,
+      "suggested_scalar": 0.0234,
+      "log_bad": 5.3132,
+      "log_good": 5.3566
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0046,
+      "good": 0.0047,
+      "ratio": 1.0217,
+      "suggested_scalar": 0.0116,
+      "log_bad": -5.3817,
+      "log_good": -5.3602
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0244,
+      "good": 1.0,
+      "ratio": 40.9836,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.7132,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0037,
+      "good": 0.0188,
+      "ratio": 5.0811,
+      "suggested_scalar": 0.8755,
+      "log_bad": -5.5994,
+      "log_good": -3.9739
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9128,
+      "good": 0.9714,
+      "ratio": 1.0642,
+      "suggested_scalar": 0.0335,
+      "log_bad": -0.0912,
+      "log_good": -0.029
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 75.0,
+      "good": 72.0,
+      "ratio": 0.96,
+      "suggested_scalar": -0.022,
+      "log_bad": 4.3175,
+      "log_good": 4.2767
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 84.4165,
+      "good": 82.8411,
+      "ratio": 0.9813,
+      "suggested_scalar": -0.0101,
+      "log_bad": 4.4358,
+      "log_good": 4.4169
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4554,
+      "good": 0.5355,
+      "ratio": 1.1759,
+      "suggested_scalar": 0.0873,
+      "log_bad": -0.7866,
+      "log_good": -0.6246
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 20.5376,
+      "good": 20.8511,
+      "ratio": 1.0153,
+      "suggested_scalar": 0.0082,
+      "log_bad": 3.0223,
+      "log_good": 3.0374
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1080.0,
+      "good": 1061.0,
+      "ratio": 0.9824,
+      "suggested_scalar": -0.0096,
+      "log_bad": 6.9847,
+      "log_good": 6.967
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0244,
+      "good": 0.025,
+      "ratio": 1.0246,
+      "suggested_scalar": 0.0131,
+      "log_bad": -3.7132,
+      "log_good": -3.6889
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7561,
+      "good": 0.75,
+      "ratio": 0.9919,
+      "suggested_scalar": -0.0044,
+      "log_bad": -0.2796,
+      "log_good": -0.2877
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.075,
+      "good": 5.3,
+      "ratio": 1.0443,
+      "suggested_scalar": 0.0234,
+      "log_bad": 1.6243,
+      "log_good": 1.6677
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.2897,
+      "good": 1.31,
+      "ratio": 1.0157,
+      "suggested_scalar": 0.0084,
+      "log_bad": 0.2544,
+      "log_good": 0.27
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 69.0,
+      "good": 67.0,
+      "ratio": 0.971,
+      "suggested_scalar": -0.0158,
+      "log_bad": 4.2341,
+      "log_good": 4.2047
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9144,
+      "good": 0.9138,
+      "ratio": 0.9993,
+      "suggested_scalar": -0.0004,
+      "log_bad": -0.0895,
+      "log_good": -0.0901
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5926,
+      "good": 0.6079,
+      "ratio": 1.0258,
+      "suggested_scalar": 0.0137,
+      "log_bad": -0.5232,
+      "log_good": -0.4977
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.204,
+      "good": 0.2381,
+      "ratio": 1.1672,
+      "suggested_scalar": 0.0833,
+      "log_bad": -1.5896,
+      "log_good": -1.4351
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4545,
+      "good": 2.5505,
+      "ratio": 1.0391,
+      "suggested_scalar": 0.0207,
+      "log_bad": 0.8979,
+      "log_good": 0.9363
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 201.0,
+      "good": 210.0,
+      "ratio": 1.0448,
+      "suggested_scalar": 0.0236,
+      "log_bad": 5.3033,
+      "log_good": 5.3471
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 10.0,
+      "good": 9.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0567,
+      "log_bad": 2.3026,
+      "log_good": 2.1972
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8826,
+      "good": 5.8329,
+      "ratio": 0.9916,
+      "suggested_scalar": -0.0046,
+      "log_bad": 1.772,
+      "log_good": 1.7635
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.155,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.4756,
+      "good": 0.4313,
+      "ratio": 0.9069,
+      "suggested_scalar": -0.0527,
+      "log_bad": -0.7432,
+      "log_good": -0.841
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0267,
+      "good": 0.0278,
+      "ratio": 1.0412,
+      "suggested_scalar": 0.0217,
+      "log_bad": -3.6231,
+      "log_good": -3.5827
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.275,
+      "good": 5.0785,
+      "ratio": 0.9627,
+      "suggested_scalar": -0.0204,
+      "log_bad": 1.663,
+      "log_good": 1.625
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7913,
+      "good": 0.8001,
+      "ratio": 1.0111,
+      "suggested_scalar": 0.006,
+      "log_bad": -0.2341,
+      "log_good": -0.223
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2115,
+      "good": 0.2157,
+      "ratio": 1.0199,
+      "suggested_scalar": 0.0106,
+      "log_bad": -1.5535,
+      "log_good": -1.5339
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.5318,
+      "good": 4.5663,
+      "ratio": 1.0076,
+      "suggested_scalar": 0.0041,
+      "log_bad": 1.5111,
+      "log_good": 1.5187
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 174.0,
+      "good": 177.0,
+      "ratio": 1.0172,
+      "suggested_scalar": 0.0092,
+      "log_bad": 5.1591,
+      "log_good": 5.1761
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.3616,
+      "good": 0.3475,
+      "ratio": 0.961,
+      "suggested_scalar": -0.0214,
+      "log_bad": -1.0172,
+      "log_good": -1.057
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 58.0,
+      "good": 52.0,
+      "ratio": 0.8966,
+      "suggested_scalar": -0.0588,
+      "log_bad": 4.0604,
+      "log_good": 3.9512
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 651.0,
+      "good": 634.0,
+      "ratio": 0.9739,
+      "suggested_scalar": -0.0143,
+      "log_bad": 6.4785,
+      "log_good": 6.452
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 79.0,
+      "good": 75.0,
+      "ratio": 0.9494,
+      "suggested_scalar": -0.028,
+      "log_bad": 4.3694,
+      "log_good": 4.3175
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1478,
+      "good": 0.217,
+      "ratio": 1.4682,
+      "suggested_scalar": 0.2069,
+      "log_bad": -1.9119,
+      "log_good": -1.5279
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 28.0,
+      "good": 35.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.1202,
+      "log_bad": 3.3322,
+      "log_good": 3.5553
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 58.0,
+      "good": 52.0,
+      "ratio": 0.8966,
+      "suggested_scalar": -0.0588,
+      "log_bad": 4.0604,
+      "log_good": 3.9512
+    },
+    "brevity.mean_sample_size": {
+      "bad": 58.0,
+      "good": 52.0,
+      "ratio": 0.8966,
+      "suggested_scalar": -0.0588,
+      "log_bad": 4.0604,
+      "log_good": 3.9512
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 203.0,
+      "good": 212.0,
+      "ratio": 1.0443,
+      "suggested_scalar": 0.0234,
+      "log_bad": 5.3132,
+      "log_good": 5.3566
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 100.0,
+      "good": 113.0,
+      "ratio": 1.13,
+      "suggested_scalar": 0.0658,
+      "log_bad": 4.6052,
+      "log_good": 4.7274
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 138.0,
+      "good": 133.0,
+      "ratio": 0.9638,
+      "suggested_scalar": -0.0199,
+      "log_bad": 4.9273,
+      "log_good": 4.8903
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0099,
+      "good": 0.0094,
+      "ratio": 0.9495,
+      "suggested_scalar": -0.0279,
+      "log_bad": -4.6152,
+      "log_good": -4.667
+    },
+    "heaps.mean_k": {
+      "bad": 1.9351,
+      "good": 2.2807,
+      "ratio": 1.1786,
+      "suggested_scalar": 0.0885,
+      "log_bad": 0.6602,
+      "log_good": 0.8245
+    },
+    "halstead.mean_effort": {
+      "bad": 28989.6349,
+      "good": 29971.3438,
+      "ratio": 1.0339,
+      "suggested_scalar": 0.0179,
+      "log_bad": 10.2747,
+      "log_good": 10.308
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.9005,
+      "good": 0.8909,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.0058,
+      "log_bad": -0.1048,
+      "log_good": -0.1155
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 34.0,
+      "good": 30.0,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.0674,
+      "log_bad": 3.5264,
+      "log_good": 3.4012
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 107.0,
+      "good": 107.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.6728,
+      "log_good": 4.6728
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4,
+      "good": 0.375,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0348,
+      "log_bad": -0.9163,
+      "log_good": -0.9808
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.68,
+      "good": 8.8056,
+      "ratio": 1.0145,
+      "suggested_scalar": 0.0077,
+      "log_bad": 2.161,
+      "log_good": 2.1754
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2115,
+      "good": 0.2157,
+      "ratio": 1.0199,
+      "suggested_scalar": 0.0106,
+      "log_bad": -1.5535,
+      "log_good": -1.5339
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.3864,
+      "good": 6.6561,
+      "ratio": 1.0422,
+      "suggested_scalar": 0.0223,
+      "log_bad": 1.8542,
+      "log_good": 1.8955
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 202.0,
+      "good": 211.0,
+      "ratio": 1.0446,
+      "suggested_scalar": 0.0235,
+      "log_bad": 5.3083,
+      "log_good": 5.3519
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 14.0,
+      "good": 17.0,
+      "ratio": 1.2143,
+      "suggested_scalar": 0.1046,
+      "log_bad": 2.6391,
+      "log_good": 2.8332
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1610.5353,
+      "good": 1665.0747,
+      "ratio": 1.0339,
+      "suggested_scalar": 0.0179,
+      "log_bad": 7.3843,
+      "log_good": 7.4176
+    },
+    "readability.mean_total_lines": {
+      "bad": 40.0,
+      "good": 40.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6889,
+      "log_good": 3.6889
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1084.9175,
+      "good": 1042.4815,
+      "ratio": 0.9609,
+      "suggested_scalar": -0.0215,
+      "log_bad": 6.9893,
+      "log_good": 6.9494
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 440.0,
+      "good": 416.0,
+      "ratio": 0.9455,
+      "suggested_scalar": -0.0302,
+      "log_bad": 6.0868,
+      "log_good": 6.0307
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 24.825,
+      "good": 25.25,
+      "ratio": 1.0171,
+      "suggested_scalar": 0.0091,
+      "log_bad": 3.2119,
+      "log_good": 3.2288
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3861,
+      "good": 1.4021,
+      "ratio": 1.0115,
+      "suggested_scalar": 0.0062,
+      "log_bad": 0.3265,
+      "log_good": 0.338
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9195,
+      "good": 0.904,
+      "ratio": 0.9831,
+      "suggested_scalar": -0.0092,
+      "log_bad": -0.0839,
+      "log_good": -0.1009
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9722,
+      "good": 0.9716,
+      "ratio": 0.9994,
+      "suggested_scalar": -0.0003,
+      "log_bad": -0.0282,
+      "log_good": -0.0288
+    },
+    "halstead.mean_length": {
+      "bad": 186.0,
+      "good": 182.0,
+      "ratio": 0.9785,
+      "suggested_scalar": -0.0117,
+      "log_bad": 5.2257,
+      "log_good": 5.204
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.7,
+      "good": 4.6,
+      "ratio": 0.9787,
+      "suggested_scalar": -0.0116,
+      "log_bad": 1.5476,
+      "log_good": 1.5261
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.858,
+      "good": 5.7004,
+      "ratio": 0.9731,
+      "suggested_scalar": -0.0147,
+      "log_bad": 1.7678,
+      "log_good": 1.7405
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0926,
+      "good": 0.1065,
+      "ratio": 1.1501,
+      "suggested_scalar": 0.0753,
+      "log_bad": -2.3795,
+      "log_good": -2.2396
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 26.7206,
+      "good": 28.75,
+      "ratio": 1.0759,
+      "suggested_scalar": 0.0394,
+      "log_bad": 3.2854,
+      "log_good": 3.3586
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 30.0,
+      "good": 27.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0567,
+      "log_bad": 3.4012,
+      "log_good": 3.2958
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7971,
+      "good": 0.7368,
+      "ratio": 0.9244,
+      "suggested_scalar": -0.0424,
+      "log_bad": -0.2268,
+      "log_good": -0.3054
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 41.0,
+      "good": 40.0,
+      "ratio": 0.9756,
+      "suggested_scalar": -0.0133,
+      "log_bad": 3.7136,
+      "log_good": 3.6889
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 28.0,
+      "good": 28.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3322,
+      "log_good": 3.3322
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    }
+  },
+  "naming_conventions.constants_are_upper_case_with_underscores": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "scope_and_assignment.prefers_val_over_var": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 47.0,
+      "good": 47.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8501,
+      "log_good": 3.8501
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9412,
+      "good": 0.9545,
+      "ratio": 1.0141,
+      "suggested_scalar": 0.0049,
+      "log_bad": -0.0606,
+      "log_good": -0.0466
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5183,
+      "good": 4.5701,
+      "ratio": 1.0115,
+      "suggested_scalar": 0.0039,
+      "log_bad": 1.5081,
+      "log_good": 1.5195
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 108.0,
+      "good": 97.0,
+      "ratio": 0.8981,
+      "suggested_scalar": -0.0372,
+      "log_bad": 4.6821,
+      "log_good": 4.5747
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5536,
+      "good": 0.5404,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0084,
+      "log_bad": -0.5913,
+      "log_good": -0.6154
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 16.0,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.0223,
+      "log_bad": 2.7081,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7086,
+      "good": 0.7119,
+      "ratio": 1.0047,
+      "suggested_scalar": 0.0016,
+      "log_bad": -0.3445,
+      "log_good": -0.3398
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.902,
+      "good": 6.5455,
+      "ratio": 0.9483,
+      "suggested_scalar": -0.0184,
+      "log_bad": 1.9318,
+      "log_good": 1.8788
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 364.0,
+      "good": 327.0,
+      "ratio": 0.8984,
+      "suggested_scalar": -0.0371,
+      "log_bad": 5.8972,
+      "log_good": 5.79
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0631,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0392,
+      "good": 0.0455,
+      "ratio": 1.1607,
+      "suggested_scalar": 0.0516,
+      "log_bad": -3.2391,
+      "log_good": -3.09
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.001,
+      "good": 0.0006,
+      "ratio": 0.6,
+      "suggested_scalar": -0.1769,
+      "log_bad": -6.9078,
+      "log_good": -7.4186
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9369,
+      "good": 0.9384,
+      "ratio": 1.0016,
+      "suggested_scalar": 0.0006,
+      "log_bad": -0.0652,
+      "log_good": -0.0636
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 144.0,
+      "good": 125.0,
+      "ratio": 0.8681,
+      "suggested_scalar": -0.049,
+      "log_bad": 4.9698,
+      "log_good": 4.8283
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 75.8075,
+      "good": 73.9206,
+      "ratio": 0.9751,
+      "suggested_scalar": -0.0087,
+      "log_bad": 4.3282,
+      "log_good": 4.303
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4353,
+      "good": 0.4417,
+      "ratio": 1.0147,
+      "suggested_scalar": 0.0051,
+      "log_bad": -0.8317,
+      "log_good": -0.8171
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 19.8819,
+      "good": 20.7209,
+      "ratio": 1.0422,
+      "suggested_scalar": 0.0143,
+      "log_bad": 2.9898,
+      "log_good": 3.0311
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2071.0,
+      "good": 1810.0,
+      "ratio": 0.874,
+      "suggested_scalar": -0.0466,
+      "log_bad": 7.6358,
+      "log_good": 7.5011
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.098,
+      "good": 0.0682,
+      "ratio": 0.6959,
+      "suggested_scalar": -0.1255,
+      "log_bad": -2.3228,
+      "log_good": -2.6853
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.902,
+      "good": 0.9318,
+      "ratio": 1.033,
+      "suggested_scalar": 0.0113,
+      "log_bad": -0.1031,
+      "log_good": -0.0706
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.1373,
+      "good": 7.4318,
+      "ratio": 1.0413,
+      "suggested_scalar": 0.014,
+      "log_bad": 1.9653,
+      "log_good": 2.0058
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 16.3629,
+      "good": 17.5207,
+      "ratio": 1.0708,
+      "suggested_scalar": 0.0237,
+      "log_bad": 2.795,
+      "log_good": 2.8634
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 65.0,
+      "good": 51.0,
+      "ratio": 0.7846,
+      "suggested_scalar": -0.084,
+      "log_bad": 4.1744,
+      "log_good": 3.9318
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9485,
+      "good": 0.9435,
+      "ratio": 0.9947,
+      "suggested_scalar": -0.0018,
+      "log_bad": -0.0529,
+      "log_good": -0.0582
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 25.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0136,
+      "log_bad": 3.2581,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6311,
+      "good": 0.6166,
+      "ratio": 0.977,
+      "suggested_scalar": -0.008,
+      "log_bad": -0.4603,
+      "log_good": -0.4835
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.221,
+      "good": 0.2308,
+      "ratio": 1.0443,
+      "suggested_scalar": 0.015,
+      "log_bad": -1.5096,
+      "log_good": -1.4662
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7107,
+      "good": 2.6081,
+      "ratio": 0.9621,
+      "suggested_scalar": -0.0134,
+      "log_bad": 0.9972,
+      "log_good": 0.9586
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 362.0,
+      "good": 325.0,
+      "ratio": 0.8978,
+      "suggested_scalar": -0.0373,
+      "log_bad": 5.8916,
+      "log_good": 5.7838
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 31.0,
+      "good": 29.0,
+      "ratio": 0.9355,
+      "suggested_scalar": -0.0231,
+      "log_bad": 3.434,
+      "log_good": 3.3673
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.033,
+      "good": 0.0336,
+      "ratio": 1.0182,
+      "suggested_scalar": 0.0062,
+      "log_bad": -3.4112,
+      "log_good": -3.3932
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9773,
+      "good": 6.0224,
+      "ratio": 1.0075,
+      "suggested_scalar": 0.0026,
+      "log_bad": 1.788,
+      "log_good": 1.7955
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 32.0,
+      "good": 26.0,
+      "ratio": 0.8125,
+      "suggested_scalar": -0.0719,
+      "log_bad": 3.4657,
+      "log_good": 3.2581
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.5274,
+      "good": 1.5852,
+      "ratio": 1.0378,
+      "suggested_scalar": 0.0129,
+      "log_bad": 0.4236,
+      "log_good": 0.4607
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8117,
+      "good": 5.6214,
+      "ratio": 0.9673,
+      "suggested_scalar": -0.0115,
+      "log_bad": 1.7599,
+      "log_good": 1.7266
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7559,
+      "good": 0.7589,
+      "ratio": 1.004,
+      "suggested_scalar": 0.0014,
+      "log_bad": -0.2798,
+      "log_good": -0.2759
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1639,
+      "good": 0.1852,
+      "ratio": 1.13,
+      "suggested_scalar": 0.0423,
+      "log_bad": -1.8085,
+      "log_good": -1.6863
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.4589,
+      "good": 4.552,
+      "ratio": 1.0209,
+      "suggested_scalar": 0.0072,
+      "log_bad": 1.4949,
+      "log_good": 1.5156
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 318.0,
+      "good": 283.0,
+      "ratio": 0.8899,
+      "suggested_scalar": -0.0404,
+      "log_bad": 5.7621,
+      "log_good": 5.6454
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8151,
+      "good": 0.7106,
+      "ratio": 0.8718,
+      "suggested_scalar": -0.0475,
+      "log_bad": -0.2044,
+      "log_good": -0.3416
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 109.0,
+      "good": 99.0,
+      "ratio": 0.9083,
+      "suggested_scalar": -0.0333,
+      "log_bad": 4.6913,
+      "log_good": 4.5951
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1164.0,
+      "good": 1019.0,
+      "ratio": 0.8754,
+      "suggested_scalar": -0.0461,
+      "log_bad": 7.0596,
+      "log_good": 6.9266
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 173.0,
+      "good": 150.0,
+      "ratio": 0.8671,
+      "suggested_scalar": -0.0494,
+      "log_bad": 5.1533,
+      "log_good": 5.0106
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 0.0031,
+      "ratio": 0.0031,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.7764
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2665,
+      "good": 0.2722,
+      "ratio": 1.0214,
+      "suggested_scalar": 0.0073,
+      "log_bad": -1.3224,
+      "log_good": -1.3012
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 59.0,
+      "good": 54.0,
+      "ratio": 0.9153,
+      "suggested_scalar": -0.0307,
+      "log_bad": 4.0775,
+      "log_good": 3.989
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 109.0,
+      "good": 99.0,
+      "ratio": 0.9083,
+      "suggested_scalar": -0.0333,
+      "log_bad": 4.6913,
+      "log_good": 4.5951
+    },
+    "brevity.mean_sample_size": {
+      "bad": 109.0,
+      "good": 99.0,
+      "ratio": 0.9083,
+      "suggested_scalar": -0.0333,
+      "log_bad": 4.6913,
+      "log_good": 4.5951
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 364.0,
+      "good": 327.0,
+      "ratio": 0.8984,
+      "suggested_scalar": -0.0371,
+      "log_bad": 5.8972,
+      "log_good": 5.79
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 171.0,
+      "good": 158.0,
+      "ratio": 0.924,
+      "suggested_scalar": -0.0274,
+      "log_bad": 5.1417,
+      "log_good": 5.0626
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 264.0,
+      "good": 236.0,
+      "ratio": 0.8939,
+      "suggested_scalar": -0.0388,
+      "log_bad": 5.5759,
+      "log_good": 5.4638
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0027,
+      "good": 0.0031,
+      "ratio": 1.1481,
+      "suggested_scalar": 0.0478,
+      "log_bad": -5.9145,
+      "log_good": -5.7764
+    },
+    "heaps.mean_k": {
+      "bad": 1.7635,
+      "good": 1.6945,
+      "ratio": 0.9609,
+      "suggested_scalar": -0.0138,
+      "log_bad": 0.5673,
+      "log_good": 0.5274
+    },
+    "halstead.mean_effort": {
+      "bad": 67065.9829,
+      "good": 55514.8919,
+      "ratio": 0.8278,
+      "suggested_scalar": -0.0654,
+      "log_bad": 11.1134,
+      "log_good": 10.9244
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8587,
+      "good": 0.848,
+      "ratio": 0.9875,
+      "suggested_scalar": -0.0043,
+      "log_bad": -0.1523,
+      "log_good": -0.1649
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 82.0,
+      "good": 72.0,
+      "ratio": 0.878,
+      "suggested_scalar": -0.045,
+      "log_bad": 4.4067,
+      "log_good": 4.2767
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 189.0,
+      "good": 173.0,
+      "ratio": 0.9153,
+      "suggested_scalar": -0.0306,
+      "log_bad": 5.2417,
+      "log_good": 5.1533
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5139,
+      "good": 0.528,
+      "ratio": 1.0274,
+      "suggested_scalar": 0.0094,
+      "log_bad": -0.6657,
+      "log_good": -0.6387
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.0833,
+      "good": 8.152,
+      "ratio": 1.0085,
+      "suggested_scalar": 0.0029,
+      "log_bad": 2.0898,
+      "log_good": 2.0983
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1639,
+      "good": 0.1852,
+      "ratio": 1.13,
+      "suggested_scalar": 0.0423,
+      "log_bad": -1.8085,
+      "log_good": -1.6863
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.0128,
+      "good": 5.8643,
+      "ratio": 0.9753,
+      "suggested_scalar": -0.0087,
+      "log_bad": 1.7939,
+      "log_good": 1.7689
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 363.0,
+      "good": 326.0,
+      "ratio": 0.8981,
+      "suggested_scalar": -0.0372,
+      "log_bad": 5.8944,
+      "log_good": 5.7869
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 36.0,
+      "good": 33.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0301,
+      "log_bad": 3.5835,
+      "log_good": 3.4965
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3725.8879,
+      "good": 3084.1607,
+      "ratio": 0.8278,
+      "suggested_scalar": -0.0654,
+      "log_bad": 8.2231,
+      "log_good": 8.034
+    },
+    "readability.mean_total_lines": {
+      "bad": 51.0,
+      "good": 44.0,
+      "ratio": 0.8627,
+      "suggested_scalar": -0.0511,
+      "log_bad": 3.9318,
+      "log_good": 3.7842
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2445.2693,
+      "good": 2131.7718,
+      "ratio": 0.8718,
+      "suggested_scalar": -0.0475,
+      "log_bad": 7.8019,
+      "log_good": 7.6647
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 764.0,
+      "good": 694.0,
+      "ratio": 0.9084,
+      "suggested_scalar": -0.0333,
+      "log_bad": 6.6386,
+      "log_good": 6.5425
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 39.4118,
+      "good": 39.8182,
+      "ratio": 1.0103,
+      "suggested_scalar": 0.0036,
+      "log_bad": 3.6741,
+      "log_good": 3.6843
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.4632,
+      "good": 1.4819,
+      "ratio": 1.0128,
+      "suggested_scalar": 0.0044,
+      "log_bad": 0.3806,
+      "log_good": 0.3933
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.0631,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 37.0,
+      "good": 38.0,
+      "ratio": 1.027,
+      "suggested_scalar": 0.0092,
+      "log_bad": 3.6109,
+      "log_good": 3.6376
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8868,
+      "good": 0.8834,
+      "ratio": 0.9962,
+      "suggested_scalar": -0.0013,
+      "log_bad": -0.1201,
+      "log_good": -0.124
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9874,
+      "good": 0.9905,
+      "ratio": 1.0031,
+      "suggested_scalar": 0.0011,
+      "log_bad": -0.0127,
+      "log_good": -0.0095
+    },
+    "halstead.mean_length": {
+      "bad": 362.0,
+      "good": 323.0,
+      "ratio": 0.8923,
+      "suggested_scalar": -0.0395,
+      "log_bad": 5.8916,
+      "log_good": 5.7777
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 21.5,
+      "good": 18.0,
+      "ratio": 0.8372,
+      "suggested_scalar": -0.0615,
+      "log_bad": 3.0681,
+      "log_good": 2.8904
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7682,
+      "good": 6.6294,
+      "ratio": 0.9795,
+      "suggested_scalar": -0.0072,
+      "log_bad": 1.9122,
+      "log_good": 1.8915
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0826,
+      "good": 0.0875,
+      "ratio": 1.0593,
+      "suggested_scalar": 0.02,
+      "log_bad": -2.4937,
+      "log_good": -2.4361
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.4268,
+      "good": 26.0417,
+      "ratio": 0.9495,
+      "suggested_scalar": -0.0179,
+      "log_bad": 3.3115,
+      "log_good": 3.2597
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 3.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.1769,
+      "log_bad": 1.6094,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 74.0,
+      "good": 66.0,
+      "ratio": 0.8919,
+      "suggested_scalar": -0.0396,
+      "log_bad": 4.3041,
+      "log_good": 4.1897
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7765,
+      "good": 0.7712,
+      "ratio": 0.9932,
+      "suggested_scalar": -0.0024,
+      "log_bad": -0.253,
+      "log_good": -0.2598
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 51.0,
+      "good": 44.0,
+      "ratio": 0.8627,
+      "suggested_scalar": -0.0511,
+      "log_bad": 3.9318,
+      "log_good": 3.7842
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.uses_enumerate_not_range_len": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 62.0,
+      "good": 58.0,
+      "ratio": 0.9355,
+      "suggested_scalar": -0.1924,
+      "log_bad": 4.1271,
+      "log_good": 4.0604
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0361,
+      "good": 0.0382,
+      "ratio": 1.0582,
+      "suggested_scalar": 0.1631,
+      "log_bad": -3.3215,
+      "log_good": -3.2649
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.25,
+      "good": 1.2,
+      "ratio": 0.96,
+      "suggested_scalar": -0.1178,
+      "log_bad": 0.2231,
+      "log_good": 0.1823
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9434,
+      "good": 0.9608,
+      "ratio": 1.0184,
+      "suggested_scalar": 0.0527,
+      "log_bad": -0.0583,
+      "log_good": -0.04
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0361,
+      "good": 0.0382,
+      "ratio": 1.0582,
+      "suggested_scalar": 0.1631,
+      "log_bad": -3.3215,
+      "log_good": -3.2649
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.3777,
+      "good": 4.601,
+      "ratio": 1.051,
+      "suggested_scalar": 0.1435,
+      "log_bad": 1.4765,
+      "log_good": 1.5263
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 87.0,
+      "good": 92.0,
+      "ratio": 1.0575,
+      "suggested_scalar": 0.1612,
+      "log_bad": 4.4659,
+      "log_good": 4.5218
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3898,
+      "good": 0.4232,
+      "ratio": 1.0857,
+      "suggested_scalar": 0.2372,
+      "log_bad": -0.9421,
+      "log_good": -0.8599
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.0,
+      "good": 20.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.1408,
+      "log_bad": 3.0445,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5752,
+      "good": 0.5822,
+      "ratio": 1.0122,
+      "suggested_scalar": 0.0349,
+      "log_bad": -0.553,
+      "log_good": -0.5409
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.3396,
+      "good": 5.3333,
+      "ratio": 0.8413,
+      "suggested_scalar": -0.4987,
+      "log_bad": 1.8468,
+      "log_good": 1.674
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 526.0,
+      "good": 576.0,
+      "ratio": 1.0951,
+      "suggested_scalar": 0.262,
+      "log_bad": 6.2653,
+      "log_good": 6.3561
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1113,
+      "good": 1.1013,
+      "ratio": 0.991,
+      "suggested_scalar": -0.0261,
+      "log_bad": 0.1055,
+      "log_good": 0.0965
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 183.0,
+      "good": 200.0,
+      "ratio": 1.0929,
+      "suggested_scalar": 0.2563,
+      "log_bad": 5.2095,
+      "log_good": 5.2983
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 109.7043,
+      "good": 104.458,
+      "ratio": 0.9522,
+      "suggested_scalar": -0.1414,
+      "log_bad": 4.6978,
+      "log_good": 4.6488
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6381,
+      "good": 0.6017,
+      "ratio": 0.943,
+      "suggested_scalar": -0.1695,
+      "log_bad": -0.4493,
+      "log_good": -0.508
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.1299,
+      "good": 9.0771,
+      "ratio": 1.1165,
+      "suggested_scalar": 0.318,
+      "log_bad": 2.0955,
+      "log_good": 2.2058
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2009.0,
+      "good": 2232.0,
+      "ratio": 1.111,
+      "suggested_scalar": 0.3037,
+      "log_bad": 7.6054,
+      "log_good": 7.7107
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2453,
+      "good": 0.2549,
+      "ratio": 1.0391,
+      "suggested_scalar": 0.1108,
+      "log_bad": -1.4053,
+      "log_good": -1.3669
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9245,
+      "good": 0.9608,
+      "ratio": 1.0393,
+      "suggested_scalar": 0.1111,
+      "log_bad": -0.0785,
+      "log_good": -0.04
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.9245,
+      "good": 11.2941,
+      "ratio": 1.138,
+      "suggested_scalar": 0.373,
+      "log_bad": 2.295,
+      "log_good": 2.4243
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 22.6016,
+      "good": 17.3595,
+      "ratio": 0.7681,
+      "suggested_scalar": -0.7614,
+      "log_bad": 3.118,
+      "log_good": 2.8541
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 171.0,
+      "good": 179.0,
+      "ratio": 1.0468,
+      "suggested_scalar": 0.1319,
+      "log_bad": 5.1417,
+      "log_good": 5.1874
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9449,
+      "good": 0.9366,
+      "ratio": 0.9912,
+      "suggested_scalar": -0.0255,
+      "log_bad": -0.0567,
+      "log_good": -0.0655
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 33.0,
+      "good": 31.0,
+      "ratio": 0.9394,
+      "suggested_scalar": -0.1804,
+      "log_bad": 3.4965,
+      "log_good": 3.434
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6361,
+      "good": 0.6219,
+      "ratio": 0.9777,
+      "suggested_scalar": -0.0651,
+      "log_bad": -0.4524,
+      "log_good": -0.475
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5076,
+      "good": 0.4477,
+      "ratio": 0.882,
+      "suggested_scalar": -0.3623,
+      "log_bad": -0.6781,
+      "log_good": -0.8036
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7483,
+      "good": 2.6445,
+      "ratio": 0.9622,
+      "suggested_scalar": -0.1111,
+      "log_bad": 1.011,
+      "log_good": 0.9725
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 524.0,
+      "good": 574.0,
+      "ratio": 1.0954,
+      "suggested_scalar": 0.263,
+      "log_bad": 6.2615,
+      "log_good": 6.3526
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 17.0,
+      "good": 14.0,
+      "ratio": 0.8235,
+      "suggested_scalar": -0.5602,
+      "log_bad": 2.8332,
+      "log_good": 2.6391
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0304,
+      "good": 0.0278,
+      "ratio": 0.9145,
+      "suggested_scalar": -0.258,
+      "log_bad": -3.4933,
+      "log_good": -3.5827
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.9307,
+      "ratio": 1.004,
+      "suggested_scalar": 0.0116,
+      "log_bad": 1.7761,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 11.0,
+      "good": 20.0,
+      "ratio": 1.8182,
+      "suggested_scalar": 1.725,
+      "log_bad": 2.3979,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.3763,
+      "good": 0.5136,
+      "ratio": 1.3649,
+      "suggested_scalar": 0.8975,
+      "log_bad": -0.9774,
+      "log_good": -0.6663
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.6141,
+      "good": 5.8041,
+      "ratio": 1.0338,
+      "suggested_scalar": 0.096,
+      "log_bad": 1.7253,
+      "log_good": 1.7586
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7411,
+      "good": 0.7758,
+      "ratio": 1.0468,
+      "suggested_scalar": 0.132,
+      "log_bad": -0.2996,
+      "log_good": -0.2539
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1719,
+      "good": 0.2031,
+      "ratio": 1.1815,
+      "suggested_scalar": 0.4812,
+      "log_bad": -1.7608,
+      "log_good": -1.5941
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.8513,
+      "good": 3.0128,
+      "ratio": 1.0566,
+      "suggested_scalar": 0.159,
+      "log_bad": 1.0478,
+      "log_good": 1.1029
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 328.0,
+      "good": 391.0,
+      "ratio": 1.1921,
+      "suggested_scalar": 0.5069,
+      "log_bad": 5.793,
+      "log_good": 5.9687
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 16.0,
+      "good": 22.0,
+      "ratio": 1.375,
+      "suggested_scalar": 0.9189,
+      "log_bad": 2.7726,
+      "log_good": 3.091
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8999,
+      "good": 1.0068,
+      "ratio": 1.1188,
+      "suggested_scalar": 0.3239,
+      "log_bad": -0.1055,
+      "log_good": 0.0068
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 119.0,
+      "ratio": 1.1121,
+      "suggested_scalar": 0.3067,
+      "log_bad": 4.6728,
+      "log_good": 4.7791
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 900.0,
+      "good": 1146.0,
+      "ratio": 1.2733,
+      "suggested_scalar": 0.6972,
+      "log_bad": 6.8024,
+      "log_good": 7.044
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 154.0,
+      "good": 177.0,
+      "ratio": 1.1494,
+      "suggested_scalar": 0.4016,
+      "log_bad": 5.037,
+      "log_good": 5.1761
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0076,
+      "good": 0.0087,
+      "ratio": 1.1447,
+      "suggested_scalar": 0.39,
+      "log_bad": -4.8796,
+      "log_good": -4.7444
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2452,
+      "good": 0.2639,
+      "ratio": 1.0763,
+      "suggested_scalar": 0.2121,
+      "log_bad": -1.4057,
+      "log_good": -1.3322
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 75.0,
+      "good": 87.0,
+      "ratio": 1.16,
+      "suggested_scalar": 0.4282,
+      "log_bad": 4.3175,
+      "log_good": 4.4659
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.6439,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 119.0,
+      "ratio": 1.1121,
+      "suggested_scalar": 0.3067,
+      "log_bad": 4.6728,
+      "log_good": 4.7791
+    },
+    "brevity.mean_sample_size": {
+      "bad": 107.0,
+      "good": 119.0,
+      "ratio": 1.1121,
+      "suggested_scalar": 0.3067,
+      "log_bad": 4.6728,
+      "log_good": 4.7791
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 526.0,
+      "good": 576.0,
+      "ratio": 1.0951,
+      "suggested_scalar": 0.262,
+      "log_bad": 6.2653,
+      "log_good": 6.3561
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 278.0,
+      "good": 298.0,
+      "ratio": 1.0719,
+      "suggested_scalar": 0.2005,
+      "log_bad": 5.6276,
+      "log_good": 5.6971
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 265.0,
+      "good": 316.0,
+      "ratio": 1.1925,
+      "suggested_scalar": 0.5079,
+      "log_bad": 5.5797,
+      "log_good": 5.7557
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0019,
+      "good": 0.0017,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.3209,
+      "log_bad": -6.2659,
+      "log_good": -6.3771
+    },
+    "heaps.mean_k": {
+      "bad": 3.2273,
+      "good": 3.0714,
+      "ratio": 0.9517,
+      "suggested_scalar": -0.1429,
+      "log_bad": 1.1716,
+      "log_good": 1.1221
+    },
+    "halstead.mean_effort": {
+      "bad": 127030.8637,
+      "good": 135844.141,
+      "ratio": 1.0694,
+      "suggested_scalar": 0.1935,
+      "log_bad": 11.7522,
+      "log_good": 11.8193
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8328,
+      "good": 0.8418,
+      "ratio": 1.0108,
+      "suggested_scalar": 0.031,
+      "log_bad": -0.183,
+      "log_good": -0.1722
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 54.0,
+      "good": 61.0,
+      "ratio": 1.1296,
+      "suggested_scalar": 0.3517,
+      "log_bad": 3.989,
+      "log_good": 4.1109
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 265.0,
+      "good": 286.0,
+      "ratio": 1.0792,
+      "suggested_scalar": 0.22,
+      "log_bad": 5.5797,
+      "log_good": 5.656
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3388,
+      "good": 0.37,
+      "ratio": 1.0921,
+      "suggested_scalar": 0.2542,
+      "log_bad": -1.0823,
+      "log_good": -0.9943
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 4.918,
+      "good": 5.73,
+      "ratio": 1.1651,
+      "suggested_scalar": 0.4409,
+      "log_bad": 1.5929,
+      "log_good": 1.7457
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1719,
+      "good": 0.2031,
+      "ratio": 1.1815,
+      "suggested_scalar": 0.4812,
+      "log_bad": -1.7608,
+      "log_good": -1.5941
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.9698,
+      "good": 4.6669,
+      "ratio": 1.1756,
+      "suggested_scalar": 0.4668,
+      "log_bad": 1.3787,
+      "log_good": 1.5405
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 525.0,
+      "good": 575.0,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.2625,
+      "log_bad": 6.2634,
+      "log_good": 6.3544
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 70.0,
+      "good": 74.0,
+      "ratio": 1.0571,
+      "suggested_scalar": 0.1603,
+      "log_bad": 4.2485,
+      "log_good": 4.3041
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 7057.2702,
+      "good": 7546.8967,
+      "ratio": 1.0694,
+      "suggested_scalar": 0.1935,
+      "log_bad": 8.8618,
+      "log_good": 8.9289
+    },
+    "readability.mean_total_lines": {
+      "bad": 53.0,
+      "good": 51.0,
+      "ratio": 0.9623,
+      "suggested_scalar": -0.111,
+      "log_bad": 3.9703,
+      "log_good": 3.9318
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2699.5933,
+      "good": 3020.4092,
+      "ratio": 1.1188,
+      "suggested_scalar": 0.324,
+      "log_bad": 7.9009,
+      "log_good": 8.0131
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 731.0,
+      "good": 844.0,
+      "ratio": 1.1546,
+      "suggested_scalar": 0.4147,
+      "log_bad": 6.5944,
+      "log_good": 6.7382
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 36.6604,
+      "good": 42.4706,
+      "ratio": 1.1585,
+      "suggested_scalar": 0.4245,
+      "log_bad": 3.6017,
+      "log_good": 3.7488
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.029,
+      "good": 1.0746,
+      "ratio": 1.0443,
+      "suggested_scalar": 0.1251,
+      "log_bad": 0.0286,
+      "log_good": 0.0719
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 46.0,
+      "good": 35.0,
+      "ratio": 0.7609,
+      "suggested_scalar": -0.7886,
+      "log_bad": 3.8286,
+      "log_good": 3.5553
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7866,
+      "good": 0.8107,
+      "ratio": 1.0306,
+      "suggested_scalar": 0.0871,
+      "log_bad": -0.24,
+      "log_good": -0.2099
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.482,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9426,
+      "good": 0.9663,
+      "ratio": 1.0251,
+      "suggested_scalar": 0.0717,
+      "log_bad": -0.0591,
+      "log_good": -0.0343
+    },
+    "halstead.mean_length": {
+      "bad": 419.0,
+      "good": 463.0,
+      "ratio": 1.105,
+      "suggested_scalar": 0.2881,
+      "log_bad": 6.0379,
+      "log_good": 6.1377
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 12.5,
+      "good": 9.8,
+      "ratio": 0.784,
+      "suggested_scalar": -0.7021,
+      "log_bad": 2.5257,
+      "log_good": 2.2824
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7415,
+      "good": 6.8948,
+      "ratio": 1.0227,
+      "suggested_scalar": 0.0649,
+      "log_bad": 1.9083,
+      "log_good": 1.9308
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1385,
+      "good": 0.1336,
+      "ratio": 0.9646,
+      "suggested_scalar": -0.1039,
+      "log_bad": -1.9769,
+      "log_good": -2.0129
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 47.0556,
+      "good": 44.9754,
+      "ratio": 0.9558,
+      "suggested_scalar": -0.1305,
+      "log_bad": 3.8513,
+      "log_good": 3.8061
+    },
+    "branching.mean_branch_count": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 62.0,
+      "good": 74.0,
+      "ratio": 1.1935,
+      "suggested_scalar": 0.5105,
+      "log_bad": 4.1271,
+      "log_good": 4.3041
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.717,
+      "good": 0.7247,
+      "ratio": 1.0107,
+      "suggested_scalar": 0.0308,
+      "log_bad": -0.3327,
+      "log_good": -0.322
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 53.0,
+      "good": 51.0,
+      "ratio": 0.9623,
+      "suggested_scalar": -0.111,
+      "log_bad": 3.9703,
+      "log_good": 3.9318
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.uses_recover_in_long_running_goroutines": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.376,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 9.0,
+      "good": 12.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0985,
+      "log_bad": 2.1972,
+      "log_good": 2.4849
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0161,
+      "good": 0.0173,
+      "ratio": 1.0745,
+      "suggested_scalar": 0.0246,
+      "log_bad": -4.1289,
+      "log_good": -4.057
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.0,
+      "good": 1.6667,
+      "ratio": 0.8334,
+      "suggested_scalar": -0.0624,
+      "log_bad": 0.6931,
+      "log_good": 0.5108
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.875,
+      "good": 0.86,
+      "ratio": 0.9829,
+      "suggested_scalar": -0.0059,
+      "log_bad": -0.1335,
+      "log_good": -0.1508
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0161,
+      "good": 0.0173,
+      "ratio": 1.0745,
+      "suggested_scalar": 0.0246,
+      "log_bad": -4.1289,
+      "log_good": -4.057
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8471,
+      "good": 4.8956,
+      "ratio": 1.01,
+      "suggested_scalar": 0.0034,
+      "log_bad": 1.5784,
+      "log_good": 1.5883
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 87.0,
+      "good": 101.0,
+      "ratio": 1.1609,
+      "suggested_scalar": 0.0511,
+      "log_bad": 4.4659,
+      "log_good": 4.6151
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.49,
+      "good": 0.5053,
+      "ratio": 1.0312,
+      "suggested_scalar": 0.0105,
+      "log_bad": -0.7133,
+      "log_good": -0.6826
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7201,
+      "good": 0.6757,
+      "ratio": 0.9383,
+      "suggested_scalar": -0.0218,
+      "log_bad": -0.3284,
+      "log_good": -0.392
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.2,
+      "good": 1.1,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0298,
+      "log_bad": 0.1823,
+      "log_good": 0.0953
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 248.0,
+      "good": 347.0,
+      "ratio": 1.3992,
+      "suggested_scalar": 0.115,
+      "log_bad": 5.5134,
+      "log_good": 5.8493
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0764,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.002,
+      "good": 0.0022,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0326,
+      "log_bad": -6.2146,
+      "log_good": -6.1193
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1,
+      "good": 0.08,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0764,
+      "log_bad": -2.3026,
+      "log_good": -2.5257
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.816,
+      "good": 0.8897,
+      "ratio": 1.0903,
+      "suggested_scalar": 0.0296,
+      "log_bad": -0.2033,
+      "log_good": -0.1169
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 109.0,
+      "good": 150.0,
+      "ratio": 1.3761,
+      "suggested_scalar": 0.1093,
+      "log_bad": 4.6913,
+      "log_good": 5.0106
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 112.8768,
+      "good": 109.7328,
+      "ratio": 0.9721,
+      "suggested_scalar": -0.0097,
+      "log_bad": 4.7263,
+      "log_good": 4.698
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.3239,
+      "good": 0.4769,
+      "ratio": 1.4724,
+      "suggested_scalar": 0.1324,
+      "log_bad": -1.1273,
+      "log_good": -0.7404
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 6.1554,
+      "good": 9.8457,
+      "ratio": 1.5995,
+      "suggested_scalar": 0.1608,
+      "log_bad": 1.8173,
+      "log_good": 2.287
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1015.0,
+      "good": 1378.0,
+      "ratio": 1.3576,
+      "suggested_scalar": 0.1047,
+      "log_bad": 6.9226,
+      "log_good": 7.2284
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2,
+      "good": 0.18,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0361,
+      "log_bad": -1.6094,
+      "log_good": -1.7148
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.775,
+      "good": 0.78,
+      "ratio": 1.0065,
+      "suggested_scalar": 0.0022,
+      "log_bad": -0.2549,
+      "log_good": -0.2485
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.2,
+      "good": 6.94,
+      "ratio": 1.1194,
+      "suggested_scalar": 0.0386,
+      "log_bad": 1.8245,
+      "log_good": 1.9373
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.61,
+      "good": 1.25,
+      "ratio": 0.7764,
+      "suggested_scalar": -0.0866,
+      "log_bad": 0.4762,
+      "log_good": 0.2231
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 78.0,
+      "good": 111.0,
+      "ratio": 1.4231,
+      "suggested_scalar": 0.1208,
+      "log_bad": 4.3567,
+      "log_good": 4.7095
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9166,
+      "good": 0.9366,
+      "ratio": 1.0218,
+      "suggested_scalar": 0.0074,
+      "log_bad": -0.0871,
+      "log_good": -0.0655
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 30.0,
+      "good": 31.0,
+      "ratio": 1.0333,
+      "suggested_scalar": 0.0112,
+      "log_bad": 3.4012,
+      "log_good": 3.434
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.4985,
+      "good": 0.5377,
+      "ratio": 1.0786,
+      "suggested_scalar": 0.0259,
+      "log_bad": -0.6962,
+      "log_good": -0.6205
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.126,
+      "good": 0.2667,
+      "ratio": 2.1167,
+      "suggested_scalar": 0.2567,
+      "log_bad": -2.0715,
+      "log_good": -1.3216
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.9941,
+      "good": 2.1633,
+      "ratio": 1.0849,
+      "suggested_scalar": 0.0279,
+      "log_bad": 0.6902,
+      "log_good": 0.7716
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 246.0,
+      "good": 345.0,
+      "ratio": 1.4024,
+      "suggested_scalar": 0.1158,
+      "log_bad": 5.5053,
+      "log_good": 5.8435
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0202,
+      "good": 0.0173,
+      "ratio": 0.8564,
+      "suggested_scalar": -0.053,
+      "log_bad": -3.9021,
+      "log_good": -4.057
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.9069,
+      "ratio": 1.0127,
+      "suggested_scalar": 0.0043,
+      "log_bad": 1.7635,
+      "log_good": 1.7761
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 31.0,
+      "good": 36.0,
+      "ratio": 1.1613,
+      "suggested_scalar": 0.0512,
+      "log_bad": 3.434,
+      "log_good": 3.5835
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8614,
+      "good": 0.9285,
+      "ratio": 1.0779,
+      "suggested_scalar": 0.0257,
+      "log_bad": -0.1492,
+      "log_good": -0.0742
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9151,
+      "good": 5.9741,
+      "ratio": 1.01,
+      "suggested_scalar": 0.0034,
+      "log_bad": 1.7775,
+      "log_good": 1.7874
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.831,
+      "good": 0.8288,
+      "ratio": 0.9974,
+      "suggested_scalar": -0.0009,
+      "log_bad": -0.1851,
+      "log_good": -0.1878
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1304,
+      "good": 0.1379,
+      "ratio": 1.0575,
+      "suggested_scalar": 0.0191,
+      "log_bad": -2.0371,
+      "log_good": -1.9812
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.481,
+      "good": 3.1378,
+      "ratio": 1.2647,
+      "suggested_scalar": 0.0804,
+      "log_bad": 0.9087,
+      "log_good": 1.1435
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 230.0,
+      "good": 296.0,
+      "ratio": 1.287,
+      "suggested_scalar": 0.0864,
+      "log_bad": 5.4381,
+      "log_good": 5.6904
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2373,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.494,
+      "good": 0.7058,
+      "ratio": 1.4287,
+      "suggested_scalar": 0.1221,
+      "log_bad": -0.7052,
+      "log_good": -0.3484
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 88.0,
+      "good": 101.0,
+      "ratio": 1.1477,
+      "suggested_scalar": 0.0472,
+      "log_bad": 4.4773,
+      "log_good": 4.6151
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 560.0,
+      "good": 789.0,
+      "ratio": 1.4089,
+      "suggested_scalar": 0.1173,
+      "log_bad": 6.3279,
+      "log_good": 6.6708
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 114.0,
+      "good": 152.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0985,
+      "log_bad": 4.7362,
+      "log_good": 5.0239
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1976,
+      "good": 0.2133,
+      "ratio": 1.0795,
+      "suggested_scalar": 0.0262,
+      "log_bad": -1.6215,
+      "log_good": -1.5451
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 34.0,
+      "good": 66.0,
+      "ratio": 1.9412,
+      "suggested_scalar": 0.227,
+      "log_bad": 3.5264,
+      "log_good": 4.1897
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1388,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 88.0,
+      "good": 101.0,
+      "ratio": 1.1477,
+      "suggested_scalar": 0.0472,
+      "log_bad": 4.4773,
+      "log_good": 4.6151
+    },
+    "brevity.mean_sample_size": {
+      "bad": 88.0,
+      "good": 101.0,
+      "ratio": 1.1477,
+      "suggested_scalar": 0.0472,
+      "log_bad": 4.4773,
+      "log_good": 4.6151
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 248.0,
+      "good": 347.0,
+      "ratio": 1.3992,
+      "suggested_scalar": 0.115,
+      "log_bad": 5.5134,
+      "log_good": 5.8493
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 110.0,
+      "good": 160.0,
+      "ratio": 1.4545,
+      "suggested_scalar": 0.1283,
+      "log_bad": 4.7005,
+      "log_good": 5.0752
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 201.0,
+      "good": 247.0,
+      "ratio": 1.2289,
+      "suggested_scalar": 0.0705,
+      "log_bad": 5.3033,
+      "log_good": 5.5094
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 0.0029,
+      "ratio": 0.0029,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.843
+    },
+    "heaps.mean_k": {
+      "bad": 1.865,
+      "good": 2.1439,
+      "ratio": 1.1495,
+      "suggested_scalar": 0.0477,
+      "log_bad": 0.6233,
+      "log_good": 0.7626
+    },
+    "halstead.mean_effort": {
+      "bad": 44456.3101,
+      "good": 71262.6473,
+      "ratio": 1.603,
+      "suggested_scalar": 0.1615,
+      "log_bad": 10.7023,
+      "log_good": 11.1741
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.9157,
+      "good": 0.8973,
+      "ratio": 0.9799,
+      "suggested_scalar": -0.0069,
+      "log_bad": -0.0881,
+      "log_good": -0.1084
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 57.0,
+      "good": 70.0,
+      "ratio": 1.2281,
+      "suggested_scalar": 0.0703,
+      "log_bad": 4.0431,
+      "log_good": 4.2485
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 116.0,
+      "good": 166.0,
+      "ratio": 1.431,
+      "suggested_scalar": 0.1227,
+      "log_bad": 4.7536,
+      "log_good": 5.112
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4679,
+      "good": 0.4133,
+      "ratio": 0.8833,
+      "suggested_scalar": -0.0425,
+      "log_bad": -0.7595,
+      "log_good": -0.8836
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.1376,
+      "good": 5.26,
+      "ratio": 1.0238,
+      "suggested_scalar": 0.0081,
+      "log_bad": 1.6366,
+      "log_good": 1.6601
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1304,
+      "good": 0.1379,
+      "ratio": 1.0575,
+      "suggested_scalar": 0.0191,
+      "log_bad": -2.0371,
+      "log_good": -1.9812
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.48,
+      "good": 3.4212,
+      "ratio": 1.3795,
+      "suggested_scalar": 0.1101,
+      "log_bad": 0.9083,
+      "log_good": 1.23
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 247.0,
+      "good": 346.0,
+      "ratio": 1.4008,
+      "suggested_scalar": 0.1154,
+      "log_bad": 5.5094,
+      "log_good": 5.8464
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 15.0,
+      "good": 43.0,
+      "ratio": 2.8667,
+      "suggested_scalar": 0.3605,
+      "log_bad": 2.7081,
+      "log_good": 3.7612
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2469.795,
+      "good": 3959.036,
+      "ratio": 1.603,
+      "suggested_scalar": 0.1615,
+      "log_bad": 7.8119,
+      "log_good": 8.2838
+    },
+    "readability.mean_total_lines": {
+      "bad": 40.0,
+      "good": 50.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0764,
+      "log_bad": 3.6889,
+      "log_good": 3.912
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1481.877,
+      "good": 2117.3113,
+      "ratio": 1.4288,
+      "suggested_scalar": 0.1221,
+      "log_bad": 7.3011,
+      "log_good": 7.6579
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 509.0,
+      "good": 637.0,
+      "ratio": 1.2515,
+      "suggested_scalar": 0.0768,
+      "log_bad": 6.2324,
+      "log_good": 6.4568
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 24.175,
+      "good": 26.36,
+      "ratio": 1.0904,
+      "suggested_scalar": 0.0296,
+      "log_bad": 3.1853,
+      "log_good": 3.2718
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0362,
+      "good": 1.0645,
+      "ratio": 1.0273,
+      "suggested_scalar": 0.0092,
+      "log_bad": 0.0356,
+      "log_good": 0.0625
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0764,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 17.0,
+      "good": 24.0,
+      "ratio": 1.4118,
+      "suggested_scalar": 0.118,
+      "log_bad": 2.8332,
+      "log_good": 3.1781
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9348,
+      "good": 0.8547,
+      "ratio": 0.9143,
+      "suggested_scalar": -0.0307,
+      "log_bad": -0.0674,
+      "log_good": -0.157
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9724,
+      "good": 0.9754,
+      "ratio": 1.0031,
+      "suggested_scalar": 0.0011,
+      "log_bad": -0.028,
+      "log_good": -0.0249
+    },
+    "halstead.mean_length": {
+      "bad": 230.0,
+      "good": 318.0,
+      "ratio": 1.3826,
+      "suggested_scalar": 0.1109,
+      "log_bad": 5.4381,
+      "log_good": 5.7621
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.0,
+      "good": 11.3333,
+      "ratio": 1.0303,
+      "suggested_scalar": 0.0102,
+      "log_bad": 2.3979,
+      "log_good": 2.4277
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4594,
+      "good": 6.6582,
+      "ratio": 1.0308,
+      "suggested_scalar": 0.0104,
+      "log_bad": 1.8655,
+      "log_good": 1.8958
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1086,
+      "good": 0.1163,
+      "ratio": 1.0709,
+      "suggested_scalar": 0.0234,
+      "log_bad": -2.2201,
+      "log_good": -2.1516
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.0,
+      "good": 33.6571,
+      "ratio": 1.1219,
+      "suggested_scalar": 0.0394,
+      "log_bad": 3.4012,
+      "log_good": 3.5162
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 9.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0403,
+      "log_bad": 2.0794,
+      "log_good": 2.1972
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 51.0,
+      "good": 62.0,
+      "ratio": 1.2157,
+      "suggested_scalar": 0.0669,
+      "log_bad": 3.9318,
+      "log_good": 4.1271
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8308,
+      "good": 0.7328,
+      "ratio": 0.882,
+      "suggested_scalar": -0.043,
+      "log_bad": -0.1854,
+      "log_good": -0.3109
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 40.0,
+      "good": 50.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0764,
+      "log_bad": 3.6889,
+      "log_good": 3.912
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 12.0,
+      "good": 18.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1388,
+      "log_bad": 2.4849,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "consistency.static_member_via_class_name": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0056,
+      "good": 0.0032,
+      "ratio": 0.5714,
+      "suggested_scalar": -2.0,
+      "log_bad": -5.185,
+      "log_good": -5.7446
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.5714,
+      "good": 0.7143,
+      "ratio": 1.2501,
+      "suggested_scalar": 0.7977,
+      "log_bad": -0.5597,
+      "log_good": -0.3365
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.86,
+      "good": 0.8367,
+      "ratio": 0.9729,
+      "suggested_scalar": -0.0982,
+      "log_bad": -0.1508,
+      "log_good": -0.1783
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0056,
+      "good": 0.0032,
+      "ratio": 0.5714,
+      "suggested_scalar": -2.0,
+      "log_bad": -5.185,
+      "log_good": -5.7446
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7012,
+      "good": 4.722,
+      "ratio": 1.0044,
+      "suggested_scalar": 0.0158,
+      "log_bad": 1.5478,
+      "log_good": 1.5522
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 101.0,
+      "good": 84.0,
+      "ratio": 0.8317,
+      "suggested_scalar": -0.6587,
+      "log_bad": 4.6151,
+      "log_good": 4.4308
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5574,
+      "good": 0.4244,
+      "ratio": 0.7614,
+      "suggested_scalar": -0.9743,
+      "log_bad": -0.5845,
+      "log_good": -0.8571
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 14.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.4772,
+      "log_bad": 2.7726,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7057,
+      "good": 0.6604,
+      "ratio": 0.9358,
+      "suggested_scalar": -0.2371,
+      "log_bad": -0.3486,
+      "log_good": -0.4149
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.84,
+      "good": 5.8776,
+      "ratio": 1.0064,
+      "suggested_scalar": 0.0229,
+      "log_bad": 1.7647,
+      "log_good": 1.7711
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 356.0,
+      "good": 313.0,
+      "ratio": 0.8792,
+      "suggested_scalar": -0.4601,
+      "log_bad": 5.8749,
+      "log_good": 5.7462
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.14,
+      "good": 0.0816,
+      "ratio": 0.5829,
+      "suggested_scalar": -1.9292,
+      "log_bad": -1.9661,
+      "log_good": -2.5059
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9367,
+      "good": 0.9599,
+      "ratio": 1.0248,
+      "suggested_scalar": 0.0874,
+      "log_bad": -0.0654,
+      "log_good": -0.0409
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 134.0,
+      "good": 115.0,
+      "ratio": 0.8582,
+      "suggested_scalar": -0.5465,
+      "log_bad": 4.8978,
+      "log_good": 4.7449
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 95.1531,
+      "good": 87.7183,
+      "ratio": 0.9219,
+      "suggested_scalar": -0.2908,
+      "log_bad": 4.5555,
+      "log_good": 4.4741
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5127,
+      "good": 0.5481,
+      "ratio": 1.069,
+      "suggested_scalar": 0.2386,
+      "log_bad": -0.6681,
+      "log_good": -0.6013
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 16.2014,
+      "good": 20.4572,
+      "ratio": 1.2627,
+      "suggested_scalar": 0.8336,
+      "log_bad": 2.7851,
+      "log_good": 3.0183
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2067.0,
+      "good": 1886.0,
+      "ratio": 0.9124,
+      "suggested_scalar": -0.3275,
+      "log_bad": 7.6339,
+      "log_good": 7.5422
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.02,
+      "good": 0.0204,
+      "ratio": 1.02,
+      "suggested_scalar": 0.0708,
+      "log_bad": -3.912,
+      "log_good": -3.8922
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.84,
+      "good": 0.7959,
+      "ratio": 0.9475,
+      "suggested_scalar": -0.1927,
+      "log_bad": -0.1744,
+      "log_good": -0.2283
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.12,
+      "good": 6.3878,
+      "ratio": 0.8972,
+      "suggested_scalar": -0.3878,
+      "log_bad": 1.9629,
+      "log_good": 1.8544
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 9.7344,
+      "good": 10.5156,
+      "ratio": 1.0803,
+      "suggested_scalar": 0.2759,
+      "log_bad": 2.2757,
+      "log_good": 2.3529
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 78.0,
+      "good": 57.0,
+      "ratio": 0.7308,
+      "suggested_scalar": -1.121,
+      "log_bad": 4.3567,
+      "log_good": 4.0431
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9419,
+      "good": 0.9435,
+      "ratio": 1.0017,
+      "suggested_scalar": 0.0061,
+      "log_bad": -0.0599,
+      "log_good": -0.0582
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 22.0,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.1663,
+      "log_bad": 3.0445,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6454,
+      "good": 0.6644,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.1037,
+      "log_bad": -0.4379,
+      "log_good": -0.4089
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2966,
+      "good": 0.2862,
+      "ratio": 0.9649,
+      "suggested_scalar": -0.1276,
+      "log_bad": -1.2154,
+      "log_good": -1.2511
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.8199,
+      "good": 2.9795,
+      "ratio": 1.0566,
+      "suggested_scalar": 0.1968,
+      "log_bad": 1.0367,
+      "log_good": 1.0918
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 354.0,
+      "good": 311.0,
+      "ratio": 0.8785,
+      "suggested_scalar": -0.4628,
+      "log_bad": 5.8693,
+      "log_good": 5.7398
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 9.0,
+      "good": 8.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.4209,
+      "log_bad": 2.1972,
+      "log_good": 2.0794
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0056,
+      "good": 0.0032,
+      "ratio": 0.5714,
+      "suggested_scalar": -2.0,
+      "log_bad": -5.185,
+      "log_good": -5.7446
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0875,
+      "good": 6.0,
+      "ratio": 0.9856,
+      "suggested_scalar": -0.0517,
+      "log_bad": 1.8062,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 36.0,
+      "good": 38.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.1932,
+      "log_bad": 3.5835,
+      "log_good": 3.6376
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4945,
+      "good": 1.6098,
+      "ratio": 1.0771,
+      "suggested_scalar": 0.2656,
+      "log_bad": 0.4018,
+      "log_good": 0.4761
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0373,
+      "good": 0.0435,
+      "ratio": 1.1662,
+      "suggested_scalar": 0.5495,
+      "log_bad": -3.2888,
+      "log_good": -3.135
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8899,
+      "good": 5.6057,
+      "ratio": 0.9517,
+      "suggested_scalar": -0.1767,
+      "log_bad": 1.7732,
+      "log_good": 1.7238
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7723,
+      "good": 0.787,
+      "ratio": 1.019,
+      "suggested_scalar": 0.0674,
+      "log_bad": -0.2584,
+      "log_good": -0.2395
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2063,
+      "good": 0.2097,
+      "ratio": 1.0165,
+      "suggested_scalar": 0.0584,
+      "log_bad": -1.5784,
+      "log_good": -1.5621
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.0251,
+      "good": 4.523,
+      "ratio": 1.1237,
+      "suggested_scalar": 0.4168,
+      "log_bad": 1.3925,
+      "log_good": 1.5092
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 289.0,
+      "good": 257.0,
+      "ratio": 0.8893,
+      "suggested_scalar": -0.4194,
+      "log_bad": 5.6664,
+      "log_good": 5.5491
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7679,
+      "good": 0.6627,
+      "ratio": 0.863,
+      "suggested_scalar": -0.5266,
+      "log_bad": -0.2641,
+      "log_good": -0.4114
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 104.0,
+      "good": 84.0,
+      "ratio": 0.8077,
+      "suggested_scalar": -0.7633,
+      "log_bad": 4.6444,
+      "log_good": 4.4308
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1073.0,
+      "good": 982.0,
+      "ratio": 0.9152,
+      "suggested_scalar": -0.3167,
+      "log_bad": 6.9782,
+      "log_good": 6.8896
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 184.0,
+      "good": 153.0,
+      "ratio": 0.8315,
+      "suggested_scalar": -0.6594,
+      "log_bad": 5.2149,
+      "log_good": 5.0304
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2191,
+      "good": 0.2332,
+      "ratio": 1.0644,
+      "suggested_scalar": 0.2229,
+      "log_bad": -1.5182,
+      "log_good": -1.4559
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 60.0,
+      "good": 57.0,
+      "ratio": 0.95,
+      "suggested_scalar": -0.1833,
+      "log_bad": 4.0943,
+      "log_good": 4.0431
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 104.0,
+      "good": 84.0,
+      "ratio": 0.8077,
+      "suggested_scalar": -0.7633,
+      "log_bad": 4.6444,
+      "log_good": 4.4308
+    },
+    "brevity.mean_sample_size": {
+      "bad": 104.0,
+      "good": 84.0,
+      "ratio": 0.8077,
+      "suggested_scalar": -0.7633,
+      "log_bad": 4.6444,
+      "log_good": 4.4308
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 356.0,
+      "good": 313.0,
+      "ratio": 0.8792,
+      "suggested_scalar": -0.4601,
+      "log_bad": 5.8749,
+      "log_good": 5.7462
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 157.0,
+      "good": 141.0,
+      "ratio": 0.8981,
+      "suggested_scalar": -0.3841,
+      "log_bad": 5.0562,
+      "log_good": 4.9488
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 233.0,
+      "good": 198.0,
+      "ratio": 0.8498,
+      "suggested_scalar": -0.5817,
+      "log_bad": 5.451,
+      "log_good": 5.2883
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0056,
+      "good": 0.0064,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.4772,
+      "log_bad": -5.185,
+      "log_good": -5.0515
+    },
+    "heaps.mean_k": {
+      "bad": 1.6979,
+      "good": 1.9437,
+      "ratio": 1.1448,
+      "suggested_scalar": 0.4832,
+      "log_bad": 0.5294,
+      "log_good": 0.6646
+    },
+    "halstead.mean_effort": {
+      "bad": 55635.3493,
+      "good": 53964.8716,
+      "ratio": 0.97,
+      "suggested_scalar": -0.109,
+      "log_bad": 10.9266,
+      "log_good": 10.8961
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.879,
+      "good": 0.8769,
+      "ratio": 0.9976,
+      "suggested_scalar": -0.0085,
+      "log_bad": -0.129,
+      "log_good": -0.1314
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 80.0,
+      "good": 62.0,
+      "ratio": 0.775,
+      "suggested_scalar": -0.911,
+      "log_bad": 4.382,
+      "log_good": 4.1271
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 162.0,
+      "good": 158.0,
+      "ratio": 0.9753,
+      "suggested_scalar": -0.0894,
+      "log_bad": 5.0876,
+      "log_good": 5.0626
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5149,
+      "good": 0.4435,
+      "ratio": 0.8613,
+      "suggested_scalar": -0.5335,
+      "log_bad": -0.6638,
+      "log_good": -0.8131
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.0075,
+      "good": 8.5391,
+      "ratio": 1.0664,
+      "suggested_scalar": 0.2297,
+      "log_bad": 2.0804,
+      "log_good": 2.1447
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2063,
+      "good": 0.2097,
+      "ratio": 1.0165,
+      "suggested_scalar": 0.0584,
+      "log_bad": -1.5784,
+      "log_good": -1.5621
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.0929,
+      "good": 5.8687,
+      "ratio": 1.1523,
+      "suggested_scalar": 0.5067,
+      "log_bad": 1.6278,
+      "log_good": 1.7696
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 355.0,
+      "good": 312.0,
+      "ratio": 0.8789,
+      "suggested_scalar": -0.4614,
+      "log_bad": 5.8721,
+      "log_good": 5.743
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 40.0,
+      "good": 35.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.4772,
+      "log_bad": 3.6889,
+      "log_good": 3.5553
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3090.8527,
+      "good": 2998.0484,
+      "ratio": 0.97,
+      "suggested_scalar": -0.109,
+      "log_bad": 8.0362,
+      "log_good": 8.0057
+    },
+    "readability.mean_total_lines": {
+      "bad": 50.0,
+      "good": 49.0,
+      "ratio": 0.98,
+      "suggested_scalar": -0.0722,
+      "log_bad": 3.912,
+      "log_good": 3.8918
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2303.7412,
+      "good": 1988.0107,
+      "ratio": 0.8629,
+      "suggested_scalar": -0.5268,
+      "log_bad": 7.7423,
+      "log_good": 7.5949
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 733.0,
+      "good": 633.0,
+      "ratio": 0.8636,
+      "suggested_scalar": -0.5242,
+      "log_bad": 6.5971,
+      "log_good": 6.4505
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 39.96,
+      "good": 37.2245,
+      "ratio": 0.9315,
+      "suggested_scalar": -0.2534,
+      "log_bad": 3.6879,
+      "log_good": 3.617
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2347,
+      "good": 1.3314,
+      "ratio": 1.0783,
+      "suggested_scalar": 0.2695,
+      "log_bad": 0.2108,
+      "log_good": 0.2862
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 27.0,
+      "good": 26.0,
+      "ratio": 0.963,
+      "suggested_scalar": -0.1349,
+      "log_bad": 3.2958,
+      "log_good": 3.2581
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 4.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.9459,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8616,
+      "good": 0.8638,
+      "ratio": 1.0026,
+      "suggested_scalar": 0.0091,
+      "log_bad": -0.149,
+      "log_good": -0.1464
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9909,
+      "good": 0.9841,
+      "ratio": 0.9931,
+      "suggested_scalar": -0.0246,
+      "log_bad": -0.0091,
+      "log_good": -0.016
+    },
+    "halstead.mean_length": {
+      "bad": 346.0,
+      "good": 311.0,
+      "ratio": 0.8988,
+      "suggested_scalar": -0.3811,
+      "log_bad": 5.8464,
+      "log_good": 5.7398
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.8571,
+      "good": 5.8571,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7677,
+      "log_good": 1.7677
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7004,
+      "good": 6.3923,
+      "ratio": 0.954,
+      "suggested_scalar": -0.1682,
+      "log_bad": 1.9022,
+      "log_good": 1.8551
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0762,
+      "good": 0.0748,
+      "ratio": 0.9816,
+      "suggested_scalar": -0.0663,
+      "log_bad": -2.5744,
+      "log_good": -2.5929
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 24.15,
+      "good": 27.1452,
+      "ratio": 1.124,
+      "suggested_scalar": 0.4178,
+      "log_bad": 3.1843,
+      "log_good": 3.3012
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 69.0,
+      "good": 51.0,
+      "ratio": 0.7391,
+      "suggested_scalar": -1.0803,
+      "log_bad": 4.2341,
+      "log_good": 3.9318
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7425,
+      "good": 0.7121,
+      "ratio": 0.9591,
+      "suggested_scalar": -0.1494,
+      "log_bad": -0.2977,
+      "log_good": -0.3395
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 50.0,
+      "good": 49.0,
+      "ratio": 0.98,
+      "suggested_scalar": -0.0722,
+      "log_bad": 3.912,
+      "log_good": 3.8918
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 21.0,
+      "good": 24.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.4772,
+      "log_bad": 3.0445,
+      "log_good": 3.1781
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    }
+  },
+  "error_handling.custom_error_type_implements_unwrap": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0219,
+      "good": 0.0211,
+      "ratio": 0.9635,
+      "suggested_scalar": -0.3335,
+      "log_bad": -3.8213,
+      "log_good": -3.8585
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.25,
+      "good": 1.2,
+      "ratio": 0.96,
+      "suggested_scalar": -0.3659,
+      "log_bad": 0.2231,
+      "log_good": 0.1823
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.78,
+      "good": 0.7885,
+      "ratio": 1.0109,
+      "suggested_scalar": 0.0971,
+      "log_bad": -0.2485,
+      "log_good": -0.2376
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0219,
+      "good": 0.0211,
+      "ratio": 0.9635,
+      "suggested_scalar": -0.3335,
+      "log_bad": -3.8213,
+      "log_good": -3.8585
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.9459,
+      "good": 4.8998,
+      "ratio": 0.9907,
+      "suggested_scalar": -0.0839,
+      "log_bad": 1.5986,
+      "log_good": 1.5892
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 92.0,
+      "good": 94.0,
+      "ratio": 1.0217,
+      "suggested_scalar": 0.1928,
+      "log_bad": 4.5218,
+      "log_good": 4.5433
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4688,
+      "good": 0.468,
+      "ratio": 0.9983,
+      "suggested_scalar": -0.0153,
+      "log_bad": -0.7576,
+      "log_good": -0.7593
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 17.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.5123,
+      "log_bad": 2.8904,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6491,
+      "good": 0.6377,
+      "ratio": 0.9824,
+      "suggested_scalar": -0.1588,
+      "log_bad": -0.4322,
+      "log_good": -0.4499
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 0.92,
+      "good": 0.9231,
+      "ratio": 1.0034,
+      "suggested_scalar": 0.0302,
+      "log_bad": -0.0834,
+      "log_good": -0.08
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 319.0,
+      "good": 332.0,
+      "ratio": 1.0408,
+      "suggested_scalar": 0.358,
+      "log_bad": 5.7652,
+      "log_good": 5.8051
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0008,
+      "good": 0.0007,
+      "ratio": 0.875,
+      "suggested_scalar": -1.1968,
+      "log_bad": -7.1309,
+      "log_good": -7.2644
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1,
+      "good": 0.1154,
+      "ratio": 1.154,
+      "suggested_scalar": 1.2838,
+      "log_bad": -2.3026,
+      "log_good": -2.1594
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9212,
+      "good": 0.9395,
+      "ratio": 1.0199,
+      "suggested_scalar": 0.1763,
+      "log_bad": -0.0821,
+      "log_good": -0.0624
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 133.0,
+      "good": 145.0,
+      "ratio": 1.0902,
+      "suggested_scalar": 0.7743,
+      "log_bad": 4.8903,
+      "log_good": 4.9767
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 104.8111,
+      "good": 104.5369,
+      "ratio": 0.9974,
+      "suggested_scalar": -0.0235,
+      "log_bad": 4.6522,
+      "log_good": 4.6495
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.478,
+      "good": 0.4924,
+      "ratio": 1.0301,
+      "suggested_scalar": 0.266,
+      "log_bad": -0.7381,
+      "log_good": -0.7085
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 16.5484,
+      "good": 17.0473,
+      "ratio": 1.0301,
+      "suggested_scalar": 0.2662,
+      "log_bad": 2.8063,
+      "log_good": 2.836
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1292.0,
+      "good": 1388.0,
+      "ratio": 1.0743,
+      "suggested_scalar": 0.6424,
+      "log_bad": 7.1639,
+      "log_good": 7.2356
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.06,
+      "good": 0.0577,
+      "ratio": 0.9617,
+      "suggested_scalar": -0.3503,
+      "log_bad": -2.8134,
+      "log_good": -2.8525
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.74,
+      "good": 0.75,
+      "ratio": 1.0135,
+      "suggested_scalar": 0.1203,
+      "log_bad": -0.3011,
+      "log_good": -0.2877
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.38,
+      "good": 6.3846,
+      "ratio": 1.0007,
+      "suggested_scalar": 0.0065,
+      "log_bad": 1.8532,
+      "log_good": 1.8539
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.9936,
+      "good": 0.9941,
+      "ratio": 1.0005,
+      "suggested_scalar": 0.0045,
+      "log_bad": -0.0064,
+      "log_good": -0.0059
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 79.0,
+      "good": 88.0,
+      "ratio": 1.1139,
+      "suggested_scalar": 0.967,
+      "log_bad": 4.3694,
+      "log_good": 4.4773
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9188,
+      "good": 0.9169,
+      "ratio": 0.9979,
+      "suggested_scalar": -0.0186,
+      "log_bad": -0.0847,
+      "log_good": -0.0868
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 24.0,
+      "ratio": 0.9231,
+      "suggested_scalar": -0.7174,
+      "log_bad": 3.2581,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5449,
+      "good": 0.5663,
+      "ratio": 1.0393,
+      "suggested_scalar": 0.3453,
+      "log_bad": -0.6072,
+      "log_good": -0.5686
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2871,
+      "good": 0.2909,
+      "ratio": 1.0132,
+      "suggested_scalar": 0.1179,
+      "log_bad": -1.2479,
+      "log_good": -1.2348
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.1973,
+      "good": 2.3056,
+      "ratio": 1.0493,
+      "suggested_scalar": 0.4312,
+      "log_bad": 0.7872,
+      "log_good": 0.8353
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 317.0,
+      "good": 330.0,
+      "ratio": 1.041,
+      "suggested_scalar": 0.3602,
+      "log_bad": 5.7589,
+      "log_good": 5.7991
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0251,
+      "good": 0.0211,
+      "ratio": 0.8406,
+      "suggested_scalar": -1.5559,
+      "log_bad": -3.6849,
+      "log_good": -3.8585
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.8074,
+      "ratio": 0.9753,
+      "suggested_scalar": -0.2237,
+      "log_bad": 1.7841,
+      "log_good": 1.7591
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 54.0,
+      "good": 57.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.4846,
+      "log_bad": 3.989,
+      "log_good": 4.0431
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9744,
+      "good": 0.9668,
+      "ratio": 0.9922,
+      "suggested_scalar": -0.0702,
+      "log_bad": -0.0259,
+      "log_good": -0.0338
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8691,
+      "good": 5.85,
+      "ratio": 0.9967,
+      "suggested_scalar": -0.0292,
+      "log_bad": 1.7697,
+      "log_good": 1.7664
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8307,
+      "good": 0.8437,
+      "ratio": 1.0156,
+      "suggested_scalar": 0.1392,
+      "log_bad": -0.1855,
+      "log_good": -0.17
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1803,
+      "good": 0.1746,
+      "ratio": 0.9684,
+      "suggested_scalar": -0.2879,
+      "log_bad": -1.7131,
+      "log_good": -1.7453
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.068,
+      "good": 4.1288,
+      "ratio": 1.0149,
+      "suggested_scalar": 0.133,
+      "log_bad": 1.4032,
+      "log_good": 1.418
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 268.0,
+      "good": 278.0,
+      "ratio": 1.0373,
+      "suggested_scalar": 0.3283,
+      "log_bad": 5.591,
+      "log_good": 5.6276
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6306,
+      "good": 0.6642,
+      "ratio": 1.0533,
+      "suggested_scalar": 0.4653,
+      "log_bad": -0.4611,
+      "log_good": -0.4092
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 96.0,
+      "good": 95.0,
+      "ratio": 0.9896,
+      "suggested_scalar": -0.0939,
+      "log_bad": 4.5643,
+      "log_good": 4.5539
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 725.0,
+      "good": 805.0,
+      "ratio": 1.1103,
+      "suggested_scalar": 0.9381,
+      "log_bad": 6.5862,
+      "log_good": 6.6908
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 142.0,
+      "good": 153.0,
+      "ratio": 1.0775,
+      "suggested_scalar": 0.6687,
+      "log_bad": 4.9558,
+      "log_good": 5.0304
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2257,
+      "good": 0.2199,
+      "ratio": 0.9743,
+      "suggested_scalar": -0.2333,
+      "log_bad": -1.4885,
+      "log_good": -1.5146
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 59.0,
+      "good": 63.0,
+      "ratio": 1.0678,
+      "suggested_scalar": 0.5879,
+      "log_bad": 4.0775,
+      "log_good": 4.1431
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 2.0,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 96.0,
+      "good": 95.0,
+      "ratio": 0.9896,
+      "suggested_scalar": -0.0939,
+      "log_bad": 4.5643,
+      "log_good": 4.5539
+    },
+    "brevity.mean_sample_size": {
+      "bad": 96.0,
+      "good": 95.0,
+      "ratio": 0.9896,
+      "suggested_scalar": -0.0939,
+      "log_bad": 4.5643,
+      "log_good": 4.5539
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 319.0,
+      "good": 332.0,
+      "ratio": 1.0408,
+      "suggested_scalar": 0.358,
+      "log_bad": 5.7652,
+      "log_good": 5.8051
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 148.0,
+      "good": 150.0,
+      "ratio": 1.0135,
+      "suggested_scalar": 0.1203,
+      "log_bad": 4.9972,
+      "log_good": 5.0106
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 225.0,
+      "good": 231.0,
+      "ratio": 1.0267,
+      "suggested_scalar": 0.2359,
+      "log_bad": 5.4161,
+      "log_good": 5.4424
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.482,
+      "good": 2.6238,
+      "ratio": 1.0571,
+      "suggested_scalar": 0.498,
+      "log_bad": 0.9091,
+      "log_good": 0.9646
+    },
+    "halstead.mean_effort": {
+      "bad": 52913.9948,
+      "good": 52262.9206,
+      "ratio": 0.9877,
+      "suggested_scalar": -0.111,
+      "log_bad": 10.8764,
+      "log_good": 10.864
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8913,
+      "good": 0.8904,
+      "ratio": 0.999,
+      "suggested_scalar": -0.0091,
+      "log_bad": -0.1151,
+      "log_good": -0.1161
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 66.0,
+      "good": 70.0,
+      "ratio": 1.0606,
+      "suggested_scalar": 0.5274,
+      "log_bad": 4.1897,
+      "log_good": 4.2485
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 148.0,
+      "good": 151.0,
+      "ratio": 1.0203,
+      "suggested_scalar": 0.1799,
+      "log_bad": 4.9972,
+      "log_good": 5.0173
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4511,
+      "good": 0.4414,
+      "ratio": 0.9785,
+      "suggested_scalar": -0.1948,
+      "log_bad": -0.7961,
+      "log_good": -0.8178
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.4511,
+      "good": 5.5517,
+      "ratio": 1.0185,
+      "suggested_scalar": 0.1639,
+      "log_bad": 1.6958,
+      "log_good": 1.7141
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1803,
+      "good": 0.1746,
+      "ratio": 0.9684,
+      "suggested_scalar": -0.2879,
+      "log_bad": -1.7131,
+      "log_good": -1.7453
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.2579,
+      "good": 3.2168,
+      "ratio": 0.9874,
+      "suggested_scalar": -0.1138,
+      "log_bad": 1.1811,
+      "log_good": 1.1684
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 318.0,
+      "good": 331.0,
+      "ratio": 1.0409,
+      "suggested_scalar": 0.3591,
+      "log_bad": 5.7621,
+      "log_good": 5.8021
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 42.0,
+      "good": 44.0,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.417,
+      "log_bad": 3.7377,
+      "log_good": 3.7842
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2939.6664,
+      "good": 2903.4956,
+      "ratio": 0.9877,
+      "suggested_scalar": -0.111,
+      "log_bad": 7.9861,
+      "log_good": 7.9737
+    },
+    "readability.mean_total_lines": {
+      "bad": 50.0,
+      "good": 52.0,
+      "ratio": 1.04,
+      "suggested_scalar": 0.3515,
+      "log_bad": 3.912,
+      "log_good": 3.9512
+    },
+    "indentation.mean_max_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "halstead.mean_volume": {
+      "bad": 1891.833,
+      "good": 1992.595,
+      "ratio": 1.0533,
+      "suggested_scalar": 0.4651,
+      "log_bad": 7.5453,
+      "log_good": 7.5972
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 588.0,
+      "good": 602.0,
+      "ratio": 1.0238,
+      "suggested_scalar": 0.2109,
+      "log_bad": 6.3767,
+      "log_good": 6.4003
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 24.58,
+      "good": 25.4808,
+      "ratio": 1.0366,
+      "suggested_scalar": 0.3226,
+      "log_bad": 3.2019,
+      "log_good": 3.2379
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1294,
+      "good": 1.1326,
+      "ratio": 1.0028,
+      "suggested_scalar": 0.0254,
+      "log_bad": 0.1217,
+      "log_good": 0.1245
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 20.0,
+      "good": 23.0,
+      "ratio": 1.15,
+      "suggested_scalar": 1.2527,
+      "log_bad": 2.9957,
+      "log_good": 3.1355
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 1.6341,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8433,
+      "good": 0.8417,
+      "ratio": 0.9981,
+      "suggested_scalar": -0.017,
+      "log_bad": -0.1704,
+      "log_good": -0.1723
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9675,
+      "good": 0.9649,
+      "ratio": 0.9973,
+      "suggested_scalar": -0.0241,
+      "log_bad": -0.033,
+      "log_good": -0.0357
+    },
+    "halstead.mean_length": {
+      "bad": 290.0,
+      "good": 304.0,
+      "ratio": 1.0483,
+      "suggested_scalar": 0.4226,
+      "log_bad": 5.6699,
+      "log_good": 5.717
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.5,
+      "good": 9.6,
+      "ratio": 0.8348,
+      "suggested_scalar": -1.6185,
+      "log_bad": 2.4423,
+      "log_good": 2.2618
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.585,
+      "good": 6.5699,
+      "ratio": 0.9977,
+      "suggested_scalar": -0.0206,
+      "log_bad": 1.8848,
+      "log_good": 1.8825
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1147,
+      "good": 0.1081,
+      "ratio": 0.9425,
+      "suggested_scalar": -0.5312,
+      "log_bad": -2.1654,
+      "log_good": -2.2247
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.9697,
+      "good": 26.2286,
+      "ratio": 0.9378,
+      "suggested_scalar": -0.5761,
+      "log_bad": 3.3311,
+      "log_good": 3.2669
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 60.0,
+      "good": 64.0,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.5784,
+      "log_bad": 4.0943,
+      "log_good": 4.1589
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7378,
+      "good": 0.7273,
+      "ratio": 0.9858,
+      "suggested_scalar": -0.1285,
+      "log_bad": -0.3041,
+      "log_good": -0.3184
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 50.0,
+      "good": 52.0,
+      "ratio": 1.04,
+      "suggested_scalar": 0.3515,
+      "log_bad": 3.912,
+      "log_good": 3.9512
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "consistency.overloads_are_contiguous": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.4286,
+      "good": 1.4286,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.3567,
+      "log_good": 0.3567
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8431,
+      "good": 0.8333,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0255,
+      "log_bad": -0.1707,
+      "log_good": -0.1824
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5832,
+      "good": 4.5494,
+      "ratio": 0.9926,
+      "suggested_scalar": -0.0162,
+      "log_bad": 1.5224,
+      "log_good": 1.515
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 84.0,
+      "good": 72.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.3365,
+      "log_bad": 4.4308,
+      "log_good": 4.2767
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4698,
+      "good": 0.3841,
+      "ratio": 0.8176,
+      "suggested_scalar": -0.4396,
+      "log_bad": -0.7554,
+      "log_good": -0.9569
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 13.0,
+      "good": 12.0,
+      "ratio": 0.9231,
+      "suggested_scalar": -0.1747,
+      "log_bad": 2.5649,
+      "log_good": 2.4849
+    },
+    "heaps.mean_beta": {
+      "bad": 0.683,
+      "good": 0.6456,
+      "ratio": 0.9452,
+      "suggested_scalar": -0.1229,
+      "log_bad": -0.3813,
+      "log_good": -0.4376
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.8039,
+      "good": 5.9167,
+      "ratio": 1.0194,
+      "suggested_scalar": 0.042,
+      "log_bad": 1.7585,
+      "log_good": 1.7778
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 360.0,
+      "good": 316.0,
+      "ratio": 0.8778,
+      "suggested_scalar": -0.2845,
+      "log_bad": 5.8861,
+      "log_good": 5.7557
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0005,
+      "good": 0.0005,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.6009,
+      "log_good": -7.6009
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.098,
+      "good": 0.0417,
+      "ratio": 0.4255,
+      "suggested_scalar": -1.8651,
+      "log_bad": -2.3228,
+      "log_good": -3.1773
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0005,
+      "good": 0.0005,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.6009,
+      "log_good": -7.6009
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9938,
+      "good": 0.9899,
+      "ratio": 0.9961,
+      "suggested_scalar": -0.0086,
+      "log_bad": -0.0062,
+      "log_good": -0.0102
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 153.0,
+      "good": 131.0,
+      "ratio": 0.8562,
+      "suggested_scalar": -0.3388,
+      "log_bad": 5.0304,
+      "log_good": 4.8752
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 95.7203,
+      "good": 93.2351,
+      "ratio": 0.974,
+      "suggested_scalar": -0.0574,
+      "log_bad": 4.5614,
+      "log_good": 4.5351
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6128,
+      "good": 0.6286,
+      "ratio": 1.0258,
+      "suggested_scalar": 0.0556,
+      "log_bad": -0.4897,
+      "log_good": -0.4643
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.6246,
+      "good": 9.8147,
+      "ratio": 1.0198,
+      "suggested_scalar": 0.0427,
+      "log_bad": 2.2643,
+      "log_good": 2.2839
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2046.0,
+      "good": 1834.0,
+      "ratio": 0.8964,
+      "suggested_scalar": -0.2388,
+      "log_bad": 7.6236,
+      "log_good": 7.5143
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8235,
+      "good": 0.8125,
+      "ratio": 0.9866,
+      "suggested_scalar": -0.0294,
+      "log_bad": -0.1942,
+      "log_good": -0.2076
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.0588,
+      "good": 6.5833,
+      "ratio": 0.9326,
+      "suggested_scalar": -0.1522,
+      "log_bad": 1.9543,
+      "log_good": 1.8845
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 12.1184,
+      "good": 12.6597,
+      "ratio": 1.0447,
+      "suggested_scalar": 0.0954,
+      "log_bad": 2.4947,
+      "log_good": 2.5384
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 97.0,
+      "good": 77.0,
+      "ratio": 0.7938,
+      "suggested_scalar": -0.504,
+      "log_bad": 4.5747,
+      "log_good": 4.3438
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9555,
+      "good": 0.9507,
+      "ratio": 0.995,
+      "suggested_scalar": -0.011,
+      "log_bad": -0.0455,
+      "log_good": -0.0506
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 16.0,
+      "good": 15.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.1409,
+      "log_bad": 2.7726,
+      "log_good": 2.7081
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6843,
+      "good": 0.6903,
+      "ratio": 1.0088,
+      "suggested_scalar": 0.0191,
+      "log_bad": -0.3794,
+      "log_good": -0.3706
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3715,
+      "good": 0.3726,
+      "ratio": 1.003,
+      "suggested_scalar": 0.0065,
+      "log_bad": -0.9902,
+      "log_good": -0.9872
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.1672,
+      "good": 3.2289,
+      "ratio": 1.0195,
+      "suggested_scalar": 0.0421,
+      "log_bad": 1.1528,
+      "log_good": 1.1721
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 358.0,
+      "good": 314.0,
+      "ratio": 0.8771,
+      "suggested_scalar": -0.2862,
+      "log_bad": 5.8805,
+      "log_good": 5.7494
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 13.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.1747,
+      "log_bad": 2.4849,
+      "log_good": 2.5649
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.7279,
+      "ratio": 0.982,
+      "suggested_scalar": -0.0396,
+      "log_bad": 1.7635,
+      "log_good": 1.7453
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 38.0,
+      "good": 36.0,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.118,
+      "log_bad": 3.6376,
+      "log_good": 3.5835
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2791,
+      "good": 1.3562,
+      "ratio": 1.0603,
+      "suggested_scalar": 0.1278,
+      "log_bad": 0.2462,
+      "log_good": 0.3047
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5004,
+      "good": 5.3324,
+      "ratio": 0.9695,
+      "suggested_scalar": -0.0677,
+      "log_bad": 1.7048,
+      "log_good": 1.6738
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7858,
+      "good": 0.7943,
+      "ratio": 1.0108,
+      "suggested_scalar": 0.0235,
+      "log_bad": -0.2411,
+      "log_good": -0.2303
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1774,
+      "good": 0.1864,
+      "ratio": 1.0507,
+      "suggested_scalar": 0.108,
+      "log_bad": -1.7293,
+      "log_good": -1.6799
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1024,
+      "good": 3.1328,
+      "ratio": 1.0098,
+      "suggested_scalar": 0.0213,
+      "log_bad": 1.1322,
+      "log_good": 1.1419
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 278.0,
+      "good": 247.0,
+      "ratio": 0.8885,
+      "suggested_scalar": -0.2581,
+      "log_bad": 5.6276,
+      "log_good": 5.5094
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7564,
+      "good": 0.6458,
+      "ratio": 0.8538,
+      "suggested_scalar": -0.345,
+      "log_bad": -0.2792,
+      "log_good": -0.4373
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 86.0,
+      "good": 73.0,
+      "ratio": 0.8488,
+      "suggested_scalar": -0.3577,
+      "log_bad": 4.4543,
+      "log_good": 4.2905
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1186.0,
+      "good": 1054.0,
+      "ratio": 0.8887,
+      "suggested_scalar": -0.2575,
+      "log_bad": 7.0783,
+      "log_good": 6.9603
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 173.0,
+      "good": 151.0,
+      "ratio": 0.8728,
+      "suggested_scalar": -0.2969,
+      "log_bad": 5.1533,
+      "log_good": 5.0173
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.275,
+      "good": 0.2975,
+      "ratio": 1.0818,
+      "suggested_scalar": 0.1717,
+      "log_bad": -1.291,
+      "log_good": -1.2123
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 69.0,
+      "good": 67.0,
+      "ratio": 0.971,
+      "suggested_scalar": -0.0642,
+      "log_bad": 4.2341,
+      "log_good": 4.2047
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 86.0,
+      "good": 73.0,
+      "ratio": 0.8488,
+      "suggested_scalar": -0.3577,
+      "log_bad": 4.4543,
+      "log_good": 4.2905
+    },
+    "brevity.mean_sample_size": {
+      "bad": 86.0,
+      "good": 73.0,
+      "ratio": 0.8488,
+      "suggested_scalar": -0.3577,
+      "log_bad": 4.4543,
+      "log_good": 4.2905
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 360.0,
+      "good": 316.0,
+      "ratio": 0.8778,
+      "suggested_scalar": -0.2845,
+      "log_bad": 5.8861,
+      "log_good": 5.7557
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 172.0,
+      "good": 153.0,
+      "ratio": 0.8895,
+      "suggested_scalar": -0.2555,
+      "log_bad": 5.1475,
+      "log_good": 5.0304
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 208.0,
+      "good": 184.0,
+      "ratio": 0.8846,
+      "suggested_scalar": -0.2676,
+      "log_bad": 5.3375,
+      "log_good": 5.2149
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.6826,
+      "good": 1.9017,
+      "ratio": 1.1302,
+      "suggested_scalar": 0.2672,
+      "log_bad": 0.5203,
+      "log_good": 0.6427
+    },
+    "halstead.mean_effort": {
+      "bad": 46186.3735,
+      "good": 38492.2137,
+      "ratio": 0.8334,
+      "suggested_scalar": -0.3978,
+      "log_bad": 10.7404,
+      "log_good": 10.5582
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8559,
+      "good": 0.8615,
+      "ratio": 1.0065,
+      "suggested_scalar": 0.0142,
+      "log_bad": -0.1556,
+      "log_good": -0.1491
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 68.0,
+      "good": 57.0,
+      "ratio": 0.8382,
+      "suggested_scalar": -0.3852,
+      "log_bad": 4.2195,
+      "log_good": 4.0431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 182.0,
+      "good": 163.0,
+      "ratio": 0.8956,
+      "suggested_scalar": -0.2407,
+      "log_bad": 5.204,
+      "log_good": 5.0938
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3987,
+      "good": 0.3817,
+      "ratio": 0.9574,
+      "suggested_scalar": -0.0951,
+      "log_bad": -0.9195,
+      "log_good": -0.9631
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.7516,
+      "good": 8.0458,
+      "ratio": 1.038,
+      "suggested_scalar": 0.0813,
+      "log_bad": 2.0479,
+      "log_good": 2.0852
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1774,
+      "good": 0.1864,
+      "ratio": 1.0507,
+      "suggested_scalar": 0.108,
+      "log_bad": -1.7293,
+      "log_good": -1.6799
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.0363,
+      "good": 2.8787,
+      "ratio": 0.9481,
+      "suggested_scalar": -0.1163,
+      "log_bad": 1.1106,
+      "log_good": 1.0573
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 359.0,
+      "good": 315.0,
+      "ratio": 0.8774,
+      "suggested_scalar": -0.2854,
+      "log_bad": 5.8833,
+      "log_good": 5.7526
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 53.0,
+      "good": 50.0,
+      "ratio": 0.9434,
+      "suggested_scalar": -0.1272,
+      "log_bad": 3.9703,
+      "log_good": 3.912
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2565.9096,
+      "good": 2138.4563,
+      "ratio": 0.8334,
+      "suggested_scalar": -0.3978,
+      "log_bad": 7.8501,
+      "log_good": 7.6678
+    },
+    "readability.mean_total_lines": {
+      "bad": 51.0,
+      "good": 48.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.1323,
+      "log_bad": 3.9318,
+      "log_good": 3.8712
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2269.2727,
+      "good": 1937.3565,
+      "ratio": 0.8537,
+      "suggested_scalar": -0.3452,
+      "log_bad": 7.7272,
+      "log_good": 7.5691
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 646.0,
+      "good": 568.0,
+      "ratio": 0.8793,
+      "suggested_scalar": -0.2809,
+      "log_bad": 6.4708,
+      "log_good": 6.3421
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 38.7843,
+      "good": 36.9792,
+      "ratio": 0.9535,
+      "suggested_scalar": -0.104,
+      "log_bad": 3.658,
+      "log_good": 3.6104
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2287,
+      "good": 1.2638,
+      "ratio": 1.0286,
+      "suggested_scalar": 0.0615,
+      "log_bad": 0.206,
+      "log_good": 0.2341
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 28.0,
+      "good": 28.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3322,
+      "log_good": 3.3322
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 2.0,
+      "ratio": 0.4,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.6094,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8094,
+      "good": 0.7976,
+      "ratio": 0.9854,
+      "suggested_scalar": -0.0321,
+      "log_bad": -0.2115,
+      "log_good": -0.2261
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9918,
+      "good": 0.9799,
+      "ratio": 0.988,
+      "suggested_scalar": -0.0263,
+      "log_bad": -0.0082,
+      "log_good": -0.0203
+    },
+    "halstead.mean_length": {
+      "bad": 355.0,
+      "good": 314.0,
+      "ratio": 0.8845,
+      "suggested_scalar": -0.2679,
+      "log_bad": 5.8721,
+      "log_good": 5.7494
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 6.4286,
+      "good": 6.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.1506,
+      "log_bad": 1.8608,
+      "log_good": 1.7918
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4263,
+      "good": 6.1898,
+      "ratio": 0.9632,
+      "suggested_scalar": -0.0818,
+      "log_bad": 1.8604,
+      "log_good": 1.8229
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0843,
+      "good": 0.0834,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.0234,
+      "log_bad": -2.4734,
+      "log_good": -2.4841
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 20.3529,
+      "good": 19.8684,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0526,
+      "log_bad": 3.0132,
+      "log_good": 2.9891
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 61.0,
+      "good": 50.0,
+      "ratio": 0.8197,
+      "suggested_scalar": -0.434,
+      "log_bad": 4.1109,
+      "log_good": 3.912
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6683,
+      "good": 0.6359,
+      "ratio": 0.9515,
+      "suggested_scalar": -0.1085,
+      "log_bad": -0.403,
+      "log_good": -0.4527
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 51.0,
+      "good": 48.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.1323,
+      "log_bad": 3.9318,
+      "log_good": 3.8712
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.prefers_synchronous_functions": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 8.0,
+      "good": 9.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.285,
+      "log_bad": 2.0794,
+      "log_good": 2.1972
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0157,
+      "good": 0.0236,
+      "ratio": 1.5032,
+      "suggested_scalar": 0.9861,
+      "log_bad": -4.1541,
+      "log_good": -3.7465
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.913,
+      "good": 0.8864,
+      "ratio": 0.9709,
+      "suggested_scalar": -0.0715,
+      "log_bad": -0.091,
+      "log_good": -0.1206
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0157,
+      "good": 0.0236,
+      "ratio": 1.5032,
+      "suggested_scalar": 0.9861,
+      "log_bad": -4.1541,
+      "log_good": -3.7465
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.9277,
+      "good": 4.9289,
+      "ratio": 1.0002,
+      "suggested_scalar": 0.0006,
+      "log_bad": 1.5949,
+      "log_good": 1.5951
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 110.0,
+      "good": 99.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.2549,
+      "log_bad": 4.7005,
+      "log_good": 4.5951
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.618,
+      "good": 0.5453,
+      "ratio": 0.8824,
+      "suggested_scalar": -0.3028,
+      "log_bad": -0.4813,
+      "log_good": -0.6064
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 16.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.285,
+      "log_bad": 2.8904,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7092,
+      "good": 0.711,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0061,
+      "log_bad": -0.3436,
+      "log_good": -0.3411
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.2391,
+      "good": 0.9091,
+      "ratio": 0.7337,
+      "suggested_scalar": -0.7492,
+      "log_bad": 0.2144,
+      "log_good": -0.0953
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 319.0,
+      "good": 296.0,
+      "ratio": 0.9279,
+      "suggested_scalar": -0.181,
+      "log_bad": 5.7652,
+      "log_good": 5.6904
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.4411,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0007,
+      "good": 0.0016,
+      "ratio": 2.2857,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.2644,
+      "log_good": -6.4378
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1522,
+      "good": 0.1136,
+      "ratio": 0.7464,
+      "suggested_scalar": -0.7077,
+      "log_bad": -1.8826,
+      "log_good": -2.1751
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8615,
+      "good": 0.8828,
+      "ratio": 1.0247,
+      "suggested_scalar": 0.0591,
+      "log_bad": -0.1491,
+      "log_good": -0.1247
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 124.0,
+      "good": 114.0,
+      "ratio": 0.9194,
+      "suggested_scalar": -0.2034,
+      "log_bad": 4.8203,
+      "log_good": 4.7362
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 108.449,
+      "good": 107.9757,
+      "ratio": 0.9956,
+      "suggested_scalar": -0.0106,
+      "log_bad": 4.6863,
+      "log_good": 4.6819
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.3805,
+      "good": 0.3797,
+      "ratio": 0.9979,
+      "suggested_scalar": -0.0051,
+      "log_bad": -0.9663,
+      "log_good": -0.9684
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.3556,
+      "good": 11.1059,
+      "ratio": 1.0725,
+      "suggested_scalar": 0.1692,
+      "log_bad": 2.3375,
+      "log_good": 2.4075
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1424.0,
+      "good": 1273.0,
+      "ratio": 0.894,
+      "suggested_scalar": -0.2712,
+      "log_bad": 7.2612,
+      "log_good": 7.1491
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1087,
+      "good": 0.1136,
+      "ratio": 1.0451,
+      "suggested_scalar": 0.1067,
+      "log_bad": -2.2192,
+      "log_good": -2.1751
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8478,
+      "good": 0.8182,
+      "ratio": 0.9651,
+      "suggested_scalar": -0.086,
+      "log_bad": -0.1651,
+      "log_good": -0.2006
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.9348,
+      "good": 6.7273,
+      "ratio": 0.9701,
+      "suggested_scalar": -0.0735,
+      "log_bad": 1.9366,
+      "log_good": 1.9062
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.6602,
+      "good": 0.8554,
+      "ratio": 0.5152,
+      "suggested_scalar": -1.6043,
+      "log_bad": 0.5069,
+      "log_good": -0.1562
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 87.0,
+      "good": 76.0,
+      "ratio": 0.8736,
+      "suggested_scalar": -0.327,
+      "log_bad": 4.4659,
+      "log_good": 4.3307
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9335,
+      "good": 0.9319,
+      "ratio": 0.9983,
+      "suggested_scalar": -0.0042,
+      "log_bad": -0.0688,
+      "log_good": -0.0705
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 28.0,
+      "ratio": 0.9655,
+      "suggested_scalar": -0.0849,
+      "log_bad": 3.3673,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5309,
+      "good": 0.531,
+      "ratio": 1.0002,
+      "suggested_scalar": 0.0005,
+      "log_bad": -0.6332,
+      "log_good": -0.633
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.1703,
+      "good": 0.1463,
+      "ratio": 0.8591,
+      "suggested_scalar": -0.3675,
+      "log_bad": -1.7702,
+      "log_good": -1.9221
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.1317,
+      "good": 2.1323,
+      "ratio": 1.0003,
+      "suggested_scalar": 0.0007,
+      "log_bad": 0.7569,
+      "log_good": 0.7572
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 317.0,
+      "good": 294.0,
+      "ratio": 0.9274,
+      "suggested_scalar": -0.1822,
+      "log_bad": 5.7589,
+      "log_good": 5.6836
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 27.0,
+      "good": 26.0,
+      "ratio": 0.963,
+      "suggested_scalar": -0.0913,
+      "log_bad": 3.2958,
+      "log_good": 3.2581
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0031,
+      "good": 0.0034,
+      "ratio": 1.0968,
+      "suggested_scalar": 0.2235,
+      "log_bad": -5.7764,
+      "log_good": -5.684
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.8329,
+      "ratio": 0.9875,
+      "suggested_scalar": -0.0305,
+      "log_bad": 1.7761,
+      "log_good": 1.7635
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 31.0,
+      "good": 32.0,
+      "ratio": 1.0323,
+      "suggested_scalar": 0.0768,
+      "log_bad": 3.434,
+      "log_good": 3.4657
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1016,
+      "good": 1.1623,
+      "ratio": 1.0551,
+      "suggested_scalar": 0.1298,
+      "log_bad": 0.0968,
+      "log_good": 0.1504
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.0509,
+      "good": 5.8732,
+      "ratio": 0.9706,
+      "suggested_scalar": -0.0721,
+      "log_bad": 1.8002,
+      "log_good": 1.7704
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8342,
+      "good": 0.845,
+      "ratio": 1.0129,
+      "suggested_scalar": 0.0311,
+      "log_bad": -0.1813,
+      "log_good": -0.1684
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1481,
+      "good": 0.1698,
+      "ratio": 1.1465,
+      "suggested_scalar": 0.3308,
+      "log_bad": -1.9099,
+      "log_good": -1.7731
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.218,
+      "good": 3.3325,
+      "ratio": 1.0356,
+      "suggested_scalar": 0.0846,
+      "log_bad": 1.1688,
+      "log_good": 1.2037
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 287.0,
+      "good": 271.0,
+      "ratio": 0.9443,
+      "suggested_scalar": -0.1388,
+      "log_bad": 5.6595,
+      "log_good": 5.6021
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6714,
+      "good": 0.5966,
+      "ratio": 0.8886,
+      "suggested_scalar": -0.2858,
+      "log_bad": -0.3984,
+      "log_good": -0.5165
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 108.0,
+      "good": 94.0,
+      "ratio": 0.8704,
+      "suggested_scalar": -0.3359,
+      "log_bad": 4.6821,
+      "log_good": 4.5433
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 849.0,
+      "good": 748.0,
+      "ratio": 0.881,
+      "suggested_scalar": -0.3064,
+      "log_bad": 6.7441,
+      "log_good": 6.6174
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 147.0,
+      "good": 134.0,
+      "ratio": 0.9116,
+      "suggested_scalar": -0.224,
+      "log_bad": 4.9904,
+      "log_good": 4.8978
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1724,
+      "good": 0.1926,
+      "ratio": 1.1172,
+      "suggested_scalar": 0.2681,
+      "log_bad": -1.7579,
+      "log_good": -1.6471
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 45.0,
+      "good": 45.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8067,
+      "log_good": 3.8067
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 108.0,
+      "good": 94.0,
+      "ratio": 0.8704,
+      "suggested_scalar": -0.3359,
+      "log_bad": 4.6821,
+      "log_good": 4.5433
+    },
+    "brevity.mean_sample_size": {
+      "bad": 108.0,
+      "good": 94.0,
+      "ratio": 0.8704,
+      "suggested_scalar": -0.3359,
+      "log_bad": 4.6821,
+      "log_good": 4.5433
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 319.0,
+      "good": 296.0,
+      "ratio": 0.9279,
+      "suggested_scalar": -0.181,
+      "log_bad": 5.7652,
+      "log_good": 5.6904
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 151.0,
+      "good": 144.0,
+      "ratio": 0.9536,
+      "suggested_scalar": -0.1148,
+      "log_bad": 5.0173,
+      "log_good": 4.9698
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 242.0,
+      "good": 228.0,
+      "ratio": 0.9421,
+      "suggested_scalar": -0.1442,
+      "log_bad": 5.4889,
+      "log_good": 5.4293
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.1312,
+      "good": 1.9248,
+      "ratio": 0.9032,
+      "suggested_scalar": -0.2464,
+      "log_bad": 0.7567,
+      "log_good": 0.6548
+    },
+    "halstead.mean_effort": {
+      "bad": 52999.7168,
+      "good": 47294.3904,
+      "ratio": 0.8924,
+      "suggested_scalar": -0.2755,
+      "log_bad": 10.878,
+      "log_good": 10.7641
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8958,
+      "good": 0.8961,
+      "ratio": 1.0003,
+      "suggested_scalar": 0.0008,
+      "log_bad": -0.11,
+      "log_good": -0.1097
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 81.0,
+      "good": 71.0,
+      "ratio": 0.8765,
+      "suggested_scalar": -0.3188,
+      "log_bad": 4.3944,
+      "log_good": 4.2627
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 150.0,
+      "good": 136.0,
+      "ratio": 0.9067,
+      "suggested_scalar": -0.237,
+      "log_bad": 5.0106,
+      "log_good": 4.9127
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5484,
+      "good": 0.5,
+      "ratio": 0.9117,
+      "suggested_scalar": -0.2235,
+      "log_bad": -0.6008,
+      "log_good": -0.6931
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.8468,
+      "good": 6.5614,
+      "ratio": 0.9583,
+      "suggested_scalar": -0.103,
+      "log_bad": 1.9238,
+      "log_good": 1.8812
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1481,
+      "good": 0.1698,
+      "ratio": 1.1465,
+      "suggested_scalar": 0.3308,
+      "log_bad": -1.9099,
+      "log_good": -1.7731
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.7739,
+      "good": 2.6909,
+      "ratio": 0.9701,
+      "suggested_scalar": -0.0735,
+      "log_bad": 1.0203,
+      "log_good": 0.9899
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 318.0,
+      "good": 295.0,
+      "ratio": 0.9277,
+      "suggested_scalar": -0.1816,
+      "log_bad": 5.7621,
+      "log_good": 5.687
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 24.0,
+      "good": 20.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.4411,
+      "log_bad": 3.1781,
+      "log_good": 2.9957
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2944.4287,
+      "good": 2627.4661,
+      "ratio": 0.8924,
+      "suggested_scalar": -0.2755,
+      "log_bad": 7.9877,
+      "log_good": 7.8738
+    },
+    "readability.mean_total_lines": {
+      "bad": 46.0,
+      "good": 44.0,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.1075,
+      "log_bad": 3.8286,
+      "log_good": 3.7842
+    },
+    "indentation.mean_max_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.5399,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2014.0638,
+      "good": 1789.9263,
+      "ratio": 0.8887,
+      "suggested_scalar": -0.2854,
+      "log_bad": 7.6079,
+      "log_good": 7.4899
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 668.0,
+      "good": 597.0,
+      "ratio": 0.8937,
+      "suggested_scalar": -0.2719,
+      "log_bad": 6.5043,
+      "log_good": 6.3919
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 29.7826,
+      "good": 27.7273,
+      "ratio": 0.931,
+      "suggested_scalar": -0.173,
+      "log_bad": 3.3939,
+      "log_good": 3.3224
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0798,
+      "good": 1.0878,
+      "ratio": 1.0074,
+      "suggested_scalar": 0.0179,
+      "log_bad": 0.0768,
+      "log_good": 0.0842
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.4411,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 17.0,
+      "good": 19.0,
+      "ratio": 1.1176,
+      "suggested_scalar": 0.2691,
+      "log_bad": 2.8332,
+      "log_good": 2.9444
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.814,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9164,
+      "good": 0.9262,
+      "ratio": 1.0107,
+      "suggested_scalar": 0.0257,
+      "log_bad": -0.0873,
+      "log_good": -0.0767
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9793,
+      "good": 0.9713,
+      "ratio": 0.9918,
+      "suggested_scalar": -0.0198,
+      "log_bad": -0.0209,
+      "log_good": -0.0291
+    },
+    "halstead.mean_length": {
+      "bad": 297.0,
+      "good": 270.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.2306,
+      "log_bad": 5.6937,
+      "log_good": 5.5984
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 17.5,
+      "good": 16.0,
+      "ratio": 0.9143,
+      "suggested_scalar": -0.2168,
+      "log_bad": 2.8622,
+      "log_good": 2.7726
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7549,
+      "good": 6.5546,
+      "ratio": 0.9703,
+      "suggested_scalar": -0.0728,
+      "log_bad": 1.9103,
+      "log_good": 1.8802
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.106,
+      "good": 0.1131,
+      "ratio": 1.067,
+      "suggested_scalar": 0.1569,
+      "log_bad": -2.2443,
+      "log_good": -2.1795
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 26.3148,
+      "good": 26.4225,
+      "ratio": 1.0041,
+      "suggested_scalar": 0.0099,
+      "log_bad": 3.2701,
+      "log_good": 3.2742
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 68.0,
+      "good": 57.0,
+      "ratio": 0.8382,
+      "suggested_scalar": -0.4269,
+      "log_bad": 4.2195,
+      "log_good": 4.0431
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.814,
+      "good": 0.8026,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0341,
+      "log_bad": -0.2058,
+      "log_good": -0.2199
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 46.0,
+      "good": 44.0,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.1075,
+      "log_bad": 3.8286,
+      "log_good": 3.7842
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.no_member_name_prefixes_suffixes": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 38.0,
+      "good": 22.0,
+      "ratio": 0.5789,
+      "suggested_scalar": -0.2867,
+      "log_bad": 3.6376,
+      "log_good": 3.091
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0073,
+      "good": 0.0077,
+      "ratio": 1.0548,
+      "suggested_scalar": 0.028,
+      "log_bad": -4.9199,
+      "log_good": -4.8665
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.2857,
+      "good": 0.2222,
+      "ratio": 0.7777,
+      "suggested_scalar": -0.1319,
+      "log_bad": -1.2528,
+      "log_good": -1.5042
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9057,
+      "good": 0.9,
+      "ratio": 0.9937,
+      "suggested_scalar": -0.0033,
+      "log_bad": -0.099,
+      "log_good": -0.1054
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0147,
+      "good": 0.0077,
+      "ratio": 0.5238,
+      "suggested_scalar": -0.3392,
+      "log_bad": -4.2199,
+      "log_good": -4.8665
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7251,
+      "good": 4.729,
+      "ratio": 1.0008,
+      "suggested_scalar": 0.0004,
+      "log_bad": 1.5529,
+      "log_good": 1.5537
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 97.0,
+      "good": 76.0,
+      "ratio": 0.7835,
+      "suggested_scalar": -0.128,
+      "log_bad": 4.5747,
+      "log_good": 4.3307
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5224,
+      "good": 0.3841,
+      "ratio": 0.7353,
+      "suggested_scalar": -0.1613,
+      "log_bad": -0.6493,
+      "log_good": -0.9569
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 14.0,
+      "good": 12.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0809,
+      "log_bad": 2.6391,
+      "log_good": 2.4849
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7113,
+      "good": 0.6317,
+      "ratio": 0.8881,
+      "suggested_scalar": -0.0623,
+      "log_bad": -0.3407,
+      "log_good": -0.4593
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.3585,
+      "good": 5.36,
+      "ratio": 1.0003,
+      "suggested_scalar": 0.0001,
+      "log_bad": 1.6787,
+      "log_good": 1.679
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 409.0,
+      "good": 389.0,
+      "ratio": 0.9511,
+      "suggested_scalar": -0.0263,
+      "log_bad": 6.0137,
+      "log_good": 5.9636
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0755,
+      "good": 1.0,
+      "ratio": 13.245,
+      "suggested_scalar": 1.3555,
+      "log_bad": -2.5836,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9688,
+      "good": 1.0511,
+      "ratio": 1.085,
+      "suggested_scalar": 0.0428,
+      "log_bad": -0.0317,
+      "log_good": 0.0498
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 148.0,
+      "good": 136.0,
+      "ratio": 0.9189,
+      "suggested_scalar": -0.0444,
+      "log_bad": 4.9972,
+      "log_good": 4.9127
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 83.2758,
+      "good": 92.0073,
+      "ratio": 1.1049,
+      "suggested_scalar": 0.0523,
+      "log_bad": 4.4222,
+      "log_good": 4.5219
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5735,
+      "good": 0.6366,
+      "ratio": 1.11,
+      "suggested_scalar": 0.0548,
+      "log_bad": -0.556,
+      "log_good": -0.4516
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 17.2361,
+      "good": 18.0942,
+      "ratio": 1.0498,
+      "suggested_scalar": 0.0255,
+      "log_bad": 2.847,
+      "log_good": 2.8956
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2221.0,
+      "good": 2070.0,
+      "ratio": 0.932,
+      "suggested_scalar": -0.0369,
+      "log_bad": 7.7057,
+      "log_good": 7.6353
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1132,
+      "good": 0.06,
+      "ratio": 0.53,
+      "suggested_scalar": -0.333,
+      "log_bad": -2.1786,
+      "log_good": -2.8134
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8679,
+      "good": 0.86,
+      "ratio": 0.9909,
+      "suggested_scalar": -0.0048,
+      "log_bad": -0.1417,
+      "log_good": -0.1508
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.717,
+      "good": 7.78,
+      "ratio": 1.0082,
+      "suggested_scalar": 0.0043,
+      "log_bad": 2.0434,
+      "log_good": 2.0516
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 18.0,
+      "good": 1.0,
+      "ratio": 0.0556,
+      "suggested_scalar": -1.5164,
+      "log_bad": 2.8904,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 9.6262,
+      "good": 9.9904,
+      "ratio": 1.0378,
+      "suggested_scalar": 0.0195,
+      "log_bad": 2.2645,
+      "log_good": 2.3016
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 43.0,
+      "good": 63.0,
+      "ratio": 1.4651,
+      "suggested_scalar": 0.2004,
+      "log_bad": 3.7612,
+      "log_good": 4.1431
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9547,
+      "good": 0.9391,
+      "ratio": 0.9837,
+      "suggested_scalar": -0.0086,
+      "log_bad": -0.0464,
+      "log_good": -0.0628
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 19.0,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.0525,
+      "log_bad": 3.0445,
+      "log_good": 2.9444
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6628,
+      "good": 0.6773,
+      "ratio": 1.0219,
+      "suggested_scalar": 0.0114,
+      "log_bad": -0.4113,
+      "log_good": -0.3896
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.371,
+      "good": 0.4057,
+      "ratio": 1.0935,
+      "suggested_scalar": 0.0469,
+      "log_bad": -0.9916,
+      "log_good": -0.9021
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9653,
+      "good": 3.0988,
+      "ratio": 1.045,
+      "suggested_scalar": 0.0231,
+      "log_bad": 1.087,
+      "log_good": 1.131
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 407.0,
+      "good": 387.0,
+      "ratio": 0.9509,
+      "suggested_scalar": -0.0264,
+      "log_bad": 6.0088,
+      "log_good": 5.9584
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0,
+      "good": 5.9307,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0061,
+      "log_bad": 1.7918,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 49.0,
+      "good": 48.0,
+      "ratio": 0.9796,
+      "suggested_scalar": -0.0108,
+      "log_bad": 3.8918,
+      "log_good": 3.8712
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.9194,
+      "good": 1.5911,
+      "ratio": 0.829,
+      "suggested_scalar": -0.0984,
+      "log_bad": 0.652,
+      "log_good": 0.4644
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 0.0221,
+      "ratio": 0.0221,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -3.8122
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7603,
+      "good": 5.4107,
+      "ratio": 0.9393,
+      "suggested_scalar": -0.0328,
+      "log_bad": 1.751,
+      "log_good": 1.6884
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7875,
+      "good": 0.7974,
+      "ratio": 1.0126,
+      "suggested_scalar": 0.0066,
+      "log_bad": -0.2389,
+      "log_good": -0.2264
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1452,
+      "good": 0.1379,
+      "ratio": 0.9497,
+      "suggested_scalar": -0.0271,
+      "log_bad": -1.9296,
+      "log_good": -1.9812
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.1516,
+      "good": 4.2537,
+      "ratio": 1.0246,
+      "suggested_scalar": 0.0127,
+      "log_bad": 1.4235,
+      "log_good": 1.4478
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.2127,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 314.0,
+      "good": 288.0,
+      "ratio": 0.9172,
+      "suggested_scalar": -0.0453,
+      "log_bad": 5.7494,
+      "log_good": 5.663
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 10.0,
+      "good": 11.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.05,
+      "log_bad": 2.3026,
+      "log_good": 2.3979
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8536,
+      "good": 0.7789,
+      "ratio": 0.9125,
+      "suggested_scalar": -0.048,
+      "log_bad": -0.1583,
+      "log_good": -0.2499
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 102.0,
+      "good": 79.0,
+      "ratio": 0.7745,
+      "suggested_scalar": -0.1341,
+      "log_bad": 4.625,
+      "log_good": 4.3694
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1181.0,
+      "good": 1083.0,
+      "ratio": 0.917,
+      "suggested_scalar": -0.0454,
+      "log_bad": 7.0741,
+      "log_good": 6.9875
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 185.0,
+      "good": 170.0,
+      "ratio": 0.9189,
+      "suggested_scalar": -0.0444,
+      "log_bad": 5.2204,
+      "log_good": 5.1358
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2421,
+      "good": 0.2648,
+      "ratio": 1.0938,
+      "suggested_scalar": 0.047,
+      "log_bad": -1.4184,
+      "log_good": -1.3288
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 72.0,
+      "good": 73.0,
+      "ratio": 1.0139,
+      "suggested_scalar": 0.0072,
+      "log_bad": 4.2767,
+      "log_good": 4.2905
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 9.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.1318,
+      "log_bad": 1.9459,
+      "log_good": 2.1972
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 102.0,
+      "good": 79.0,
+      "ratio": 0.7745,
+      "suggested_scalar": -0.1341,
+      "log_bad": 4.625,
+      "log_good": 4.3694
+    },
+    "brevity.mean_sample_size": {
+      "bad": 102.0,
+      "good": 79.0,
+      "ratio": 0.7745,
+      "suggested_scalar": -0.1341,
+      "log_bad": 4.625,
+      "log_good": 4.3694
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 409.0,
+      "good": 389.0,
+      "ratio": 0.9511,
+      "suggested_scalar": -0.0263,
+      "log_bad": 6.0137,
+      "log_good": 5.9636
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 192.0,
+      "good": 188.0,
+      "ratio": 0.9792,
+      "suggested_scalar": -0.011,
+      "log_bad": 5.2575,
+      "log_good": 5.2364
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 246.0,
+      "good": 214.0,
+      "ratio": 0.8699,
+      "suggested_scalar": -0.0731,
+      "log_bad": 5.5053,
+      "log_good": 5.366
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0073,
+      "good": 0.0051,
+      "ratio": 0.6986,
+      "suggested_scalar": -0.1882,
+      "log_bad": -4.9199,
+      "log_good": -5.2785
+    },
+    "heaps.mean_k": {
+      "bad": 1.6501,
+      "good": 2.0187,
+      "ratio": 1.2234,
+      "suggested_scalar": 0.1058,
+      "log_bad": 0.5008,
+      "log_good": 0.7025
+    },
+    "halstead.mean_effort": {
+      "bad": 65451.162,
+      "good": 66207.2052,
+      "ratio": 1.0116,
+      "suggested_scalar": 0.006,
+      "log_bad": 11.0891,
+      "log_good": 11.1005
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8633,
+      "good": 0.8583,
+      "ratio": 0.9942,
+      "suggested_scalar": -0.003,
+      "log_bad": -0.147,
+      "log_good": -0.1528
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 76.0,
+      "good": 57.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1509,
+      "log_bad": 4.3307,
+      "log_good": 4.0431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 203.0,
+      "good": 204.0,
+      "ratio": 1.0049,
+      "suggested_scalar": 0.0026,
+      "log_bad": 5.3132,
+      "log_good": 5.3181
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4662,
+      "good": 0.3676,
+      "ratio": 0.7885,
+      "suggested_scalar": -0.1247,
+      "log_bad": -0.7631,
+      "log_good": -1.0008
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.9797,
+      "good": 7.9632,
+      "ratio": 0.9979,
+      "suggested_scalar": -0.0011,
+      "log_bad": 2.0769,
+      "log_good": 2.0748
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1452,
+      "good": 0.1379,
+      "ratio": 0.9497,
+      "suggested_scalar": -0.0271,
+      "log_bad": -1.9296,
+      "log_good": -1.9812
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.5396,
+      "good": 4.3303,
+      "ratio": 0.7817,
+      "suggested_scalar": -0.1292,
+      "log_bad": 1.7119,
+      "log_good": 1.4656
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 408.0,
+      "good": 388.0,
+      "ratio": 0.951,
+      "suggested_scalar": -0.0264,
+      "log_bad": 6.0113,
+      "log_good": 5.961
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 58.0,
+      "good": 58.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0604,
+      "log_good": 4.0604
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3636.1757,
+      "good": 3678.1781,
+      "ratio": 1.0116,
+      "suggested_scalar": 0.006,
+      "log_bad": 8.1987,
+      "log_good": 8.2102
+    },
+    "readability.mean_total_lines": {
+      "bad": 53.0,
+      "good": 50.0,
+      "ratio": 0.9434,
+      "suggested_scalar": -0.0306,
+      "log_bad": 3.9703,
+      "log_good": 3.912
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2560.7662,
+      "good": 2336.7249,
+      "ratio": 0.9125,
+      "suggested_scalar": -0.048,
+      "log_bad": 7.8481,
+      "log_good": 7.7565
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 749.0,
+      "good": 668.0,
+      "ratio": 0.8919,
+      "suggested_scalar": -0.06,
+      "log_bad": 6.6187,
+      "log_good": 6.5043
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 40.7358,
+      "good": 40.24,
+      "ratio": 0.9878,
+      "suggested_scalar": -0.0064,
+      "log_bad": 3.7071,
+      "log_good": 3.6949
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3679,
+      "good": 1.264,
+      "ratio": 0.924,
+      "suggested_scalar": -0.0414,
+      "log_bad": 0.3133,
+      "log_good": 0.2343
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 32.0,
+      "good": 33.0,
+      "ratio": 1.0313,
+      "suggested_scalar": 0.0161,
+      "log_bad": 3.4657,
+      "log_good": 3.4965
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 1.0,
+      "ratio": 0.25,
+      "suggested_scalar": -0.7273,
+      "log_bad": 1.3863,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8153,
+      "good": 0.7986,
+      "ratio": 0.9795,
+      "suggested_scalar": -0.0109,
+      "log_bad": -0.2042,
+      "log_good": -0.2249
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9671,
+      "good": 0.9732,
+      "ratio": 1.0063,
+      "suggested_scalar": 0.0033,
+      "log_bad": -0.0335,
+      "log_good": -0.0272
+    },
+    "halstead.mean_length": {
+      "bad": 388.0,
+      "good": 374.0,
+      "ratio": 0.9639,
+      "suggested_scalar": -0.0193,
+      "log_bad": 5.961,
+      "log_good": 5.9243
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 3.7143,
+      "good": 3.1111,
+      "ratio": 0.8376,
+      "suggested_scalar": -0.093,
+      "log_bad": 1.3122,
+      "log_good": 1.135
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6724,
+      "good": 6.3038,
+      "ratio": 0.9448,
+      "suggested_scalar": -0.0298,
+      "log_bad": 1.898,
+      "log_good": 1.8412
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0864,
+      "good": 0.0908,
+      "ratio": 1.0509,
+      "suggested_scalar": 0.0261,
+      "log_bad": -2.4488,
+      "log_good": -2.3991
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.5592,
+      "good": 28.3333,
+      "ratio": 1.1085,
+      "suggested_scalar": 0.0541,
+      "log_bad": 3.241,
+      "log_good": 3.344
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 3.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.3636,
+      "log_bad": 1.7918,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 69.0,
+      "good": 50.0,
+      "ratio": 0.7246,
+      "suggested_scalar": -0.169,
+      "log_bad": 4.2341,
+      "log_good": 3.912
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7073,
+      "good": 0.6589,
+      "ratio": 0.9316,
+      "suggested_scalar": -0.0372,
+      "log_bad": -0.3463,
+      "log_good": -0.4172
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 53.0,
+      "good": 50.0,
+      "ratio": 0.9434,
+      "suggested_scalar": -0.0306,
+      "log_bad": 3.9703,
+      "log_good": 3.912
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 26.0,
+      "good": 26.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2581,
+      "log_good": 3.2581
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.5764,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    }
+  },
+  "type_and_value.uses_return_type_declaration": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "consistency.consistent_error_return_shape": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 52.0,
+      "good": 60.0,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.1553,
+      "log_bad": 3.9512,
+      "log_good": 4.0943
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.012,
+      "good": 0.0019,
+      "ratio": 0.1583,
+      "suggested_scalar": -2.0,
+      "log_bad": -4.4228,
+      "log_good": -6.2659
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.381,
+      "good": 1.381,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.3228,
+      "log_good": 0.3228
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7442,
+      "good": 0.7848,
+      "ratio": 1.0546,
+      "suggested_scalar": 0.0576,
+      "log_bad": -0.2954,
+      "log_good": -0.2423
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.012,
+      "good": 0.0019,
+      "ratio": 0.1583,
+      "suggested_scalar": -2.0,
+      "log_bad": -4.4228,
+      "log_good": -6.2659
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.3598,
+      "good": 4.4243,
+      "ratio": 1.0148,
+      "suggested_scalar": 0.0159,
+      "log_bad": 1.4724,
+      "log_good": 1.4871
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 87.0,
+      "good": 90.0,
+      "ratio": 1.0345,
+      "suggested_scalar": 0.0368,
+      "log_bad": 4.4659,
+      "log_good": 4.4998
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4607,
+      "good": 0.4722,
+      "ratio": 1.025,
+      "suggested_scalar": 0.0268,
+      "log_bad": -0.775,
+      "log_good": -0.7504
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5391,
+      "good": 0.5195,
+      "ratio": 0.9636,
+      "suggested_scalar": -0.0402,
+      "log_bad": -0.6179,
+      "log_good": -0.6549
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.6047,
+      "good": 4.3418,
+      "ratio": 0.9429,
+      "suggested_scalar": -0.0638,
+      "log_bad": 1.5271,
+      "log_good": 1.4683
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 502.0,
+      "good": 519.0,
+      "ratio": 1.0339,
+      "suggested_scalar": 0.0361,
+      "log_bad": 6.2186,
+      "log_good": 6.2519
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0017,
+      "good": 0.0017,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.3771,
+      "log_good": -6.3771
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1357,
+      "good": 1.1548,
+      "ratio": 1.0168,
+      "suggested_scalar": 0.0181,
+      "log_bad": 0.1272,
+      "log_good": 0.1439
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 143.0,
+      "good": 150.0,
+      "ratio": 1.049,
+      "suggested_scalar": 0.0519,
+      "log_bad": 4.9628,
+      "log_good": 5.0106
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 93.2375,
+      "good": 89.4557,
+      "ratio": 0.9594,
+      "suggested_scalar": -0.0449,
+      "log_bad": 4.5352,
+      "log_good": 4.4937
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6886,
+      "good": 0.7278,
+      "ratio": 1.0569,
+      "suggested_scalar": 0.0601,
+      "log_bad": -0.3731,
+      "log_good": -0.3177
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 21.531,
+      "good": 22.8549,
+      "ratio": 1.0615,
+      "suggested_scalar": 0.0648,
+      "log_bad": 3.0695,
+      "log_good": 3.1292
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2348.0,
+      "good": 2298.0,
+      "ratio": 0.9787,
+      "suggested_scalar": -0.0234,
+      "log_bad": 7.7613,
+      "log_good": 7.7398
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1279,
+      "good": 0.1139,
+      "ratio": 0.8905,
+      "suggested_scalar": -0.1258,
+      "log_bad": -2.0565,
+      "log_good": -2.1724
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7093,
+      "good": 0.7468,
+      "ratio": 1.0529,
+      "suggested_scalar": 0.0559,
+      "log_bad": -0.3435,
+      "log_good": -0.292
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.8372,
+      "good": 6.5696,
+      "ratio": 1.1255,
+      "suggested_scalar": 0.1283,
+      "log_bad": 1.7643,
+      "log_good": 1.8825
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 6.6111,
+      "good": 6.1237,
+      "ratio": 0.9263,
+      "suggested_scalar": -0.0831,
+      "log_bad": 1.8888,
+      "log_good": 1.8122
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 127.0,
+      "good": 134.0,
+      "ratio": 1.0551,
+      "suggested_scalar": 0.0582,
+      "log_bad": 4.8442,
+      "log_good": 4.8978
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9464,
+      "good": 0.9489,
+      "ratio": 1.0026,
+      "suggested_scalar": 0.0029,
+      "log_bad": -0.0551,
+      "log_good": -0.0525
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 27.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.0835,
+      "log_bad": 3.2189,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.7138,
+      "good": 0.7176,
+      "ratio": 1.0053,
+      "suggested_scalar": 0.0058,
+      "log_bad": -0.3372,
+      "log_good": -0.3318
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.494,
+      "good": 0.5377,
+      "ratio": 1.0885,
+      "suggested_scalar": 0.092,
+      "log_bad": -0.7052,
+      "log_good": -0.6205
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.494,
+      "good": 3.5408,
+      "ratio": 1.0134,
+      "suggested_scalar": 0.0144,
+      "log_bad": 1.251,
+      "log_good": 1.2644
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 500.0,
+      "good": 517.0,
+      "ratio": 1.034,
+      "suggested_scalar": 0.0363,
+      "log_bad": 6.2146,
+      "log_good": 6.248
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0259,
+      "good": 0.025,
+      "ratio": 0.9653,
+      "suggested_scalar": -0.0384,
+      "log_bad": -3.6535,
+      "log_good": -3.6889
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.6147,
+      "good": 5.6147,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7254,
+      "log_good": 1.7254
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.5964,
+      "good": 0.5763,
+      "ratio": 0.9663,
+      "suggested_scalar": -0.0372,
+      "log_bad": -0.5168,
+      "log_good": -0.5511
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.3991,
+      "good": 5.2631,
+      "ratio": 0.9748,
+      "suggested_scalar": -0.0277,
+      "log_bad": 1.6862,
+      "log_good": 1.6607
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7765,
+      "good": 0.788,
+      "ratio": 1.0148,
+      "suggested_scalar": 0.016,
+      "log_bad": -0.253,
+      "log_good": -0.2383
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1569,
+      "good": 0.1596,
+      "ratio": 1.0172,
+      "suggested_scalar": 0.0185,
+      "log_bad": -1.8521,
+      "log_good": -1.8351
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.6402,
+      "good": 4.7807,
+      "ratio": 1.0303,
+      "suggested_scalar": 0.0324,
+      "log_bad": 1.5348,
+      "log_good": 1.5646
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 325.0,
+      "good": 312.0,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0443,
+      "log_bad": 5.7838,
+      "log_good": 5.743
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 13.0,
+      "good": 14.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0804,
+      "log_bad": 2.5649,
+      "log_good": 2.6391
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9686,
+      "good": 1.0603,
+      "ratio": 1.0947,
+      "suggested_scalar": 0.0982,
+      "log_bad": -0.0319,
+      "log_good": 0.0586
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 93.0,
+      "good": 95.0,
+      "ratio": 1.0215,
+      "suggested_scalar": 0.0231,
+      "log_bad": 4.5326,
+      "log_good": 4.5539
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1108.0,
+      "good": 1158.0,
+      "ratio": 1.0451,
+      "suggested_scalar": 0.0479,
+      "log_bad": 7.0103,
+      "log_good": 7.0544
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 156.0,
+      "good": 160.0,
+      "ratio": 1.0256,
+      "suggested_scalar": 0.0275,
+      "log_bad": 5.0499,
+      "log_good": 5.0752
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0438,
+      "good": 0.0308,
+      "ratio": 0.7032,
+      "suggested_scalar": -0.3821,
+      "log_bad": -3.1281,
+      "log_good": -3.4802
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2669,
+      "good": 0.2852,
+      "ratio": 1.0686,
+      "suggested_scalar": 0.072,
+      "log_bad": -1.3209,
+      "log_good": -1.2546
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 79.0,
+      "good": 80.0,
+      "ratio": 1.0127,
+      "suggested_scalar": 0.0136,
+      "log_bad": 4.3694,
+      "log_good": 4.382
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 93.0,
+      "good": 95.0,
+      "ratio": 1.0215,
+      "suggested_scalar": 0.0231,
+      "log_bad": 4.5326,
+      "log_good": 4.5539
+    },
+    "brevity.mean_sample_size": {
+      "bad": 93.0,
+      "good": 95.0,
+      "ratio": 1.0215,
+      "suggested_scalar": 0.0231,
+      "log_bad": 4.5326,
+      "log_good": 4.5539
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 502.0,
+      "good": 519.0,
+      "ratio": 1.0339,
+      "suggested_scalar": 0.0361,
+      "log_bad": 6.2186,
+      "log_good": 6.2519
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 248.0,
+      "good": 275.0,
+      "ratio": 1.1089,
+      "suggested_scalar": 0.1121,
+      "log_bad": 5.5134,
+      "log_good": 5.6168
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 235.0,
+      "good": 221.0,
+      "ratio": 0.9404,
+      "suggested_scalar": -0.0667,
+      "log_bad": 5.4596,
+      "log_good": 5.3982
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.002,
+      "good": 0.0019,
+      "ratio": 0.95,
+      "suggested_scalar": -0.0557,
+      "log_bad": -6.2146,
+      "log_good": -6.2659
+    },
+    "heaps.mean_k": {
+      "bad": 3.48,
+      "good": 3.782,
+      "ratio": 1.0868,
+      "suggested_scalar": 0.0903,
+      "log_bad": 1.247,
+      "log_good": 1.3303
+    },
+    "halstead.mean_effort": {
+      "bad": 91391.0751,
+      "good": 109063.132,
+      "ratio": 1.1934,
+      "suggested_scalar": 0.1918,
+      "log_bad": 11.4229,
+      "log_good": 11.5997
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8257,
+      "good": 0.8011,
+      "ratio": 0.9702,
+      "suggested_scalar": -0.0328,
+      "log_bad": -0.1915,
+      "log_good": -0.2218
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 62.0,
+      "good": 63.0,
+      "ratio": 1.0161,
+      "suggested_scalar": 0.0174,
+      "log_bad": 4.1271,
+      "log_good": 4.1431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 295.0,
+      "good": 330.0,
+      "ratio": 1.1186,
+      "suggested_scalar": 0.1217,
+      "log_bad": 5.687,
+      "log_good": 5.7991
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4056,
+      "good": 0.4,
+      "ratio": 0.9862,
+      "suggested_scalar": -0.0151,
+      "log_bad": -0.9024,
+      "log_good": -0.9163
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.7483,
+      "good": 7.72,
+      "ratio": 0.9963,
+      "suggested_scalar": -0.004,
+      "log_bad": 2.0475,
+      "log_good": 2.0438
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1569,
+      "good": 0.1596,
+      "ratio": 1.0172,
+      "suggested_scalar": 0.0185,
+      "log_bad": -1.8521,
+      "log_good": -1.8351
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.1807,
+      "good": 5.5908,
+      "ratio": 1.0792,
+      "suggested_scalar": 0.0827,
+      "log_bad": 1.6449,
+      "log_good": 1.7211
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 501.0,
+      "good": 518.0,
+      "ratio": 1.0339,
+      "suggested_scalar": 0.0362,
+      "log_bad": 6.2166,
+      "log_good": 6.25
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 72.0,
+      "good": 73.0,
+      "ratio": 1.0139,
+      "suggested_scalar": 0.015,
+      "log_bad": 4.2767,
+      "log_good": 4.2905
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5077.282,
+      "good": 6059.0629,
+      "ratio": 1.1934,
+      "suggested_scalar": 0.1918,
+      "log_bad": 8.5325,
+      "log_good": 8.7093
+    },
+    "readability.mean_total_lines": {
+      "bad": 86.0,
+      "good": 79.0,
+      "ratio": 0.9186,
+      "suggested_scalar": -0.0921,
+      "log_bad": 4.4543,
+      "log_good": 4.3694
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 2905.7675,
+      "good": 3181.008,
+      "ratio": 1.0947,
+      "suggested_scalar": 0.0982,
+      "log_bad": 7.9745,
+      "log_good": 8.065
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 672.0,
+      "good": 649.0,
+      "ratio": 0.9658,
+      "suggested_scalar": -0.0378,
+      "log_bad": 6.5103,
+      "log_good": 6.4754
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 26.1163,
+      "good": 27.8987,
+      "ratio": 1.0682,
+      "suggested_scalar": 0.0716,
+      "log_bad": 3.2626,
+      "log_good": 3.3286
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2727,
+      "good": 1.3086,
+      "ratio": 1.0282,
+      "suggested_scalar": 0.0302,
+      "log_bad": 0.2411,
+      "log_good": 0.269
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7785,
+      "good": 0.766,
+      "ratio": 0.9839,
+      "suggested_scalar": -0.0176,
+      "log_bad": -0.2504,
+      "log_good": -0.2666
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9876,
+      "good": 0.9841,
+      "ratio": 0.9965,
+      "suggested_scalar": -0.0039,
+      "log_bad": -0.0125,
+      "log_good": -0.016
+    },
+    "halstead.mean_length": {
+      "bad": 451.0,
+      "good": 490.0,
+      "ratio": 1.0865,
+      "suggested_scalar": 0.09,
+      "log_bad": 6.1115,
+      "log_good": 6.1944
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.7143,
+      "good": 4.3333,
+      "ratio": 0.9192,
+      "suggested_scalar": -0.0914,
+      "log_bad": 1.5506,
+      "log_good": 1.4663
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5392,
+      "good": 6.5699,
+      "ratio": 1.0047,
+      "suggested_scalar": 0.0051,
+      "log_bad": 1.8778,
+      "log_good": 1.8825
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1056,
+      "good": 0.1197,
+      "ratio": 1.1335,
+      "suggested_scalar": 0.136,
+      "log_bad": -2.2481,
+      "log_good": -2.1228
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 31.4516,
+      "good": 34.2857,
+      "ratio": 1.0901,
+      "suggested_scalar": 0.0936,
+      "log_bad": 3.4484,
+      "log_good": 3.5347
+    },
+    "branching.mean_branch_count": {
+      "bad": 11.0,
+      "good": 9.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.2178,
+      "log_bad": 2.3979,
+      "log_good": 2.1972
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 58.0,
+      "good": 60.0,
+      "ratio": 1.0345,
+      "suggested_scalar": 0.0368,
+      "log_bad": 4.0604,
+      "log_good": 4.0943
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6638,
+      "good": 0.638,
+      "ratio": 0.9611,
+      "suggested_scalar": -0.043,
+      "log_bad": -0.4098,
+      "log_good": -0.4494
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 86.0,
+      "good": 79.0,
+      "ratio": 0.9186,
+      "suggested_scalar": -0.0921,
+      "log_bad": 4.4543,
+      "log_good": 4.3694
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.no_arguments_object": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 22.0,
+      "good": 29.0,
+      "ratio": 1.3182,
+      "suggested_scalar": 0.1035,
+      "log_bad": 3.091,
+      "log_good": 3.3673
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.0626,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2596,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0246,
+      "good": 0.0285,
+      "ratio": 1.1585,
+      "suggested_scalar": 0.0551,
+      "log_bad": -3.705,
+      "log_good": -3.5579
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.4,
+      "good": 2.0,
+      "ratio": 5.0,
+      "suggested_scalar": 0.6029,
+      "log_bad": -0.9163,
+      "log_good": 0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7708,
+      "good": 0.8718,
+      "ratio": 1.131,
+      "suggested_scalar": 0.0461,
+      "log_bad": -0.2603,
+      "log_good": -0.1372
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0246,
+      "good": 0.0285,
+      "ratio": 1.1585,
+      "suggested_scalar": 0.0551,
+      "log_bad": -3.705,
+      "log_good": -3.5579
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.9933,
+      "good": 5.0334,
+      "ratio": 1.008,
+      "suggested_scalar": 0.003,
+      "log_bad": 1.6081,
+      "log_good": 1.6161
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 72.0,
+      "good": 74.0,
+      "ratio": 1.0278,
+      "suggested_scalar": 0.0103,
+      "log_bad": 4.2767,
+      "log_good": 4.3041
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3744,
+      "good": 0.43,
+      "ratio": 1.1485,
+      "suggested_scalar": 0.0519,
+      "log_bad": -0.9824,
+      "log_good": -0.844
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 19.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.0203,
+      "log_bad": 2.8904,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.4162,
+      "good": 0.5357,
+      "ratio": 1.2871,
+      "suggested_scalar": 0.0946,
+      "log_bad": -0.8766,
+      "log_good": -0.6242
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.7917,
+      "good": 1.6923,
+      "ratio": 0.9445,
+      "suggested_scalar": -0.0214,
+      "log_bad": 0.5832,
+      "log_good": 0.5261
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 488.0,
+      "good": 421.0,
+      "ratio": 0.8627,
+      "suggested_scalar": -0.0553,
+      "log_bad": 6.1903,
+      "log_good": 6.0426
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0836,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0012,
+      "good": 0.0013,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.03,
+      "log_bad": -6.7254,
+      "log_good": -6.6454
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1274,
+      "good": 1.0821,
+      "ratio": 0.9598,
+      "suggested_scalar": -0.0154,
+      "log_bad": 0.1199,
+      "log_good": 0.0789
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 131.0,
+      "good": 104.0,
+      "ratio": 0.7939,
+      "suggested_scalar": -0.0865,
+      "log_bad": 4.8752,
+      "log_good": 4.6444
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 96.0533,
+      "good": 85.6418,
+      "ratio": 0.8916,
+      "suggested_scalar": -0.043,
+      "log_bad": 4.5649,
+      "log_good": 4.4502
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7331,
+      "good": 0.6833,
+      "ratio": 0.9321,
+      "suggested_scalar": -0.0264,
+      "log_bad": -0.3105,
+      "log_good": -0.3808
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 15.088,
+      "good": 17.173,
+      "ratio": 1.1382,
+      "suggested_scalar": 0.0485,
+      "log_bad": 2.7139,
+      "log_good": 2.8433
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1699.0,
+      "good": 1485.0,
+      "ratio": 0.874,
+      "suggested_scalar": -0.0504,
+      "log_bad": 7.4378,
+      "log_good": 7.3032
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1875,
+      "good": 0.1282,
+      "ratio": 0.6837,
+      "suggested_scalar": -0.1424,
+      "log_bad": -1.674,
+      "log_good": -2.0542
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.75,
+      "good": 0.8462,
+      "ratio": 1.1283,
+      "suggested_scalar": 0.0452,
+      "log_bad": -0.2877,
+      "log_good": -0.167
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.1667,
+      "good": 10.7949,
+      "ratio": 1.0618,
+      "suggested_scalar": 0.0225,
+      "log_bad": 2.3191,
+      "log_good": 2.3791
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.3733,
+      "good": 1.9566,
+      "ratio": 1.4247,
+      "suggested_scalar": 0.1326,
+      "log_bad": 0.3172,
+      "log_good": 0.6712
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 94.0,
+      "good": 60.0,
+      "ratio": 0.6383,
+      "suggested_scalar": -0.1682,
+      "log_bad": 4.5433,
+      "log_good": 4.0943
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.888,
+      "good": 0.9467,
+      "ratio": 1.0661,
+      "suggested_scalar": 0.024,
+      "log_bad": -0.1188,
+      "log_good": -0.0548
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6563,
+      "good": 0.6088,
+      "ratio": 0.9276,
+      "suggested_scalar": -0.0281,
+      "log_bad": -0.4211,
+      "log_good": -0.4963
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.572,
+      "good": 0.4463,
+      "ratio": 0.7802,
+      "suggested_scalar": -0.093,
+      "log_bad": -0.5586,
+      "log_good": -0.8068
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9092,
+      "good": 2.5559,
+      "ratio": 0.8786,
+      "suggested_scalar": -0.0485,
+      "log_bad": 1.0679,
+      "log_good": 0.9384
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 486.0,
+      "good": 419.0,
+      "ratio": 0.8621,
+      "suggested_scalar": -0.0556,
+      "log_bad": 6.1862,
+      "log_good": 6.0379
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 18.0,
+      "good": 17.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.0214,
+      "log_bad": 2.8904,
+      "log_good": 2.8332
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 0.0071,
+      "ratio": 0.0071,
+      "suggested_scalar": -1.8534,
+      "log_bad": 0.0,
+      "log_good": -4.9477
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9773,
+      "good": 5.9773,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.788,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1339,
+      "good": 1.3745,
+      "ratio": 1.2122,
+      "suggested_scalar": 0.0721,
+      "log_bad": 0.1257,
+      "log_good": 0.3181
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.3233,
+      "good": 5.1434,
+      "ratio": 0.9662,
+      "suggested_scalar": -0.0129,
+      "log_bad": 1.6721,
+      "log_good": 1.6377
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8354,
+      "good": 0.8421,
+      "ratio": 1.008,
+      "suggested_scalar": 0.003,
+      "log_bad": -0.1798,
+      "log_good": -0.1719
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1579,
+      "good": 0.2041,
+      "ratio": 1.2926,
+      "suggested_scalar": 0.0961,
+      "log_bad": -1.8458,
+      "log_good": -1.5891
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.8843,
+      "good": 4.144,
+      "ratio": 1.0669,
+      "suggested_scalar": 0.0242,
+      "log_bad": 1.3569,
+      "log_good": 1.4217
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 304.0,
+      "good": 302.0,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0025,
+      "log_bad": 5.717,
+      "log_good": 5.7104
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 32.0,
+      "good": 29.0,
+      "ratio": 0.9063,
+      "suggested_scalar": -0.0369,
+      "log_bad": 3.4657,
+      "log_good": 3.3673
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.907,
+      "good": 0.7286,
+      "ratio": 0.8033,
+      "suggested_scalar": -0.082,
+      "log_bad": -0.0976,
+      "log_good": -0.3166
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 69.0,
+      "good": 70.0,
+      "ratio": 1.0145,
+      "suggested_scalar": 0.0054,
+      "log_bad": 4.2341,
+      "log_good": 4.2485
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 875.0,
+      "good": 805.0,
+      "ratio": 0.92,
+      "suggested_scalar": -0.0312,
+      "log_bad": 6.7742,
+      "log_good": 6.6908
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 163.0,
+      "good": 119.0,
+      "ratio": 0.7301,
+      "suggested_scalar": -0.1179,
+      "log_bad": 5.0938,
+      "log_good": 4.7791
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 0.0048,
+      "ratio": 0.0048,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -5.3391
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1947,
+      "good": 0.1876,
+      "ratio": 0.9635,
+      "suggested_scalar": -0.0139,
+      "log_bad": -1.6363,
+      "log_good": -1.6734
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 98.0,
+      "good": 91.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.0278,
+      "log_bad": 4.585,
+      "log_good": 4.5109
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0683,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 69.0,
+      "good": 70.0,
+      "ratio": 1.0145,
+      "suggested_scalar": 0.0054,
+      "log_bad": 4.2341,
+      "log_good": 4.2485
+    },
+    "brevity.mean_sample_size": {
+      "bad": 69.0,
+      "good": 70.0,
+      "ratio": 1.0145,
+      "suggested_scalar": 0.0054,
+      "log_bad": 4.2341,
+      "log_good": 4.2485
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 488.0,
+      "good": 421.0,
+      "ratio": 0.8627,
+      "suggested_scalar": -0.0553,
+      "log_bad": 6.1903,
+      "log_good": 6.0426
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 304.0,
+      "good": 285.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0242,
+      "log_bad": 5.717,
+      "log_good": 5.6525
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 228.0,
+      "good": 224.0,
+      "ratio": 0.9825,
+      "suggested_scalar": -0.0066,
+      "log_bad": 5.4293,
+      "log_good": 5.4116
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 4.8459,
+      "good": 2.6806,
+      "ratio": 0.5532,
+      "suggested_scalar": -0.2218,
+      "log_bad": 1.5781,
+      "log_good": 0.986
+    },
+    "halstead.mean_effort": {
+      "bad": 97572.7982,
+      "good": 55021.4886,
+      "ratio": 0.5639,
+      "suggested_scalar": -0.2146,
+      "log_bad": 11.4884,
+      "log_good": 10.9155
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8715,
+      "good": 0.8392,
+      "ratio": 0.9629,
+      "suggested_scalar": -0.0141,
+      "log_bad": -0.1375,
+      "log_good": -0.1753
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 50.0,
+      "good": 52.0,
+      "ratio": 1.04,
+      "suggested_scalar": 0.0147,
+      "log_bad": 3.912,
+      "log_good": 3.9512
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 278.0,
+      "good": 233.0,
+      "ratio": 0.8381,
+      "suggested_scalar": -0.0661,
+      "log_bad": 5.6276,
+      "log_good": 5.451
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.313,
+      "good": 0.4135,
+      "ratio": 1.3211,
+      "suggested_scalar": 0.1043,
+      "log_bad": -1.1616,
+      "log_good": -0.8831
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.6794,
+      "good": 7.7404,
+      "ratio": 1.1588,
+      "suggested_scalar": 0.0552,
+      "log_bad": 1.899,
+      "log_good": 2.0465
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1579,
+      "good": 0.2041,
+      "ratio": 1.2926,
+      "suggested_scalar": 0.0961,
+      "log_bad": -1.8458,
+      "log_good": -1.5891
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.5667,
+      "good": 7.6513,
+      "ratio": 1.1652,
+      "suggested_scalar": 0.0573,
+      "log_bad": 1.882,
+      "log_good": 2.0349
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 487.0,
+      "good": 420.0,
+      "ratio": 0.8624,
+      "suggested_scalar": -0.0554,
+      "log_bad": 6.1883,
+      "log_good": 6.0403
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 96.0,
+      "good": 70.0,
+      "ratio": 0.7292,
+      "suggested_scalar": -0.1183,
+      "log_bad": 4.5643,
+      "log_good": 4.2485
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5420.711,
+      "good": 3056.7494,
+      "ratio": 0.5639,
+      "suggested_scalar": -0.2146,
+      "log_bad": 8.598,
+      "log_good": 8.0251
+    },
+    "readability.mean_total_lines": {
+      "bad": 48.0,
+      "good": 39.0,
+      "ratio": 0.8125,
+      "suggested_scalar": -0.0778,
+      "log_bad": 3.8712,
+      "log_good": 3.6636
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2720.9369,
+      "good": 2185.7276,
+      "ratio": 0.8033,
+      "suggested_scalar": -0.082,
+      "log_bad": 7.9087,
+      "log_good": 7.6897
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 584.0,
+      "good": 581.0,
+      "ratio": 0.9949,
+      "suggested_scalar": -0.0019,
+      "log_bad": 6.3699,
+      "log_good": 6.3648
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 34.2083,
+      "good": 36.8205,
+      "ratio": 1.0764,
+      "suggested_scalar": 0.0276,
+      "log_bad": 3.5325,
+      "log_good": 3.6061
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1875,
+      "good": 1.303,
+      "ratio": 1.0973,
+      "suggested_scalar": 0.0348,
+      "log_bad": 0.1719,
+      "log_good": 0.2647
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0836,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 31.0,
+      "good": 49.0,
+      "ratio": 1.5806,
+      "suggested_scalar": 0.1715,
+      "log_bad": 3.434,
+      "log_good": 3.8918
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6842,
+      "good": 0.7682,
+      "ratio": 1.1228,
+      "suggested_scalar": 0.0434,
+      "log_bad": -0.3795,
+      "log_good": -0.2637
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9476,
+      "good": 0.9741,
+      "ratio": 1.028,
+      "suggested_scalar": 0.0103,
+      "log_bad": -0.0538,
+      "log_good": -0.0262
+    },
+    "halstead.mean_length": {
+      "bad": 441.0,
+      "good": 352.0,
+      "ratio": 0.7982,
+      "suggested_scalar": -0.0844,
+      "log_bad": 6.089,
+      "log_good": 5.8636
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.4,
+      "good": 8.1667,
+      "ratio": 0.7164,
+      "suggested_scalar": -0.1249,
+      "log_bad": 2.4336,
+      "log_good": 2.1001
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.1085,
+      "good": 6.1293,
+      "ratio": 1.0034,
+      "suggested_scalar": 0.0013,
+      "log_bad": 1.8097,
+      "log_good": 1.8131
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1789,
+      "good": 0.1919,
+      "ratio": 1.0727,
+      "suggested_scalar": 0.0263,
+      "log_bad": -1.7209,
+      "log_good": -1.6508
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 35.86,
+      "good": 25.1731,
+      "ratio": 0.702,
+      "suggested_scalar": -0.1325,
+      "log_bad": 3.5796,
+      "log_good": 3.2258
+    },
+    "branching.mean_branch_count": {
+      "bad": 9.0,
+      "good": 5.0,
+      "ratio": 0.5556,
+      "suggested_scalar": -0.2202,
+      "log_bad": 2.1972,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 41.0,
+      "good": 43.0,
+      "ratio": 1.0488,
+      "suggested_scalar": 0.0178,
+      "log_bad": 3.7136,
+      "log_good": 3.7612
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5702,
+      "good": 0.5938,
+      "ratio": 1.0414,
+      "suggested_scalar": 0.0152,
+      "log_bad": -0.5618,
+      "log_good": -0.5212
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 48.0,
+      "good": 39.0,
+      "ratio": 0.8125,
+      "suggested_scalar": -0.0778,
+      "log_bad": 3.8712,
+      "log_good": 3.6636
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.uses_short_type_keywords": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_beta": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_redundancy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_sample_size": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_effort": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_total_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_max_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_volume": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_length": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.no_abbreviations_in_identifiers": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 22.0,
+      "good": 29.0,
+      "ratio": 1.3182,
+      "suggested_scalar": 0.7249,
+      "log_bad": 3.091,
+      "log_good": 3.3673
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 1.5,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.4055,
+      "log_good": 0.4055
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7593,
+      "good": 0.75,
+      "ratio": 0.9878,
+      "suggested_scalar": -0.0323,
+      "log_bad": -0.2754,
+      "log_good": -0.2877
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.3907,
+      "good": 4.4077,
+      "ratio": 1.0039,
+      "suggested_scalar": 0.0101,
+      "log_bad": 1.4795,
+      "log_good": 1.4834
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 79.0,
+      "good": 76.0,
+      "ratio": 0.962,
+      "suggested_scalar": -0.1016,
+      "log_bad": 4.3694,
+      "log_good": 4.3307
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4544,
+      "good": 0.4646,
+      "ratio": 1.0224,
+      "suggested_scalar": 0.0583,
+      "log_bad": -0.7888,
+      "log_good": -0.7666
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 13.0,
+      "good": 12.0,
+      "ratio": 0.9231,
+      "suggested_scalar": -0.21,
+      "log_bad": 2.5649,
+      "log_good": 2.4849
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6999,
+      "good": 0.7173,
+      "ratio": 1.0249,
+      "suggested_scalar": 0.0644,
+      "log_bad": -0.3568,
+      "log_good": -0.3323
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 9.8519,
+      "good": 9.9286,
+      "ratio": 1.0078,
+      "suggested_scalar": 0.0204,
+      "log_bad": 2.2877,
+      "log_good": 2.2954
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 295.0,
+      "good": 268.0,
+      "ratio": 0.9085,
+      "suggested_scalar": -0.2519,
+      "log_bad": 5.687,
+      "log_good": 5.591
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0019,
+      "good": 0.0016,
+      "ratio": 0.8421,
+      "suggested_scalar": -0.451,
+      "log_bad": -6.2659,
+      "log_good": -6.4378
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9394,
+      "good": 0.9175,
+      "ratio": 0.9767,
+      "suggested_scalar": -0.0619,
+      "log_bad": -0.0625,
+      "log_good": -0.0861
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 108.0,
+      "good": 99.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.2283,
+      "log_bad": 4.6821,
+      "log_good": 4.5951
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 63.0129,
+      "good": 51.4393,
+      "ratio": 0.8163,
+      "suggested_scalar": -0.5325,
+      "log_bad": 4.1433,
+      "log_good": 3.9404
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.534,
+      "good": 0.5131,
+      "ratio": 0.9609,
+      "suggested_scalar": -0.1048,
+      "log_bad": -0.6274,
+      "log_good": -0.6673
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 39.8466,
+      "good": 35.9871,
+      "ratio": 0.9031,
+      "suggested_scalar": -0.2673,
+      "log_bad": 3.685,
+      "log_good": 3.5832
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2125.0,
+      "good": 2447.0,
+      "ratio": 1.1515,
+      "suggested_scalar": 0.3702,
+      "log_bad": 7.6615,
+      "log_good": 7.8026
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0926,
+      "good": 0.0893,
+      "ratio": 0.9644,
+      "suggested_scalar": -0.0952,
+      "log_bad": -2.3795,
+      "log_good": -2.4158
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6481,
+      "good": 0.6429,
+      "ratio": 0.992,
+      "suggested_scalar": -0.0211,
+      "log_bad": -0.4337,
+      "log_good": -0.4418
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 5.463,
+      "good": 4.7857,
+      "ratio": 0.876,
+      "suggested_scalar": -0.3474,
+      "log_bad": 1.698,
+      "log_good": 1.5656
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 20.5706,
+      "good": 19.9949,
+      "ratio": 0.972,
+      "suggested_scalar": -0.0745,
+      "log_bad": 3.0239,
+      "log_good": 2.9955
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 30.0,
+      "good": 14.0,
+      "ratio": 0.4667,
+      "suggested_scalar": -2.0,
+      "log_bad": 3.4012,
+      "log_good": 2.6391
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9394,
+      "good": 0.9445,
+      "ratio": 1.0054,
+      "suggested_scalar": 0.0142,
+      "log_bad": -0.0625,
+      "log_good": -0.0571
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 23.0,
+      "good": 22.0,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.1166,
+      "log_bad": 3.1355,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6762,
+      "good": 0.725,
+      "ratio": 1.0722,
+      "suggested_scalar": 0.1829,
+      "log_bad": -0.3913,
+      "log_good": -0.3216
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.314,
+      "good": 0.2744,
+      "ratio": 0.8739,
+      "suggested_scalar": -0.3538,
+      "log_bad": -1.1584,
+      "log_good": -1.2932
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0887,
+      "good": 3.636,
+      "ratio": 1.1772,
+      "suggested_scalar": 0.4281,
+      "log_bad": 1.1278,
+      "log_good": 1.2909
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 293.0,
+      "good": 266.0,
+      "ratio": 0.9078,
+      "suggested_scalar": -0.2537,
+      "log_bad": 5.6802,
+      "log_good": 5.5835
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.8074,
+      "ratio": 0.9956,
+      "suggested_scalar": -0.0115,
+      "log_bad": 1.7635,
+      "log_good": 1.7591
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 45.0,
+      "good": 45.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8067,
+      "log_good": 3.8067
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.8428,
+      "good": 1.7872,
+      "ratio": 0.9698,
+      "suggested_scalar": -0.0804,
+      "log_bad": 0.6113,
+      "log_good": 0.5807
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5219,
+      "good": 5.4727,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.0235,
+      "log_bad": 1.7087,
+      "log_good": 1.6998
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7527,
+      "good": 0.759,
+      "ratio": 1.0084,
+      "suggested_scalar": 0.0219,
+      "log_bad": -0.2841,
+      "log_good": -0.2758
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1692,
+      "good": 0.1642,
+      "ratio": 0.9704,
+      "suggested_scalar": -0.0787,
+      "log_bad": -1.7767,
+      "log_good": -1.8067
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 6.3124,
+      "good": 5.9989,
+      "ratio": 0.9503,
+      "suggested_scalar": -0.1337,
+      "log_bad": 1.8425,
+      "log_good": 1.7916
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 236.0,
+      "good": 225.0,
+      "ratio": 0.9534,
+      "suggested_scalar": -0.1253,
+      "log_bad": 5.4638,
+      "log_good": 5.4161
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6094,
+      "good": 0.5477,
+      "ratio": 0.8988,
+      "suggested_scalar": -0.2801,
+      "log_bad": -0.4953,
+      "log_good": -0.602
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 79.0,
+      "good": 76.0,
+      "ratio": 0.962,
+      "suggested_scalar": -0.1016,
+      "log_bad": 4.3694,
+      "log_good": 4.3307
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1093.0,
+      "good": 1434.0,
+      "ratio": 1.312,
+      "suggested_scalar": 0.7126,
+      "log_bad": 6.9967,
+      "log_good": 7.2682
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 129.0,
+      "good": 120.0,
+      "ratio": 0.9302,
+      "suggested_scalar": -0.1898,
+      "log_bad": 4.8598,
+      "log_good": 4.7875
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2644,
+      "good": 0.291,
+      "ratio": 1.1006,
+      "suggested_scalar": 0.2516,
+      "log_bad": -1.3303,
+      "log_good": -1.2344
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 50.0,
+      "good": 47.0,
+      "ratio": 0.94,
+      "suggested_scalar": -0.1624,
+      "log_bad": 3.912,
+      "log_good": 3.8501
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 79.0,
+      "good": 76.0,
+      "ratio": 0.962,
+      "suggested_scalar": -0.1016,
+      "log_bad": 4.3694,
+      "log_good": 4.3307
+    },
+    "brevity.mean_sample_size": {
+      "bad": 79.0,
+      "good": 76.0,
+      "ratio": 0.962,
+      "suggested_scalar": -0.1016,
+      "log_bad": 4.3694,
+      "log_good": 4.3307
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 295.0,
+      "good": 268.0,
+      "ratio": 0.9085,
+      "suggested_scalar": -0.2519,
+      "log_bad": 5.687,
+      "log_good": 5.591
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 148.0,
+      "good": 130.0,
+      "ratio": 0.8784,
+      "suggested_scalar": -0.3403,
+      "log_bad": 4.9972,
+      "log_good": 4.8675
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 187.0,
+      "good": 177.0,
+      "ratio": 0.9465,
+      "suggested_scalar": -0.1442,
+      "log_bad": 5.2311,
+      "log_good": 5.1761
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.5799,
+      "good": 1.4943,
+      "ratio": 0.9458,
+      "suggested_scalar": -0.1462,
+      "log_bad": 0.4574,
+      "log_good": 0.4017
+    },
+    "halstead.mean_effort": {
+      "bad": 48428.2328,
+      "good": 40167.2318,
+      "ratio": 0.8294,
+      "suggested_scalar": -0.4908,
+      "log_bad": 10.7878,
+      "log_good": 10.6008
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.876,
+      "good": 0.8759,
+      "ratio": 0.9999,
+      "suggested_scalar": -0.0003,
+      "log_bad": -0.1324,
+      "log_good": -0.1325
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 56.0,
+      "good": 54.0,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.0954,
+      "log_bad": 4.0254,
+      "log_good": 3.989
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 161.0,
+      "good": 143.0,
+      "ratio": 0.8882,
+      "suggested_scalar": -0.3111,
+      "log_bad": 5.0814,
+      "log_good": 4.9628
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4444,
+      "good": 0.4646,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.1166,
+      "log_bad": -0.811,
+      "log_good": -0.7666
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 10.1204,
+      "good": 14.4848,
+      "ratio": 1.4312,
+      "suggested_scalar": 0.9409,
+      "log_bad": 2.3146,
+      "log_good": 2.6731
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1692,
+      "good": 0.1642,
+      "ratio": 0.9704,
+      "suggested_scalar": -0.0787,
+      "log_bad": -1.7767,
+      "log_good": -1.8067
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.8748,
+      "good": 6.9143,
+      "ratio": 1.0057,
+      "suggested_scalar": 0.015,
+      "log_bad": 1.9279,
+      "log_good": 1.9336
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 294.0,
+      "good": 267.0,
+      "ratio": 0.9082,
+      "suggested_scalar": -0.2528,
+      "log_bad": 5.6836,
+      "log_good": 5.5872
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 35.0,
+      "good": 32.0,
+      "ratio": 0.9143,
+      "suggested_scalar": -0.2352,
+      "log_bad": 3.5553,
+      "log_good": 3.4657
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2690.4574,
+      "good": 2231.5129,
+      "ratio": 0.8294,
+      "suggested_scalar": -0.4908,
+      "log_bad": 7.8975,
+      "log_good": 7.7104
+    },
+    "readability.mean_total_lines": {
+      "bad": 54.0,
+      "good": 56.0,
+      "ratio": 1.037,
+      "suggested_scalar": 0.0954,
+      "log_bad": 3.989,
+      "log_good": 4.0254
+    },
+    "indentation.mean_max_depth": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "halstead.mean_volume": {
+      "bad": 1828.0964,
+      "good": 1643.2049,
+      "ratio": 0.8989,
+      "suggested_scalar": -0.2798,
+      "log_bad": 7.511,
+      "log_good": 7.4044
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 688.0,
+      "good": 673.0,
+      "ratio": 0.9782,
+      "suggested_scalar": -0.0578,
+      "log_bad": 6.5338,
+      "log_good": 6.5117
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 38.1481,
+      "good": 42.5,
+      "ratio": 1.1141,
+      "suggested_scalar": 0.2835,
+      "log_bad": 3.6415,
+      "log_good": 3.7495
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.6345,
+      "good": 1.7794,
+      "ratio": 1.0887,
+      "suggested_scalar": 0.2229,
+      "log_bad": 0.4913,
+      "log_good": 0.5763
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8517,
+      "good": 0.8578,
+      "ratio": 1.0072,
+      "suggested_scalar": 0.0187,
+      "log_bad": -0.1605,
+      "log_good": -0.1534
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9749,
+      "good": 0.9746,
+      "ratio": 0.9997,
+      "suggested_scalar": -0.0008,
+      "log_bad": -0.0254,
+      "log_good": -0.0257
+    },
+    "halstead.mean_length": {
+      "bad": 290.0,
+      "good": 263.0,
+      "ratio": 0.9069,
+      "suggested_scalar": -0.2565,
+      "log_bad": 5.6699,
+      "log_good": 5.5722
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 12.25,
+      "good": 12.25,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5055,
+      "log_good": 2.5055
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.3038,
+      "good": 6.2479,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.0234,
+      "log_bad": 1.8412,
+      "log_good": 1.8322
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0696,
+      "good": 0.0531,
+      "ratio": 0.7629,
+      "suggested_scalar": -0.7101,
+      "log_bad": -2.665,
+      "log_good": -2.9356
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 26.4911,
+      "good": 24.4444,
+      "ratio": 0.9227,
+      "suggested_scalar": -0.211,
+      "log_bad": 3.2768,
+      "log_good": 3.1964
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 48.0,
+      "good": 46.0,
+      "ratio": 0.9583,
+      "suggested_scalar": -0.1117,
+      "log_bad": 3.8712,
+      "log_good": 3.8286
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7326,
+      "good": 0.7345,
+      "ratio": 1.0026,
+      "suggested_scalar": 0.0068,
+      "log_bad": -0.3112,
+      "log_good": -0.3086
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 54.0,
+      "good": 56.0,
+      "ratio": 1.037,
+      "suggested_scalar": 0.0954,
+      "log_bad": 3.989,
+      "log_good": 4.0254
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 29.0,
+      "good": 39.0,
+      "ratio": 1.3448,
+      "suggested_scalar": 0.7775,
+      "log_bad": 3.3673,
+      "log_good": 3.6636
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.throws_error_objects_not_primitives": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 20.0,
+      "good": 19.0,
+      "ratio": 0.95,
+      "suggested_scalar": -0.112,
+      "log_bad": 2.9957,
+      "log_good": 2.9444
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.023,
+      "good": 0.0231,
+      "ratio": 1.0043,
+      "suggested_scalar": 0.0095,
+      "log_bad": -3.7723,
+      "log_good": -3.7679
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3333,
+      "good": 1.5,
+      "ratio": 1.125,
+      "suggested_scalar": 0.2571,
+      "log_bad": 0.2877,
+      "log_good": 0.4055
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.74,
+      "good": 0.7018,
+      "ratio": 0.9484,
+      "suggested_scalar": -0.1157,
+      "log_bad": -0.3011,
+      "log_good": -0.3541
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0255,
+      "good": 0.0277,
+      "ratio": 1.0863,
+      "suggested_scalar": 0.1806,
+      "log_bad": -3.6691,
+      "log_good": -3.5863
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8168,
+      "good": 4.7926,
+      "ratio": 0.995,
+      "suggested_scalar": -0.011,
+      "log_bad": 1.5721,
+      "log_good": 1.5671
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 75.0,
+      "good": 91.0,
+      "ratio": 1.2133,
+      "suggested_scalar": 0.4221,
+      "log_bad": 4.3175,
+      "log_good": 4.5109
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4612,
+      "good": 0.5336,
+      "ratio": 1.157,
+      "suggested_scalar": 0.3183,
+      "log_bad": -0.7739,
+      "log_good": -0.6281
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6172,
+      "good": 0.6911,
+      "ratio": 1.1197,
+      "suggested_scalar": 0.2468,
+      "log_bad": -0.4826,
+      "log_good": -0.3695
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.48,
+      "good": 2.6667,
+      "ratio": 1.0753,
+      "suggested_scalar": 0.1584,
+      "log_bad": 0.9083,
+      "log_good": 0.9808
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 392.0,
+      "good": 433.0,
+      "ratio": 1.1046,
+      "suggested_scalar": 0.2171,
+      "log_bad": 5.9713,
+      "log_good": 6.0707
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.005,
+      "good": 0.003,
+      "ratio": 0.6,
+      "suggested_scalar": -1.115,
+      "log_bad": -5.2983,
+      "log_good": -5.8091
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0014,
+      "good": 0.0012,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.3365,
+      "log_bad": -6.5713,
+      "log_good": -6.7254
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0556,
+      "good": 1.0191,
+      "ratio": 0.9654,
+      "suggested_scalar": -0.0768,
+      "log_bad": 0.0541,
+      "log_good": 0.0189
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 107.0,
+      "good": 124.0,
+      "ratio": 1.1589,
+      "suggested_scalar": 0.3218,
+      "log_bad": 4.6728,
+      "log_good": 4.8203
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 102.2697,
+      "good": 98.5446,
+      "ratio": 0.9636,
+      "suggested_scalar": -0.081,
+      "log_bad": 4.6276,
+      "log_good": 4.5905
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.624,
+      "good": 0.6019,
+      "ratio": 0.9646,
+      "suggested_scalar": -0.0787,
+      "log_bad": -0.4716,
+      "log_good": -0.5077
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 6.3682,
+      "good": 7.5168,
+      "ratio": 1.1804,
+      "suggested_scalar": 0.3619,
+      "log_bad": 1.8513,
+      "log_good": 2.0171
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1410.0,
+      "good": 1650.0,
+      "ratio": 1.1702,
+      "suggested_scalar": 0.3431,
+      "log_bad": 7.2513,
+      "log_good": 7.4085
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.22,
+      "good": 0.1754,
+      "ratio": 0.7973,
+      "suggested_scalar": -0.4945,
+      "log_bad": -1.5141,
+      "log_good": -1.7407
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.72,
+      "good": 0.6842,
+      "ratio": 0.9503,
+      "suggested_scalar": -0.1113,
+      "log_bad": -0.3285,
+      "log_good": -0.3795
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.84,
+      "good": 7.5965,
+      "ratio": 0.9689,
+      "suggested_scalar": -0.0689,
+      "log_bad": 2.0592,
+      "log_good": 2.0277
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.1696,
+      "good": 2.7135,
+      "ratio": 1.2507,
+      "suggested_scalar": 0.4883,
+      "log_bad": 0.7745,
+      "log_good": 0.9982
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 77.0,
+      "good": 80.0,
+      "ratio": 1.039,
+      "suggested_scalar": 0.0834,
+      "log_bad": 4.3438,
+      "log_good": 4.382
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9307,
+      "good": 0.9452,
+      "ratio": 1.0156,
+      "suggested_scalar": 0.0337,
+      "log_bad": -0.0718,
+      "log_good": -0.0564
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 31.0,
+      "ratio": 1.1071,
+      "suggested_scalar": 0.2222,
+      "log_bad": 3.3322,
+      "log_good": 3.434
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.595,
+      "good": 0.6048,
+      "ratio": 1.0165,
+      "suggested_scalar": 0.0357,
+      "log_bad": -0.5192,
+      "log_good": -0.5029
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4615,
+      "good": 0.4269,
+      "ratio": 0.925,
+      "suggested_scalar": -0.1701,
+      "log_bad": -0.7733,
+      "log_good": -0.8512
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4694,
+      "good": 2.5307,
+      "ratio": 1.0248,
+      "suggested_scalar": 0.0535,
+      "log_bad": 0.904,
+      "log_good": 0.9285
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 390.0,
+      "good": 431.0,
+      "ratio": 1.1051,
+      "suggested_scalar": 0.2182,
+      "log_bad": 5.9661,
+      "log_good": 6.0661
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 27.0,
+      "good": 30.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.23,
+      "log_bad": 3.2958,
+      "log_good": 3.4012
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0281,
+      "good": 0.0139,
+      "ratio": 0.4947,
+      "suggested_scalar": -1.5364,
+      "log_bad": -3.572,
+      "log_good": -4.2759
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0224,
+      "good": 6.0,
+      "ratio": 0.9963,
+      "suggested_scalar": -0.0081,
+      "log_bad": 1.7955,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 10.0,
+      "good": 25.0,
+      "ratio": 2.5,
+      "suggested_scalar": 2.0,
+      "log_bad": 2.3026,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1134,
+      "good": 1.2884,
+      "ratio": 1.1572,
+      "suggested_scalar": 0.3186,
+      "log_bad": 0.1074,
+      "log_good": 0.2534
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5363,
+      "good": 5.6896,
+      "ratio": 1.0277,
+      "suggested_scalar": 0.0596,
+      "log_bad": 1.7113,
+      "log_good": 1.7386
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7998,
+      "good": 0.7988,
+      "ratio": 0.9987,
+      "suggested_scalar": -0.0027,
+      "log_bad": -0.2234,
+      "log_good": -0.2246
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2188,
+      "good": 0.1739,
+      "ratio": 0.7948,
+      "suggested_scalar": -0.5013,
+      "log_bad": -1.5196,
+      "log_good": -1.7493
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.5235,
+      "good": 2.7417,
+      "ratio": 1.0865,
+      "suggested_scalar": 0.181,
+      "log_bad": 0.9256,
+      "log_good": 1.0086
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 278.0,
+      "good": 321.0,
+      "ratio": 1.1547,
+      "suggested_scalar": 0.3139,
+      "log_bad": 5.6276,
+      "log_good": 5.7714
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 18.0,
+      "good": 24.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.6279,
+      "log_bad": 2.8904,
+      "log_good": 3.1781
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6852,
+      "good": 0.7961,
+      "ratio": 1.1619,
+      "suggested_scalar": 0.3274,
+      "log_bad": -0.378,
+      "log_good": -0.228
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 88.0,
+      "good": 100.0,
+      "ratio": 1.1364,
+      "suggested_scalar": 0.279,
+      "log_bad": 4.4773,
+      "log_good": 4.6052
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 634.0,
+      "good": 787.0,
+      "ratio": 1.2413,
+      "suggested_scalar": 0.4719,
+      "log_bad": 6.452,
+      "log_good": 6.6682
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 104.0,
+      "good": 126.0,
+      "ratio": 1.2115,
+      "suggested_scalar": 0.4188,
+      "log_bad": 4.6444,
+      "log_good": 4.8363
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0026,
+      "good": 0.0023,
+      "ratio": 0.8846,
+      "suggested_scalar": -0.2676,
+      "log_bad": -5.9522,
+      "log_good": -6.0748
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.199,
+      "good": 0.2032,
+      "ratio": 1.0211,
+      "suggested_scalar": 0.0456,
+      "log_bad": -1.6145,
+      "log_good": -1.5936
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 72.0,
+      "good": 81.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.2571,
+      "log_bad": 4.2767,
+      "log_good": 4.3944
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.885,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 88.0,
+      "good": 100.0,
+      "ratio": 1.1364,
+      "suggested_scalar": 0.279,
+      "log_bad": 4.4773,
+      "log_good": 4.6052
+    },
+    "brevity.mean_sample_size": {
+      "bad": 88.0,
+      "good": 100.0,
+      "ratio": 1.1364,
+      "suggested_scalar": 0.279,
+      "log_bad": 4.4773,
+      "log_good": 4.6052
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 392.0,
+      "good": 433.0,
+      "ratio": 1.1046,
+      "suggested_scalar": 0.2171,
+      "log_bad": 5.9713,
+      "log_good": 6.0707
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 233.0,
+      "good": 249.0,
+      "ratio": 1.0687,
+      "suggested_scalar": 0.145,
+      "log_bad": 5.451,
+      "log_good": 5.5175
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 219.0,
+      "good": 253.0,
+      "ratio": 1.1553,
+      "suggested_scalar": 0.315,
+      "log_bad": 5.3891,
+      "log_good": 5.5334
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0102,
+      "good": 0.0092,
+      "ratio": 0.902,
+      "suggested_scalar": -0.2252,
+      "log_bad": -4.5854,
+      "log_good": -4.6886
+    },
+    "heaps.mean_k": {
+      "bad": 2.5348,
+      "good": 1.6302,
+      "ratio": 0.6431,
+      "suggested_scalar": -0.9635,
+      "log_bad": 0.9301,
+      "log_good": 0.4887
+    },
+    "halstead.mean_effort": {
+      "bad": 63677.0809,
+      "good": 77741.1386,
+      "ratio": 1.2209,
+      "suggested_scalar": 0.4356,
+      "log_bad": 11.0616,
+      "log_good": 11.2611
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8571,
+      "good": 0.8564,
+      "ratio": 0.9992,
+      "suggested_scalar": -0.0018,
+      "log_bad": -0.1542,
+      "log_good": -0.155
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 47.0,
+      "good": 60.0,
+      "ratio": 1.2766,
+      "suggested_scalar": 0.533,
+      "log_bad": 3.8501,
+      "log_good": 4.0943
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 226.0,
+      "good": 241.0,
+      "ratio": 1.0664,
+      "suggested_scalar": 0.1403,
+      "log_bad": 5.4205,
+      "log_good": 5.4848
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4393,
+      "good": 0.4516,
+      "ratio": 1.028,
+      "suggested_scalar": 0.0603,
+      "log_bad": -0.8226,
+      "log_good": -0.795
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.9252,
+      "good": 6.3468,
+      "ratio": 1.0712,
+      "suggested_scalar": 0.15,
+      "log_bad": 1.7792,
+      "log_good": 1.848
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2188,
+      "good": 0.1739,
+      "ratio": 0.7948,
+      "suggested_scalar": -0.5013,
+      "log_bad": -1.5196,
+      "log_good": -1.7493
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.6521,
+      "good": 3.483,
+      "ratio": 0.9537,
+      "suggested_scalar": -0.1035,
+      "log_bad": 1.2953,
+      "log_good": 1.2479
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 391.0,
+      "good": 432.0,
+      "ratio": 1.1049,
+      "suggested_scalar": 0.2177,
+      "log_bad": 5.9687,
+      "log_good": 6.0684
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 68.0,
+      "good": 74.0,
+      "ratio": 1.0882,
+      "suggested_scalar": 0.1846,
+      "log_bad": 4.2195,
+      "log_good": 4.3041
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3537.6156,
+      "good": 4318.9521,
+      "ratio": 1.2209,
+      "suggested_scalar": 0.4356,
+      "log_bad": 8.1712,
+      "log_good": 8.3708
+    },
+    "readability.mean_total_lines": {
+      "bad": 50.0,
+      "good": 57.0,
+      "ratio": 1.14,
+      "suggested_scalar": 0.286,
+      "log_bad": 3.912,
+      "log_good": 4.0431
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2055.5102,
+      "good": 2388.3606,
+      "ratio": 1.1619,
+      "suggested_scalar": 0.3276,
+      "log_bad": 7.6283,
+      "log_good": 7.7784
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 571.0,
+      "good": 652.0,
+      "ratio": 1.1419,
+      "suggested_scalar": 0.2895,
+      "log_bad": 6.3474,
+      "log_good": 6.48
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 26.92,
+      "good": 27.7368,
+      "ratio": 1.0303,
+      "suggested_scalar": 0.0652,
+      "log_bad": 3.2929,
+      "log_good": 3.3228
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1419,
+      "good": 1.1889,
+      "ratio": 1.0412,
+      "suggested_scalar": 0.088,
+      "log_bad": 0.1327,
+      "log_good": 0.173
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 16.0,
+      "good": 19.0,
+      "ratio": 1.1875,
+      "suggested_scalar": 0.3751,
+      "log_bad": 2.7726,
+      "log_good": 2.9444
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7554,
+      "good": 0.7695,
+      "ratio": 1.0187,
+      "suggested_scalar": 0.0404,
+      "log_bad": -0.2805,
+      "log_good": -0.262
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9752,
+      "good": 0.9778,
+      "ratio": 1.0027,
+      "suggested_scalar": 0.0058,
+      "log_bad": -0.0251,
+      "log_good": -0.0225
+    },
+    "halstead.mean_length": {
+      "bad": 330.0,
+      "good": 367.0,
+      "ratio": 1.1121,
+      "suggested_scalar": 0.232,
+      "log_bad": 5.7991,
+      "log_good": 5.9054
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 21.3333,
+      "good": 26.5,
+      "ratio": 1.2422,
+      "suggested_scalar": 0.4734,
+      "log_bad": 3.0603,
+      "log_good": 3.2771
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4594,
+      "good": 6.6439,
+      "ratio": 1.0286,
+      "suggested_scalar": 0.0615,
+      "log_bad": 1.8655,
+      "log_good": 1.8937
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1652,
+      "good": 0.1509,
+      "ratio": 0.9134,
+      "suggested_scalar": -0.1976,
+      "log_bad": -1.8006,
+      "log_good": -1.8911
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.9787,
+      "good": 32.55,
+      "ratio": 1.0507,
+      "suggested_scalar": 0.108,
+      "log_bad": 3.4333,
+      "log_good": 3.4828
+    },
+    "branching.mean_branch_count": {
+      "bad": 11.0,
+      "good": 10.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.208,
+      "log_bad": 2.3979,
+      "log_good": 2.3026
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 47.0,
+      "good": 56.0,
+      "ratio": 1.1915,
+      "suggested_scalar": 0.3824,
+      "log_bad": 3.8501,
+      "log_good": 4.0254
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6712,
+      "good": 0.6798,
+      "ratio": 1.0128,
+      "suggested_scalar": 0.0278,
+      "log_bad": -0.3987,
+      "log_good": -0.386
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 50.0,
+      "good": 57.0,
+      "ratio": 1.14,
+      "suggested_scalar": 0.286,
+      "log_bad": 3.912,
+      "log_good": 4.0431
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.boolean_assigned_from_comparison": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 5.0,
+      "good": 12.0,
+      "ratio": 2.4,
+      "suggested_scalar": 0.2455,
+      "log_bad": 1.6094,
+      "log_good": 2.4849
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0127,
+      "good": 0.0119,
+      "ratio": 0.937,
+      "suggested_scalar": -0.0182,
+      "log_bad": -4.3662,
+      "log_good": -4.4312
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.6667,
+      "good": 0.92,
+      "ratio": 1.3799,
+      "suggested_scalar": 0.0903,
+      "log_bad": -0.4054,
+      "log_good": -0.0834
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0127,
+      "good": 0.0119,
+      "ratio": 0.937,
+      "suggested_scalar": -0.0182,
+      "log_bad": -4.3662,
+      "log_good": -4.4312
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 3.9013,
+      "good": 4.6119,
+      "ratio": 1.1821,
+      "suggested_scalar": 0.0469,
+      "log_bad": 1.3613,
+      "log_good": 1.5286
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 63.0,
+      "good": 79.0,
+      "ratio": 1.254,
+      "suggested_scalar": 0.0635,
+      "log_bad": 4.1431,
+      "log_good": 4.3694
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5833,
+      "good": 0.5825,
+      "ratio": 0.9986,
+      "suggested_scalar": -0.0004,
+      "log_bad": -0.5391,
+      "log_good": -0.5404
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 17.0,
+      "ratio": 1.1333,
+      "suggested_scalar": 0.0351,
+      "log_bad": 2.7081,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6487,
+      "good": 0.6997,
+      "ratio": 1.0786,
+      "suggested_scalar": 0.0212,
+      "log_bad": -0.4328,
+      "log_good": -0.3571
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.2727,
+      "good": 2.96,
+      "ratio": 0.4719,
+      "suggested_scalar": -0.2106,
+      "log_bad": 1.8362,
+      "log_good": 1.0852
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 237.0,
+      "good": 252.0,
+      "ratio": 1.0633,
+      "suggested_scalar": 0.0172,
+      "log_bad": 5.4681,
+      "log_good": 5.5294
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1944,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 0.0008,
+      "ratio": 0.0008,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -7.1309
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9112,
+      "good": 0.8451,
+      "ratio": 0.9275,
+      "suggested_scalar": -0.0211,
+      "log_bad": -0.093,
+      "log_good": -0.1683
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 72.0,
+      "good": 103.0,
+      "ratio": 1.4306,
+      "suggested_scalar": 0.1004,
+      "log_bad": 4.2767,
+      "log_good": 4.6347
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 108.8066,
+      "good": 88.3945,
+      "ratio": 0.8124,
+      "suggested_scalar": -0.0583,
+      "log_bad": 4.6896,
+      "log_good": 4.4818
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4195,
+      "good": 0.3267,
+      "ratio": 0.7788,
+      "suggested_scalar": -0.0701,
+      "log_bad": -0.8687,
+      "log_good": -1.1187
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.6937,
+      "good": 7.2391,
+      "ratio": 0.9409,
+      "suggested_scalar": -0.0171,
+      "log_bad": 2.0404,
+      "log_good": 1.9795
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1441.0,
+      "good": 1190.0,
+      "ratio": 0.8258,
+      "suggested_scalar": -0.0537,
+      "log_bad": 7.2731,
+      "log_good": 7.0817
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.303,
+      "good": 1.0,
+      "ratio": 3.3003,
+      "suggested_scalar": 0.3349,
+      "log_bad": -1.194,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.5758,
+      "good": 0.88,
+      "ratio": 1.5283,
+      "suggested_scalar": 0.119,
+      "log_bad": -0.552,
+      "log_good": -0.1278
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 3.5909,
+      "good": 10.08,
+      "ratio": 2.8071,
+      "suggested_scalar": 0.2895,
+      "log_bad": 1.2784,
+      "log_good": 2.3106
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.1944,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 6.5317,
+      "good": 1.6384,
+      "ratio": 0.2508,
+      "suggested_scalar": -0.3879,
+      "log_bad": 1.8767,
+      "log_good": 0.4937
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 66.0,
+      "good": 97.0,
+      "ratio": 1.4697,
+      "suggested_scalar": 0.108,
+      "log_bad": 4.1897,
+      "log_good": 4.5747
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9133,
+      "good": 0.9532,
+      "ratio": 1.0437,
+      "suggested_scalar": 0.012,
+      "log_bad": -0.0907,
+      "log_good": -0.0479
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 22.0,
+      "ratio": 0.88,
+      "suggested_scalar": -0.0359,
+      "log_bad": 3.2189,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6766,
+      "good": 0.5563,
+      "ratio": 0.8222,
+      "suggested_scalar": -0.0549,
+      "log_bad": -0.3907,
+      "log_good": -0.5864
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2511,
+      "good": 0.132,
+      "ratio": 0.5257,
+      "suggested_scalar": -0.1804,
+      "log_bad": -1.3819,
+      "log_good": -2.025
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0923,
+      "good": 2.2538,
+      "ratio": 0.7288,
+      "suggested_scalar": -0.0887,
+      "log_bad": 1.1289,
+      "log_good": 0.8126
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 235.0,
+      "good": 250.0,
+      "ratio": 1.0638,
+      "suggested_scalar": 0.0174,
+      "log_bad": 5.4596,
+      "log_good": 5.5215
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 40.0,
+      "good": 9.0,
+      "ratio": 0.225,
+      "suggested_scalar": -0.4184,
+      "log_bad": 3.6889,
+      "log_good": 2.1972
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0422,
+      "good": 0.0476,
+      "ratio": 1.128,
+      "suggested_scalar": 0.0338,
+      "log_bad": -3.1653,
+      "log_good": -3.0449
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.585,
+      "good": 5.7549,
+      "ratio": 1.0304,
+      "suggested_scalar": 0.0084,
+      "log_bad": 1.7201,
+      "log_good": 1.7501
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 4.0,
+      "good": 6.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1137,
+      "log_bad": 1.3863,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.4903,
+      "good": 0.3205,
+      "ratio": 0.6537,
+      "suggested_scalar": -0.1192,
+      "log_bad": -0.7127,
+      "log_good": -1.1379
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.507,
+      "good": 5.6946,
+      "ratio": 1.0341,
+      "suggested_scalar": 0.0094,
+      "log_bad": 1.706,
+      "log_good": 1.7395
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.6985,
+      "good": 0.8014,
+      "ratio": 1.1473,
+      "suggested_scalar": 0.0385,
+      "log_bad": -0.3588,
+      "log_good": -0.2214
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1316,
+      "good": 0.1935,
+      "ratio": 1.4704,
+      "suggested_scalar": 0.1081,
+      "log_bad": -2.028,
+      "log_good": -1.6425
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.7737,
+      "good": 2.6906,
+      "ratio": 0.97,
+      "suggested_scalar": -0.0085,
+      "log_bad": 1.0202,
+      "log_good": 0.9898
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1944,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 197.0,
+      "good": 230.0,
+      "ratio": 1.1675,
+      "suggested_scalar": 0.0434,
+      "log_bad": 5.2832,
+      "log_good": 5.4381
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.4164,
+      "good": 0.4917,
+      "ratio": 1.1808,
+      "suggested_scalar": 0.0466,
+      "log_bad": -0.8761,
+      "log_good": -0.7099
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 74.0,
+      "good": 87.0,
+      "ratio": 1.1757,
+      "suggested_scalar": 0.0454,
+      "log_bad": 4.3041,
+      "log_good": 4.4659
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 506.0,
+      "good": 776.0,
+      "ratio": 1.5336,
+      "suggested_scalar": 0.1199,
+      "log_bad": 6.2265,
+      "log_good": 6.6542
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 88.0,
+      "good": 103.0,
+      "ratio": 1.1705,
+      "suggested_scalar": 0.0441,
+      "log_bad": 4.4773,
+      "log_good": 4.6347
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0338,
+      "good": 1.0,
+      "ratio": 29.5858,
+      "suggested_scalar": 0.95,
+      "log_bad": -3.3873,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1561,
+      "good": 0.254,
+      "ratio": 1.6272,
+      "suggested_scalar": 0.1365,
+      "log_bad": -1.8573,
+      "log_good": -1.3704
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 29.0,
+      "good": 27.0,
+      "ratio": 0.931,
+      "suggested_scalar": -0.02,
+      "log_bad": 3.3673,
+      "log_good": 3.2958
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1137,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 74.0,
+      "good": 87.0,
+      "ratio": 1.1757,
+      "suggested_scalar": 0.0454,
+      "log_bad": 4.3041,
+      "log_good": 4.4659
+    },
+    "brevity.mean_sample_size": {
+      "bad": 74.0,
+      "good": 87.0,
+      "ratio": 1.1757,
+      "suggested_scalar": 0.0454,
+      "log_bad": 4.3041,
+      "log_good": 4.4659
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 237.0,
+      "good": 252.0,
+      "ratio": 1.0633,
+      "suggested_scalar": 0.0172,
+      "log_bad": 5.4681,
+      "log_good": 5.5294
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 87.0,
+      "good": 118.0,
+      "ratio": 1.3563,
+      "suggested_scalar": 0.0855,
+      "log_bad": 4.4659,
+      "log_good": 4.7707
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 166.0,
+      "good": 196.0,
+      "ratio": 1.1807,
+      "suggested_scalar": 0.0466,
+      "log_bad": 5.112,
+      "log_good": 5.2781
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0042,
+      "good": 0.0079,
+      "ratio": 1.881,
+      "suggested_scalar": 0.1772,
+      "log_bad": -5.4727,
+      "log_good": -4.8409
+    },
+    "heaps.mean_k": {
+      "bad": 2.3469,
+      "good": 1.942,
+      "ratio": 0.8275,
+      "suggested_scalar": -0.0531,
+      "log_bad": 0.8531,
+      "log_good": 0.6637
+    },
+    "halstead.mean_effort": {
+      "bad": 36162.5435,
+      "good": 29320.5431,
+      "ratio": 0.8108,
+      "suggested_scalar": -0.0588,
+      "log_bad": 10.4958,
+      "log_good": 10.286
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8869,
+      "good": 0.8839,
+      "ratio": 0.9966,
+      "suggested_scalar": -0.001,
+      "log_bad": -0.12,
+      "log_good": -0.1234
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 38.0,
+      "good": 57.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1137,
+      "log_bad": 3.6376,
+      "log_good": 4.0431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 121.0,
+      "good": 131.0,
+      "ratio": 1.0826,
+      "suggested_scalar": 0.0223,
+      "log_bad": 4.7958,
+      "log_good": 4.8752
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5833,
+      "good": 0.5728,
+      "ratio": 0.982,
+      "suggested_scalar": -0.0051,
+      "log_bad": -0.5391,
+      "log_good": -0.5572
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.0278,
+      "good": 7.534,
+      "ratio": 1.072,
+      "suggested_scalar": 0.0195,
+      "log_bad": 1.9499,
+      "log_good": 2.0194
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1316,
+      "good": 0.1935,
+      "ratio": 1.4704,
+      "suggested_scalar": 0.1081,
+      "log_bad": -2.028,
+      "log_good": -1.6425
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 1.4364,
+      "good": 4.032,
+      "ratio": 2.807,
+      "suggested_scalar": 0.2895,
+      "log_bad": 0.3621,
+      "log_good": 1.3943
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 236.0,
+      "good": 251.0,
+      "ratio": 1.0636,
+      "suggested_scalar": 0.0173,
+      "log_bad": 5.4638,
+      "log_good": 5.5255
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1137,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 21.0,
+      "good": 13.0,
+      "ratio": 0.619,
+      "suggested_scalar": -0.1345,
+      "log_bad": 3.0445,
+      "log_good": 2.5649
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2009.0302,
+      "good": 1628.9191,
+      "ratio": 0.8108,
+      "suggested_scalar": -0.0588,
+      "log_bad": 7.6054,
+      "log_good": 7.3957
+    },
+    "readability.mean_total_lines": {
+      "bad": 66.0,
+      "good": 25.0,
+      "ratio": 0.3788,
+      "suggested_scalar": -0.2723,
+      "log_bad": 4.1897,
+      "log_good": 3.2189
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 4.0,
+      "ratio": 0.4,
+      "suggested_scalar": -0.257,
+      "log_bad": 2.3026,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1249.2515,
+      "good": 1475.0847,
+      "ratio": 1.1808,
+      "suggested_scalar": 0.0466,
+      "log_bad": 7.1303,
+      "log_good": 7.2965
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 466.0,
+      "good": 528.0,
+      "ratio": 1.133,
+      "suggested_scalar": 0.035,
+      "log_bad": 6.1442,
+      "log_good": 6.2691
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 20.6515,
+      "good": 46.28,
+      "ratio": 2.241,
+      "suggested_scalar": 0.2263,
+      "log_bad": 3.0278,
+      "log_good": 3.8347
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1156,
+      "good": 1.2791,
+      "ratio": 1.1466,
+      "suggested_scalar": 0.0384,
+      "log_bad": 0.1094,
+      "log_good": 0.2462
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1944,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 12.0,
+      "good": 21.0,
+      "ratio": 1.75,
+      "suggested_scalar": 0.157,
+      "log_bad": 2.4849,
+      "log_good": 3.0445
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8934,
+      "good": 0.9435,
+      "ratio": 1.0561,
+      "suggested_scalar": 0.0153,
+      "log_bad": -0.1127,
+      "log_good": -0.0582
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9737,
+      "good": 0.9897,
+      "ratio": 1.0164,
+      "suggested_scalar": 0.0046,
+      "log_bad": -0.0267,
+      "log_good": -0.0104
+    },
+    "halstead.mean_length": {
+      "bad": 209.0,
+      "good": 234.0,
+      "ratio": 1.1196,
+      "suggested_scalar": 0.0317,
+      "log_bad": 5.3423,
+      "log_good": 5.4553
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 35.5,
+      "good": 8.6667,
+      "ratio": 0.2441,
+      "suggested_scalar": -0.3955,
+      "log_bad": 3.5695,
+      "log_good": 2.1595
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2095,
+      "good": 6.4429,
+      "ratio": 1.0376,
+      "suggested_scalar": 0.0103,
+      "log_bad": 1.8261,
+      "log_good": 1.863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0605,
+      "good": 0.0993,
+      "ratio": 1.6413,
+      "suggested_scalar": 0.139,
+      "log_bad": -2.8051,
+      "log_good": -2.3096
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 28.9474,
+      "good": 19.8772,
+      "ratio": 0.6867,
+      "suggested_scalar": -0.1054,
+      "log_bad": 3.3655,
+      "log_good": 2.9896
+    },
+    "branching.mean_branch_count": {
+      "bad": 20.0,
+      "good": 1.0,
+      "ratio": 0.05,
+      "suggested_scalar": -0.8402,
+      "log_bad": 2.9957,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 42.0,
+      "good": 59.0,
+      "ratio": 1.4048,
+      "suggested_scalar": 0.0953,
+      "log_bad": 3.7377,
+      "log_good": 4.0775
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8253,
+      "good": 0.8622,
+      "ratio": 1.0447,
+      "suggested_scalar": 0.0123,
+      "log_bad": -0.192,
+      "log_good": -0.1483
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 66.0,
+      "good": 25.0,
+      "ratio": 0.3788,
+      "suggested_scalar": -0.2723,
+      "log_bad": 4.1897,
+      "log_good": 3.2189
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 13.0,
+      "good": 14.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0208,
+      "log_bad": 2.5649,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "variable_naming.collection_name_is_plural": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 36.0,
+      "good": 38.0,
+      "ratio": 1.0556,
+      "suggested_scalar": 0.6209,
+      "log_bad": 3.5835,
+      "log_good": 3.6376
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 19.6667,
+      "good": 19.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9789,
+      "log_good": 2.9789
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.9697,
+      "good": 0.9697,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.0308,
+      "log_good": -0.0308
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7972,
+      "good": 0.7965,
+      "ratio": 0.9991,
+      "suggested_scalar": -0.0101,
+      "log_bad": -0.2266,
+      "log_good": -0.2275
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0006,
+      "good": 0.0006,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.4186,
+      "log_good": -7.4186
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6197,
+      "good": 4.6231,
+      "ratio": 1.0007,
+      "suggested_scalar": 0.0084,
+      "log_bad": 1.5303,
+      "log_good": 1.5311
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 80.0,
+      "good": 75.3333,
+      "ratio": 0.9417,
+      "suggested_scalar": -0.6902,
+      "log_bad": 4.382,
+      "log_good": 4.3219
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.377,
+      "good": 0.3493,
+      "ratio": 0.9265,
+      "suggested_scalar": -0.8764,
+      "log_bad": -0.9755,
+      "log_good": -1.0518
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5269,
+      "good": 0.5282,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0283,
+      "log_bad": -0.6407,
+      "log_good": -0.6383
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.6978,
+      "good": 3.6978,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3077,
+      "log_good": 1.3077
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 476.0,
+      "good": 474.0,
+      "ratio": 0.9958,
+      "suggested_scalar": -0.0484,
+      "log_bad": 6.1654,
+      "log_good": 6.1612
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0003,
+      "good": 0.0003,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -8.1117,
+      "log_good": -8.1117
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0016,
+      "good": 0.0015,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.7411,
+      "log_bad": -6.4378,
+      "log_good": -6.5023
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1263,
+      "good": 1.1468,
+      "ratio": 1.0182,
+      "suggested_scalar": 0.2071,
+      "log_bad": 0.1189,
+      "log_good": 0.137
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 164.3333,
+      "good": 163.3333,
+      "ratio": 0.9939,
+      "suggested_scalar": -0.0701,
+      "log_bad": 5.1019,
+      "log_good": 5.0958
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 98.014,
+      "good": 96.5546,
+      "ratio": 0.9851,
+      "suggested_scalar": -0.1723,
+      "log_bad": 4.5851,
+      "log_good": 4.5701
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6919,
+      "good": 0.7038,
+      "ratio": 1.0172,
+      "suggested_scalar": 0.1958,
+      "log_bad": -0.3683,
+      "log_good": -0.3513
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.276,
+      "good": 11.4865,
+      "ratio": 0.8652,
+      "suggested_scalar": -1.6626,
+      "log_bad": 2.586,
+      "log_good": 2.4412
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1876.6667,
+      "good": 2063.6667,
+      "ratio": 1.0996,
+      "suggested_scalar": 1.0908,
+      "log_bad": 7.5373,
+      "log_good": 7.6322
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0467,
+      "good": 0.0467,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.064,
+      "log_good": -3.064
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7739,
+      "good": 0.7732,
+      "ratio": 0.9991,
+      "suggested_scalar": -0.0104,
+      "log_bad": -0.2563,
+      "log_good": -0.2572
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.1808,
+      "good": 8.1485,
+      "ratio": 0.9961,
+      "suggested_scalar": -0.0454,
+      "log_bad": 2.1018,
+      "log_good": 2.0978
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.0288,
+      "good": 3.0288,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.1082,
+      "log_good": 1.1082
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 142.6667,
+      "good": 141.0,
+      "ratio": 0.9883,
+      "suggested_scalar": -0.1349,
+      "log_bad": 4.9605,
+      "log_good": 4.9488
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9323,
+      "good": 0.9224,
+      "ratio": 0.9894,
+      "suggested_scalar": -0.1226,
+      "log_bad": -0.0701,
+      "log_good": -0.0808
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.6667,
+      "good": 24.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2055,
+      "log_good": 3.2055
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6767,
+      "good": 0.702,
+      "ratio": 1.0374,
+      "suggested_scalar": 0.4215,
+      "log_bad": -0.3905,
+      "log_good": -0.3538
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5021,
+      "good": 0.5036,
+      "ratio": 1.003,
+      "suggested_scalar": 0.0343,
+      "log_bad": -0.689,
+      "log_good": -0.686
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0928,
+      "good": 3.3577,
+      "ratio": 1.0857,
+      "suggested_scalar": 0.9437,
+      "log_bad": 1.1291,
+      "log_good": 1.2113
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 474.0,
+      "good": 472.0,
+      "ratio": 0.9958,
+      "suggested_scalar": -0.0486,
+      "log_bad": 6.1612,
+      "log_good": 6.157
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 7.3333,
+      "good": 7.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9924,
+      "log_good": 1.9924
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0206,
+      "good": 0.0188,
+      "ratio": 0.9126,
+      "suggested_scalar": -1.05,
+      "log_bad": -3.8825,
+      "log_good": -3.9739
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.6834,
+      "good": 5.6834,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7375,
+      "log_good": 1.7375
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 9.6667,
+      "good": 9.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.2687,
+      "log_good": 2.2687
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.5117,
+      "good": 0.5217,
+      "ratio": 1.0195,
+      "suggested_scalar": 0.2223,
+      "log_bad": -0.67,
+      "log_good": -0.6507
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.3298,
+      "good": 5.2675,
+      "ratio": 0.9883,
+      "suggested_scalar": -0.135,
+      "log_bad": 1.6733,
+      "log_good": 1.6616
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8132,
+      "good": 0.8138,
+      "ratio": 1.0007,
+      "suggested_scalar": 0.0085,
+      "log_bad": -0.2068,
+      "log_good": -0.206
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1515,
+      "good": 0.1515,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.8872,
+      "log_good": -1.8872
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6358,
+      "good": 3.3866,
+      "ratio": 0.9315,
+      "suggested_scalar": -0.8154,
+      "log_bad": 1.2908,
+      "log_good": 1.2198
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 322.3333,
+      "good": 321.0,
+      "ratio": 0.9959,
+      "suggested_scalar": -0.0476,
+      "log_bad": 5.7756,
+      "log_good": 5.7714
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 13.3333,
+      "good": 13.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5903,
+      "log_good": 2.5903
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9791,
+      "good": 0.9618,
+      "ratio": 0.9823,
+      "suggested_scalar": -0.2047,
+      "log_bad": -0.0211,
+      "log_good": -0.0389
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 79.0,
+      "good": 74.3333,
+      "ratio": 0.9409,
+      "suggested_scalar": -0.6992,
+      "log_bad": 4.3694,
+      "log_good": 4.3086
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1034.6667,
+      "good": 1223.6667,
+      "ratio": 1.1827,
+      "suggested_scalar": 1.9266,
+      "log_bad": 6.9418,
+      "log_good": 7.1096
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 173.0,
+      "good": 172.0,
+      "ratio": 0.9942,
+      "suggested_scalar": -0.0666,
+      "log_bad": 5.1533,
+      "log_good": 5.1475
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0124,
+      "good": 0.0125,
+      "ratio": 1.0081,
+      "suggested_scalar": 0.0922,
+      "log_bad": -4.3901,
+      "log_good": -4.382
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2908,
+      "good": 0.2899,
+      "ratio": 0.9969,
+      "suggested_scalar": -0.0356,
+      "log_bad": -1.2351,
+      "log_good": -1.2382
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 94.0,
+      "good": 94.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.5433,
+      "log_good": 4.5433
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.3333,
+      "good": 7.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9924,
+      "log_good": 1.9924
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 79.0,
+      "good": 74.3333,
+      "ratio": 0.9409,
+      "suggested_scalar": -0.6992,
+      "log_bad": 4.3694,
+      "log_good": 4.3086
+    },
+    "brevity.mean_sample_size": {
+      "bad": 79.0,
+      "good": 74.3333,
+      "ratio": 0.9409,
+      "suggested_scalar": -0.6992,
+      "log_bad": 4.3694,
+      "log_good": 4.3086
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 476.0,
+      "good": 474.0,
+      "ratio": 0.9958,
+      "suggested_scalar": -0.0484,
+      "log_bad": 6.1654,
+      "log_good": 6.1612
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 268.0,
+      "good": 267.0,
+      "ratio": 0.9963,
+      "suggested_scalar": -0.0429,
+      "log_bad": 5.591,
+      "log_good": 5.5872
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 238.6667,
+      "good": 233.6667,
+      "ratio": 0.9791,
+      "suggested_scalar": -0.2431,
+      "log_bad": 5.4751,
+      "log_good": 5.4539
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0021,
+      "good": 0.0021,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.1658,
+      "log_good": -6.1658
+    },
+    "heaps.mean_k": {
+      "bad": 3.1744,
+      "good": 2.922,
+      "ratio": 0.9205,
+      "suggested_scalar": -0.9514,
+      "log_bad": 1.1551,
+      "log_good": 1.0723
+    },
+    "halstead.mean_effort": {
+      "bad": 115406.7384,
+      "good": 122493.9053,
+      "ratio": 1.0614,
+      "suggested_scalar": 0.6844,
+      "log_bad": 11.6562,
+      "log_good": 11.7158
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8457,
+      "good": 0.8478,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0285,
+      "log_bad": -0.1676,
+      "log_good": -0.1651
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 55.3333,
+      "good": 50.6667,
+      "ratio": 0.9157,
+      "suggested_scalar": -1.0118,
+      "log_bad": 4.0134,
+      "log_good": 3.9253
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 291.3333,
+      "good": 290.3333,
+      "ratio": 0.9966,
+      "suggested_scalar": -0.0395,
+      "log_bad": 5.6745,
+      "log_good": 5.671
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3214,
+      "good": 0.2941,
+      "ratio": 0.9151,
+      "suggested_scalar": -1.0193,
+      "log_bad": -1.1351,
+      "log_good": -1.2238
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.3096,
+      "good": 7.51,
+      "ratio": 1.1902,
+      "suggested_scalar": 2.0,
+      "log_bad": 1.8421,
+      "log_good": 2.0162
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1515,
+      "good": 0.1515,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.8872,
+      "log_good": -1.8872
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.9997,
+      "good": 4.385,
+      "ratio": 1.0963,
+      "suggested_scalar": 1.0561,
+      "log_bad": 1.3862,
+      "log_good": 1.4782
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 475.0,
+      "good": 473.0,
+      "ratio": 0.9958,
+      "suggested_scalar": -0.0485,
+      "log_bad": 6.1633,
+      "log_good": 6.1591
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.6667,
+      "good": 2.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9808,
+      "log_good": 0.9808
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 87.6667,
+      "good": 86.0,
+      "ratio": 0.981,
+      "suggested_scalar": -0.2204,
+      "log_bad": 4.4735,
+      "log_good": 4.4543
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6411.4855,
+      "good": 6805.217,
+      "ratio": 1.0614,
+      "suggested_scalar": 0.6844,
+      "log_bad": 8.7658,
+      "log_good": 8.8254
+    },
+    "readability.mean_total_lines": {
+      "bad": 58.0,
+      "good": 58.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0604,
+      "log_good": 4.0604
+    },
+    "indentation.mean_max_depth": {
+      "bad": 7.3333,
+      "good": 7.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9924,
+      "log_good": 1.9924
+    },
+    "halstead.mean_volume": {
+      "bad": 2937.437,
+      "good": 2885.484,
+      "ratio": 0.9823,
+      "suggested_scalar": -0.2049,
+      "log_bad": 7.9853,
+      "log_good": 7.9674
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 607.0,
+      "good": 615.6667,
+      "ratio": 1.0143,
+      "suggested_scalar": 0.1628,
+      "log_bad": 6.4085,
+      "log_good": 6.4227
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.1597,
+      "good": 34.4021,
+      "ratio": 1.1041,
+      "suggested_scalar": 1.1368,
+      "log_bad": 3.4391,
+      "log_good": 3.5381
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1882,
+      "good": 1.2058,
+      "ratio": 1.0148,
+      "suggested_scalar": 0.1688,
+      "log_bad": 0.1724,
+      "log_good": 0.1871
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 37.0,
+      "good": 37.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.6109,
+      "log_good": 3.6109
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7285,
+      "good": 0.7297,
+      "ratio": 1.0016,
+      "suggested_scalar": 0.0189,
+      "log_bad": -0.3168,
+      "log_good": -0.3151
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.987,
+      "good": 0.99,
+      "ratio": 1.003,
+      "suggested_scalar": 0.0349,
+      "log_bad": -0.0131,
+      "log_good": -0.0101
+    },
+    "halstead.mean_length": {
+      "bad": 464.3333,
+      "good": 462.3333,
+      "ratio": 0.9957,
+      "suggested_scalar": -0.0496,
+      "log_bad": 6.1406,
+      "log_good": 6.1363
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 3.9697,
+      "good": 3.9697,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3787,
+      "log_good": 1.3787
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.3028,
+      "good": 6.214,
+      "ratio": 0.9859,
+      "suggested_scalar": -0.1629,
+      "log_bad": 1.841,
+      "log_good": 1.8268
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1419,
+      "good": 0.1286,
+      "ratio": 0.9063,
+      "suggested_scalar": -1.1302,
+      "log_bad": -1.9526,
+      "log_good": -2.051
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 38.6954,
+      "good": 41.9592,
+      "ratio": 1.0843,
+      "suggested_scalar": 0.9299,
+      "log_bad": 3.6557,
+      "log_good": 3.7367
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.6667,
+      "good": 2.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.9808,
+      "log_good": 0.9808
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 52.6667,
+      "good": 48.0,
+      "ratio": 0.9114,
+      "suggested_scalar": -1.0655,
+      "log_bad": 3.964,
+      "log_good": 3.8712
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6073,
+      "good": 0.5977,
+      "ratio": 0.9842,
+      "suggested_scalar": -0.183,
+      "log_bad": -0.4987,
+      "log_good": -0.5147
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 58.0,
+      "good": 58.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0604,
+      "log_good": 4.0604
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.3333,
+      "good": 17.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8526,
+      "log_good": 2.8526
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.uses_result_for_recoverable_errors": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 7.0,
+      "ratio": 2.3333,
+      "suggested_scalar": 0.2769,
+      "log_bad": 1.0986,
+      "log_good": 1.9459
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2265,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0186,
+      "good": 0.0203,
+      "ratio": 1.0914,
+      "suggested_scalar": 0.0286,
+      "log_bad": -3.9846,
+      "log_good": -3.8971
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.3333,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.094,
+      "log_bad": 0.0,
+      "log_good": 0.2877
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8571,
+      "good": 0.8333,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.0092,
+      "log_bad": -0.1542,
+      "log_good": -0.1824
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0279,
+      "good": 0.0203,
+      "ratio": 0.7276,
+      "suggested_scalar": -0.1039,
+      "log_bad": -3.5791,
+      "log_good": -3.8971
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.361,
+      "good": 4.522,
+      "ratio": 1.0369,
+      "suggested_scalar": 0.0118,
+      "log_bad": 1.4727,
+      "log_good": 1.509
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 92.0,
+      "good": 77.0,
+      "ratio": 0.837,
+      "suggested_scalar": -0.0582,
+      "log_bad": 4.5218,
+      "log_good": 4.3438
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.51,
+      "good": 0.4478,
+      "ratio": 0.878,
+      "suggested_scalar": -0.0425,
+      "log_bad": -0.6733,
+      "log_good": -0.8034
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 22.0,
+      "good": 21.0,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.0152,
+      "log_bad": 3.091,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7034,
+      "good": 0.6163,
+      "ratio": 0.8762,
+      "suggested_scalar": -0.0432,
+      "log_bad": -0.3518,
+      "log_good": -0.484
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 7.3333,
+      "good": 7.5152,
+      "ratio": 1.0248,
+      "suggested_scalar": 0.008,
+      "log_bad": 1.9924,
+      "log_good": 2.0169
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 323.0,
+      "good": 543.0,
+      "ratio": 1.6811,
+      "suggested_scalar": 0.1698,
+      "log_bad": 5.7777,
+      "log_good": 6.2971
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 7.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.11,
+      "log_bad": 1.6094,
+      "log_good": 1.9459
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.003,
+      "good": 0.0013,
+      "ratio": 0.4333,
+      "suggested_scalar": -0.2733,
+      "log_bad": -5.8091,
+      "log_good": -6.6454
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0714,
+      "good": 0.0152,
+      "ratio": 0.2129,
+      "suggested_scalar": -0.5056,
+      "log_bad": -2.6395,
+      "log_good": -4.1865
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 0.0022,
+      "ratio": 0.0022,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.1193
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9541,
+      "good": 1.1089,
+      "ratio": 1.1622,
+      "suggested_scalar": 0.0491,
+      "log_bad": -0.047,
+      "log_good": 0.1034
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 104.0,
+      "good": 158.0,
+      "ratio": 1.5192,
+      "suggested_scalar": 0.1367,
+      "log_bad": 4.6444,
+      "log_good": 5.0626
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 108.8715,
+      "good": 92.095,
+      "ratio": 0.8459,
+      "suggested_scalar": -0.0547,
+      "log_bad": 4.6902,
+      "log_good": 4.5228
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5062,
+      "good": 0.6439,
+      "ratio": 1.272,
+      "suggested_scalar": 0.0786,
+      "log_bad": -0.6808,
+      "log_good": -0.4402
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.3842,
+      "good": 14.2368,
+      "ratio": 1.6981,
+      "suggested_scalar": 0.1731,
+      "log_bad": 2.1263,
+      "log_good": 2.6558
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1353.0,
+      "good": 2228.0,
+      "ratio": 1.6467,
+      "suggested_scalar": 0.163,
+      "log_bad": 7.2101,
+      "log_good": 7.7089
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1667,
+      "good": 0.1061,
+      "ratio": 0.6365,
+      "suggested_scalar": -0.1477,
+      "log_bad": -1.7916,
+      "log_good": -2.2434
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7857,
+      "good": 0.7727,
+      "ratio": 0.9835,
+      "suggested_scalar": -0.0055,
+      "log_bad": -0.2412,
+      "log_good": -0.2579
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.6905,
+      "good": 8.3538,
+      "ratio": 1.0862,
+      "suggested_scalar": 0.027,
+      "log_bad": 2.04,
+      "log_good": 2.1227
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.167,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 18.2222,
+      "good": 31.7649,
+      "ratio": 1.7432,
+      "suggested_scalar": 0.1816,
+      "log_bad": 2.9026,
+      "log_good": 3.4584
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 92.0,
+      "good": 109.0,
+      "ratio": 1.1848,
+      "suggested_scalar": 0.0554,
+      "log_bad": 4.5218,
+      "log_good": 4.6913
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9295,
+      "good": 0.9469,
+      "ratio": 1.0187,
+      "suggested_scalar": 0.0061,
+      "log_bad": -0.0731,
+      "log_good": -0.0546
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 28.0,
+      "ratio": 0.9655,
+      "suggested_scalar": -0.0115,
+      "log_bad": 3.3673,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5868,
+      "good": 0.6504,
+      "ratio": 1.1084,
+      "suggested_scalar": 0.0336,
+      "log_bad": -0.5331,
+      "log_good": -0.4302
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2804,
+      "good": 0.3845,
+      "ratio": 1.3713,
+      "suggested_scalar": 0.1032,
+      "log_bad": -1.2715,
+      "log_good": -0.9558
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4204,
+      "good": 2.8601,
+      "ratio": 1.1817,
+      "suggested_scalar": 0.0546,
+      "log_bad": 0.8839,
+      "log_good": 1.0509
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 321.0,
+      "good": 541.0,
+      "ratio": 1.6854,
+      "suggested_scalar": 0.1706,
+      "log_bad": 5.7714,
+      "log_good": 6.2934
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 44.0,
+      "good": 40.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0312,
+      "log_bad": 3.7842,
+      "log_good": 3.6889
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0341,
+      "good": 0.0608,
+      "ratio": 1.783,
+      "suggested_scalar": 0.189,
+      "log_bad": -3.3785,
+      "log_good": -2.8002
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 6.0444,
+      "ratio": 1.0192,
+      "suggested_scalar": 0.0062,
+      "log_bad": 1.7801,
+      "log_good": 1.7991
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 9.0,
+      "good": 44.0,
+      "ratio": 4.8889,
+      "suggested_scalar": 0.5187,
+      "log_bad": 2.1972,
+      "log_good": 3.7842
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6096,
+      "good": 1.0408,
+      "ratio": 1.7073,
+      "suggested_scalar": 0.1748,
+      "log_bad": -0.495,
+      "log_good": 0.04
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7324,
+      "good": 5.5723,
+      "ratio": 0.9721,
+      "suggested_scalar": -0.0093,
+      "log_bad": 1.7461,
+      "log_good": 1.7178
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7353,
+      "good": 0.7481,
+      "ratio": 1.0174,
+      "suggested_scalar": 0.0056,
+      "log_bad": -0.3075,
+      "log_good": -0.2902
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.16,
+      "good": 0.1081,
+      "ratio": 0.6756,
+      "suggested_scalar": -0.1282,
+      "log_bad": -1.8326,
+      "log_good": -2.2247
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.8956,
+      "good": 3.7732,
+      "ratio": 1.3031,
+      "suggested_scalar": 0.0865,
+      "log_bad": 1.0632,
+      "log_good": 1.3279
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2265,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 268.0,
+      "good": 406.0,
+      "ratio": 1.5149,
+      "suggested_scalar": 0.1358,
+      "log_bad": 5.591,
+      "log_good": 6.0064
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 17.0,
+      "good": 28.0,
+      "ratio": 1.6471,
+      "suggested_scalar": 0.1631,
+      "log_bad": 2.8332,
+      "log_good": 3.3322
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6328,
+      "good": 0.8711,
+      "ratio": 1.3766,
+      "suggested_scalar": 0.1045,
+      "log_bad": -0.4576,
+      "log_good": -0.138
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 90.0,
+      "good": 100.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0344,
+      "log_bad": 4.4998,
+      "log_good": 4.6052
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 570.0,
+      "good": 996.0,
+      "ratio": 1.7474,
+      "suggested_scalar": 0.1824,
+      "log_bad": 6.3456,
+      "log_good": 6.9037
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 118.0,
+      "good": 99.0,
+      "ratio": 0.839,
+      "suggested_scalar": -0.0574,
+      "log_bad": 4.7707,
+      "log_good": 4.5951
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0155,
+      "good": 0.0184,
+      "ratio": 1.1871,
+      "suggested_scalar": 0.0561,
+      "log_bad": -4.1669,
+      "log_good": -3.9954
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1796,
+      "good": 0.2468,
+      "ratio": 1.3742,
+      "suggested_scalar": 0.1039,
+      "log_bad": -1.717,
+      "log_good": -1.3992
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 59.0,
+      "good": 101.0,
+      "ratio": 1.7119,
+      "suggested_scalar": 0.1757,
+      "log_bad": 4.0775,
+      "log_good": 4.6151
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.3591,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 90.0,
+      "good": 100.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0344,
+      "log_bad": 4.4998,
+      "log_good": 4.6052
+    },
+    "brevity.mean_sample_size": {
+      "bad": 90.0,
+      "good": 100.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0344,
+      "log_bad": 4.4998,
+      "log_good": 4.6052
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 323.0,
+      "good": 543.0,
+      "ratio": 1.6811,
+      "suggested_scalar": 0.1698,
+      "log_bad": 5.7777,
+      "log_good": 6.2971
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 179.0,
+      "good": 333.0,
+      "ratio": 1.8603,
+      "suggested_scalar": 0.2029,
+      "log_bad": 5.1874,
+      "log_good": 5.8081
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 218.0,
+      "good": 294.0,
+      "ratio": 1.3486,
+      "suggested_scalar": 0.0978,
+      "log_bad": 5.3845,
+      "log_good": 5.6836
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0031,
+      "good": 0.0037,
+      "ratio": 1.1935,
+      "suggested_scalar": 0.0578,
+      "log_bad": -5.7764,
+      "log_good": -5.5994
+    },
+    "heaps.mean_k": {
+      "bad": 1.697,
+      "good": 2.277,
+      "ratio": 1.3418,
+      "suggested_scalar": 0.0961,
+      "log_bad": 0.5289,
+      "log_good": 0.8229
+    },
+    "halstead.mean_effort": {
+      "bad": 51556.9527,
+      "good": 73917.6425,
+      "ratio": 1.4337,
+      "suggested_scalar": 0.1177,
+      "log_bad": 10.8504,
+      "log_good": 11.2107
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.883,
+      "good": 0.8387,
+      "ratio": 0.9498,
+      "suggested_scalar": -0.0168,
+      "log_bad": -0.1244,
+      "log_good": -0.1759
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 63.0,
+      "good": 49.0,
+      "ratio": 0.7778,
+      "suggested_scalar": -0.0821,
+      "log_bad": 4.1431,
+      "log_good": 3.8918
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 173.0,
+      "good": 318.0,
+      "ratio": 1.8382,
+      "suggested_scalar": 0.199,
+      "log_bad": 5.1533,
+      "log_good": 5.7621
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4904,
+      "good": 0.3608,
+      "ratio": 0.7357,
+      "suggested_scalar": -0.1003,
+      "log_bad": -0.7125,
+      "log_good": -1.0194
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.4808,
+      "good": 6.3038,
+      "ratio": 1.1502,
+      "suggested_scalar": 0.0457,
+      "log_bad": 1.7013,
+      "log_good": 1.8412
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.16,
+      "good": 0.1081,
+      "ratio": 0.6756,
+      "suggested_scalar": -0.1282,
+      "log_bad": -1.8326,
+      "log_good": -2.2247
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.0762,
+      "good": 4.6942,
+      "ratio": 1.526,
+      "suggested_scalar": 0.1381,
+      "log_bad": 1.1237,
+      "log_good": 1.5463
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 322.0,
+      "good": 542.0,
+      "ratio": 1.6832,
+      "suggested_scalar": 0.1702,
+      "log_bad": 5.7746,
+      "log_good": 6.2953
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.167,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 37.0,
+      "good": 73.0,
+      "ratio": 1.973,
+      "suggested_scalar": 0.2221,
+      "log_bad": 3.6109,
+      "log_good": 4.2905
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2864.2752,
+      "good": 4106.5357,
+      "ratio": 1.4337,
+      "suggested_scalar": 0.1177,
+      "log_bad": 7.9601,
+      "log_good": 8.3203
+    },
+    "readability.mean_total_lines": {
+      "bad": 42.0,
+      "good": 65.0,
+      "ratio": 1.5476,
+      "suggested_scalar": 0.1427,
+      "log_bad": 3.7377,
+      "log_good": 4.1744
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 20.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0729,
+      "log_bad": 2.7726,
+      "log_good": 2.9957
+    },
+    "halstead.mean_volume": {
+      "bad": 1898.3565,
+      "good": 2613.25,
+      "ratio": 1.3766,
+      "suggested_scalar": 0.1045,
+      "log_bad": 7.5487,
+      "log_good": 7.8683
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 559.0,
+      "good": 779.0,
+      "ratio": 1.3936,
+      "suggested_scalar": 0.1085,
+      "log_bad": 6.3261,
+      "log_good": 6.658
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.9286,
+      "good": 32.8923,
+      "ratio": 1.0635,
+      "suggested_scalar": 0.0201,
+      "log_bad": 3.4317,
+      "log_good": 3.4932
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0657,
+      "good": 1.256,
+      "ratio": 1.1786,
+      "suggested_scalar": 0.0537,
+      "log_bad": 0.0636,
+      "log_good": 0.2279
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 7.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.11,
+      "log_bad": 1.6094,
+      "log_good": 1.9459
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 15.0,
+      "good": 23.0,
+      "ratio": 1.5333,
+      "suggested_scalar": 0.1397,
+      "log_bad": 2.7081,
+      "log_good": 3.1355
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.3591,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8619,
+      "good": 0.8202,
+      "ratio": 0.9516,
+      "suggested_scalar": -0.0162,
+      "log_bad": -0.1486,
+      "log_good": -0.1982
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9917,
+      "good": 0.9724,
+      "ratio": 0.9805,
+      "suggested_scalar": -0.0064,
+      "log_bad": -0.0083,
+      "log_good": -0.028
+    },
+    "halstead.mean_length": {
+      "bad": 291.0,
+      "good": 417.0,
+      "ratio": 1.433,
+      "suggested_scalar": 0.1176,
+      "log_bad": 5.6733,
+      "log_good": 6.0331
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 44.0,
+      "good": 21.0,
+      "ratio": 0.4773,
+      "suggested_scalar": -0.2417,
+      "log_bad": 3.7842,
+      "log_good": 3.0445
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4919,
+      "good": 6.6439,
+      "ratio": 1.0234,
+      "suggested_scalar": 0.0076,
+      "log_bad": 1.8706,
+      "log_good": 1.8937
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1327,
+      "good": 0.1495,
+      "ratio": 1.1266,
+      "suggested_scalar": 0.039,
+      "log_bad": -2.0197,
+      "log_good": -1.9005
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.1587,
+      "good": 28.2857,
+      "ratio": 1.0415,
+      "suggested_scalar": 0.0133,
+      "log_bad": 3.3017,
+      "log_good": 3.3424
+    },
+    "branching.mean_branch_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 51.0,
+      "good": 57.0,
+      "ratio": 1.1176,
+      "suggested_scalar": 0.0364,
+      "log_bad": 3.9318,
+      "log_good": 4.0431
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7294,
+      "good": 0.6565,
+      "ratio": 0.9001,
+      "suggested_scalar": -0.0344,
+      "log_bad": -0.3155,
+      "log_good": -0.4208
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 42.0,
+      "good": 66.0,
+      "ratio": 1.5714,
+      "suggested_scalar": 0.1477,
+      "log_bad": 3.7377,
+      "log_good": 4.1897
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2265,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_process_for_code_organization": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 26.0,
+      "good": 22.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.1219,
+      "log_bad": 3.2581,
+      "log_good": 3.091
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.2958,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0059,
+      "good": 0.0403,
+      "ratio": 6.8305,
+      "suggested_scalar": 1.4019,
+      "log_bad": -5.1328,
+      "log_good": -3.2114
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.875,
+      "good": 1.6,
+      "ratio": 0.8533,
+      "suggested_scalar": -0.1157,
+      "log_bad": 0.6286,
+      "log_good": 0.47
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7419,
+      "good": 0.7692,
+      "ratio": 1.0368,
+      "suggested_scalar": 0.0264,
+      "log_bad": -0.2985,
+      "log_good": -0.2624
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0059,
+      "good": 0.0403,
+      "ratio": 6.8305,
+      "suggested_scalar": 1.4019,
+      "log_bad": -5.1328,
+      "log_good": -3.2114
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7518,
+      "good": 4.8448,
+      "ratio": 1.0196,
+      "suggested_scalar": 0.0141,
+      "log_bad": 1.5585,
+      "log_good": 1.5779
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 111.0,
+      "good": 91.0,
+      "ratio": 0.8198,
+      "suggested_scalar": -0.145,
+      "log_bad": 4.7095,
+      "log_good": 4.5109
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4488,
+      "good": 0.5644,
+      "ratio": 1.2576,
+      "suggested_scalar": 0.1672,
+      "log_bad": -0.8012,
+      "log_good": -0.572
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6112,
+      "good": 0.657,
+      "ratio": 1.0749,
+      "suggested_scalar": 0.0527,
+      "log_bad": -0.4923,
+      "log_good": -0.4201
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.7097,
+      "good": 2.6154,
+      "ratio": 0.705,
+      "suggested_scalar": -0.255,
+      "log_bad": 1.311,
+      "log_good": 0.9614
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 505.0,
+      "good": 472.0,
+      "ratio": 0.9347,
+      "suggested_scalar": -0.0493,
+      "log_bad": 6.2246,
+      "log_good": 6.157
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0009,
+      "good": 0.001,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0769,
+      "log_bad": -7.0131,
+      "log_good": -6.9078
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0645,
+      "good": 1.0,
+      "ratio": 15.5039,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.7411,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0009,
+      "good": 0.0015,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.3727,
+      "log_bad": -7.0131,
+      "log_good": -6.5023
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9966,
+      "good": 0.8853,
+      "ratio": 0.8883,
+      "suggested_scalar": -0.0864,
+      "log_bad": -0.0034,
+      "log_good": -0.1218
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 182.0,
+      "good": 179.0,
+      "ratio": 0.9835,
+      "suggested_scalar": -0.0121,
+      "log_bad": 5.204,
+      "log_good": 5.1874
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 99.7523,
+      "good": 98.0485,
+      "ratio": 0.9829,
+      "suggested_scalar": -0.0126,
+      "log_bad": 4.6027,
+      "log_good": 4.5855
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6766,
+      "good": 0.5648,
+      "ratio": 0.8348,
+      "suggested_scalar": -0.1318,
+      "log_bad": -0.3907,
+      "log_good": -0.5713
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 14.5545,
+      "good": 14.1142,
+      "ratio": 0.9697,
+      "suggested_scalar": -0.0224,
+      "log_bad": 2.6779,
+      "log_good": 2.6472
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2214.0,
+      "good": 1946.0,
+      "ratio": 0.879,
+      "suggested_scalar": -0.0941,
+      "log_bad": 7.7026,
+      "log_good": 7.5735
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0968,
+      "good": 0.1923,
+      "ratio": 1.9866,
+      "suggested_scalar": 0.5008,
+      "log_bad": -2.3351,
+      "log_good": -1.6487
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6935,
+      "good": 0.7308,
+      "ratio": 1.0538,
+      "suggested_scalar": 0.0382,
+      "log_bad": -0.366,
+      "log_good": -0.3136
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.7069,
+      "good": 9.0769,
+      "ratio": 1.0425,
+      "suggested_scalar": 0.0304,
+      "log_bad": 2.1641,
+      "log_good": 2.2057
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 8.0,
+      "good": 1.0,
+      "ratio": 0.125,
+      "suggested_scalar": -1.5172,
+      "log_bad": 2.0794,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 6.1738,
+      "good": 2.5444,
+      "ratio": 0.4121,
+      "suggested_scalar": -0.6468,
+      "log_bad": 1.8203,
+      "log_good": 0.9339
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 151.0,
+      "good": 149.0,
+      "ratio": 0.9868,
+      "suggested_scalar": -0.0097,
+      "log_bad": 5.0173,
+      "log_good": 5.0039
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9496,
+      "good": 0.9562,
+      "ratio": 1.007,
+      "suggested_scalar": 0.0051,
+      "log_bad": -0.0517,
+      "log_good": -0.0448
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 38.0,
+      "good": 34.0,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.0812,
+      "log_bad": 3.6376,
+      "log_good": 3.5264
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6436,
+      "good": 0.5858,
+      "ratio": 0.9102,
+      "suggested_scalar": -0.0687,
+      "log_bad": -0.4407,
+      "log_good": -0.5348
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5109,
+      "good": 0.3638,
+      "ratio": 0.7121,
+      "suggested_scalar": -0.2478,
+      "log_bad": -0.6716,
+      "log_good": -1.0112
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.8061,
+      "good": 2.4144,
+      "ratio": 0.8604,
+      "suggested_scalar": -0.1097,
+      "log_bad": 1.0318,
+      "log_good": 0.8815
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 503.0,
+      "good": 470.0,
+      "ratio": 0.9344,
+      "suggested_scalar": -0.0495,
+      "log_bad": 6.2206,
+      "log_good": 6.1527
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 14.0,
+      "good": 16.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.0974,
+      "log_bad": 2.6391,
+      "log_good": 2.7726
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0099,
+      "good": 0.0085,
+      "ratio": 0.8586,
+      "suggested_scalar": -0.1112,
+      "log_bad": -4.6152,
+      "log_good": -4.7677
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0444,
+      "good": 6.0,
+      "ratio": 0.9927,
+      "suggested_scalar": -0.0054,
+      "log_bad": 1.7991,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 23.0,
+      "good": 29.0,
+      "ratio": 1.2609,
+      "suggested_scalar": 0.1691,
+      "log_bad": 3.1355,
+      "log_good": 3.3673
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7988,
+      "good": 0.6875,
+      "ratio": 0.8607,
+      "suggested_scalar": -0.1095,
+      "log_bad": -0.2246,
+      "log_good": -0.3747
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9864,
+      "good": 6.1259,
+      "ratio": 1.0233,
+      "suggested_scalar": 0.0168,
+      "log_bad": 1.7895,
+      "log_good": 1.8125
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7862,
+      "good": 0.8075,
+      "ratio": 1.0271,
+      "suggested_scalar": 0.0195,
+      "log_bad": -0.2405,
+      "log_good": -0.2138
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1268,
+      "good": 0.1034,
+      "ratio": 0.8155,
+      "suggested_scalar": -0.1489,
+      "log_bad": -2.0651,
+      "log_good": -2.2692
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.815,
+      "good": 3.7569,
+      "ratio": 0.9848,
+      "suggested_scalar": -0.0112,
+      "log_bad": 1.3389,
+      "log_good": 1.3236
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 347.0,
+      "good": 359.0,
+      "ratio": 1.0346,
+      "suggested_scalar": 0.0248,
+      "log_bad": 5.8493,
+      "log_good": 5.8833
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 8.0,
+      "good": 9.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0859,
+      "log_bad": 2.0794,
+      "log_good": 2.1972
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0328,
+      "good": 0.7592,
+      "ratio": 0.7351,
+      "suggested_scalar": -0.2246,
+      "log_bad": 0.0323,
+      "log_good": -0.2755
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 126.0,
+      "good": 140.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0769,
+      "log_bad": 4.8363,
+      "log_good": 4.9416
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1260.0,
+      "good": 1156.0,
+      "ratio": 0.9175,
+      "suggested_scalar": -0.0629,
+      "log_bad": 7.1389,
+      "log_good": 7.0527
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 178.0,
+      "good": 127.0,
+      "ratio": 0.7135,
+      "suggested_scalar": -0.2463,
+      "log_bad": 5.1818,
+      "log_good": 4.8442
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0099,
+      "good": 0.0042,
+      "ratio": 0.4242,
+      "suggested_scalar": -0.6256,
+      "log_bad": -4.6152,
+      "log_good": -5.4727
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2396,
+      "good": 0.2055,
+      "ratio": 0.8577,
+      "suggested_scalar": -0.112,
+      "log_bad": -1.4288,
+      "log_good": -1.5823
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 110.0,
+      "good": 84.0,
+      "ratio": 0.7636,
+      "suggested_scalar": -0.1968,
+      "log_bad": 4.7005,
+      "log_good": 4.4308
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 8.0,
+      "good": 5.0,
+      "ratio": 0.625,
+      "suggested_scalar": -0.3429,
+      "log_bad": 2.0794,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 126.0,
+      "good": 140.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0769,
+      "log_bad": 4.8363,
+      "log_good": 4.9416
+    },
+    "brevity.mean_sample_size": {
+      "bad": 126.0,
+      "good": 140.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0769,
+      "log_bad": 4.8363,
+      "log_good": 4.9416
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 505.0,
+      "good": 472.0,
+      "ratio": 0.9347,
+      "suggested_scalar": -0.0493,
+      "log_bad": 6.2246,
+      "log_good": 6.157
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 252.0,
+      "good": 242.0,
+      "ratio": 0.9603,
+      "suggested_scalar": -0.0295,
+      "log_bad": 5.5294,
+      "log_good": 5.4889
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 273.0,
+      "good": 289.0,
+      "ratio": 1.0586,
+      "suggested_scalar": 0.0416,
+      "log_bad": 5.6095,
+      "log_good": 5.6664
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.004,
+      "good": 0.0042,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0356,
+      "log_bad": -5.5215,
+      "log_good": -5.4727
+    },
+    "heaps.mean_k": {
+      "bad": 3.2172,
+      "good": 2.5395,
+      "ratio": 0.7894,
+      "suggested_scalar": -0.1726,
+      "log_bad": 1.1685,
+      "log_good": 0.932
+    },
+    "halstead.mean_effort": {
+      "bad": 143538.2711,
+      "good": 86273.9477,
+      "ratio": 0.6011,
+      "suggested_scalar": -0.3714,
+      "log_bad": 11.8744,
+      "log_good": 11.3653
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.858,
+      "good": 0.8593,
+      "ratio": 1.0015,
+      "suggested_scalar": 0.0011,
+      "log_bad": -0.1532,
+      "log_good": -0.1516
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 73.0,
+      "good": 57.0,
+      "ratio": 0.7808,
+      "suggested_scalar": -0.1805,
+      "log_bad": 4.2905,
+      "log_good": 4.0431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 278.0,
+      "good": 223.0,
+      "ratio": 0.8022,
+      "suggested_scalar": -0.1608,
+      "log_bad": 5.6276,
+      "log_good": 5.4072
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4121,
+      "good": 0.5251,
+      "ratio": 1.2742,
+      "suggested_scalar": 0.1768,
+      "log_bad": -0.8865,
+      "log_good": -0.6442
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.9231,
+      "good": 6.4581,
+      "ratio": 0.9328,
+      "suggested_scalar": -0.0507,
+      "log_bad": 1.9349,
+      "log_good": 1.8653
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1268,
+      "good": 0.1034,
+      "ratio": 0.8155,
+      "suggested_scalar": -0.1489,
+      "log_bad": -2.0651,
+      "log_good": -2.2692
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.644,
+      "good": 4.3387,
+      "ratio": 1.1906,
+      "suggested_scalar": 0.1273,
+      "log_bad": 1.2931,
+      "log_good": 1.4676
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 504.0,
+      "good": 471.0,
+      "ratio": 0.9345,
+      "suggested_scalar": -0.0494,
+      "log_bad": 6.2226,
+      "log_good": 6.1549
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 8.0,
+      "good": 9.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0859,
+      "log_bad": 2.0794,
+      "log_good": 2.1972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 101.0,
+      "good": 60.0,
+      "ratio": 0.5941,
+      "suggested_scalar": -0.38,
+      "log_bad": 4.6151,
+      "log_good": 4.0943
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 7974.3484,
+      "good": 4792.9971,
+      "ratio": 0.6011,
+      "suggested_scalar": -0.3714,
+      "log_bad": 8.984,
+      "log_good": 8.4749
+    },
+    "readability.mean_total_lines": {
+      "bad": 58.0,
+      "good": 52.0,
+      "ratio": 0.8966,
+      "suggested_scalar": -0.0797,
+      "log_bad": 4.0604,
+      "log_good": 3.9512
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 8.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1628,
+      "log_bad": 2.3026,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 3098.2536,
+      "good": 2277.7281,
+      "ratio": 0.7352,
+      "suggested_scalar": -0.2245,
+      "log_bad": 8.0386,
+      "log_good": 7.7309
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 789.0,
+      "good": 806.0,
+      "ratio": 1.0215,
+      "suggested_scalar": 0.0156,
+      "log_bad": 6.6708,
+      "log_good": 6.6921
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.8621,
+      "good": 36.1538,
+      "ratio": 1.1002,
+      "suggested_scalar": 0.0697,
+      "log_bad": 3.4923,
+      "log_good": 3.5878
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1613,
+      "good": 1.177,
+      "ratio": 1.0135,
+      "suggested_scalar": 0.0098,
+      "log_bad": 0.1495,
+      "log_good": 0.163
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 24.0,
+      "good": 27.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0859,
+      "log_bad": 3.1781,
+      "log_good": 3.2958
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 4.0,
+      "good": 1.0,
+      "ratio": 0.25,
+      "suggested_scalar": -1.0115,
+      "log_bad": 1.3863,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7089,
+      "good": 0.8329,
+      "ratio": 1.1749,
+      "suggested_scalar": 0.1176,
+      "log_bad": -0.344,
+      "log_good": -0.1828
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 7.0,
+      "ratio": 3.5,
+      "suggested_scalar": 0.9141,
+      "log_bad": 0.6931,
+      "log_good": 1.9459
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9457,
+      "good": 0.9845,
+      "ratio": 1.041,
+      "suggested_scalar": 0.0293,
+      "log_bad": -0.0558,
+      "log_good": -0.0156
+    },
+    "halstead.mean_length": {
+      "bad": 456.0,
+      "good": 350.0,
+      "ratio": 0.7675,
+      "suggested_scalar": -0.193,
+      "log_bad": 6.1225,
+      "log_good": 5.8579
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.5,
+      "good": 8.8,
+      "ratio": 1.1733,
+      "suggested_scalar": 0.1166,
+      "log_bad": 2.0149,
+      "log_good": 2.1748
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9773,
+      "good": 7.1293,
+      "ratio": 1.0218,
+      "suggested_scalar": 0.0157,
+      "log_bad": 1.9427,
+      "log_good": 1.9642
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1139,
+      "good": 0.1249,
+      "ratio": 1.0966,
+      "suggested_scalar": 0.0673,
+      "log_bad": -2.1724,
+      "log_good": -2.0802
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 46.3288,
+      "good": 37.8772,
+      "ratio": 0.8176,
+      "suggested_scalar": -0.147,
+      "log_bad": 3.8358,
+      "log_good": 3.6343
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 10.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.3727,
+      "log_bad": 1.7918,
+      "log_good": 2.3026
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 75.0,
+      "good": 94.0,
+      "ratio": 1.2533,
+      "suggested_scalar": 0.1648,
+      "log_bad": 4.3175,
+      "log_good": 4.5433
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5971,
+      "good": 0.7093,
+      "ratio": 1.1879,
+      "suggested_scalar": 0.1256,
+      "log_bad": -0.5157,
+      "log_good": -0.3435
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 62.0,
+      "good": 52.0,
+      "ratio": 0.8387,
+      "suggested_scalar": -0.1283,
+      "log_bad": 4.1271,
+      "log_good": 3.9512
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_virtual_calls_in_constructors": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 12.0,
+      "good": 8.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1315,
+      "log_bad": 2.4849,
+      "log_good": 2.0794
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 6.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2248,
+      "log_bad": 1.0986,
+      "log_good": 1.7918
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0045,
+      "good": 0.0041,
+      "ratio": 0.9111,
+      "suggested_scalar": -0.0302,
+      "log_bad": -5.4037,
+      "log_good": -5.4968
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7833,
+      "good": 0.8387,
+      "ratio": 1.0707,
+      "suggested_scalar": 0.0222,
+      "log_bad": -0.2442,
+      "log_good": -0.1759
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0022,
+      "good": 0.0041,
+      "ratio": 1.8636,
+      "suggested_scalar": 0.2019,
+      "log_bad": -6.1193,
+      "log_good": -5.4968
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.583,
+      "good": 4.6775,
+      "ratio": 1.0206,
+      "suggested_scalar": 0.0066,
+      "log_bad": 1.5224,
+      "log_good": 1.5428
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 76.0,
+      "good": 132.0,
+      "ratio": 1.7368,
+      "suggested_scalar": 0.1791,
+      "log_bad": 4.3307,
+      "log_good": 4.8828
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4883,
+      "good": 0.5304,
+      "ratio": 1.0862,
+      "suggested_scalar": 0.0268,
+      "log_bad": -0.7168,
+      "log_good": -0.6341
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 22.0,
+      "good": 21.0,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.0151,
+      "log_bad": 3.091,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7053,
+      "good": 0.6845,
+      "ratio": 0.9705,
+      "suggested_scalar": -0.0097,
+      "log_bad": -0.3491,
+      "log_good": -0.3791
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.2667,
+      "good": 3.4194,
+      "ratio": 0.8014,
+      "suggested_scalar": -0.0718,
+      "log_bad": 1.4508,
+      "log_good": 1.2295
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 448.0,
+      "good": 482.0,
+      "ratio": 1.0759,
+      "suggested_scalar": 0.0237,
+      "log_bad": 6.1048,
+      "log_good": 6.1779
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1833,
+      "good": 0.1613,
+      "ratio": 0.88,
+      "suggested_scalar": -0.0415,
+      "log_bad": -1.6966,
+      "log_good": -1.8245
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9157,
+      "good": 0.9489,
+      "ratio": 1.0363,
+      "suggested_scalar": 0.0116,
+      "log_bad": -0.0881,
+      "log_good": -0.0525
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 147.0,
+      "good": 147.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.9904,
+      "log_good": 4.9904
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 106.4654,
+      "good": 109.2024,
+      "ratio": 1.0257,
+      "suggested_scalar": 0.0082,
+      "log_bad": 4.6678,
+      "log_good": 4.6932
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.66,
+      "good": 0.5593,
+      "ratio": 0.8474,
+      "suggested_scalar": -0.0537,
+      "log_bad": -0.4155,
+      "log_good": -0.5811
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 10.7728,
+      "good": 9.7737,
+      "ratio": 0.9073,
+      "suggested_scalar": -0.0316,
+      "log_bad": 2.377,
+      "log_good": 2.2797
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2160.0,
+      "good": 2160.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 7.6779,
+      "log_good": 7.6779
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0833,
+      "good": 0.0806,
+      "ratio": 0.9676,
+      "suggested_scalar": -0.0107,
+      "log_bad": -2.4853,
+      "log_good": -2.5183
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7833,
+      "good": 0.8226,
+      "ratio": 1.0502,
+      "suggested_scalar": 0.0159,
+      "log_bad": -0.2442,
+      "log_good": -0.1953
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.8596,
+      "good": 8.1695,
+      "ratio": 1.0394,
+      "suggested_scalar": 0.0125,
+      "log_bad": 2.0617,
+      "log_good": 2.1004
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 8.9956,
+      "good": 8.179,
+      "ratio": 0.9092,
+      "suggested_scalar": -0.0309,
+      "log_bad": 2.1967,
+      "log_good": 2.1016
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 93.0,
+      "good": 100.0,
+      "ratio": 1.0753,
+      "suggested_scalar": 0.0235,
+      "log_bad": 4.5326,
+      "log_good": 4.6052
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9525,
+      "good": 0.9582,
+      "ratio": 1.006,
+      "suggested_scalar": 0.0019,
+      "log_bad": -0.0487,
+      "log_good": -0.0427
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 28.0,
+      "good": 32.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.0433,
+      "log_bad": 3.3322,
+      "log_good": 3.4657
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6556,
+      "good": 0.6079,
+      "ratio": 0.9272,
+      "suggested_scalar": -0.0245,
+      "log_bad": -0.4222,
+      "log_good": -0.4977
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4641,
+      "good": 0.3396,
+      "ratio": 0.7317,
+      "suggested_scalar": -0.1013,
+      "log_bad": -0.7677,
+      "log_good": -1.08
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9032,
+      "good": 2.5502,
+      "ratio": 0.8784,
+      "suggested_scalar": -0.0421,
+      "log_bad": 1.0658,
+      "log_good": 0.9362
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 446.0,
+      "good": 480.0,
+      "ratio": 1.0762,
+      "suggested_scalar": 0.0238,
+      "log_bad": 6.1003,
+      "log_good": 6.1738
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0424,
+      "good": 0.0436,
+      "ratio": 1.0283,
+      "suggested_scalar": 0.0091,
+      "log_bad": -3.1606,
+      "log_good": -3.1327
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9773,
+      "good": 6.0224,
+      "ratio": 1.0075,
+      "suggested_scalar": 0.0024,
+      "log_bad": 1.788,
+      "log_good": 1.7955
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 27.0,
+      "good": 24.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0382,
+      "log_bad": 3.2958,
+      "log_good": 3.1781
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.498,
+      "good": 1.3695,
+      "ratio": 0.9142,
+      "suggested_scalar": -0.0291,
+      "log_bad": 0.4041,
+      "log_good": 0.3144
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.007,
+      "good": 6.0506,
+      "ratio": 1.0073,
+      "suggested_scalar": 0.0023,
+      "log_bad": 1.7929,
+      "log_good": 1.8002
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7667,
+      "good": 0.7767,
+      "ratio": 1.013,
+      "suggested_scalar": 0.0042,
+      "log_bad": -0.2657,
+      "log_good": -0.2527
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1667,
+      "good": 0.1948,
+      "ratio": 1.1686,
+      "suggested_scalar": 0.0505,
+      "log_bad": -1.7916,
+      "log_good": -1.6358
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.2822,
+      "good": 3.1263,
+      "ratio": 0.9525,
+      "suggested_scalar": -0.0158,
+      "log_bad": 1.1885,
+      "log_good": 1.1399
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 328.0,
+      "good": 380.0,
+      "ratio": 1.1585,
+      "suggested_scalar": 0.0477,
+      "log_bad": 5.793,
+      "log_good": 5.9402
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 9.0,
+      "good": 13.0,
+      "ratio": 1.4444,
+      "suggested_scalar": 0.1193,
+      "log_bad": 2.1972,
+      "log_good": 2.5649
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.629,
+      "good": 1.0942,
+      "ratio": 1.7396,
+      "suggested_scalar": 0.1796,
+      "log_bad": -0.4636,
+      "log_good": 0.09
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 131.0,
+      "ratio": 1.1593,
+      "suggested_scalar": 0.0479,
+      "log_bad": 4.7274,
+      "log_good": 4.8752
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 983.0,
+      "good": 957.0,
+      "ratio": 0.9736,
+      "suggested_scalar": -0.0087,
+      "log_bad": 6.8906,
+      "log_good": 6.8638
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 77.0,
+      "good": 214.0,
+      "ratio": 2.7792,
+      "suggested_scalar": 0.3316,
+      "log_bad": 4.3438,
+      "log_good": 5.366
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 0.0021,
+      "ratio": 0.0021,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.1658
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1875,
+      "good": 0.2178,
+      "ratio": 1.1616,
+      "suggested_scalar": 0.0486,
+      "log_bad": -1.674,
+      "log_good": -1.5242
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 103.0,
+      "good": 84.0,
+      "ratio": 0.8155,
+      "suggested_scalar": -0.0661,
+      "log_bad": 4.6347,
+      "log_good": 4.4308
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 113.0,
+      "good": 131.0,
+      "ratio": 1.1593,
+      "suggested_scalar": 0.0479,
+      "log_bad": 4.7274,
+      "log_good": 4.8752
+    },
+    "brevity.mean_sample_size": {
+      "bad": 113.0,
+      "good": 131.0,
+      "ratio": 1.1593,
+      "suggested_scalar": 0.0479,
+      "log_bad": 4.7274,
+      "log_good": 4.8752
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 448.0,
+      "good": 482.0,
+      "ratio": 1.0759,
+      "suggested_scalar": 0.0237,
+      "log_bad": 6.1048,
+      "log_good": 6.1779
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 217.0,
+      "good": 247.0,
+      "ratio": 1.1382,
+      "suggested_scalar": 0.042,
+      "log_bad": 5.3799,
+      "log_good": 5.5094
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 255.0,
+      "good": 296.0,
+      "ratio": 1.1608,
+      "suggested_scalar": 0.0484,
+      "log_bad": 5.5413,
+      "log_good": 5.6904
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0022,
+      "good": 0.0021,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.0151,
+      "log_bad": -6.1193,
+      "log_good": -6.1658
+    },
+    "heaps.mean_k": {
+      "bad": 1.6817,
+      "good": 2.0739,
+      "ratio": 1.2332,
+      "suggested_scalar": 0.068,
+      "log_bad": 0.5198,
+      "log_good": 0.7294
+    },
+    "halstead.mean_effort": {
+      "bad": 42376.0477,
+      "good": 112399.2255,
+      "ratio": 2.6524,
+      "suggested_scalar": 0.3164,
+      "log_bad": 10.6543,
+      "log_good": 11.6298
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8808,
+      "good": 0.8603,
+      "ratio": 0.9767,
+      "suggested_scalar": -0.0076,
+      "log_bad": -0.1269,
+      "log_good": -0.1505
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 48.0,
+      "good": 100.0,
+      "ratio": 2.0833,
+      "suggested_scalar": 0.2381,
+      "log_bad": 3.8712,
+      "log_good": 4.6052
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 225.0,
+      "good": 252.0,
+      "ratio": 1.12,
+      "suggested_scalar": 0.0368,
+      "log_bad": 5.4161,
+      "log_good": 5.5294
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4354,
+      "good": 0.517,
+      "ratio": 1.1874,
+      "suggested_scalar": 0.0557,
+      "log_bad": -0.8315,
+      "log_good": -0.6597
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.6871,
+      "good": 6.5102,
+      "ratio": 0.9735,
+      "suggested_scalar": -0.0087,
+      "log_bad": 1.9002,
+      "log_good": 1.8734
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1667,
+      "good": 0.1948,
+      "ratio": 1.1686,
+      "suggested_scalar": 0.0505,
+      "log_bad": -1.7916,
+      "log_good": -1.6358
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.1439,
+      "good": 3.2678,
+      "ratio": 1.0394,
+      "suggested_scalar": 0.0125,
+      "log_bad": 1.1455,
+      "log_good": 1.1841
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 447.0,
+      "good": 481.0,
+      "ratio": 1.0761,
+      "suggested_scalar": 0.0238,
+      "log_bad": 6.1026,
+      "log_good": 6.1759
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0933,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 89.0,
+      "good": 63.0,
+      "ratio": 0.7079,
+      "suggested_scalar": -0.1121,
+      "log_bad": 4.4886,
+      "log_good": 4.1431
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2354.2249,
+      "good": 6244.4014,
+      "ratio": 2.6524,
+      "suggested_scalar": 0.3164,
+      "log_bad": 7.764,
+      "log_good": 8.7394
+    },
+    "readability.mean_total_lines": {
+      "bad": 57.0,
+      "good": 59.0,
+      "ratio": 1.0351,
+      "suggested_scalar": 0.0112,
+      "log_bad": 4.0431,
+      "log_good": 4.0775
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 1886.8741,
+      "good": 3282.6877,
+      "ratio": 1.7397,
+      "suggested_scalar": 0.1796,
+      "log_bad": 7.5427,
+      "log_good": 8.0964
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 744.0,
+      "good": 847.0,
+      "ratio": 1.1384,
+      "suggested_scalar": 0.0421,
+      "log_bad": 6.612,
+      "log_good": 6.7417
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.5614,
+      "good": 34.3051,
+      "ratio": 0.9647,
+      "suggested_scalar": -0.0117,
+      "log_bad": 3.5713,
+      "log_good": 3.5353
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0921,
+      "good": 1.056,
+      "ratio": 0.9669,
+      "suggested_scalar": -0.0109,
+      "log_bad": 0.0881,
+      "log_good": 0.0545
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 11.0,
+      "good": 10.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0309,
+      "log_bad": 2.3979,
+      "log_good": 2.3026
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7287,
+      "good": 0.8342,
+      "ratio": 1.1448,
+      "suggested_scalar": 0.0439,
+      "log_bad": -0.3165,
+      "log_good": -0.1813
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9603,
+      "good": 0.9478,
+      "ratio": 0.987,
+      "suggested_scalar": -0.0042,
+      "log_bad": -0.0405,
+      "log_good": -0.0536
+    },
+    "halstead.mean_length": {
+      "bad": 302.0,
+      "good": 466.0,
+      "ratio": 1.543,
+      "suggested_scalar": 0.1407,
+      "log_bad": 5.7104,
+      "log_good": 6.1442
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8202,
+      "good": 7.0334,
+      "ratio": 1.0313,
+      "suggested_scalar": 0.01,
+      "log_bad": 1.9199,
+      "log_good": 1.9507
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1009,
+      "good": 0.1148,
+      "ratio": 1.1378,
+      "suggested_scalar": 0.0419,
+      "log_bad": -2.2936,
+      "log_good": -2.1646
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 22.4583,
+      "good": 34.24,
+      "ratio": 1.5246,
+      "suggested_scalar": 0.1368,
+      "log_bad": 3.1117,
+      "log_good": 3.5334
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 64.0,
+      "good": 76.0,
+      "ratio": 1.1875,
+      "suggested_scalar": 0.0557,
+      "log_bad": 4.1589,
+      "log_good": 4.3307
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5961,
+      "good": 0.7162,
+      "ratio": 1.2015,
+      "suggested_scalar": 0.0595,
+      "log_bad": -0.5173,
+      "log_good": -0.3338
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 60.0,
+      "good": 62.0,
+      "ratio": 1.0333,
+      "suggested_scalar": 0.0106,
+      "log_bad": 4.0943,
+      "log_good": 4.1271
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 14.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.0433,
+      "log_bad": 2.7726,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.no_static_class_for_namespacing": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 2.0,
+      "good": 16.0,
+      "ratio": 8.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.6931,
+      "log_good": 2.7726
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0225,
+      "good": 0.0225,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.7942,
+      "log_good": -3.7942
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7037,
+      "good": 0.6863,
+      "ratio": 0.9753,
+      "suggested_scalar": -0.0241,
+      "log_bad": -0.3514,
+      "log_good": -0.3764
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0247,
+      "good": 0.0248,
+      "ratio": 1.004,
+      "suggested_scalar": 0.0039,
+      "log_bad": -3.701,
+      "log_good": -3.6969
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6696,
+      "good": 4.8433,
+      "ratio": 1.0372,
+      "suggested_scalar": 0.0351,
+      "log_bad": 1.5411,
+      "log_good": 1.5776
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 80.0,
+      "good": 78.0,
+      "ratio": 0.975,
+      "suggested_scalar": -0.0244,
+      "log_bad": 4.382,
+      "log_good": 4.3567
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.389,
+      "good": 0.3889,
+      "ratio": 0.9997,
+      "suggested_scalar": -0.0002,
+      "log_bad": -0.9442,
+      "log_good": -0.9444
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.4855,
+      "good": 0.4827,
+      "ratio": 0.9942,
+      "suggested_scalar": -0.0056,
+      "log_bad": -0.7226,
+      "log_good": -0.7284
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.6296,
+      "good": 1.8431,
+      "ratio": 0.5078,
+      "suggested_scalar": -0.6518,
+      "log_bad": 1.2891,
+      "log_good": 0.6114
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 445.0,
+      "good": 444.0,
+      "ratio": 0.9978,
+      "suggested_scalar": -0.0022,
+      "log_bad": 6.0981,
+      "log_good": 6.0958
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.2146,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1181,
+      "good": 1.1199,
+      "ratio": 1.0016,
+      "suggested_scalar": 0.0015,
+      "log_bad": 0.1116,
+      "log_good": 0.1132
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 128.0,
+      "good": 126.0,
+      "ratio": 0.9844,
+      "suggested_scalar": -0.0151,
+      "log_bad": 4.852,
+      "log_good": 4.8363
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 92.7206,
+      "good": 93.6585,
+      "ratio": 1.0101,
+      "suggested_scalar": 0.0097,
+      "log_bad": 4.5296,
+      "log_good": 4.5397
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7568,
+      "good": 0.7765,
+      "ratio": 1.026,
+      "suggested_scalar": 0.0247,
+      "log_bad": -0.2787,
+      "log_good": -0.253
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.7185,
+      "good": 7.6417,
+      "ratio": 0.99,
+      "suggested_scalar": -0.0096,
+      "log_bad": 2.0436,
+      "log_good": 2.0336
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1623.0,
+      "good": 1550.0,
+      "ratio": 0.955,
+      "suggested_scalar": -0.0443,
+      "log_bad": 7.392,
+      "log_good": 7.346
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0185,
+      "good": 0.0196,
+      "ratio": 1.0595,
+      "suggested_scalar": 0.0556,
+      "log_bad": -3.99,
+      "log_good": -3.9322
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6667,
+      "good": 0.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.4054,
+      "log_good": -0.4054
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.2407,
+      "good": 8.7059,
+      "ratio": 1.0565,
+      "suggested_scalar": 0.0528,
+      "log_bad": 2.1091,
+      "log_good": 2.164
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.8258,
+      "good": 2.1715,
+      "ratio": 0.7685,
+      "suggested_scalar": -0.2533,
+      "log_bad": 1.0388,
+      "log_good": 0.7754
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 68.0,
+      "good": 68.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2195,
+      "log_good": 4.2195
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9386,
+      "good": 0.9377,
+      "ratio": 0.999,
+      "suggested_scalar": -0.0009,
+      "log_bad": -0.0634,
+      "log_good": -0.0643
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.671,
+      "good": 0.6697,
+      "ratio": 0.9981,
+      "suggested_scalar": -0.0019,
+      "log_bad": -0.399,
+      "log_good": -0.4009
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.6366,
+      "good": 0.6538,
+      "ratio": 1.027,
+      "suggested_scalar": 0.0256,
+      "log_bad": -0.4516,
+      "log_good": -0.425
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0393,
+      "good": 3.0273,
+      "ratio": 0.9961,
+      "suggested_scalar": -0.0038,
+      "log_bad": 1.1116,
+      "log_good": 1.1077
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 443.0,
+      "good": 442.0,
+      "ratio": 0.9977,
+      "suggested_scalar": -0.0022,
+      "log_bad": 6.0936,
+      "log_good": 6.0913
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0427,
+      "good": 0.0428,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0022,
+      "log_bad": -3.1536,
+      "log_good": -3.1512
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0224,
+      "good": 6.0224,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7955,
+      "log_good": 1.7955
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 33.0,
+      "good": 31.0,
+      "ratio": 0.9394,
+      "suggested_scalar": -0.0601,
+      "log_bad": 3.4965,
+      "log_good": 3.434
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4625,
+      "good": 1.4542,
+      "ratio": 0.9943,
+      "suggested_scalar": -0.0055,
+      "log_bad": 0.3801,
+      "log_good": 0.3745
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.375,
+      "good": 5.3737,
+      "ratio": 0.9998,
+      "suggested_scalar": -0.0002,
+      "log_bad": 1.6818,
+      "log_good": 1.6815
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7754,
+      "good": 0.8042,
+      "ratio": 1.0371,
+      "suggested_scalar": 0.0351,
+      "log_bad": -0.2544,
+      "log_good": -0.2179
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.129,
+      "good": 0.1207,
+      "ratio": 0.9357,
+      "suggested_scalar": -0.064,
+      "log_bad": -2.0479,
+      "log_good": -2.1144
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.7782,
+      "good": 2.7644,
+      "ratio": 0.995,
+      "suggested_scalar": -0.0048,
+      "log_bad": 1.0218,
+      "log_good": 1.0168
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 264.0,
+      "good": 257.0,
+      "ratio": 0.9735,
+      "suggested_scalar": -0.0258,
+      "log_bad": 5.5759,
+      "log_good": 5.5491
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 26.0,
+      "good": 25.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0377,
+      "log_bad": 3.2581,
+      "log_good": 3.2189
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8703,
+      "good": 0.8632,
+      "ratio": 0.9918,
+      "suggested_scalar": -0.0079,
+      "log_bad": -0.1389,
+      "log_good": -0.1471
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 84.0,
+      "good": 82.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0232,
+      "log_bad": 4.4308,
+      "log_good": 4.4067
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 702.0,
+      "good": 684.0,
+      "ratio": 0.9744,
+      "suggested_scalar": -0.025,
+      "log_bad": 6.5539,
+      "log_good": 6.528
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 163.0,
+      "good": 153.0,
+      "ratio": 0.9387,
+      "suggested_scalar": -0.0609,
+      "log_bad": 5.0938,
+      "log_good": 5.0304
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2472,
+      "good": 0.2477,
+      "ratio": 1.002,
+      "suggested_scalar": 0.0019,
+      "log_bad": -1.3976,
+      "log_good": -1.3955
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 98.0,
+      "good": 99.0,
+      "ratio": 1.0102,
+      "suggested_scalar": 0.0098,
+      "log_bad": 4.585,
+      "log_good": 4.5951
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 84.0,
+      "good": 82.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0232,
+      "log_bad": 4.4308,
+      "log_good": 4.4067
+    },
+    "brevity.mean_sample_size": {
+      "bad": 84.0,
+      "good": 82.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0232,
+      "log_bad": 4.4308,
+      "log_good": 4.4067
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 445.0,
+      "good": 444.0,
+      "ratio": 0.9978,
+      "suggested_scalar": -0.0022,
+      "log_bad": 6.0981,
+      "log_good": 6.0958
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 255.0,
+      "good": 250.0,
+      "ratio": 0.9804,
+      "suggested_scalar": -0.019,
+      "log_bad": 5.5413,
+      "log_good": 5.5215
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 206.0,
+      "good": 198.0,
+      "ratio": 0.9612,
+      "suggested_scalar": -0.0381,
+      "log_bad": 5.3279,
+      "log_good": 5.2883
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.018,
+      "good": 0.018,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.0174,
+      "log_good": -4.0174
+    },
+    "heaps.mean_k": {
+      "bad": 3.8191,
+      "good": 3.783,
+      "ratio": 0.9905,
+      "suggested_scalar": -0.0091,
+      "log_bad": 1.34,
+      "log_good": 1.3305
+    },
+    "halstead.mean_effort": {
+      "bad": 80714.563,
+      "good": 77826.2992,
+      "ratio": 0.9642,
+      "suggested_scalar": -0.035,
+      "log_bad": 11.2987,
+      "log_good": 11.2622
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8408,
+      "good": 0.8452,
+      "ratio": 1.0052,
+      "suggested_scalar": 0.005,
+      "log_bad": -0.1734,
+      "log_good": -0.1682
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 58.0,
+      "good": 56.0,
+      "ratio": 0.9655,
+      "suggested_scalar": -0.0338,
+      "log_bad": 4.0604,
+      "log_good": 4.0254
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 250.0,
+      "good": 259.0,
+      "ratio": 1.036,
+      "suggested_scalar": 0.034,
+      "log_bad": 5.5215,
+      "log_good": 5.5568
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3594,
+      "good": 0.3571,
+      "ratio": 0.9936,
+      "suggested_scalar": -0.0062,
+      "log_bad": -1.0233,
+      "log_good": -1.0297
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.4844,
+      "good": 5.4286,
+      "ratio": 0.9898,
+      "suggested_scalar": -0.0098,
+      "log_bad": 1.7019,
+      "log_good": 1.6917
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.129,
+      "good": 0.1207,
+      "ratio": 0.9357,
+      "suggested_scalar": -0.064,
+      "log_bad": -2.0479,
+      "log_good": -2.1144
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.0236,
+      "good": 6.149,
+      "ratio": 1.0208,
+      "suggested_scalar": 0.0198,
+      "log_bad": 1.7957,
+      "log_good": 1.8163
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 444.0,
+      "good": 443.0,
+      "ratio": 0.9977,
+      "suggested_scalar": -0.0022,
+      "log_bad": 6.0958,
+      "log_good": 6.0936
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 103.0,
+      "good": 104.0,
+      "ratio": 1.0097,
+      "suggested_scalar": 0.0093,
+      "log_bad": 4.6347,
+      "log_good": 4.6444
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4484.1424,
+      "good": 4323.6833,
+      "ratio": 0.9642,
+      "suggested_scalar": -0.035,
+      "log_bad": 8.4083,
+      "log_good": 8.3719
+    },
+    "readability.mean_total_lines": {
+      "bad": 54.0,
+      "good": 51.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.055,
+      "log_bad": 3.989,
+      "log_good": 3.9318
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 4.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.39,
+      "log_bad": 1.7918,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2610.9563,
+      "good": 2589.5857,
+      "ratio": 0.9918,
+      "suggested_scalar": -0.0079,
+      "log_bad": 7.8675,
+      "log_good": 7.8593
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 534.0,
+      "good": 512.0,
+      "ratio": 0.9588,
+      "suggested_scalar": -0.0405,
+      "log_bad": 6.2804,
+      "log_good": 6.2383
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 28.9074,
+      "good": 29.2549,
+      "ratio": 1.012,
+      "suggested_scalar": 0.0115,
+      "log_bad": 3.3641,
+      "log_good": 3.376
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.25,
+      "good": 1.2333,
+      "ratio": 0.9866,
+      "suggested_scalar": -0.0129,
+      "log_bad": 0.2231,
+      "log_good": 0.2097
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.2146,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6098,
+      "good": 0.5953,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0231,
+      "log_bad": -0.4946,
+      "log_good": -0.5187
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9541,
+      "good": 0.9536,
+      "ratio": 0.9995,
+      "suggested_scalar": -0.0005,
+      "log_bad": -0.047,
+      "log_good": -0.0475
+    },
+    "halstead.mean_length": {
+      "bad": 413.0,
+      "good": 412.0,
+      "ratio": 0.9976,
+      "suggested_scalar": -0.0023,
+      "log_bad": 6.0234,
+      "log_good": 6.021
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.3923,
+      "good": 6.3576,
+      "ratio": 0.9946,
+      "suggested_scalar": -0.0052,
+      "log_bad": 1.8551,
+      "log_good": 1.8497
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1571,
+      "good": 0.1613,
+      "ratio": 1.0267,
+      "suggested_scalar": 0.0254,
+      "log_bad": -1.8509,
+      "log_good": -1.8245
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 30.9138,
+      "good": 30.0536,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.0271,
+      "log_bad": 3.4312,
+      "log_good": 3.403
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 46.0,
+      "good": 45.0,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.0211,
+      "log_bad": 3.8286,
+      "log_good": 3.8067
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5243,
+      "good": 0.5,
+      "ratio": 0.9537,
+      "suggested_scalar": -0.0456,
+      "log_bad": -0.6457,
+      "log_good": -0.6931
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 54.0,
+      "good": 51.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.055,
+      "log_bad": 3.989,
+      "log_good": 3.9318
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "consistency.consistent_casing_within_file": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 55.0,
+      "good": 1.0,
+      "ratio": 0.0182,
+      "suggested_scalar": -2.0,
+      "log_bad": 4.0073,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 29.0,
+      "good": 29.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3673,
+      "log_good": 3.3673
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0049,
+      "good": 0.0049,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.3185,
+      "log_good": -5.3185
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.4444,
+      "good": 2.4444,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.8938,
+      "log_good": 0.8938
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8636,
+      "good": 0.8636,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1466,
+      "log_good": -0.1466
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0049,
+      "good": 0.0049,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -5.3185,
+      "log_good": -5.3185
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5551,
+      "good": 4.4419,
+      "ratio": 0.9751,
+      "suggested_scalar": -0.0126,
+      "log_bad": 1.5162,
+      "log_good": 1.4911
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 103.0,
+      "good": 94.0,
+      "ratio": 0.9126,
+      "suggested_scalar": -0.0456,
+      "log_bad": 4.6347,
+      "log_good": 4.5433
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5378,
+      "good": 0.4694,
+      "ratio": 0.8728,
+      "suggested_scalar": -0.0679,
+      "log_bad": -0.6203,
+      "log_good": -0.7563
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6219,
+      "good": 0.5937,
+      "ratio": 0.9547,
+      "suggested_scalar": -0.0232,
+      "log_bad": -0.475,
+      "log_good": -0.5214
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.0909,
+      "good": 4.0909,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.4088,
+      "log_good": 1.4088
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 411.0,
+      "good": 411.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.0186,
+      "log_good": 6.0186
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9137,
+      "good": 0.9636,
+      "ratio": 1.0546,
+      "suggested_scalar": 0.0265,
+      "log_bad": -0.0903,
+      "log_good": -0.0371
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 149.0,
+      "good": 149.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.0039,
+      "log_good": 5.0039
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 73.8207,
+      "good": 73.8207,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3016,
+      "log_good": 4.3016
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4878,
+      "good": 0.5146,
+      "ratio": 1.0549,
+      "suggested_scalar": 0.0267,
+      "log_bad": -0.7178,
+      "log_good": -0.6644
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.0423,
+      "good": 9.4998,
+      "ratio": 1.0506,
+      "suggested_scalar": 0.0246,
+      "log_bad": 2.2019,
+      "log_good": 2.2513
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2086.0,
+      "good": 2177.0,
+      "ratio": 1.0436,
+      "suggested_scalar": 0.0213,
+      "log_bad": 7.643,
+      "log_good": 7.6857
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0303,
+      "good": 0.0303,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.4966,
+      "log_good": -3.4966
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8182,
+      "good": 0.8182,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2006,
+      "log_good": -0.2006
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.2273,
+      "good": 6.2273,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8289,
+      "log_good": 1.8289
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.5675,
+      "good": 3.5675,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.2719,
+      "log_good": 1.2719
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 75.0,
+      "good": 130.0,
+      "ratio": 1.7333,
+      "suggested_scalar": 0.2745,
+      "log_bad": 4.3175,
+      "log_good": 4.8675
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9535,
+      "good": 0.9539,
+      "ratio": 1.0004,
+      "suggested_scalar": 0.0002,
+      "log_bad": -0.0476,
+      "log_good": -0.0472
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6357,
+      "good": 0.6642,
+      "ratio": 1.0448,
+      "suggested_scalar": 0.0219,
+      "log_bad": -0.453,
+      "log_good": -0.4092
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2298,
+      "good": 0.2738,
+      "ratio": 1.1915,
+      "suggested_scalar": 0.0874,
+      "log_bad": -1.4705,
+      "log_good": -1.2954
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7447,
+      "good": 2.9781,
+      "ratio": 1.085,
+      "suggested_scalar": 0.0407,
+      "log_bad": 1.0097,
+      "log_good": 1.0913
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 409.0,
+      "good": 409.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.0137,
+      "log_good": 6.0137
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0219,
+      "good": 0.0219,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -3.8213,
+      "log_good": -3.8213
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.7549,
+      "ratio": 0.9665,
+      "suggested_scalar": -0.017,
+      "log_bad": 1.7841,
+      "log_good": 1.7501
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.5028,
+      "good": 0.6453,
+      "ratio": 0.4294,
+      "suggested_scalar": -0.4219,
+      "log_bad": 0.4073,
+      "log_good": -0.438
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8566,
+      "good": 5.7519,
+      "ratio": 0.9821,
+      "suggested_scalar": -0.009,
+      "log_bad": 1.7676,
+      "log_good": 1.7495
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.765,
+      "good": 0.7718,
+      "ratio": 1.0089,
+      "suggested_scalar": 0.0044,
+      "log_bad": -0.2679,
+      "log_good": -0.259
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1538,
+      "good": 0.1538,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.8721,
+      "log_good": -1.8721
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.007,
+      "good": 3.0822,
+      "ratio": 1.025,
+      "suggested_scalar": 0.0123,
+      "log_bad": 1.1009,
+      "log_good": 1.1256
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 355.0,
+      "good": 343.0,
+      "ratio": 0.9662,
+      "suggested_scalar": -0.0172,
+      "log_bad": 5.8721,
+      "log_good": 5.8377
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8603,
+      "good": 0.8434,
+      "ratio": 0.9804,
+      "suggested_scalar": -0.0099,
+      "log_bad": -0.1505,
+      "log_good": -0.1703
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 111.0,
+      "good": 101.0,
+      "ratio": 0.9099,
+      "suggested_scalar": -0.0471,
+      "log_bad": 4.7095,
+      "log_good": 4.6151
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1228.0,
+      "good": 1315.0,
+      "ratio": 1.0708,
+      "suggested_scalar": 0.0342,
+      "log_bad": 7.1131,
+      "log_good": 7.1816
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 153.0,
+      "good": 153.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.0304,
+      "log_good": 5.0304
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0097,
+      "good": 0.0097,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -4.6356,
+      "log_good": -4.6356
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.3017,
+      "good": 0.3017,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.1983,
+      "log_good": -1.1983
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 74.0,
+      "good": 74.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.3041,
+      "log_good": 4.3041
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 111.0,
+      "good": 101.0,
+      "ratio": 0.9099,
+      "suggested_scalar": -0.0471,
+      "log_bad": 4.7095,
+      "log_good": 4.6151
+    },
+    "brevity.mean_sample_size": {
+      "bad": 111.0,
+      "good": 101.0,
+      "ratio": 0.9099,
+      "suggested_scalar": -0.0471,
+      "log_bad": 4.7095,
+      "log_good": 4.6151
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 411.0,
+      "good": 411.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.0186,
+      "log_good": 6.0186
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 204.0,
+      "good": 204.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.3181,
+      "log_good": 5.3181
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 284.0,
+      "good": 273.0,
+      "ratio": 0.9613,
+      "suggested_scalar": -0.0197,
+      "log_bad": 5.649,
+      "log_good": 5.6095
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0024,
+      "good": 0.0024,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -6.0323,
+      "log_good": -6.0323
+    },
+    "heaps.mean_k": {
+      "bad": 2.6588,
+      "good": 2.7971,
+      "ratio": 1.052,
+      "suggested_scalar": 0.0253,
+      "log_bad": 0.9779,
+      "log_good": 1.0286
+    },
+    "halstead.mean_effort": {
+      "bad": 70145.1737,
+      "good": 77997.9442,
+      "ratio": 1.112,
+      "suggested_scalar": 0.053,
+      "log_bad": 11.1583,
+      "log_good": 11.2644
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.862,
+      "good": 0.8639,
+      "ratio": 1.0022,
+      "suggested_scalar": 0.0011,
+      "log_bad": -0.1485,
+      "log_good": -0.1463
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 76.0,
+      "good": 67.0,
+      "ratio": 0.8816,
+      "suggested_scalar": -0.0629,
+      "log_bad": 4.3307,
+      "log_good": 4.2047
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 233.0,
+      "good": 233.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.451,
+      "log_good": 5.451
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5034,
+      "good": 0.4362,
+      "ratio": 0.8665,
+      "suggested_scalar": -0.0715,
+      "log_bad": -0.6864,
+      "log_good": -0.8297
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.2416,
+      "good": 8.8255,
+      "ratio": 1.0708,
+      "suggested_scalar": 0.0342,
+      "log_bad": 2.1092,
+      "log_good": 2.1776
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1538,
+      "good": 0.1538,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.8721,
+      "log_good": -1.8721
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.2714,
+      "good": 3.2714,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.1852,
+      "log_good": 1.1852
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 410.0,
+      "good": 410.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 6.0162,
+      "log_good": 6.0162
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 40.0,
+      "good": 46.0,
+      "ratio": 1.15,
+      "suggested_scalar": 0.0698,
+      "log_bad": 3.6889,
+      "log_good": 3.8286
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3896.9541,
+      "good": 4333.2191,
+      "ratio": 1.112,
+      "suggested_scalar": 0.053,
+      "log_bad": 8.268,
+      "log_good": 8.3741
+    },
+    "readability.mean_total_lines": {
+      "bad": 66.0,
+      "good": 66.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.1897,
+      "log_good": 4.1897
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 2580.9892,
+      "good": 2530.0713,
+      "ratio": 0.9803,
+      "suggested_scalar": -0.0099,
+      "log_bad": 7.8559,
+      "log_good": 7.836
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 760.0,
+      "good": 731.0,
+      "ratio": 0.9618,
+      "suggested_scalar": -0.0194,
+      "log_bad": 6.6333,
+      "log_good": 6.5944
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.4242,
+      "good": 31.803,
+      "ratio": 1.0453,
+      "suggested_scalar": 0.0221,
+      "log_bad": 3.4152,
+      "log_good": 3.4596
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.4976,
+      "good": 1.4976,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.4039,
+      "log_good": 0.4039
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8873,
+      "good": 0.8659,
+      "ratio": 0.9759,
+      "suggested_scalar": -0.0122,
+      "log_bad": -0.1196,
+      "log_good": -0.144
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9931,
+      "good": 0.9881,
+      "ratio": 0.995,
+      "suggested_scalar": -0.0025,
+      "log_bad": -0.0069,
+      "log_good": -0.012
+    },
+    "halstead.mean_length": {
+      "bad": 386.0,
+      "good": 386.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.9558,
+      "log_good": 5.9558
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 8.3333,
+      "good": 8.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1203,
+      "log_good": 2.1203
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7944,
+      "good": 6.6582,
+      "ratio": 0.98,
+      "suggested_scalar": -0.0101,
+      "log_bad": 1.9161,
+      "log_good": 1.8958
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0978,
+      "good": 0.0937,
+      "ratio": 0.9581,
+      "suggested_scalar": -0.0214,
+      "log_bad": -2.3248,
+      "log_good": -2.3677
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.1776,
+      "good": 30.8284,
+      "ratio": 1.1343,
+      "suggested_scalar": 0.0629,
+      "log_bad": 3.3024,
+      "log_good": 3.4284
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 75.0,
+      "good": 65.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.0714,
+      "log_bad": 4.3175,
+      "log_good": 4.1744
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7394,
+      "good": 0.7289,
+      "ratio": 0.9858,
+      "suggested_scalar": -0.0071,
+      "log_bad": -0.3019,
+      "log_good": -0.3162
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 66.0,
+      "good": 66.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.1897,
+      "log_good": 4.1897
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_with_statement": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 35.0,
+      "good": 37.0,
+      "ratio": 1.0571,
+      "suggested_scalar": 0.0357,
+      "log_bad": 3.5553,
+      "log_good": 3.6109
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0221,
+      "good": 0.0217,
+      "ratio": 0.9819,
+      "suggested_scalar": -0.0117,
+      "log_bad": -3.8122,
+      "log_good": -3.8304
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.2,
+      "good": 1.2,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.1823,
+      "log_good": 0.1823
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8444,
+      "good": 0.8537,
+      "ratio": 1.011,
+      "suggested_scalar": 0.007,
+      "log_bad": -0.1691,
+      "log_good": -0.1582
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0221,
+      "good": 0.0217,
+      "ratio": 0.9819,
+      "suggested_scalar": -0.0117,
+      "log_bad": -3.8122,
+      "log_good": -3.8304
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7906,
+      "good": 4.8155,
+      "ratio": 1.0052,
+      "suggested_scalar": 0.0033,
+      "log_bad": 1.5667,
+      "log_good": 1.5718
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 81.0,
+      "good": 80.0,
+      "ratio": 0.9877,
+      "suggested_scalar": -0.008,
+      "log_bad": 4.3944,
+      "log_good": 4.382
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5106,
+      "good": 0.4708,
+      "ratio": 0.9221,
+      "suggested_scalar": -0.0521,
+      "log_bad": -0.6722,
+      "log_good": -0.7533
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5989,
+      "good": 0.5814,
+      "ratio": 0.9708,
+      "suggested_scalar": -0.019,
+      "log_bad": -0.5127,
+      "log_good": -0.5423
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.0222,
+      "good": 2.1463,
+      "ratio": 0.7102,
+      "suggested_scalar": -0.2198,
+      "log_bad": 1.106,
+      "log_good": 0.7637
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 362.0,
+      "good": 369.0,
+      "ratio": 1.0193,
+      "suggested_scalar": 0.0123,
+      "log_bad": 5.8916,
+      "log_good": 5.9108
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1171,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0039,
+      "good": 1.0396,
+      "ratio": 1.0356,
+      "suggested_scalar": 0.0224,
+      "log_bad": 0.0039,
+      "log_good": 0.0388
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 115.0,
+      "good": 125.0,
+      "ratio": 1.087,
+      "suggested_scalar": 0.0535,
+      "log_bad": 4.7449,
+      "log_good": 4.8283
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 85.2699,
+      "good": 84.7107,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0042,
+      "log_bad": 4.4458,
+      "log_good": 4.4392
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5596,
+      "good": 0.5571,
+      "ratio": 0.9955,
+      "suggested_scalar": -0.0029,
+      "log_bad": -0.5805,
+      "log_good": -0.585
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 16.6317,
+      "good": 16.2624,
+      "ratio": 0.9778,
+      "suggested_scalar": -0.0144,
+      "log_bad": 2.8113,
+      "log_good": 2.7889
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1518.0,
+      "good": 1508.0,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0042,
+      "log_bad": 7.3251,
+      "log_good": 7.3185
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0444,
+      "good": 1.0,
+      "ratio": 22.5225,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.1145,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8222,
+      "good": 0.8537,
+      "ratio": 1.0383,
+      "suggested_scalar": 0.0241,
+      "log_bad": -0.1958,
+      "log_good": -0.1582
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.0444,
+      "good": 9.0,
+      "ratio": 1.1188,
+      "suggested_scalar": 0.0721,
+      "log_bad": 2.085,
+      "log_good": 2.1972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 4.9106,
+      "good": 2.4176,
+      "ratio": 0.4923,
+      "suggested_scalar": -0.455,
+      "log_bad": 1.5914,
+      "log_good": 0.8828
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 70.0,
+      "good": 78.0,
+      "ratio": 1.1143,
+      "suggested_scalar": 0.0695,
+      "log_bad": 4.2485,
+      "log_good": 4.3567
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9472,
+      "good": 0.9459,
+      "ratio": 0.9986,
+      "suggested_scalar": -0.0009,
+      "log_bad": -0.0542,
+      "log_good": -0.0556
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 20.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0313,
+      "log_bad": 3.0445,
+      "log_good": 2.9957
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5962,
+      "good": 0.6041,
+      "ratio": 1.0133,
+      "suggested_scalar": 0.0085,
+      "log_bad": -0.5172,
+      "log_good": -0.504
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2833,
+      "good": 0.297,
+      "ratio": 1.0484,
+      "suggested_scalar": 0.0303,
+      "log_bad": -1.2612,
+      "log_good": -1.214
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4763,
+      "good": 2.526,
+      "ratio": 1.0201,
+      "suggested_scalar": 0.0128,
+      "log_bad": 0.9068,
+      "log_good": 0.9266
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 360.0,
+      "good": 367.0,
+      "ratio": 1.0194,
+      "suggested_scalar": 0.0124,
+      "log_bad": 5.8861,
+      "log_good": 5.9054
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 18.0,
+      "good": 16.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0756,
+      "log_bad": 2.8904,
+      "log_good": 2.7726
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0359,
+      "good": 0.0379,
+      "ratio": 1.0557,
+      "suggested_scalar": 0.0348,
+      "log_bad": -3.327,
+      "log_good": -3.2728
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.858,
+      "good": 5.858,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7678,
+      "log_good": 1.7678
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2647,
+      "good": 1.2359,
+      "ratio": 0.9772,
+      "suggested_scalar": -0.0148,
+      "log_bad": 0.2348,
+      "log_good": 0.2118
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4613,
+      "good": 5.4151,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0055,
+      "log_bad": 1.6977,
+      "log_good": 1.6892
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8178,
+      "good": 0.822,
+      "ratio": 1.0051,
+      "suggested_scalar": 0.0033,
+      "log_bad": -0.2011,
+      "log_good": -0.196
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1667,
+      "good": 0.1633,
+      "ratio": 0.9796,
+      "suggested_scalar": -0.0132,
+      "log_bad": -1.7916,
+      "log_good": -1.8122
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.0782,
+      "good": 4.0327,
+      "ratio": 0.9888,
+      "suggested_scalar": -0.0072,
+      "log_bad": 1.4057,
+      "log_good": 1.3944
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.7055,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 305.0,
+      "good": 306.0,
+      "ratio": 1.0033,
+      "suggested_scalar": 0.0021,
+      "log_bad": 5.7203,
+      "log_good": 5.7236
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7101,
+      "good": 0.7228,
+      "ratio": 1.0179,
+      "suggested_scalar": 0.0114,
+      "log_bad": -0.3423,
+      "log_good": -0.3246
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 83.0,
+      "good": 82.0,
+      "ratio": 0.988,
+      "suggested_scalar": -0.0078,
+      "log_bad": 4.4188,
+      "log_good": 4.4067
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 859.0,
+      "good": 920.0,
+      "ratio": 1.071,
+      "suggested_scalar": 0.0441,
+      "log_bad": 6.7558,
+      "log_good": 6.8244
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 128.0,
+      "good": 136.0,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.0389,
+      "log_bad": 4.852,
+      "log_good": 4.9127
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0055,
+      "good": 0.0054,
+      "ratio": 0.9818,
+      "suggested_scalar": -0.0118,
+      "log_bad": -5.203,
+      "log_good": -5.2214
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2762,
+      "good": 0.3008,
+      "ratio": 1.0891,
+      "suggested_scalar": 0.0548,
+      "log_bad": -1.2866,
+      "log_good": -1.2013
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 74.0,
+      "good": 72.0,
+      "ratio": 0.973,
+      "suggested_scalar": -0.0176,
+      "log_bad": 4.3041,
+      "log_good": 4.2767
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 83.0,
+      "good": 82.0,
+      "ratio": 0.988,
+      "suggested_scalar": -0.0078,
+      "log_bad": 4.4188,
+      "log_good": 4.4067
+    },
+    "brevity.mean_sample_size": {
+      "bad": 83.0,
+      "good": 82.0,
+      "ratio": 0.988,
+      "suggested_scalar": -0.0078,
+      "log_bad": 4.4188,
+      "log_good": 4.4067
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 362.0,
+      "good": 369.0,
+      "ratio": 1.0193,
+      "suggested_scalar": 0.0123,
+      "log_bad": 5.8916,
+      "log_good": 5.9108
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 215.0,
+      "good": 216.0,
+      "ratio": 1.0047,
+      "suggested_scalar": 0.003,
+      "log_bad": 5.3706,
+      "log_good": 5.3753
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 233.0,
+      "good": 235.0,
+      "ratio": 1.0086,
+      "suggested_scalar": 0.0055,
+      "log_bad": 5.451,
+      "log_good": 5.4596
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0083,
+      "good": 0.0027,
+      "ratio": 0.3253,
+      "suggested_scalar": -0.7211,
+      "log_bad": -4.7915,
+      "log_good": -5.9145
+    },
+    "heaps.mean_k": {
+      "bad": 2.4702,
+      "good": 2.6058,
+      "ratio": 1.0549,
+      "suggested_scalar": 0.0343,
+      "log_bad": 0.9043,
+      "log_good": 0.9577
+    },
+    "halstead.mean_effort": {
+      "bad": 47716.2471,
+      "good": 49150.8836,
+      "ratio": 1.0301,
+      "suggested_scalar": 0.019,
+      "log_bad": 10.773,
+      "log_good": 10.8027
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8567,
+      "good": 0.8518,
+      "ratio": 0.9943,
+      "suggested_scalar": -0.0037,
+      "log_bad": -0.1547,
+      "log_good": -0.1604
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 60.0,
+      "good": 60.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0943,
+      "log_good": 4.0943
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 208.0,
+      "good": 207.0,
+      "ratio": 0.9952,
+      "suggested_scalar": -0.0031,
+      "log_bad": 5.3375,
+      "log_good": 5.3327
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4783,
+      "good": 0.44,
+      "ratio": 0.9199,
+      "suggested_scalar": -0.0536,
+      "log_bad": -0.7375,
+      "log_good": -0.821
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.4696,
+      "good": 7.36,
+      "ratio": 0.9853,
+      "suggested_scalar": -0.0095,
+      "log_bad": 2.0108,
+      "log_good": 1.9961
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1667,
+      "good": 0.1633,
+      "ratio": 0.9796,
+      "suggested_scalar": -0.0132,
+      "log_bad": -1.7916,
+      "log_good": -1.8122
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.3383,
+      "good": 6.553,
+      "ratio": 1.0339,
+      "suggested_scalar": 0.0214,
+      "log_bad": 1.8466,
+      "log_good": 1.8799
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 361.0,
+      "good": 368.0,
+      "ratio": 1.0194,
+      "suggested_scalar": 0.0123,
+      "log_bad": 5.8889,
+      "log_good": 5.9081
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 47.0,
+      "good": 48.0,
+      "ratio": 1.0213,
+      "suggested_scalar": 0.0135,
+      "log_bad": 3.8501,
+      "log_good": 3.8712
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2650.9026,
+      "good": 2730.6046,
+      "ratio": 1.0301,
+      "suggested_scalar": 0.019,
+      "log_bad": 7.8827,
+      "log_good": 7.9123
+    },
+    "readability.mean_total_lines": {
+      "bad": 45.0,
+      "good": 41.0,
+      "ratio": 0.9111,
+      "suggested_scalar": -0.0598,
+      "log_bad": 3.8067,
+      "log_good": 3.7136
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 4.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.2604,
+      "log_bad": 1.7918,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2130.1896,
+      "good": 2168.4213,
+      "ratio": 1.0179,
+      "suggested_scalar": 0.0114,
+      "log_bad": 7.664,
+      "log_good": 7.6818
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 613.0,
+      "good": 597.0,
+      "ratio": 0.9739,
+      "suggested_scalar": -0.017,
+      "log_bad": 6.4184,
+      "log_good": 6.3919
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.5333,
+      "good": 35.5854,
+      "ratio": 1.0938,
+      "suggested_scalar": 0.0576,
+      "log_bad": 3.4823,
+      "log_good": 3.5719
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3404,
+      "good": 1.3356,
+      "ratio": 0.9964,
+      "suggested_scalar": -0.0023,
+      "log_bad": 0.293,
+      "log_good": 0.2894
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1171,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 22.0,
+      "good": 32.0,
+      "ratio": 1.4545,
+      "suggested_scalar": 0.2406,
+      "log_bad": 3.091,
+      "log_good": 3.4657
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8459,
+      "good": 0.8431,
+      "ratio": 0.9967,
+      "suggested_scalar": -0.0021,
+      "log_bad": -0.1674,
+      "log_good": -0.1707
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9887,
+      "good": 0.9889,
+      "ratio": 1.0002,
+      "suggested_scalar": 0.0001,
+      "log_bad": -0.0114,
+      "log_good": -0.0112
+    },
+    "halstead.mean_length": {
+      "bad": 336.0,
+      "good": 343.0,
+      "ratio": 1.0208,
+      "suggested_scalar": 0.0132,
+      "log_bad": 5.8171,
+      "log_good": 5.8377
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.8,
+      "good": 9.8,
+      "ratio": 0.9074,
+      "suggested_scalar": -0.0624,
+      "log_bad": 2.3795,
+      "log_good": 2.2824
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.375,
+      "good": 6.3576,
+      "ratio": 0.9973,
+      "suggested_scalar": -0.0018,
+      "log_bad": 1.8524,
+      "log_good": 1.8497
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1416,
+      "good": 0.1432,
+      "ratio": 1.0113,
+      "suggested_scalar": 0.0072,
+      "log_bad": -1.9547,
+      "log_good": -1.9435
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 22.4,
+      "good": 22.6667,
+      "ratio": 1.0119,
+      "suggested_scalar": 0.0076,
+      "log_bad": 3.1091,
+      "log_good": 3.1209
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.4451,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 55.0,
+      "good": 55.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0073,
+      "log_good": 4.0073
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6824,
+      "good": 0.6936,
+      "ratio": 1.0164,
+      "suggested_scalar": 0.0105,
+      "log_bad": -0.3821,
+      "log_good": -0.3659
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 45.0,
+      "good": 41.0,
+      "ratio": 0.9111,
+      "suggested_scalar": -0.0598,
+      "log_bad": 3.8067,
+      "log_good": 3.7136
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.return_values_over_output_parameters": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 32.0,
+      "good": 9.0,
+      "ratio": 0.2813,
+      "suggested_scalar": -2.0,
+      "log_bad": 3.4657,
+      "log_good": 2.1972
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 10.0,
+      "good": 11.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.1503,
+      "log_bad": 2.3026,
+      "log_good": 2.3979
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0039,
+      "good": 0.0045,
+      "ratio": 1.1538,
+      "suggested_scalar": 0.2256,
+      "log_bad": -5.5468,
+      "log_good": -5.4037
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7794,
+      "good": 0.8966,
+      "ratio": 1.1504,
+      "suggested_scalar": 0.2209,
+      "log_bad": -0.2492,
+      "log_good": -0.1091
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0058,
+      "good": 0.0067,
+      "ratio": 1.1552,
+      "suggested_scalar": 0.2274,
+      "log_bad": -5.1499,
+      "log_good": -5.0056
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5139,
+      "good": 4.6645,
+      "ratio": 1.0334,
+      "suggested_scalar": 0.0517,
+      "log_bad": 1.5072,
+      "log_good": 1.54
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 106.0,
+      "good": 97.0,
+      "ratio": 0.9151,
+      "suggested_scalar": -0.1399,
+      "log_bad": 4.6634,
+      "log_good": 4.5747
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4944,
+      "good": 0.4859,
+      "ratio": 0.9828,
+      "suggested_scalar": -0.0273,
+      "log_bad": -0.7044,
+      "log_good": -0.7218
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 20.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0809,
+      "log_bad": 2.9444,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6964,
+      "good": 0.7733,
+      "ratio": 1.1104,
+      "suggested_scalar": 0.1651,
+      "log_bad": -0.3618,
+      "log_good": -0.2571
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.8382,
+      "good": 3.3103,
+      "ratio": 0.6842,
+      "suggested_scalar": -0.5983,
+      "log_bad": 1.5765,
+      "log_good": 1.197
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 513.0,
+      "good": 447.0,
+      "ratio": 0.8713,
+      "suggested_scalar": -0.2171,
+      "log_bad": 6.2403,
+      "log_good": 6.1026
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1029,
+      "good": 0.1552,
+      "ratio": 1.5083,
+      "suggested_scalar": 0.6479,
+      "log_bad": -2.274,
+      "log_good": -1.863
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9615,
+      "good": 1.0027,
+      "ratio": 1.0428,
+      "suggested_scalar": 0.0662,
+      "log_bad": -0.0393,
+      "log_good": 0.0027
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 179.0,
+      "good": 143.0,
+      "ratio": 0.7989,
+      "suggested_scalar": -0.354,
+      "log_bad": 5.1874,
+      "log_good": 4.9628
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 97.4386,
+      "good": 102.8391,
+      "ratio": 1.0554,
+      "suggested_scalar": 0.085,
+      "log_bad": 4.5792,
+      "log_good": 4.6332
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6563,
+      "good": 0.6211,
+      "ratio": 0.9464,
+      "suggested_scalar": -0.0869,
+      "log_bad": -0.4211,
+      "log_good": -0.4763
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.4267,
+      "good": 8.4799,
+      "ratio": 1.1418,
+      "suggested_scalar": 0.2091,
+      "log_bad": 2.0051,
+      "log_good": 2.1377
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2278.0,
+      "good": 1767.0,
+      "ratio": 0.7757,
+      "suggested_scalar": -0.4005,
+      "log_bad": 7.7311,
+      "log_good": 7.477
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1324,
+      "good": 0.1207,
+      "ratio": 0.9116,
+      "suggested_scalar": -0.1459,
+      "log_bad": -2.0219,
+      "log_good": -2.1144
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7647,
+      "good": 0.8621,
+      "ratio": 1.1274,
+      "suggested_scalar": 0.189,
+      "log_bad": -0.2683,
+      "log_good": -0.1484
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.8923,
+      "good": 8.434,
+      "ratio": 1.0686,
+      "suggested_scalar": 0.1047,
+      "log_bad": 2.0659,
+      "log_good": 2.1323
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 26.2238,
+      "good": 10.0071,
+      "ratio": 0.3816,
+      "suggested_scalar": -1.5189,
+      "log_bad": 3.2667,
+      "log_good": 2.3033
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 134.0,
+      "good": 118.0,
+      "ratio": 0.8806,
+      "suggested_scalar": -0.2005,
+      "log_bad": 4.8978,
+      "log_good": 4.7707
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.945,
+      "good": 0.9566,
+      "ratio": 1.0123,
+      "suggested_scalar": 0.0192,
+      "log_bad": -0.0566,
+      "log_good": -0.0444
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 25.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0618,
+      "log_bad": 3.2581,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6594,
+      "good": 0.6146,
+      "ratio": 0.9321,
+      "suggested_scalar": -0.1109,
+      "log_bad": -0.4164,
+      "log_good": -0.4868
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4521,
+      "good": 0.4202,
+      "ratio": 0.9294,
+      "suggested_scalar": -0.1154,
+      "log_bad": -0.7939,
+      "log_good": -0.867
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9356,
+      "good": 2.5947,
+      "ratio": 0.8839,
+      "suggested_scalar": -0.1946,
+      "log_bad": 1.0769,
+      "log_good": 0.9535
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 511.0,
+      "good": 445.0,
+      "ratio": 0.8708,
+      "suggested_scalar": -0.218,
+      "log_bad": 6.2364,
+      "log_good": 6.0981
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.037,
+      "good": 0.0515,
+      "ratio": 1.3919,
+      "suggested_scalar": 0.5213,
+      "log_bad": -3.2968,
+      "log_good": -2.9662
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 5.858,
+      "ratio": 0.9877,
+      "suggested_scalar": -0.0194,
+      "log_bad": 1.7801,
+      "log_good": 1.7678
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 13.0,
+      "good": 16.0,
+      "ratio": 1.2308,
+      "suggested_scalar": 0.3274,
+      "log_bad": 2.5649,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.0315,
+      "good": 0.8334,
+      "ratio": 0.8079,
+      "suggested_scalar": -0.3362,
+      "log_bad": 0.031,
+      "log_good": -0.1822
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.903,
+      "good": 5.7139,
+      "ratio": 0.968,
+      "suggested_scalar": -0.0513,
+      "log_bad": 1.7755,
+      "log_good": 1.7429
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7611,
+      "good": 0.7963,
+      "ratio": 1.0462,
+      "suggested_scalar": 0.0713,
+      "log_bad": -0.273,
+      "log_good": -0.2278
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1053,
+      "good": 0.1471,
+      "ratio": 1.397,
+      "suggested_scalar": 0.5271,
+      "log_bad": -2.2509,
+      "log_good": -1.9166
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.7252,
+      "good": 2.912,
+      "ratio": 1.0685,
+      "suggested_scalar": 0.1045,
+      "log_bad": 1.0025,
+      "log_good": 1.0688
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 364.0,
+      "good": 322.0,
+      "ratio": 0.8846,
+      "suggested_scalar": -0.1933,
+      "log_bad": 5.8972,
+      "log_good": 5.7746
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 12.0,
+      "good": 18.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.6393,
+      "log_bad": 2.4849,
+      "log_good": 2.8904
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.1034,
+      "good": 0.9306,
+      "ratio": 0.8434,
+      "suggested_scalar": -0.2685,
+      "log_bad": 0.0984,
+      "log_good": -0.0719
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 100.0,
+      "ratio": 0.9346,
+      "suggested_scalar": -0.1067,
+      "log_bad": 4.6728,
+      "log_good": 4.6052
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1057.0,
+      "good": 844.0,
+      "ratio": 0.7985,
+      "suggested_scalar": -0.3548,
+      "log_bad": 6.9632,
+      "log_good": 6.7382
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 224.0,
+      "good": 180.0,
+      "ratio": 0.8036,
+      "suggested_scalar": -0.3448,
+      "log_bad": 5.4116,
+      "log_good": 5.193
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2359,
+      "good": 0.2438,
+      "ratio": 1.0335,
+      "suggested_scalar": 0.0519,
+      "log_bad": -1.4443,
+      "log_good": -1.4114
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 101.0,
+      "good": 78.0,
+      "ratio": 0.7723,
+      "suggested_scalar": -0.4074,
+      "log_bad": 4.6151,
+      "log_good": 4.3567
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 100.0,
+      "ratio": 0.9346,
+      "suggested_scalar": -0.1067,
+      "log_bad": 4.6728,
+      "log_good": 4.6052
+    },
+    "brevity.mean_sample_size": {
+      "bad": 107.0,
+      "good": 100.0,
+      "ratio": 0.9346,
+      "suggested_scalar": -0.1067,
+      "log_bad": 4.6728,
+      "log_good": 4.6052
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 513.0,
+      "good": 447.0,
+      "ratio": 0.8713,
+      "suggested_scalar": -0.2171,
+      "log_bad": 6.2403,
+      "log_good": 6.1026
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 257.0,
+      "good": 240.0,
+      "ratio": 0.9339,
+      "suggested_scalar": -0.1079,
+      "log_bad": 5.5491,
+      "log_good": 5.4806
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 277.0,
+      "good": 247.0,
+      "ratio": 0.8917,
+      "suggested_scalar": -0.1807,
+      "log_bad": 5.624,
+      "log_good": 5.5094
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.6413,
+      "good": 1.0155,
+      "ratio": 0.6187,
+      "suggested_scalar": -0.757,
+      "log_bad": 0.4955,
+      "log_good": 0.0154
+    },
+    "halstead.mean_effort": {
+      "bad": 120488.9818,
+      "good": 87242.5979,
+      "ratio": 0.7241,
+      "suggested_scalar": -0.509,
+      "log_bad": 11.6993,
+      "log_good": 11.3764
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8756,
+      "good": 0.86,
+      "ratio": 0.9822,
+      "suggested_scalar": -0.0283,
+      "log_bad": -0.1328,
+      "log_good": -0.1508
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 80.0,
+      "good": 72.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.1661,
+      "log_bad": 4.382,
+      "log_good": 4.2767
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 268.0,
+      "good": 243.0,
+      "ratio": 0.9067,
+      "suggested_scalar": -0.1544,
+      "log_bad": 5.591,
+      "log_good": 5.4931
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3575,
+      "good": 0.4056,
+      "ratio": 1.1345,
+      "suggested_scalar": 0.199,
+      "log_bad": -1.0286,
+      "log_good": -0.9024
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.905,
+      "good": 5.9021,
+      "ratio": 0.9995,
+      "suggested_scalar": -0.0008,
+      "log_bad": 1.7758,
+      "log_good": 1.7753
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1053,
+      "good": 0.1471,
+      "ratio": 1.397,
+      "suggested_scalar": 0.5271,
+      "log_bad": -2.2509,
+      "log_good": -1.9166
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.9506,
+      "good": 3.5706,
+      "ratio": 0.9038,
+      "suggested_scalar": -0.1595,
+      "log_bad": 1.3739,
+      "log_good": 1.2727
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 512.0,
+      "good": 446.0,
+      "ratio": 0.8711,
+      "suggested_scalar": -0.2176,
+      "log_bad": 6.2383,
+      "log_good": 6.1003
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 84.0,
+      "good": 64.0,
+      "ratio": 0.7619,
+      "suggested_scalar": -0.4287,
+      "log_bad": 4.4308,
+      "log_good": 4.1589
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6693.8323,
+      "good": 4846.811,
+      "ratio": 0.7241,
+      "suggested_scalar": -0.509,
+      "log_bad": 8.8089,
+      "log_good": 8.4861
+    },
+    "readability.mean_total_lines": {
+      "bad": 65.0,
+      "good": 53.0,
+      "ratio": 0.8154,
+      "suggested_scalar": -0.3218,
+      "log_bad": 4.1744,
+      "log_good": 3.9703
+    },
+    "indentation.mean_max_depth": {
+      "bad": 19.0,
+      "good": 12.0,
+      "ratio": 0.6316,
+      "suggested_scalar": -0.7245,
+      "log_bad": 2.9444,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 3310.1369,
+      "good": 2791.7631,
+      "ratio": 0.8434,
+      "suggested_scalar": -0.2685,
+      "log_bad": 8.1047,
+      "log_good": 7.9344
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 776.0,
+      "good": 681.0,
+      "ratio": 0.8776,
+      "suggested_scalar": -0.2059,
+      "log_bad": 6.6542,
+      "log_good": 6.5236
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.9231,
+      "good": 30.1887,
+      "ratio": 0.9169,
+      "suggested_scalar": -0.1367,
+      "log_bad": 3.4942,
+      "log_good": 3.4075
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1984,
+      "good": 1.1281,
+      "ratio": 0.9413,
+      "suggested_scalar": -0.0953,
+      "log_bad": 0.181,
+      "log_good": 0.1205
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 18.0,
+      "good": 13.0,
+      "ratio": 0.7222,
+      "suggested_scalar": -0.5131,
+      "log_bad": 2.8904,
+      "log_good": 2.5649
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 7.0,
+      "good": 9.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.3962,
+      "log_bad": 1.9459,
+      "log_good": 2.1972
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7692,
+      "good": 0.8012,
+      "ratio": 1.0416,
+      "suggested_scalar": 0.0643,
+      "log_bad": -0.2624,
+      "log_good": -0.2216
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9659,
+      "good": 0.9847,
+      "ratio": 1.0195,
+      "suggested_scalar": 0.0304,
+      "log_bad": -0.0347,
+      "log_good": -0.0154
+    },
+    "halstead.mean_length": {
+      "bad": 492.0,
+      "good": 423.0,
+      "ratio": 0.8598,
+      "suggested_scalar": -0.2382,
+      "log_bad": 6.1985,
+      "log_good": 6.0474
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7415,
+      "good": 6.6439,
+      "ratio": 0.9855,
+      "suggested_scalar": -0.023,
+      "log_bad": 1.9083,
+      "log_good": 1.8937
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1131,
+      "good": 0.1364,
+      "ratio": 1.206,
+      "suggested_scalar": 0.2953,
+      "log_bad": -2.1795,
+      "log_good": -1.9922
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 36.4,
+      "good": 31.25,
+      "ratio": 0.8585,
+      "suggested_scalar": -0.2405,
+      "log_bad": 3.5946,
+      "log_good": 3.442
+    },
+    "branching.mean_branch_count": {
+      "bad": 9.0,
+      "good": 7.0,
+      "ratio": 0.7778,
+      "suggested_scalar": -0.3962,
+      "log_bad": 2.1972,
+      "log_good": 1.9459
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 64.0,
+      "good": 58.0,
+      "ratio": 0.9063,
+      "suggested_scalar": -0.1552,
+      "log_bad": 4.1589,
+      "log_good": 4.0604
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6354,
+      "good": 0.6842,
+      "ratio": 1.0768,
+      "suggested_scalar": 0.1167,
+      "log_bad": -0.4535,
+      "log_good": -0.3795
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 68.0,
+      "good": 58.0,
+      "ratio": 0.8529,
+      "suggested_scalar": -0.2508,
+      "log_bad": 4.2195,
+      "log_good": 4.0604
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.name_reflects_semantics_not_type": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 47.0,
+      "good": 22.0,
+      "ratio": 0.4681,
+      "suggested_scalar": -0.2551,
+      "log_bad": 3.8501,
+      "log_good": 3.091
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0315,
+      "good": 1.0,
+      "ratio": 31.746,
+      "suggested_scalar": 1.1618,
+      "log_bad": -3.4578,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6,
+      "good": 1.6,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.47,
+      "log_good": 0.47
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8226,
+      "good": 0.7593,
+      "ratio": 0.923,
+      "suggested_scalar": -0.0269,
+      "log_bad": -0.1953,
+      "log_good": -0.2754
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0315,
+      "good": 1.0,
+      "ratio": 31.746,
+      "suggested_scalar": 1.1618,
+      "log_bad": -3.4578,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4752,
+      "good": 4.4011,
+      "ratio": 0.9834,
+      "suggested_scalar": -0.0056,
+      "log_bad": 1.4986,
+      "log_good": 1.4819
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 115.0,
+      "good": 70.0,
+      "ratio": 0.6087,
+      "suggested_scalar": -0.1668,
+      "log_bad": 4.7449,
+      "log_good": 4.2485
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5402,
+      "good": 0.41,
+      "ratio": 0.759,
+      "suggested_scalar": -0.0927,
+      "log_bad": -0.6158,
+      "log_good": -0.8916
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 13.0,
+      "ratio": 0.7222,
+      "suggested_scalar": -0.1093,
+      "log_bad": 2.8904,
+      "log_good": 2.5649
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7072,
+      "good": 0.6938,
+      "ratio": 0.9811,
+      "suggested_scalar": -0.0064,
+      "log_bad": -0.3464,
+      "log_good": -0.3656
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 9.9355,
+      "good": 9.6296,
+      "ratio": 0.9692,
+      "suggested_scalar": -0.0105,
+      "log_bad": 2.2961,
+      "log_good": 2.2648
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 381.0,
+      "good": 269.0,
+      "ratio": 0.706,
+      "suggested_scalar": -0.117,
+      "log_bad": 5.9428,
+      "log_good": 5.5947
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0007,
+      "good": 0.0009,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.0844,
+      "log_bad": -7.2644,
+      "log_good": -7.0131
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0968,
+      "good": 1.0,
+      "ratio": 10.3306,
+      "suggested_scalar": 0.7846,
+      "log_bad": -2.3351,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0014,
+      "good": 0.0018,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.0844,
+      "log_bad": -6.5713,
+      "log_good": -6.32
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9112,
+      "good": 0.9665,
+      "ratio": 1.0607,
+      "suggested_scalar": 0.0198,
+      "log_bad": -0.093,
+      "log_good": -0.0341
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 147.0,
+      "good": 101.0,
+      "ratio": 0.6871,
+      "suggested_scalar": -0.1261,
+      "log_bad": 4.9904,
+      "log_good": 4.6151
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 65.6607,
+      "good": 61.7932,
+      "ratio": 0.9411,
+      "suggested_scalar": -0.0204,
+      "log_bad": 4.1845,
+      "log_good": 4.1238
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4895,
+      "good": 0.5746,
+      "ratio": 1.1739,
+      "suggested_scalar": 0.0539,
+      "log_bad": -0.7144,
+      "log_good": -0.5541
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 43.3375,
+      "good": 38.8391,
+      "ratio": 0.8962,
+      "suggested_scalar": -0.0368,
+      "log_bad": 3.769,
+      "log_good": 3.6594
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2938.0,
+      "good": 2281.0,
+      "ratio": 0.7764,
+      "suggested_scalar": -0.085,
+      "log_bad": 7.9855,
+      "log_good": 7.7324
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0161,
+      "good": 1.0,
+      "ratio": 62.1118,
+      "suggested_scalar": 1.3874,
+      "log_bad": -4.1289,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7419,
+      "good": 0.6667,
+      "ratio": 0.8986,
+      "suggested_scalar": -0.0359,
+      "log_bad": -0.2985,
+      "log_good": -0.4054
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.1452,
+      "good": 4.9815,
+      "ratio": 0.8106,
+      "suggested_scalar": -0.0705,
+      "log_bad": 1.8157,
+      "log_good": 1.6057
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 17.4152,
+      "good": 19.2702,
+      "ratio": 1.1065,
+      "suggested_scalar": 0.034,
+      "log_bad": 2.8573,
+      "log_good": 2.9586
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 37.0,
+      "good": 18.0,
+      "ratio": 0.4865,
+      "suggested_scalar": -0.2421,
+      "log_bad": 3.6109,
+      "log_good": 2.8904
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9489,
+      "good": 0.9433,
+      "ratio": 0.9941,
+      "suggested_scalar": -0.002,
+      "log_bad": -0.0525,
+      "log_good": -0.0584
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 19.0,
+      "ratio": 0.7037,
+      "suggested_scalar": -0.1181,
+      "log_bad": 3.2958,
+      "log_good": 2.9444
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.7185,
+      "good": 0.7422,
+      "ratio": 1.033,
+      "suggested_scalar": 0.0109,
+      "log_bad": -0.3306,
+      "log_good": -0.2981
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3087,
+      "good": 0.397,
+      "ratio": 1.286,
+      "suggested_scalar": 0.0845,
+      "log_bad": -1.1754,
+      "log_good": -0.9238
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.5526,
+      "good": 3.8793,
+      "ratio": 1.092,
+      "suggested_scalar": 0.0296,
+      "log_bad": 1.2677,
+      "log_good": 1.3557
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 379.0,
+      "good": 267.0,
+      "ratio": 0.7045,
+      "suggested_scalar": -0.1177,
+      "log_bad": 5.9375,
+      "log_good": 5.5872
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0232,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0026,
+      "good": 1.0,
+      "ratio": 384.6154,
+      "suggested_scalar": 2.0,
+      "log_bad": -5.9522,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0224,
+      "good": 5.8074,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.0122,
+      "log_bad": 1.7955,
+      "log_good": 1.7591
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 54.0,
+      "good": 52.0,
+      "ratio": 0.963,
+      "suggested_scalar": -0.0127,
+      "log_bad": 3.989,
+      "log_good": 3.9512
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.8044,
+      "good": 1.7263,
+      "ratio": 0.9567,
+      "suggested_scalar": -0.0149,
+      "log_bad": 0.5902,
+      "log_good": 0.546
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9868,
+      "good": 5.3589,
+      "ratio": 0.8951,
+      "suggested_scalar": -0.0372,
+      "log_bad": 1.7896,
+      "log_good": 1.6788
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7431,
+      "good": 0.7579,
+      "ratio": 1.0199,
+      "suggested_scalar": 0.0066,
+      "log_bad": -0.2969,
+      "log_good": -0.2772
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1268,
+      "good": 0.1429,
+      "ratio": 1.127,
+      "suggested_scalar": 0.0402,
+      "log_bad": -2.0651,
+      "log_good": -1.9456
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 6.5831,
+      "good": 6.2321,
+      "ratio": 0.9467,
+      "suggested_scalar": -0.0184,
+      "log_bad": 1.8845,
+      "log_good": 1.8297
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 309.0,
+      "good": 201.0,
+      "ratio": 0.6505,
+      "suggested_scalar": -0.1445,
+      "log_bad": 5.7333,
+      "log_good": 5.3033
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7964,
+      "good": 0.5394,
+      "ratio": 0.6773,
+      "suggested_scalar": -0.1309,
+      "log_bad": -0.2277,
+      "log_good": -0.6173
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 111.0,
+      "good": 70.0,
+      "ratio": 0.6306,
+      "suggested_scalar": -0.1549,
+      "log_bad": 4.7095,
+      "log_good": 4.2485
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1686.0,
+      "good": 1308.0,
+      "ratio": 0.7758,
+      "suggested_scalar": -0.0853,
+      "log_bad": 7.4301,
+      "log_good": 7.1763
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 182.0,
+      "good": 127.0,
+      "ratio": 0.6978,
+      "suggested_scalar": -0.1209,
+      "log_bad": 5.204,
+      "log_good": 4.8442
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2441,
+      "good": 0.2788,
+      "ratio": 1.1422,
+      "suggested_scalar": 0.0447,
+      "log_bad": -1.4102,
+      "log_good": -1.2773
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 64.0,
+      "good": 48.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.0967,
+      "log_bad": 4.1589,
+      "log_good": 3.8712
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 111.0,
+      "good": 70.0,
+      "ratio": 0.6306,
+      "suggested_scalar": -0.1549,
+      "log_bad": 4.7095,
+      "log_good": 4.2485
+    },
+    "brevity.mean_sample_size": {
+      "bad": 111.0,
+      "good": 70.0,
+      "ratio": 0.6306,
+      "suggested_scalar": -0.1549,
+      "log_bad": 4.7095,
+      "log_good": 4.2485
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 381.0,
+      "good": 269.0,
+      "ratio": 0.706,
+      "suggested_scalar": -0.117,
+      "log_bad": 5.9428,
+      "log_good": 5.5947
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 181.0,
+      "good": 130.0,
+      "ratio": 0.7182,
+      "suggested_scalar": -0.1112,
+      "log_bad": 5.1985,
+      "log_good": 4.8675
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 258.0,
+      "good": 162.0,
+      "ratio": 0.6279,
+      "suggested_scalar": -0.1564,
+      "log_bad": 5.553,
+      "log_good": 5.0876
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.8286,
+      "good": 1.6901,
+      "ratio": 0.9243,
+      "suggested_scalar": -0.0265,
+      "log_bad": 0.6036,
+      "log_good": 0.5248
+    },
+    "halstead.mean_effort": {
+      "bad": 66704.0886,
+      "good": 38279.8963,
+      "ratio": 0.5739,
+      "suggested_scalar": -0.1866,
+      "log_bad": 11.108,
+      "log_good": 10.5527
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8811,
+      "good": 0.8743,
+      "ratio": 0.9923,
+      "suggested_scalar": -0.0026,
+      "log_bad": -0.1266,
+      "log_good": -0.1343
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 88.0,
+      "good": 51.0,
+      "ratio": 0.5795,
+      "suggested_scalar": -0.1833,
+      "log_bad": 4.4773,
+      "log_good": 3.9318
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 167.0,
+      "good": 137.0,
+      "ratio": 0.8204,
+      "suggested_scalar": -0.0665,
+      "log_bad": 5.118,
+      "log_good": 4.92
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4762,
+      "good": 0.4059,
+      "ratio": 0.8524,
+      "suggested_scalar": -0.0537,
+      "log_bad": -0.7419,
+      "log_good": -0.9016
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 11.4694,
+      "good": 12.9505,
+      "ratio": 1.1291,
+      "suggested_scalar": 0.0408,
+      "log_bad": 2.4397,
+      "log_good": 2.5611
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1268,
+      "good": 0.1429,
+      "ratio": 1.127,
+      "suggested_scalar": 0.0402,
+      "log_bad": -2.0651,
+      "log_good": -1.9456
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 7.0581,
+      "good": 7.748,
+      "ratio": 1.0977,
+      "suggested_scalar": 0.0313,
+      "log_bad": 1.9542,
+      "log_good": 2.0474
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 380.0,
+      "good": 268.0,
+      "ratio": 0.7053,
+      "suggested_scalar": -0.1173,
+      "log_bad": 5.9402,
+      "log_good": 5.591
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 47.0,
+      "good": 40.0,
+      "ratio": 0.8511,
+      "suggested_scalar": -0.0542,
+      "log_bad": 3.8501,
+      "log_good": 3.6889
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3705.7827,
+      "good": 2126.6609,
+      "ratio": 0.5739,
+      "suggested_scalar": -0.1866,
+      "log_bad": 8.2176,
+      "log_good": 7.6623
+    },
+    "readability.mean_total_lines": {
+      "bad": 62.0,
+      "good": 54.0,
+      "ratio": 0.871,
+      "suggested_scalar": -0.0464,
+      "log_bad": 4.1271,
+      "log_good": 3.989
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2389.076,
+      "good": 1618.1307,
+      "ratio": 0.6773,
+      "suggested_scalar": -0.1309,
+      "log_bad": 7.7787,
+      "log_good": 7.389
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 827.0,
+      "good": 588.0,
+      "ratio": 0.711,
+      "suggested_scalar": -0.1146,
+      "log_bad": 6.7178,
+      "log_good": 6.3767
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 46.1452,
+      "good": 41.0741,
+      "ratio": 0.8901,
+      "suggested_scalar": -0.0391,
+      "log_bad": 3.8318,
+      "log_good": 3.7154
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.595,
+      "good": 1.6547,
+      "ratio": 1.0374,
+      "suggested_scalar": 0.0123,
+      "log_bad": 0.4669,
+      "log_good": 0.5036
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 1.0,
+      "ratio": 0.1667,
+      "suggested_scalar": -0.602,
+      "log_bad": 1.7918,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8479,
+      "good": 0.801,
+      "ratio": 0.9447,
+      "suggested_scalar": -0.0191,
+      "log_bad": -0.165,
+      "log_good": -0.2219
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.981,
+      "good": 0.9594,
+      "ratio": 0.978,
+      "suggested_scalar": -0.0075,
+      "log_bad": -0.0192,
+      "log_good": -0.0414
+    },
+    "halstead.mean_length": {
+      "bad": 349.0,
+      "good": 264.0,
+      "ratio": 0.7564,
+      "suggested_scalar": -0.0938,
+      "log_bad": 5.8551,
+      "log_good": 5.5759
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.4,
+      "good": 9.8,
+      "ratio": 0.8596,
+      "suggested_scalar": -0.0508,
+      "log_bad": 2.4336,
+      "log_good": 2.2824
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7944,
+      "good": 6.1293,
+      "ratio": 0.9021,
+      "suggested_scalar": -0.0346,
+      "log_bad": 1.9161,
+      "log_good": 1.8131
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0617,
+      "good": 0.057,
+      "ratio": 0.9238,
+      "suggested_scalar": -0.0266,
+      "log_bad": -2.7855,
+      "log_good": -2.8647
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.9205,
+      "good": 23.6569,
+      "ratio": 0.8473,
+      "suggested_scalar": -0.0557,
+      "log_bad": 3.3294,
+      "log_good": 3.1637
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 70.0,
+      "good": 41.0,
+      "ratio": 0.5857,
+      "suggested_scalar": -0.1797,
+      "log_bad": 4.2485,
+      "log_good": 3.7136
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7519,
+      "good": 0.7037,
+      "ratio": 0.9359,
+      "suggested_scalar": -0.0223,
+      "log_bad": -0.2852,
+      "log_good": -0.3514
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 62.0,
+      "good": 54.0,
+      "ratio": 0.871,
+      "suggested_scalar": -0.0464,
+      "log_bad": 4.1271,
+      "log_good": 3.989
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 29.0,
+      "good": 29.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3673,
+      "log_good": 3.3673
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "consistency.doc_vs_comment_separation": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 25.0,
+      "good": 19.0,
+      "ratio": 0.76,
+      "suggested_scalar": -0.0868,
+      "log_bad": 3.2189,
+      "log_good": 2.9444
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0054,
+      "good": 0.0176,
+      "ratio": 3.2593,
+      "suggested_scalar": 0.3739,
+      "log_bad": -5.2214,
+      "log_good": -4.0399
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.25,
+      "good": 1.3333,
+      "ratio": 1.0666,
+      "suggested_scalar": 0.0204,
+      "log_bad": 0.2231,
+      "log_good": 0.2877
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.92,
+      "good": 0.9286,
+      "ratio": 1.0093,
+      "suggested_scalar": 0.0029,
+      "log_bad": -0.0834,
+      "log_good": -0.0741
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0054,
+      "good": 0.0176,
+      "ratio": 3.2593,
+      "suggested_scalar": 0.3739,
+      "log_bad": -5.2214,
+      "log_good": -4.0399
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7884,
+      "good": 4.7146,
+      "ratio": 0.9846,
+      "suggested_scalar": -0.0049,
+      "log_bad": 1.5662,
+      "log_good": 1.5507
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 119.0,
+      "good": 103.0,
+      "ratio": 0.8655,
+      "suggested_scalar": -0.0457,
+      "log_bad": 4.7791,
+      "log_good": 4.6347
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.6593,
+      "good": 0.5783,
+      "ratio": 0.8771,
+      "suggested_scalar": -0.0415,
+      "log_bad": -0.4166,
+      "log_good": -0.5477
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.684,
+      "good": 0.6785,
+      "ratio": 0.992,
+      "suggested_scalar": -0.0026,
+      "log_bad": -0.3798,
+      "log_good": -0.3879
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.0,
+      "good": 3.7857,
+      "ratio": 1.2619,
+      "suggested_scalar": 0.0736,
+      "log_bad": 1.0986,
+      "log_good": 1.3312
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 554.0,
+      "good": 511.0,
+      "ratio": 0.9224,
+      "suggested_scalar": -0.0256,
+      "log_bad": 6.3172,
+      "log_good": 6.2364
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.16,
+      "good": 0.0536,
+      "ratio": 0.335,
+      "suggested_scalar": -0.3461,
+      "log_bad": -1.8326,
+      "log_good": -2.9262
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9092,
+      "good": 0.9544,
+      "ratio": 1.0497,
+      "suggested_scalar": 0.0154,
+      "log_bad": -0.0952,
+      "log_good": -0.0467
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 225.0,
+      "good": 195.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.0453,
+      "log_bad": 5.4161,
+      "log_good": 5.273
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 99.8146,
+      "good": 103.0489,
+      "ratio": 1.0324,
+      "suggested_scalar": 0.0101,
+      "log_bad": 4.6033,
+      "log_good": 4.6352
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5461,
+      "good": 0.5431,
+      "ratio": 0.9945,
+      "suggested_scalar": -0.0017,
+      "log_bad": -0.605,
+      "log_good": -0.6105
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 13.3765,
+      "good": 13.1572,
+      "ratio": 0.9836,
+      "suggested_scalar": -0.0052,
+      "log_bad": 2.5935,
+      "log_good": 2.577
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2283.0,
+      "good": 2095.0,
+      "ratio": 0.9177,
+      "suggested_scalar": -0.0272,
+      "log_bad": 7.7332,
+      "log_good": 7.6473
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2,
+      "good": 0.125,
+      "ratio": 0.625,
+      "suggested_scalar": -0.1487,
+      "log_bad": -1.6094,
+      "log_good": -2.0794
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.88,
+      "good": 0.875,
+      "ratio": 0.9943,
+      "suggested_scalar": -0.0018,
+      "log_bad": -0.1278,
+      "log_good": -0.1335
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 13.1905,
+      "good": 9.6415,
+      "ratio": 0.7309,
+      "suggested_scalar": -0.0992,
+      "log_bad": 2.5795,
+      "log_good": 2.2661
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.76,
+      "good": 5.6684,
+      "ratio": 2.0538,
+      "suggested_scalar": 0.2277,
+      "log_bad": 1.0152,
+      "log_good": 1.7349
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 170.0,
+      "good": 156.0,
+      "ratio": 0.9176,
+      "suggested_scalar": -0.0272,
+      "log_bad": 5.1358,
+      "log_good": 5.0499
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9586,
+      "good": 0.958,
+      "ratio": 0.9994,
+      "suggested_scalar": -0.0002,
+      "log_bad": -0.0423,
+      "log_good": -0.0429
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 35.0,
+      "good": 34.0,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.0092,
+      "log_bad": 3.5553,
+      "log_good": 3.5264
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5887,
+      "good": 0.5924,
+      "ratio": 1.0063,
+      "suggested_scalar": 0.002,
+      "log_bad": -0.5298,
+      "log_good": -0.5236
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3967,
+      "good": 0.3831,
+      "ratio": 0.9657,
+      "suggested_scalar": -0.011,
+      "log_bad": -0.9246,
+      "log_good": -0.9595
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4313,
+      "good": 2.4532,
+      "ratio": 1.009,
+      "suggested_scalar": 0.0028,
+      "log_bad": 0.8884,
+      "log_good": 0.8974
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 552.0,
+      "good": 509.0,
+      "ratio": 0.9221,
+      "suggested_scalar": -0.0257,
+      "log_bad": 6.3135,
+      "log_good": 6.2324
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 31.0,
+      "good": 27.0,
+      "ratio": 0.871,
+      "suggested_scalar": -0.0437,
+      "log_bad": 3.434,
+      "log_good": 3.2958
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0307,
+      "good": 0.0274,
+      "ratio": 0.8925,
+      "suggested_scalar": -0.036,
+      "log_bad": -3.4835,
+      "log_good": -3.5972
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0661,
+      "good": 5.9069,
+      "ratio": 0.9738,
+      "suggested_scalar": -0.0084,
+      "log_bad": 1.8027,
+      "log_good": 1.7761
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 55.0,
+      "good": 38.0,
+      "ratio": 0.6909,
+      "suggested_scalar": -0.117,
+      "log_bad": 4.0073,
+      "log_good": 3.6376
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8024,
+      "good": 0.7563,
+      "ratio": 0.9425,
+      "suggested_scalar": -0.0187,
+      "log_bad": -0.2201,
+      "log_good": -0.2793
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.2759,
+      "good": 6.0628,
+      "ratio": 0.966,
+      "suggested_scalar": -0.0109,
+      "log_bad": 1.8367,
+      "log_good": 1.8022
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7894,
+      "good": 0.7982,
+      "ratio": 1.0111,
+      "suggested_scalar": 0.0035,
+      "log_bad": -0.2365,
+      "log_good": -0.2254
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1379,
+      "good": 0.1642,
+      "ratio": 1.1907,
+      "suggested_scalar": 0.0552,
+      "log_bad": -1.9812,
+      "log_good": -1.8067
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.6574,
+      "good": 3.6273,
+      "ratio": 0.9918,
+      "suggested_scalar": -0.0026,
+      "log_bad": 1.2968,
+      "log_good": 1.2885
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 409.0,
+      "good": 394.0,
+      "ratio": 0.9633,
+      "suggested_scalar": -0.0118,
+      "log_bad": 6.0137,
+      "log_good": 5.9764
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 3.0,
+      "good": 10.0,
+      "ratio": 3.3333,
+      "suggested_scalar": 0.381,
+      "log_bad": 1.0986,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0595,
+      "good": 0.8938,
+      "ratio": 0.8436,
+      "suggested_scalar": -0.0538,
+      "log_bad": 0.0578,
+      "log_good": -0.1123
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 161.0,
+      "good": 138.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0488,
+      "log_bad": 5.0814,
+      "log_good": 4.9273
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1358.0,
+      "good": 1236.0,
+      "ratio": 0.9102,
+      "suggested_scalar": -0.0298,
+      "log_bad": 7.2138,
+      "log_good": 7.1196
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 175.0,
+      "good": 139.0,
+      "ratio": 0.7943,
+      "suggested_scalar": -0.0729,
+      "log_bad": 5.1648,
+      "log_good": 4.9345
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 0.0098,
+      "ratio": 0.0098,
+      "suggested_scalar": -1.4637,
+      "log_bad": 0.0,
+      "log_good": -4.6254
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.231,
+      "good": 0.225,
+      "ratio": 0.974,
+      "suggested_scalar": -0.0083,
+      "log_bad": -1.4653,
+      "log_good": -1.4917
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 89.0,
+      "good": 89.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.4886,
+      "log_good": 4.4886
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.091,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 161.0,
+      "good": 138.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0488,
+      "log_bad": 5.0814,
+      "log_good": 4.9273
+    },
+    "brevity.mean_sample_size": {
+      "bad": 161.0,
+      "good": 138.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0488,
+      "log_bad": 5.0814,
+      "log_good": 4.9273
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 554.0,
+      "good": 511.0,
+      "ratio": 0.9224,
+      "suggested_scalar": -0.0256,
+      "log_bad": 6.3172,
+      "log_good": 6.2364
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 265.0,
+      "good": 273.0,
+      "ratio": 1.0302,
+      "suggested_scalar": 0.0094,
+      "log_bad": 5.5797,
+      "log_good": 5.6095
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 340.0,
+      "good": 322.0,
+      "ratio": 0.9471,
+      "suggested_scalar": -0.0172,
+      "log_bad": 5.8289,
+      "log_good": 5.7746
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0018,
+      "good": 1.0,
+      "ratio": 555.5556,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.32,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.4233,
+      "good": 2.2358,
+      "ratio": 0.9226,
+      "suggested_scalar": -0.0255,
+      "log_bad": 0.8851,
+      "log_good": 0.8046
+    },
+    "halstead.mean_effort": {
+      "bad": 115883.2131,
+      "good": 91824.3551,
+      "ratio": 0.7924,
+      "suggested_scalar": -0.0736,
+      "log_bad": 11.6603,
+      "log_good": 11.4276
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8561,
+      "good": 0.8529,
+      "ratio": 0.9963,
+      "suggested_scalar": -0.0012,
+      "log_bad": -0.1554,
+      "log_good": -0.1591
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 84.0,
+      "good": 69.0,
+      "ratio": 0.8214,
+      "suggested_scalar": -0.0623,
+      "log_bad": 4.4308,
+      "log_good": 4.2341
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 286.0,
+      "good": 262.0,
+      "ratio": 0.9161,
+      "suggested_scalar": -0.0277,
+      "log_bad": 5.656,
+      "log_good": 5.5683
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4889,
+      "good": 0.4872,
+      "ratio": 0.9965,
+      "suggested_scalar": -0.0011,
+      "log_bad": -0.7156,
+      "log_good": -0.7191
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.0356,
+      "good": 6.3385,
+      "ratio": 1.0502,
+      "suggested_scalar": 0.0155,
+      "log_bad": 1.7977,
+      "log_good": 1.8466
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1379,
+      "good": 0.1642,
+      "ratio": 1.1907,
+      "suggested_scalar": 0.0552,
+      "log_bad": -1.9812,
+      "log_good": -1.8067
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.7032,
+      "good": 4.3694,
+      "ratio": 0.7661,
+      "suggested_scalar": -0.0843,
+      "log_bad": 1.741,
+      "log_good": 1.4746
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 553.0,
+      "good": 510.0,
+      "ratio": 0.9222,
+      "suggested_scalar": -0.0256,
+      "log_bad": 6.3154,
+      "log_good": 6.2344
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 4.0,
+      "good": 9.0,
+      "ratio": 2.25,
+      "suggested_scalar": 0.2566,
+      "log_bad": 1.3863,
+      "log_good": 2.1972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 76.0,
+      "good": 80.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0162,
+      "log_bad": 4.3307,
+      "log_good": 4.382
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6437.9563,
+      "good": 5101.3531,
+      "ratio": 0.7924,
+      "suggested_scalar": -0.0736,
+      "log_bad": 8.77,
+      "log_good": 8.5373
+    },
+    "readability.mean_total_lines": {
+      "bad": 42.0,
+      "good": 53.0,
+      "ratio": 1.2619,
+      "suggested_scalar": 0.0736,
+      "log_bad": 3.7377,
+      "log_good": 3.9703
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 10.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0706,
+      "log_bad": 2.0794,
+      "log_good": 2.3026
+    },
+    "halstead.mean_volume": {
+      "bad": 3178.511,
+      "good": 2681.2867,
+      "ratio": 0.8436,
+      "suggested_scalar": -0.0538,
+      "log_bad": 8.0642,
+      "log_good": 7.8941
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 939.0,
+      "good": 854.0,
+      "ratio": 0.9095,
+      "suggested_scalar": -0.03,
+      "log_bad": 6.8448,
+      "log_good": 6.7499
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 40.0714,
+      "good": 34.6038,
+      "ratio": 0.8636,
+      "suggested_scalar": -0.0464,
+      "log_bad": 3.6907,
+      "log_good": 3.544
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1068,
+      "good": 1.1111,
+      "ratio": 1.0039,
+      "suggested_scalar": 0.0012,
+      "log_bad": 0.1015,
+      "log_good": 0.1054
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 45.0,
+      "good": 34.0,
+      "ratio": 0.7556,
+      "suggested_scalar": -0.0887,
+      "log_bad": 3.8067,
+      "log_good": 3.5264
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 8.0,
+      "good": 3.0,
+      "ratio": 0.375,
+      "suggested_scalar": -0.3104,
+      "log_bad": 2.0794,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8142,
+      "good": 0.797,
+      "ratio": 0.9789,
+      "suggested_scalar": -0.0068,
+      "log_bad": -0.2055,
+      "log_good": -0.2269
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2194,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9906,
+      "good": 0.9836,
+      "ratio": 0.9929,
+      "suggested_scalar": -0.0022,
+      "log_bad": -0.0094,
+      "log_good": -0.0165
+    },
+    "halstead.mean_length": {
+      "bad": 461.0,
+      "good": 401.0,
+      "ratio": 0.8698,
+      "suggested_scalar": -0.0441,
+      "log_bad": 6.1334,
+      "log_good": 5.994
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.75,
+      "good": 15.3333,
+      "ratio": 1.305,
+      "suggested_scalar": 0.0842,
+      "log_bad": 2.4639,
+      "log_good": 2.73
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.3309,
+      "good": 7.1085,
+      "ratio": 0.9697,
+      "suggested_scalar": -0.0097,
+      "log_bad": 1.9921,
+      "log_good": 1.9613
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1164,
+      "good": 0.1303,
+      "ratio": 1.1194,
+      "suggested_scalar": 0.0357,
+      "log_bad": -2.1507,
+      "log_good": -2.0379
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 36.4583,
+      "good": 34.2464,
+      "ratio": 0.9393,
+      "suggested_scalar": -0.0198,
+      "log_bad": 3.5962,
+      "log_good": 3.5336
+    },
+    "branching.mean_branch_count": {
+      "bad": 10.0,
+      "good": 7.0,
+      "ratio": 0.7,
+      "suggested_scalar": -0.1129,
+      "log_bad": 2.3026,
+      "log_good": 1.9459
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 110.0,
+      "good": 95.0,
+      "ratio": 0.8636,
+      "suggested_scalar": -0.0464,
+      "log_bad": 4.7005,
+      "log_good": 4.5539
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7382,
+      "good": 0.7236,
+      "ratio": 0.9802,
+      "suggested_scalar": -0.0063,
+      "log_bad": -0.3035,
+      "log_good": -0.3235
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 50.0,
+      "good": 56.0,
+      "ratio": 1.12,
+      "suggested_scalar": 0.0359,
+      "log_bad": 3.912,
+      "log_good": 4.0254
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.type_parameter_is_descriptive_or_single_letter": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0139,
+      "good": 0.0078,
+      "ratio": 0.5612,
+      "suggested_scalar": -2.0,
+      "log_bad": -4.2759,
+      "log_good": -4.8536
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8085,
+      "good": 0.8,
+      "ratio": 0.9895,
+      "suggested_scalar": -0.0366,
+      "log_bad": -0.2126,
+      "log_good": -0.2231
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0139,
+      "good": 0.0078,
+      "ratio": 0.5612,
+      "suggested_scalar": -2.0,
+      "log_bad": -4.2759,
+      "log_good": -4.8536
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7323,
+      "good": 4.6764,
+      "ratio": 0.9882,
+      "suggested_scalar": -0.0411,
+      "log_bad": 1.5544,
+      "log_good": 1.5425
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 124.0,
+      "good": 104.0,
+      "ratio": 0.8387,
+      "suggested_scalar": -0.6089,
+      "log_bad": 4.8203,
+      "log_good": 4.6444
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.497,
+      "good": 0.47,
+      "ratio": 0.9457,
+      "suggested_scalar": -0.1934,
+      "log_bad": -0.6992,
+      "log_good": -0.755
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 21.0,
+      "good": 19.0,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.3465,
+      "log_bad": 3.0445,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6205,
+      "good": 0.6185,
+      "ratio": 0.9968,
+      "suggested_scalar": -0.0112,
+      "log_bad": -0.4772,
+      "log_good": -0.4805
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.2553,
+      "good": 4.4444,
+      "ratio": 1.0444,
+      "suggested_scalar": 0.1505,
+      "log_bad": 1.4482,
+      "log_good": 1.4916
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 433.0,
+      "good": 383.0,
+      "ratio": 0.8845,
+      "suggested_scalar": -0.4247,
+      "log_bad": 6.0707,
+      "log_good": 5.948
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0006,
+      "good": 0.0006,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.4186,
+      "log_good": -7.4186
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1064,
+      "good": 0.0667,
+      "ratio": 0.6269,
+      "suggested_scalar": -1.6166,
+      "log_bad": -2.2405,
+      "log_good": -2.7076
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0028,
+      "good": 0.003,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.2388,
+      "log_bad": -5.8781,
+      "log_good": -5.8091
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9125,
+      "good": 0.9166,
+      "ratio": 1.0045,
+      "suggested_scalar": 0.0155,
+      "log_bad": -0.0916,
+      "log_good": -0.0871
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 159.0,
+      "good": 129.0,
+      "ratio": 0.8113,
+      "suggested_scalar": -0.7238,
+      "log_bad": 5.0689,
+      "log_good": 4.8598
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.5257,
+      "good": 100.4059,
+      "ratio": 0.989,
+      "suggested_scalar": -0.0384,
+      "log_bad": 4.6203,
+      "log_good": 4.6092
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4144,
+      "good": 0.4372,
+      "ratio": 1.055,
+      "suggested_scalar": 0.1854,
+      "log_bad": -0.8809,
+      "log_good": -0.8274
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.5076,
+      "good": 9.6706,
+      "ratio": 1.0171,
+      "suggested_scalar": 0.0588,
+      "log_bad": 2.2521,
+      "log_good": 2.2691
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1779.0,
+      "good": 1643.0,
+      "ratio": 0.9236,
+      "suggested_scalar": -0.2753,
+      "log_bad": 7.4838,
+      "log_good": 7.4043
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2128,
+      "good": 0.2667,
+      "ratio": 1.2533,
+      "suggested_scalar": 0.7815,
+      "log_bad": -1.5474,
+      "log_good": -1.3216
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.766,
+      "good": 0.7556,
+      "ratio": 0.9864,
+      "suggested_scalar": -0.0473,
+      "log_bad": -0.2666,
+      "log_good": -0.2802
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.2128,
+      "good": 8.5111,
+      "ratio": 0.9238,
+      "suggested_scalar": -0.2742,
+      "log_bad": 2.2206,
+      "log_good": 2.1414
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 11.8497,
+      "good": 11.5358,
+      "ratio": 0.9735,
+      "suggested_scalar": -0.0929,
+      "log_bad": 2.4723,
+      "log_good": 2.4455
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 96.0,
+      "good": 70.0,
+      "ratio": 0.7292,
+      "suggested_scalar": -1.0934,
+      "log_bad": 4.5643,
+      "log_good": 4.2485
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9275,
+      "good": 0.9166,
+      "ratio": 0.9882,
+      "suggested_scalar": -0.0409,
+      "log_bad": -0.0753,
+      "log_good": -0.0871
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 34.0,
+      "good": 32.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.2099,
+      "log_bad": 3.5264,
+      "log_good": 3.4657
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.566,
+      "good": 0.5715,
+      "ratio": 1.0097,
+      "suggested_scalar": 0.0335,
+      "log_bad": -0.5692,
+      "log_good": -0.5595
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.1763,
+      "good": 0.1969,
+      "ratio": 1.1168,
+      "suggested_scalar": 0.3825,
+      "log_bad": -1.7356,
+      "log_good": -1.6251
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3044,
+      "good": 2.3338,
+      "ratio": 1.0128,
+      "suggested_scalar": 0.0439,
+      "log_bad": 0.8348,
+      "log_good": 0.8475
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 431.0,
+      "good": 381.0,
+      "ratio": 0.884,
+      "suggested_scalar": -0.4268,
+      "log_bad": 6.0661,
+      "log_good": 5.9428
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 23.0,
+      "good": 22.0,
+      "ratio": 0.9565,
+      "suggested_scalar": -0.1539,
+      "log_bad": 3.1355,
+      "log_good": 3.091
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0531,
+      "good": 0.0627,
+      "ratio": 1.1808,
+      "suggested_scalar": 0.5753,
+      "log_bad": -2.9356,
+      "log_good": -2.7694
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.1085,
+      "good": 6.0,
+      "ratio": 0.9822,
+      "suggested_scalar": -0.062,
+      "log_bad": 1.8097,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 43.0,
+      "good": 39.0,
+      "ratio": 0.907,
+      "suggested_scalar": -0.338,
+      "log_bad": 3.7612,
+      "log_good": 3.6636
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3849,
+      "good": 1.49,
+      "ratio": 1.0759,
+      "suggested_scalar": 0.2532,
+      "log_bad": 0.3256,
+      "log_good": 0.3988
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 6.1826,
+      "good": 5.9598,
+      "ratio": 0.964,
+      "suggested_scalar": -0.127,
+      "log_bad": 1.8217,
+      "log_good": 1.785
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7747,
+      "good": 0.7794,
+      "ratio": 1.0061,
+      "suggested_scalar": 0.0209,
+      "log_bad": -0.2553,
+      "log_good": -0.2492
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1607,
+      "good": 0.1667,
+      "ratio": 1.0373,
+      "suggested_scalar": 0.1269,
+      "log_bad": -1.8282,
+      "log_good": -1.7916
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.0834,
+      "good": 3.1098,
+      "ratio": 1.0086,
+      "suggested_scalar": 0.0295,
+      "log_bad": 1.126,
+      "log_good": 1.1346
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 389.0,
+      "good": 341.0,
+      "ratio": 0.8766,
+      "suggested_scalar": -0.4559,
+      "log_bad": 5.9636,
+      "log_good": 5.8319
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9295,
+      "good": 0.8041,
+      "ratio": 0.8651,
+      "suggested_scalar": -0.5017,
+      "log_bad": -0.0731,
+      "log_good": -0.218
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 118.0,
+      "good": 100.0,
+      "ratio": 0.8475,
+      "suggested_scalar": -0.5729,
+      "log_bad": 4.7707,
+      "log_good": 4.6052
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 872.0,
+      "good": 782.0,
+      "ratio": 0.8968,
+      "suggested_scalar": -0.3771,
+      "log_bad": 6.7708,
+      "log_good": 6.6619
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 191.0,
+      "good": 162.0,
+      "ratio": 0.8482,
+      "suggested_scalar": -0.57,
+      "log_bad": 5.2523,
+      "log_good": 5.0876
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0069,
+      "good": 0.0078,
+      "ratio": 1.1304,
+      "suggested_scalar": 0.4244,
+      "log_bad": -4.9762,
+      "log_good": -4.8536
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2309,
+      "good": 0.235,
+      "ratio": 1.0178,
+      "suggested_scalar": 0.0609,
+      "log_bad": -1.4658,
+      "log_good": -1.4482
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 70.0,
+      "good": 68.0,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.1003,
+      "log_bad": 4.2485,
+      "log_good": 4.2195
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 118.0,
+      "good": 100.0,
+      "ratio": 0.8475,
+      "suggested_scalar": -0.5729,
+      "log_bad": 4.7707,
+      "log_good": 4.6052
+    },
+    "brevity.mean_sample_size": {
+      "bad": 118.0,
+      "good": 100.0,
+      "ratio": 0.8475,
+      "suggested_scalar": -0.5729,
+      "log_bad": 4.7707,
+      "log_good": 4.6052
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 433.0,
+      "good": 383.0,
+      "ratio": 0.8845,
+      "suggested_scalar": -0.4247,
+      "log_bad": 6.0707,
+      "log_good": 5.948
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 210.0,
+      "good": 190.0,
+      "ratio": 0.9048,
+      "suggested_scalar": -0.3465,
+      "log_bad": 5.3471,
+      "log_good": 5.247
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 323.0,
+      "good": 283.0,
+      "ratio": 0.8762,
+      "suggested_scalar": -0.4576,
+      "log_bad": 5.7777,
+      "log_good": 5.6454
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0069,
+      "good": 0.0078,
+      "ratio": 1.1304,
+      "suggested_scalar": 0.4244,
+      "log_bad": -4.9762,
+      "log_good": -4.8536
+    },
+    "heaps.mean_k": {
+      "bad": 2.7375,
+      "good": 2.5719,
+      "ratio": 0.9395,
+      "suggested_scalar": -0.216,
+      "log_bad": 1.007,
+      "log_good": 0.9446
+    },
+    "halstead.mean_effort": {
+      "bad": 100607.6716,
+      "good": 86837.6987,
+      "ratio": 0.8631,
+      "suggested_scalar": -0.5095,
+      "log_bad": 11.519,
+      "log_good": 11.3718
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8983,
+      "good": 0.897,
+      "ratio": 0.9986,
+      "suggested_scalar": -0.005,
+      "log_bad": -0.1073,
+      "log_good": -0.1087
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 90.0,
+      "good": 72.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.7724,
+      "log_bad": 4.4998,
+      "log_good": 4.2767
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 210.0,
+      "good": 198.0,
+      "ratio": 0.9429,
+      "suggested_scalar": -0.2037,
+      "log_bad": 5.3471,
+      "log_good": 5.2883
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4654,
+      "good": 0.4496,
+      "ratio": 0.9661,
+      "suggested_scalar": -0.1196,
+      "log_bad": -0.7649,
+      "log_good": -0.7994
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.4843,
+      "good": 6.062,
+      "ratio": 1.1053,
+      "suggested_scalar": 0.3467,
+      "log_bad": 1.7019,
+      "log_good": 1.802
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1607,
+      "good": 0.1667,
+      "ratio": 1.0373,
+      "suggested_scalar": 0.1269,
+      "log_bad": -1.8282,
+      "log_good": -1.7916
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.9814,
+      "good": 4.9098,
+      "ratio": 0.9856,
+      "suggested_scalar": -0.0501,
+      "log_bad": 1.6057,
+      "log_good": 1.5912
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 432.0,
+      "good": 382.0,
+      "ratio": 0.8843,
+      "suggested_scalar": -0.4258,
+      "log_bad": 6.0684,
+      "log_good": 5.9454
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 34.0,
+      "good": 35.0,
+      "ratio": 1.0294,
+      "suggested_scalar": 0.1003,
+      "log_bad": 3.5264,
+      "log_good": 3.5553
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5589.3151,
+      "good": 4824.3166,
+      "ratio": 0.8631,
+      "suggested_scalar": -0.5095,
+      "log_bad": 8.6286,
+      "log_good": 8.4814
+    },
+    "readability.mean_total_lines": {
+      "bad": 47.0,
+      "good": 45.0,
+      "ratio": 0.9574,
+      "suggested_scalar": -0.1505,
+      "log_bad": 3.8501,
+      "log_good": 3.8067
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2788.6327,
+      "good": 2412.1583,
+      "ratio": 0.865,
+      "suggested_scalar": -0.502,
+      "log_bad": 7.9333,
+      "log_good": 7.7883
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 772.0,
+      "good": 704.0,
+      "ratio": 0.9119,
+      "suggested_scalar": -0.3192,
+      "log_bad": 6.649,
+      "log_good": 6.5568
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 36.617,
+      "good": 35.3111,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.1257,
+      "log_bad": 3.6005,
+      "log_good": 3.5642
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1343,
+      "good": 1.1559,
+      "ratio": 1.019,
+      "suggested_scalar": 0.0653,
+      "log_bad": 0.126,
+      "log_good": 0.1449
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 5.0,
+      "good": 3.0,
+      "ratio": 0.6,
+      "suggested_scalar": -1.7683,
+      "log_bad": 1.6094,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9126,
+      "good": 0.8974,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0581,
+      "log_bad": -0.0915,
+      "log_good": -0.1083
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9782,
+      "good": 0.9774,
+      "ratio": 0.9992,
+      "suggested_scalar": -0.0028,
+      "log_bad": -0.022,
+      "log_good": -0.0229
+    },
+    "halstead.mean_length": {
+      "bad": 401.0,
+      "good": 360.0,
+      "ratio": 0.8978,
+      "suggested_scalar": -0.3734,
+      "log_bad": 5.994,
+      "log_good": 5.8861
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.6667,
+      "good": 11.3333,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.1004,
+      "log_bad": 2.4567,
+      "log_good": 2.4277
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.8826,
+      "good": 6.6439,
+      "ratio": 0.9653,
+      "suggested_scalar": -0.1222,
+      "log_bad": 1.929,
+      "log_good": 1.8937
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1182,
+      "good": 0.1156,
+      "ratio": 0.978,
+      "suggested_scalar": -0.077,
+      "log_bad": -2.1354,
+      "log_good": -2.1576
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 36.0778,
+      "good": 36.0,
+      "ratio": 0.9978,
+      "suggested_scalar": -0.0075,
+      "log_bad": 3.5857,
+      "log_good": 3.5835
+    },
+    "branching.mean_branch_count": {
+      "bad": 10.0,
+      "good": 12.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.6311,
+      "log_bad": 2.3026,
+      "log_good": 2.4849
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 74.0,
+      "good": 58.0,
+      "ratio": 0.7838,
+      "suggested_scalar": -0.8433,
+      "log_bad": 4.3041,
+      "log_good": 4.0604
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7833,
+      "good": 0.7597,
+      "ratio": 0.9699,
+      "suggested_scalar": -0.1059,
+      "log_bad": -0.2442,
+      "log_good": -0.2748
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 47.0,
+      "good": 45.0,
+      "ratio": 0.9574,
+      "suggested_scalar": -0.1505,
+      "log_bad": 3.8501,
+      "log_good": 3.8067
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.no_predicate_method_with_is_prefix": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 7.0,
+      "good": 10.0,
+      "ratio": 1.4286,
+      "suggested_scalar": 0.2343,
+      "log_bad": 1.9459,
+      "log_good": 2.3026
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.1111,
+      "good": 0.2,
+      "ratio": 1.8002,
+      "suggested_scalar": 0.3861,
+      "log_bad": -2.1973,
+      "log_good": -1.6094
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7949,
+      "good": 0.7857,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0076,
+      "log_bad": -0.2295,
+      "log_good": -0.2412
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5665,
+      "good": 4.5385,
+      "ratio": 0.9939,
+      "suggested_scalar": -0.004,
+      "log_bad": 1.5187,
+      "log_good": 1.5126
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 59.0,
+      "good": 57.0,
+      "ratio": 0.9661,
+      "suggested_scalar": -0.0227,
+      "log_bad": 4.0775,
+      "log_good": 4.0431
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4938,
+      "good": 0.4366,
+      "ratio": 0.8842,
+      "suggested_scalar": -0.0809,
+      "log_bad": -0.7056,
+      "log_good": -0.8287
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 16.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0774,
+      "log_bad": 2.8904,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6605,
+      "good": 0.5897,
+      "ratio": 0.8928,
+      "suggested_scalar": -0.0745,
+      "log_bad": -0.4148,
+      "log_good": -0.5281
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.6154,
+      "good": 2.7143,
+      "ratio": 1.0378,
+      "suggested_scalar": 0.0244,
+      "log_bad": 0.9614,
+      "log_good": 0.9985
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 216.0,
+      "good": 213.0,
+      "ratio": 0.9861,
+      "suggested_scalar": -0.0092,
+      "log_bad": 5.3753,
+      "log_good": 5.3613
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0048,
+      "good": 0.0041,
+      "ratio": 0.8542,
+      "suggested_scalar": -0.1035,
+      "log_bad": -5.3391,
+      "log_good": -5.4968
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0769,
+      "good": 1.0,
+      "ratio": 13.0039,
+      "suggested_scalar": 1.6849,
+      "log_bad": -2.5652,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0172,
+      "good": 0.0174,
+      "ratio": 1.0116,
+      "suggested_scalar": 0.0076,
+      "log_bad": -4.0628,
+      "log_good": -4.0513
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9305,
+      "good": 0.9553,
+      "ratio": 1.0267,
+      "suggested_scalar": 0.0173,
+      "log_bad": -0.072,
+      "log_good": -0.0457
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 81.0,
+      "good": 71.0,
+      "ratio": 0.8765,
+      "suggested_scalar": -0.0866,
+      "log_bad": 4.3944,
+      "log_good": 4.2627
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 85.1529,
+      "good": 97.6295,
+      "ratio": 1.1465,
+      "suggested_scalar": 0.0898,
+      "log_bad": 4.4444,
+      "log_good": 4.5812
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5814,
+      "good": 0.5189,
+      "ratio": 0.8925,
+      "suggested_scalar": -0.0747,
+      "log_bad": -0.5423,
+      "log_good": -0.656
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 15.768,
+      "good": 12.1825,
+      "ratio": 0.7726,
+      "suggested_scalar": -0.1695,
+      "log_bad": 2.758,
+      "log_good": 2.5
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1045.0,
+      "good": 976.0,
+      "ratio": 0.934,
+      "suggested_scalar": -0.0449,
+      "log_bad": 6.9518,
+      "log_good": 6.8835
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 0.0476,
+      "ratio": 0.0476,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -3.0449
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7692,
+      "good": 0.7619,
+      "ratio": 0.9905,
+      "suggested_scalar": -0.0063,
+      "log_bad": -0.2624,
+      "log_good": -0.2719
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.0,
+      "good": 5.0714,
+      "ratio": 0.8452,
+      "suggested_scalar": -0.1104,
+      "log_bad": 1.7918,
+      "log_good": 1.6236
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.7216,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.2623,
+      "good": 1.2993,
+      "ratio": 1.0293,
+      "suggested_scalar": 0.019,
+      "log_bad": 0.2329,
+      "log_good": 0.2618
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 73.0,
+      "good": 66.0,
+      "ratio": 0.9041,
+      "suggested_scalar": -0.0662,
+      "log_bad": 4.2905,
+      "log_good": 4.1897
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9161,
+      "good": 0.897,
+      "ratio": 0.9792,
+      "suggested_scalar": -0.0138,
+      "log_bad": -0.0876,
+      "log_good": -0.1087
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 18.0,
+      "good": 22.0,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.1318,
+      "log_bad": 2.8904,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5943,
+      "good": 0.5789,
+      "ratio": 0.9741,
+      "suggested_scalar": -0.0172,
+      "log_bad": -0.5204,
+      "log_good": -0.5466
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2757,
+      "good": 0.237,
+      "ratio": 0.8596,
+      "suggested_scalar": -0.0993,
+      "log_bad": -1.2884,
+      "log_good": -1.4397
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4646,
+      "good": 2.3747,
+      "ratio": 0.9635,
+      "suggested_scalar": -0.0244,
+      "log_bad": 0.902,
+      "log_good": 0.8649
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 214.0,
+      "good": 211.0,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0093,
+      "log_bad": 5.366,
+      "log_good": 5.3519
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 10.0,
+      "good": 9.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0692,
+      "log_bad": 2.3026,
+      "log_good": 2.1972
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7549,
+      "good": 5.7814,
+      "ratio": 1.0046,
+      "suggested_scalar": 0.003,
+      "log_bad": 1.7501,
+      "log_good": 1.7546
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.2663,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6193,
+      "good": 0.4359,
+      "ratio": 0.7039,
+      "suggested_scalar": -0.2307,
+      "log_bad": -0.4792,
+      "log_good": -0.8303
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0247,
+      "good": 0.0423,
+      "ratio": 1.7126,
+      "suggested_scalar": 0.3534,
+      "log_bad": -3.701,
+      "log_good": -3.163
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.327,
+      "good": 5.2179,
+      "ratio": 0.9795,
+      "suggested_scalar": -0.0136,
+      "log_bad": 1.6728,
+      "log_good": 1.6521
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7935,
+      "good": 0.785,
+      "ratio": 0.9893,
+      "suggested_scalar": -0.0071,
+      "log_bad": -0.2313,
+      "log_good": -0.2421
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2041,
+      "good": 0.2364,
+      "ratio": 1.1583,
+      "suggested_scalar": 0.0965,
+      "log_bad": -1.5891,
+      "log_good": -1.4422
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.9709,
+      "good": 3.4903,
+      "ratio": 0.879,
+      "suggested_scalar": -0.0847,
+      "log_bad": 1.379,
+      "log_good": 1.25
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 177.0,
+      "good": 179.0,
+      "ratio": 1.0113,
+      "suggested_scalar": 0.0074,
+      "log_bad": 5.1761,
+      "log_good": 5.1874
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.353,
+      "good": 0.3616,
+      "ratio": 1.0244,
+      "suggested_scalar": 0.0158,
+      "log_bad": -1.0413,
+      "log_good": -1.0172
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 62.0,
+      "good": 57.0,
+      "ratio": 0.9194,
+      "suggested_scalar": -0.0552,
+      "log_bad": 4.1271,
+      "log_good": 4.0431
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 640.0,
+      "good": 525.0,
+      "ratio": 0.8203,
+      "suggested_scalar": -0.1301,
+      "log_bad": 6.4615,
+      "log_good": 6.2634
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 82.0,
+      "good": 75.0,
+      "ratio": 0.9146,
+      "suggested_scalar": -0.0586,
+      "log_bad": 4.4067,
+      "log_good": 4.3175
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2037,
+      "good": 0.216,
+      "ratio": 1.0604,
+      "suggested_scalar": 0.0385,
+      "log_bad": -1.5911,
+      "log_good": -1.5325
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 43.0,
+      "good": 38.0,
+      "ratio": 0.8837,
+      "suggested_scalar": -0.0812,
+      "log_bad": 3.7612,
+      "log_good": 3.6376
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 9.0,
+      "good": 10.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0692,
+      "log_bad": 2.1972,
+      "log_good": 2.3026
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 62.0,
+      "good": 57.0,
+      "ratio": 0.9194,
+      "suggested_scalar": -0.0552,
+      "log_bad": 4.1271,
+      "log_good": 4.0431
+    },
+    "brevity.mean_sample_size": {
+      "bad": 62.0,
+      "good": 57.0,
+      "ratio": 0.9194,
+      "suggested_scalar": -0.0552,
+      "log_bad": 4.1271,
+      "log_good": 4.0431
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 216.0,
+      "good": 213.0,
+      "ratio": 0.9861,
+      "suggested_scalar": -0.0092,
+      "log_bad": 5.3753,
+      "log_good": 5.3613
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 114.0,
+      "good": 112.0,
+      "ratio": 0.9825,
+      "suggested_scalar": -0.0116,
+      "log_bad": 4.7362,
+      "log_good": 4.7185
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 133.0,
+      "good": 140.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0337,
+      "log_bad": 4.8903,
+      "log_good": 4.9416
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0046,
+      "good": 0.0047,
+      "ratio": 1.0217,
+      "suggested_scalar": 0.0141,
+      "log_bad": -5.3817,
+      "log_good": -5.3602
+    },
+    "heaps.mean_k": {
+      "bad": 1.8274,
+      "good": 2.2782,
+      "ratio": 1.2467,
+      "suggested_scalar": 0.1448,
+      "log_bad": 0.6029,
+      "log_good": 0.8234
+    },
+    "halstead.mean_effort": {
+      "bad": 19059.7635,
+      "good": 25573.0564,
+      "ratio": 1.3417,
+      "suggested_scalar": 0.1931,
+      "log_bad": 9.8553,
+      "log_good": 10.1493
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8947,
+      "good": 0.8946,
+      "ratio": 0.9999,
+      "suggested_scalar": -0.0001,
+      "log_bad": -0.1113,
+      "log_good": -0.1114
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 41.0,
+      "good": 35.0,
+      "ratio": 0.8537,
+      "suggested_scalar": -0.1039,
+      "log_bad": 3.7136,
+      "log_good": 3.5553
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 98.0,
+      "good": 111.0,
+      "ratio": 1.1327,
+      "suggested_scalar": 0.0818,
+      "log_bad": 4.585,
+      "log_good": 4.7095
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4938,
+      "good": 0.4366,
+      "ratio": 0.8842,
+      "suggested_scalar": -0.0809,
+      "log_bad": -0.7056,
+      "log_good": -0.8287
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.9012,
+      "good": 7.3944,
+      "ratio": 0.9359,
+      "suggested_scalar": -0.0435,
+      "log_bad": 2.067,
+      "log_good": 2.0007
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2041,
+      "good": 0.2364,
+      "ratio": 1.1583,
+      "suggested_scalar": 0.0965,
+      "log_bad": -1.5891,
+      "log_good": -1.4422
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.7762,
+      "good": 2.8286,
+      "ratio": 0.5922,
+      "suggested_scalar": -0.3441,
+      "log_bad": 1.5636,
+      "log_good": 1.0398
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 215.0,
+      "good": 212.0,
+      "ratio": 0.986,
+      "suggested_scalar": -0.0092,
+      "log_bad": 5.3706,
+      "log_good": 5.3566
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.4553,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 22.0,
+      "good": 18.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.1318,
+      "log_bad": 3.091,
+      "log_good": 2.8904
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1058.8757,
+      "good": 1420.7254,
+      "ratio": 1.3417,
+      "suggested_scalar": 0.1931,
+      "log_bad": 6.965,
+      "log_good": 7.2589
+    },
+    "readability.mean_total_lines": {
+      "bad": 36.0,
+      "good": 42.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.1013,
+      "log_bad": 3.5835,
+      "log_good": 3.7377
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 1058.8757,
+      "good": 1084.9175,
+      "ratio": 1.0246,
+      "suggested_scalar": 0.016,
+      "log_bad": 6.965,
+      "log_good": 6.9893
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 424.0,
+      "good": 411.0,
+      "ratio": 0.9693,
+      "suggested_scalar": -0.0205,
+      "log_bad": 6.0497,
+      "log_good": 6.0186
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 23.7778,
+      "good": 21.9286,
+      "ratio": 0.9222,
+      "suggested_scalar": -0.0532,
+      "log_bad": 3.1688,
+      "log_good": 3.0878
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.3663,
+      "good": 1.23,
+      "ratio": 0.9002,
+      "suggested_scalar": -0.069,
+      "log_bad": 0.3121,
+      "log_good": 0.207
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 5.0,
+      "good": 7.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.221,
+      "log_bad": 1.6094,
+      "log_good": 1.9459
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.7216,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8757,
+      "good": 0.8994,
+      "ratio": 1.0271,
+      "suggested_scalar": 0.0175,
+      "log_bad": -0.1327,
+      "log_good": -0.106
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9791,
+      "good": 0.9767,
+      "ratio": 0.9975,
+      "suggested_scalar": -0.0016,
+      "log_bad": -0.0211,
+      "log_good": -0.0236
+    },
+    "halstead.mean_length": {
+      "bad": 180.0,
+      "good": 186.0,
+      "ratio": 1.0333,
+      "suggested_scalar": 0.0215,
+      "log_bad": 5.193,
+      "log_good": 5.2257
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.8889,
+      "good": 5.0,
+      "ratio": 1.0227,
+      "suggested_scalar": 0.0148,
+      "log_bad": 1.587,
+      "log_good": 1.6094
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.9542,
+      "good": 5.8329,
+      "ratio": 0.9796,
+      "suggested_scalar": -0.0135,
+      "log_bad": 1.7841,
+      "log_good": 1.7635
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1091,
+      "good": 0.1148,
+      "ratio": 1.0522,
+      "suggested_scalar": 0.0335,
+      "log_bad": -2.2155,
+      "log_good": -2.1646
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 18.0,
+      "good": 23.5714,
+      "ratio": 1.3095,
+      "suggested_scalar": 0.1771,
+      "log_bad": 2.8904,
+      "log_good": 3.16
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.4553,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 40.0,
+      "good": 31.0,
+      "ratio": 0.775,
+      "suggested_scalar": -0.1674,
+      "log_bad": 3.6889,
+      "log_good": 3.434
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6767,
+      "good": 0.7286,
+      "ratio": 1.0767,
+      "suggested_scalar": 0.0485,
+      "log_bad": -0.3905,
+      "log_good": -0.3166
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 39.0,
+      "good": 42.0,
+      "ratio": 1.0769,
+      "suggested_scalar": 0.0487,
+      "log_bad": 3.6636,
+      "log_good": 3.7377
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 22.0,
+      "good": 20.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0626,
+      "log_bad": 3.091,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.2663,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    }
+  },
+  "type_and_value.uses_isinstance_not_type_comparison": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 42.0,
+      "good": 40.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.1408,
+      "log_bad": 3.7377,
+      "log_good": 3.6889
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0431,
+      "good": 0.0451,
+      "ratio": 1.0464,
+      "suggested_scalar": 0.1309,
+      "log_bad": -3.1442,
+      "log_good": -3.0989
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1667,
+      "good": 0.8333,
+      "ratio": 0.7142,
+      "suggested_scalar": -0.9711,
+      "log_bad": 0.1542,
+      "log_good": -0.1824
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9024,
+      "good": 0.9091,
+      "ratio": 1.0074,
+      "suggested_scalar": 0.0213,
+      "log_bad": -0.1027,
+      "log_good": -0.0953
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0431,
+      "good": 0.0451,
+      "ratio": 1.0464,
+      "suggested_scalar": 0.1309,
+      "log_bad": -3.1442,
+      "log_good": -3.0989
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6883,
+      "good": 4.6352,
+      "ratio": 0.9887,
+      "suggested_scalar": -0.0329,
+      "log_bad": 1.5451,
+      "log_good": 1.5337
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 71.0,
+      "good": 65.0,
+      "ratio": 0.9155,
+      "suggested_scalar": -0.2548,
+      "log_bad": 4.2627,
+      "log_good": 4.1744
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5376,
+      "good": 0.5138,
+      "ratio": 0.9557,
+      "suggested_scalar": -0.1307,
+      "log_bad": -0.6206,
+      "log_good": -0.6659
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 15.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.5261,
+      "log_bad": 2.8904,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6701,
+      "good": 0.6733,
+      "ratio": 1.0048,
+      "suggested_scalar": 0.0137,
+      "log_bad": -0.4003,
+      "log_good": -0.3956
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 2.5366,
+      "good": 2.5455,
+      "ratio": 1.0035,
+      "suggested_scalar": 0.0101,
+      "log_bad": 0.9308,
+      "log_good": 0.9343
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 371.0,
+      "good": 355.0,
+      "ratio": 0.9569,
+      "suggested_scalar": -0.1272,
+      "log_bad": 5.9162,
+      "log_good": 5.8721
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9686,
+      "good": 0.9648,
+      "ratio": 0.9961,
+      "suggested_scalar": -0.0113,
+      "log_bad": -0.0319,
+      "log_good": -0.0358
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 120.0,
+      "good": 123.0,
+      "ratio": 1.025,
+      "suggested_scalar": 0.0712,
+      "log_bad": 4.7875,
+      "log_good": 4.8122
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 88.3755,
+      "good": 90.0016,
+      "ratio": 1.0184,
+      "suggested_scalar": 0.0526,
+      "log_bad": 4.4816,
+      "log_good": 4.4998
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5027,
+      "good": 0.5226,
+      "ratio": 1.0396,
+      "suggested_scalar": 0.112,
+      "log_bad": -0.6878,
+      "log_good": -0.6489
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 26.7716,
+      "good": 26.3468,
+      "ratio": 0.9841,
+      "suggested_scalar": -0.0462,
+      "log_bad": 3.2873,
+      "log_good": 3.2713
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1850.0,
+      "good": 1810.0,
+      "ratio": 0.9784,
+      "suggested_scalar": -0.0631,
+      "log_bad": 7.5229,
+      "log_good": 7.5011
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2195,
+      "good": 0.1591,
+      "ratio": 0.7248,
+      "suggested_scalar": -0.9286,
+      "log_bad": -1.5164,
+      "log_good": -1.8382
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9024,
+      "good": 0.9091,
+      "ratio": 1.0074,
+      "suggested_scalar": 0.0213,
+      "log_bad": -0.1027,
+      "log_good": -0.0953
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.0488,
+      "good": 8.0682,
+      "ratio": 0.8916,
+      "suggested_scalar": -0.331,
+      "log_bad": 2.2026,
+      "log_good": 2.0879
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 6.0535,
+      "good": 5.8843,
+      "ratio": 0.972,
+      "suggested_scalar": -0.0818,
+      "log_bad": 1.8006,
+      "log_good": 1.7723
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 91.0,
+      "good": 94.0,
+      "ratio": 1.033,
+      "suggested_scalar": 0.0936,
+      "log_bad": 4.5109,
+      "log_good": 4.5433
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9552,
+      "good": 0.9535,
+      "ratio": 0.9982,
+      "suggested_scalar": -0.0051,
+      "log_bad": -0.0458,
+      "log_good": -0.0476
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 22.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.091,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6373,
+      "good": 0.6486,
+      "ratio": 1.0177,
+      "suggested_scalar": 0.0507,
+      "log_bad": -0.4505,
+      "log_good": -0.4329
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3388,
+      "good": 0.3258,
+      "ratio": 0.9616,
+      "suggested_scalar": -0.1129,
+      "log_bad": -1.0823,
+      "log_good": -1.1215
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7571,
+      "good": 2.8459,
+      "ratio": 1.0322,
+      "suggested_scalar": 0.0915,
+      "log_bad": 1.0142,
+      "log_good": 1.0459
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 369.0,
+      "good": 353.0,
+      "ratio": 0.9566,
+      "suggested_scalar": -0.1279,
+      "log_bad": 5.9108,
+      "log_good": 5.8665
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0755,
+      "good": 0.0704,
+      "ratio": 0.9325,
+      "suggested_scalar": -0.2018,
+      "log_bad": -2.5836,
+      "log_good": -2.6536
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8329,
+      "good": 5.7279,
+      "ratio": 0.982,
+      "suggested_scalar": -0.0524,
+      "log_bad": 1.7635,
+      "log_good": 1.7453
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8853,
+      "good": 0.8733,
+      "ratio": 0.9864,
+      "suggested_scalar": -0.0394,
+      "log_bad": -0.1218,
+      "log_good": -0.1355
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7132,
+      "good": 5.6654,
+      "ratio": 0.9916,
+      "suggested_scalar": -0.0242,
+      "log_bad": 1.7428,
+      "log_good": 1.7344
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8038,
+      "good": 0.8092,
+      "ratio": 1.0067,
+      "suggested_scalar": 0.0193,
+      "log_bad": -0.2184,
+      "log_good": -0.2117
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.3387,
+      "good": 0.3231,
+      "ratio": 0.9539,
+      "suggested_scalar": -0.1361,
+      "log_bad": -1.0826,
+      "log_good": -1.1298
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 5.1741,
+      "good": 5.1329,
+      "ratio": 0.992,
+      "suggested_scalar": -0.0231,
+      "log_bad": 1.6437,
+      "log_good": 1.6357
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 282.0,
+      "good": 275.0,
+      "ratio": 0.9752,
+      "suggested_scalar": -0.0725,
+      "log_bad": 5.6419,
+      "log_good": 5.6168
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 10.0,
+      "good": 14.0,
+      "ratio": 1.4,
+      "suggested_scalar": 0.9709,
+      "log_bad": 2.3026,
+      "log_good": 2.6391
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5617,
+      "good": 0.5199,
+      "ratio": 0.9256,
+      "suggested_scalar": -0.2231,
+      "log_bad": -0.5768,
+      "log_good": -0.6541
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 102.0,
+      "good": 98.0,
+      "ratio": 0.9608,
+      "suggested_scalar": -0.1154,
+      "log_bad": 4.625,
+      "log_good": 4.585
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1033.0,
+      "good": 1042.0,
+      "ratio": 1.0087,
+      "suggested_scalar": 0.025,
+      "log_bad": 6.9402,
+      "log_good": 6.9489
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 117.0,
+      "good": 106.0,
+      "ratio": 0.906,
+      "suggested_scalar": -0.2849,
+      "log_bad": 4.7622,
+      "log_good": 4.6634
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0162,
+      "good": 0.0169,
+      "ratio": 1.0432,
+      "suggested_scalar": 0.1221,
+      "log_bad": -4.1227,
+      "log_good": -4.0804
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2588,
+      "good": 0.262,
+      "ratio": 1.0124,
+      "suggested_scalar": 0.0355,
+      "log_bad": -1.3517,
+      "log_good": -1.3394
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 46.0,
+      "good": 49.0,
+      "ratio": 1.0652,
+      "suggested_scalar": 0.1823,
+      "log_bad": 3.8286,
+      "log_good": 3.8918
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 102.0,
+      "good": 98.0,
+      "ratio": 0.9608,
+      "suggested_scalar": -0.1154,
+      "log_bad": 4.625,
+      "log_good": 4.585
+    },
+    "brevity.mean_sample_size": {
+      "bad": 102.0,
+      "good": 98.0,
+      "ratio": 0.9608,
+      "suggested_scalar": -0.1154,
+      "log_bad": 4.625,
+      "log_good": 4.585
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 371.0,
+      "good": 355.0,
+      "ratio": 0.9569,
+      "suggested_scalar": -0.1272,
+      "log_bad": 5.9162,
+      "log_good": 5.8721
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 177.0,
+      "good": 163.0,
+      "ratio": 0.9209,
+      "suggested_scalar": -0.2378,
+      "log_bad": 5.1761,
+      "log_good": 5.0938
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 230.0,
+      "good": 218.0,
+      "ratio": 0.9478,
+      "suggested_scalar": -0.1546,
+      "log_bad": 5.4381,
+      "log_good": 5.3845
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.9004,
+      "good": 1.8763,
+      "ratio": 0.9873,
+      "suggested_scalar": -0.0368,
+      "log_bad": 0.6421,
+      "log_good": 0.6293
+    },
+    "halstead.mean_effort": {
+      "bad": 44257.8474,
+      "good": 42295.7894,
+      "ratio": 0.9557,
+      "suggested_scalar": -0.1308,
+      "log_bad": 10.6978,
+      "log_good": 10.6524
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8562,
+      "good": 0.8565,
+      "ratio": 1.0004,
+      "suggested_scalar": 0.001,
+      "log_bad": -0.1553,
+      "log_good": -0.1549
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 49.0,
+      "good": 43.0,
+      "ratio": 0.8776,
+      "suggested_scalar": -0.3769,
+      "log_bad": 3.8918,
+      "log_good": 3.7612
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 157.0,
+      "good": 153.0,
+      "ratio": 0.9745,
+      "suggested_scalar": -0.0745,
+      "log_bad": 5.0562,
+      "log_good": 5.0304
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5583,
+      "good": 0.5122,
+      "ratio": 0.9174,
+      "suggested_scalar": -0.2487,
+      "log_bad": -0.5829,
+      "log_good": -0.669
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.6083,
+      "good": 8.4715,
+      "ratio": 0.9841,
+      "suggested_scalar": -0.0462,
+      "log_bad": 2.1527,
+      "log_good": 2.1367
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.3387,
+      "good": 0.3231,
+      "ratio": 0.9539,
+      "suggested_scalar": -0.1361,
+      "log_bad": -1.0826,
+      "log_good": -1.1298
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.5362,
+      "good": 5.9641,
+      "ratio": 0.9125,
+      "suggested_scalar": -0.2643,
+      "log_bad": 1.8774,
+      "log_good": 1.7858
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 370.0,
+      "good": 354.0,
+      "ratio": 0.9568,
+      "suggested_scalar": -0.1276,
+      "log_bad": 5.9135,
+      "log_good": 5.8693
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 38.0,
+      "good": 37.0,
+      "ratio": 0.9737,
+      "suggested_scalar": -0.0769,
+      "log_bad": 3.6376,
+      "log_good": 3.6109
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2458.7693,
+      "good": 2349.7661,
+      "ratio": 0.9557,
+      "suggested_scalar": -0.1308,
+      "log_bad": 7.8074,
+      "log_good": 7.7621
+    },
+    "readability.mean_total_lines": {
+      "bad": 41.0,
+      "good": 44.0,
+      "ratio": 1.0732,
+      "suggested_scalar": 0.2038,
+      "log_bad": 3.7136,
+      "log_good": 3.7842
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 1685.0307,
+      "good": 1559.7933,
+      "ratio": 0.9257,
+      "suggested_scalar": -0.2228,
+      "log_bad": 7.4295,
+      "log_good": 7.3523
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 671.0,
+      "good": 636.0,
+      "ratio": 0.9478,
+      "suggested_scalar": -0.1546,
+      "log_bad": 6.5088,
+      "log_good": 6.4552
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 43.5122,
+      "good": 39.5682,
+      "ratio": 0.9094,
+      "suggested_scalar": -0.2742,
+      "log_bad": 3.773,
+      "log_good": 3.678
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2917,
+      "good": 1.2842,
+      "ratio": 0.9942,
+      "suggested_scalar": -0.0168,
+      "log_bad": 0.256,
+      "log_good": 0.2501
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8652,
+      "good": 0.8655,
+      "ratio": 1.0003,
+      "suggested_scalar": 0.001,
+      "log_bad": -0.1448,
+      "log_good": -0.1444
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9877,
+      "good": 0.9876,
+      "ratio": 0.9999,
+      "suggested_scalar": -0.0003,
+      "log_bad": -0.0124,
+      "log_good": -0.0125
+    },
+    "halstead.mean_length": {
+      "bad": 274.0,
+      "good": 259.0,
+      "ratio": 0.9453,
+      "suggested_scalar": -0.1624,
+      "log_bad": 5.6131,
+      "log_good": 5.5568
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.1667,
+      "good": 5.6667,
+      "ratio": 1.0968,
+      "suggested_scalar": 0.2665,
+      "log_bad": 1.6422,
+      "log_good": 1.7346
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6724,
+      "good": 6.6147,
+      "ratio": 0.9914,
+      "suggested_scalar": -0.0251,
+      "log_bad": 1.898,
+      "log_good": 1.8893
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0959,
+      "good": 0.0903,
+      "ratio": 0.9416,
+      "suggested_scalar": -0.1736,
+      "log_bad": -2.3444,
+      "log_good": -2.4046
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 26.2653,
+      "good": 27.1163,
+      "ratio": 1.0324,
+      "suggested_scalar": 0.092,
+      "log_bad": 3.2682,
+      "log_good": 3.3001
+    },
+    "branching.mean_branch_count": {
+      "bad": 9.0,
+      "good": 7.0,
+      "ratio": 0.7778,
+      "suggested_scalar": -0.7251,
+      "log_bad": 2.1972,
+      "log_good": 1.9459
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 67.0,
+      "good": 63.0,
+      "ratio": 0.9403,
+      "suggested_scalar": -0.1776,
+      "log_bad": 4.2047,
+      "log_good": 4.1431
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8,
+      "good": 0.7752,
+      "ratio": 0.969,
+      "suggested_scalar": -0.0909,
+      "log_bad": -0.2231,
+      "log_good": -0.2546
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 41.0,
+      "good": 44.0,
+      "ratio": 1.0732,
+      "suggested_scalar": 0.2038,
+      "log_bad": 3.7136,
+      "log_good": 3.7842
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_c_style_casts": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 7.0,
+      "good": 4.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -0.6954,
+      "log_bad": 1.9459,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0041,
+      "good": 0.0044,
+      "ratio": 1.0732,
+      "suggested_scalar": 0.0878,
+      "log_bad": -5.4968,
+      "log_good": -5.4262
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9259,
+      "good": 0.94,
+      "ratio": 1.0152,
+      "suggested_scalar": 0.0188,
+      "log_bad": -0.077,
+      "log_good": -0.0619
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0041,
+      "good": 0.0044,
+      "ratio": 1.0732,
+      "suggested_scalar": 0.0878,
+      "log_bad": -5.4968,
+      "log_good": -5.4262
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6721,
+      "good": 4.654,
+      "ratio": 0.9961,
+      "suggested_scalar": -0.0048,
+      "log_bad": 1.5416,
+      "log_good": 1.5377
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 118.0,
+      "good": 115.0,
+      "ratio": 0.9746,
+      "suggested_scalar": -0.032,
+      "log_bad": 4.7707,
+      "log_good": 4.7449
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5072,
+      "good": 0.5239,
+      "ratio": 1.0329,
+      "suggested_scalar": 0.0403,
+      "log_bad": -0.6788,
+      "log_good": -0.6465
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 23.0,
+      "good": 21.0,
+      "ratio": 0.913,
+      "suggested_scalar": -0.113,
+      "log_bad": 3.1355,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7675,
+      "good": 0.7717,
+      "ratio": 1.0055,
+      "suggested_scalar": 0.0068,
+      "log_bad": -0.2646,
+      "log_good": -0.2592
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.3333,
+      "good": 5.44,
+      "ratio": 1.02,
+      "suggested_scalar": 0.0246,
+      "log_bad": 1.674,
+      "log_good": 1.6938
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 484.0,
+      "good": 450.0,
+      "ratio": 0.9298,
+      "suggested_scalar": -0.0905,
+      "log_bad": 6.1821,
+      "log_good": 6.1092
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1852,
+      "good": 0.2,
+      "ratio": 1.0799,
+      "suggested_scalar": 0.0955,
+      "log_bad": -1.6863,
+      "log_good": -1.6094
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0147,
+      "good": 0.9832,
+      "ratio": 0.969,
+      "suggested_scalar": -0.0392,
+      "log_bad": 0.0146,
+      "log_good": -0.0169
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 177.0,
+      "good": 156.0,
+      "ratio": 0.8814,
+      "suggested_scalar": -0.1569,
+      "log_bad": 5.1761,
+      "log_good": 5.0499
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 98.0488,
+      "good": 96.5949,
+      "ratio": 0.9852,
+      "suggested_scalar": -0.0186,
+      "log_bad": 4.5855,
+      "log_good": 4.5705
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5487,
+      "good": 0.5657,
+      "ratio": 1.031,
+      "suggested_scalar": 0.0379,
+      "log_bad": -0.6002,
+      "log_good": -0.5697
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.5672,
+      "good": 9.712,
+      "ratio": 1.2834,
+      "suggested_scalar": 0.3101,
+      "log_bad": 2.0238,
+      "log_good": 2.2734
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2075.0,
+      "good": 1934.0,
+      "ratio": 0.932,
+      "suggested_scalar": -0.0874,
+      "log_bad": 7.6377,
+      "log_good": 7.5673
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0741,
+      "good": 0.08,
+      "ratio": 1.0796,
+      "suggested_scalar": 0.0952,
+      "log_bad": -2.6023,
+      "log_good": -2.5257
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9259,
+      "good": 0.94,
+      "ratio": 1.0152,
+      "suggested_scalar": 0.0188,
+      "log_bad": -0.077,
+      "log_good": -0.0619
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.8776,
+      "good": 10.0,
+      "ratio": 1.0124,
+      "suggested_scalar": 0.0153,
+      "log_bad": 2.2903,
+      "log_good": 2.3026
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 43.0,
+      "good": 36.0,
+      "ratio": 0.8372,
+      "suggested_scalar": -0.2208,
+      "log_bad": 3.7612,
+      "log_good": 3.5835
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 10.6667,
+      "good": 15.8464,
+      "ratio": 1.4856,
+      "suggested_scalar": 0.4919,
+      "log_bad": 2.3671,
+      "log_good": 2.7629
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 116.0,
+      "good": 106.0,
+      "ratio": 0.9138,
+      "suggested_scalar": -0.112,
+      "log_bad": 4.7536,
+      "log_good": 4.6634
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.928,
+      "good": 0.9403,
+      "ratio": 1.0133,
+      "suggested_scalar": 0.0164,
+      "log_bad": -0.0747,
+      "log_good": -0.0616
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 34.0,
+      "good": 33.0,
+      "ratio": 0.9706,
+      "suggested_scalar": -0.0371,
+      "log_bad": 3.5264,
+      "log_good": 3.4965
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6077,
+      "good": 0.5946,
+      "ratio": 0.9784,
+      "suggested_scalar": -0.0271,
+      "log_bad": -0.4981,
+      "log_good": -0.5199
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3299,
+      "good": 0.346,
+      "ratio": 1.0488,
+      "suggested_scalar": 0.0592,
+      "log_bad": -1.109,
+      "log_good": -1.0613
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5491,
+      "good": 2.4668,
+      "ratio": 0.9677,
+      "suggested_scalar": -0.0408,
+      "log_bad": 0.9357,
+      "log_good": 0.9029
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 482.0,
+      "good": 448.0,
+      "ratio": 0.9295,
+      "suggested_scalar": -0.0909,
+      "log_bad": 6.1779,
+      "log_good": 6.1048
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0372,
+      "good": 0.0444,
+      "ratio": 1.1935,
+      "suggested_scalar": 0.2199,
+      "log_bad": -3.2914,
+      "log_good": -3.1145
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0444,
+      "good": 6.0,
+      "ratio": 0.9927,
+      "suggested_scalar": -0.0092,
+      "log_bad": 1.7991,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 11.0,
+      "good": 10.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.1184,
+      "log_bad": 2.3979,
+      "log_good": 2.3026
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3288,
+      "good": 1.2566,
+      "ratio": 0.9457,
+      "suggested_scalar": -0.0694,
+      "log_bad": 0.2843,
+      "log_good": 0.2284
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9611,
+      "good": 5.9142,
+      "ratio": 0.9921,
+      "suggested_scalar": -0.0098,
+      "log_bad": 1.7853,
+      "log_good": 1.7774
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.773,
+      "good": 0.7757,
+      "ratio": 1.0035,
+      "suggested_scalar": 0.0043,
+      "log_bad": -0.2575,
+      "log_good": -0.254
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1692,
+      "good": 0.1667,
+      "ratio": 0.9852,
+      "suggested_scalar": -0.0185,
+      "log_bad": -1.7767,
+      "log_good": -1.7916
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.7508,
+      "good": 3.1164,
+      "ratio": 1.1329,
+      "suggested_scalar": 0.1551,
+      "log_bad": 1.0119,
+      "log_good": 1.1367
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 369.0,
+      "good": 349.0,
+      "ratio": 0.9458,
+      "suggested_scalar": -0.0692,
+      "log_bad": 5.9108,
+      "log_good": 5.8551
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 11.0,
+      "good": 13.0,
+      "ratio": 1.1818,
+      "suggested_scalar": 0.2076,
+      "log_bad": 2.3979,
+      "log_good": 2.5649
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0576,
+      "good": 0.9835,
+      "ratio": 0.9299,
+      "suggested_scalar": -0.0903,
+      "log_bad": 0.056,
+      "log_good": -0.0166
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 121.0,
+      "good": 119.0,
+      "ratio": 0.9835,
+      "suggested_scalar": -0.0207,
+      "log_bad": 4.7958,
+      "log_good": 4.7791
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 996.0,
+      "good": 924.0,
+      "ratio": 0.9277,
+      "suggested_scalar": -0.0932,
+      "log_bad": 6.9037,
+      "log_good": 6.8287
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 209.0,
+      "good": 188.0,
+      "ratio": 0.8995,
+      "suggested_scalar": -0.1316,
+      "log_bad": 5.3423,
+      "log_good": 5.2364
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2335,
+      "good": 0.2333,
+      "ratio": 0.9991,
+      "suggested_scalar": -0.0011,
+      "log_bad": -1.4546,
+      "log_good": -1.4554
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 72.0,
+      "good": 78.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.0995,
+      "log_bad": 4.2767,
+      "log_good": 4.3567
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 121.0,
+      "good": 119.0,
+      "ratio": 0.9835,
+      "suggested_scalar": -0.0207,
+      "log_bad": 4.7958,
+      "log_good": 4.7791
+    },
+    "brevity.mean_sample_size": {
+      "bad": 121.0,
+      "good": 119.0,
+      "ratio": 0.9835,
+      "suggested_scalar": -0.0207,
+      "log_bad": 4.7958,
+      "log_good": 4.7791
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 484.0,
+      "good": 450.0,
+      "ratio": 0.9298,
+      "suggested_scalar": -0.0905,
+      "log_bad": 6.1821,
+      "log_good": 6.1092
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 247.0,
+      "good": 233.0,
+      "ratio": 0.9433,
+      "suggested_scalar": -0.0725,
+      "log_bad": 5.5094,
+      "log_good": 5.451
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 290.0,
+      "good": 273.0,
+      "ratio": 0.9414,
+      "suggested_scalar": -0.0751,
+      "log_bad": 5.6699,
+      "log_good": 5.6095
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.1667,
+      "good": 1.2294,
+      "ratio": 1.0537,
+      "suggested_scalar": 0.0651,
+      "log_bad": 0.1542,
+      "log_good": 0.2065
+    },
+    "halstead.mean_effort": {
+      "bad": 134206.0497,
+      "good": 111611.7082,
+      "ratio": 0.8316,
+      "suggested_scalar": -0.2291,
+      "log_bad": 11.8071,
+      "log_good": 11.6228
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8616,
+      "good": 0.8578,
+      "ratio": 0.9956,
+      "suggested_scalar": -0.0055,
+      "log_bad": -0.149,
+      "log_good": -0.1534
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 84.0,
+      "good": 82.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0299,
+      "log_bad": 4.4308,
+      "log_good": 4.4067
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 252.0,
+      "good": 243.0,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.0452,
+      "log_bad": 5.5294,
+      "log_good": 5.4931
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4181,
+      "good": 0.4551,
+      "ratio": 1.0885,
+      "suggested_scalar": 0.1054,
+      "log_bad": -0.872,
+      "log_good": -0.7872
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.6271,
+      "good": 5.9231,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0637,
+      "log_bad": 1.7276,
+      "log_good": 1.7789
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1692,
+      "good": 0.1667,
+      "ratio": 0.9852,
+      "suggested_scalar": -0.0185,
+      "log_bad": -1.7767,
+      "log_good": -1.7916
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.466,
+      "good": 4.3756,
+      "ratio": 0.9798,
+      "suggested_scalar": -0.0254,
+      "log_bad": 1.4965,
+      "log_good": 1.476
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 483.0,
+      "good": 449.0,
+      "ratio": 0.9296,
+      "suggested_scalar": -0.0907,
+      "log_bad": 6.18,
+      "log_good": 6.107
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 46.0,
+      "good": 56.0,
+      "ratio": 1.2174,
+      "suggested_scalar": 0.2444,
+      "log_bad": 3.8286,
+      "log_good": 4.0254
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 7455.8917,
+      "good": 6200.6505,
+      "ratio": 0.8316,
+      "suggested_scalar": -0.2291,
+      "log_bad": 8.9168,
+      "log_good": 8.7324
+    },
+    "readability.mean_total_lines": {
+      "bad": 49.0,
+      "good": 45.0,
+      "ratio": 0.9184,
+      "suggested_scalar": -0.1058,
+      "log_bad": 3.8918,
+      "log_good": 3.8067
+    },
+    "indentation.mean_max_depth": {
+      "bad": 12.0,
+      "good": 20.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.6348,
+      "log_bad": 2.4849,
+      "log_good": 2.9957
+    },
+    "halstead.mean_volume": {
+      "bad": 3172.8984,
+      "good": 2950.4062,
+      "ratio": 0.9299,
+      "suggested_scalar": -0.0903,
+      "log_bad": 8.0624,
+      "log_good": 7.9897
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 814.0,
+      "good": 784.0,
+      "ratio": 0.9631,
+      "suggested_scalar": -0.0467,
+      "log_bad": 6.702,
+      "log_good": 6.6644
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 39.0204,
+      "good": 39.5556,
+      "ratio": 1.0137,
+      "suggested_scalar": 0.0169,
+      "log_bad": 3.6641,
+      "log_good": 3.6777
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1674,
+      "good": 1.1831,
+      "ratio": 1.0134,
+      "suggested_scalar": 0.0166,
+      "log_bad": 0.1548,
+      "log_good": 0.1681
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 1.7227,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 10.0,
+      "good": 10.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3026,
+      "log_good": 2.3026
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8753,
+      "good": 0.8395,
+      "ratio": 0.9591,
+      "suggested_scalar": -0.0519,
+      "log_bad": -0.1332,
+      "log_good": -0.1749
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9758,
+      "good": 0.9593,
+      "ratio": 0.9831,
+      "suggested_scalar": -0.0212,
+      "log_bad": -0.0245,
+      "log_good": -0.0416
+    },
+    "halstead.mean_length": {
+      "bad": 461.0,
+      "good": 431.0,
+      "ratio": 0.9349,
+      "suggested_scalar": -0.0836,
+      "log_bad": 6.1334,
+      "log_good": 6.0661
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9189,
+      "good": 6.8948,
+      "ratio": 0.9965,
+      "suggested_scalar": -0.0043,
+      "log_bad": 1.9343,
+      "log_good": 1.9308
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1195,
+      "good": 0.1207,
+      "ratio": 1.01,
+      "suggested_scalar": 0.0124,
+      "log_bad": -2.1244,
+      "log_good": -2.1144
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 42.2976,
+      "good": 37.8293,
+      "ratio": 0.8944,
+      "suggested_scalar": -0.1387,
+      "log_bad": 3.7447,
+      "log_good": 3.6331
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 74.0,
+      "good": 71.0,
+      "ratio": 0.9595,
+      "suggested_scalar": -0.0514,
+      "log_bad": 4.3041,
+      "log_good": 4.2627
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7517,
+      "good": 0.7143,
+      "ratio": 0.9502,
+      "suggested_scalar": -0.0634,
+      "log_bad": -0.2854,
+      "log_good": -0.3365
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 54.0,
+      "good": 50.0,
+      "ratio": 0.9259,
+      "suggested_scalar": -0.0956,
+      "log_bad": 3.989,
+      "log_good": 3.912
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_global_scope_pollution": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 43.0,
+      "good": 13.0,
+      "ratio": 0.3023,
+      "suggested_scalar": -0.36,
+      "log_bad": 3.7612,
+      "log_good": 2.5649
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 12.0,
+      "good": 3.0,
+      "ratio": 0.25,
+      "suggested_scalar": -0.4172,
+      "log_bad": 2.4849,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2086,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0232,
+      "good": 0.0183,
+      "ratio": 0.7888,
+      "suggested_scalar": -0.0714,
+      "log_bad": -3.7636,
+      "log_good": -4.0009
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.8,
+      "good": 1.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0672,
+      "log_bad": -0.2231,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.88,
+      "good": 0.8596,
+      "ratio": 0.9768,
+      "suggested_scalar": -0.0071,
+      "log_bad": -0.1278,
+      "log_good": -0.1513
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0232,
+      "good": 0.0183,
+      "ratio": 0.7888,
+      "suggested_scalar": -0.0714,
+      "log_bad": -3.7636,
+      "log_good": -4.0009
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 5.1318,
+      "good": 4.9418,
+      "ratio": 0.963,
+      "suggested_scalar": -0.0114,
+      "log_bad": 1.6355,
+      "log_good": 1.5977
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 74.0,
+      "good": 86.0,
+      "ratio": 1.1622,
+      "suggested_scalar": 0.0452,
+      "log_bad": 4.3041,
+      "log_good": 4.4543
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.49,
+      "good": 0.596,
+      "ratio": 1.2163,
+      "suggested_scalar": 0.0589,
+      "log_bad": -0.7133,
+      "log_good": -0.5175
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 16.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.0182,
+      "log_bad": 2.8332,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6441,
+      "good": 0.6037,
+      "ratio": 0.9373,
+      "suggested_scalar": -0.0195,
+      "log_bad": -0.4399,
+      "log_good": -0.5047
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.76,
+      "good": 3.2982,
+      "ratio": 1.874,
+      "suggested_scalar": 0.189,
+      "log_bad": 0.5653,
+      "log_good": 1.1934
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 345.0,
+      "good": 382.0,
+      "ratio": 1.1072,
+      "suggested_scalar": 0.0307,
+      "log_bad": 5.8435,
+      "log_good": 5.9454
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0549,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0013,
+      "good": 1.0,
+      "ratio": 769.2308,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.6454,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0743,
+      "good": 1.0449,
+      "ratio": 0.9726,
+      "suggested_scalar": -0.0084,
+      "log_bad": 0.0717,
+      "log_good": 0.0439
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 110.0,
+      "good": 99.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0317,
+      "log_bad": 4.7005,
+      "log_good": 4.5951
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 72.6036,
+      "good": 88.5941,
+      "ratio": 1.2202,
+      "suggested_scalar": 0.0599,
+      "log_bad": 4.285,
+      "log_good": 4.4841
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5407,
+      "good": 0.5118,
+      "ratio": 0.9466,
+      "suggested_scalar": -0.0165,
+      "log_bad": -0.6149,
+      "log_good": -0.6698
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 24.1408,
+      "good": 15.6464,
+      "ratio": 0.6481,
+      "suggested_scalar": -0.1305,
+      "log_bad": 3.1839,
+      "log_good": 2.7502
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1595.0,
+      "good": 1592.0,
+      "ratio": 0.9981,
+      "suggested_scalar": -0.0006,
+      "log_bad": 7.3746,
+      "log_good": 7.3727
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.06,
+      "good": 0.0702,
+      "ratio": 1.17,
+      "suggested_scalar": 0.0473,
+      "log_bad": -2.8134,
+      "log_good": -2.6564
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.84,
+      "good": 0.7895,
+      "ratio": 0.9399,
+      "suggested_scalar": -0.0187,
+      "log_bad": -0.1744,
+      "log_good": -0.2364
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.9,
+      "good": 6.7018,
+      "ratio": 0.9713,
+      "suggested_scalar": -0.0088,
+      "log_bad": 1.9315,
+      "log_good": 1.9024
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 24.0,
+      "ratio": 24.0,
+      "suggested_scalar": 0.9565,
+      "log_bad": 0.0,
+      "log_good": 3.1781
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.1424,
+      "good": 3.297,
+      "ratio": 1.0492,
+      "suggested_scalar": 0.0145,
+      "log_bad": 1.145,
+      "log_good": 1.193
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 52.0,
+      "good": 45.0,
+      "ratio": 0.8654,
+      "suggested_scalar": -0.0435,
+      "log_bad": 3.9512,
+      "log_good": 3.8067
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9397,
+      "good": 0.9341,
+      "ratio": 0.994,
+      "suggested_scalar": -0.0018,
+      "log_bad": -0.0622,
+      "log_good": -0.0682
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 22.0,
+      "good": 24.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0262,
+      "log_bad": 3.091,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6138,
+      "good": 0.576,
+      "ratio": 0.9384,
+      "suggested_scalar": -0.0191,
+      "log_bad": -0.4881,
+      "log_good": -0.5516
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3265,
+      "good": 0.3105,
+      "ratio": 0.951,
+      "suggested_scalar": -0.0151,
+      "log_bad": -1.1193,
+      "log_good": -1.1696
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.5893,
+      "good": 2.3585,
+      "ratio": 0.9109,
+      "suggested_scalar": -0.0281,
+      "log_bad": 0.9514,
+      "log_good": 0.858
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 343.0,
+      "good": 380.0,
+      "ratio": 1.1079,
+      "suggested_scalar": 0.0308,
+      "log_bad": 5.8377,
+      "log_good": 5.9402
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 19.0,
+      "good": 1.0,
+      "ratio": 0.0526,
+      "suggested_scalar": -0.8862,
+      "log_bad": 2.9444,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0174,
+      "good": 0.0209,
+      "ratio": 1.2011,
+      "suggested_scalar": 0.0552,
+      "log_bad": -4.0513,
+      "log_good": -3.868
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0444,
+      "good": 6.0661,
+      "ratio": 1.0036,
+      "suggested_scalar": 0.0011,
+      "log_bad": 1.7991,
+      "log_good": 1.8027
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 8.0,
+      "good": 11.0,
+      "ratio": 1.375,
+      "suggested_scalar": 0.0958,
+      "log_bad": 2.0794,
+      "log_good": 2.3979
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.5686,
+      "good": 1.9946,
+      "ratio": 1.2716,
+      "suggested_scalar": 0.0723,
+      "log_bad": 0.4502,
+      "log_good": 0.6904
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 0.0636,
+      "good": 0.0606,
+      "ratio": 0.9528,
+      "suggested_scalar": -0.0145,
+      "log_bad": -2.7551,
+      "log_good": -2.8035
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.1957,
+      "good": 5.29,
+      "ratio": 1.0181,
+      "suggested_scalar": 0.0054,
+      "log_bad": 1.6478,
+      "log_good": 1.6658
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.849,
+      "good": 0.8147,
+      "ratio": 0.9596,
+      "suggested_scalar": -0.0124,
+      "log_bad": -0.1637,
+      "log_good": -0.2049
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1525,
+      "good": 0.1618,
+      "ratio": 1.061,
+      "suggested_scalar": 0.0178,
+      "log_bad": -1.8806,
+      "log_good": -1.8214
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.9133,
+      "good": 3.9555,
+      "ratio": 0.8051,
+      "suggested_scalar": -0.0653,
+      "log_bad": 1.5919,
+      "log_good": 1.3751
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 268.0,
+      "good": 300.0,
+      "ratio": 1.1194,
+      "suggested_scalar": 0.0339,
+      "log_bad": 5.591,
+      "log_good": 5.7038
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 17.0,
+      "good": 20.0,
+      "ratio": 1.1765,
+      "suggested_scalar": 0.0489,
+      "log_bad": 2.8332,
+      "log_good": 2.9957
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6561,
+      "good": 0.7669,
+      "ratio": 1.1689,
+      "suggested_scalar": 0.047,
+      "log_bad": -0.4214,
+      "log_good": -0.2654
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 79.0,
+      "good": 89.0,
+      "ratio": 1.1266,
+      "suggested_scalar": 0.0359,
+      "log_bad": 4.3694,
+      "log_good": 4.4886
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1044.0,
+      "good": 802.0,
+      "ratio": 0.7682,
+      "suggested_scalar": -0.0794,
+      "log_bad": 6.9508,
+      "log_good": 6.6871
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 116.0,
+      "good": 129.0,
+      "ratio": 1.1121,
+      "suggested_scalar": 0.032,
+      "log_bad": 4.7536,
+      "log_good": 4.8598
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0029,
+      "good": 0.0026,
+      "ratio": 0.8966,
+      "suggested_scalar": -0.0329,
+      "log_bad": -5.843,
+      "log_good": -5.9522
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2725,
+      "good": 0.2723,
+      "ratio": 0.9993,
+      "suggested_scalar": -0.0002,
+      "log_bad": -1.3001,
+      "log_good": -1.3009
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 51.0,
+      "good": 51.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9318,
+      "log_good": 3.9318
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 1.0,
+      "ratio": 0.2,
+      "suggested_scalar": -0.4844,
+      "log_bad": 1.6094,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 79.0,
+      "good": 89.0,
+      "ratio": 1.1266,
+      "suggested_scalar": 0.0359,
+      "log_bad": 4.3694,
+      "log_good": 4.4886
+    },
+    "brevity.mean_sample_size": {
+      "bad": 79.0,
+      "good": 89.0,
+      "ratio": 1.1266,
+      "suggested_scalar": 0.0359,
+      "log_bad": 4.3694,
+      "log_good": 4.4886
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 345.0,
+      "good": 382.0,
+      "ratio": 1.1072,
+      "suggested_scalar": 0.0307,
+      "log_bad": 5.8435,
+      "log_good": 5.9454
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 212.0,
+      "good": 233.0,
+      "ratio": 1.0991,
+      "suggested_scalar": 0.0284,
+      "log_bad": 5.3566,
+      "log_good": 5.451
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 209.0,
+      "good": 237.0,
+      "ratio": 1.134,
+      "suggested_scalar": 0.0378,
+      "log_bad": 5.3423,
+      "log_good": 5.4681
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0058,
+      "good": 0.0052,
+      "ratio": 0.8966,
+      "suggested_scalar": -0.0329,
+      "log_bad": -5.1499,
+      "log_good": -5.2591
+    },
+    "heaps.mean_k": {
+      "bad": 1.919,
+      "good": 2.3383,
+      "ratio": 1.2185,
+      "suggested_scalar": 0.0595,
+      "log_bad": 0.6518,
+      "log_good": 0.8494
+    },
+    "halstead.mean_effort": {
+      "bad": 48301.4271,
+      "good": 57440.8566,
+      "ratio": 1.1892,
+      "suggested_scalar": 0.0522,
+      "log_bad": 10.7852,
+      "log_good": 10.9585
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8242,
+      "good": 0.8169,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.0027,
+      "log_bad": -0.1933,
+      "log_good": -0.2022
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 52.0,
+      "good": 62.0,
+      "ratio": 1.1923,
+      "suggested_scalar": 0.0529,
+      "log_bad": 3.9512,
+      "log_good": 4.1271
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 201.0,
+      "good": 229.0,
+      "ratio": 1.1393,
+      "suggested_scalar": 0.0393,
+      "log_bad": 5.3033,
+      "log_good": 5.4337
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4636,
+      "good": 0.596,
+      "ratio": 1.2856,
+      "suggested_scalar": 0.0756,
+      "log_bad": -0.7687,
+      "log_good": -0.5175
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 9.4909,
+      "good": 8.101,
+      "ratio": 0.8536,
+      "suggested_scalar": -0.0477,
+      "log_bad": 2.2503,
+      "log_good": 2.092
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1525,
+      "good": 0.1618,
+      "ratio": 1.061,
+      "suggested_scalar": 0.0178,
+      "log_bad": -1.8806,
+      "log_good": -1.8214
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 7.4112,
+      "good": 4.06,
+      "ratio": 0.5478,
+      "suggested_scalar": -0.1811,
+      "log_bad": 2.003,
+      "log_good": 1.4012
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 344.0,
+      "good": 381.0,
+      "ratio": 1.1076,
+      "suggested_scalar": 0.0307,
+      "log_bad": 5.8406,
+      "log_good": 5.9428
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 37.0,
+      "good": 38.0,
+      "ratio": 1.027,
+      "suggested_scalar": 0.008,
+      "log_bad": 3.6109,
+      "log_good": 3.6376
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2683.4126,
+      "good": 3191.1587,
+      "ratio": 1.1892,
+      "suggested_scalar": 0.0522,
+      "log_bad": 7.8948,
+      "log_good": 8.0681
+    },
+    "readability.mean_total_lines": {
+      "bad": 50.0,
+      "good": 57.0,
+      "ratio": 1.14,
+      "suggested_scalar": 0.0394,
+      "log_bad": 3.912,
+      "log_good": 4.0431
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 1968.3967,
+      "good": 2300.6028,
+      "ratio": 1.1688,
+      "suggested_scalar": 0.0469,
+      "log_bad": 7.585,
+      "log_good": 7.7409
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 616.0,
+      "good": 675.0,
+      "ratio": 1.0958,
+      "suggested_scalar": 0.0275,
+      "log_bad": 6.4232,
+      "log_good": 6.5147
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 30.72,
+      "good": 26.7368,
+      "ratio": 0.8703,
+      "suggested_scalar": -0.0418,
+      "log_bad": 3.4249,
+      "log_good": 3.286
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.5039,
+      "good": 1.3172,
+      "ratio": 0.8759,
+      "suggested_scalar": -0.0399,
+      "log_bad": 0.4081,
+      "log_good": 0.2755
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0549,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 37.0,
+      "good": 39.0,
+      "ratio": 1.0541,
+      "suggested_scalar": 0.0158,
+      "log_bad": 3.6109,
+      "log_good": 3.6636
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8619,
+      "good": 0.8733,
+      "ratio": 1.0132,
+      "suggested_scalar": 0.004,
+      "log_bad": -0.1486,
+      "log_good": -0.1355
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.989,
+      "good": 0.9843,
+      "ratio": 0.9952,
+      "suggested_scalar": -0.0014,
+      "log_bad": -0.0111,
+      "log_good": -0.0158
+    },
+    "halstead.mean_length": {
+      "bad": 317.0,
+      "good": 358.0,
+      "ratio": 1.1293,
+      "suggested_scalar": 0.0366,
+      "log_bad": 5.7589,
+      "log_good": 5.8805
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 10.4,
+      "good": 1.0,
+      "ratio": 0.0962,
+      "suggested_scalar": -0.7048,
+      "log_bad": 2.3418,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.3038,
+      "good": 6.4757,
+      "ratio": 1.0273,
+      "suggested_scalar": 0.0081,
+      "log_bad": 1.8412,
+      "log_good": 1.8681
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1329,
+      "good": 0.1464,
+      "ratio": 1.1016,
+      "suggested_scalar": 0.0291,
+      "log_bad": -2.0182,
+      "log_good": -1.9214
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 24.5385,
+      "good": 24.9677,
+      "ratio": 1.0175,
+      "suggested_scalar": 0.0052,
+      "log_bad": 3.2002,
+      "log_good": 3.2176
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0866,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 51.0,
+      "good": 59.0,
+      "ratio": 1.1569,
+      "suggested_scalar": 0.0439,
+      "log_bad": 3.9318,
+      "log_good": 4.0775
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.756,
+      "good": 0.7848,
+      "ratio": 1.0381,
+      "suggested_scalar": 0.0113,
+      "log_bad": -0.2797,
+      "log_good": -0.2423
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 50.0,
+      "good": 57.0,
+      "ratio": 1.14,
+      "suggested_scalar": 0.0394,
+      "log_bad": 3.912,
+      "log_good": 4.0431
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 22.0,
+      "good": 20.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0287,
+      "log_bad": 3.091,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 7.0,
+      "good": 6.0,
+      "ratio": 0.8571,
+      "suggested_scalar": -0.0464,
+      "log_bad": 1.9459,
+      "log_good": 1.7918
+    }
+  },
+  "naming_conventions.does_not_repeat_module_name_in_type": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0056,
+      "good": 0.0029,
+      "ratio": 0.5179,
+      "suggested_scalar": -1.3187,
+      "log_bad": -5.185,
+      "log_good": -5.843
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.3333,
+      "good": 2.0,
+      "ratio": 0.8572,
+      "suggested_scalar": -0.3089,
+      "log_bad": 0.8473,
+      "log_good": 0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8545,
+      "good": 0.8364,
+      "ratio": 0.9788,
+      "suggested_scalar": -0.0429,
+      "log_bad": -0.1572,
+      "log_good": -0.1786
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0056,
+      "good": 0.0029,
+      "ratio": 0.5179,
+      "suggested_scalar": -1.3187,
+      "log_bad": -5.185,
+      "log_good": -5.843
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4756,
+      "good": 4.3638,
+      "ratio": 0.975,
+      "suggested_scalar": -0.0507,
+      "log_bad": 1.4986,
+      "log_good": 1.4733
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 85.0,
+      "good": 88.0,
+      "ratio": 1.0353,
+      "suggested_scalar": 0.0695,
+      "log_bad": 4.4427,
+      "log_good": 4.4773
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4319,
+      "good": 0.4729,
+      "ratio": 1.0949,
+      "suggested_scalar": 0.1817,
+      "log_bad": -0.8396,
+      "log_good": -0.7489
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 18.0,
+      "ratio": 0.9474,
+      "suggested_scalar": -0.1083,
+      "log_bad": 2.9444,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6883,
+      "good": 0.7013,
+      "ratio": 1.0189,
+      "suggested_scalar": 0.0375,
+      "log_bad": -0.3735,
+      "log_good": -0.3548
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 6.9091,
+      "good": 7.1273,
+      "ratio": 1.0316,
+      "suggested_scalar": 0.0623,
+      "log_bad": 1.9328,
+      "log_good": 1.9639
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 359.0,
+      "good": 341.0,
+      "ratio": 0.9499,
+      "suggested_scalar": -0.1031,
+      "log_bad": 5.8833,
+      "log_good": 5.8319
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2,
+      "good": 0.1455,
+      "ratio": 0.7275,
+      "suggested_scalar": -0.6375,
+      "log_bad": -1.6094,
+      "log_good": -1.9276
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.984,
+      "good": 0.9729,
+      "ratio": 0.9887,
+      "suggested_scalar": -0.0227,
+      "log_bad": -0.0161,
+      "log_good": -0.0275
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 125.0,
+      "good": 113.0,
+      "ratio": 0.904,
+      "suggested_scalar": -0.2022,
+      "log_bad": 4.8283,
+      "log_good": 4.7274
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 99.0713,
+      "good": 109.0231,
+      "ratio": 1.1005,
+      "suggested_scalar": 0.1918,
+      "log_bad": 4.5958,
+      "log_good": 4.6916
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6145,
+      "good": 0.6118,
+      "ratio": 0.9956,
+      "suggested_scalar": -0.0088,
+      "log_bad": -0.4869,
+      "log_good": -0.4913
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 12.3031,
+      "good": 4.5349,
+      "ratio": 0.3686,
+      "suggested_scalar": -2.0,
+      "log_bad": 2.5099,
+      "log_good": 1.5118
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1847.0,
+      "good": 1610.0,
+      "ratio": 0.8717,
+      "suggested_scalar": -0.2752,
+      "log_bad": 7.5213,
+      "log_good": 7.384
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0182,
+      "good": 0.0364,
+      "ratio": 2.0,
+      "suggested_scalar": 1.389,
+      "log_bad": -4.0063,
+      "log_good": -3.3132
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8,
+      "good": 0.7818,
+      "ratio": 0.9773,
+      "suggested_scalar": -0.0461,
+      "log_bad": -0.2231,
+      "log_good": -0.2462
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.0392,
+      "good": 6.6863,
+      "ratio": 0.9499,
+      "suggested_scalar": -0.1031,
+      "log_bad": 1.9515,
+      "log_good": 1.9001
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 17.719,
+      "good": 18.4383,
+      "ratio": 1.0406,
+      "suggested_scalar": 0.0797,
+      "log_bad": 2.8746,
+      "log_good": 2.9144
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 58.0,
+      "good": 56.0,
+      "ratio": 0.9655,
+      "suggested_scalar": -0.0703,
+      "log_bad": 4.0604,
+      "log_good": 4.0254
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9421,
+      "good": 0.9383,
+      "ratio": 0.996,
+      "suggested_scalar": -0.0081,
+      "log_bad": -0.0596,
+      "log_good": -0.0637
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 27.0,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0756,
+      "log_bad": 3.2581,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6708,
+      "good": 0.6391,
+      "ratio": 0.9527,
+      "suggested_scalar": -0.097,
+      "log_bad": -0.3993,
+      "log_good": -0.4477
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3866,
+      "good": 0.3894,
+      "ratio": 1.0072,
+      "suggested_scalar": 0.0145,
+      "log_bad": -0.9504,
+      "log_good": -0.9431
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0378,
+      "good": 2.7711,
+      "ratio": 0.9122,
+      "suggested_scalar": -0.1841,
+      "log_bad": 1.1111,
+      "log_good": 1.0192
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 357.0,
+      "good": 339.0,
+      "ratio": 0.9496,
+      "suggested_scalar": -0.1037,
+      "log_bad": 5.8777,
+      "log_good": 5.826
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 18.0,
+      "good": 11.0,
+      "ratio": 0.6111,
+      "suggested_scalar": -0.9869,
+      "log_bad": 2.8904,
+      "log_good": 2.3979
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0891,
+      "good": 0.0762,
+      "ratio": 0.8552,
+      "suggested_scalar": -0.3134,
+      "log_bad": -2.418,
+      "log_good": -2.5744
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0224,
+      "good": 5.9773,
+      "ratio": 0.9925,
+      "suggested_scalar": -0.0151,
+      "log_bad": 1.7955,
+      "log_good": 1.788
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 65.0,
+      "good": 55.0,
+      "ratio": 0.8462,
+      "suggested_scalar": -0.3348,
+      "log_bad": 4.1744,
+      "log_good": 4.0073
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1,
+      "good": 1.1106,
+      "ratio": 1.0096,
+      "suggested_scalar": 0.0192,
+      "log_bad": 0.0953,
+      "log_good": 0.1049
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5719,
+      "good": 5.5842,
+      "ratio": 1.0022,
+      "suggested_scalar": 0.0044,
+      "log_bad": 1.7177,
+      "log_good": 1.7199
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7432,
+      "good": 0.7301,
+      "ratio": 0.9824,
+      "suggested_scalar": -0.0356,
+      "log_bad": -0.2968,
+      "log_good": -0.3146
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.0984,
+      "good": 0.1129,
+      "ratio": 1.1474,
+      "suggested_scalar": 0.2755,
+      "log_bad": -2.3187,
+      "log_good": -2.1813
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.5076,
+      "good": 2.1295,
+      "ratio": 0.6071,
+      "suggested_scalar": -1.0,
+      "log_bad": 1.2549,
+      "log_good": 0.7559
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 272.0,
+      "good": 260.0,
+      "ratio": 0.9559,
+      "suggested_scalar": -0.0904,
+      "log_bad": 5.6058,
+      "log_good": 5.5607
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7349,
+      "good": 0.7105,
+      "ratio": 0.9668,
+      "suggested_scalar": -0.0677,
+      "log_bad": -0.308,
+      "log_good": -0.3418
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 88.0,
+      "good": 89.0,
+      "ratio": 1.0114,
+      "suggested_scalar": 0.0226,
+      "log_bad": 4.4773,
+      "log_good": 4.4886
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 917.0,
+      "good": 695.0,
+      "ratio": 0.7579,
+      "suggested_scalar": -0.5555,
+      "log_bad": 6.8211,
+      "log_good": 6.5439
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 136.0,
+      "good": 126.0,
+      "ratio": 0.9265,
+      "suggested_scalar": -0.153,
+      "log_bad": 4.9127,
+      "log_good": 4.8363
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0084,
+      "good": 0.0117,
+      "ratio": 1.3929,
+      "suggested_scalar": 0.664,
+      "log_bad": -4.7795,
+      "log_good": -4.4482
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2507,
+      "good": 0.2551,
+      "ratio": 1.0176,
+      "suggested_scalar": 0.0349,
+      "log_bad": -1.3835,
+      "log_good": -1.3661
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 70.0,
+      "good": 70.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2485,
+      "log_good": 4.2485
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.5765,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 88.0,
+      "good": 89.0,
+      "ratio": 1.0114,
+      "suggested_scalar": 0.0226,
+      "log_bad": 4.4773,
+      "log_good": 4.4886
+    },
+    "brevity.mean_sample_size": {
+      "bad": 88.0,
+      "good": 89.0,
+      "ratio": 1.0114,
+      "suggested_scalar": 0.0226,
+      "log_bad": 4.4773,
+      "log_good": 4.4886
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 359.0,
+      "good": 341.0,
+      "ratio": 0.9499,
+      "suggested_scalar": -0.1031,
+      "log_bad": 5.8833,
+      "log_good": 5.8319
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 190.0,
+      "good": 183.0,
+      "ratio": 0.9632,
+      "suggested_scalar": -0.0752,
+      "log_bad": 5.247,
+      "log_good": 5.2095
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 208.0,
+      "good": 202.0,
+      "ratio": 0.9712,
+      "suggested_scalar": -0.0587,
+      "log_bad": 5.3375,
+      "log_good": 5.3083
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.7279,
+      "good": 1.7729,
+      "ratio": 1.026,
+      "suggested_scalar": 0.0515,
+      "log_bad": 0.5469,
+      "log_good": 0.5726
+    },
+    "halstead.mean_effort": {
+      "bad": 66070.1744,
+      "good": 59440.5369,
+      "ratio": 0.8997,
+      "suggested_scalar": -0.2119,
+      "log_bad": 11.0985,
+      "log_good": 10.9927
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8626,
+      "good": 0.8623,
+      "ratio": 0.9997,
+      "suggested_scalar": -0.0007,
+      "log_bad": -0.1478,
+      "log_good": -0.1482
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 59.0,
+      "good": 61.0,
+      "ratio": 1.0339,
+      "suggested_scalar": 0.0668,
+      "log_bad": 4.0775,
+      "log_good": 4.1109
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 208.0,
+      "good": 204.0,
+      "ratio": 0.9808,
+      "suggested_scalar": -0.0389,
+      "log_bad": 5.3375,
+      "log_good": 5.3181
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.424,
+      "good": 0.4867,
+      "ratio": 1.1479,
+      "suggested_scalar": 0.2764,
+      "log_bad": -0.858,
+      "log_good": -0.7201
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.336,
+      "good": 6.1504,
+      "ratio": 0.8384,
+      "suggested_scalar": -0.3532,
+      "log_bad": 1.9928,
+      "log_good": 1.8165
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.0984,
+      "good": 0.1129,
+      "ratio": 1.1474,
+      "suggested_scalar": 0.2755,
+      "log_bad": -2.3187,
+      "log_good": -2.1813
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 2.8157,
+      "good": 2.6745,
+      "ratio": 0.9499,
+      "suggested_scalar": -0.1031,
+      "log_bad": 1.0352,
+      "log_good": 0.9838
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 358.0,
+      "good": 340.0,
+      "ratio": 0.9497,
+      "suggested_scalar": -0.1034,
+      "log_bad": 5.8805,
+      "log_good": 5.8289
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 53.0,
+      "good": 53.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9703,
+      "log_good": 3.9703
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3670.5652,
+      "good": 3302.252,
+      "ratio": 0.8997,
+      "suggested_scalar": -0.2119,
+      "log_bad": 8.2081,
+      "log_good": 8.1024
+    },
+    "readability.mean_total_lines": {
+      "bad": 51.0,
+      "good": 51.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.9318,
+      "log_good": 3.9318
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 2204.8305,
+      "good": 2131.6124,
+      "ratio": 0.9668,
+      "suggested_scalar": -0.0677,
+      "log_bad": 7.6984,
+      "log_good": 7.6646
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 608.0,
+      "good": 581.0,
+      "ratio": 0.9556,
+      "suggested_scalar": -0.091,
+      "log_bad": 6.4102,
+      "log_good": 6.3648
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 32.451,
+      "good": 27.9412,
+      "ratio": 0.861,
+      "suggested_scalar": -0.2998,
+      "log_bad": 3.4797,
+      "log_good": 3.3301
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1893,
+      "good": 1.0759,
+      "ratio": 0.9046,
+      "suggested_scalar": -0.2008,
+      "log_bad": 0.1734,
+      "log_good": 0.0732
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 6.0,
+      "good": 8.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.5765,
+      "log_bad": 1.7918,
+      "log_good": 2.0794
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 11.0,
+      "good": 8.0,
+      "ratio": 0.7273,
+      "suggested_scalar": -0.6382,
+      "log_bad": 2.3979,
+      "log_good": 2.0794
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8051,
+      "good": 0.7962,
+      "ratio": 0.9889,
+      "suggested_scalar": -0.0223,
+      "log_bad": -0.2168,
+      "log_good": -0.2279
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9605,
+      "good": 0.9467,
+      "ratio": 0.9856,
+      "suggested_scalar": -0.029,
+      "log_bad": -0.0403,
+      "log_good": -0.0548
+    },
+    "halstead.mean_length": {
+      "bad": 344.0,
+      "good": 330.0,
+      "ratio": 0.9593,
+      "suggested_scalar": -0.0833,
+      "log_bad": 5.8406,
+      "log_good": 5.7991
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.3333,
+      "good": 7.75,
+      "ratio": 0.8304,
+      "suggested_scalar": -0.3725,
+      "log_bad": 2.2336,
+      "log_good": 2.0477
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4594,
+      "good": 6.4757,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0051,
+      "log_bad": 1.8655,
+      "log_good": 1.8681
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1033,
+      "good": 0.1137,
+      "ratio": 1.1007,
+      "suggested_scalar": 0.1922,
+      "log_bad": -2.2701,
+      "log_good": -2.1742
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.9661,
+      "good": 27.8852,
+      "ratio": 0.9306,
+      "suggested_scalar": -0.1442,
+      "log_bad": 3.4001,
+      "log_good": 3.3281
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 1.389,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 53.0,
+      "good": 55.0,
+      "ratio": 1.0377,
+      "suggested_scalar": 0.0742,
+      "log_bad": 3.9703,
+      "log_good": 4.0073
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6635,
+      "good": 0.6535,
+      "ratio": 0.9849,
+      "suggested_scalar": -0.0304,
+      "log_bad": -0.4102,
+      "log_good": -0.4254
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 55.0,
+      "good": 55.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0073,
+      "log_good": 4.0073
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 12.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.5765,
+      "log_bad": 2.7726,
+      "log_good": 2.4849
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.copy_not_assumed_to_be_deep": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 16.0,
+      "good": 18.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0318,
+      "log_bad": 2.7726,
+      "log_good": 2.8904
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0062,
+      "good": 1.0,
+      "ratio": 161.2903,
+      "suggested_scalar": 1.3704,
+      "log_bad": -5.0832,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8421,
+      "good": 0.85,
+      "ratio": 1.0094,
+      "suggested_scalar": 0.0025,
+      "log_bad": -0.1719,
+      "log_good": -0.1625
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0062,
+      "good": 1.0,
+      "ratio": 161.2903,
+      "suggested_scalar": 1.3704,
+      "log_bad": -5.0832,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6852,
+      "good": 4.5962,
+      "ratio": 0.981,
+      "suggested_scalar": -0.0052,
+      "log_bad": 1.5444,
+      "log_good": 1.5252
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 101.0,
+      "good": 109.0,
+      "ratio": 1.0792,
+      "suggested_scalar": 0.0206,
+      "log_bad": 4.6151,
+      "log_good": 4.6913
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5258,
+      "good": 0.5175,
+      "ratio": 0.9842,
+      "suggested_scalar": -0.0043,
+      "log_bad": -0.6428,
+      "log_good": -0.6587
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 16.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0318,
+      "log_bad": 2.8904,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7184,
+      "good": 0.7009,
+      "ratio": 0.9756,
+      "suggested_scalar": -0.0066,
+      "log_bad": -0.3307,
+      "log_good": -0.3554
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.5526,
+      "good": 5.2,
+      "ratio": 1.1422,
+      "suggested_scalar": 0.0358,
+      "log_bad": 1.5157,
+      "log_good": 1.6487
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 321.0,
+      "good": 351.0,
+      "ratio": 1.0935,
+      "suggested_scalar": 0.0241,
+      "log_bad": 5.7714,
+      "log_good": 5.8608
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0602,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0006,
+      "good": 1.0,
+      "ratio": 1666.6667,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.4186,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.3947,
+      "good": 0.325,
+      "ratio": 0.8234,
+      "suggested_scalar": -0.0524,
+      "log_bad": -0.9296,
+      "log_good": -1.1239
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0013,
+      "good": 0.0006,
+      "ratio": 0.4615,
+      "suggested_scalar": -0.2084,
+      "log_bad": -6.6454,
+      "log_good": -7.4186
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8848,
+      "good": 0.9195,
+      "ratio": 1.0392,
+      "suggested_scalar": 0.0104,
+      "log_bad": -0.1224,
+      "log_good": -0.0839
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 147.0,
+      "good": 159.0,
+      "ratio": 1.0816,
+      "suggested_scalar": 0.0212,
+      "log_bad": 4.9904,
+      "log_good": 5.0689
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 96.556,
+      "good": 96.9134,
+      "ratio": 1.0037,
+      "suggested_scalar": 0.001,
+      "log_bad": 4.5701,
+      "log_good": 4.5738
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.3812,
+      "good": 0.44,
+      "ratio": 1.1542,
+      "suggested_scalar": 0.0387,
+      "log_bad": -0.9644,
+      "log_good": -0.821
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.2282,
+      "good": 10.1883,
+      "ratio": 1.104,
+      "suggested_scalar": 0.0267,
+      "log_bad": 2.2223,
+      "log_good": 2.3212
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1567.0,
+      "good": 1762.0,
+      "ratio": 1.1244,
+      "suggested_scalar": 0.0316,
+      "log_bad": 7.3569,
+      "log_good": 7.4742
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0263,
+      "good": 0.1,
+      "ratio": 3.8023,
+      "suggested_scalar": 0.3601,
+      "log_bad": -3.6382,
+      "log_good": -2.3026
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8158,
+      "good": 0.775,
+      "ratio": 0.95,
+      "suggested_scalar": -0.0138,
+      "log_bad": -0.2036,
+      "log_good": -0.2549
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.4474,
+      "good": 8.775,
+      "ratio": 1.0388,
+      "suggested_scalar": 0.0103,
+      "log_bad": 2.1339,
+      "log_good": 2.1719
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 7.0893,
+      "good": 11.56,
+      "ratio": 1.6306,
+      "suggested_scalar": 0.1318,
+      "log_bad": 1.9586,
+      "log_good": 2.4476
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 98.0,
+      "good": 109.0,
+      "ratio": 1.1122,
+      "suggested_scalar": 0.0287,
+      "log_bad": 4.585,
+      "log_good": 4.6913
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9372,
+      "good": 0.9297,
+      "ratio": 0.992,
+      "suggested_scalar": -0.0022,
+      "log_bad": -0.0649,
+      "log_good": -0.0729
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 24.0,
+      "good": 30.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0602,
+      "log_bad": 3.1781,
+      "log_good": 3.4012
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5756,
+      "good": 0.5914,
+      "ratio": 1.0274,
+      "suggested_scalar": 0.0073,
+      "log_bad": -0.5523,
+      "log_good": -0.5253
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2069,
+      "good": 0.2693,
+      "ratio": 1.3016,
+      "suggested_scalar": 0.0711,
+      "log_bad": -1.5755,
+      "log_good": -1.3119
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3564,
+      "good": 2.4472,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0102,
+      "log_bad": 0.8571,
+      "log_good": 0.8949
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 319.0,
+      "good": 349.0,
+      "ratio": 1.094,
+      "suggested_scalar": 0.0242,
+      "log_bad": 5.7652,
+      "log_good": 5.8551
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0374,
+      "good": 0.0342,
+      "ratio": 0.9144,
+      "suggested_scalar": -0.0241,
+      "log_bad": -3.2861,
+      "log_good": -3.3755
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0444,
+      "good": 5.9307,
+      "ratio": 0.9812,
+      "suggested_scalar": -0.0051,
+      "log_bad": 1.7991,
+      "log_good": 1.7801
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 33.0,
+      "good": 32.0,
+      "ratio": 0.9697,
+      "suggested_scalar": -0.0083,
+      "log_bad": 3.4965,
+      "log_good": 3.4657
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.2221,
+      "good": 1.1947,
+      "ratio": 0.9776,
+      "suggested_scalar": -0.0061,
+      "log_bad": 0.2006,
+      "log_good": 0.1779
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9598,
+      "good": 5.9442,
+      "ratio": 0.9974,
+      "suggested_scalar": -0.0007,
+      "log_bad": 1.785,
+      "log_good": 1.7824
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7751,
+      "good": 0.775,
+      "ratio": 0.9999,
+      "suggested_scalar": -0.0,
+      "log_bad": -0.2548,
+      "log_good": -0.2549
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1556,
+      "good": 0.1489,
+      "ratio": 0.9569,
+      "suggested_scalar": -0.0119,
+      "log_bad": -1.8605,
+      "log_good": -1.9045
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.0378,
+      "good": 3.1919,
+      "ratio": 1.0507,
+      "suggested_scalar": 0.0133,
+      "log_bad": 1.1111,
+      "log_good": 1.1606
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 278.0,
+      "good": 289.0,
+      "ratio": 1.0396,
+      "suggested_scalar": 0.0105,
+      "log_bad": 5.6276,
+      "log_good": 5.6664
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6769,
+      "good": 0.7761,
+      "ratio": 1.1466,
+      "suggested_scalar": 0.0369,
+      "log_bad": -0.3902,
+      "log_good": -0.2535
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 103.0,
+      "good": 109.0,
+      "ratio": 1.0583,
+      "suggested_scalar": 0.0153,
+      "log_bad": 4.6347,
+      "log_good": 4.6913
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 901.0,
+      "good": 994.0,
+      "ratio": 1.1032,
+      "suggested_scalar": 0.0265,
+      "log_bad": 6.8035,
+      "log_good": 6.9017
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 165.0,
+      "good": 179.0,
+      "ratio": 1.0848,
+      "suggested_scalar": 0.022,
+      "log_bad": 5.1059,
+      "log_good": 5.1874
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 0.0028,
+      "ratio": 0.0028,
+      "suggested_scalar": -1.5847,
+      "log_bad": 0.0,
+      "log_good": -5.8781
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2118,
+      "good": 0.2137,
+      "ratio": 1.009,
+      "suggested_scalar": 0.0024,
+      "log_bad": -1.5521,
+      "log_good": -1.5432
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 40.0,
+      "good": 48.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.0492,
+      "log_bad": 3.6889,
+      "log_good": 3.8712
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 103.0,
+      "good": 109.0,
+      "ratio": 1.0583,
+      "suggested_scalar": 0.0153,
+      "log_bad": 4.6347,
+      "log_good": 4.6913
+    },
+    "brevity.mean_sample_size": {
+      "bad": 103.0,
+      "good": 109.0,
+      "ratio": 1.0583,
+      "suggested_scalar": 0.0153,
+      "log_bad": 4.6347,
+      "log_good": 4.6913
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 321.0,
+      "good": 351.0,
+      "ratio": 1.0935,
+      "suggested_scalar": 0.0241,
+      "log_bad": 5.7714,
+      "log_good": 5.8608
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 137.0,
+      "good": 149.0,
+      "ratio": 1.0876,
+      "suggested_scalar": 0.0226,
+      "log_bad": 4.92,
+      "log_good": 5.0039
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 238.0,
+      "good": 244.0,
+      "ratio": 1.0252,
+      "suggested_scalar": 0.0067,
+      "log_bad": 5.4723,
+      "log_good": 5.4972
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.8131,
+      "good": 2.0247,
+      "ratio": 1.1167,
+      "suggested_scalar": 0.0298,
+      "log_bad": 0.595,
+      "log_good": 0.7054
+    },
+    "halstead.mean_effort": {
+      "bad": 52219.4015,
+      "good": 79131.2123,
+      "ratio": 1.5154,
+      "suggested_scalar": 0.1121,
+      "log_bad": 10.8632,
+      "log_good": 11.2789
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8913,
+      "good": 0.8783,
+      "ratio": 0.9854,
+      "suggested_scalar": -0.004,
+      "log_bad": -0.1151,
+      "log_good": -0.1298
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 77.0,
+      "good": 79.0,
+      "ratio": 1.026,
+      "suggested_scalar": 0.0069,
+      "log_bad": 4.3438,
+      "log_good": 4.3694
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 140.0,
+      "good": 165.0,
+      "ratio": 1.1786,
+      "suggested_scalar": 0.0443,
+      "log_bad": 4.9416,
+      "log_good": 5.1059
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4626,
+      "good": 0.4465,
+      "ratio": 0.9652,
+      "suggested_scalar": -0.0095,
+      "log_bad": -0.7709,
+      "log_good": -0.8063
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.1293,
+      "good": 6.2516,
+      "ratio": 1.02,
+      "suggested_scalar": 0.0053,
+      "log_bad": 1.8131,
+      "log_good": 1.8328
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1556,
+      "good": 0.1489,
+      "ratio": 0.9569,
+      "suggested_scalar": -0.0119,
+      "log_bad": -1.8605,
+      "log_good": -1.9045
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.4718,
+      "good": 4.505,
+      "ratio": 1.0074,
+      "suggested_scalar": 0.002,
+      "log_bad": 1.4978,
+      "log_good": 1.5052
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 320.0,
+      "good": 350.0,
+      "ratio": 1.0938,
+      "suggested_scalar": 0.0242,
+      "log_bad": 5.7683,
+      "log_good": 5.8579
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 25.0,
+      "good": 34.0,
+      "ratio": 1.36,
+      "suggested_scalar": 0.0829,
+      "log_bad": 3.2189,
+      "log_good": 3.5264
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2901.0779,
+      "good": 4396.1785,
+      "ratio": 1.5154,
+      "suggested_scalar": 0.1121,
+      "log_bad": 7.9728,
+      "log_good": 8.3885
+    },
+    "readability.mean_total_lines": {
+      "bad": 38.0,
+      "good": 40.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0138,
+      "log_bad": 3.6376,
+      "log_good": 3.6889
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 12.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1093,
+      "log_bad": 2.0794,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2030.7545,
+      "good": 2328.2554,
+      "ratio": 1.1465,
+      "suggested_scalar": 0.0369,
+      "log_bad": 7.6162,
+      "log_good": 7.7529
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 665.0,
+      "good": 720.0,
+      "ratio": 1.0827,
+      "suggested_scalar": 0.0214,
+      "log_bad": 6.4998,
+      "log_good": 6.5793
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 39.8421,
+      "good": 42.675,
+      "ratio": 1.0711,
+      "suggested_scalar": 0.0185,
+      "log_bad": 3.6849,
+      "log_good": 3.7536
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2022,
+      "good": 1.194,
+      "ratio": 0.9932,
+      "suggested_scalar": -0.0018,
+      "log_bad": 0.1842,
+      "log_good": 0.1773
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 5.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0602,
+      "log_bad": 1.3863,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 21.0,
+      "good": 24.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.036,
+      "log_bad": 3.0445,
+      "log_good": 3.1781
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 15.0,
+      "good": 13.0,
+      "ratio": 0.8667,
+      "suggested_scalar": -0.0386,
+      "log_bad": 2.7081,
+      "log_good": 2.5649
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9101,
+      "good": 0.8824,
+      "ratio": 0.9696,
+      "suggested_scalar": -0.0083,
+      "log_bad": -0.0942,
+      "log_good": -0.1251
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9864,
+      "good": 0.9814,
+      "ratio": 0.9949,
+      "suggested_scalar": -0.0014,
+      "log_bad": -0.0137,
+      "log_good": -0.0188
+    },
+    "halstead.mean_length": {
+      "bad": 305.0,
+      "good": 344.0,
+      "ratio": 1.1279,
+      "suggested_scalar": 0.0324,
+      "log_bad": 5.7203,
+      "log_good": 5.8406
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.0,
+      "good": 9.6667,
+      "ratio": 1.0741,
+      "suggested_scalar": 0.0193,
+      "log_bad": 2.1972,
+      "log_good": 2.2687
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.6865,
+      "good": 6.7682,
+      "ratio": 1.0122,
+      "suggested_scalar": 0.0033,
+      "log_bad": 1.9001,
+      "log_good": 1.9122
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0879,
+      "good": 0.0849,
+      "ratio": 0.9659,
+      "suggested_scalar": -0.0094,
+      "log_bad": -2.4316,
+      "log_good": -2.4663
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.7143,
+      "good": 33.9873,
+      "ratio": 1.3217,
+      "suggested_scalar": 0.0752,
+      "log_bad": 3.247,
+      "log_good": 3.526
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 0.3737,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 68.0,
+      "good": 71.0,
+      "ratio": 1.0441,
+      "suggested_scalar": 0.0116,
+      "log_bad": 4.2195,
+      "log_good": 4.2627
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8319,
+      "good": 0.8033,
+      "ratio": 0.9656,
+      "suggested_scalar": -0.0094,
+      "log_bad": -0.184,
+      "log_good": -0.219
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 38.0,
+      "good": 40.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0138,
+      "log_bad": 3.6376,
+      "log_good": 3.6889
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.does_not_cast_ref_to_mut_ptr": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2849,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.1666,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 0.0077,
+      "ratio": 0.0077,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -4.8665
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.8,
+      "good": 1.1111,
+      "ratio": 0.6173,
+      "suggested_scalar": -0.1983,
+      "log_bad": 0.5878,
+      "log_good": 0.1054
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7949,
+      "good": 0.76,
+      "ratio": 0.9561,
+      "suggested_scalar": -0.0185,
+      "log_bad": -0.2295,
+      "log_good": -0.2744
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 0.0077,
+      "ratio": 0.0077,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -4.8665
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4915,
+      "good": 4.6664,
+      "ratio": 1.0389,
+      "suggested_scalar": 0.0157,
+      "log_bad": 1.5022,
+      "log_good": 1.5404
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 95.0,
+      "good": 79.0,
+      "ratio": 0.8316,
+      "suggested_scalar": -0.0758,
+      "log_bad": 4.5539,
+      "log_good": 4.3694
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.55,
+      "good": 0.5056,
+      "ratio": 0.9193,
+      "suggested_scalar": -0.0346,
+      "log_bad": -0.5978,
+      "log_good": -0.682
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7068,
+      "good": 0.5937,
+      "ratio": 0.84,
+      "suggested_scalar": -0.0717,
+      "log_bad": -0.347,
+      "log_good": -0.5214
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.7436,
+      "good": 4.64,
+      "ratio": 0.8079,
+      "suggested_scalar": -0.0877,
+      "log_bad": 1.7481,
+      "log_good": 1.5347
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 309.0,
+      "good": 391.0,
+      "ratio": 1.2654,
+      "suggested_scalar": 0.0967,
+      "log_bad": 5.7333,
+      "log_good": 5.9687
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.2308,
+      "good": 0.06,
+      "ratio": 0.26,
+      "suggested_scalar": -0.5537,
+      "log_bad": -1.4662,
+      "log_good": -2.8134
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.8849,
+      "good": 1.0642,
+      "ratio": 1.2026,
+      "suggested_scalar": 0.0758,
+      "log_bad": -0.1223,
+      "log_good": 0.0622
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 105.0,
+      "good": 89.0,
+      "ratio": 0.8476,
+      "suggested_scalar": -0.0679,
+      "log_bad": 4.654,
+      "log_good": 4.4886
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 107.0149,
+      "good": 106.4279,
+      "ratio": 0.9945,
+      "suggested_scalar": -0.0023,
+      "log_bad": 4.673,
+      "log_good": 4.6675
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4675,
+      "good": 0.7,
+      "ratio": 1.4973,
+      "suggested_scalar": 0.1659,
+      "log_bad": -0.7604,
+      "log_good": -0.3567
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.7632,
+      "good": 10.2192,
+      "ratio": 1.1661,
+      "suggested_scalar": 0.0632,
+      "log_bad": 2.1706,
+      "log_good": 2.3243
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1366.0,
+      "good": 1441.0,
+      "ratio": 1.0549,
+      "suggested_scalar": 0.022,
+      "log_bad": 7.2196,
+      "log_good": 7.2731
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0256,
+      "good": 0.02,
+      "ratio": 0.7813,
+      "suggested_scalar": -0.1015,
+      "log_bad": -3.6652,
+      "log_good": -3.912
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6923,
+      "good": 0.72,
+      "ratio": 1.04,
+      "suggested_scalar": 0.0161,
+      "log_bad": -0.3677,
+      "log_good": -0.3285
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.9231,
+      "good": 7.82,
+      "ratio": 0.987,
+      "suggested_scalar": -0.0054,
+      "log_bad": 2.0698,
+      "log_good": 2.0567
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 8.0,
+      "good": 6.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1182,
+      "log_bad": 2.0794,
+      "log_good": 1.7918
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 15.4214,
+      "good": 10.4704,
+      "ratio": 0.679,
+      "suggested_scalar": -0.1591,
+      "log_bad": 2.7358,
+      "log_good": 2.3486
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 83.0,
+      "good": 66.0,
+      "ratio": 0.7952,
+      "suggested_scalar": -0.0942,
+      "log_bad": 4.4188,
+      "log_good": 4.1897
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9084,
+      "good": 0.9227,
+      "ratio": 1.0157,
+      "suggested_scalar": 0.0064,
+      "log_bad": -0.0961,
+      "log_good": -0.0805
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 26.0,
+      "ratio": 0.963,
+      "suggested_scalar": -0.0155,
+      "log_bad": 3.2958,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5769,
+      "good": 0.619,
+      "ratio": 1.073,
+      "suggested_scalar": 0.0289,
+      "log_bad": -0.5501,
+      "log_good": -0.4797
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2573,
+      "good": 0.4653,
+      "ratio": 1.8084,
+      "suggested_scalar": 0.2435,
+      "log_bad": -1.3575,
+      "log_good": -0.7651
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3633,
+      "good": 2.6248,
+      "ratio": 1.1107,
+      "suggested_scalar": 0.0431,
+      "log_bad": 0.8601,
+      "log_good": 0.965
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 307.0,
+      "good": 389.0,
+      "ratio": 1.2671,
+      "suggested_scalar": 0.0973,
+      "log_bad": 5.7268,
+      "log_good": 5.9636
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 9.0,
+      "good": 10.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0433,
+      "log_bad": 2.1972,
+      "log_good": 2.3026
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0421,
+      "good": 0.0384,
+      "ratio": 0.9121,
+      "suggested_scalar": -0.0378,
+      "log_bad": -3.1677,
+      "log_good": -3.2597
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7814,
+      "good": 5.8329,
+      "ratio": 1.0089,
+      "suggested_scalar": 0.0036,
+      "log_bad": 1.7546,
+      "log_good": 1.7635
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 14.0,
+      "good": 17.0,
+      "ratio": 1.2143,
+      "suggested_scalar": 0.0798,
+      "log_bad": 2.6391,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.9387,
+      "good": 1.0384,
+      "ratio": 1.1062,
+      "suggested_scalar": 0.0415,
+      "log_bad": -0.0633,
+      "log_good": 0.0377
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.961,
+      "good": 5.5091,
+      "ratio": 0.9242,
+      "suggested_scalar": -0.0324,
+      "log_bad": 1.7852,
+      "log_good": 1.7064
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7769,
+      "good": 0.8,
+      "ratio": 1.0297,
+      "suggested_scalar": 0.012,
+      "log_bad": -0.2524,
+      "log_good": -0.2231
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1136,
+      "good": 0.1803,
+      "ratio": 1.5871,
+      "suggested_scalar": 0.1898,
+      "log_bad": -2.1751,
+      "log_good": -1.7131
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.9603,
+      "good": 3.1967,
+      "ratio": 1.0799,
+      "suggested_scalar": 0.0316,
+      "log_bad": 1.0853,
+      "log_good": 1.1621
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 260.0,
+      "good": 273.0,
+      "ratio": 1.05,
+      "suggested_scalar": 0.0201,
+      "log_bad": 5.5607,
+      "log_good": 5.6095
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 3.0,
+      "good": 13.0,
+      "ratio": 4.3333,
+      "suggested_scalar": 0.6026,
+      "log_bad": 1.0986,
+      "log_good": 2.5649
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6657,
+      "good": 0.7817,
+      "ratio": 1.1743,
+      "suggested_scalar": 0.066,
+      "log_bad": -0.4069,
+      "log_good": -0.2463
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 96.0,
+      "good": 81.0,
+      "ratio": 0.8438,
+      "suggested_scalar": -0.0698,
+      "log_bad": 4.5643,
+      "log_good": 4.3944
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 581.0,
+      "good": 514.0,
+      "ratio": 0.8847,
+      "suggested_scalar": -0.0504,
+      "log_bad": 6.3648,
+      "log_good": 6.2422
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 140.0,
+      "good": 140.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.9416,
+      "log_good": 4.9416
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0065,
+      "good": 0.0179,
+      "ratio": 2.7538,
+      "suggested_scalar": 0.4163,
+      "log_bad": -5.036,
+      "log_good": -4.023
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2071,
+      "good": 0.2379,
+      "ratio": 1.1487,
+      "suggested_scalar": 0.057,
+      "log_bad": -1.5746,
+      "log_good": -1.4359
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 48.0,
+      "good": 78.0,
+      "ratio": 1.625,
+      "suggested_scalar": 0.1995,
+      "log_bad": 3.8712,
+      "log_good": 4.3567
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 9.0,
+      "ratio": 1.8,
+      "suggested_scalar": 0.2416,
+      "log_bad": 1.6094,
+      "log_good": 2.1972
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 96.0,
+      "good": 81.0,
+      "ratio": 0.8438,
+      "suggested_scalar": -0.0698,
+      "log_bad": 4.5643,
+      "log_good": 4.3944
+    },
+    "brevity.mean_sample_size": {
+      "bad": 96.0,
+      "good": 81.0,
+      "ratio": 0.8438,
+      "suggested_scalar": -0.0698,
+      "log_bad": 4.5643,
+      "log_good": 4.3944
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 309.0,
+      "good": 391.0,
+      "ratio": 1.2654,
+      "suggested_scalar": 0.0967,
+      "log_bad": 5.7333,
+      "log_good": 5.9687
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 144.0,
+      "good": 218.0,
+      "ratio": 1.5139,
+      "suggested_scalar": 0.1704,
+      "log_bad": 4.9698,
+      "log_good": 5.3845
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 212.0,
+      "good": 195.0,
+      "ratio": 0.9198,
+      "suggested_scalar": -0.0344,
+      "log_bad": 5.3566,
+      "log_good": 5.273
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.0004,
+      "good": 2.8,
+      "ratio": 1.3997,
+      "suggested_scalar": 0.1382,
+      "log_bad": 0.6933,
+      "log_good": 1.0296
+    },
+    "halstead.mean_effort": {
+      "bad": 55511.4153,
+      "good": 80526.6362,
+      "ratio": 1.4506,
+      "suggested_scalar": 0.1529,
+      "log_bad": 10.9243,
+      "log_good": 11.2963
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.9052,
+      "good": 0.869,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0168,
+      "log_bad": -0.0996,
+      "log_good": -0.1404
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 68.0,
+      "good": 53.0,
+      "ratio": 0.7794,
+      "suggested_scalar": -0.1024,
+      "log_bad": 4.2195,
+      "log_good": 3.9703
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 164.0,
+      "good": 232.0,
+      "ratio": 1.4146,
+      "suggested_scalar": 0.1426,
+      "log_bad": 5.0999,
+      "log_good": 5.4467
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5429,
+      "good": 0.5056,
+      "ratio": 0.9313,
+      "suggested_scalar": -0.0293,
+      "log_bad": -0.6108,
+      "log_good": -0.682
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.5333,
+      "good": 5.7753,
+      "ratio": 1.0437,
+      "suggested_scalar": 0.0176,
+      "log_bad": 1.7108,
+      "log_good": 1.7536
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1136,
+      "good": 0.1803,
+      "ratio": 1.5871,
+      "suggested_scalar": 0.1898,
+      "log_bad": -2.1751,
+      "log_good": -1.7131
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.1692,
+      "good": 3.5931,
+      "ratio": 1.1338,
+      "suggested_scalar": 0.0516,
+      "log_bad": 1.1535,
+      "log_good": 1.279
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 308.0,
+      "good": 390.0,
+      "ratio": 1.2662,
+      "suggested_scalar": 0.097,
+      "log_bad": 5.7301,
+      "log_good": 5.9661
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.4515,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 32.0,
+      "good": 65.0,
+      "ratio": 2.0313,
+      "suggested_scalar": 0.2912,
+      "log_bad": 3.4657,
+      "log_good": 4.1744
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3083.9675,
+      "good": 4473.702,
+      "ratio": 1.4506,
+      "suggested_scalar": 0.1529,
+      "log_bad": 8.034,
+      "log_good": 8.406
+    },
+    "readability.mean_total_lines": {
+      "bad": 39.0,
+      "good": 50.0,
+      "ratio": 1.2821,
+      "suggested_scalar": 0.1021,
+      "log_bad": 3.6636,
+      "log_good": 3.912
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 12.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.1182,
+      "log_bad": 2.7726,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 1997.2361,
+      "good": 2345.0064,
+      "ratio": 1.1741,
+      "suggested_scalar": 0.066,
+      "log_bad": 7.5995,
+      "log_good": 7.76
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 578.0,
+      "good": 549.0,
+      "ratio": 0.9498,
+      "suggested_scalar": -0.0212,
+      "log_bad": 6.3596,
+      "log_good": 6.3081
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 33.7949,
+      "good": 27.52,
+      "ratio": 0.8143,
+      "suggested_scalar": -0.0844,
+      "log_bad": 3.5203,
+      "log_good": 3.3149
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0848,
+      "good": 1.093,
+      "ratio": 1.0076,
+      "suggested_scalar": 0.0031,
+      "log_bad": 0.0814,
+      "log_good": 0.0889
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 13.0,
+      "good": 26.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2849,
+      "log_bad": 2.5649,
+      "log_good": 3.2581
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 9.0,
+      "good": 3.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.4515,
+      "log_bad": 2.1972,
+      "log_good": 1.0986
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8769,
+      "good": 0.7619,
+      "ratio": 0.8689,
+      "suggested_scalar": -0.0578,
+      "log_bad": -0.1314,
+      "log_good": -0.2719
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.958,
+      "good": 0.8924,
+      "ratio": 0.9315,
+      "suggested_scalar": -0.0292,
+      "log_bad": -0.0429,
+      "log_good": -0.1138
+    },
+    "halstead.mean_length": {
+      "bad": 304.0,
+      "good": 372.0,
+      "ratio": 1.2237,
+      "suggested_scalar": 0.083,
+      "log_bad": 5.717,
+      "log_good": 5.9189
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.2,
+      "good": 5.6667,
+      "ratio": 0.787,
+      "suggested_scalar": -0.0984,
+      "log_bad": 1.9741,
+      "log_good": 1.7346
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.585,
+      "good": 6.3399,
+      "ratio": 0.9628,
+      "suggested_scalar": -0.0156,
+      "log_bad": 1.8848,
+      "log_good": 1.8469
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1057,
+      "good": 0.1517,
+      "ratio": 1.4352,
+      "suggested_scalar": 0.1485,
+      "log_bad": -2.2472,
+      "log_good": -1.8859
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.7941,
+      "good": 34.3396,
+      "ratio": 1.2355,
+      "suggested_scalar": 0.0869,
+      "log_bad": 3.3248,
+      "log_good": 3.5363
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 57.0,
+      "good": 45.0,
+      "ratio": 0.7895,
+      "suggested_scalar": -0.0971,
+      "log_bad": 4.0431,
+      "log_good": 3.8067
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7736,
+      "good": 0.6,
+      "ratio": 0.7756,
+      "suggested_scalar": -0.1044,
+      "log_bad": -0.2567,
+      "log_good": -0.5108
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 39.0,
+      "good": 50.0,
+      "ratio": 1.2821,
+      "suggested_scalar": 0.1021,
+      "log_bad": 3.6636,
+      "log_good": 3.912
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 17.0,
+      "ratio": 1.2143,
+      "suggested_scalar": 0.0798,
+      "log_bad": 2.6391,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.no_library_global_application_config": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 36.0,
+      "good": 29.0,
+      "ratio": 0.8056,
+      "suggested_scalar": -0.2059,
+      "log_bad": 3.5835,
+      "log_good": 3.3673
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.66,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0294,
+      "good": 0.0286,
+      "ratio": 0.9728,
+      "suggested_scalar": -0.0263,
+      "log_bad": -3.5268,
+      "log_good": -3.5543
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.66,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7755,
+      "good": 0.8298,
+      "ratio": 1.07,
+      "suggested_scalar": 0.0644,
+      "log_bad": -0.2542,
+      "log_good": -0.1866
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0294,
+      "good": 0.0286,
+      "ratio": 0.9728,
+      "suggested_scalar": -0.0263,
+      "log_bad": -3.5268,
+      "log_good": -3.5543
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.9017,
+      "good": 4.916,
+      "ratio": 1.0029,
+      "suggested_scalar": 0.0028,
+      "log_bad": 1.5896,
+      "log_good": 1.5925
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 124.0,
+      "good": 88.0,
+      "ratio": 0.7097,
+      "suggested_scalar": -0.3265,
+      "log_bad": 4.8203,
+      "log_good": 4.4773
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5855,
+      "good": 0.5277,
+      "ratio": 0.9013,
+      "suggested_scalar": -0.099,
+      "log_bad": -0.5353,
+      "log_good": -0.6392
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 22.0,
+      "good": 23.0,
+      "ratio": 1.0455,
+      "suggested_scalar": 0.0423,
+      "log_bad": 3.091,
+      "log_good": 3.1355
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6157,
+      "good": 0.6191,
+      "ratio": 1.0055,
+      "suggested_scalar": 0.0052,
+      "log_bad": -0.485,
+      "log_good": -0.4795
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.4286,
+      "good": 3.4043,
+      "ratio": 0.9929,
+      "suggested_scalar": -0.0068,
+      "log_bad": 1.2322,
+      "log_good": 1.225
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 646.0,
+      "good": 559.0,
+      "ratio": 0.8653,
+      "suggested_scalar": -0.1377,
+      "log_bad": 6.4708,
+      "log_good": 6.3261
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0012,
+      "good": 0.0015,
+      "ratio": 1.25,
+      "suggested_scalar": 0.2125,
+      "log_bad": -6.7254,
+      "log_good": -6.5023
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1224,
+      "good": 1.0,
+      "ratio": 8.1699,
+      "suggested_scalar": 2.0,
+      "log_bad": -2.1005,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0004,
+      "good": 0.0005,
+      "ratio": 1.25,
+      "suggested_scalar": 0.2125,
+      "log_bad": -7.824,
+      "log_good": -7.6009
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0015,
+      "good": 1.0113,
+      "ratio": 1.0098,
+      "suggested_scalar": 0.0093,
+      "log_bad": 0.0015,
+      "log_good": 0.0112
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 227.0,
+      "good": 181.0,
+      "ratio": 0.7974,
+      "suggested_scalar": -0.2156,
+      "log_bad": 5.425,
+      "log_good": 5.1985
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 91.925,
+      "good": 96.6424,
+      "ratio": 1.0513,
+      "suggested_scalar": 0.0477,
+      "log_bad": 4.521,
+      "log_good": 4.571
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7581,
+      "good": 0.7258,
+      "ratio": 0.9574,
+      "suggested_scalar": -0.0415,
+      "log_bad": -0.2769,
+      "log_good": -0.3205
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.8505,
+      "good": 9.3934,
+      "ratio": 0.9536,
+      "suggested_scalar": -0.0452,
+      "log_bad": 2.2875,
+      "log_good": 2.24
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2440.0,
+      "good": 2036.0,
+      "ratio": 0.8344,
+      "suggested_scalar": -0.1724,
+      "log_bad": 7.7998,
+      "log_good": 7.6187
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0816,
+      "good": 0.0638,
+      "ratio": 0.7819,
+      "suggested_scalar": -0.2343,
+      "log_bad": -2.5059,
+      "log_good": -2.752
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7347,
+      "good": 0.7872,
+      "ratio": 1.0715,
+      "suggested_scalar": 0.0657,
+      "log_bad": -0.3083,
+      "log_good": -0.2393
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 15.0233,
+      "good": 11.8936,
+      "ratio": 0.7917,
+      "suggested_scalar": -0.2224,
+      "log_bad": 2.7096,
+      "log_good": 2.476
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.6122,
+      "good": 2.8791,
+      "ratio": 1.1022,
+      "suggested_scalar": 0.0926,
+      "log_bad": 0.9602,
+      "log_good": 1.0575
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 189.0,
+      "good": 150.0,
+      "ratio": 0.7937,
+      "suggested_scalar": -0.2201,
+      "log_bad": 5.2417,
+      "log_good": 5.0106
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9667,
+      "good": 0.9606,
+      "ratio": 0.9937,
+      "suggested_scalar": -0.006,
+      "log_bad": -0.0339,
+      "log_good": -0.0402
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 28.0,
+      "ratio": 0.9655,
+      "suggested_scalar": -0.0334,
+      "log_bad": 3.3673,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6664,
+      "good": 0.6159,
+      "ratio": 0.9242,
+      "suggested_scalar": -0.075,
+      "log_bad": -0.4059,
+      "log_good": -0.4847
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.6522,
+      "good": 0.5835,
+      "ratio": 0.8947,
+      "suggested_scalar": -0.106,
+      "log_bad": -0.4274,
+      "log_good": -0.5387
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9975,
+      "good": 2.6036,
+      "ratio": 0.8686,
+      "suggested_scalar": -0.1341,
+      "log_bad": 1.0978,
+      "log_good": 0.9569
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 644.0,
+      "good": 557.0,
+      "ratio": 0.8649,
+      "suggested_scalar": -0.1382,
+      "log_bad": 6.4677,
+      "log_good": 6.3226
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 23.0,
+      "good": 16.0,
+      "ratio": 0.6957,
+      "suggested_scalar": -0.3455,
+      "log_bad": 3.1355,
+      "log_good": 2.7726
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0279,
+      "good": 0.0286,
+      "ratio": 1.0251,
+      "suggested_scalar": 0.0236,
+      "log_bad": -3.5791,
+      "log_good": -3.5543
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0661,
+      "good": 6.1699,
+      "ratio": 1.0171,
+      "suggested_scalar": 0.0162,
+      "log_bad": 1.8027,
+      "log_good": 1.8197
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 38.0,
+      "good": 30.0,
+      "ratio": 0.7895,
+      "suggested_scalar": -0.2251,
+      "log_bad": 3.6376,
+      "log_good": 3.4012
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6517,
+      "good": 0.6958,
+      "ratio": 1.0677,
+      "suggested_scalar": 0.0623,
+      "log_bad": -0.4282,
+      "log_good": -0.3627
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.9288,
+      "good": 5.8116,
+      "ratio": 0.9802,
+      "suggested_scalar": -0.019,
+      "log_bad": 1.7798,
+      "log_good": 1.7599
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.808,
+      "good": 0.7968,
+      "ratio": 0.9861,
+      "suggested_scalar": -0.0133,
+      "log_bad": -0.2132,
+      "log_good": -0.2272
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1552,
+      "good": 0.1132,
+      "ratio": 0.7294,
+      "suggested_scalar": -0.3005,
+      "log_bad": -1.863,
+      "log_good": -2.1786
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.1385,
+      "good": 3.0649,
+      "ratio": 0.9765,
+      "suggested_scalar": -0.0226,
+      "log_bad": 1.1437,
+      "log_good": 1.12
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 380.0,
+      "good": 354.0,
+      "ratio": 0.9316,
+      "suggested_scalar": -0.0675,
+      "log_bad": 5.9402,
+      "log_good": 5.8693
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 7.0,
+      "good": 11.0,
+      "ratio": 1.5714,
+      "suggested_scalar": 0.4304,
+      "log_bad": 1.9459,
+      "log_good": 2.3979
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.2703,
+      "good": 0.9689,
+      "ratio": 0.7627,
+      "suggested_scalar": -0.2579,
+      "log_bad": 0.2393,
+      "log_good": -0.0316
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 140.0,
+      "good": 127.0,
+      "ratio": 0.9071,
+      "suggested_scalar": -0.0928,
+      "log_bad": 4.9416,
+      "log_good": 4.8442
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1463.0,
+      "good": 1153.0,
+      "ratio": 0.7881,
+      "suggested_scalar": -0.2267,
+      "log_bad": 7.2882,
+      "log_good": 7.0501
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 211.0,
+      "good": 146.0,
+      "ratio": 0.6919,
+      "suggested_scalar": -0.3506,
+      "log_bad": 5.3519,
+      "log_good": 4.9836
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0108,
+      "good": 0.0107,
+      "ratio": 0.9907,
+      "suggested_scalar": -0.0089,
+      "log_bad": -4.5282,
+      "log_good": -4.5375
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2399,
+      "good": 0.2361,
+      "ratio": 0.9842,
+      "suggested_scalar": -0.0152,
+      "log_bad": -1.4275,
+      "log_good": -1.4435
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 157.0,
+      "good": 132.0,
+      "ratio": 0.8408,
+      "suggested_scalar": -0.1651,
+      "log_bad": 5.0562,
+      "log_good": 4.8828
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 140.0,
+      "good": 127.0,
+      "ratio": 0.9071,
+      "suggested_scalar": -0.0928,
+      "log_bad": 4.9416,
+      "log_good": 4.8442
+    },
+    "brevity.mean_sample_size": {
+      "bad": 140.0,
+      "good": 127.0,
+      "ratio": 0.9071,
+      "suggested_scalar": -0.0928,
+      "log_bad": 4.9416,
+      "log_good": 4.8442
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 646.0,
+      "good": 559.0,
+      "ratio": 0.8653,
+      "suggested_scalar": -0.1377,
+      "log_bad": 6.4708,
+      "log_good": 6.3261
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 373.0,
+      "good": 333.0,
+      "ratio": 0.8928,
+      "suggested_scalar": -0.108,
+      "log_bad": 5.9216,
+      "log_good": 5.8081
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 313.0,
+      "good": 285.0,
+      "ratio": 0.9105,
+      "suggested_scalar": -0.0892,
+      "log_bad": 5.7462,
+      "log_good": 5.6525
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0062,
+      "good": 0.0072,
+      "ratio": 1.1613,
+      "suggested_scalar": 0.1424,
+      "log_bad": -5.0832,
+      "log_good": -4.9337
+    },
+    "heaps.mean_k": {
+      "bad": 3.1007,
+      "good": 3.0512,
+      "ratio": 0.984,
+      "suggested_scalar": -0.0153,
+      "log_bad": 1.1316,
+      "log_good": 1.1155
+    },
+    "halstead.mean_effort": {
+      "bad": 122731.0238,
+      "good": 99023.0867,
+      "ratio": 0.8068,
+      "suggested_scalar": -0.2044,
+      "log_bad": 11.7178,
+      "log_good": 11.5031
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8316,
+      "good": 0.8316,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.1844,
+      "log_good": -0.1844
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 95.0,
+      "good": 60.0,
+      "ratio": 0.6316,
+      "suggested_scalar": -0.4376,
+      "log_bad": 4.5539,
+      "log_good": 4.0943
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 337.0,
+      "good": 304.0,
+      "ratio": 0.9021,
+      "suggested_scalar": -0.0981,
+      "log_bad": 5.8201,
+      "log_good": 5.717
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4185,
+      "good": 0.4254,
+      "ratio": 1.0165,
+      "suggested_scalar": 0.0156,
+      "log_bad": -0.8711,
+      "log_good": -0.8547
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.4449,
+      "good": 6.3702,
+      "ratio": 0.9884,
+      "suggested_scalar": -0.0111,
+      "log_bad": 1.8633,
+      "log_good": 1.8516
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1552,
+      "good": 0.1132,
+      "ratio": 0.7294,
+      "suggested_scalar": -0.3005,
+      "log_bad": -1.863,
+      "log_good": -2.1786
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 6.0093,
+      "good": 4.9401,
+      "ratio": 0.8221,
+      "suggested_scalar": -0.1866,
+      "log_bad": 1.7933,
+      "log_good": 1.5974
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 645.0,
+      "good": 558.0,
+      "ratio": 0.8651,
+      "suggested_scalar": -0.138,
+      "log_bad": 6.4693,
+      "log_good": 6.3244
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 156.0,
+      "good": 122.0,
+      "ratio": 0.7821,
+      "suggested_scalar": -0.2341,
+      "log_bad": 5.0499,
+      "log_good": 4.804
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6818.3902,
+      "good": 5501.2826,
+      "ratio": 0.8068,
+      "suggested_scalar": -0.2044,
+      "log_bad": 8.8274,
+      "log_good": 8.6127
+    },
+    "readability.mean_total_lines": {
+      "bad": 43.0,
+      "good": 47.0,
+      "ratio": 1.093,
+      "suggested_scalar": 0.0847,
+      "log_bad": 3.7612,
+      "log_good": 3.8501
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 3810.8996,
+      "good": 2906.7442,
+      "ratio": 0.7627,
+      "suggested_scalar": -0.2579,
+      "log_bad": 8.2456,
+      "log_good": 7.9748
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 814.0,
+      "good": 782.0,
+      "ratio": 0.9607,
+      "suggested_scalar": -0.0382,
+      "log_bad": 6.702,
+      "log_good": 6.6619
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 45.6279,
+      "good": 42.1489,
+      "ratio": 0.9238,
+      "suggested_scalar": -0.0755,
+      "log_bad": 3.8205,
+      "log_good": 3.7412
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.178,
+      "good": 1.1598,
+      "ratio": 0.9846,
+      "suggested_scalar": -0.0148,
+      "log_bad": 0.1638,
+      "log_good": 0.1482
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 31.0,
+      "good": 28.0,
+      "ratio": 0.9032,
+      "suggested_scalar": -0.0969,
+      "log_bad": 3.434,
+      "log_good": 3.3322
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 1.0,
+      "ratio": 0.1667,
+      "suggested_scalar": -1.7061,
+      "log_bad": 1.7918,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.5895,
+      "good": 0.6554,
+      "ratio": 1.1118,
+      "suggested_scalar": 0.1009,
+      "log_bad": -0.5285,
+      "log_good": -0.4225
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9563,
+      "good": 0.9575,
+      "ratio": 1.0013,
+      "suggested_scalar": 0.0012,
+      "log_bad": -0.0447,
+      "log_good": -0.0434
+    },
+    "halstead.mean_length": {
+      "bad": 548.0,
+      "good": 450.0,
+      "ratio": 0.8212,
+      "suggested_scalar": -0.1876,
+      "log_bad": 6.3063,
+      "log_good": 6.1092
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 22.0,
+      "good": 14.0,
+      "ratio": 0.6364,
+      "suggested_scalar": -0.4304,
+      "log_bad": 3.091,
+      "log_good": 2.6391
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 7.1293,
+      "good": 6.9887,
+      "ratio": 0.9803,
+      "suggested_scalar": -0.019,
+      "log_bad": 1.9642,
+      "log_good": 1.9443
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1529,
+      "good": 0.1637,
+      "ratio": 1.0706,
+      "suggested_scalar": 0.065,
+      "log_bad": -1.878,
+      "log_good": -1.8097
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 32.2053,
+      "good": 34.0667,
+      "ratio": 1.0578,
+      "suggested_scalar": 0.0535,
+      "log_bad": 3.4721,
+      "log_good": 3.5283
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.2739,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 95.0,
+      "good": 77.0,
+      "ratio": 0.8105,
+      "suggested_scalar": -0.2,
+      "log_bad": 4.5539,
+      "log_good": 4.3438
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.4984,
+      "good": 0.5368,
+      "ratio": 1.077,
+      "suggested_scalar": 0.0707,
+      "log_bad": -0.6964,
+      "log_good": -0.6221
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 49.0,
+      "good": 47.0,
+      "ratio": 0.9592,
+      "suggested_scalar": -0.0397,
+      "log_bad": 3.8918,
+      "log_good": 3.8501
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 15.0,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.0657,
+      "log_bad": 2.6391,
+      "log_good": 2.7081
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.bang_function_raises_on_failure": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 36.0,
+      "good": 42.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.0416,
+      "log_bad": 3.5835,
+      "log_good": 3.7377
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0085,
+      "good": 0.036,
+      "ratio": 4.2353,
+      "suggested_scalar": 0.3891,
+      "log_bad": -4.7677,
+      "log_good": -3.3242
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3333,
+      "good": 1.2857,
+      "ratio": 0.9643,
+      "suggested_scalar": -0.0098,
+      "log_bad": 0.2877,
+      "log_good": 0.2513
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8167,
+      "good": 0.6667,
+      "ratio": 0.8163,
+      "suggested_scalar": -0.0547,
+      "log_bad": -0.2025,
+      "log_good": -0.4054
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0085,
+      "good": 0.036,
+      "ratio": 4.2353,
+      "suggested_scalar": 0.3891,
+      "log_bad": -4.7677,
+      "log_good": -3.3242
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5475,
+      "good": 4.6969,
+      "ratio": 1.0329,
+      "suggested_scalar": 0.0087,
+      "log_bad": 1.5146,
+      "log_good": 1.5469
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 84.0,
+      "good": 64.0,
+      "ratio": 0.7619,
+      "suggested_scalar": -0.0733,
+      "log_bad": 4.4308,
+      "log_good": 4.1589
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4005,
+      "good": 0.392,
+      "ratio": 0.9788,
+      "suggested_scalar": -0.0058,
+      "log_bad": -0.915,
+      "log_good": -0.9365
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5551,
+      "good": 0.4599,
+      "ratio": 0.8285,
+      "suggested_scalar": -0.0507,
+      "log_bad": -0.5886,
+      "log_good": -0.7767
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.9,
+      "good": 2.56,
+      "ratio": 0.6564,
+      "suggested_scalar": -0.1135,
+      "log_bad": 1.361,
+      "log_good": 0.94
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 468.0,
+      "good": 667.0,
+      "ratio": 1.4252,
+      "suggested_scalar": 0.0955,
+      "log_bad": 6.1485,
+      "log_good": 6.5028
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0051,
+      "good": 0.0041,
+      "ratio": 0.8039,
+      "suggested_scalar": -0.0588,
+      "log_bad": -5.2785,
+      "log_good": -5.4968
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1,
+      "good": 1.0,
+      "ratio": 10.0,
+      "suggested_scalar": 0.6208,
+      "log_bad": -2.3026,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0006,
+      "good": 1.0,
+      "ratio": 1666.6667,
+      "suggested_scalar": 2.0,
+      "log_bad": -7.4186,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.06,
+      "good": 1.1622,
+      "ratio": 1.0964,
+      "suggested_scalar": 0.0248,
+      "log_bad": 0.0583,
+      "log_good": 0.1503
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 164.0,
+      "good": 241.0,
+      "ratio": 1.4695,
+      "suggested_scalar": 0.1038,
+      "log_bad": 5.0999,
+      "log_good": 5.4848
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 106.3573,
+      "good": 105.4124,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.0024,
+      "log_bad": 4.6668,
+      "log_good": 4.6579
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7623,
+      "good": 0.8904,
+      "ratio": 1.168,
+      "suggested_scalar": 0.0419,
+      "log_bad": -0.2714,
+      "log_good": -0.1161
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.2387,
+      "good": 8.2759,
+      "ratio": 0.8958,
+      "suggested_scalar": -0.0297,
+      "log_bad": 2.2234,
+      "log_good": 2.1133
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1770.0,
+      "good": 2214.0,
+      "ratio": 1.2508,
+      "suggested_scalar": 0.0603,
+      "log_bad": 7.4787,
+      "log_good": 7.7026
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1333,
+      "good": 0.12,
+      "ratio": 0.9002,
+      "suggested_scalar": -0.0283,
+      "log_bad": -2.0152,
+      "log_good": -2.1203
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.75,
+      "good": 0.64,
+      "ratio": 0.8533,
+      "suggested_scalar": -0.0428,
+      "log_bad": -0.2877,
+      "log_good": -0.4463
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.6667,
+      "good": 8.8933,
+      "ratio": 1.0261,
+      "suggested_scalar": 0.007,
+      "log_bad": 2.1595,
+      "log_good": 2.1853
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1869,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 6.8567,
+      "good": 1.3397,
+      "ratio": 0.1954,
+      "suggested_scalar": -0.4402,
+      "log_bad": 1.9252,
+      "log_good": 0.2924
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 120.0,
+      "good": 176.0,
+      "ratio": 1.4667,
+      "suggested_scalar": 0.1033,
+      "log_bad": 4.7875,
+      "log_good": 5.1705
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.925,
+      "good": 0.9331,
+      "ratio": 1.0088,
+      "suggested_scalar": 0.0024,
+      "log_bad": -0.078,
+      "log_good": -0.0692
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 28.0,
+      "ratio": 0.9655,
+      "suggested_scalar": -0.0095,
+      "log_bad": 3.3673,
+      "log_good": 3.3322
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6701,
+      "good": 0.7132,
+      "ratio": 1.0643,
+      "suggested_scalar": 0.0168,
+      "log_bad": -0.4003,
+      "log_good": -0.338
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.6052,
+      "good": 0.788,
+      "ratio": 1.302,
+      "suggested_scalar": 0.0712,
+      "log_bad": -0.5022,
+      "log_good": -0.2383
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.0308,
+      "good": 3.4866,
+      "ratio": 1.1504,
+      "suggested_scalar": 0.0378,
+      "log_bad": 1.1088,
+      "log_good": 1.2489
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 466.0,
+      "good": 665.0,
+      "ratio": 1.427,
+      "suggested_scalar": 0.0959,
+      "log_bad": 6.1442,
+      "log_good": 6.4998
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 14.0,
+      "good": 13.0,
+      "ratio": 0.9286,
+      "suggested_scalar": -0.02,
+      "log_bad": 2.6391,
+      "log_good": 2.5649
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0171,
+      "good": 1.0,
+      "ratio": 58.4795,
+      "suggested_scalar": 1.0969,
+      "log_bad": -4.0687,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.6724,
+      "good": 5.7549,
+      "ratio": 1.0145,
+      "suggested_scalar": 0.0039,
+      "log_bad": 1.7356,
+      "log_good": 1.7501
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 43.0,
+      "good": 65.0,
+      "ratio": 1.5116,
+      "suggested_scalar": 0.1114,
+      "log_bad": 3.7612,
+      "log_good": 4.1744
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.881,
+      "good": 0.841,
+      "ratio": 0.9546,
+      "suggested_scalar": -0.0125,
+      "log_bad": -0.1267,
+      "log_good": -0.1732
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5688,
+      "good": 5.5601,
+      "ratio": 0.9984,
+      "suggested_scalar": -0.0004,
+      "log_bad": 1.7172,
+      "log_good": 1.7156
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8017,
+      "good": 0.8162,
+      "ratio": 1.0181,
+      "suggested_scalar": 0.0048,
+      "log_bad": -0.221,
+      "log_good": -0.2031
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1869,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1176,
+      "good": 0.0964,
+      "ratio": 0.8197,
+      "suggested_scalar": -0.0536,
+      "log_bad": -2.1405,
+      "log_good": -2.3392
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.0395,
+      "good": 2.8768,
+      "ratio": 0.9465,
+      "suggested_scalar": -0.0148,
+      "log_bad": 1.1117,
+      "log_good": 1.0567
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 285.0,
+      "good": 292.0,
+      "ratio": 1.0246,
+      "suggested_scalar": 0.0065,
+      "log_bad": 5.6525,
+      "log_good": 5.6768
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 10.0,
+      "ratio": 5.0,
+      "suggested_scalar": 0.4339,
+      "log_bad": 0.6931,
+      "log_good": 2.3026
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.9248,
+      "good": 0.992,
+      "ratio": 1.0727,
+      "suggested_scalar": 0.0189,
+      "log_bad": -0.0782,
+      "log_good": -0.008
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 86.0,
+      "good": 97.0,
+      "ratio": 1.1279,
+      "suggested_scalar": 0.0324,
+      "log_bad": 4.4543,
+      "log_good": 4.5747
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 851.0,
+      "good": 1194.0,
+      "ratio": 1.4031,
+      "suggested_scalar": 0.0913,
+      "log_bad": 6.7464,
+      "log_good": 7.0851
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 172.0,
+      "good": 159.0,
+      "ratio": 0.9244,
+      "suggested_scalar": -0.0212,
+      "log_bad": 5.1475,
+      "log_good": 5.0689
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1869,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0171,
+      "good": 0.003,
+      "ratio": 0.1754,
+      "suggested_scalar": -0.4692,
+      "log_bad": -4.0687,
+      "log_good": -5.8091
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2457,
+      "good": 0.2234,
+      "ratio": 0.9092,
+      "suggested_scalar": -0.0257,
+      "log_bad": -1.4036,
+      "log_good": -1.4988
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 100.0,
+      "good": 138.0,
+      "ratio": 1.38,
+      "suggested_scalar": 0.0868,
+      "log_bad": 4.6052,
+      "log_good": 4.9273
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 7.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.0416,
+      "log_bad": 1.7918,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 86.0,
+      "good": 97.0,
+      "ratio": 1.1279,
+      "suggested_scalar": 0.0324,
+      "log_bad": 4.4543,
+      "log_good": 4.5747
+    },
+    "brevity.mean_sample_size": {
+      "bad": 86.0,
+      "good": 97.0,
+      "ratio": 1.1279,
+      "suggested_scalar": 0.0324,
+      "log_bad": 4.4543,
+      "log_good": 4.5747
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 468.0,
+      "good": 667.0,
+      "ratio": 1.4252,
+      "suggested_scalar": 0.0955,
+      "log_bad": 6.1485,
+      "log_good": 6.5028
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 241.0,
+      "good": 374.0,
+      "ratio": 1.5519,
+      "suggested_scalar": 0.1185,
+      "log_bad": 5.4848,
+      "log_good": 5.9243
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 211.0,
+      "good": 211.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.3519,
+      "log_good": 5.3519
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 3.0391,
+      "good": 5.6072,
+      "ratio": 1.845,
+      "suggested_scalar": 0.1651,
+      "log_bad": 1.1116,
+      "log_good": 1.7241
+    },
+    "halstead.mean_effort": {
+      "bad": 125800.342,
+      "good": 184016.0,
+      "ratio": 1.4628,
+      "suggested_scalar": 0.1025,
+      "log_bad": 11.7425,
+      "log_good": 12.1228
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.2962,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8666,
+      "good": 0.8425,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.0076,
+      "log_bad": -0.1432,
+      "log_good": -0.1714
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 55.0,
+      "good": 36.0,
+      "ratio": 0.6545,
+      "suggested_scalar": -0.1143,
+      "log_bad": 4.0073,
+      "log_good": 3.5835
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 262.0,
+      "good": 337.0,
+      "ratio": 1.2863,
+      "suggested_scalar": 0.0679,
+      "log_bad": 5.5683,
+      "log_good": 5.8201
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3171,
+      "good": 0.2656,
+      "ratio": 0.8376,
+      "suggested_scalar": -0.0478,
+      "log_bad": -1.1485,
+      "log_good": -1.3258
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.189,
+      "good": 4.9544,
+      "ratio": 0.9548,
+      "suggested_scalar": -0.0125,
+      "log_bad": 1.6465,
+      "log_good": 1.6003
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1176,
+      "good": 0.0964,
+      "ratio": 0.8197,
+      "suggested_scalar": -0.0536,
+      "log_bad": -2.1405,
+      "log_good": -2.3392
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.8191,
+      "good": 3.8304,
+      "ratio": 1.003,
+      "suggested_scalar": 0.0008,
+      "log_bad": 1.34,
+      "log_good": 1.343
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 467.0,
+      "good": 666.0,
+      "ratio": 1.4261,
+      "suggested_scalar": 0.0957,
+      "log_bad": 6.1463,
+      "log_good": 6.5013
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 11.0,
+      "good": 17.0,
+      "ratio": 1.5455,
+      "suggested_scalar": 0.1174,
+      "log_bad": 2.3979,
+      "log_good": 2.8332
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 101.0,
+      "good": 151.0,
+      "ratio": 1.495,
+      "suggested_scalar": 0.1084,
+      "log_bad": 4.6151,
+      "log_good": 5.0173
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6988.9079,
+      "good": 10223.1111,
+      "ratio": 1.4628,
+      "suggested_scalar": 0.1025,
+      "log_bad": 8.8521,
+      "log_good": 9.2324
+    },
+    "readability.mean_total_lines": {
+      "bad": 54.0,
+      "good": 75.0,
+      "ratio": 1.3889,
+      "suggested_scalar": 0.0886,
+      "log_bad": 3.989,
+      "log_good": 4.3175
+    },
+    "indentation.mean_max_depth": {
+      "bad": 10.0,
+      "good": 6.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.1377,
+      "log_bad": 2.3026,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2774.2658,
+      "good": 2976.0,
+      "ratio": 1.0727,
+      "suggested_scalar": 0.0189,
+      "log_bad": 7.9281,
+      "log_good": 7.9983
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 584.0,
+      "good": 635.0,
+      "ratio": 1.0873,
+      "suggested_scalar": 0.0226,
+      "log_bad": 6.3699,
+      "log_good": 6.4536
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 25.3333,
+      "good": 28.4133,
+      "ratio": 1.1216,
+      "suggested_scalar": 0.0309,
+      "log_bad": 3.2321,
+      "log_good": 3.3469
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0837,
+      "good": 1.0922,
+      "ratio": 1.0078,
+      "suggested_scalar": 0.0021,
+      "log_bad": 0.0804,
+      "log_good": 0.0882
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 27.0,
+      "good": 49.0,
+      "ratio": 1.8148,
+      "suggested_scalar": 0.1607,
+      "log_bad": 3.2958,
+      "log_good": 3.8918
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 1.0,
+      "ratio": 0.1667,
+      "suggested_scalar": -0.483,
+      "log_bad": 1.7918,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6456,
+      "good": 0.4829,
+      "ratio": 0.748,
+      "suggested_scalar": -0.0783,
+      "log_bad": -0.4376,
+      "log_good": -0.7279
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 9.0,
+      "ratio": 4.5,
+      "suggested_scalar": 0.4055,
+      "log_bad": 0.6931,
+      "log_good": 2.1972
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9651,
+      "good": 0.9183,
+      "ratio": 0.9515,
+      "suggested_scalar": -0.0134,
+      "log_bad": -0.0355,
+      "log_good": -0.0852
+    },
+    "halstead.mean_length": {
+      "bad": 434.0,
+      "good": 496.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.036,
+      "log_bad": 6.073,
+      "log_good": 6.2066
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.6667,
+      "good": 9.8571,
+      "ratio": 1.0197,
+      "suggested_scalar": 0.0053,
+      "log_bad": 2.2687,
+      "log_good": 2.2882
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4263,
+      "good": 6.5999,
+      "ratio": 1.027,
+      "suggested_scalar": 0.0072,
+      "log_bad": 1.8604,
+      "log_good": 1.8871
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1362,
+      "good": 0.1689,
+      "ratio": 1.2401,
+      "suggested_scalar": 0.058,
+      "log_bad": -1.9936,
+      "log_good": -1.7784
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 45.3455,
+      "good": 61.8333,
+      "ratio": 1.3636,
+      "suggested_scalar": 0.0836,
+      "log_bad": 3.8143,
+      "log_good": 4.1244
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 9.0,
+      "ratio": 1.125,
+      "suggested_scalar": 0.0318,
+      "log_bad": 2.0794,
+      "log_good": 2.1972
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 52.0,
+      "good": 64.0,
+      "ratio": 1.2308,
+      "suggested_scalar": 0.056,
+      "log_bad": 3.9512,
+      "log_good": 4.1589
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5261,
+      "good": 0.346,
+      "ratio": 0.6577,
+      "suggested_scalar": -0.113,
+      "log_bad": -0.6423,
+      "log_good": -1.0613
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 60.0,
+      "good": 75.0,
+      "ratio": 1.25,
+      "suggested_scalar": 0.0602,
+      "log_bad": 4.0943,
+      "log_good": 4.3175
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 21.0,
+      "ratio": 1.2353,
+      "suggested_scalar": 0.057,
+      "log_bad": 2.8332,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.does_not_use_get_prefix_for_accessors": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 33.0,
+      "good": 27.0,
+      "ratio": 0.8182,
+      "suggested_scalar": -0.0844,
+      "log_bad": 3.4965,
+      "log_good": 3.2958
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0086,
+      "good": 1.0,
+      "ratio": 116.2791,
+      "suggested_scalar": 2.0,
+      "log_bad": -4.756,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.3333,
+      "good": 1.3333,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.2877,
+      "log_good": 0.2877
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8261,
+      "good": 0.8,
+      "ratio": 0.9684,
+      "suggested_scalar": -0.0135,
+      "log_bad": -0.191,
+      "log_good": -0.2231
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0086,
+      "good": 1.0,
+      "ratio": 116.2791,
+      "suggested_scalar": 2.0,
+      "log_bad": -4.756,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7063,
+      "good": 4.5727,
+      "ratio": 0.9716,
+      "suggested_scalar": -0.0121,
+      "log_bad": 1.5489,
+      "log_good": 1.5201
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 83.0,
+      "good": 59.0,
+      "ratio": 0.7108,
+      "suggested_scalar": -0.1435,
+      "log_bad": 4.4188,
+      "log_good": 4.0775
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4379,
+      "good": 0.2967,
+      "ratio": 0.6776,
+      "suggested_scalar": -0.1637,
+      "log_bad": -0.8258,
+      "log_good": -1.215
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 16.0,
+      "ratio": 0.8421,
+      "suggested_scalar": -0.0723,
+      "log_bad": 2.9444,
+      "log_good": 2.7726
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6187,
+      "good": 0.5553,
+      "ratio": 0.8975,
+      "suggested_scalar": -0.0455,
+      "log_bad": -0.4801,
+      "log_good": -0.5882
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.0,
+      "good": 5.15,
+      "ratio": 1.03,
+      "suggested_scalar": 0.0124,
+      "log_bad": 1.6094,
+      "log_good": 1.639
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 349.0,
+      "good": 273.0,
+      "ratio": 0.7822,
+      "suggested_scalar": -0.1033,
+      "log_bad": 5.8551,
+      "log_good": 5.6095
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1304,
+      "good": 1.0,
+      "ratio": 7.6687,
+      "suggested_scalar": 0.8567,
+      "log_bad": -2.0371,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0034,
+      "good": 0.0043,
+      "ratio": 1.2647,
+      "suggested_scalar": 0.0988,
+      "log_bad": -5.684,
+      "log_good": -5.4491
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9853,
+      "good": 0.9925,
+      "ratio": 1.0073,
+      "suggested_scalar": 0.0031,
+      "log_bad": -0.0148,
+      "log_good": -0.0075
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 123.0,
+      "good": 91.0,
+      "ratio": 0.7398,
+      "suggested_scalar": -0.1267,
+      "log_bad": 4.8122,
+      "log_good": 4.5109
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 90.2921,
+      "good": 93.01,
+      "ratio": 1.0301,
+      "suggested_scalar": 0.0125,
+      "log_bad": 4.503,
+      "log_good": 4.5327
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.592,
+      "good": 0.5846,
+      "ratio": 0.9875,
+      "suggested_scalar": -0.0053,
+      "log_bad": -0.5242,
+      "log_good": -0.5368
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 23.8604,
+      "good": 18.7084,
+      "ratio": 0.7841,
+      "suggested_scalar": -0.1023,
+      "log_bad": 3.1722,
+      "log_good": 2.929
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1785.0,
+      "good": 1398.0,
+      "ratio": 0.7832,
+      "suggested_scalar": -0.1028,
+      "log_bad": 7.4872,
+      "log_good": 7.2428
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2174,
+      "good": 0.2,
+      "ratio": 0.92,
+      "suggested_scalar": -0.0351,
+      "log_bad": -1.526,
+      "log_good": -1.6094
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7826,
+      "good": 0.75,
+      "ratio": 0.9583,
+      "suggested_scalar": -0.0179,
+      "log_bad": -0.2451,
+      "log_good": -0.2877
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.587,
+      "good": 6.825,
+      "ratio": 0.8996,
+      "suggested_scalar": -0.0445,
+      "log_bad": 2.0264,
+      "log_good": 1.9206
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 8.4783,
+      "good": 9.5775,
+      "ratio": 1.1296,
+      "suggested_scalar": 0.0513,
+      "log_bad": 2.1375,
+      "log_good": 2.2594
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 58.0,
+      "good": 40.0,
+      "ratio": 0.6897,
+      "suggested_scalar": -0.1563,
+      "log_bad": 4.0604,
+      "log_good": 3.6889
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.8698,
+      "good": 0.8245,
+      "ratio": 0.9479,
+      "suggested_scalar": -0.0225,
+      "log_bad": -0.1395,
+      "log_good": -0.193
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 24.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.0495,
+      "log_bad": 3.2958,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6644,
+      "good": 0.666,
+      "ratio": 1.0024,
+      "suggested_scalar": 0.001,
+      "log_bad": -0.4089,
+      "log_good": -0.4065
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4035,
+      "good": 0.3911,
+      "ratio": 0.9693,
+      "suggested_scalar": -0.0131,
+      "log_bad": -0.9076,
+      "log_good": -0.9388
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.98,
+      "good": 2.9936,
+      "ratio": 1.0046,
+      "suggested_scalar": 0.0019,
+      "log_bad": 1.0919,
+      "log_good": 1.0965
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 347.0,
+      "good": 271.0,
+      "ratio": 0.781,
+      "suggested_scalar": -0.104,
+      "log_bad": 5.8493,
+      "log_good": 5.6021
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.063,
+      "good": 0.0659,
+      "ratio": 1.046,
+      "suggested_scalar": 0.0189,
+      "log_bad": -2.7646,
+      "log_good": -2.7196
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.0,
+      "good": 5.8074,
+      "ratio": 0.9679,
+      "suggested_scalar": -0.0137,
+      "log_bad": 1.7918,
+      "log_good": 1.7591
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 31.0,
+      "good": 24.0,
+      "ratio": 0.7742,
+      "suggested_scalar": -0.1076,
+      "log_bad": 3.434,
+      "log_good": 3.1781
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.5782,
+      "good": 1.5485,
+      "ratio": 0.9812,
+      "suggested_scalar": -0.008,
+      "log_bad": 0.4563,
+      "log_good": 0.4373
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7395,
+      "good": 5.3126,
+      "ratio": 0.9256,
+      "suggested_scalar": -0.0325,
+      "log_bad": 1.7474,
+      "log_good": 1.6701
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7844,
+      "good": 0.7874,
+      "ratio": 1.0038,
+      "suggested_scalar": 0.0016,
+      "log_bad": -0.2428,
+      "log_good": -0.239
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1786,
+      "good": 0.2,
+      "ratio": 1.1198,
+      "suggested_scalar": 0.0476,
+      "log_bad": -1.7226,
+      "log_good": -1.6094
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.8847,
+      "good": 4.3253,
+      "ratio": 0.8855,
+      "suggested_scalar": -0.0511,
+      "log_bad": 1.5861,
+      "log_good": 1.4645
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 256.0,
+      "good": 205.0,
+      "ratio": 0.8008,
+      "suggested_scalar": -0.0934,
+      "log_bad": 5.5452,
+      "log_good": 5.323
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6864,
+      "good": 0.502,
+      "ratio": 0.7314,
+      "suggested_scalar": -0.1316,
+      "log_bad": -0.3763,
+      "log_good": -0.6892
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 59.0,
+      "ratio": 0.6941,
+      "suggested_scalar": -0.1535,
+      "log_bad": 4.4427,
+      "log_good": 4.0775
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 972.0,
+      "good": 721.0,
+      "ratio": 0.7418,
+      "suggested_scalar": -0.1256,
+      "log_bad": 6.8794,
+      "log_good": 6.5806
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 145.0,
+      "good": 110.0,
+      "ratio": 0.7586,
+      "suggested_scalar": -0.1162,
+      "log_bad": 4.9767,
+      "log_good": 4.7005
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0143,
+      "good": 0.0183,
+      "ratio": 1.2797,
+      "suggested_scalar": 0.1037,
+      "log_bad": -4.2475,
+      "log_good": -4.0009
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2178,
+      "good": 0.2344,
+      "ratio": 1.0762,
+      "suggested_scalar": 0.0309,
+      "log_bad": -1.5242,
+      "log_good": -1.4507
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 63.0,
+      "good": 50.0,
+      "ratio": 0.7937,
+      "suggested_scalar": -0.0972,
+      "log_bad": 4.1431,
+      "log_good": 3.912
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 59.0,
+      "ratio": 0.6941,
+      "suggested_scalar": -0.1535,
+      "log_bad": 4.4427,
+      "log_good": 4.0775
+    },
+    "brevity.mean_sample_size": {
+      "bad": 85.0,
+      "good": 59.0,
+      "ratio": 0.6941,
+      "suggested_scalar": -0.1535,
+      "log_bad": 4.4427,
+      "log_good": 4.0775
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 349.0,
+      "good": 273.0,
+      "ratio": 0.7822,
+      "suggested_scalar": -0.1033,
+      "log_bad": 5.8551,
+      "log_good": 5.6095
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 171.0,
+      "good": 137.0,
+      "ratio": 0.8012,
+      "suggested_scalar": -0.0932,
+      "log_bad": 5.1417,
+      "log_good": 4.92
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 205.0,
+      "good": 163.0,
+      "ratio": 0.7951,
+      "suggested_scalar": -0.0964,
+      "log_bad": 5.323,
+      "log_good": 5.0938
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0057,
+      "good": 0.0073,
+      "ratio": 1.2807,
+      "suggested_scalar": 0.104,
+      "log_bad": -5.1673,
+      "log_good": -4.9199
+    },
+    "heaps.mean_k": {
+      "bad": 2.6231,
+      "good": 2.9241,
+      "ratio": 1.1147,
+      "suggested_scalar": 0.0457,
+      "log_bad": 0.9644,
+      "log_good": 1.073
+    },
+    "halstead.mean_effort": {
+      "bad": 71977.895,
+      "good": 56796.0783,
+      "ratio": 0.7891,
+      "suggested_scalar": -0.0996,
+      "log_bad": 11.1841,
+      "log_good": 10.9472
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8955,
+      "good": 0.9031,
+      "ratio": 1.0085,
+      "suggested_scalar": 0.0036,
+      "log_bad": -0.1104,
+      "log_good": -0.1019
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 56.0,
+      "good": 35.0,
+      "ratio": 0.625,
+      "suggested_scalar": -0.1976,
+      "log_bad": 4.0254,
+      "log_good": 3.5553
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 178.0,
+      "good": 146.0,
+      "ratio": 0.8202,
+      "suggested_scalar": -0.0833,
+      "log_bad": 5.1818,
+      "log_good": 4.9836
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3821,
+      "good": 0.2967,
+      "ratio": 0.7765,
+      "suggested_scalar": -0.1064,
+      "log_bad": -0.9621,
+      "log_good": -1.215
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.9024,
+      "good": 7.9231,
+      "ratio": 1.0026,
+      "suggested_scalar": 0.0011,
+      "log_bad": 2.0672,
+      "log_good": 2.0698
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1786,
+      "good": 0.2,
+      "ratio": 1.1198,
+      "suggested_scalar": 0.0476,
+      "log_bad": -1.7226,
+      "log_good": -1.6094
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.14,
+      "good": 3.3502,
+      "ratio": 0.6518,
+      "suggested_scalar": -0.18,
+      "log_bad": 1.6371,
+      "log_good": 1.209
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 348.0,
+      "good": 272.0,
+      "ratio": 0.7816,
+      "suggested_scalar": -0.1036,
+      "log_bad": 5.8522,
+      "log_good": 5.6058
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 49.0,
+      "good": 40.0,
+      "ratio": 0.8163,
+      "suggested_scalar": -0.0853,
+      "log_bad": 3.8918,
+      "log_good": 3.6889
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3998.7719,
+      "good": 3155.3377,
+      "ratio": 0.7891,
+      "suggested_scalar": -0.0996,
+      "log_bad": 8.2937,
+      "log_good": 8.0569
+    },
+    "readability.mean_total_lines": {
+      "bad": 46.0,
+      "good": 40.0,
+      "ratio": 0.8696,
+      "suggested_scalar": -0.0588,
+      "log_bad": 3.8286,
+      "log_good": 3.6889
+    },
+    "indentation.mean_max_depth": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "halstead.mean_volume": {
+      "bad": 2059.1377,
+      "good": 1505.9566,
+      "ratio": 0.7314,
+      "suggested_scalar": -0.1316,
+      "log_bad": 7.63,
+      "log_good": 7.3172
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 599.0,
+      "good": 467.0,
+      "ratio": 0.7796,
+      "suggested_scalar": -0.1047,
+      "log_bad": 6.3953,
+      "log_good": 6.1463
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 37.4565,
+      "good": 33.7,
+      "ratio": 0.8997,
+      "suggested_scalar": -0.0444,
+      "log_bad": 3.6232,
+      "log_good": 3.5175
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2865,
+      "good": 1.2636,
+      "ratio": 0.9822,
+      "suggested_scalar": -0.0076,
+      "log_bad": 0.2519,
+      "log_good": 0.234
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 11.0,
+      "good": 11.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.3979,
+      "log_good": 2.3979
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 6.0,
+      "good": 1.0,
+      "ratio": 0.1667,
+      "suggested_scalar": -0.7535,
+      "log_bad": 1.7918,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8086,
+      "good": 0.8049,
+      "ratio": 0.9954,
+      "suggested_scalar": -0.0019,
+      "log_bad": -0.2125,
+      "log_good": -0.217
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9646,
+      "good": 0.9656,
+      "ratio": 1.001,
+      "suggested_scalar": 0.0004,
+      "log_bad": -0.036,
+      "log_good": -0.035
+    },
+    "halstead.mean_length": {
+      "bad": 323.0,
+      "good": 256.0,
+      "ratio": 0.7926,
+      "suggested_scalar": -0.0978,
+      "log_bad": 5.7777,
+      "log_good": 5.5452
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.5,
+      "good": 5.0,
+      "ratio": 0.9091,
+      "suggested_scalar": -0.0401,
+      "log_bad": 1.7047,
+      "log_good": 1.6094
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4094,
+      "good": 5.8826,
+      "ratio": 0.9178,
+      "suggested_scalar": -0.0361,
+      "log_bad": 1.8578,
+      "log_good": 1.772
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0961,
+      "good": 0.098,
+      "ratio": 1.0198,
+      "suggested_scalar": 0.0082,
+      "log_bad": -2.3424,
+      "log_good": -2.3228
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 34.9554,
+      "good": 37.7143,
+      "ratio": 1.0789,
+      "suggested_scalar": 0.0319,
+      "log_bad": 3.5541,
+      "log_good": 3.63
+    },
+    "branching.mean_branch_count": {
+      "bad": 10.0,
+      "good": 8.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0938,
+      "log_bad": 2.3026,
+      "log_good": 2.0794
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 47.0,
+      "good": 27.0,
+      "ratio": 0.5745,
+      "suggested_scalar": -0.2331,
+      "log_bad": 3.8501,
+      "log_good": 3.2958
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6927,
+      "good": 0.6933,
+      "ratio": 1.0009,
+      "suggested_scalar": 0.0004,
+      "log_bad": -0.3672,
+      "log_good": -0.3663
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 46.0,
+      "good": 40.0,
+      "ratio": 0.8696,
+      "suggested_scalar": -0.0588,
+      "log_bad": 3.8286,
+      "log_good": 3.6889
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 22.0,
+      "good": 19.0,
+      "ratio": 0.8636,
+      "suggested_scalar": -0.0616,
+      "log_bad": 3.091,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.single_argument_constructors_are_explicit": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0212,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 7.0,
+      "good": 4.0,
+      "ratio": 0.5714,
+      "suggested_scalar": -0.1721,
+      "log_bad": 1.9459,
+      "log_good": 1.3863
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0045,
+      "good": 0.0015,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.3379,
+      "log_bad": -5.4037,
+      "log_good": -6.5023
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8228,
+      "good": 0.8158,
+      "ratio": 0.9915,
+      "suggested_scalar": -0.0026,
+      "log_bad": -0.195,
+      "log_good": -0.2036
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0045,
+      "good": 0.0015,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.3379,
+      "log_bad": -5.4037,
+      "log_good": -6.5023
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6446,
+      "good": 4.6083,
+      "ratio": 0.9922,
+      "suggested_scalar": -0.0024,
+      "log_bad": 1.5357,
+      "log_good": 1.5279
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 110.0,
+      "good": 98.0,
+      "ratio": 0.8909,
+      "suggested_scalar": -0.0355,
+      "log_bad": 4.7005,
+      "log_good": 4.585
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.446,
+      "good": 0.4084,
+      "ratio": 0.9157,
+      "suggested_scalar": -0.0271,
+      "log_bad": -0.8074,
+      "log_good": -0.8955
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 20.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.0158,
+      "log_bad": 2.9444,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6413,
+      "good": 0.6244,
+      "ratio": 0.9736,
+      "suggested_scalar": -0.0082,
+      "log_bad": -0.4443,
+      "log_good": -0.471
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.0127,
+      "good": 5.3684,
+      "ratio": 1.071,
+      "suggested_scalar": 0.0211,
+      "log_bad": 1.612,
+      "log_good": 1.6805
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 673.0,
+      "good": 646.0,
+      "ratio": 0.9599,
+      "suggested_scalar": -0.0126,
+      "log_bad": 6.5117,
+      "log_good": 6.4708
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0004,
+      "good": 0.0004,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -7.824,
+      "log_good": -7.824
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.1266,
+      "good": 0.0658,
+      "ratio": 0.5197,
+      "suggested_scalar": -0.2013,
+      "log_bad": -2.0667,
+      "log_good": -2.7211
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1111,
+      "good": 1.1256,
+      "ratio": 1.0131,
+      "suggested_scalar": 0.004,
+      "log_bad": 0.1054,
+      "log_good": 0.1183
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 198.0,
+      "good": 182.0,
+      "ratio": 0.9192,
+      "suggested_scalar": -0.0259,
+      "log_bad": 5.2883,
+      "log_good": 5.204
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 102.5152,
+      "good": 102.1208,
+      "ratio": 0.9962,
+      "suggested_scalar": -0.0012,
+      "log_bad": 4.63,
+      "log_good": 4.6262
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7143,
+      "good": 0.7488,
+      "ratio": 1.0483,
+      "suggested_scalar": 0.0145,
+      "log_bad": -0.3365,
+      "log_good": -0.2893
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.5496,
+      "good": 8.1447,
+      "ratio": 0.9526,
+      "suggested_scalar": -0.0149,
+      "log_bad": 2.1459,
+      "log_good": 2.0974
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2785.0,
+      "good": 2679.0,
+      "ratio": 0.9619,
+      "suggested_scalar": -0.0119,
+      "log_bad": 7.932,
+      "log_good": 7.8932
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1139,
+      "good": 0.1184,
+      "ratio": 1.0395,
+      "suggested_scalar": 0.0119,
+      "log_bad": -2.1724,
+      "log_good": -2.1337
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8101,
+      "good": 0.8026,
+      "ratio": 0.9907,
+      "suggested_scalar": -0.0029,
+      "log_bad": -0.2106,
+      "log_good": -0.2199
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 8.9733,
+      "good": 8.9722,
+      "ratio": 0.9999,
+      "suggested_scalar": -0.0,
+      "log_bad": 2.1943,
+      "log_good": 2.1941
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 31.0,
+      "good": 31.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.434,
+      "log_good": 3.434
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 19.6328,
+      "good": 19.1801,
+      "ratio": 0.9769,
+      "suggested_scalar": -0.0072,
+      "log_bad": 2.9772,
+      "log_good": 2.9539
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 103.0,
+      "good": 97.0,
+      "ratio": 0.9417,
+      "suggested_scalar": -0.0185,
+      "log_bad": 4.6347,
+      "log_good": 4.5747
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9696,
+      "good": 0.9667,
+      "ratio": 0.997,
+      "suggested_scalar": -0.0009,
+      "log_bad": -0.0309,
+      "log_good": -0.0339
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 29.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.3673,
+      "log_good": 3.3673
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6887,
+      "good": 0.7059,
+      "ratio": 1.025,
+      "suggested_scalar": 0.0076,
+      "log_bad": -0.3729,
+      "log_good": -0.3483
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5514,
+      "good": 0.573,
+      "ratio": 1.0392,
+      "suggested_scalar": 0.0118,
+      "log_bad": -0.5953,
+      "log_good": -0.5569
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.2122,
+      "good": 3.3997,
+      "ratio": 1.0584,
+      "suggested_scalar": 0.0174,
+      "log_bad": 1.167,
+      "log_good": 1.2237
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 671.0,
+      "good": 644.0,
+      "ratio": 0.9598,
+      "suggested_scalar": -0.0126,
+      "log_bad": 6.5088,
+      "log_good": 6.4677
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0684,
+      "good": 0.0728,
+      "ratio": 1.0643,
+      "suggested_scalar": 0.0192,
+      "log_bad": -2.6824,
+      "log_good": -2.62
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.858,
+      "ratio": 0.9917,
+      "suggested_scalar": -0.0026,
+      "log_bad": 1.7761,
+      "log_good": 1.7678
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 49.0,
+      "good": 40.0,
+      "ratio": 0.8163,
+      "suggested_scalar": -0.0624,
+      "log_bad": 3.8918,
+      "log_good": 3.6889
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.6899,
+      "good": 1.6839,
+      "ratio": 0.9964,
+      "suggested_scalar": -0.0011,
+      "log_bad": 0.5247,
+      "log_good": 0.5211
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4591,
+      "good": 5.2966,
+      "ratio": 0.9702,
+      "suggested_scalar": -0.0093,
+      "log_bad": 1.6973,
+      "log_good": 1.6671
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7863,
+      "good": 0.7867,
+      "ratio": 1.0005,
+      "suggested_scalar": 0.0002,
+      "log_bad": -0.2404,
+      "log_good": -0.2399
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1856,
+      "good": 0.1828,
+      "ratio": 0.9849,
+      "suggested_scalar": -0.0047,
+      "log_bad": -1.6842,
+      "log_good": -1.6994
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.924,
+      "good": 2.8539,
+      "ratio": 0.976,
+      "suggested_scalar": -0.0075,
+      "log_bad": 1.073,
+      "log_good": 1.0487
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 408.0,
+      "good": 381.0,
+      "ratio": 0.9338,
+      "suggested_scalar": -0.0211,
+      "log_bad": 6.0113,
+      "log_good": 5.9428
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 24.0,
+      "good": 22.0,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0268,
+      "log_bad": 3.1781,
+      "log_good": 3.091
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.4919,
+      "good": 1.4067,
+      "ratio": 0.9429,
+      "suggested_scalar": -0.0181,
+      "log_bad": 0.4001,
+      "log_good": 0.3412
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 111.0,
+      "good": 97.0,
+      "ratio": 0.8739,
+      "suggested_scalar": -0.0415,
+      "log_bad": 4.7095,
+      "log_good": 4.5747
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1264.0,
+      "good": 1159.0,
+      "ratio": 0.9169,
+      "suggested_scalar": -0.0267,
+      "log_bad": 7.142,
+      "log_good": 7.0553
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 256.0,
+      "good": 241.0,
+      "ratio": 0.9414,
+      "suggested_scalar": -0.0186,
+      "log_bad": 5.5452,
+      "log_good": 5.4848
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 0.0015,
+      "ratio": 0.0015,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.5023
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2571,
+      "good": 0.2709,
+      "ratio": 1.0537,
+      "suggested_scalar": 0.0161,
+      "log_bad": -1.3583,
+      "log_good": -1.306
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 109.0,
+      "good": 111.0,
+      "ratio": 1.0183,
+      "suggested_scalar": 0.0056,
+      "log_bad": 4.6913,
+      "log_good": 4.7095
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 111.0,
+      "good": 97.0,
+      "ratio": 0.8739,
+      "suggested_scalar": -0.0415,
+      "log_bad": 4.7095,
+      "log_good": 4.5747
+    },
+    "brevity.mean_sample_size": {
+      "bad": 111.0,
+      "good": 97.0,
+      "ratio": 0.8739,
+      "suggested_scalar": -0.0415,
+      "log_bad": 4.7095,
+      "log_good": 4.5747
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 673.0,
+      "good": 646.0,
+      "ratio": 0.9599,
+      "suggested_scalar": -0.0126,
+      "log_bad": 6.5117,
+      "log_good": 6.4708
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 382.0,
+      "good": 375.0,
+      "ratio": 0.9817,
+      "suggested_scalar": -0.0057,
+      "log_bad": 5.9454,
+      "log_good": 5.9269
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 301.0,
+      "good": 273.0,
+      "ratio": 0.907,
+      "suggested_scalar": -0.03,
+      "log_bad": 5.7071,
+      "log_good": 5.6095
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 2.0208,
+      "good": 2.0038,
+      "ratio": 0.9916,
+      "suggested_scalar": -0.0026,
+      "log_bad": 0.7035,
+      "log_good": 0.695
+    },
+    "halstead.mean_effort": {
+      "bad": 205108.5036,
+      "good": 213730.9575,
+      "ratio": 1.042,
+      "suggested_scalar": 0.0127,
+      "log_bad": 12.2313,
+      "log_good": 12.2725
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8035,
+      "good": 0.8025,
+      "ratio": 0.9988,
+      "suggested_scalar": -0.0004,
+      "log_bad": -0.2188,
+      "log_good": -0.22
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 81.0,
+      "good": 69.0,
+      "ratio": 0.8519,
+      "suggested_scalar": -0.0493,
+      "log_bad": 4.3944,
+      "log_good": 4.2341
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 404.0,
+      "good": 397.0,
+      "ratio": 0.9827,
+      "suggested_scalar": -0.0054,
+      "log_bad": 6.0014,
+      "log_good": 5.9839
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3283,
+      "good": 0.2967,
+      "ratio": 0.9037,
+      "suggested_scalar": -0.0311,
+      "log_bad": -1.1138,
+      "log_good": -1.215
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.3838,
+      "good": 6.3681,
+      "ratio": 0.9975,
+      "suggested_scalar": -0.0008,
+      "log_bad": 1.8538,
+      "log_good": 1.8513
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1856,
+      "good": 0.1828,
+      "ratio": 0.9849,
+      "suggested_scalar": -0.0047,
+      "log_bad": -1.6842,
+      "log_good": -1.6994
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.8681,
+      "good": 3.8863,
+      "ratio": 1.0047,
+      "suggested_scalar": 0.0014,
+      "log_bad": 1.3528,
+      "log_good": 1.3575
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 672.0,
+      "good": 645.0,
+      "ratio": 0.9598,
+      "suggested_scalar": -0.0126,
+      "log_bad": 6.5103,
+      "log_good": 6.4693
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 107.0,
+      "good": 106.0,
+      "ratio": 0.9907,
+      "suggested_scalar": -0.0029,
+      "log_bad": 4.6728,
+      "log_good": 4.6634
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 11394.9169,
+      "good": 11873.9421,
+      "ratio": 1.042,
+      "suggested_scalar": 0.0127,
+      "log_bad": 9.3409,
+      "log_good": 9.3821
+    },
+    "readability.mean_total_lines": {
+      "bad": 75.0,
+      "good": 72.0,
+      "ratio": 0.96,
+      "suggested_scalar": -0.0126,
+      "log_bad": 4.3175,
+      "log_good": 4.2767
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 4475.6974,
+      "good": 4220.1849,
+      "ratio": 0.9429,
+      "suggested_scalar": -0.0181,
+      "log_bad": 8.4064,
+      "log_good": 8.3476
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 867.0,
+      "good": 788.0,
+      "ratio": 0.9089,
+      "suggested_scalar": -0.0294,
+      "log_bad": 6.765,
+      "log_good": 6.6695
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 34.8267,
+      "good": 34.8611,
+      "ratio": 1.001,
+      "suggested_scalar": 0.0003,
+      "log_bad": 3.5504,
+      "log_good": 3.5514
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1254,
+      "good": 1.1301,
+      "ratio": 1.0042,
+      "suggested_scalar": 0.0013,
+      "log_bad": 0.1181,
+      "log_good": 0.1223
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 10.0,
+      "good": 5.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2132,
+      "log_bad": 2.3026,
+      "log_good": 1.6094
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7377,
+      "good": 0.7218,
+      "ratio": 0.9784,
+      "suggested_scalar": -0.0067,
+      "log_bad": -0.3042,
+      "log_good": -0.326
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9571,
+      "good": 0.9679,
+      "ratio": 1.0113,
+      "suggested_scalar": 0.0035,
+      "log_bad": -0.0438,
+      "log_good": -0.0326
+    },
+    "halstead.mean_length": {
+      "bad": 660.0,
+      "good": 638.0,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0104,
+      "log_bad": 6.4922,
+      "log_good": 6.4583
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7944,
+      "good": 6.5999,
+      "ratio": 0.9714,
+      "suggested_scalar": -0.0089,
+      "log_bad": 1.9161,
+      "log_good": 1.8871
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1372,
+      "good": 0.14,
+      "ratio": 1.0204,
+      "suggested_scalar": 0.0062,
+      "log_bad": -1.9863,
+      "log_good": -1.9661
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 45.8272,
+      "good": 50.6449,
+      "ratio": 1.1051,
+      "suggested_scalar": 0.0307,
+      "log_bad": 3.8249,
+      "log_good": 3.9248
+    },
+    "branching.mean_branch_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 65.0,
+      "good": 54.0,
+      "ratio": 0.8308,
+      "suggested_scalar": -0.057,
+      "log_bad": 4.1744,
+      "log_good": 3.989
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6379,
+      "good": 0.5934,
+      "ratio": 0.9302,
+      "suggested_scalar": -0.0222,
+      "log_bad": -0.4496,
+      "log_good": -0.5219
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 79.0,
+      "good": 76.0,
+      "ratio": 0.962,
+      "suggested_scalar": -0.0119,
+      "log_bad": 4.3694,
+      "log_good": 4.3307
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "documentation.docstring_is_nonempty": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 41.0,
+      "good": 40.0,
+      "ratio": 0.9756,
+      "suggested_scalar": -0.0061,
+      "log_bad": 3.7136,
+      "log_good": 3.6889
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0206,
+      "good": 0.0319,
+      "ratio": 1.5485,
+      "suggested_scalar": 0.1078,
+      "log_bad": -3.8825,
+      "log_good": -3.4451
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.7778,
+      "good": 1.875,
+      "ratio": 1.0547,
+      "suggested_scalar": 0.0131,
+      "log_bad": 0.5754,
+      "log_good": 0.6286
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7463,
+      "good": 0.7625,
+      "ratio": 1.0217,
+      "suggested_scalar": 0.0053,
+      "log_bad": -0.2926,
+      "log_good": -0.2712
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0206,
+      "good": 0.0319,
+      "ratio": 1.5485,
+      "suggested_scalar": 0.1078,
+      "log_bad": -3.8825,
+      "log_good": -3.4451
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.639,
+      "good": 4.7638,
+      "ratio": 1.0269,
+      "suggested_scalar": 0.0065,
+      "log_bad": 1.5345,
+      "log_good": 1.561
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 82.0,
+      "good": 99.0,
+      "ratio": 1.2073,
+      "suggested_scalar": 0.0465,
+      "log_bad": 4.4067,
+      "log_good": 4.5951
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3068,
+      "good": 0.543,
+      "ratio": 1.7699,
+      "suggested_scalar": 0.1408,
+      "log_bad": -1.1816,
+      "log_good": -0.6106
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 22.0,
+      "good": 27.0,
+      "ratio": 1.2273,
+      "suggested_scalar": 0.0505,
+      "log_bad": 3.091,
+      "log_good": 3.2958
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5264,
+      "good": 0.5806,
+      "ratio": 1.103,
+      "suggested_scalar": 0.0242,
+      "log_bad": -0.6417,
+      "log_good": -0.5437
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.3731,
+      "good": 2.95,
+      "ratio": 0.8746,
+      "suggested_scalar": -0.033,
+      "log_bad": 1.2158,
+      "log_good": 1.0818
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 535.0,
+      "good": 815.0,
+      "ratio": 1.5234,
+      "suggested_scalar": 0.1038,
+      "log_bad": 6.2823,
+      "log_good": 6.7032
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 0.0003,
+      "ratio": 0.0003,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -8.1117
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1655,
+      "good": 1.0102,
+      "ratio": 0.8668,
+      "suggested_scalar": -0.0353,
+      "log_bad": 0.1532,
+      "log_good": 0.0101
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 146.0,
+      "good": 292.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1709,
+      "log_bad": 4.9836,
+      "log_good": 5.6768
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 106.4041,
+      "good": 106.806,
+      "ratio": 1.0038,
+      "suggested_scalar": 0.0009,
+      "log_bad": 4.6672,
+      "log_good": 4.671
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7154,
+      "good": 0.5774,
+      "ratio": 0.8071,
+      "suggested_scalar": -0.0528,
+      "log_bad": -0.3349,
+      "log_good": -0.5492
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 8.1207,
+      "good": 7.1693,
+      "ratio": 0.8828,
+      "suggested_scalar": -0.0307,
+      "log_bad": 2.0944,
+      "log_good": 1.9698
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1773.0,
+      "good": 2938.0,
+      "ratio": 1.6571,
+      "suggested_scalar": 0.1245,
+      "log_bad": 7.4804,
+      "log_good": 7.9855
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0597,
+      "good": 0.175,
+      "ratio": 2.9313,
+      "suggested_scalar": 0.2652,
+      "log_bad": -2.8184,
+      "log_good": -1.743
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7164,
+      "good": 0.7375,
+      "ratio": 1.0295,
+      "suggested_scalar": 0.0072,
+      "log_bad": -0.3335,
+      "log_good": -0.3045
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.9851,
+      "good": 10.1875,
+      "ratio": 1.2758,
+      "suggested_scalar": 0.0601,
+      "log_bad": 2.0776,
+      "log_good": 2.3212
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.2709,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 3.0,
+      "good": 4.0,
+      "ratio": 1.3333,
+      "suggested_scalar": 0.0709,
+      "log_bad": 1.0986,
+      "log_good": 1.3863
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.9652,
+      "good": 3.4975,
+      "ratio": 0.882,
+      "suggested_scalar": -0.0309,
+      "log_bad": 1.3776,
+      "log_good": 1.252
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 133.0,
+      "good": 253.0,
+      "ratio": 1.9023,
+      "suggested_scalar": 0.1585,
+      "log_bad": 4.8903,
+      "log_good": 5.5334
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9482,
+      "good": 0.9627,
+      "ratio": 1.0153,
+      "suggested_scalar": 0.0037,
+      "log_bad": -0.0532,
+      "log_good": -0.038
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 29.0,
+      "good": 42.0,
+      "ratio": 1.4483,
+      "suggested_scalar": 0.0913,
+      "log_bad": 3.3673,
+      "log_good": 3.7377
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6362,
+      "good": 0.5871,
+      "ratio": 0.9228,
+      "suggested_scalar": -0.0198,
+      "log_bad": -0.4522,
+      "log_good": -0.5326
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5066,
+      "good": 0.3948,
+      "ratio": 0.7793,
+      "suggested_scalar": -0.0615,
+      "log_bad": -0.68,
+      "log_good": -0.9294
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7488,
+      "good": 2.4221,
+      "ratio": 0.8811,
+      "suggested_scalar": -0.0312,
+      "log_bad": 1.0112,
+      "log_good": 0.8846
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 533.0,
+      "good": 813.0,
+      "ratio": 1.5253,
+      "suggested_scalar": 0.1041,
+      "log_bad": 6.2785,
+      "log_good": 6.7007
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 14.0,
+      "good": 16.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.0329,
+      "log_bad": 2.6391,
+      "log_good": 2.7726
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.015,
+      "good": 0.0135,
+      "ratio": 0.9,
+      "suggested_scalar": -0.026,
+      "log_bad": -4.1997,
+      "log_good": -4.3051
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9773,
+      "good": 6.2288,
+      "ratio": 1.0421,
+      "suggested_scalar": 0.0102,
+      "log_bad": 1.788,
+      "log_good": 1.8292
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 10.0,
+      "good": 35.0,
+      "ratio": 3.5,
+      "suggested_scalar": 0.3089,
+      "log_bad": 2.3026,
+      "log_good": 3.5553
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.5027,
+      "good": 0.6308,
+      "ratio": 1.2548,
+      "suggested_scalar": 0.056,
+      "log_bad": -0.6878,
+      "log_good": -0.4608
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.2451,
+      "good": 6.1885,
+      "ratio": 1.1799,
+      "suggested_scalar": 0.0408,
+      "log_bad": 1.6573,
+      "log_good": 1.8227
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7761,
+      "good": 0.7648,
+      "ratio": 0.9854,
+      "suggested_scalar": -0.0036,
+      "log_bad": -0.2535,
+      "log_good": -0.2681
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.141,
+      "good": 0.1667,
+      "ratio": 1.1823,
+      "suggested_scalar": 0.0413,
+      "log_bad": -1.959,
+      "log_good": -1.7916
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.8497,
+      "good": 2.6776,
+      "ratio": 0.9396,
+      "suggested_scalar": -0.0154,
+      "log_bad": 1.0472,
+      "log_good": 0.9849
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.1709,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 334.0,
+      "good": 586.0,
+      "ratio": 1.7545,
+      "suggested_scalar": 0.1386,
+      "log_bad": 5.8111,
+      "log_good": 6.3733
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 8.0,
+      "good": 12.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.1,
+      "log_bad": 2.0794,
+      "log_good": 2.4849
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.0405,
+      "good": 1.2198,
+      "ratio": 1.1723,
+      "suggested_scalar": 0.0392,
+      "log_bad": 0.0397,
+      "log_good": 0.1987
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 186.0,
+      "ratio": 2.1882,
+      "suggested_scalar": 0.1931,
+      "log_bad": 4.4427,
+      "log_good": 5.2257
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 767.0,
+      "good": 1510.0,
+      "ratio": 1.9687,
+      "suggested_scalar": 0.167,
+      "log_bad": 6.6425,
+      "log_good": 7.3199
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 181.0,
+      "good": 179.0,
+      "ratio": 0.989,
+      "suggested_scalar": -0.0027,
+      "log_bad": 5.1985,
+      "log_good": 5.1874
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0112,
+      "good": 0.0086,
+      "ratio": 0.7679,
+      "suggested_scalar": -0.0651,
+      "log_bad": -4.4918,
+      "log_good": -4.756
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2692,
+      "good": 0.2221,
+      "ratio": 0.825,
+      "suggested_scalar": -0.0474,
+      "log_bad": -1.3123,
+      "log_good": -1.5046
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 85.0,
+      "good": 116.0,
+      "ratio": 1.3647,
+      "suggested_scalar": 0.0767,
+      "log_bad": 4.4427,
+      "log_good": 4.7536
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 9.0,
+      "good": 8.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.029,
+      "log_bad": 2.1972,
+      "log_good": 2.0794
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 186.0,
+      "ratio": 2.1882,
+      "suggested_scalar": 0.1931,
+      "log_bad": 4.4427,
+      "log_good": 5.2257
+    },
+    "brevity.mean_sample_size": {
+      "bad": 85.0,
+      "good": 186.0,
+      "ratio": 2.1882,
+      "suggested_scalar": 0.1931,
+      "log_bad": 4.4427,
+      "log_good": 5.2257
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 535.0,
+      "good": 815.0,
+      "ratio": 1.5234,
+      "suggested_scalar": 0.1038,
+      "log_bad": 6.2823,
+      "log_good": 6.7032
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 314.0,
+      "good": 411.0,
+      "ratio": 1.3089,
+      "suggested_scalar": 0.0664,
+      "log_bad": 5.7494,
+      "log_good": 6.0186
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 237.0,
+      "good": 460.0,
+      "ratio": 1.9409,
+      "suggested_scalar": 0.1635,
+      "log_bad": 5.4681,
+      "log_good": 6.1312
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0037,
+      "good": 0.0049,
+      "ratio": 1.3243,
+      "suggested_scalar": 0.0693,
+      "log_bad": -5.5994,
+      "log_good": -5.3185
+    },
+    "heaps.mean_k": {
+      "bad": 3.4312,
+      "good": 4.2998,
+      "ratio": 1.2531,
+      "suggested_scalar": 0.0556,
+      "log_bad": 1.2329,
+      "log_good": 1.4586
+    },
+    "halstead.mean_effort": {
+      "bad": 154576.02,
+      "good": 241328.1201,
+      "ratio": 1.5612,
+      "suggested_scalar": 0.1098,
+      "log_bad": 11.9484,
+      "log_good": 12.3939
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8183,
+      "good": 0.8208,
+      "ratio": 1.0031,
+      "suggested_scalar": 0.0008,
+      "log_bad": -0.2005,
+      "log_good": -0.1975
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 53.0,
+      "good": 57.0,
+      "ratio": 1.0755,
+      "suggested_scalar": 0.0179,
+      "log_bad": 3.9703,
+      "log_good": 4.0431
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 310.0,
+      "good": 373.0,
+      "ratio": 1.2032,
+      "suggested_scalar": 0.0456,
+      "log_bad": 5.7366,
+      "log_good": 5.9216
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.2945,
+      "good": 0.4315,
+      "ratio": 1.4652,
+      "suggested_scalar": 0.0942,
+      "log_bad": -1.2225,
+      "log_good": -0.8405
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.2534,
+      "good": 5.1712,
+      "ratio": 0.9844,
+      "suggested_scalar": -0.0039,
+      "log_bad": 1.6589,
+      "log_good": 1.6431
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.141,
+      "good": 0.1667,
+      "ratio": 1.1823,
+      "suggested_scalar": 0.0413,
+      "log_bad": -1.959,
+      "log_good": -1.7916
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.5593,
+      "good": 4.2755,
+      "ratio": 1.2012,
+      "suggested_scalar": 0.0452,
+      "log_bad": 1.2696,
+      "log_good": 1.4529
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 534.0,
+      "good": 814.0,
+      "ratio": 1.5243,
+      "suggested_scalar": 0.1039,
+      "log_bad": 6.2804,
+      "log_good": 6.702
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 5.0,
+      "good": 6.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.045,
+      "log_bad": 1.6094,
+      "log_good": 1.7918
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 71.0,
+      "good": 94.0,
+      "ratio": 1.3239,
+      "suggested_scalar": 0.0692,
+      "log_bad": 4.2627,
+      "log_good": 4.5433
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 8587.5567,
+      "good": 13407.1178,
+      "ratio": 1.5612,
+      "suggested_scalar": 0.1098,
+      "log_bad": 9.0581,
+      "log_good": 9.5035
+    },
+    "readability.mean_total_lines": {
+      "bad": 67.0,
+      "good": 80.0,
+      "ratio": 1.194,
+      "suggested_scalar": 0.0437,
+      "log_bad": 4.2047,
+      "log_good": 4.382
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 3121.558,
+      "good": 3659.4049,
+      "ratio": 1.1723,
+      "suggested_scalar": 0.0392,
+      "log_bad": 8.0461,
+      "log_good": 8.2051
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 645.0,
+      "good": 1213.0,
+      "ratio": 1.8806,
+      "suggested_scalar": 0.1557,
+      "log_bad": 6.4693,
+      "log_good": 7.1009
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 25.2985,
+      "good": 35.475,
+      "ratio": 1.4023,
+      "suggested_scalar": 0.0834,
+      "log_bad": 3.2307,
+      "log_good": 3.5688
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0913,
+      "good": 1.0602,
+      "ratio": 0.9715,
+      "suggested_scalar": -0.0071,
+      "log_bad": 0.0874,
+      "log_good": 0.0585
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 19.0,
+      "good": 34.0,
+      "ratio": 1.7895,
+      "suggested_scalar": 0.1435,
+      "log_bad": 2.9444,
+      "log_good": 3.5264
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7874,
+      "good": 0.8396,
+      "ratio": 1.0663,
+      "suggested_scalar": 0.0158,
+      "log_bad": -0.239,
+      "log_good": -0.1748
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 9.0,
+      "ratio": 9.0,
+      "suggested_scalar": 0.5417,
+      "log_bad": 0.0,
+      "log_good": 2.1972
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9485,
+      "good": 0.9461,
+      "ratio": 0.9975,
+      "suggested_scalar": -0.0006,
+      "log_bad": -0.0529,
+      "log_good": -0.0554
+    },
+    "halstead.mean_length": {
+      "bad": 491.0,
+      "good": 552.0,
+      "ratio": 1.1242,
+      "suggested_scalar": 0.0289,
+      "log_bad": 6.1964,
+      "log_good": 6.3135
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 8.1111,
+      "good": 9.375,
+      "ratio": 1.1558,
+      "suggested_scalar": 0.0357,
+      "log_bad": 2.0932,
+      "log_good": 2.238
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4094,
+      "good": 7.5392,
+      "ratio": 1.1763,
+      "suggested_scalar": 0.04,
+      "log_bad": 1.8578,
+      "log_good": 2.0201
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1771,
+      "good": 0.1401,
+      "ratio": 0.7911,
+      "suggested_scalar": -0.0578,
+      "log_bad": -1.731,
+      "log_good": -1.9654
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 49.5189,
+      "good": 65.9474,
+      "ratio": 1.3318,
+      "suggested_scalar": 0.0706,
+      "log_bad": 3.9024,
+      "log_good": 4.1889
+    },
+    "branching.mean_branch_count": {
+      "bad": 4.0,
+      "good": 14.0,
+      "ratio": 3.5,
+      "suggested_scalar": 0.3089,
+      "log_bad": 1.3863,
+      "log_good": 2.6391
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 43.0,
+      "good": 126.0,
+      "ratio": 2.9302,
+      "suggested_scalar": 0.2651,
+      "log_bad": 3.7612,
+      "log_good": 4.8363
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6414,
+      "good": 0.7478,
+      "ratio": 1.1659,
+      "suggested_scalar": 0.0378,
+      "log_bad": -0.4441,
+      "log_good": -0.2906
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 67.0,
+      "good": 80.0,
+      "ratio": 1.194,
+      "suggested_scalar": 0.0437,
+      "log_bad": 4.2047,
+      "log_good": 4.382
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_magic_value_assigned": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 14.0,
+      "good": 18.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.2805,
+      "log_bad": 2.6391,
+      "log_good": 2.8904
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.125,
+      "good": 0.0261,
+      "ratio": 0.2088,
+      "suggested_scalar": -1.7484,
+      "log_bad": -2.0794,
+      "log_good": -3.6458
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.8,
+      "good": 1.3636,
+      "ratio": 0.7576,
+      "suggested_scalar": -0.3099,
+      "log_bad": 0.5878,
+      "log_good": 0.3101
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8846,
+      "good": 0.8958,
+      "ratio": 1.0127,
+      "suggested_scalar": 0.014,
+      "log_bad": -0.1226,
+      "log_good": -0.11
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.125,
+      "good": 0.0261,
+      "ratio": 0.2088,
+      "suggested_scalar": -1.7484,
+      "log_bad": -2.0794,
+      "log_good": -3.6458
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4765,
+      "good": 4.4808,
+      "ratio": 1.001,
+      "suggested_scalar": 0.0011,
+      "log_bad": 1.4988,
+      "log_good": 1.4998
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 80.0,
+      "good": 79.0,
+      "ratio": 0.9875,
+      "suggested_scalar": -0.014,
+      "log_bad": 4.382,
+      "log_good": 4.3694
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.568,
+      "good": 0.585,
+      "ratio": 1.0299,
+      "suggested_scalar": 0.0329,
+      "log_bad": -0.5656,
+      "log_good": -0.5361
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5828,
+      "good": 0.6311,
+      "ratio": 1.0829,
+      "suggested_scalar": 0.0889,
+      "log_bad": -0.5399,
+      "log_good": -0.4603
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.7692,
+      "good": 3.7083,
+      "ratio": 0.7776,
+      "suggested_scalar": -0.2808,
+      "log_bad": 1.5622,
+      "log_good": 1.3106
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 344.0,
+      "good": 307.0,
+      "ratio": 0.8924,
+      "suggested_scalar": -0.127,
+      "log_bad": 5.8406,
+      "log_good": 5.7268
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0005,
+      "good": 0.0012,
+      "ratio": 2.4,
+      "suggested_scalar": 0.9772,
+      "log_bad": -7.6009,
+      "log_good": -6.7254
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9771,
+      "good": 0.9322,
+      "ratio": 0.954,
+      "suggested_scalar": -0.0525,
+      "log_bad": -0.0232,
+      "log_good": -0.0702
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 104.0,
+      "good": 101.0,
+      "ratio": 0.9712,
+      "suggested_scalar": -0.0327,
+      "log_bad": 4.6444,
+      "log_good": 4.6151
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 72.0288,
+      "good": 88.4895,
+      "ratio": 1.2285,
+      "suggested_scalar": 0.2297,
+      "log_bad": 4.2771,
+      "log_good": 4.4829
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6531,
+      "good": 0.5261,
+      "ratio": 0.8055,
+      "suggested_scalar": -0.2414,
+      "log_bad": -0.426,
+      "log_good": -0.6423
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 45.1538,
+      "good": 30.9401,
+      "ratio": 0.6852,
+      "suggested_scalar": -0.422,
+      "log_bad": 3.8101,
+      "log_good": 3.4321
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1887.0,
+      "good": 1606.0,
+      "ratio": 0.8511,
+      "suggested_scalar": -0.18,
+      "log_bad": 7.5427,
+      "log_good": 7.3815
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1154,
+      "good": 0.1042,
+      "ratio": 0.9029,
+      "suggested_scalar": -0.114,
+      "log_bad": -2.1594,
+      "log_good": -2.2614
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8269,
+      "good": 0.8333,
+      "ratio": 1.0077,
+      "suggested_scalar": 0.0086,
+      "log_bad": -0.1901,
+      "log_good": -0.1824
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.6154,
+      "good": 6.3958,
+      "ratio": 0.9668,
+      "suggested_scalar": -0.0377,
+      "log_bad": 1.8894,
+      "log_good": 1.8556
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 4.0,
+      "good": 3.0,
+      "ratio": 0.75,
+      "suggested_scalar": -0.3211,
+      "log_bad": 1.3863,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 5.5621,
+      "good": 4.8316,
+      "ratio": 0.8687,
+      "suggested_scalar": -0.1572,
+      "log_bad": 1.716,
+      "log_good": 1.5752
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 91.0,
+      "good": 89.0,
+      "ratio": 0.978,
+      "suggested_scalar": -0.0248,
+      "log_bad": 4.5109,
+      "log_good": 4.4886
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9311,
+      "good": 0.9486,
+      "ratio": 1.0188,
+      "suggested_scalar": 0.0208,
+      "log_bad": -0.0714,
+      "log_good": -0.0528
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 25.0,
+      "ratio": 0.9259,
+      "suggested_scalar": -0.0859,
+      "log_bad": 3.2958,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6433,
+      "good": 0.6239,
+      "ratio": 0.9698,
+      "suggested_scalar": -0.0342,
+      "log_bad": -0.4411,
+      "log_good": -0.4718
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3889,
+      "good": 0.177,
+      "ratio": 0.4551,
+      "suggested_scalar": -0.8787,
+      "log_bad": -0.9444,
+      "log_good": -1.7316
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.8039,
+      "good": 2.6589,
+      "ratio": 0.9483,
+      "suggested_scalar": -0.0593,
+      "log_bad": 1.031,
+      "log_good": 0.9779
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 342.0,
+      "good": 305.0,
+      "ratio": 0.8918,
+      "suggested_scalar": -0.1278,
+      "log_bad": 5.8348,
+      "log_good": 5.7203
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 22.0,
+      "good": 13.0,
+      "ratio": 0.5909,
+      "suggested_scalar": -0.5872,
+      "log_bad": 3.091,
+      "log_good": 2.5649
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0407,
+      "good": 0.0326,
+      "ratio": 0.801,
+      "suggested_scalar": -0.2477,
+      "log_bad": -3.2015,
+      "log_good": -3.4234
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8826,
+      "good": 5.8074,
+      "ratio": 0.9872,
+      "suggested_scalar": -0.0144,
+      "log_bad": 1.772,
+      "log_good": 1.7591
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6549,
+      "good": 0.6223,
+      "ratio": 0.9502,
+      "suggested_scalar": -0.057,
+      "log_bad": -0.4233,
+      "log_good": -0.4743
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.1214,
+      "good": 5.52,
+      "ratio": 1.0778,
+      "suggested_scalar": 0.0837,
+      "log_bad": 1.6334,
+      "log_good": 1.7084
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.761,
+      "good": 0.7716,
+      "ratio": 1.0139,
+      "suggested_scalar": 0.0154,
+      "log_bad": -0.2731,
+      "log_good": -0.2593
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1875,
+      "good": 0.1579,
+      "ratio": 0.8421,
+      "suggested_scalar": -0.1918,
+      "log_bad": -1.674,
+      "log_good": -1.8458
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 6.7197,
+      "good": 5.5624,
+      "ratio": 0.8278,
+      "suggested_scalar": -0.211,
+      "log_bad": 1.905,
+      "log_good": 1.716
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 243.0,
+      "good": 266.0,
+      "ratio": 1.0947,
+      "suggested_scalar": 0.1009,
+      "log_bad": 5.4931,
+      "log_good": 5.5835
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 6.0,
+      "ratio": 6.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 1.7918
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.4847,
+      "good": 0.5547,
+      "ratio": 1.1444,
+      "suggested_scalar": 0.1506,
+      "log_bad": -0.7242,
+      "log_good": -0.5893
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 92.0,
+      "good": 91.0,
+      "ratio": 0.9891,
+      "suggested_scalar": -0.0122,
+      "log_bad": 4.5218,
+      "log_good": 4.5109
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1144.0,
+      "good": 965.0,
+      "ratio": 0.8435,
+      "suggested_scalar": -0.1899,
+      "log_bad": 7.0423,
+      "log_good": 6.8721
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 100.0,
+      "good": 97.0,
+      "ratio": 0.97,
+      "suggested_scalar": -0.034,
+      "log_bad": 4.6052,
+      "log_good": 4.5747
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0465,
+      "good": 0.0326,
+      "ratio": 0.7011,
+      "suggested_scalar": -0.3964,
+      "log_bad": -3.0683,
+      "log_good": -3.4234
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2267,
+      "good": 0.2182,
+      "ratio": 0.9625,
+      "suggested_scalar": -0.0427,
+      "log_bad": -1.4841,
+      "log_good": -1.5223
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 56.0,
+      "good": 50.0,
+      "ratio": 0.8929,
+      "suggested_scalar": -0.1265,
+      "log_bad": 4.0254,
+      "log_good": 3.912
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 11.0,
+      "ratio": 2.2,
+      "suggested_scalar": 0.8801,
+      "log_bad": 1.6094,
+      "log_good": 2.3979
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 92.0,
+      "good": 91.0,
+      "ratio": 0.9891,
+      "suggested_scalar": -0.0122,
+      "log_bad": 4.5218,
+      "log_good": 4.5109
+    },
+    "brevity.mean_sample_size": {
+      "bad": 92.0,
+      "good": 91.0,
+      "ratio": 0.9891,
+      "suggested_scalar": -0.0122,
+      "log_bad": 4.5218,
+      "log_good": 4.5109
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 344.0,
+      "good": 307.0,
+      "ratio": 0.8924,
+      "suggested_scalar": -0.127,
+      "log_bad": 5.8406,
+      "log_good": 5.7268
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 202.0,
+      "good": 158.0,
+      "ratio": 0.7822,
+      "suggested_scalar": -0.2742,
+      "log_bad": 5.3083,
+      "log_good": 5.0626
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 175.0,
+      "good": 195.0,
+      "ratio": 1.1143,
+      "suggested_scalar": 0.1208,
+      "log_bad": 5.1648,
+      "log_good": 5.273
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 3.0309,
+      "good": 2.5242,
+      "ratio": 0.8328,
+      "suggested_scalar": -0.2042,
+      "log_bad": 1.1089,
+      "log_good": 0.9259
+    },
+    "halstead.mean_effort": {
+      "bad": 37036.9561,
+      "good": 37367.4114,
+      "ratio": 1.0089,
+      "suggested_scalar": 0.0099,
+      "log_bad": 10.5197,
+      "log_good": 10.5286
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.7851,
+      "good": 0.8482,
+      "ratio": 1.0804,
+      "suggested_scalar": 0.0863,
+      "log_bad": -0.2419,
+      "log_good": -0.1646
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 53.0,
+      "good": 54.0,
+      "ratio": 1.0189,
+      "suggested_scalar": 0.0209,
+      "log_bad": 3.9703,
+      "log_good": 3.989
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 130.0,
+      "good": 167.0,
+      "ratio": 1.2846,
+      "suggested_scalar": 0.2796,
+      "log_bad": 4.8675,
+      "log_good": 5.118
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5673,
+      "good": 0.5842,
+      "ratio": 1.0298,
+      "suggested_scalar": 0.0328,
+      "log_bad": -0.5669,
+      "log_good": -0.5375
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 11.0,
+      "good": 9.5545,
+      "ratio": 0.8686,
+      "suggested_scalar": -0.1573,
+      "log_bad": 2.3979,
+      "log_good": 2.257
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1875,
+      "good": 0.1579,
+      "ratio": 0.8421,
+      "suggested_scalar": -0.1918,
+      "log_bad": -1.674,
+      "log_good": -1.8458
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 8.8433,
+      "good": 5.2429,
+      "ratio": 0.5929,
+      "suggested_scalar": -0.5835,
+      "log_bad": 2.1797,
+      "log_good": 1.6569
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 343.0,
+      "good": 306.0,
+      "ratio": 0.8921,
+      "suggested_scalar": -0.1274,
+      "log_bad": 5.8377,
+      "log_good": 5.7236
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 8.0,
+      "good": 4.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.7737,
+      "log_bad": 2.0794,
+      "log_good": 1.3863
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 34.0,
+      "good": 15.0,
+      "ratio": 0.4412,
+      "suggested_scalar": -0.9134,
+      "log_bad": 3.5264,
+      "log_good": 2.7081
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2057.6087,
+      "good": 2075.9673,
+      "ratio": 1.0089,
+      "suggested_scalar": 0.0099,
+      "log_bad": 7.6293,
+      "log_good": 7.6382
+    },
+    "readability.mean_total_lines": {
+      "bad": 52.0,
+      "good": 48.0,
+      "ratio": 0.9231,
+      "suggested_scalar": -0.0893,
+      "log_bad": 3.9512,
+      "log_good": 3.8712
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 8.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.0794,
+      "log_good": 2.0794
+    },
+    "halstead.mean_volume": {
+      "bad": 1454.0435,
+      "good": 1664.1981,
+      "ratio": 1.1445,
+      "suggested_scalar": 0.1507,
+      "log_bad": 7.2821,
+      "log_good": 7.4171
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 673.0,
+      "good": 604.0,
+      "ratio": 0.8975,
+      "suggested_scalar": -0.1207,
+      "log_bad": 6.5117,
+      "log_good": 6.4036
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.0192,
+      "good": 32.2292,
+      "ratio": 0.9203,
+      "suggested_scalar": -0.0927,
+      "log_bad": 3.5559,
+      "log_good": 3.4729
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.5141,
+      "good": 1.3221,
+      "ratio": 0.8732,
+      "suggested_scalar": -0.1514,
+      "log_bad": 0.4148,
+      "log_good": 0.2792
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8601,
+      "good": 0.9436,
+      "ratio": 1.0971,
+      "suggested_scalar": 0.1034,
+      "log_bad": -0.1507,
+      "log_good": -0.0581
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9614,
+      "good": 0.9814,
+      "ratio": 1.0208,
+      "suggested_scalar": 0.023,
+      "log_bad": -0.0394,
+      "log_good": -0.0188
+    },
+    "halstead.mean_length": {
+      "bad": 230.0,
+      "good": 264.0,
+      "ratio": 1.1478,
+      "suggested_scalar": 0.1539,
+      "log_bad": 5.4381,
+      "log_good": 5.5759
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.8,
+      "good": 4.3636,
+      "ratio": 0.3698,
+      "suggested_scalar": -1.1104,
+      "log_bad": 2.4681,
+      "log_good": 1.4733
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5236,
+      "good": 6.5078,
+      "ratio": 0.9976,
+      "suggested_scalar": -0.0027,
+      "log_bad": 1.8754,
+      "log_good": 1.873
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1072,
+      "good": 0.0985,
+      "ratio": 0.9188,
+      "suggested_scalar": -0.0945,
+      "log_bad": -2.2331,
+      "log_good": -2.3177
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 25.4717,
+      "good": 22.4537,
+      "ratio": 0.8815,
+      "suggested_scalar": -0.1408,
+      "log_bad": 3.2376,
+      "log_good": 3.1115
+    },
+    "branching.mean_branch_count": {
+      "bad": 6.0,
+      "good": 5.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.2035,
+      "log_bad": 1.7918,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 59.0,
+      "good": 59.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.0775,
+      "log_good": 4.0775
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.68,
+      "good": 0.7436,
+      "ratio": 1.0935,
+      "suggested_scalar": 0.0998,
+      "log_bad": -0.3857,
+      "log_good": -0.2963
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 52.0,
+      "good": 48.0,
+      "ratio": 0.9231,
+      "suggested_scalar": -0.0893,
+      "log_bad": 3.9512,
+      "log_good": 3.8712
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 26.0,
+      "good": 25.0,
+      "ratio": 0.9615,
+      "suggested_scalar": -0.0438,
+      "log_bad": 3.2581,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.cyclomatic_complexity_under_10": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 23.0,
+      "good": 32.0,
+      "ratio": 1.3913,
+      "suggested_scalar": 0.0994,
+      "log_bad": 3.1355,
+      "log_good": 3.4657
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0059,
+      "good": 0.0051,
+      "ratio": 0.8644,
+      "suggested_scalar": -0.0439,
+      "log_bad": -5.1328,
+      "log_good": -5.2785
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.913,
+      "good": 0.825,
+      "ratio": 0.9036,
+      "suggested_scalar": -0.0305,
+      "log_bad": -0.091,
+      "log_good": -0.1924
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0059,
+      "good": 0.0051,
+      "ratio": 0.8644,
+      "suggested_scalar": -0.0439,
+      "log_bad": -5.1328,
+      "log_good": -5.2785
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.0627,
+      "good": 4.5627,
+      "ratio": 1.1231,
+      "suggested_scalar": 0.0349,
+      "log_bad": 1.4018,
+      "log_good": 1.5179
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 69.0,
+      "good": 70.0,
+      "ratio": 1.0145,
+      "suggested_scalar": 0.0043,
+      "log_bad": 4.2341,
+      "log_good": 4.2485
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4167,
+      "good": 0.374,
+      "ratio": 0.8975,
+      "suggested_scalar": -0.0325,
+      "log_bad": -0.8754,
+      "log_good": -0.9835
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 17.0,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.0172,
+      "log_bad": 2.8904,
+      "log_good": 2.8332
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5655,
+      "good": 0.5005,
+      "ratio": 0.8851,
+      "suggested_scalar": -0.0367,
+      "log_bad": -0.57,
+      "log_good": -0.6921
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 8.7826,
+      "good": 3.35,
+      "ratio": 0.3814,
+      "suggested_scalar": -0.2901,
+      "log_bad": 2.1728,
+      "log_good": 1.209
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 339.0,
+      "good": 392.0,
+      "ratio": 1.1563,
+      "suggested_scalar": 0.0437,
+      "log_bad": 5.826,
+      "log_good": 5.9713
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0013,
+      "good": 1.0,
+      "ratio": 769.2308,
+      "suggested_scalar": 2.0,
+      "log_bad": -6.6454,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.14,
+      "good": 1.1863,
+      "ratio": 1.0406,
+      "suggested_scalar": 0.012,
+      "log_bad": 0.131,
+      "log_good": 0.1708
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 96.0,
+      "good": 109.0,
+      "ratio": 1.1354,
+      "suggested_scalar": 0.0382,
+      "log_bad": 4.5643,
+      "log_good": 4.6913
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 102.2216,
+      "good": 97.575,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.014,
+      "log_bad": 4.6271,
+      "log_good": 4.5806
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7189,
+      "good": 0.7468,
+      "ratio": 1.0388,
+      "suggested_scalar": 0.0115,
+      "log_bad": -0.33,
+      "log_good": -0.292
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 17.2881,
+      "good": 19.8618,
+      "ratio": 1.1489,
+      "suggested_scalar": 0.0418,
+      "log_bad": 2.85,
+      "log_good": 2.9888
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1511.0,
+      "good": 1432.0,
+      "ratio": 0.9477,
+      "suggested_scalar": -0.0162,
+      "log_bad": 7.3205,
+      "log_good": 7.2668
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.2391,
+      "good": 0.125,
+      "ratio": 0.5228,
+      "suggested_scalar": -0.1952,
+      "log_bad": -1.4309,
+      "log_good": -2.0794
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7609,
+      "good": 0.775,
+      "ratio": 1.0185,
+      "suggested_scalar": 0.0055,
+      "log_bad": -0.2733,
+      "log_good": -0.2549
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.3696,
+      "good": 9.8,
+      "ratio": 1.3298,
+      "suggested_scalar": 0.0858,
+      "log_bad": 1.9974,
+      "log_good": 2.2824
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 2.0,
+      "good": 6.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.3306,
+      "log_bad": 0.6931,
+      "log_good": 1.7918
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 19.7353,
+      "good": 4.2275,
+      "ratio": 0.2142,
+      "suggested_scalar": -0.4637,
+      "log_bad": 2.9824,
+      "log_good": 1.4416
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 91.0,
+      "good": 100.0,
+      "ratio": 1.0989,
+      "suggested_scalar": 0.0284,
+      "log_bad": 4.5109,
+      "log_good": 4.6052
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9315,
+      "good": 0.9492,
+      "ratio": 1.019,
+      "suggested_scalar": 0.0057,
+      "log_bad": -0.071,
+      "log_good": -0.0521
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 27.0,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0114,
+      "log_bad": 3.2581,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6883,
+      "good": 0.6501,
+      "ratio": 0.9445,
+      "suggested_scalar": -0.0172,
+      "log_bad": -0.3735,
+      "log_good": -0.4306
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.5816,
+      "good": 0.5923,
+      "ratio": 1.0184,
+      "suggested_scalar": 0.0055,
+      "log_bad": -0.542,
+      "log_good": -0.5237
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.2081,
+      "good": 2.8583,
+      "ratio": 0.891,
+      "suggested_scalar": -0.0347,
+      "log_bad": 1.1657,
+      "log_good": 1.0502
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 337.0,
+      "good": 390.0,
+      "ratio": 1.1573,
+      "suggested_scalar": 0.044,
+      "log_bad": 5.8201,
+      "log_good": 5.9661
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 48.0,
+      "good": 9.0,
+      "ratio": 0.1875,
+      "suggested_scalar": -0.5038,
+      "log_bad": 3.8712,
+      "log_good": 2.1972
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0265,
+      "good": 0.0663,
+      "ratio": 2.5019,
+      "suggested_scalar": 0.276,
+      "log_bad": -3.6306,
+      "log_good": -2.7136
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.585,
+      "good": 5.6147,
+      "ratio": 1.0053,
+      "suggested_scalar": 0.0016,
+      "log_bad": 1.7201,
+      "log_good": 1.7254
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.3458,
+      "good": 0.487,
+      "ratio": 1.4083,
+      "suggested_scalar": 0.103,
+      "log_bad": -1.0619,
+      "log_good": -0.7195
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.0811,
+      "good": 4.9977,
+      "ratio": 0.9836,
+      "suggested_scalar": -0.005,
+      "log_bad": 1.6255,
+      "log_good": 1.609
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7274,
+      "good": 0.8126,
+      "ratio": 1.1171,
+      "suggested_scalar": 0.0333,
+      "log_bad": -0.3183,
+      "log_good": -0.2075
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1154,
+      "good": 0.2,
+      "ratio": 1.7331,
+      "suggested_scalar": 0.1655,
+      "log_bad": -2.1594,
+      "log_good": -1.6094
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 4.1579,
+      "good": 4.4567,
+      "ratio": 1.0719,
+      "suggested_scalar": 0.0209,
+      "log_bad": 1.425,
+      "log_good": 1.4944
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 196.0,
+      "good": 223.0,
+      "ratio": 1.1378,
+      "suggested_scalar": 0.0388,
+      "log_bad": 5.2781,
+      "log_good": 5.4072
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 4.0,
+      "good": 12.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.3306,
+      "log_bad": 1.3863,
+      "log_good": 2.4849
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.6312,
+      "good": 0.7743,
+      "ratio": 1.2267,
+      "suggested_scalar": 0.0615,
+      "log_bad": -0.4601,
+      "log_good": -0.2558
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 72.0,
+      "good": 72.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2767,
+      "log_good": 4.2767
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 639.0,
+      "good": 748.0,
+      "ratio": 1.1706,
+      "suggested_scalar": 0.0474,
+      "log_bad": 6.4599,
+      "log_good": 6.6174
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 95.0,
+      "good": 107.0,
+      "ratio": 1.1263,
+      "suggested_scalar": 0.0358,
+      "log_bad": 4.5539,
+      "log_good": 4.6728
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0265,
+      "good": 0.0051,
+      "ratio": 0.1925,
+      "suggested_scalar": -0.496,
+      "log_bad": -3.6306,
+      "log_good": -5.2785
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2183,
+      "good": 0.2679,
+      "ratio": 1.2272,
+      "suggested_scalar": 0.0616,
+      "log_bad": -1.5219,
+      "log_good": -1.3171
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 57.0,
+      "good": 63.0,
+      "ratio": 1.1053,
+      "suggested_scalar": 0.0301,
+      "log_bad": 4.0431,
+      "log_good": 4.1431
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 14.0,
+      "ratio": 4.6667,
+      "suggested_scalar": 0.4636,
+      "log_bad": 1.0986,
+      "log_good": 2.6391
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 72.0,
+      "good": 72.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2767,
+      "log_good": 4.2767
+    },
+    "brevity.mean_sample_size": {
+      "bad": 72.0,
+      "good": 72.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.2767,
+      "log_good": 4.2767
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 339.0,
+      "good": 392.0,
+      "ratio": 1.1563,
+      "suggested_scalar": 0.0437,
+      "log_bad": 5.826,
+      "log_good": 5.9713
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 202.0,
+      "good": 230.0,
+      "ratio": 1.1386,
+      "suggested_scalar": 0.0391,
+      "log_bad": 5.3083,
+      "log_good": 5.4381
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 152.0,
+      "good": 162.0,
+      "ratio": 1.0658,
+      "suggested_scalar": 0.0192,
+      "log_bad": 5.0239,
+      "log_good": 5.0876
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0029,
+      "good": 0.0026,
+      "ratio": 0.8966,
+      "suggested_scalar": -0.0329,
+      "log_bad": -5.843,
+      "log_good": -5.9522
+    },
+    "heaps.mean_k": {
+      "bad": 2.8081,
+      "good": 3.5111,
+      "ratio": 1.2503,
+      "suggested_scalar": 0.0672,
+      "log_bad": 1.0325,
+      "log_good": 1.2559
+    },
+    "halstead.mean_effort": {
+      "bad": 54387.1765,
+      "good": 78036.5347,
+      "ratio": 1.4348,
+      "suggested_scalar": 0.1087,
+      "log_bad": 10.9039,
+      "log_good": 11.2649
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8235,
+      "good": 0.81,
+      "ratio": 0.9836,
+      "suggested_scalar": -0.005,
+      "log_bad": -0.1942,
+      "log_good": -0.2107
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 43.0,
+      "good": 43.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.7612,
+      "log_good": 3.7612
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 215.0,
+      "good": 272.0,
+      "ratio": 1.2651,
+      "suggested_scalar": 0.0708,
+      "log_bad": 5.3706,
+      "log_good": 5.6058
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4167,
+      "good": 0.3761,
+      "ratio": 0.9026,
+      "suggested_scalar": -0.0309,
+      "log_bad": -0.8754,
+      "log_good": -0.9779
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.6563,
+      "good": 6.8624,
+      "ratio": 1.031,
+      "suggested_scalar": 0.0092,
+      "log_bad": 1.8956,
+      "log_good": 1.9261
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1154,
+      "good": 0.2,
+      "ratio": 1.7331,
+      "suggested_scalar": 0.1655,
+      "log_bad": -2.1594,
+      "log_good": -1.6094
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.8367,
+      "good": 5.4107,
+      "ratio": 1.4102,
+      "suggested_scalar": 0.1035,
+      "log_bad": 1.3446,
+      "log_good": 1.6884
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 338.0,
+      "good": 391.0,
+      "ratio": 1.1568,
+      "suggested_scalar": 0.0438,
+      "log_bad": 5.823,
+      "log_good": 5.9687
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 7.0,
+      "good": 16.0,
+      "ratio": 2.2857,
+      "suggested_scalar": 0.2488,
+      "log_bad": 1.9459,
+      "log_good": 2.7726
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 55.0,
+      "good": 64.0,
+      "ratio": 1.1636,
+      "suggested_scalar": 0.0456,
+      "log_bad": 4.0073,
+      "log_good": 4.1589
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3021.5098,
+      "good": 4335.363,
+      "ratio": 1.4348,
+      "suggested_scalar": 0.1087,
+      "log_bad": 8.0135,
+      "log_good": 8.3746
+    },
+    "readability.mean_total_lines": {
+      "bad": 46.0,
+      "good": 40.0,
+      "ratio": 0.8696,
+      "suggested_scalar": -0.0421,
+      "log_bad": 3.8286,
+      "log_good": 3.6889
+    },
+    "indentation.mean_max_depth": {
+      "bad": 18.0,
+      "good": 9.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2086,
+      "log_bad": 2.8904,
+      "log_good": 2.1972
+    },
+    "halstead.mean_volume": {
+      "bad": 1893.6426,
+      "good": 2322.9983,
+      "ratio": 1.2267,
+      "suggested_scalar": 0.0615,
+      "log_bad": 7.5463,
+      "log_good": 7.7506
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 471.0,
+      "good": 501.0,
+      "ratio": 1.0637,
+      "suggested_scalar": 0.0186,
+      "log_bad": 6.1549,
+      "log_good": 6.2166
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.7174,
+      "good": 34.55,
+      "ratio": 1.0893,
+      "suggested_scalar": 0.0257,
+      "log_bad": 3.4569,
+      "log_good": 3.5424
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1481,
+      "good": 1.1739,
+      "ratio": 1.0225,
+      "suggested_scalar": 0.0067,
+      "log_bad": 0.1381,
+      "log_good": 0.1603
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 19.0,
+      "good": 7.0,
+      "ratio": 0.3684,
+      "suggested_scalar": -0.3005,
+      "log_bad": 2.9444,
+      "log_good": 1.9459
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7194,
+      "good": 0.713,
+      "ratio": 0.9911,
+      "suggested_scalar": -0.0027,
+      "log_bad": -0.3293,
+      "log_good": -0.3383
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9678,
+      "good": 0.9838,
+      "ratio": 1.0165,
+      "suggested_scalar": 0.0049,
+      "log_bad": -0.0327,
+      "log_good": -0.0163
+    },
+    "halstead.mean_length": {
+      "bad": 310.0,
+      "good": 379.0,
+      "ratio": 1.2226,
+      "suggested_scalar": 0.0605,
+      "log_bad": 5.7366,
+      "log_good": 5.9375
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 17.0,
+      "good": 3.5,
+      "ratio": 0.2059,
+      "suggested_scalar": -0.4757,
+      "log_bad": 2.8332,
+      "log_good": 1.2528
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.1699,
+      "good": 6.1699,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.8197,
+      "log_good": 1.8197
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1337,
+      "good": 0.1606,
+      "ratio": 1.2012,
+      "suggested_scalar": 0.0552,
+      "log_bad": -2.0122,
+      "log_good": -1.8288
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 28.7209,
+      "good": 33.593,
+      "ratio": 1.1696,
+      "suggested_scalar": 0.0472,
+      "log_bad": 3.3576,
+      "log_good": 3.5143
+    },
+    "branching.mean_branch_count": {
+      "bad": 11.0,
+      "good": 5.0,
+      "ratio": 0.4545,
+      "suggested_scalar": -0.2373,
+      "log_bad": 2.3979,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 40.0,
+      "good": 41.0,
+      "ratio": 1.025,
+      "suggested_scalar": 0.0074,
+      "log_bad": 3.6889,
+      "log_good": 3.7136
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.625,
+      "good": 0.6111,
+      "ratio": 0.9778,
+      "suggested_scalar": -0.0068,
+      "log_bad": -0.47,
+      "log_good": -0.4925
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 46.0,
+      "good": 40.0,
+      "ratio": 0.8696,
+      "suggested_scalar": -0.0421,
+      "log_bad": 3.8286,
+      "log_good": 3.6889
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.uses_using_statement_for_disposables": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0184,
+      "good": 0.0222,
+      "ratio": 1.2065,
+      "suggested_scalar": 0.1221,
+      "log_bad": -3.9954,
+      "log_good": -3.8077
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6667,
+      "good": 1.6667,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.5108,
+      "log_good": 0.5108
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8154,
+      "good": 0.7925,
+      "ratio": 0.9719,
+      "suggested_scalar": -0.0185,
+      "log_bad": -0.2041,
+      "log_good": -0.2326
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0204,
+      "good": 0.0246,
+      "ratio": 1.2059,
+      "suggested_scalar": 0.1218,
+      "log_bad": -3.8922,
+      "log_good": -3.705
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.448,
+      "good": 4.5125,
+      "ratio": 1.0145,
+      "suggested_scalar": 0.0094,
+      "log_bad": 1.4925,
+      "log_good": 1.5069
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 112.0,
+      "good": 90.0,
+      "ratio": 0.8036,
+      "suggested_scalar": -0.1422,
+      "log_bad": 4.7185,
+      "log_good": 4.4998
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5666,
+      "good": 0.5248,
+      "ratio": 0.9262,
+      "suggested_scalar": -0.0498,
+      "log_bad": -0.5681,
+      "log_good": -0.6447
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 20.0,
+      "good": 18.0,
+      "ratio": 0.9,
+      "suggested_scalar": -0.0685,
+      "log_bad": 2.9957,
+      "log_good": 2.8904
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7407,
+      "good": 0.7424,
+      "ratio": 1.0023,
+      "suggested_scalar": 0.0015,
+      "log_bad": -0.3002,
+      "log_good": -0.2979
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 9.9077,
+      "good": 9.434,
+      "ratio": 0.9522,
+      "suggested_scalar": -0.0319,
+      "log_bad": 2.2933,
+      "log_good": 2.2443
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 489.0,
+      "good": 406.0,
+      "ratio": 0.8303,
+      "suggested_scalar": -0.121,
+      "log_bad": 6.1924,
+      "log_good": 6.0064
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0462,
+      "good": 1.0,
+      "ratio": 21.645,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.0748,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.967,
+      "good": 0.9875,
+      "ratio": 1.0212,
+      "suggested_scalar": 0.0136,
+      "log_bad": -0.0336,
+      "log_good": -0.0126
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 170.0,
+      "good": 128.0,
+      "ratio": 0.7529,
+      "suggested_scalar": -0.1846,
+      "log_bad": 5.1358,
+      "log_good": 4.852
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 92.9913,
+      "good": 88.7697,
+      "ratio": 0.9546,
+      "suggested_scalar": -0.0302,
+      "log_bad": 4.5325,
+      "log_good": 4.486
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6352,
+      "good": 0.6444,
+      "ratio": 1.0145,
+      "suggested_scalar": 0.0094,
+      "log_bad": -0.4538,
+      "log_good": -0.4394
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 11.4444,
+      "good": 13.2006,
+      "ratio": 1.1535,
+      "suggested_scalar": 0.0929,
+      "log_bad": 2.4375,
+      "log_good": 2.5803
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 2713.0,
+      "good": 2229.0,
+      "ratio": 0.8216,
+      "suggested_scalar": -0.1278,
+      "log_bad": 7.9058,
+      "log_good": 7.7093
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0769,
+      "good": 0.0377,
+      "ratio": 0.4902,
+      "suggested_scalar": -0.4637,
+      "log_bad": -2.5652,
+      "log_good": -3.2781
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7231,
+      "good": 0.6792,
+      "ratio": 0.9393,
+      "suggested_scalar": -0.0407,
+      "log_bad": -0.3242,
+      "log_good": -0.3868
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.5231,
+      "good": 7.6604,
+      "ratio": 1.0183,
+      "suggested_scalar": 0.0118,
+      "log_bad": 2.018,
+      "log_good": 2.0361
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 19.253,
+      "good": 22.3966,
+      "ratio": 1.1633,
+      "suggested_scalar": 0.0984,
+      "log_bad": 2.9577,
+      "log_good": 3.1089
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 63.0,
+      "good": 35.0,
+      "ratio": 0.5556,
+      "suggested_scalar": -0.3823,
+      "log_bad": 4.1431,
+      "log_good": 3.5553
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9584,
+      "good": 0.9555,
+      "ratio": 0.997,
+      "suggested_scalar": -0.002,
+      "log_bad": -0.0425,
+      "log_good": -0.0455
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 20.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.1451,
+      "log_bad": 3.2189,
+      "log_good": 2.9957
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.686,
+      "good": 0.6895,
+      "ratio": 1.0051,
+      "suggested_scalar": 0.0033,
+      "log_bad": -0.3769,
+      "log_good": -0.3718
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4702,
+      "good": 0.4901,
+      "ratio": 1.0423,
+      "suggested_scalar": 0.027,
+      "log_bad": -0.7546,
+      "log_good": -0.7131
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.1843,
+      "good": 3.2211,
+      "ratio": 1.0116,
+      "suggested_scalar": 0.0075,
+      "log_bad": 1.1582,
+      "log_good": 1.1697
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 487.0,
+      "good": 404.0,
+      "ratio": 0.8296,
+      "suggested_scalar": -0.1215,
+      "log_bad": 6.1883,
+      "log_good": 6.0014
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 29.0,
+      "good": 22.0,
+      "ratio": 0.7586,
+      "suggested_scalar": -0.1797,
+      "log_bad": 3.3673,
+      "log_good": 3.091
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0041,
+      "good": 0.0074,
+      "ratio": 1.8049,
+      "suggested_scalar": 0.3841,
+      "log_bad": -5.4968,
+      "log_good": -4.9063
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 6.1699,
+      "good": 6.0875,
+      "ratio": 0.9866,
+      "suggested_scalar": -0.0087,
+      "log_bad": 1.8197,
+      "log_good": 1.8062
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 86.0,
+      "good": 72.0,
+      "ratio": 0.8372,
+      "suggested_scalar": -0.1156,
+      "log_bad": 4.4543,
+      "log_good": 4.2767
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4875,
+      "good": 1.5215,
+      "ratio": 1.0229,
+      "suggested_scalar": 0.0147,
+      "log_bad": 0.3971,
+      "log_good": 0.4197
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8421,
+      "good": 5.6716,
+      "ratio": 0.9708,
+      "suggested_scalar": -0.0193,
+      "log_bad": 1.7651,
+      "log_good": 1.7355
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7209,
+      "good": 0.7413,
+      "ratio": 1.0283,
+      "suggested_scalar": 0.0182,
+      "log_bad": -0.3273,
+      "log_good": -0.2993
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1975,
+      "good": 0.197,
+      "ratio": 0.9975,
+      "suggested_scalar": -0.0016,
+      "log_bad": -1.622,
+      "log_good": -1.6246
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.383,
+      "good": 3.6333,
+      "ratio": 1.074,
+      "suggested_scalar": 0.0464,
+      "log_bad": 1.2188,
+      "log_good": 1.2901
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 348.0,
+      "good": 290.0,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.1186,
+      "log_bad": 5.8522,
+      "log_good": 5.6699
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 35.0,
+      "good": 27.0,
+      "ratio": 0.7714,
+      "suggested_scalar": -0.1688,
+      "log_bad": 3.5553,
+      "log_good": 3.2958
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.012,
+      "good": 0.7877,
+      "ratio": 0.7784,
+      "suggested_scalar": -0.163,
+      "log_bad": 0.0119,
+      "log_good": -0.2386
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 125.0,
+      "good": 102.0,
+      "ratio": 0.816,
+      "suggested_scalar": -0.1323,
+      "log_bad": 4.8283,
+      "log_good": 4.625
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1314.0,
+      "good": 1037.0,
+      "ratio": 0.7892,
+      "suggested_scalar": -0.154,
+      "log_bad": 7.1808,
+      "log_good": 6.9441
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 191.0,
+      "good": 146.0,
+      "ratio": 0.7644,
+      "suggested_scalar": -0.1748,
+      "log_bad": 5.2523,
+      "log_good": 4.9836
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2536,
+      "good": 0.2635,
+      "ratio": 1.039,
+      "suggested_scalar": 0.0249,
+      "log_bad": -1.372,
+      "log_good": -1.3337
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 98.0,
+      "good": 87.0,
+      "ratio": 0.8878,
+      "suggested_scalar": -0.0774,
+      "log_bad": 4.585,
+      "log_good": 4.4659
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 125.0,
+      "good": 102.0,
+      "ratio": 0.816,
+      "suggested_scalar": -0.1323,
+      "log_bad": 4.8283,
+      "log_good": 4.625
+    },
+    "brevity.mean_sample_size": {
+      "bad": 125.0,
+      "good": 102.0,
+      "ratio": 0.816,
+      "suggested_scalar": -0.1323,
+      "log_bad": 4.8283,
+      "log_good": 4.625
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 489.0,
+      "good": 406.0,
+      "ratio": 0.8303,
+      "suggested_scalar": -0.121,
+      "log_bad": 6.1924,
+      "log_good": 6.0064
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 257.0,
+      "good": 214.0,
+      "ratio": 0.8327,
+      "suggested_scalar": -0.1191,
+      "log_bad": 5.5491,
+      "log_good": 5.366
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 276.0,
+      "good": 231.0,
+      "ratio": 0.837,
+      "suggested_scalar": -0.1158,
+      "log_bad": 5.6204,
+      "log_good": 5.4424
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.002,
+      "good": 0.0025,
+      "ratio": 1.25,
+      "suggested_scalar": 0.1451,
+      "log_bad": -6.2146,
+      "log_good": -5.9915
+    },
+    "heaps.mean_k": {
+      "bad": 1.4481,
+      "good": 1.3056,
+      "ratio": 0.9016,
+      "suggested_scalar": -0.0674,
+      "log_bad": 0.3703,
+      "log_good": 0.2667
+    },
+    "halstead.mean_effort": {
+      "bad": 83317.7207,
+      "good": 49286.1487,
+      "ratio": 0.5915,
+      "suggested_scalar": -0.3415,
+      "log_bad": 11.3304,
+      "log_good": 10.8054
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8387,
+      "good": 0.85,
+      "ratio": 1.0135,
+      "suggested_scalar": 0.0087,
+      "log_bad": -0.1759,
+      "log_good": -0.1625
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 87.0,
+      "good": 70.0,
+      "ratio": 0.8046,
+      "suggested_scalar": -0.1414,
+      "log_bad": 4.4659,
+      "log_good": 4.2485
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 255.0,
+      "good": 218.0,
+      "ratio": 0.8549,
+      "suggested_scalar": -0.102,
+      "log_bad": 5.5413,
+      "log_good": 5.3845
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4882,
+      "good": 0.5156,
+      "ratio": 1.0561,
+      "suggested_scalar": 0.0355,
+      "log_bad": -0.717,
+      "log_good": -0.6624
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 7.7294,
+      "good": 8.1016,
+      "ratio": 1.0482,
+      "suggested_scalar": 0.0306,
+      "log_bad": 2.045,
+      "log_good": 2.0921
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1975,
+      "good": 0.197,
+      "ratio": 0.9975,
+      "suggested_scalar": -0.0016,
+      "log_bad": -1.622,
+      "log_good": -1.6246
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.7019,
+      "good": 3.9018,
+      "ratio": 1.054,
+      "suggested_scalar": 0.0342,
+      "log_bad": 1.3088,
+      "log_good": 1.3614
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 488.0,
+      "good": 405.0,
+      "ratio": 0.8299,
+      "suggested_scalar": -0.1213,
+      "log_bad": 6.1903,
+      "log_good": 6.0039
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 90.0,
+      "good": 84.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0449,
+      "log_bad": 4.4998,
+      "log_good": 4.4308
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4628.7623,
+      "good": 2738.1194,
+      "ratio": 0.5915,
+      "suggested_scalar": -0.3415,
+      "log_bad": 8.44,
+      "log_good": 7.915
+    },
+    "readability.mean_total_lines": {
+      "bad": 65.0,
+      "good": 53.0,
+      "ratio": 0.8154,
+      "suggested_scalar": -0.1328,
+      "log_bad": 4.1744,
+      "log_good": 3.9703
+    },
+    "indentation.mean_max_depth": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "halstead.mean_volume": {
+      "bad": 3036.0803,
+      "good": 2363.0345,
+      "ratio": 0.7783,
+      "suggested_scalar": -0.163,
+      "log_bad": 8.0183,
+      "log_good": 7.7677
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 852.0,
+      "good": 692.0,
+      "ratio": 0.8122,
+      "suggested_scalar": -0.1353,
+      "log_bad": 6.7476,
+      "log_good": 6.5396
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 40.4615,
+      "good": 40.8113,
+      "ratio": 1.0086,
+      "suggested_scalar": 0.0056,
+      "log_bad": 3.7004,
+      "log_good": 3.709
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2554,
+      "good": 1.3037,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0246,
+      "log_bad": 0.2275,
+      "log_good": 0.2652
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 36.0,
+      "good": 28.0,
+      "ratio": 0.7778,
+      "suggested_scalar": -0.1635,
+      "log_bad": 3.5835,
+      "log_good": 3.3322
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.7146,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7414,
+      "good": 0.7103,
+      "ratio": 0.9581,
+      "suggested_scalar": -0.0279,
+      "log_bad": -0.2992,
+      "log_good": -0.3421
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9581,
+      "good": 0.977,
+      "ratio": 1.0197,
+      "suggested_scalar": 0.0127,
+      "log_bad": -0.0428,
+      "log_good": -0.0233
+    },
+    "halstead.mean_length": {
+      "bad": 446.0,
+      "good": 364.0,
+      "ratio": 0.8161,
+      "suggested_scalar": -0.1321,
+      "log_bad": 6.1003,
+      "log_good": 5.8972
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 21.6667,
+      "good": 16.6667,
+      "ratio": 0.7692,
+      "suggested_scalar": -0.1707,
+      "log_bad": 3.0758,
+      "log_good": 2.8134
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.9658,
+      "good": 6.6724,
+      "ratio": 0.9579,
+      "suggested_scalar": -0.028,
+      "log_bad": 1.941,
+      "log_good": 1.898
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0948,
+      "good": 0.096,
+      "ratio": 1.0127,
+      "suggested_scalar": 0.0082,
+      "log_bad": -2.356,
+      "log_good": -2.3434
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 27.4425,
+      "good": 20.8571,
+      "ratio": 0.76,
+      "suggested_scalar": -0.1785,
+      "log_bad": 3.3121,
+      "log_good": 3.0377
+    },
+    "branching.mean_branch_count": {
+      "bad": 5.0,
+      "good": 2.0,
+      "ratio": 0.4,
+      "suggested_scalar": -0.596,
+      "log_bad": 1.6094,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 83.0,
+      "good": 66.0,
+      "ratio": 0.7952,
+      "suggested_scalar": -0.1491,
+      "log_bad": 4.4188,
+      "log_good": 4.1897
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6449,
+      "good": 0.6234,
+      "ratio": 0.9667,
+      "suggested_scalar": -0.0221,
+      "log_bad": -0.4387,
+      "log_good": -0.4726
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 65.0,
+      "good": 53.0,
+      "ratio": 0.8154,
+      "suggested_scalar": -0.1328,
+      "log_bad": 4.1744,
+      "log_good": 3.9703
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.no_single_char_variable_ambiguous": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 86.0,
+      "good": 80.0,
+      "ratio": 0.9302,
+      "suggested_scalar": -0.0696,
+      "log_bad": 4.4543,
+      "log_good": 4.382
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0119,
+      "good": 0.0498,
+      "ratio": 4.1849,
+      "suggested_scalar": 1.3768,
+      "log_bad": -4.4312,
+      "log_good": -2.9997
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.4286,
+      "good": 1.4286,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.3567,
+      "log_good": 0.3567
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 0.9783,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.0211,
+      "log_bad": 0.0,
+      "log_good": -0.0219
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0119,
+      "good": 0.0498,
+      "ratio": 4.1849,
+      "suggested_scalar": 1.3768,
+      "log_bad": -4.4312,
+      "log_good": -2.9997
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4873,
+      "good": 4.5657,
+      "ratio": 1.0175,
+      "suggested_scalar": 0.0167,
+      "log_bad": 1.5013,
+      "log_good": 1.5186
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 97.0,
+      "good": 76.0,
+      "ratio": 0.7835,
+      "suggested_scalar": -0.2347,
+      "log_bad": 4.5747,
+      "log_good": 4.3307
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.3666,
+      "good": 0.3281,
+      "ratio": 0.895,
+      "suggested_scalar": -0.1067,
+      "log_bad": -1.0035,
+      "log_good": -1.1144
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 16.0,
+      "good": 14.0,
+      "ratio": 0.875,
+      "suggested_scalar": -0.1284,
+      "log_bad": 2.7726,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5605,
+      "good": 0.5313,
+      "ratio": 0.9479,
+      "suggested_scalar": -0.0515,
+      "log_bad": -0.5789,
+      "log_good": -0.6324
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.5,
+      "good": 4.3478,
+      "ratio": 0.9662,
+      "suggested_scalar": -0.0331,
+      "log_bad": 1.5041,
+      "log_good": 1.4697
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 506.0,
+      "good": 482.0,
+      "ratio": 0.9526,
+      "suggested_scalar": -0.0467,
+      "log_bad": 6.2265,
+      "log_good": 6.1779
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.4913,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.0925,
+      "good": 1.0824,
+      "ratio": 0.9908,
+      "suggested_scalar": -0.0089,
+      "log_bad": 0.0885,
+      "log_good": 0.0792
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 201.0,
+      "good": 173.0,
+      "ratio": 0.8607,
+      "suggested_scalar": -0.1443,
+      "log_bad": 5.3033,
+      "log_good": 5.1533
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 109.704,
+      "good": 99.7625,
+      "ratio": 0.9094,
+      "suggested_scalar": -0.0914,
+      "log_bad": 4.6978,
+      "log_good": 4.6028
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5703,
+      "good": 0.6507,
+      "ratio": 1.141,
+      "suggested_scalar": 0.1268,
+      "log_bad": -0.5616,
+      "log_good": -0.4297
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 7.4901,
+      "good": 4.0895,
+      "ratio": 0.546,
+      "suggested_scalar": -0.582,
+      "log_bad": 2.0136,
+      "log_good": 1.4084
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1702.0,
+      "good": 1871.0,
+      "ratio": 1.0993,
+      "suggested_scalar": 0.0911,
+      "log_bad": 7.4396,
+      "log_good": 7.5342
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.4,
+      "good": 0.3261,
+      "ratio": 0.8152,
+      "suggested_scalar": -0.1965,
+      "log_bad": -0.9163,
+      "log_good": -1.1206
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 1.0,
+      "good": 0.9783,
+      "ratio": 0.9783,
+      "suggested_scalar": -0.0211,
+      "log_bad": 0.0,
+      "log_good": -0.0219
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 12.65,
+      "good": 10.4783,
+      "ratio": 0.8283,
+      "suggested_scalar": -0.1812,
+      "log_bad": 2.5377,
+      "log_good": 2.3493
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 1.548,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 7.0,
+      "good": 2.0,
+      "ratio": 0.2857,
+      "suggested_scalar": -1.2049,
+      "log_bad": 1.9459,
+      "log_good": 0.6931
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 15.35,
+      "good": 13.7921,
+      "ratio": 0.8985,
+      "suggested_scalar": -0.1029,
+      "log_bad": 2.7311,
+      "log_good": 2.6241
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 158.0,
+      "good": 150.0,
+      "ratio": 0.9494,
+      "suggested_scalar": -0.05,
+      "log_bad": 5.0626,
+      "log_good": 5.0106
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.6667,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9018,
+      "good": 0.9247,
+      "ratio": 1.0254,
+      "suggested_scalar": 0.0241,
+      "log_bad": -0.1034,
+      "log_good": -0.0783
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 27.0,
+      "good": 24.0,
+      "ratio": 0.8889,
+      "suggested_scalar": -0.1133,
+      "log_bad": 3.2958,
+      "log_good": 3.1781
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5787,
+      "good": 0.6558,
+      "ratio": 1.1332,
+      "suggested_scalar": 0.1203,
+      "log_bad": -0.547,
+      "log_good": -0.4219
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.3552,
+      "good": 0.4292,
+      "ratio": 1.2083,
+      "suggested_scalar": 0.182,
+      "log_bad": -1.0351,
+      "log_good": -0.8458
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.3738,
+      "good": 2.9053,
+      "ratio": 1.2239,
+      "suggested_scalar": 0.1943,
+      "log_bad": 0.8645,
+      "log_good": 1.0665
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 504.0,
+      "good": 480.0,
+      "ratio": 0.9524,
+      "suggested_scalar": -0.0469,
+      "log_bad": 6.2226,
+      "log_good": 6.1738
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 14.0,
+      "good": 15.0,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.0664,
+      "log_bad": 2.6391,
+      "log_good": 2.7081
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0336,
+      "good": 0.0353,
+      "ratio": 1.0506,
+      "suggested_scalar": 0.0475,
+      "log_bad": -3.3932,
+      "log_good": -3.3439
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7279,
+      "good": 5.6439,
+      "ratio": 0.9853,
+      "suggested_scalar": -0.0142,
+      "log_bad": 1.7453,
+      "log_good": 1.7306
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 36.0,
+      "good": 21.0,
+      "ratio": 0.5833,
+      "suggested_scalar": -0.5184,
+      "log_bad": 3.5835,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.886,
+      "good": 0.6221,
+      "ratio": 0.7021,
+      "suggested_scalar": -0.3401,
+      "log_bad": -0.121,
+      "log_good": -0.4747
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.8204,
+      "good": 5.5705,
+      "ratio": 0.9571,
+      "suggested_scalar": -0.0422,
+      "log_bad": 1.7614,
+      "log_good": 1.7175
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7834,
+      "good": 0.809,
+      "ratio": 1.0327,
+      "suggested_scalar": 0.0309,
+      "log_bad": -0.2441,
+      "log_good": -0.212
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 8.0,
+      "ratio": 8.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 2.0794
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2727,
+      "good": 0.2581,
+      "ratio": 0.9465,
+      "suggested_scalar": -0.0529,
+      "log_bad": -1.2994,
+      "log_good": -1.3544
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.7368,
+      "good": 2.0223,
+      "ratio": 0.7389,
+      "suggested_scalar": -0.291,
+      "log_bad": 1.0068,
+      "log_good": 0.7042
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 1.0566,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 385.0,
+      "good": 336.0,
+      "ratio": 0.8727,
+      "suggested_scalar": -0.1309,
+      "log_bad": 5.9532,
+      "log_good": 5.8171
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.012,
+      "good": 0.8226,
+      "ratio": 0.8128,
+      "suggested_scalar": -0.1993,
+      "log_bad": 0.0119,
+      "log_good": -0.1953
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 90.0,
+      "ratio": 0.8411,
+      "suggested_scalar": -0.1664,
+      "log_bad": 4.6728,
+      "log_good": 4.4998
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 680.0,
+      "good": 926.0,
+      "ratio": 1.3618,
+      "suggested_scalar": 0.297,
+      "log_bad": 6.5221,
+      "log_good": 6.8309
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 218.0,
+      "good": 162.0,
+      "ratio": 0.7431,
+      "suggested_scalar": -0.2856,
+      "log_bad": 5.3845,
+      "log_good": 5.0876
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 4.0,
+      "ratio": 4.0,
+      "suggested_scalar": 1.3333,
+      "log_bad": 0.0,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0138,
+      "good": 0.0145,
+      "ratio": 1.0507,
+      "suggested_scalar": 0.0476,
+      "log_bad": -4.2831,
+      "log_good": -4.2336
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2253,
+      "good": 0.2365,
+      "ratio": 1.0497,
+      "suggested_scalar": 0.0467,
+      "log_bad": -1.4903,
+      "log_good": -1.4418
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 79.0,
+      "good": 84.0,
+      "ratio": 1.0633,
+      "suggested_scalar": 0.059,
+      "log_bad": 4.3694,
+      "log_good": 4.4308
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 107.0,
+      "good": 90.0,
+      "ratio": 0.8411,
+      "suggested_scalar": -0.1664,
+      "log_bad": 4.6728,
+      "log_good": 4.4998
+    },
+    "brevity.mean_sample_size": {
+      "bad": 107.0,
+      "good": 90.0,
+      "ratio": 0.8411,
+      "suggested_scalar": -0.1664,
+      "log_bad": 4.6728,
+      "log_good": 4.4998
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 506.0,
+      "good": 482.0,
+      "ratio": 0.9526,
+      "suggested_scalar": -0.0467,
+      "log_bad": 6.2265,
+      "log_good": 6.1779
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 219.0,
+      "good": 233.0,
+      "ratio": 1.0639,
+      "suggested_scalar": 0.0596,
+      "log_bad": 5.3891,
+      "log_good": 5.451
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 296.0,
+      "good": 252.0,
+      "ratio": 0.8514,
+      "suggested_scalar": -0.1548,
+      "log_bad": 5.6904,
+      "log_good": 5.5294
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 3.4789,
+      "good": 3.551,
+      "ratio": 1.0207,
+      "suggested_scalar": 0.0197,
+      "log_bad": 1.2467,
+      "log_good": 1.2672
+    },
+    "halstead.mean_effort": {
+      "bad": 127640.4287,
+      "good": 92262.665,
+      "ratio": 0.7228,
+      "suggested_scalar": -0.3122,
+      "log_bad": 11.757,
+      "log_good": 11.4324
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 6.0,
+      "ratio": 6.0,
+      "suggested_scalar": 1.7233,
+      "log_bad": 0.0,
+      "log_good": 1.7918
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8634,
+      "good": 0.8581,
+      "ratio": 0.9939,
+      "suggested_scalar": -0.0059,
+      "log_bad": -0.1469,
+      "log_good": -0.153
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 70.0,
+      "good": 52.0,
+      "ratio": 0.7429,
+      "suggested_scalar": -0.2859,
+      "log_bad": 4.2485,
+      "log_good": 3.9512
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 242.0,
+      "good": 233.0,
+      "ratio": 0.9628,
+      "suggested_scalar": -0.0365,
+      "log_bad": 5.4889,
+      "log_good": 5.451
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3333,
+      "good": 0.3179,
+      "ratio": 0.9538,
+      "suggested_scalar": -0.0455,
+      "log_bad": -1.0987,
+      "log_good": -1.146
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 3.3831,
+      "good": 5.3526,
+      "ratio": 1.5822,
+      "suggested_scalar": 0.4413,
+      "log_bad": 1.2188,
+      "log_good": 1.6776
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2727,
+      "good": 0.2581,
+      "ratio": 0.9465,
+      "suggested_scalar": -0.0529,
+      "log_bad": -1.2994,
+      "log_good": -1.3544
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.06,
+      "good": 4.1913,
+      "ratio": 0.8283,
+      "suggested_scalar": -0.1812,
+      "log_bad": 1.6214,
+      "log_good": 1.433
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 505.0,
+      "good": 481.0,
+      "ratio": 0.9525,
+      "suggested_scalar": -0.0468,
+      "log_bad": 6.2246,
+      "log_good": 6.1759
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 7.0,
+      "good": 7.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.9459,
+      "log_good": 1.9459
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 60.0,
+      "good": 62.0,
+      "ratio": 1.0333,
+      "suggested_scalar": 0.0315,
+      "log_bad": 4.0943,
+      "log_good": 4.1271
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 7091.1349,
+      "good": 5125.7036,
+      "ratio": 0.7228,
+      "suggested_scalar": -0.3122,
+      "log_bad": 8.8666,
+      "log_good": 8.542
+    },
+    "readability.mean_total_lines": {
+      "bad": 40.0,
+      "good": 46.0,
+      "ratio": 1.15,
+      "suggested_scalar": 0.1344,
+      "log_bad": 3.6889,
+      "log_good": 3.8286
+    },
+    "indentation.mean_max_depth": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "halstead.mean_volume": {
+      "bad": 3035.9599,
+      "good": 2467.9314,
+      "ratio": 0.8129,
+      "suggested_scalar": -0.1992,
+      "log_bad": 8.0183,
+      "log_good": 7.8111
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 717.0,
+      "good": 644.0,
+      "ratio": 0.8982,
+      "suggested_scalar": -0.1033,
+      "log_bad": 6.5751,
+      "log_good": 6.4677
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 40.825,
+      "good": 39.2826,
+      "ratio": 0.9622,
+      "suggested_scalar": -0.037,
+      "log_bad": 3.7093,
+      "log_good": 3.6708
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 0.9964,
+      "good": 1.1399,
+      "ratio": 1.144,
+      "suggested_scalar": 0.1294,
+      "log_bad": -0.0036,
+      "log_good": 0.1309
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.4913,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 5.0,
+      "good": 11.0,
+      "ratio": 2.2,
+      "suggested_scalar": 0.7583,
+      "log_bad": 1.6094,
+      "log_good": 2.3979
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8442,
+      "good": 0.8155,
+      "ratio": 0.966,
+      "suggested_scalar": -0.0333,
+      "log_bad": -0.1694,
+      "log_good": -0.204
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 5.0,
+      "good": 17.0,
+      "ratio": 3.4,
+      "suggested_scalar": 1.177,
+      "log_bad": 1.6094,
+      "log_good": 2.8332
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9416,
+      "good": 0.9505,
+      "ratio": 1.0095,
+      "suggested_scalar": 0.009,
+      "log_bad": -0.0602,
+      "log_good": -0.0508
+    },
+    "halstead.mean_length": {
+      "bad": 460.0,
+      "good": 395.0,
+      "ratio": 0.8587,
+      "suggested_scalar": -0.1465,
+      "log_bad": 6.1312,
+      "log_good": 5.9789
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.0,
+      "good": 7.7143,
+      "ratio": 1.102,
+      "suggested_scalar": 0.0935,
+      "log_bad": 1.9459,
+      "log_good": 2.0431
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.7415,
+      "good": 6.4919,
+      "ratio": 0.963,
+      "suggested_scalar": -0.0363,
+      "log_bad": 1.9083,
+      "log_good": 1.8706
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 6.0,
+      "ratio": 6.0,
+      "suggested_scalar": 1.7233,
+      "log_bad": 0.0,
+      "log_good": 1.7918
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1297,
+      "good": 0.1247,
+      "ratio": 0.9614,
+      "suggested_scalar": -0.0378,
+      "log_bad": -2.0425,
+      "log_good": -2.0818
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 42.0429,
+      "good": 37.3846,
+      "ratio": 0.8892,
+      "suggested_scalar": -0.1129,
+      "log_bad": 3.7387,
+      "log_good": 3.6213
+    },
+    "branching.mean_branch_count": {
+      "bad": 16.0,
+      "good": 15.0,
+      "ratio": 0.9375,
+      "suggested_scalar": -0.0621,
+      "log_bad": 2.7726,
+      "log_good": 2.7081
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 67.0,
+      "good": 55.0,
+      "ratio": 0.8209,
+      "suggested_scalar": -0.1898,
+      "log_bad": 4.2047,
+      "log_good": 4.0073
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7331,
+      "good": 0.6667,
+      "ratio": 0.9094,
+      "suggested_scalar": -0.0913,
+      "log_bad": -0.3105,
+      "log_good": -0.4054
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 40.0,
+      "good": 46.0,
+      "ratio": 1.15,
+      "suggested_scalar": 0.1344,
+      "log_bad": 3.6889,
+      "log_good": 3.8286
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_non_null_assertion": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 16.0,
+      "good": 17.0,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.0188,
+      "log_bad": 2.7726,
+      "log_good": 2.8332
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0058,
+      "good": 0.0069,
+      "ratio": 1.1897,
+      "suggested_scalar": 0.054,
+      "log_bad": -5.1499,
+      "log_good": -4.9762
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.5,
+      "good": 1.1667,
+      "ratio": 0.7778,
+      "suggested_scalar": -0.0781,
+      "log_bad": 0.4055,
+      "log_good": 0.1542
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8571,
+      "good": 0.8431,
+      "ratio": 0.9837,
+      "suggested_scalar": -0.0051,
+      "log_bad": -0.1542,
+      "log_good": -0.1707
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0058,
+      "good": 0.0069,
+      "ratio": 1.1897,
+      "suggested_scalar": 0.054,
+      "log_bad": -5.1499,
+      "log_good": -4.9762
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.6316,
+      "good": 4.6633,
+      "ratio": 1.0068,
+      "suggested_scalar": 0.0021,
+      "log_bad": 1.5329,
+      "log_good": 1.5397
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 80.0,
+      "good": 73.0,
+      "ratio": 0.9125,
+      "suggested_scalar": -0.0284,
+      "log_bad": 4.382,
+      "log_good": 4.2905
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.43,
+      "good": 0.3412,
+      "ratio": 0.7935,
+      "suggested_scalar": -0.0719,
+      "log_bad": -0.844,
+      "log_good": -1.0753
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 18.0,
+      "good": 20.0,
+      "ratio": 1.1111,
+      "suggested_scalar": 0.0327,
+      "log_bad": 2.8904,
+      "log_good": 2.9957
+    },
+    "heaps.mean_beta": {
+      "bad": 0.6897,
+      "good": 0.5889,
+      "ratio": 0.8538,
+      "suggested_scalar": -0.0491,
+      "log_bad": -0.3715,
+      "log_good": -0.5295
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.2245,
+      "good": 1.5294,
+      "ratio": 1.249,
+      "suggested_scalar": 0.0691,
+      "log_bad": 0.2025,
+      "log_good": 0.4249
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 347.0,
+      "good": 433.0,
+      "ratio": 1.2478,
+      "suggested_scalar": 0.0688,
+      "log_bad": 5.8493,
+      "log_good": 6.0707
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.1587,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0032,
+      "good": 1.0,
+      "ratio": 312.5,
+      "suggested_scalar": 1.7847,
+      "log_bad": -5.7446,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0612,
+      "good": 1.0,
+      "ratio": 16.3399,
+      "suggested_scalar": 0.8679,
+      "log_bad": -2.7936,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 0.0016,
+      "ratio": 0.0016,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.4378
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9765,
+      "good": 1.0657,
+      "ratio": 1.0913,
+      "suggested_scalar": 0.0272,
+      "log_bad": -0.0238,
+      "log_good": 0.0636
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 100.0,
+      "good": 107.0,
+      "ratio": 1.07,
+      "suggested_scalar": 0.021,
+      "log_bad": 4.6052,
+      "log_good": 4.6728
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 91.0317,
+      "good": 94.0568,
+      "ratio": 1.0332,
+      "suggested_scalar": 0.0102,
+      "log_bad": 4.5112,
+      "log_good": 4.5439
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.6185,
+      "good": 0.6204,
+      "ratio": 1.0031,
+      "suggested_scalar": 0.001,
+      "log_bad": -0.4805,
+      "log_good": -0.4774
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 28.5475,
+      "good": 21.2211,
+      "ratio": 0.7434,
+      "suggested_scalar": -0.0921,
+      "log_bad": 3.3516,
+      "log_good": 3.055
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1583.0,
+      "good": 1843.0,
+      "ratio": 1.1642,
+      "suggested_scalar": 0.0472,
+      "log_bad": 7.3671,
+      "log_good": 7.5191
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0408,
+      "good": 0.098,
+      "ratio": 2.402,
+      "suggested_scalar": 0.2722,
+      "log_bad": -3.1991,
+      "log_good": -2.3228
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.8571,
+      "good": 0.8235,
+      "ratio": 0.9608,
+      "suggested_scalar": -0.0124,
+      "log_bad": -0.1542,
+      "log_good": -0.1942
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 7.0816,
+      "good": 8.4902,
+      "ratio": 1.1989,
+      "suggested_scalar": 0.0564,
+      "log_bad": 1.9575,
+      "log_good": 2.1389
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 0.9496,
+      "good": 1.6609,
+      "ratio": 1.7491,
+      "suggested_scalar": 0.1737,
+      "log_bad": -0.0517,
+      "log_good": 0.5074
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 53.0,
+      "good": 58.0,
+      "ratio": 1.0943,
+      "suggested_scalar": 0.028,
+      "log_bad": 3.9703,
+      "log_good": 4.0604
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9296,
+      "good": 0.9189,
+      "ratio": 0.9885,
+      "suggested_scalar": -0.0036,
+      "log_bad": -0.073,
+      "log_good": -0.0846
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.662,
+      "good": 0.6696,
+      "ratio": 1.0115,
+      "suggested_scalar": 0.0035,
+      "log_bad": -0.4125,
+      "log_good": -0.4011
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.4174,
+      "good": 0.3805,
+      "ratio": 0.9116,
+      "suggested_scalar": -0.0288,
+      "log_bad": -0.8737,
+      "log_good": -0.9663
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.9589,
+      "good": 3.0263,
+      "ratio": 1.0228,
+      "suggested_scalar": 0.007,
+      "log_bad": 1.0848,
+      "log_good": 1.1073
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 345.0,
+      "good": 431.0,
+      "ratio": 1.2493,
+      "suggested_scalar": 0.0691,
+      "log_bad": 5.8435,
+      "log_good": 6.0661
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 13.0,
+      "good": 10.0,
+      "ratio": 0.7692,
+      "suggested_scalar": -0.0815,
+      "log_bad": 2.5649,
+      "log_good": 2.3026
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0548,
+      "good": 0.0416,
+      "ratio": 0.7591,
+      "suggested_scalar": -0.0856,
+      "log_bad": -2.9041,
+      "log_good": -3.1797
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.8074,
+      "good": 5.8826,
+      "ratio": 1.0129,
+      "suggested_scalar": 0.004,
+      "log_bad": 1.7591,
+      "log_good": 1.772
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 20.0,
+      "good": 22.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0296,
+      "log_bad": 2.9957,
+      "log_good": 3.091
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.4599,
+      "good": 1.4494,
+      "ratio": 0.9928,
+      "suggested_scalar": -0.0022,
+      "log_bad": 0.3784,
+      "log_good": 0.3711
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5459,
+      "good": 5.3595,
+      "ratio": 0.9664,
+      "suggested_scalar": -0.0106,
+      "log_bad": 1.7131,
+      "log_good": 1.6789
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7975,
+      "good": 0.7927,
+      "ratio": 0.994,
+      "suggested_scalar": -0.0019,
+      "log_bad": -0.2263,
+      "log_good": -0.2323
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1404,
+      "good": 0.1639,
+      "ratio": 1.1674,
+      "suggested_scalar": 0.0481,
+      "log_bad": -1.9633,
+      "log_good": -1.8085
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 5.343,
+      "good": 4.6066,
+      "ratio": 0.8622,
+      "suggested_scalar": -0.0461,
+      "log_bad": 1.6758,
+      "log_good": 1.5275
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 257.0,
+      "good": 327.0,
+      "ratio": 1.2724,
+      "suggested_scalar": 0.0748,
+      "log_bad": 5.5491,
+      "log_good": 5.79
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 21.0,
+      "good": 27.0,
+      "ratio": 1.2857,
+      "suggested_scalar": 0.0781,
+      "log_bad": 3.0445,
+      "log_good": 3.2958
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7144,
+      "good": 0.8501,
+      "ratio": 1.1899,
+      "suggested_scalar": 0.054,
+      "log_bad": -0.3363,
+      "log_good": -0.1624
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 77.0,
+      "good": 72.0,
+      "ratio": 0.9351,
+      "suggested_scalar": -0.0209,
+      "log_bad": 4.3438,
+      "log_good": 4.2767
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 845.0,
+      "good": 951.0,
+      "ratio": 1.1254,
+      "suggested_scalar": 0.0367,
+      "log_bad": 6.7393,
+      "log_good": 6.8575
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 141.0,
+      "good": 149.0,
+      "ratio": 1.0567,
+      "suggested_scalar": 0.0171,
+      "log_bad": 4.9488,
+      "log_good": 5.0039
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0058,
+      "good": 0.0092,
+      "ratio": 1.5862,
+      "suggested_scalar": 0.1433,
+      "log_bad": -5.1499,
+      "log_good": -4.6886
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2507,
+      "good": 0.2494,
+      "ratio": 0.9948,
+      "suggested_scalar": -0.0016,
+      "log_bad": -1.3835,
+      "log_good": -1.3887
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 72.0,
+      "good": 78.0,
+      "ratio": 1.0833,
+      "suggested_scalar": 0.0249,
+      "log_bad": 4.2767,
+      "log_good": 4.3567
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 77.0,
+      "good": 72.0,
+      "ratio": 0.9351,
+      "suggested_scalar": -0.0209,
+      "log_bad": 4.3438,
+      "log_good": 4.2767
+    },
+    "brevity.mean_sample_size": {
+      "bad": 77.0,
+      "good": 72.0,
+      "ratio": 0.9351,
+      "suggested_scalar": -0.0209,
+      "log_bad": 4.3438,
+      "log_good": 4.2767
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 347.0,
+      "good": 433.0,
+      "ratio": 1.2478,
+      "suggested_scalar": 0.0688,
+      "log_bad": 5.8493,
+      "log_good": 6.0707
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 187.0,
+      "good": 256.0,
+      "ratio": 1.369,
+      "suggested_scalar": 0.0976,
+      "log_bad": 5.2311,
+      "log_good": 5.5452
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 204.0,
+      "good": 242.0,
+      "ratio": 1.1863,
+      "suggested_scalar": 0.0531,
+      "log_bad": 5.3181,
+      "log_good": 5.4889
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0058,
+      "good": 0.0046,
+      "ratio": 0.7931,
+      "suggested_scalar": -0.072,
+      "log_bad": -5.1499,
+      "log_good": -5.3817
+    },
+    "heaps.mean_k": {
+      "bad": 1.5572,
+      "good": 2.2343,
+      "ratio": 1.4348,
+      "suggested_scalar": 0.1122,
+      "log_bad": 0.4429,
+      "log_good": 0.8039
+    },
+    "halstead.mean_effort": {
+      "bad": 68677.6911,
+      "good": 98953.3724,
+      "ratio": 1.4408,
+      "suggested_scalar": 0.1135,
+      "log_bad": 11.1372,
+      "log_good": 11.5024
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.885,
+      "good": 0.8686,
+      "ratio": 0.9815,
+      "suggested_scalar": -0.0058,
+      "log_bad": -0.1222,
+      "log_good": -0.1409
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 55.0,
+      "good": 48.0,
+      "ratio": 0.8727,
+      "suggested_scalar": -0.0423,
+      "log_bad": 4.0073,
+      "log_good": 3.8712
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 198.0,
+      "good": 263.0,
+      "ratio": 1.3283,
+      "suggested_scalar": 0.0882,
+      "log_bad": 5.2883,
+      "log_good": 5.5722
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.43,
+      "good": 0.3271,
+      "ratio": 0.7607,
+      "suggested_scalar": -0.085,
+      "log_bad": -0.844,
+      "log_good": -1.1175
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 8.45,
+      "good": 8.8879,
+      "ratio": 1.0518,
+      "suggested_scalar": 0.0157,
+      "log_bad": 2.1342,
+      "log_good": 2.1847
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1404,
+      "good": 0.1639,
+      "ratio": 1.1674,
+      "suggested_scalar": 0.0481,
+      "log_bad": -1.9633,
+      "log_good": -1.8085
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 5.9294,
+      "good": 5.7082,
+      "ratio": 0.9627,
+      "suggested_scalar": -0.0118,
+      "log_bad": 1.7799,
+      "log_good": 1.7419
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 346.0,
+      "good": 432.0,
+      "ratio": 1.2486,
+      "suggested_scalar": 0.069,
+      "log_bad": 5.8464,
+      "log_good": 6.0684
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2153,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 56.0,
+      "good": 60.0,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.0214,
+      "log_bad": 4.0254,
+      "log_good": 4.0943
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3815.4273,
+      "good": 5497.4096,
+      "ratio": 1.4408,
+      "suggested_scalar": 0.1135,
+      "log_bad": 8.2468,
+      "log_good": 8.612
+    },
+    "readability.mean_total_lines": {
+      "bad": 49.0,
+      "good": 51.0,
+      "ratio": 1.0408,
+      "suggested_scalar": 0.0124,
+      "log_bad": 3.8918,
+      "log_good": 3.9318
+    },
+    "indentation.mean_max_depth": {
+      "bad": 2.0,
+      "good": 4.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.2153,
+      "log_bad": 0.6931,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2143.1336,
+      "good": 2550.2077,
+      "ratio": 1.1899,
+      "suggested_scalar": 0.054,
+      "log_bad": 7.67,
+      "log_good": 7.8439
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 535.0,
+      "good": 609.0,
+      "ratio": 1.1383,
+      "suggested_scalar": 0.0402,
+      "log_bad": 6.2823,
+      "log_good": 6.4118
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.1429,
+      "good": 34.9412,
+      "ratio": 1.122,
+      "suggested_scalar": 0.0358,
+      "log_bad": 3.4386,
+      "log_good": 3.5537
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2839,
+      "good": 1.2312,
+      "ratio": 0.959,
+      "suggested_scalar": -0.013,
+      "log_bad": 0.2499,
+      "log_good": 0.208
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 5.0,
+      "ratio": 1.6667,
+      "suggested_scalar": 0.1587,
+      "log_bad": 1.0986,
+      "log_good": 1.6094
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 14.0,
+      "good": 24.0,
+      "ratio": 1.7143,
+      "suggested_scalar": 0.1674,
+      "log_bad": 2.6391,
+      "log_good": 3.1781
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.3413,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7821,
+      "good": 0.8165,
+      "ratio": 1.044,
+      "suggested_scalar": 0.0134,
+      "log_bad": -0.2458,
+      "log_good": -0.2027
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9828,
+      "good": 0.9806,
+      "ratio": 0.9978,
+      "suggested_scalar": -0.0007,
+      "log_bad": -0.0173,
+      "log_good": -0.0196
+    },
+    "halstead.mean_length": {
+      "bad": 339.0,
+      "good": 412.0,
+      "ratio": 1.2153,
+      "suggested_scalar": 0.0606,
+      "log_bad": 5.826,
+      "log_good": 6.021
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 7.0,
+      "good": 7.6667,
+      "ratio": 1.0952,
+      "suggested_scalar": 0.0283,
+      "log_bad": 1.9459,
+      "log_good": 2.0369
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2668,
+      "good": 6.1699,
+      "ratio": 0.9845,
+      "suggested_scalar": -0.0048,
+      "log_bad": 1.8353,
+      "log_good": 1.8197
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1181,
+      "good": 0.1389,
+      "ratio": 1.1761,
+      "suggested_scalar": 0.0504,
+      "log_bad": -2.1362,
+      "log_good": -1.974
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 32.0455,
+      "good": 38.8021,
+      "ratio": 1.2108,
+      "suggested_scalar": 0.0594,
+      "log_bad": 3.4672,
+      "log_good": 3.6585
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 5.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.2847,
+      "log_bad": 0.6931,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 43.0,
+      "good": 35.0,
+      "ratio": 0.814,
+      "suggested_scalar": -0.064,
+      "log_bad": 3.7612,
+      "log_good": 3.5553
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6471,
+      "good": 0.6777,
+      "ratio": 1.0473,
+      "suggested_scalar": 0.0144,
+      "log_bad": -0.4353,
+      "log_good": -0.3891
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 49.0,
+      "good": 51.0,
+      "ratio": 1.0408,
+      "suggested_scalar": 0.0124,
+      "log_bad": 3.8918,
+      "log_good": 3.9318
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.2153,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 23.0,
+      "good": 23.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.1355,
+      "log_good": 3.1355
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "naming_conventions.test_name_starts_with_verb": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 27.0,
+      "good": 27.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2958,
+      "log_good": 3.2958
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0541,
+      "good": 0.0515,
+      "ratio": 0.9519,
+      "suggested_scalar": -0.0611,
+      "log_bad": -2.9169,
+      "log_good": -2.9662
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.7826,
+      "good": 0.7826,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.2451,
+      "log_good": -0.2451
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0541,
+      "good": 0.0515,
+      "ratio": 0.9519,
+      "suggested_scalar": -0.0611,
+      "log_bad": -2.9169,
+      "log_good": -2.9662
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.4457,
+      "good": 4.4256,
+      "ratio": 0.9955,
+      "suggested_scalar": -0.0056,
+      "log_bad": 1.4919,
+      "log_good": 1.4874
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 75.0,
+      "good": 76.0,
+      "ratio": 1.0133,
+      "suggested_scalar": 0.0164,
+      "log_bad": 4.3175,
+      "log_good": 4.3307
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4225,
+      "good": 0.4373,
+      "ratio": 1.035,
+      "suggested_scalar": 0.0427,
+      "log_bad": -0.8616,
+      "log_good": -0.8271
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 15.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7081,
+      "log_good": 2.7081
+    },
+    "heaps.mean_beta": {
+      "bad": 0.487,
+      "good": 0.4812,
+      "ratio": 0.9881,
+      "suggested_scalar": -0.0149,
+      "log_bad": -0.7195,
+      "log_good": -0.7315
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.3043,
+      "good": 4.3043,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.4596,
+      "log_good": 1.4596
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 444.0,
+      "good": 466.0,
+      "ratio": 1.0495,
+      "suggested_scalar": 0.06,
+      "log_bad": 6.0958,
+      "log_good": 6.1442
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.1336,
+      "good": 1.112,
+      "ratio": 0.9809,
+      "suggested_scalar": -0.0239,
+      "log_bad": 0.1254,
+      "log_good": 0.1062
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 158.0,
+      "good": 173.0,
+      "ratio": 1.0949,
+      "suggested_scalar": 0.1126,
+      "log_bad": 5.0626,
+      "log_good": 5.1533
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 108.7239,
+      "good": 108.5984,
+      "ratio": 0.9988,
+      "suggested_scalar": -0.0014,
+      "log_bad": 4.6888,
+      "log_good": 4.6877
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7585,
+      "good": 0.7677,
+      "ratio": 1.0121,
+      "suggested_scalar": 0.015,
+      "log_bad": -0.2764,
+      "log_good": -0.2644
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 6.4519,
+      "good": 6.2267,
+      "ratio": 0.9651,
+      "suggested_scalar": -0.0441,
+      "log_bad": 1.8644,
+      "log_good": 1.8288
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1676.0,
+      "good": 1804.0,
+      "ratio": 1.0764,
+      "suggested_scalar": 0.0914,
+      "log_bad": 7.4242,
+      "log_good": 7.4978
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0217,
+      "good": 0.1087,
+      "ratio": 5.0092,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.8304,
+      "log_good": -2.2192
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7391,
+      "good": 0.7391,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -0.3023,
+      "log_good": -0.3023
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.6522,
+      "good": 10.1304,
+      "ratio": 1.0495,
+      "suggested_scalar": 0.06,
+      "log_bad": 2.2672,
+      "log_good": 2.3155
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.1248,
+      "good": 3.1248,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.1394,
+      "log_good": 1.1394
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 134.0,
+      "good": 149.0,
+      "ratio": 1.1119,
+      "suggested_scalar": 0.1317,
+      "log_bad": 4.8978,
+      "log_good": 5.0039
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9344,
+      "good": 0.9368,
+      "ratio": 1.0026,
+      "suggested_scalar": 0.0032,
+      "log_bad": -0.0679,
+      "log_good": -0.0653
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 22.0,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.0577,
+      "log_bad": 3.0445,
+      "log_good": 3.091
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6987,
+      "good": 0.709,
+      "ratio": 1.0147,
+      "suggested_scalar": 0.0182,
+      "log_bad": -0.3585,
+      "log_good": -0.3439
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.6448,
+      "good": 0.6509,
+      "ratio": 1.0095,
+      "suggested_scalar": 0.0117,
+      "log_bad": -0.4388,
+      "log_good": -0.4294
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.3188,
+      "good": 3.4362,
+      "ratio": 1.0354,
+      "suggested_scalar": 0.0431,
+      "log_bad": 1.1996,
+      "log_good": 1.2344
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 442.0,
+      "good": 464.0,
+      "ratio": 1.0498,
+      "suggested_scalar": 0.0603,
+      "log_bad": 6.0913,
+      "log_good": 6.1399
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0495,
+      "good": 0.0472,
+      "ratio": 0.9535,
+      "suggested_scalar": -0.0591,
+      "log_bad": -3.0058,
+      "log_good": -3.0534
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.6147,
+      "good": 5.6439,
+      "ratio": 1.0052,
+      "suggested_scalar": 0.0064,
+      "log_bad": 1.7254,
+      "log_good": 1.7306
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.6971,
+      "good": 0.6563,
+      "ratio": 0.9415,
+      "suggested_scalar": -0.0749,
+      "log_bad": -0.3608,
+      "log_good": -0.4211
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.411,
+      "good": 5.5251,
+      "ratio": 1.0211,
+      "suggested_scalar": 0.0259,
+      "log_bad": 1.6884,
+      "log_good": 1.7093
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7918,
+      "good": 0.7841,
+      "ratio": 0.9903,
+      "suggested_scalar": -0.0121,
+      "log_bad": -0.2334,
+      "log_good": -0.2432
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.1481,
+      "good": 0.1481,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.9099,
+      "log_good": -1.9099
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.5401,
+      "good": 2.4953,
+      "ratio": 0.9824,
+      "suggested_scalar": -0.0221,
+      "log_bad": 0.9322,
+      "log_good": 0.9144
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 244.0,
+      "good": 256.0,
+      "ratio": 1.0492,
+      "suggested_scalar": 0.0596,
+      "log_bad": 5.4972,
+      "log_good": 5.5452
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7454,
+      "good": 0.7622,
+      "ratio": 1.0225,
+      "suggested_scalar": 0.0277,
+      "log_bad": -0.2938,
+      "log_good": -0.2715
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 87.0,
+      "good": 92.0,
+      "ratio": 1.0575,
+      "suggested_scalar": 0.0694,
+      "log_bad": 4.4659,
+      "log_good": 4.5218
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 865.0,
+      "good": 949.0,
+      "ratio": 1.0971,
+      "suggested_scalar": 0.115,
+      "log_bad": 6.7627,
+      "log_good": 6.8554
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 151.0,
+      "good": 151.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.0173,
+      "log_good": 5.0173
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0023,
+      "good": 0.0021,
+      "ratio": 0.913,
+      "suggested_scalar": -0.1129,
+      "log_bad": -6.0748,
+      "log_good": -6.1658
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2703,
+      "good": 0.2575,
+      "ratio": 0.9526,
+      "suggested_scalar": -0.0602,
+      "log_bad": -1.3082,
+      "log_good": -1.3567
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 88.0,
+      "good": 97.0,
+      "ratio": 1.1023,
+      "suggested_scalar": 0.1209,
+      "log_bad": 4.4773,
+      "log_good": 4.5747
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 87.0,
+      "good": 92.0,
+      "ratio": 1.0575,
+      "suggested_scalar": 0.0694,
+      "log_bad": 4.4659,
+      "log_good": 4.5218
+    },
+    "brevity.mean_sample_size": {
+      "bad": 87.0,
+      "good": 92.0,
+      "ratio": 1.0575,
+      "suggested_scalar": 0.0694,
+      "log_bad": 4.4659,
+      "log_good": 4.5218
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 444.0,
+      "good": 466.0,
+      "ratio": 1.0495,
+      "suggested_scalar": 0.06,
+      "log_bad": 6.0958,
+      "log_good": 6.1442
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 232.0,
+      "good": 232.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 5.4467,
+      "log_good": 5.4467
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 195.0,
+      "good": 205.0,
+      "ratio": 1.0513,
+      "suggested_scalar": 0.0621,
+      "log_bad": 5.273,
+      "log_good": 5.323
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 4.4414,
+      "good": 4.7352,
+      "ratio": 1.0662,
+      "suggested_scalar": 0.0795,
+      "log_bad": 1.491,
+      "log_good": 1.555
+    },
+    "halstead.mean_effort": {
+      "bad": 65655.7285,
+      "good": 70338.4737,
+      "ratio": 1.0713,
+      "suggested_scalar": 0.0855,
+      "log_bad": 11.0922,
+      "log_good": 11.1611
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8398,
+      "good": 0.8469,
+      "ratio": 1.0085,
+      "suggested_scalar": 0.0104,
+      "log_bad": -0.1746,
+      "log_good": -0.1662
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 54.0,
+      "good": 54.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.989,
+      "log_good": 3.989
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 208.0,
+      "good": 215.0,
+      "ratio": 1.0337,
+      "suggested_scalar": 0.0411,
+      "log_bad": 5.3375,
+      "log_good": 5.3706
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3671,
+      "good": 0.3584,
+      "ratio": 0.9763,
+      "suggested_scalar": -0.0298,
+      "log_bad": -1.0021,
+      "log_good": -1.0261
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.4747,
+      "good": 5.4855,
+      "ratio": 1.002,
+      "suggested_scalar": 0.0024,
+      "log_bad": 1.7001,
+      "log_good": 1.7021
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.1481,
+      "good": 0.1481,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": -1.9099,
+      "log_good": -1.9099
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 3.8609,
+      "good": 4.0522,
+      "ratio": 1.0495,
+      "suggested_scalar": 0.06,
+      "log_bad": 1.3509,
+      "log_good": 1.3993
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 443.0,
+      "good": 465.0,
+      "ratio": 1.0497,
+      "suggested_scalar": 0.0602,
+      "log_bad": 6.0936,
+      "log_good": 6.142
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 9.0,
+      "good": 9.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.1972,
+      "log_good": 2.1972
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 87.0,
+      "good": 94.0,
+      "ratio": 1.0805,
+      "suggested_scalar": 0.0961,
+      "log_bad": 4.4659,
+      "log_good": 4.5433
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 3647.5405,
+      "good": 3907.693,
+      "ratio": 1.0713,
+      "suggested_scalar": 0.0855,
+      "log_bad": 8.2018,
+      "log_good": 8.2707
+    },
+    "readability.mean_total_lines": {
+      "bad": 46.0,
+      "good": 46.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8286,
+      "log_good": 3.8286
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 2236.1459,
+      "good": 2286.7415,
+      "ratio": 1.0226,
+      "suggested_scalar": 0.0278,
+      "log_bad": 7.7125,
+      "log_good": 7.7349
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 505.0,
+      "good": 525.0,
+      "ratio": 1.0396,
+      "suggested_scalar": 0.0482,
+      "log_bad": 6.2246,
+      "log_good": 6.2634
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.2609,
+      "good": 38.0435,
+      "ratio": 1.0789,
+      "suggested_scalar": 0.0943,
+      "log_bad": 3.5628,
+      "log_good": 3.6387
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0439,
+      "good": 1.0396,
+      "ratio": 0.9959,
+      "suggested_scalar": -0.0051,
+      "log_bad": 0.043,
+      "log_good": 0.0388
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 20.0,
+      "good": 20.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9957,
+      "log_good": 2.9957
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6434,
+      "good": 0.6328,
+      "ratio": 0.9835,
+      "suggested_scalar": -0.0206,
+      "log_bad": -0.441,
+      "log_good": -0.4576
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9643,
+      "good": 0.958,
+      "ratio": 0.9935,
+      "suggested_scalar": -0.0081,
+      "log_bad": -0.0364,
+      "log_good": -0.0429
+    },
+    "halstead.mean_length": {
+      "bad": 359.0,
+      "good": 366.0,
+      "ratio": 1.0195,
+      "suggested_scalar": 0.024,
+      "log_bad": 5.8833,
+      "log_good": 5.9026
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4429,
+      "good": 6.5236,
+      "ratio": 1.0125,
+      "suggested_scalar": 0.0155,
+      "log_bad": 1.863,
+      "log_good": 1.8754
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1384,
+      "good": 0.1286,
+      "ratio": 0.9292,
+      "suggested_scalar": -0.0912,
+      "log_bad": -1.9776,
+      "log_good": -2.051
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 29.3611,
+      "good": 30.7593,
+      "ratio": 1.0476,
+      "suggested_scalar": 0.0577,
+      "log_bad": 3.3797,
+      "log_good": 3.4262
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 1.9977,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 58.0,
+      "good": 62.0,
+      "ratio": 1.069,
+      "suggested_scalar": 0.0828,
+      "log_bad": 4.0604,
+      "log_good": 4.1271
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.5487,
+      "good": 0.5268,
+      "ratio": 0.9601,
+      "suggested_scalar": -0.0506,
+      "log_bad": -0.6002,
+      "log_good": -0.6409
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 46.0,
+      "good": 46.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.8286,
+      "log_good": 3.8286
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 16.0,
+      "good": 16.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.7726,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "function_design.uses_default_parameters_over_overloads": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 2.0,
+      "good": 3.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.4167,
+      "log_bad": 0.6931,
+      "log_good": 1.0986
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 7.0,
+      "good": 1.0,
+      "ratio": 0.1429,
+      "suggested_scalar": -2.0,
+      "log_bad": 1.9459,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 3.875,
+      "good": 1.0,
+      "ratio": 0.2581,
+      "suggested_scalar": -1.3922,
+      "log_bad": 1.3545,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8158,
+      "good": 0.8889,
+      "ratio": 1.0896,
+      "suggested_scalar": 0.0882,
+      "log_bad": -0.2036,
+      "log_good": -0.1178
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5723,
+      "good": 4.3834,
+      "ratio": 0.9587,
+      "suggested_scalar": -0.0434,
+      "log_bad": 1.52,
+      "log_good": 1.4778
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 59.0,
+      "good": 58.0,
+      "ratio": 0.9831,
+      "suggested_scalar": -0.0176,
+      "log_bad": 4.0775,
+      "log_good": 4.0604
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.1942,
+      "good": 0.3286,
+      "ratio": 1.6921,
+      "suggested_scalar": 0.5406,
+      "log_bad": -1.6389,
+      "log_good": -1.1129
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "heaps.mean_beta": {
+      "bad": 0.3702,
+      "good": 0.6015,
+      "ratio": 1.6248,
+      "suggested_scalar": 0.4989,
+      "log_bad": -0.9937,
+      "log_good": -0.5083
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 5.4737,
+      "good": 6.4889,
+      "ratio": 1.1855,
+      "suggested_scalar": 0.1749,
+      "log_bad": 1.7,
+      "log_good": 1.8701
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 431.0,
+      "good": 262.0,
+      "ratio": 0.6079,
+      "suggested_scalar": -0.5116,
+      "log_bad": 6.0661,
+      "log_good": 5.5683
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.2293,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0263,
+      "good": 0.0222,
+      "ratio": 0.8441,
+      "suggested_scalar": -0.1742,
+      "log_bad": -3.6382,
+      "log_good": -3.8077
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0017,
+      "good": 0.0014,
+      "ratio": 0.8235,
+      "suggested_scalar": -0.1996,
+      "log_bad": -6.3771,
+      "log_good": -6.5713
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.3122,
+      "good": 1.0273,
+      "ratio": 0.7829,
+      "suggested_scalar": -0.2516,
+      "log_bad": 0.2717,
+      "log_good": 0.0269
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 180.0,
+      "good": 106.0,
+      "ratio": 0.5889,
+      "suggested_scalar": -0.5442,
+      "log_bad": 5.193,
+      "log_good": 4.6634
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 97.7074,
+      "good": 97.2427,
+      "ratio": 0.9952,
+      "suggested_scalar": -0.0049,
+      "log_bad": 4.582,
+      "log_good": 4.5772
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.8581,
+      "good": 0.6705,
+      "ratio": 0.7814,
+      "suggested_scalar": -0.2536,
+      "log_bad": -0.153,
+      "log_good": -0.3997
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 6.7277,
+      "good": 8.1731,
+      "ratio": 1.2148,
+      "suggested_scalar": 0.2,
+      "log_bad": 1.9062,
+      "log_good": 2.1008
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1780.0,
+      "good": 1389.0,
+      "ratio": 0.7803,
+      "suggested_scalar": -0.2549,
+      "log_bad": 7.4844,
+      "log_good": 7.2363
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0263,
+      "good": 0.0222,
+      "ratio": 0.8441,
+      "suggested_scalar": -0.1742,
+      "log_bad": -3.6382,
+      "log_good": -3.8077
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7895,
+      "good": 0.8444,
+      "ratio": 1.0695,
+      "suggested_scalar": 0.0691,
+      "log_bad": -0.2364,
+      "log_good": -0.1691
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 11.3421,
+      "good": 5.8222,
+      "ratio": 0.5133,
+      "suggested_scalar": -0.6854,
+      "log_bad": 2.4285,
+      "log_good": 1.7617
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 6.2493,
+      "good": 13.0054,
+      "ratio": 2.0811,
+      "suggested_scalar": 0.7533,
+      "log_bad": 1.8325,
+      "log_good": 2.5654
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 96.0,
+      "good": 48.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.7124,
+      "log_bad": 4.5643,
+      "log_good": 3.8712
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9199,
+      "good": 0.9343,
+      "ratio": 1.0157,
+      "suggested_scalar": 0.016,
+      "log_bad": -0.0835,
+      "log_good": -0.068
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.764,
+      "good": 0.6782,
+      "ratio": 0.8877,
+      "suggested_scalar": -0.1224,
+      "log_bad": -0.2692,
+      "log_good": -0.3883
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.8112,
+      "good": 0.5038,
+      "ratio": 0.6211,
+      "suggested_scalar": -0.4896,
+      "log_bad": -0.2092,
+      "log_good": -0.6856
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 4.2381,
+      "good": 3.1074,
+      "ratio": 0.7332,
+      "suggested_scalar": -0.319,
+      "log_bad": 1.4441,
+      "log_good": 1.1338
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 429.0,
+      "good": 260.0,
+      "ratio": 0.6061,
+      "suggested_scalar": -0.5147,
+      "log_bad": 6.0615,
+      "log_good": 5.5607
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 14.0,
+      "good": 23.0,
+      "ratio": 1.6429,
+      "suggested_scalar": 0.5102,
+      "log_bad": 2.6391,
+      "log_good": 3.1355
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0928,
+      "good": 0.084,
+      "ratio": 0.9052,
+      "suggested_scalar": -0.1024,
+      "log_bad": -2.3773,
+      "log_good": -2.4769
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.6724,
+      "good": 5.6724,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7356,
+      "log_good": 1.7356
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 66.0,
+      "good": 40.0,
+      "ratio": 0.6061,
+      "suggested_scalar": -0.5147,
+      "log_bad": 4.1897,
+      "log_good": 3.6889
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.3466,
+      "good": 1.4825,
+      "ratio": 1.1009,
+      "suggested_scalar": 0.0988,
+      "log_bad": 0.2976,
+      "log_good": 0.3937
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 4.7247,
+      "good": 5.0977,
+      "ratio": 1.0789,
+      "suggested_scalar": 0.0781,
+      "log_bad": 1.5528,
+      "log_good": 1.6288
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8061,
+      "good": 0.7728,
+      "ratio": 0.9587,
+      "suggested_scalar": -0.0434,
+      "log_bad": -0.2155,
+      "log_good": -0.2577
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2083,
+      "good": 0.0816,
+      "ratio": 0.3917,
+      "suggested_scalar": -0.9632,
+      "log_bad": -1.5688,
+      "log_good": -2.5059
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.5938,
+      "good": 2.8589,
+      "ratio": 1.1022,
+      "suggested_scalar": 0.1,
+      "log_bad": 0.9531,
+      "log_good": 1.0504
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 158.0,
+      "good": 175.0,
+      "ratio": 1.1076,
+      "suggested_scalar": 0.105,
+      "log_bad": 5.0626,
+      "log_good": 5.1648
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 10.0,
+      "good": 6.0,
+      "ratio": 0.6,
+      "suggested_scalar": -0.525,
+      "log_bad": 2.3026,
+      "log_good": 1.7918
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.8393,
+      "good": 0.5077,
+      "ratio": 0.6049,
+      "suggested_scalar": -0.5167,
+      "log_bad": -0.1752,
+      "log_good": -0.6779
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 60.0,
+      "good": 59.0,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0173,
+      "log_bad": 4.0943,
+      "log_good": 4.0775
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1009.0,
+      "good": 693.0,
+      "ratio": 0.6868,
+      "suggested_scalar": -0.3861,
+      "log_bad": 6.9167,
+      "log_good": 6.541
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 188.0,
+      "good": 124.0,
+      "ratio": 0.6596,
+      "suggested_scalar": -0.4277,
+      "log_bad": 5.2364,
+      "log_good": 4.8203
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.3875,
+      "good": 0.3092,
+      "ratio": 0.7979,
+      "suggested_scalar": -0.232,
+      "log_bad": -0.948,
+      "log_good": -1.1738
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 62.0,
+      "good": 55.0,
+      "ratio": 0.8871,
+      "suggested_scalar": -0.1231,
+      "log_bad": 4.1271,
+      "log_good": 4.0073
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 8.0,
+      "good": 2.0,
+      "ratio": 0.25,
+      "suggested_scalar": -1.4248,
+      "log_bad": 2.0794,
+      "log_good": 0.6931
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 60.0,
+      "good": 59.0,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0173,
+      "log_bad": 4.0943,
+      "log_good": 4.0775
+    },
+    "brevity.mean_sample_size": {
+      "bad": 60.0,
+      "good": 59.0,
+      "ratio": 0.9833,
+      "suggested_scalar": -0.0173,
+      "log_bad": 4.0943,
+      "log_good": 4.0775
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 431.0,
+      "good": 262.0,
+      "ratio": 0.6079,
+      "suggested_scalar": -0.5116,
+      "log_bad": 6.0661,
+      "log_good": 5.5683
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 223.0,
+      "good": 129.0,
+      "ratio": 0.5785,
+      "suggested_scalar": -0.5626,
+      "log_bad": 5.4072,
+      "log_good": 4.8598
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 123.0,
+      "good": 141.0,
+      "ratio": 1.1463,
+      "suggested_scalar": 0.1404,
+      "log_bad": 4.8122,
+      "log_good": 4.9488
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 6.4544,
+      "good": 2.4235,
+      "ratio": 0.3755,
+      "suggested_scalar": -1.0068,
+      "log_bad": 1.8648,
+      "log_good": 0.8852
+    },
+    "halstead.mean_effort": {
+      "bad": 95795.2004,
+      "good": 39154.1735,
+      "ratio": 0.4087,
+      "suggested_scalar": -0.9196,
+      "log_bad": 11.47,
+      "log_good": 10.5753
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.7999,
+      "good": 0.8666,
+      "ratio": 1.0834,
+      "suggested_scalar": 0.0823,
+      "log_bad": -0.2233,
+      "log_good": -0.1432
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 42.0,
+      "good": 41.0,
+      "ratio": 0.9762,
+      "suggested_scalar": -0.0248,
+      "log_bad": 3.7377,
+      "log_good": 3.7136
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 240.0,
+      "good": 136.0,
+      "ratio": 0.5667,
+      "suggested_scalar": -0.5838,
+      "log_bad": 5.4806,
+      "log_good": 4.9127
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.2,
+      "good": 0.3302,
+      "ratio": 1.651,
+      "suggested_scalar": 0.5153,
+      "log_bad": -1.6094,
+      "log_good": -1.1081
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.6056,
+      "good": 6.5377,
+      "ratio": 1.1663,
+      "suggested_scalar": 0.1581,
+      "log_bad": 1.7238,
+      "log_good": 1.8776
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2083,
+      "good": 0.0816,
+      "ratio": 0.3917,
+      "suggested_scalar": -0.9632,
+      "log_bad": -1.5688,
+      "log_good": -2.5059
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.7291,
+      "good": 2.3289,
+      "ratio": 0.4925,
+      "suggested_scalar": -0.728,
+      "log_bad": 1.5537,
+      "log_good": 0.8454
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 430.0,
+      "good": 261.0,
+      "ratio": 0.607,
+      "suggested_scalar": -0.5131,
+      "log_bad": 6.0638,
+      "log_good": 5.5645
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 77.0,
+      "good": 46.0,
+      "ratio": 0.5974,
+      "suggested_scalar": -0.5295,
+      "log_bad": 4.3438,
+      "log_good": 3.8286
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 5321.9556,
+      "good": 2175.2319,
+      "ratio": 0.4087,
+      "suggested_scalar": -0.9196,
+      "log_bad": 8.5796,
+      "log_good": 7.6849
+    },
+    "readability.mean_total_lines": {
+      "bad": 38.0,
+      "good": 45.0,
+      "ratio": 1.1842,
+      "suggested_scalar": 0.1738,
+      "log_bad": 3.6376,
+      "log_good": 3.8067
+    },
+    "indentation.mean_max_depth": {
+      "bad": 8.0,
+      "good": 12.0,
+      "ratio": 1.5,
+      "suggested_scalar": 0.4167,
+      "log_bad": 2.0794,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 2517.7712,
+      "good": 1523.0751,
+      "ratio": 0.6049,
+      "suggested_scalar": -0.5166,
+      "log_bad": 7.8311,
+      "log_good": 7.3285
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 420.0,
+      "good": 447.0,
+      "ratio": 1.0643,
+      "suggested_scalar": 0.064,
+      "log_bad": 6.0403,
+      "log_good": 6.1026
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 45.5789,
+      "good": 29.7778,
+      "ratio": 0.6533,
+      "suggested_scalar": -0.4375,
+      "log_bad": 3.8194,
+      "log_good": 3.3938
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1538,
+      "good": 1.2256,
+      "ratio": 1.0622,
+      "suggested_scalar": 0.062,
+      "log_bad": 0.1431,
+      "log_good": 0.2034
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.2293,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 6.0,
+      "good": 7.0,
+      "ratio": 1.1667,
+      "suggested_scalar": 0.1584,
+      "log_bad": 1.7918,
+      "log_good": 1.9459
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.5127,
+      "good": 0.7371,
+      "ratio": 1.4377,
+      "suggested_scalar": 0.3731,
+      "log_bad": -0.6681,
+      "log_good": -0.305
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.861,
+      "good": 0.9475,
+      "ratio": 1.1005,
+      "suggested_scalar": 0.0984,
+      "log_bad": -0.1497,
+      "log_good": -0.0539
+    },
+    "halstead.mean_length": {
+      "bad": 428.0,
+      "good": 260.0,
+      "ratio": 0.6075,
+      "suggested_scalar": -0.5123,
+      "log_bad": 6.0591,
+      "log_good": 5.5607
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 5.25,
+      "good": 16.5,
+      "ratio": 3.1429,
+      "suggested_scalar": 1.177,
+      "log_bad": 1.6582,
+      "log_good": 2.8034
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.8826,
+      "ratio": 0.9959,
+      "suggested_scalar": -0.0042,
+      "log_bad": 1.7761,
+      "log_good": 1.772
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1253,
+      "good": 0.0929,
+      "ratio": 0.7414,
+      "suggested_scalar": -0.3075,
+      "log_bad": -2.077,
+      "log_good": -2.3762
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 38.0476,
+      "good": 25.7073,
+      "ratio": 0.6757,
+      "suggested_scalar": -0.403,
+      "log_bad": 3.6388,
+      "log_good": 3.2468
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 36.0,
+      "good": 35.0,
+      "ratio": 0.9722,
+      "suggested_scalar": -0.029,
+      "log_bad": 3.5835,
+      "log_good": 3.5553
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.4959,
+      "good": 0.6099,
+      "ratio": 1.2299,
+      "suggested_scalar": 0.2127,
+      "log_bad": -0.7014,
+      "log_good": -0.4945
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 38.0,
+      "good": 45.0,
+      "ratio": 1.1842,
+      "suggested_scalar": 0.1738,
+      "log_bad": 3.6376,
+      "log_good": 3.8067
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "code_smells.lambda_not_assigned_to_variable": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 24.0,
+      "good": 44.0,
+      "ratio": 1.8333,
+      "suggested_scalar": 0.5265,
+      "log_bad": 3.1781,
+      "log_good": 3.7842
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0337,
+      "good": 0.0733,
+      "ratio": 2.1751,
+      "suggested_scalar": 0.6749,
+      "log_bad": -3.3903,
+      "log_good": -2.6132
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 0.5,
+      "good": 0.9167,
+      "ratio": 1.8334,
+      "suggested_scalar": 0.5265,
+      "log_bad": -0.6931,
+      "log_good": -0.087
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9063,
+      "good": 0.9556,
+      "ratio": 1.0544,
+      "suggested_scalar": 0.046,
+      "log_bad": -0.0984,
+      "log_good": -0.0454
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0337,
+      "good": 0.0733,
+      "ratio": 2.1751,
+      "suggested_scalar": 0.6749,
+      "log_bad": -3.3903,
+      "log_good": -2.6132
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.7219,
+      "good": 4.6183,
+      "ratio": 0.9781,
+      "suggested_scalar": -0.0193,
+      "log_bad": 1.5522,
+      "log_good": 1.53
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 83.0,
+      "good": 83.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 4.4188,
+      "log_good": 4.4188
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4779,
+      "good": 0.4065,
+      "ratio": 0.8506,
+      "suggested_scalar": -0.1406,
+      "log_bad": -0.7384,
+      "log_good": -0.9002
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 19.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.9444,
+      "log_good": 2.9444
+    },
+    "heaps.mean_beta": {
+      "bad": 0.727,
+      "good": 0.6244,
+      "ratio": 0.8589,
+      "suggested_scalar": -0.1321,
+      "log_bad": -0.3188,
+      "log_good": -0.471
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.5,
+      "good": 3.2889,
+      "ratio": 2.1926,
+      "suggested_scalar": 0.6819,
+      "log_bad": 0.4055,
+      "log_good": 1.1906
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 297.0,
+      "good": 423.0,
+      "ratio": 1.4242,
+      "suggested_scalar": 0.3072,
+      "log_bad": 5.6937,
+      "log_good": 6.0474
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.3522,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0938,
+      "good": 0.0222,
+      "ratio": 0.2367,
+      "suggested_scalar": -1.2517,
+      "log_bad": -2.3666,
+      "log_good": -3.8077
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9072,
+      "good": 1.0175,
+      "ratio": 1.1216,
+      "suggested_scalar": 0.0997,
+      "log_bad": -0.0974,
+      "log_good": 0.0173
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 113.0,
+      "good": 162.0,
+      "ratio": 1.4336,
+      "suggested_scalar": 0.3129,
+      "log_bad": 4.7274,
+      "log_good": 5.0876
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 101.8216,
+      "good": 103.2554,
+      "ratio": 1.0141,
+      "suggested_scalar": 0.0121,
+      "log_bad": 4.6232,
+      "log_good": 4.6372
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.4291,
+      "good": 0.5355,
+      "ratio": 1.248,
+      "suggested_scalar": 0.1924,
+      "log_bad": -0.8461,
+      "log_good": -0.6246
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 14.6193,
+      "good": 13.072,
+      "ratio": 0.8942,
+      "suggested_scalar": -0.0972,
+      "log_bad": 2.6823,
+      "log_good": 2.5705
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1410.0,
+      "good": 1929.0,
+      "ratio": 1.3681,
+      "suggested_scalar": 0.2722,
+      "log_bad": 7.2513,
+      "log_good": 7.5648
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0625,
+      "good": 0.0444,
+      "ratio": 0.7104,
+      "suggested_scalar": -0.297,
+      "log_bad": -2.7726,
+      "log_good": -3.1145
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9063,
+      "good": 0.9556,
+      "ratio": 1.0544,
+      "suggested_scalar": 0.046,
+      "log_bad": -0.0984,
+      "log_good": -0.0454
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 10.2414,
+      "good": 9.6136,
+      "ratio": 0.9387,
+      "suggested_scalar": -0.0549,
+      "log_bad": 2.3264,
+      "log_good": 2.2632
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 6.0,
+      "ratio": 6.0,
+      "suggested_scalar": 1.5563,
+      "log_bad": 0.0,
+      "log_good": 1.7918
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.75,
+      "good": 8.0277,
+      "ratio": 2.1407,
+      "suggested_scalar": 0.6611,
+      "log_bad": 1.3218,
+      "log_good": 2.0829
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 87.0,
+      "good": 118.0,
+      "ratio": 1.3563,
+      "suggested_scalar": 0.2647,
+      "log_bad": 4.4659,
+      "log_good": 4.7707
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 10.0,
+      "ratio": 10.0,
+      "suggested_scalar": 2.0,
+      "log_bad": 0.0,
+      "log_good": 2.3026
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9461,
+      "good": 0.9399,
+      "ratio": 0.9934,
+      "suggested_scalar": -0.0057,
+      "log_bad": -0.0554,
+      "log_good": -0.062
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 27.0,
+      "ratio": 1.0385,
+      "suggested_scalar": 0.0328,
+      "log_bad": 3.2581,
+      "log_good": 3.2958
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.5858,
+      "good": 0.6537,
+      "ratio": 1.1159,
+      "suggested_scalar": 0.0953,
+      "log_bad": -0.5348,
+      "log_good": -0.4251
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.2576,
+      "good": 0.4014,
+      "ratio": 1.5582,
+      "suggested_scalar": 0.3853,
+      "log_bad": -1.3563,
+      "log_good": -0.9128
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.4144,
+      "good": 2.8877,
+      "ratio": 1.196,
+      "suggested_scalar": 0.1555,
+      "log_bad": 0.8815,
+      "log_good": 1.0605
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 295.0,
+      "good": 421.0,
+      "ratio": 1.4271,
+      "suggested_scalar": 0.3089,
+      "log_bad": 5.687,
+      "log_good": 6.0426
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 16.0,
+      "good": 10.0,
+      "ratio": 0.625,
+      "suggested_scalar": -0.4082,
+      "log_bad": 2.7726,
+      "log_good": 2.3026
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0774,
+      "good": 0.0638,
+      "ratio": 0.8243,
+      "suggested_scalar": -0.1678,
+      "log_bad": -2.5588,
+      "log_good": -2.752
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9307,
+      "good": 5.8826,
+      "ratio": 0.9919,
+      "suggested_scalar": -0.0071,
+      "log_bad": 1.7801,
+      "log_good": 1.772
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 25.0,
+      "good": 43.0,
+      "ratio": 1.72,
+      "suggested_scalar": 0.4711,
+      "log_bad": 3.2189,
+      "log_good": 3.7612
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.8323,
+      "good": 0.8863,
+      "ratio": 1.0649,
+      "suggested_scalar": 0.0546,
+      "log_bad": -0.1836,
+      "log_good": -0.1207
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.7564,
+      "good": 5.4615,
+      "ratio": 0.9488,
+      "suggested_scalar": -0.0457,
+      "log_bad": 1.7503,
+      "log_good": 1.6977
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.7962,
+      "good": 0.7851,
+      "ratio": 0.9861,
+      "suggested_scalar": -0.0122,
+      "log_bad": -0.2279,
+      "log_good": -0.2419
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 5.0,
+      "ratio": 5.0,
+      "suggested_scalar": 1.3979,
+      "log_bad": 0.0,
+      "log_good": 1.6094
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.3191,
+      "good": 0.2969,
+      "ratio": 0.9304,
+      "suggested_scalar": -0.0626,
+      "log_bad": -1.1423,
+      "log_good": -1.2144
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.8235,
+      "good": 3.6155,
+      "ratio": 0.9456,
+      "suggested_scalar": -0.0486,
+      "log_bad": 1.3412,
+      "log_good": 1.2852
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 7.0,
+      "ratio": 7.0,
+      "suggested_scalar": 1.6902,
+      "log_bad": 0.0,
+      "log_good": 1.9459
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 4.0,
+      "good": 7.0,
+      "ratio": 1.75,
+      "suggested_scalar": 0.4861,
+      "log_bad": 1.3863,
+      "log_good": 1.9459
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 241.0,
+      "good": 292.0,
+      "ratio": 1.2116,
+      "suggested_scalar": 0.1667,
+      "log_bad": 5.4848,
+      "log_good": 5.6768
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.3522,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5313,
+      "good": 0.6503,
+      "ratio": 1.224,
+      "suggested_scalar": 0.1755,
+      "log_bad": -0.6324,
+      "log_good": -0.4303
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 95.0,
+      "good": 108.0,
+      "ratio": 1.1368,
+      "suggested_scalar": 0.1114,
+      "log_bad": 4.5539,
+      "log_good": 4.6821
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 740.0,
+      "good": 1081.0,
+      "ratio": 1.4608,
+      "suggested_scalar": 0.3292,
+      "log_bad": 6.6067,
+      "log_good": 6.9856
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 114.0,
+      "good": 135.0,
+      "ratio": 1.1842,
+      "suggested_scalar": 0.1469,
+      "log_bad": 4.7362,
+      "log_good": 4.9053
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0067,
+      "good": 0.0284,
+      "ratio": 4.2388,
+      "suggested_scalar": 1.2545,
+      "log_bad": -5.0056,
+      "log_good": -3.5614
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.1751,
+      "good": 0.1962,
+      "ratio": 1.1205,
+      "suggested_scalar": 0.0988,
+      "log_bad": -1.7424,
+      "log_good": -1.6286
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 35.0,
+      "good": 47.0,
+      "ratio": 1.3429,
+      "suggested_scalar": 0.2561,
+      "log_bad": 3.5553,
+      "log_good": 3.8501
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 2.0,
+      "good": 12.0,
+      "ratio": 6.0,
+      "suggested_scalar": 1.5563,
+      "log_bad": 0.6931,
+      "log_good": 2.4849
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 95.0,
+      "good": 108.0,
+      "ratio": 1.1368,
+      "suggested_scalar": 0.1114,
+      "log_bad": 4.5539,
+      "log_good": 4.6821
+    },
+    "brevity.mean_sample_size": {
+      "bad": 95.0,
+      "good": 108.0,
+      "ratio": 1.1368,
+      "suggested_scalar": 0.1114,
+      "log_bad": 4.5539,
+      "log_good": 4.6821
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 297.0,
+      "good": 423.0,
+      "ratio": 1.4242,
+      "suggested_scalar": 0.3072,
+      "log_bad": 5.6937,
+      "log_good": 6.0474
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 138.0,
+      "good": 203.0,
+      "ratio": 1.471,
+      "suggested_scalar": 0.3352,
+      "log_bad": 4.9273,
+      "log_good": 5.3132
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 204.0,
+      "good": 243.0,
+      "ratio": 1.1912,
+      "suggested_scalar": 0.152,
+      "log_bad": 5.3181,
+      "log_good": 5.4931
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0135,
+      "good": 0.0165,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.1743,
+      "log_bad": -4.3051,
+      "log_good": -4.1044
+    },
+    "heaps.mean_k": {
+      "bad": 1.6595,
+      "good": 2.3301,
+      "ratio": 1.4041,
+      "suggested_scalar": 0.2948,
+      "log_bad": 0.5065,
+      "log_good": 0.8459
+    },
+    "halstead.mean_effort": {
+      "bad": 41437.7563,
+      "good": 63486.8547,
+      "ratio": 1.5321,
+      "suggested_scalar": 0.3706,
+      "log_bad": 10.6319,
+      "log_good": 11.0586
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 7.0,
+      "ratio": 7.0,
+      "suggested_scalar": 1.6902,
+      "log_bad": 0.0,
+      "log_good": 1.9459
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8762,
+      "good": 0.8085,
+      "ratio": 0.9227,
+      "suggested_scalar": -0.0698,
+      "log_bad": -0.1322,
+      "log_good": -0.2126
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 57.0,
+      "good": 56.0,
+      "ratio": 0.9825,
+      "suggested_scalar": -0.0154,
+      "log_bad": 4.0431,
+      "log_good": 4.0254
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 136.0,
+      "good": 171.0,
+      "ratio": 1.2574,
+      "suggested_scalar": 0.1989,
+      "log_bad": 4.9127,
+      "log_good": 5.1417
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.4956,
+      "good": 0.3951,
+      "ratio": 0.7972,
+      "suggested_scalar": -0.1968,
+      "log_bad": -0.702,
+      "log_good": -0.9286
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 6.5487,
+      "good": 6.6728,
+      "ratio": 1.019,
+      "suggested_scalar": 0.0163,
+      "log_bad": 1.8793,
+      "log_good": 1.898
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.3191,
+      "good": 0.2969,
+      "ratio": 0.9304,
+      "suggested_scalar": -0.0626,
+      "log_bad": -1.1423,
+      "log_good": -1.2144
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.6229,
+      "good": 4.2246,
+      "ratio": 0.9138,
+      "suggested_scalar": -0.0783,
+      "log_bad": 1.531,
+      "log_good": 1.4409
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 2.0,
+      "ratio": 2.0,
+      "suggested_scalar": 0.6021,
+      "log_bad": 0.0,
+      "log_good": 0.6931
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 296.0,
+      "good": 422.0,
+      "ratio": 1.4257,
+      "suggested_scalar": 0.308,
+      "log_bad": 5.6904,
+      "log_good": 6.045
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.6021,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 22.0,
+      "good": 40.0,
+      "ratio": 1.8182,
+      "suggested_scalar": 0.5193,
+      "log_bad": 3.091,
+      "log_good": 3.6889
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 2302.0976,
+      "good": 3527.0475,
+      "ratio": 1.5321,
+      "suggested_scalar": 0.3706,
+      "log_bad": 7.7416,
+      "log_good": 8.1682
+    },
+    "readability.mean_total_lines": {
+      "bad": 29.0,
+      "good": 44.0,
+      "ratio": 1.5172,
+      "suggested_scalar": 0.3621,
+      "log_bad": 3.3673,
+      "log_good": 3.7842
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 12.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.9542,
+      "log_bad": 1.3863,
+      "log_good": 2.4849
+    },
+    "halstead.mean_volume": {
+      "bad": 1593.7599,
+      "good": 1950.7621,
+      "ratio": 1.224,
+      "suggested_scalar": 0.1756,
+      "log_bad": 7.3739,
+      "log_good": 7.576
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 584.0,
+      "good": 668.0,
+      "ratio": 1.1438,
+      "suggested_scalar": 0.1167,
+      "log_bad": 6.3699,
+      "log_good": 6.5043
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 40.6207,
+      "good": 40.75,
+      "ratio": 1.0032,
+      "suggested_scalar": 0.0028,
+      "log_bad": 3.7043,
+      "log_good": 3.7075
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1184,
+      "good": 1.109,
+      "ratio": 0.9916,
+      "suggested_scalar": -0.0073,
+      "log_bad": 0.1119,
+      "log_good": 0.1035
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 3.0,
+      "good": 2.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.3522,
+      "log_bad": 1.0986,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 6.0,
+      "good": 13.0,
+      "ratio": 2.1667,
+      "suggested_scalar": 0.6716,
+      "log_bad": 1.7918,
+      "log_good": 2.5649
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 3.0,
+      "good": 1.0,
+      "ratio": 0.3333,
+      "suggested_scalar": -0.9542,
+      "log_bad": 1.0986,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.9087,
+      "good": 0.863,
+      "ratio": 0.9497,
+      "suggested_scalar": -0.0448,
+      "log_bad": -0.0957,
+      "log_good": -0.1473
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 5.0,
+      "good": 19.0,
+      "ratio": 3.8,
+      "suggested_scalar": 1.1596,
+      "log_bad": 1.6094,
+      "log_good": 2.9444
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.963,
+      "good": 0.9624,
+      "ratio": 0.9994,
+      "suggested_scalar": -0.0005,
+      "log_bad": -0.0377,
+      "log_good": -0.0383
+    },
+    "halstead.mean_length": {
+      "bad": 250.0,
+      "good": 306.0,
+      "ratio": 1.224,
+      "suggested_scalar": 0.1756,
+      "log_bad": 5.5215,
+      "log_good": 5.7236
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.5,
+      "good": 4.5,
+      "ratio": 0.3913,
+      "suggested_scalar": -0.815,
+      "log_bad": 2.4423,
+      "log_good": 1.5041
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.5699,
+      "good": 6.7549,
+      "ratio": 1.0282,
+      "suggested_scalar": 0.0241,
+      "log_bad": 1.8825,
+      "log_good": 1.9103
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 3.0,
+      "ratio": 3.0,
+      "suggested_scalar": 0.9542,
+      "log_bad": 0.0,
+      "log_good": 1.0986
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0986,
+      "good": 0.1052,
+      "ratio": 1.0669,
+      "suggested_scalar": 0.0563,
+      "log_bad": -2.3167,
+      "log_good": -2.2519
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 26.0,
+      "good": 32.5446,
+      "ratio": 1.2517,
+      "suggested_scalar": 0.195,
+      "log_bad": 3.2581,
+      "log_good": 3.4826
+    },
+    "branching.mean_branch_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 56.0,
+      "good": 64.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.116,
+      "log_bad": 4.0254,
+      "log_good": 4.1589
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.8284,
+      "good": 0.8066,
+      "ratio": 0.9737,
+      "suggested_scalar": -0.0232,
+      "log_bad": -0.1883,
+      "log_good": -0.2149
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 32.0,
+      "good": 45.0,
+      "ratio": 1.4063,
+      "suggested_scalar": 0.2961,
+      "log_bad": 3.4657,
+      "log_good": 3.8067
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 25.0,
+      "good": 25.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2189,
+      "log_good": 3.2189
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "error_handling.no_return_from_ensure": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 20.0,
+      "good": 22.0,
+      "ratio": 1.1,
+      "suggested_scalar": 0.0617,
+      "log_bad": 2.9957,
+      "log_good": 3.091
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0074,
+      "good": 0.0151,
+      "ratio": 2.0405,
+      "suggested_scalar": 0.4616,
+      "log_bad": -4.9063,
+      "log_good": -4.1931
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.6,
+      "good": 1.6,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.47,
+      "log_good": 0.47
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.8409,
+      "good": 0.8444,
+      "ratio": 1.0042,
+      "suggested_scalar": 0.0027,
+      "log_bad": -0.1733,
+      "log_good": -0.1691
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0074,
+      "good": 0.0151,
+      "ratio": 2.0405,
+      "suggested_scalar": 0.4616,
+      "log_bad": -4.9063,
+      "log_good": -4.1931
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5152,
+      "good": 4.5799,
+      "ratio": 1.0143,
+      "suggested_scalar": 0.0092,
+      "log_bad": 1.5074,
+      "log_good": 1.5217
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 79.0,
+      "good": 74.0,
+      "ratio": 0.9367,
+      "suggested_scalar": -0.0423,
+      "log_bad": 4.3694,
+      "log_good": 4.3041
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.5314,
+      "good": 0.4974,
+      "ratio": 0.936,
+      "suggested_scalar": -0.0428,
+      "log_bad": -0.6322,
+      "log_good": -0.6984
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 15.0,
+      "good": 14.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0447,
+      "log_bad": 2.7081,
+      "log_good": 2.6391
+    },
+    "heaps.mean_beta": {
+      "bad": 0.7375,
+      "good": 0.6789,
+      "ratio": 0.9205,
+      "suggested_scalar": -0.0536,
+      "log_bad": -0.3045,
+      "log_good": -0.3873
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 4.1364,
+      "good": 4.0444,
+      "ratio": 0.9778,
+      "suggested_scalar": -0.0146,
+      "log_bad": 1.4198,
+      "log_good": 1.3973
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 272.0,
+      "good": 332.0,
+      "ratio": 1.2206,
+      "suggested_scalar": 0.129,
+      "log_bad": 5.6058,
+      "log_good": 5.8051
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0012,
+      "good": 0.0011,
+      "ratio": 0.9167,
+      "suggested_scalar": -0.0563,
+      "log_bad": -6.7254,
+      "log_good": -6.8124
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 0.0455,
+      "good": 1.0,
+      "ratio": 21.978,
+      "suggested_scalar": 2.0,
+      "log_bad": -3.09,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 0.0006,
+      "good": 0.0005,
+      "ratio": 0.8333,
+      "suggested_scalar": -0.118,
+      "log_bad": -7.4186,
+      "log_good": -7.6009
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9148,
+      "good": 1.0053,
+      "ratio": 1.0989,
+      "suggested_scalar": 0.0611,
+      "log_bad": -0.089,
+      "log_good": 0.0053
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 106.0,
+      "good": 130.0,
+      "ratio": 1.2264,
+      "suggested_scalar": 0.1321,
+      "log_bad": 4.6634,
+      "log_good": 4.8675
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 94.6575,
+      "good": 94.6283,
+      "ratio": 0.9997,
+      "suggested_scalar": -0.0002,
+      "log_bad": 4.5503,
+      "log_good": 4.55
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.5018,
+      "good": 0.5982,
+      "ratio": 1.1921,
+      "suggested_scalar": 0.1137,
+      "log_bad": -0.6896,
+      "log_good": -0.5138
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 31.8812,
+      "good": 30.1882,
+      "ratio": 0.9469,
+      "suggested_scalar": -0.0353,
+      "log_bad": 3.462,
+      "log_good": 3.4075
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1652.0,
+      "good": 1854.0,
+      "ratio": 1.1223,
+      "suggested_scalar": 0.0747,
+      "log_bad": 7.4097,
+      "log_good": 7.5251
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.1818,
+      "good": 0.2444,
+      "ratio": 1.3443,
+      "suggested_scalar": 0.1915,
+      "log_bad": -1.7048,
+      "log_good": -1.4089
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.7955,
+      "good": 0.8,
+      "ratio": 1.0057,
+      "suggested_scalar": 0.0037,
+      "log_bad": -0.2288,
+      "log_good": -0.2231
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 6.4762,
+      "good": 7.3778,
+      "ratio": 1.1392,
+      "suggested_scalar": 0.0844,
+      "log_bad": 1.8681,
+      "log_good": 1.9985
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 3.345,
+      "good": 3.1091,
+      "ratio": 0.9295,
+      "suggested_scalar": -0.0473,
+      "log_bad": 1.2075,
+      "log_good": 1.1343
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 96.0,
+      "good": 117.0,
+      "ratio": 1.2188,
+      "suggested_scalar": 0.128,
+      "log_bad": 4.5643,
+      "log_good": 4.7622
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9442,
+      "good": 0.9452,
+      "ratio": 1.0011,
+      "suggested_scalar": 0.0007,
+      "log_bad": -0.0574,
+      "log_good": -0.0564
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 21.0,
+      "good": 21.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.0445,
+      "log_good": 3.0445
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6471,
+      "good": 0.6699,
+      "ratio": 1.0352,
+      "suggested_scalar": 0.0224,
+      "log_bad": -0.4353,
+      "log_good": -0.4006
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.337,
+      "good": 0.4333,
+      "ratio": 1.2858,
+      "suggested_scalar": 0.1627,
+      "log_bad": -1.0877,
+      "log_good": -0.8363
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.8336,
+      "good": 3.0294,
+      "ratio": 1.0691,
+      "suggested_scalar": 0.0432,
+      "log_bad": 1.0415,
+      "log_good": 1.1084
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 270.0,
+      "good": 330.0,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.1299,
+      "log_bad": 5.5984,
+      "log_good": 5.7991
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 18.0,
+      "good": 22.0,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.1299,
+      "log_bad": 2.8904,
+      "log_good": 3.091
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0588,
+      "good": 0.0392,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.2624,
+      "log_bad": -2.8336,
+      "log_good": -3.2391
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.6147,
+      "good": 5.6147,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7254,
+      "log_good": 1.7254
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 10.0,
+      "good": 13.0,
+      "ratio": 1.3,
+      "suggested_scalar": 0.1698,
+      "log_bad": 2.3026,
+      "log_good": 2.5649
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.4508,
+      "good": 0.469,
+      "ratio": 1.0404,
+      "suggested_scalar": 0.0256,
+      "log_bad": -0.7967,
+      "log_good": -0.7572
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.5673,
+      "good": 5.4905,
+      "ratio": 0.9862,
+      "suggested_scalar": -0.009,
+      "log_bad": 1.7169,
+      "log_good": 1.703
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8042,
+      "good": 0.8157,
+      "ratio": 1.0143,
+      "suggested_scalar": 0.0092,
+      "log_bad": -0.2179,
+      "log_good": -0.2037
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.102,
+      "good": 0.1346,
+      "ratio": 1.3196,
+      "suggested_scalar": 0.1795,
+      "log_bad": -2.2828,
+      "log_good": -2.0054
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 5.6463,
+      "good": 5.4944,
+      "ratio": 0.9731,
+      "suggested_scalar": -0.0177,
+      "log_bad": 1.731,
+      "log_good": 1.7037
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 220.0,
+      "good": 240.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0563,
+      "log_bad": 5.3936,
+      "log_good": 5.4806
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 2.0,
+      "good": 8.0,
+      "ratio": 4.0,
+      "suggested_scalar": 0.8973,
+      "log_bad": 0.6931,
+      "log_good": 2.0794
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.5211,
+      "good": 0.563,
+      "ratio": 1.0804,
+      "suggested_scalar": 0.0501,
+      "log_bad": -0.6518,
+      "log_good": -0.5745
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 88.0,
+      "ratio": 1.0353,
+      "suggested_scalar": 0.0224,
+      "log_bad": 4.4427,
+      "log_good": 4.4773
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1047.0,
+      "good": 1237.0,
+      "ratio": 1.1815,
+      "suggested_scalar": 0.1079,
+      "log_bad": 6.9537,
+      "log_good": 7.1204
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 109.0,
+      "good": 107.0,
+      "ratio": 0.9817,
+      "suggested_scalar": -0.012,
+      "log_bad": 4.6913,
+      "log_good": 4.6728
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0074,
+      "good": 0.009,
+      "ratio": 1.2162,
+      "suggested_scalar": 0.1267,
+      "log_bad": -4.9063,
+      "log_good": -4.7105
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.3088,
+      "good": 0.2922,
+      "ratio": 0.9462,
+      "suggested_scalar": -0.0358,
+      "log_bad": -1.1751,
+      "log_good": -1.2303
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 50.0,
+      "good": 60.0,
+      "ratio": 1.2,
+      "suggested_scalar": 0.118,
+      "log_bad": 3.912,
+      "log_good": 4.0943
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 5.0,
+      "good": 5.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.6094,
+      "log_good": 1.6094
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 88.0,
+      "ratio": 1.0353,
+      "suggested_scalar": 0.0224,
+      "log_bad": 4.4427,
+      "log_good": 4.4773
+    },
+    "brevity.mean_sample_size": {
+      "bad": 85.0,
+      "good": 88.0,
+      "ratio": 1.0353,
+      "suggested_scalar": 0.0224,
+      "log_bad": 4.4427,
+      "log_good": 4.4773
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 272.0,
+      "good": 332.0,
+      "ratio": 1.2206,
+      "suggested_scalar": 0.129,
+      "log_bad": 5.6058,
+      "log_good": 5.8051
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 127.0,
+      "good": 168.0,
+      "ratio": 1.3228,
+      "suggested_scalar": 0.1811,
+      "log_bad": 4.8442,
+      "log_good": 5.124
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 185.0,
+      "good": 193.0,
+      "ratio": 1.0432,
+      "suggested_scalar": 0.0274,
+      "log_bad": 5.2204,
+      "log_good": 5.2627
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 1.4316,
+      "good": 1.7905,
+      "ratio": 1.2507,
+      "suggested_scalar": 0.1448,
+      "log_bad": 0.3588,
+      "log_good": 0.5825
+    },
+    "halstead.mean_effort": {
+      "bad": 30848.964,
+      "good": 35803.0051,
+      "ratio": 1.1606,
+      "suggested_scalar": 0.0964,
+      "log_bad": 10.3369,
+      "log_good": 10.4858
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8686,
+      "good": 0.85,
+      "ratio": 0.9786,
+      "suggested_scalar": -0.014,
+      "log_bad": -0.1409,
+      "log_good": -0.1625
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 58.0,
+      "good": 53.0,
+      "ratio": 0.9138,
+      "suggested_scalar": -0.0583,
+      "log_bad": 4.0604,
+      "log_good": 3.9703
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 139.0,
+      "good": 165.0,
+      "ratio": 1.1871,
+      "suggested_scalar": 0.111,
+      "log_bad": 4.9345,
+      "log_good": 5.1059
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.5283,
+      "good": 0.4538,
+      "ratio": 0.859,
+      "suggested_scalar": -0.0984,
+      "log_bad": -0.6381,
+      "log_good": -0.7901
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 9.8774,
+      "good": 9.5154,
+      "ratio": 0.9634,
+      "suggested_scalar": -0.0242,
+      "log_bad": 2.2902,
+      "log_good": 2.2529
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.102,
+      "good": 0.1346,
+      "ratio": 1.3196,
+      "suggested_scalar": 0.1795,
+      "log_bad": -2.2828,
+      "log_good": -2.0054
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.7974,
+      "good": 5.1462,
+      "ratio": 1.0727,
+      "suggested_scalar": 0.0454,
+      "log_bad": 1.5681,
+      "log_good": 1.6383
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 271.0,
+      "good": 331.0,
+      "ratio": 1.2214,
+      "suggested_scalar": 0.1294,
+      "log_bad": 5.6021,
+      "log_good": 5.8021
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 4.0,
+      "good": 10.0,
+      "ratio": 2.5,
+      "suggested_scalar": 0.5931,
+      "log_bad": 1.3863,
+      "log_good": 2.3026
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 41.0,
+      "good": 53.0,
+      "ratio": 1.2927,
+      "suggested_scalar": 0.1662,
+      "log_bad": 3.7136,
+      "log_good": 3.9703
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 1713.8313,
+      "good": 1989.0558,
+      "ratio": 1.1606,
+      "suggested_scalar": 0.0964,
+      "log_bad": 7.4465,
+      "log_good": 7.5954
+    },
+    "readability.mean_total_lines": {
+      "bad": 42.0,
+      "good": 45.0,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.0447,
+      "log_bad": 3.7377,
+      "log_good": 3.8067
+    },
+    "indentation.mean_max_depth": {
+      "bad": 6.0,
+      "good": 6.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.7918,
+      "log_good": 1.7918
+    },
+    "halstead.mean_volume": {
+      "bad": 1563.3376,
+      "good": 1688.9713,
+      "ratio": 1.0804,
+      "suggested_scalar": 0.05,
+      "log_bad": 7.3546,
+      "log_good": 7.4319
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 583.0,
+      "good": 612.0,
+      "ratio": 1.0497,
+      "suggested_scalar": 0.0314,
+      "log_bad": 6.3682,
+      "log_good": 6.4167
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 35.2381,
+      "good": 40.0444,
+      "ratio": 1.1364,
+      "suggested_scalar": 0.0828,
+      "log_bad": 3.5621,
+      "log_good": 3.69
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.2483,
+      "good": 1.2378,
+      "ratio": 0.9916,
+      "suggested_scalar": -0.0055,
+      "log_bad": 0.2218,
+      "log_good": 0.2133
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 22.0,
+      "good": 31.0,
+      "ratio": 1.4091,
+      "suggested_scalar": 0.222,
+      "log_bad": 3.091,
+      "log_good": 3.434
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 2.0,
+      "good": 1.0,
+      "ratio": 0.5,
+      "suggested_scalar": -0.4486,
+      "log_bad": 0.6931,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.8136,
+      "good": 0.7792,
+      "ratio": 0.9577,
+      "suggested_scalar": -0.028,
+      "log_bad": -0.2063,
+      "log_good": -0.2495
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9889,
+      "good": 0.9902,
+      "ratio": 1.0013,
+      "suggested_scalar": 0.0009,
+      "log_bad": -0.0112,
+      "log_good": -0.0098
+    },
+    "halstead.mean_length": {
+      "bad": 248.0,
+      "good": 272.0,
+      "ratio": 1.0968,
+      "suggested_scalar": 0.0598,
+      "log_bad": 5.5134,
+      "log_good": 5.6058
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.6,
+      "good": 10.2,
+      "ratio": 1.0625,
+      "suggested_scalar": 0.0392,
+      "log_bad": 2.2618,
+      "log_good": 2.3224
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4094,
+      "good": 6.4594,
+      "ratio": 1.0078,
+      "suggested_scalar": 0.005,
+      "log_bad": 1.8578,
+      "log_good": 1.8655
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.0769,
+      "good": 0.0906,
+      "ratio": 1.1782,
+      "suggested_scalar": 0.1061,
+      "log_bad": -2.5652,
+      "log_good": -2.4013
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 19.7328,
+      "good": 21.1981,
+      "ratio": 1.0743,
+      "suggested_scalar": 0.0464,
+      "log_bad": 2.9823,
+      "log_good": 3.0539
+    },
+    "branching.mean_branch_count": {
+      "bad": 8.0,
+      "good": 11.0,
+      "ratio": 1.375,
+      "suggested_scalar": 0.2061,
+      "log_bad": 2.0794,
+      "log_good": 2.3979
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 56.0,
+      "good": 59.0,
+      "ratio": 1.0536,
+      "suggested_scalar": 0.0338,
+      "log_bad": 4.0254,
+      "log_good": 4.0775
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.7297,
+      "good": 0.6891,
+      "ratio": 0.9444,
+      "suggested_scalar": -0.0371,
+      "log_bad": -0.3151,
+      "log_good": -0.3724
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 44.0,
+      "good": 45.0,
+      "ratio": 1.0227,
+      "suggested_scalar": 0.0145,
+      "log_bad": 3.7842,
+      "log_good": 3.8067
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 30.0,
+      "good": 30.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.4012,
+      "log_good": 3.4012
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "scope_and_assignment.reassigned_multiple_times": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 28.0,
+      "good": 32.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.328,
+      "log_bad": 3.3322,
+      "log_good": 3.4657
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.0161,
+      "good": 0.0197,
+      "ratio": 1.2236,
+      "suggested_scalar": 0.4958,
+      "log_bad": -4.1289,
+      "log_good": -3.9271
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.9333,
+      "good": 0.9268,
+      "ratio": 0.993,
+      "suggested_scalar": -0.0172,
+      "log_bad": -0.069,
+      "log_good": -0.076
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.0161,
+      "good": 0.0197,
+      "ratio": 1.2236,
+      "suggested_scalar": 0.4958,
+      "log_bad": -4.1289,
+      "log_good": -3.9271
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.5868,
+      "good": 4.7519,
+      "ratio": 1.036,
+      "suggested_scalar": 0.0869,
+      "log_bad": 1.5232,
+      "log_good": 1.5585
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 79.0,
+      "good": 80.0,
+      "ratio": 1.0127,
+      "suggested_scalar": 0.0309,
+      "log_bad": 4.3694,
+      "log_good": 4.382
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.2911,
+      "good": 0.4292,
+      "ratio": 1.4744,
+      "suggested_scalar": 0.9538,
+      "log_bad": -1.2341,
+      "log_good": -0.8458
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 13.0,
+      "good": 13.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.5649,
+      "log_good": 2.5649
+    },
+    "heaps.mean_beta": {
+      "bad": 0.5065,
+      "good": 0.5558,
+      "ratio": 1.0973,
+      "suggested_scalar": 0.2282,
+      "log_bad": -0.6802,
+      "log_good": -0.5873
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 3.3333,
+      "good": 3.2683,
+      "ratio": 0.9805,
+      "suggested_scalar": -0.0484,
+      "log_bad": 1.204,
+      "log_good": 1.1843
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 558.0,
+      "good": 458.0,
+      "ratio": 0.8208,
+      "suggested_scalar": -0.4852,
+      "log_bad": 6.3244,
+      "log_good": 6.1269
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_exponent": {
+      "bad": 1.2601,
+      "good": 1.1439,
+      "ratio": 0.9078,
+      "suggested_scalar": -0.2377,
+      "log_bad": 0.2312,
+      "log_good": 0.1344
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 207.0,
+      "good": 151.0,
+      "ratio": 0.7295,
+      "suggested_scalar": -0.7749,
+      "log_bad": 5.3327,
+      "log_good": 5.0173
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 105.6521,
+      "good": 99.49,
+      "ratio": 0.9417,
+      "suggested_scalar": -0.1476,
+      "log_bad": 4.6602,
+      "log_good": 4.6001
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7469,
+      "good": 0.6171,
+      "ratio": 0.8262,
+      "suggested_scalar": -0.469,
+      "log_bad": -0.2918,
+      "log_good": -0.4827
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 5.7291,
+      "good": 11.1914,
+      "ratio": 1.9534,
+      "suggested_scalar": 1.645,
+      "log_bad": 1.7456,
+      "log_good": 2.4151
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1920.0,
+      "good": 1579.0,
+      "ratio": 0.8224,
+      "suggested_scalar": -0.4804,
+      "log_bad": 7.5601,
+      "log_good": 7.3645
+    },
+    "branching.mean_branching_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.9111,
+      "good": 0.9024,
+      "ratio": 0.9905,
+      "suggested_scalar": -0.0236,
+      "log_bad": -0.0931,
+      "log_good": -0.1027
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 12.4,
+      "good": 11.1707,
+      "ratio": 0.9009,
+      "suggested_scalar": -0.2565,
+      "log_bad": 2.5177,
+      "log_good": 2.4133
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 1.2444,
+      "good": 1.3183,
+      "ratio": 1.0594,
+      "suggested_scalar": 0.1417,
+      "log_bad": 0.2187,
+      "log_good": 0.2763
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 161.0,
+      "good": 111.0,
+      "ratio": 0.6894,
+      "suggested_scalar": -0.9136,
+      "log_bad": 5.0814,
+      "log_good": 4.7095
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.937,
+      "good": 0.9403,
+      "ratio": 1.0035,
+      "suggested_scalar": 0.0086,
+      "log_bad": -0.0651,
+      "log_good": -0.0616
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 17.0,
+      "good": 16.0,
+      "ratio": 0.9412,
+      "suggested_scalar": -0.1489,
+      "log_bad": 2.8332,
+      "log_good": 2.7726
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6896,
+      "good": 0.6194,
+      "ratio": 0.8982,
+      "suggested_scalar": -0.2638,
+      "log_bad": -0.3716,
+      "log_good": -0.479
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.6151,
+      "good": 0.4452,
+      "ratio": 0.7238,
+      "suggested_scalar": -0.7942,
+      "log_bad": -0.486,
+      "log_good": -0.8092
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 3.2215,
+      "good": 2.6273,
+      "ratio": 0.8156,
+      "suggested_scalar": -0.5009,
+      "log_bad": 1.1698,
+      "log_good": 0.966
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 556.0,
+      "good": 456.0,
+      "ratio": 0.8201,
+      "suggested_scalar": -0.4871,
+      "log_bad": 6.3208,
+      "log_good": 6.1225
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 12.0,
+      "good": 12.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.4849,
+      "log_good": 2.4849
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0018,
+      "good": 0.0022,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.493,
+      "log_bad": -6.32,
+      "log_good": -6.1193
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.7004,
+      "good": 5.7549,
+      "ratio": 1.0096,
+      "suggested_scalar": 0.0234,
+      "log_bad": 1.7405,
+      "log_good": 1.7501
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 46.0,
+      "good": 40.0,
+      "ratio": 0.8696,
+      "suggested_scalar": -0.3434,
+      "log_bad": 3.8286,
+      "log_good": 3.6889
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 0.7642,
+      "good": 0.8341,
+      "ratio": 1.0915,
+      "suggested_scalar": 0.215,
+      "log_bad": -0.2689,
+      "log_good": -0.1814
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 4.9413,
+      "good": 5.0498,
+      "ratio": 1.022,
+      "suggested_scalar": 0.0534,
+      "log_bad": 1.5976,
+      "log_good": 1.6193
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8046,
+      "good": 0.8257,
+      "ratio": 1.0262,
+      "suggested_scalar": 0.0636,
+      "log_bad": -0.2174,
+      "log_good": -0.1915
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.0816,
+      "good": 0.1277,
+      "ratio": 1.565,
+      "suggested_scalar": 1.1002,
+      "log_bad": -2.5059,
+      "log_good": -2.0581
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 2.3936,
+      "good": 3.3453,
+      "ratio": 1.3976,
+      "suggested_scalar": 0.8224,
+      "log_bad": 0.8728,
+      "log_good": 1.2076
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 293.0,
+      "good": 288.0,
+      "ratio": 0.9829,
+      "suggested_scalar": -0.0423,
+      "log_bad": 5.6802,
+      "log_good": 5.663
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 1.1263,
+      "good": 0.9209,
+      "ratio": 0.8176,
+      "suggested_scalar": -0.4946,
+      "log_bad": 0.1189,
+      "log_good": -0.0824
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 86.0,
+      "ratio": 1.0118,
+      "suggested_scalar": 0.0287,
+      "log_bad": 4.4427,
+      "log_good": 4.4543
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 1085.0,
+      "good": 902.0,
+      "ratio": 0.8313,
+      "suggested_scalar": -0.4538,
+      "log_bad": 6.9893,
+      "log_good": 6.8046
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 239.0,
+      "good": 165.0,
+      "ratio": 0.6904,
+      "suggested_scalar": -0.9103,
+      "log_bad": 5.4765,
+      "log_good": 5.1059
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.3351,
+      "good": 0.2904,
+      "ratio": 0.8666,
+      "suggested_scalar": -0.3517,
+      "log_bad": -1.0933,
+      "log_good": -1.2365
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 71.0,
+      "good": 44.0,
+      "ratio": 0.6197,
+      "suggested_scalar": -1.1755,
+      "log_bad": 4.2627,
+      "log_good": 3.7842
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 85.0,
+      "good": 86.0,
+      "ratio": 1.0118,
+      "suggested_scalar": 0.0287,
+      "log_bad": 4.4427,
+      "log_good": 4.4543
+    },
+    "brevity.mean_sample_size": {
+      "bad": 85.0,
+      "good": 86.0,
+      "ratio": 1.0118,
+      "suggested_scalar": 0.0287,
+      "log_bad": 4.4427,
+      "log_good": 4.4543
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 558.0,
+      "good": 458.0,
+      "ratio": 0.8208,
+      "suggested_scalar": -0.4852,
+      "log_bad": 6.3244,
+      "log_good": 6.1269
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 299.0,
+      "good": 275.0,
+      "ratio": 0.9197,
+      "suggested_scalar": -0.2056,
+      "log_bad": 5.7004,
+      "log_good": 5.6168
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 212.0,
+      "good": 219.0,
+      "ratio": 1.033,
+      "suggested_scalar": 0.0798,
+      "log_bad": 5.3566,
+      "log_good": 5.3891
+    },
+    "magic_number_density.mean_density": {
+      "bad": 0.0018,
+      "good": 0.0022,
+      "ratio": 1.2222,
+      "suggested_scalar": 0.493,
+      "log_bad": -6.32,
+      "log_good": -6.1193
+    },
+    "heaps.mean_k": {
+      "bad": 3.59,
+      "good": 3.0633,
+      "ratio": 0.8533,
+      "suggested_scalar": -0.3898,
+      "log_bad": 1.2782,
+      "log_good": 1.1195
+    },
+    "halstead.mean_effort": {
+      "bad": 110711.0645,
+      "good": 56980.3282,
+      "ratio": 0.5147,
+      "suggested_scalar": -1.6318,
+      "log_bad": 11.6147,
+      "log_good": 10.9505
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.7709,
+      "good": 0.7858,
+      "ratio": 1.0193,
+      "suggested_scalar": 0.047,
+      "log_bad": -0.2602,
+      "log_good": -0.2411
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 62.0,
+      "good": 64.0,
+      "ratio": 1.0323,
+      "suggested_scalar": 0.078,
+      "log_bad": 4.1271,
+      "log_good": 4.1589
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 297.0,
+      "good": 272.0,
+      "ratio": 0.9158,
+      "suggested_scalar": -0.216,
+      "log_bad": 5.6937,
+      "log_good": 5.6058
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.2754,
+      "good": 0.3974,
+      "ratio": 1.443,
+      "suggested_scalar": 0.9009,
+      "log_bad": -1.2895,
+      "log_good": -0.9228
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.2415,
+      "good": 5.9735,
+      "ratio": 1.1397,
+      "suggested_scalar": 0.3212,
+      "log_bad": 1.6566,
+      "log_good": 1.7873
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.0816,
+      "good": 0.1277,
+      "ratio": 1.565,
+      "suggested_scalar": 1.1002,
+      "log_bad": -2.5059,
+      "log_good": -2.0581
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.96,
+      "good": 4.4683,
+      "ratio": 0.9009,
+      "suggested_scalar": -0.2565,
+      "log_bad": 1.6014,
+      "log_good": 1.497
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 557.0,
+      "good": 457.0,
+      "ratio": 0.8205,
+      "suggested_scalar": -0.4861,
+      "log_bad": 6.3226,
+      "log_good": 6.1247
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 79.0,
+      "good": 35.0,
+      "ratio": 0.443,
+      "suggested_scalar": -2.0,
+      "log_bad": 4.3694,
+      "log_good": 3.5553
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 6150.6147,
+      "good": 3165.5738,
+      "ratio": 0.5147,
+      "suggested_scalar": -1.6318,
+      "log_bad": 8.7243,
+      "log_good": 8.0601
+    },
+    "readability.mean_total_lines": {
+      "bad": 45.0,
+      "good": 41.0,
+      "ratio": 0.9111,
+      "suggested_scalar": -0.2287,
+      "log_bad": 3.8067,
+      "log_good": 3.7136
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 3378.8265,
+      "good": 2762.6826,
+      "ratio": 0.8176,
+      "suggested_scalar": -0.4946,
+      "log_bad": 8.1253,
+      "log_good": 7.924
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 596.0,
+      "good": 601.0,
+      "ratio": 1.0084,
+      "suggested_scalar": 0.0205,
+      "log_bad": 6.3902,
+      "log_good": 6.3986
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 41.5333,
+      "good": 37.3171,
+      "ratio": 0.8985,
+      "suggested_scalar": -0.263,
+      "log_bad": 3.7265,
+      "log_good": 3.6195
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.0472,
+      "good": 1.1348,
+      "ratio": 1.0837,
+      "suggested_scalar": 0.1974,
+      "log_bad": 0.0461,
+      "log_good": 0.1265
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 67.0,
+      "good": 55.0,
+      "ratio": 0.8209,
+      "suggested_scalar": -0.4849,
+      "log_bad": 4.2047,
+      "log_good": 4.0073
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.7304,
+      "good": 0.8785,
+      "ratio": 1.2028,
+      "suggested_scalar": 0.4536,
+      "log_bad": -0.3142,
+      "log_good": -0.1295
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9654,
+      "good": 0.9792,
+      "ratio": 1.0143,
+      "suggested_scalar": 0.0349,
+      "log_bad": -0.0352,
+      "log_good": -0.021
+    },
+    "halstead.mean_length": {
+      "bad": 536.0,
+      "good": 437.0,
+      "ratio": 0.8153,
+      "suggested_scalar": -0.5017,
+      "log_bad": 6.2841,
+      "log_good": 6.0799
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 11.0,
+      "good": 10.5,
+      "ratio": 0.9545,
+      "suggested_scalar": -0.1143,
+      "log_bad": 2.3979,
+      "log_good": 2.3514
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.4094,
+      "good": 6.4263,
+      "ratio": 1.0026,
+      "suggested_scalar": 0.0065,
+      "log_bad": 1.8578,
+      "log_good": 1.8604
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1559,
+      "good": 0.1744,
+      "ratio": 1.1187,
+      "suggested_scalar": 0.2755,
+      "log_bad": -1.8585,
+      "log_good": -1.7464
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 32.7661,
+      "good": 20.625,
+      "ratio": 0.6295,
+      "suggested_scalar": -1.1372,
+      "log_bad": 3.4894,
+      "log_good": 3.0265
+    },
+    "branching.mean_branch_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 57.0,
+      "good": 60.0,
+      "ratio": 1.0526,
+      "suggested_scalar": 0.126,
+      "log_bad": 4.0431,
+      "log_good": 4.0943
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.6651,
+      "good": 0.7991,
+      "ratio": 1.2015,
+      "suggested_scalar": 0.4509,
+      "log_bad": -0.4078,
+      "log_good": -0.2243
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 45.0,
+      "good": 41.0,
+      "ratio": 0.9111,
+      "suggested_scalar": -0.2287,
+      "log_bad": 3.8067,
+      "log_good": 3.7136
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 14.0,
+      "good": 16.0,
+      "ratio": 1.1429,
+      "suggested_scalar": 0.328,
+      "log_bad": 2.6391,
+      "log_good": 2.7726
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  },
+  "type_and_value.no_explicit_any": {
+    "casing_entropy.mean_camel_case_count": {
+      "bad": 18.0,
+      "good": 18.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8904,
+      "log_good": 2.8904
+    },
+    "near_duplicate_blocks_file.mean_sub_block_count": {
+      "bad": 14.0,
+      "good": 14.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.6391,
+      "log_good": 2.6391
+    },
+    "function_metrics.mean_max_param_count": {
+      "bad": 2.0,
+      "good": 2.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.6931,
+      "log_good": 0.6931
+    },
+    "magic_number_density.mean_string_literal_ratio": {
+      "bad": 0.022,
+      "good": 0.028,
+      "ratio": 1.2727,
+      "suggested_scalar": 0.0708,
+      "log_bad": -3.8167,
+      "log_good": -3.5756
+    },
+    "function_metrics.mean_avg_param_count": {
+      "bad": 1.1667,
+      "good": 1.25,
+      "ratio": 1.0714,
+      "suggested_scalar": 0.0202,
+      "log_bad": 0.1542,
+      "log_good": 0.2231
+    },
+    "compression.mean_unique_line_ratio": {
+      "bad": 0.6977,
+      "good": 0.6885,
+      "ratio": 0.9868,
+      "suggested_scalar": -0.0039,
+      "log_bad": -0.36,
+      "log_good": -0.3732
+    },
+    "line_patterns.mean_string_literal_ratio": {
+      "bad": 0.022,
+      "good": 0.028,
+      "ratio": 1.2727,
+      "suggested_scalar": 0.0708,
+      "log_bad": -3.8167,
+      "log_good": -3.5756
+    },
+    "entropy.mean_char_entropy": {
+      "bad": 4.8977,
+      "good": 4.8748,
+      "ratio": 0.9953,
+      "suggested_scalar": -0.0014,
+      "log_bad": 1.5888,
+      "log_good": 1.5841
+    },
+    "halstead.mean_vocabulary": {
+      "bad": 74.0,
+      "good": 81.0,
+      "ratio": 1.0946,
+      "suggested_scalar": 0.0265,
+      "log_bad": 4.3041,
+      "log_good": 4.3944
+    },
+    "vocabulary.mean_mattr": {
+      "bad": 0.4308,
+      "good": 0.4016,
+      "ratio": 0.9322,
+      "suggested_scalar": -0.0206,
+      "log_bad": -0.8421,
+      "log_good": -0.9123
+    },
+    "symbol_density.mean_distinct_symbol_types": {
+      "bad": 19.0,
+      "good": 21.0,
+      "ratio": 1.1053,
+      "suggested_scalar": 0.0294,
+      "log_bad": 2.9444,
+      "log_good": 3.0445
+    },
+    "heaps.mean_beta": {
+      "bad": 0.4593,
+      "good": 0.6551,
+      "ratio": 1.4263,
+      "suggested_scalar": 0.1042,
+      "log_bad": -0.7781,
+      "log_good": -0.423
+    },
+    "indentation.mean_mean_depth": {
+      "bad": 1.9535,
+      "good": 1.8033,
+      "ratio": 0.9231,
+      "suggested_scalar": -0.0235,
+      "log_bad": 0.6696,
+      "log_good": 0.5896
+    },
+    "zipf.mean_total_tokens": {
+      "bad": 410.0,
+      "good": 464.0,
+      "ratio": 1.1317,
+      "suggested_scalar": 0.0363,
+      "log_bad": 6.0162,
+      "log_good": 6.1399
+    },
+    "line_patterns.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0655,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "brevity.mean_slope": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_exclamation_density": {
+      "bad": 0.0029,
+      "good": 0.0017,
+      "ratio": 0.5862,
+      "suggested_scalar": -0.1568,
+      "log_bad": -5.843,
+      "log_good": -6.3771
+    },
+    "comment_structure.mean_comment_line_ratio": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_question_mark_density": {
+      "bad": 1.0,
+      "good": 0.0011,
+      "ratio": 0.0011,
+      "suggested_scalar": -2.0,
+      "log_bad": 0.0,
+      "log_good": -6.8124
+    },
+    "zipf.mean_exponent": {
+      "bad": 0.9986,
+      "good": 0.9746,
+      "ratio": 0.976,
+      "suggested_scalar": -0.0071,
+      "log_bad": -0.0014,
+      "log_good": -0.0257
+    },
+    "vocabulary.mean_total_identifiers": {
+      "bad": 111.0,
+      "good": 136.0,
+      "ratio": 1.2252,
+      "suggested_scalar": 0.0596,
+      "log_bad": 4.7095,
+      "log_good": 4.9127
+    },
+    "readability.mean_flesch_adapted": {
+      "bad": 100.9246,
+      "good": 99.6875,
+      "ratio": 0.9877,
+      "suggested_scalar": -0.0036,
+      "log_bad": 4.6144,
+      "log_good": 4.602
+    },
+    "ngram.mean_bigram_repetition_rate": {
+      "bad": 0.7506,
+      "good": 0.7689,
+      "ratio": 1.0244,
+      "suggested_scalar": 0.0071,
+      "log_bad": -0.2869,
+      "log_good": -0.2628
+    },
+    "vocabulary.mean_vocabulary": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_variance": {
+      "bad": 9.1863,
+      "good": 10.8832,
+      "ratio": 1.1847,
+      "suggested_scalar": 0.0498,
+      "log_bad": 2.2177,
+      "log_good": 2.3872
+    },
+    "compression.mean_raw_bytes": {
+      "bad": 1392.0,
+      "good": 1769.0,
+      "ratio": 1.2708,
+      "suggested_scalar": 0.0704,
+      "log_bad": 7.2385,
+      "log_good": 7.4782
+    },
+    "branching.mean_branching_density": {
+      "bad": 0.0698,
+      "good": 0.0492,
+      "ratio": 0.7049,
+      "suggested_scalar": -0.1027,
+      "log_bad": -2.6621,
+      "log_good": -3.0119
+    },
+    "line_patterns.mean_unique_line_ratio": {
+      "bad": 0.6744,
+      "good": 0.6721,
+      "ratio": 0.9966,
+      "suggested_scalar": -0.001,
+      "log_bad": -0.3939,
+      "log_good": -0.3973
+    },
+    "readability.mean_avg_tokens_per_line": {
+      "bad": 9.5349,
+      "good": 7.6066,
+      "ratio": 0.7978,
+      "suggested_scalar": -0.0663,
+      "log_bad": 2.255,
+      "log_good": 2.029
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d8": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "casing_entropy.mean_other_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_todo_fixme_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_variance": {
+      "bad": 2.3234,
+      "good": 1.9285,
+      "ratio": 0.83,
+      "suggested_scalar": -0.0547,
+      "log_bad": 0.843,
+      "log_good": 0.6567
+    },
+    "casing_entropy.mean_snake_case_count": {
+      "bad": 77.0,
+      "good": 79.0,
+      "ratio": 1.026,
+      "suggested_scalar": 0.0075,
+      "log_bad": 4.3438,
+      "log_good": 4.3694
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d6": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "zipf.mean_r_squared": {
+      "bad": 0.9277,
+      "good": 0.9395,
+      "ratio": 1.0127,
+      "suggested_scalar": 0.0037,
+      "log_bad": -0.075,
+      "log_good": -0.0624
+    },
+    "halstead.mean_n1_unique_operators": {
+      "bad": 26.0,
+      "good": 26.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 3.2581,
+      "log_good": 3.2581
+    },
+    "compression.mean_redundancy": {
+      "bad": 0.6307,
+      "good": 0.6783,
+      "ratio": 1.0755,
+      "suggested_scalar": 0.0214,
+      "log_bad": -0.4609,
+      "log_good": -0.3882
+    },
+    "ngram.mean_trigram_repetition_rate": {
+      "bad": 0.6176,
+      "good": 0.6494,
+      "ratio": 1.0515,
+      "suggested_scalar": 0.0147,
+      "log_bad": -0.4819,
+      "log_good": -0.4317
+    },
+    "compression.mean_zlib_ratio": {
+      "bad": 2.7082,
+      "good": 3.109,
+      "ratio": 1.148,
+      "suggested_scalar": 0.0405,
+      "log_bad": 0.9963,
+      "log_good": 1.1343
+    },
+    "ngram.mean_trigram_total": {
+      "bad": 408.0,
+      "good": 462.0,
+      "ratio": 1.1324,
+      "suggested_scalar": 0.0365,
+      "log_bad": 6.0113,
+      "log_good": 6.1356
+    },
+    "function_metrics.mean_max_function_lines": {
+      "bad": 15.0,
+      "good": 16.0,
+      "ratio": 1.0667,
+      "suggested_scalar": 0.0189,
+      "log_bad": 2.7081,
+      "log_good": 2.7726
+    },
+    "punctuation_density.mean_colon_suffix_density": {
+      "bad": 0.0463,
+      "good": 0.0625,
+      "ratio": 1.3499,
+      "suggested_scalar": 0.0881,
+      "log_bad": -3.0726,
+      "log_good": -2.7726
+    },
+    "entropy.mean_char_max_entropy": {
+      "bad": 5.9069,
+      "good": 5.9542,
+      "ratio": 1.008,
+      "suggested_scalar": 0.0023,
+      "log_bad": 1.7761,
+      "log_good": 1.7841
+    },
+    "casing_entropy.mean_pascal_case_count": {
+      "bad": 16.0,
+      "good": 39.0,
+      "ratio": 2.4375,
+      "suggested_scalar": 0.2616,
+      "log_bad": 2.7726,
+      "log_good": 3.6636
+    },
+    "casing_entropy.mean_entropy": {
+      "bad": 1.1944,
+      "good": 1.3581,
+      "ratio": 1.1371,
+      "suggested_scalar": 0.0377,
+      "log_bad": 0.1776,
+      "log_good": 0.3061
+    },
+    "casing_entropy.mean_screaming_snake_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_entropy": {
+      "bad": 5.4598,
+      "good": 5.6019,
+      "ratio": 1.026,
+      "suggested_scalar": 0.0075,
+      "log_bad": 1.6974,
+      "log_good": 1.7231
+    },
+    "casing_entropy.mean_kebab_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_char_normalized": {
+      "bad": 0.8292,
+      "good": 0.8187,
+      "ratio": 0.9873,
+      "suggested_scalar": -0.0037,
+      "log_bad": -0.1873,
+      "log_good": -0.2
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d2": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_blank_line_ratio": {
+      "bad": 0.2182,
+      "good": 0.1867,
+      "ratio": 0.8556,
+      "suggested_scalar": -0.0458,
+      "log_bad": -1.5223,
+      "log_good": -1.6783
+    },
+    "identifier_length_variance.mean_std_dev": {
+      "bad": 3.0309,
+      "good": 3.299,
+      "ratio": 1.0885,
+      "suggested_scalar": 0.0249,
+      "log_bad": 1.1089,
+      "log_good": 1.1936
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d0": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "magic_number_density.mean_magic_number_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_unique": {
+      "bad": 256.0,
+      "good": 278.0,
+      "ratio": 1.0859,
+      "suggested_scalar": 0.0242,
+      "log_bad": 5.5452,
+      "log_good": 5.6276
+    },
+    "vowel_density.mean_vowel_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_bracket_nonalpha_suffix_count": {
+      "bad": 30.0,
+      "good": 28.0,
+      "ratio": 0.9333,
+      "suggested_scalar": -0.0203,
+      "log_bad": 3.4012,
+      "log_good": 3.3322
+    },
+    "halstead.mean_estimated_bugs": {
+      "bad": 0.7617,
+      "good": 0.8812,
+      "ratio": 1.1569,
+      "suggested_scalar": 0.0428,
+      "log_bad": -0.2722,
+      "log_good": -0.1265
+    },
+    "zipf.mean_vocab_size": {
+      "bad": 75.0,
+      "good": 83.0,
+      "ratio": 1.1067,
+      "suggested_scalar": 0.0298,
+      "log_bad": 4.3175,
+      "log_good": 4.4188
+    },
+    "vowel_density.mean_total_chars": {
+      "bad": 660.0,
+      "good": 861.0,
+      "ratio": 1.3045,
+      "suggested_scalar": 0.078,
+      "log_bad": 6.4922,
+      "log_good": 6.7581
+    },
+    "halstead.mean_N2_total_operands": {
+      "bad": 126.0,
+      "good": 160.0,
+      "ratio": 1.2698,
+      "suggested_scalar": 0.0701,
+      "log_bad": 4.8363,
+      "log_good": 5.0752
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d3": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_arrow_density": {
+      "bad": 0.0049,
+      "good": 1.0,
+      "ratio": 204.0816,
+      "suggested_scalar": 1.5614,
+      "log_bad": -5.3185,
+      "log_good": 0.0
+    },
+    "punctuation_density.mean_id_nonalpha_suffix_density": {
+      "bad": 0.2707,
+      "good": 0.2909,
+      "ratio": 1.0746,
+      "suggested_scalar": 0.0211,
+      "log_bad": -1.3067,
+      "log_good": -1.2348
+    },
+    "ngram.mean_bigram_repeated_unique": {
+      "bad": 104.0,
+      "good": 116.0,
+      "ratio": 1.1154,
+      "suggested_scalar": 0.0321,
+      "log_bad": 4.6444,
+      "log_good": 4.7536
+    },
+    "function_metrics.mean_function_count": {
+      "bad": 6.0,
+      "good": 4.0,
+      "ratio": 0.6667,
+      "suggested_scalar": -0.119,
+      "log_bad": 1.7918,
+      "log_good": 1.3863
+    },
+    "entropy.mean_vocab_size": {
+      "bad": 75.0,
+      "good": 83.0,
+      "ratio": 1.1067,
+      "suggested_scalar": 0.0298,
+      "log_bad": 4.3175,
+      "log_good": 4.4188
+    },
+    "brevity.mean_sample_size": {
+      "bad": 75.0,
+      "good": 83.0,
+      "ratio": 1.1067,
+      "suggested_scalar": 0.0298,
+      "log_bad": 4.3175,
+      "log_good": 4.4188
+    },
+    "entropy.mean_total_tokens": {
+      "bad": 410.0,
+      "good": 464.0,
+      "ratio": 1.1317,
+      "suggested_scalar": 0.0363,
+      "log_bad": 6.0162,
+      "log_good": 6.1399
+    },
+    "symbol_density.mean_symbol_count": {
+      "bad": 250.0,
+      "good": 270.0,
+      "ratio": 1.08,
+      "suggested_scalar": 0.0226,
+      "log_bad": 5.5215,
+      "log_good": 5.5984
+    },
+    "ngram.mean_bigram_unique": {
+      "bad": 206.0,
+      "good": 223.0,
+      "ratio": 1.0825,
+      "suggested_scalar": 0.0233,
+      "log_bad": 5.3279,
+      "log_good": 5.4072
+    },
+    "magic_number_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_k": {
+      "bad": 4.8331,
+      "good": 1.7406,
+      "ratio": 0.3601,
+      "suggested_scalar": -0.2998,
+      "log_bad": 1.5755,
+      "log_good": 0.5542
+    },
+    "halstead.mean_effort": {
+      "bad": 77978.3154,
+      "good": 99980.5872,
+      "ratio": 1.2822,
+      "suggested_scalar": 0.073,
+      "log_bad": 11.2642,
+      "log_good": 11.5127
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d7": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "entropy.mean_token_normalized": {
+      "bad": 0.8765,
+      "good": 0.8787,
+      "ratio": 1.0025,
+      "suggested_scalar": 0.0007,
+      "log_bad": -0.1318,
+      "log_good": -0.1293
+    },
+    "halstead.mean_n2_unique_operands": {
+      "bad": 48.0,
+      "good": 55.0,
+      "ratio": 1.1458,
+      "suggested_scalar": 0.04,
+      "log_bad": 3.8712,
+      "log_good": 4.0073
+    },
+    "halstead.mean_N1_total_operators": {
+      "bad": 242.0,
+      "good": 257.0,
+      "ratio": 1.062,
+      "suggested_scalar": 0.0177,
+      "log_bad": 5.4889,
+      "log_good": 5.5491
+    },
+    "vocabulary.mean_raw_ttr": {
+      "bad": 0.3964,
+      "good": 0.3529,
+      "ratio": 0.8903,
+      "suggested_scalar": -0.0341,
+      "log_bad": -0.9253,
+      "log_good": -1.0416
+    },
+    "identifier_length_variance.mean_mean": {
+      "bad": 5.9459,
+      "good": 6.3309,
+      "ratio": 1.0648,
+      "suggested_scalar": 0.0184,
+      "log_bad": 1.7827,
+      "log_good": 1.8454
+    },
+    "line_patterns.mean_blank_line_ratio": {
+      "bad": 0.2182,
+      "good": 0.1867,
+      "ratio": 0.8556,
+      "suggested_scalar": -0.0458,
+      "log_bad": -1.5223,
+      "log_good": -1.6783
+    },
+    "readability.mean_fog_adapted": {
+      "bad": 4.814,
+      "good": 4.2797,
+      "ratio": 0.889,
+      "suggested_scalar": -0.0345,
+      "log_bad": 1.5715,
+      "log_good": 1.4539
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d4": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_bigram_total": {
+      "bad": 409.0,
+      "good": 463.0,
+      "ratio": 1.132,
+      "suggested_scalar": 0.0364,
+      "log_bad": 6.0137,
+      "log_good": 6.1377
+    },
+    "punctuation_density.mean_bracket_nonalpha_prefix_count": {
+      "bad": 7.0,
+      "good": 5.0,
+      "ratio": 0.7143,
+      "suggested_scalar": -0.0988,
+      "log_bad": 1.9459,
+      "log_good": 1.6094
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d1": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_repeated_unique": {
+      "bad": 100.0,
+      "good": 116.0,
+      "ratio": 1.16,
+      "suggested_scalar": 0.0436,
+      "log_bad": 4.6052,
+      "log_good": 4.7536
+    },
+    "halstead.mean_time_to_implement_seconds": {
+      "bad": 4332.1286,
+      "good": 5554.4771,
+      "ratio": 1.2822,
+      "suggested_scalar": 0.073,
+      "log_bad": 8.3738,
+      "log_good": 8.6224
+    },
+    "readability.mean_total_lines": {
+      "bad": 43.0,
+      "good": 61.0,
+      "ratio": 1.4186,
+      "suggested_scalar": 0.1027,
+      "log_bad": 3.7612,
+      "log_good": 4.1109
+    },
+    "indentation.mean_max_depth": {
+      "bad": 4.0,
+      "good": 4.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.3863,
+      "log_good": 1.3863
+    },
+    "halstead.mean_volume": {
+      "bad": 2285.0788,
+      "good": 2643.7175,
+      "ratio": 1.1569,
+      "suggested_scalar": 0.0428,
+      "log_bad": 7.7342,
+      "log_good": 7.8799
+    },
+    "compression.mean_zlib_bytes": {
+      "bad": 514.0,
+      "good": 569.0,
+      "ratio": 1.107,
+      "suggested_scalar": 0.0298,
+      "log_bad": 6.2422,
+      "log_good": 6.3439
+    },
+    "readability.mean_avg_line_length": {
+      "bad": 31.093,
+      "good": 27.7705,
+      "ratio": 0.8931,
+      "suggested_scalar": -0.0332,
+      "log_bad": 3.437,
+      "log_good": 3.324
+    },
+    "readability.mean_avg_sub_words_per_id": {
+      "bad": 1.1375,
+      "good": 1.1753,
+      "ratio": 1.0332,
+      "suggested_scalar": 0.0096,
+      "log_bad": 0.1288,
+      "log_good": 0.1615
+    },
+    "branching.mean_max_nesting_depth": {
+      "bad": 5.0,
+      "good": 4.0,
+      "ratio": 0.8,
+      "suggested_scalar": -0.0655,
+      "log_bad": 1.6094,
+      "log_good": 1.3863
+    },
+    "punctuation_density.mean_dot_count": {
+      "bad": 19.0,
+      "good": 16.0,
+      "ratio": 0.8421,
+      "suggested_scalar": -0.0505,
+      "log_bad": 2.9444,
+      "log_good": 2.7726
+    },
+    "brevity.mean_correlation": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "indentation.mean_uses_tabs": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "comment_structure.mean_comment_line_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "ngram.mean_trigram_hapax_fraction": {
+      "bad": 0.6094,
+      "good": 0.5827,
+      "ratio": 0.9562,
+      "suggested_scalar": -0.0132,
+      "log_bad": -0.4953,
+      "log_good": -0.5401
+    },
+    "near_duplicate_blocks_file.mean_block_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "heaps.mean_r_squared": {
+      "bad": 0.9451,
+      "good": 0.9582,
+      "ratio": 1.0139,
+      "suggested_scalar": 0.004,
+      "log_bad": -0.0565,
+      "log_good": -0.0427
+    },
+    "halstead.mean_length": {
+      "bad": 368.0,
+      "good": 417.0,
+      "ratio": 1.1332,
+      "suggested_scalar": 0.0367,
+      "log_bad": 5.9081,
+      "log_good": 6.0331
+    },
+    "function_metrics.mean_avg_function_lines": {
+      "bad": 9.1667,
+      "good": 12.0,
+      "ratio": 1.3091,
+      "suggested_scalar": 0.0791,
+      "log_bad": 2.2156,
+      "log_good": 2.4849
+    },
+    "entropy.mean_token_max_entropy": {
+      "bad": 6.2288,
+      "good": 6.375,
+      "ratio": 1.0235,
+      "suggested_scalar": 0.0068,
+      "log_bad": 1.8292,
+      "log_good": 1.8524
+    },
+    "near_duplicate_blocks_file.mean_near_dup_block_d5": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "symbol_density.mean_density": {
+      "bad": 0.1796,
+      "good": 0.1526,
+      "ratio": 0.8497,
+      "suggested_scalar": -0.0478,
+      "log_bad": -1.717,
+      "log_good": -1.8799
+    },
+    "vowel_density.mean_density": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "halstead.mean_difficulty": {
+      "bad": 34.125,
+      "good": 37.8182,
+      "ratio": 1.1082,
+      "suggested_scalar": 0.0302,
+      "log_bad": 3.53,
+      "log_good": 3.6328
+    },
+    "branching.mean_branch_count": {
+      "bad": 3.0,
+      "good": 3.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 1.0986,
+      "log_good": 1.0986
+    },
+    "vocabulary.mean_unique_identifiers": {
+      "bad": 44.0,
+      "good": 48.0,
+      "ratio": 1.0909,
+      "suggested_scalar": 0.0255,
+      "log_bad": 3.7842,
+      "log_good": 3.8712
+    },
+    "ngram.mean_bigram_hapax_fraction": {
+      "bad": 0.4951,
+      "good": 0.4798,
+      "ratio": 0.9691,
+      "suggested_scalar": -0.0092,
+      "log_bad": -0.703,
+      "log_good": -0.7344
+    },
+    "branching.mean_non_blank_count": {
+      "bad": 43.0,
+      "good": 61.0,
+      "ratio": 1.4186,
+      "suggested_scalar": 0.1027,
+      "log_bad": 3.7612,
+      "log_good": 4.1109
+    },
+    "punctuation_density.mean_bracket_number_pair_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    },
+    "identifier_length_variance.mean_max": {
+      "bad": 17.0,
+      "good": 17.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 2.8332,
+      "log_good": 2.8332
+    },
+    "casing_entropy.mean_macro_case_count": {
+      "bad": 1.0,
+      "good": 1.0,
+      "ratio": 1.0,
+      "suggested_scalar": 0.0,
+      "log_bad": 0.0,
+      "log_good": 0.0
+    }
+  }
+}
\ No newline at end of file
diff --git a/tools/scalar_tuner/src/App.css b/tools/scalar_tuner/src/App.css
new file mode 100644
index 0000000..d772420
--- /dev/null
+++ b/tools/scalar_tuner/src/App.css
@@ -0,0 +1,328 @@
+* { box-sizing: border-box; margin: 0; padding: 0; }
+
+body {
+  font-family: 'SF Mono', 'Fira Code', monospace;
+  font-size: 13px;
+  background: #0f1117;
+  color: #c9d1d9;
+}
+
+.loading { padding: 2rem; color: #8b949e; }
+
+.app { display: flex; flex-direction: column; height: 100vh; overflow: hidden; }
+
+/* Header */
+.header {
+  flex-shrink: 0;
+  background: #161b22;
+  border-bottom: 1px solid #30363d;
+  padding: 0.6rem 1.5rem;
+  display: flex;
+  align-items: center;
+  gap: 1.5rem;
+}
+
+.header h1 { font-size: 1rem; color: #58a6ff; white-space: nowrap; }
+
+.summary { display: flex; gap: 0.5rem; flex: 1; flex-wrap: wrap; }
+
+.badge {
+  padding: 2px 8px;
+  border-radius: 12px;
+  font-size: 11px;
+  font-weight: 600;
+}
+.badge.total { background: #21262d; color: #8b949e; }
+.badge.pass  { background: #033a16; color: #3fb950; }
+.badge.weak  { background: #2d2208; color: #d29922; }
+.badge.fail  { background: #3d1212; color: #f85149; }
+
+.actions { display: flex; gap: 0.5rem; }
+
+.actions button, .nav-bar button {
+  padding: 4px 10px;
+  background: #21262d;
+  border: 1px solid #30363d;
+  border-radius: 6px;
+  color: #c9d1d9;
+  cursor: pointer;
+  font-size: 12px;
+  font-family: inherit;
+}
+.actions button:hover, .nav-bar button:hover { background: #30363d; }
+.actions button:disabled, .nav-bar button:disabled { opacity: 0.35; cursor: default; }
+.yaml-btn { background: #1f6feb !important; border-color: #388bfd !important; color: #fff !important; }
+.yaml-btn:hover { background: #388bfd !important; }
+.btn-reviewed { background: #033a16 !important; border-color: #3fb950 !important; color: #3fb950 !important; }
+
+/* Layout */
+.app-body {
+  display: grid;
+  grid-template-columns: 260px 1fr;
+  flex: 1;
+  overflow: hidden;
+}
+
+/* Sidebar */
+.sidebar {
+  overflow-y: auto;
+  border-right: 1px solid #30363d;
+  background: #0d1117;
+}
+
+.sidebar-category {
+  padding: 8px 10px 4px;
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: #4a5568;
+  border-top: 1px solid #21262d;
+  margin-top: 4px;
+}
+.sidebar-category:first-child { margin-top: 0; border-top: none; }
+
+.sidebar-item {
+  display: flex;
+  align-items: center;
+  gap: 5px;
+  padding: 3px 8px;
+  cursor: pointer;
+  font-size: 11px;
+  line-height: 1.4;
+}
+.sidebar-item:hover { background: #161b22; }
+.sidebar-item.selected { background: #1c2d3f; }
+
+.sb-icon { width: 12px; font-size: 10px; flex-shrink: 0; }
+.sb-good { color: #3fb950; }
+.sb-weak { color: #d29922; }
+.sb-bad  { color: #f85149; }
+
+.sb-name { flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: #c9d1d9; }
+
+.sb-flags { display: flex; gap: 3px; flex-shrink: 0; font-size: 10px; }
+.flag-underflow { color: #d29922; }
+.flag-touched   { color: #58a6ff; }
+.flag-reviewed  { color: #3fb950; }
+
+/* Main panel */
+.main-panel {
+  overflow-y: auto;
+  overflow-x: hidden;
+  padding: 1rem 1.5rem;
+  min-width: 0;
+}
+
+/* Nav bar */
+.nav-bar {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  margin-bottom: 1rem;
+  padding-bottom: 0.75rem;
+  border-bottom: 1px solid #21262d;
+}
+.nav-pos { font-size: 11px; color: #8b949e; white-space: nowrap; }
+.nav-name { flex: 1; font-weight: 600; color: #e6edf3; font-size: 13px; }
+.nav-actions { display: flex; gap: 0.4rem; }
+
+/* Sticky behavior header */
+.behavior-sticky {
+  position: sticky;
+  top: 0;
+  z-index: 5;
+  background: #0f1117;
+  display: flex;
+  align-items: flex-start;
+  gap: 2rem;
+  padding: 0.75rem 0;
+  border-bottom: 1px solid #21262d;
+  margin-bottom: 0.25rem;
+}
+
+/* Table toolbar */
+.score-display {
+  font-size: 11px;
+  border-collapse: collapse;
+  border-radius: 4px;
+  overflow: hidden;
+  font-variant-numeric: tabular-nums;
+  table-layout: fixed;
+  width: 260px;
+}
+.ratio-good { background: #033a16; color: #3fb950; }
+.ratio-weak { background: #2d2208; color: #d29922; }
+.ratio-bad  { background: #3d1212; color: #f85149; }
+
+.sd-label { width: 36px; padding: 2px 6px 2px 8px; opacity: 0.6; white-space: nowrap; }
+.sd-val   { width: 110px; padding: 2px 4px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.sd-log   { width: 114px; padding: 2px 8px 2px 4px; opacity: 0.55; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.sd-ratio { font-weight: 600; }
+
+/* Table toolbar */
+.table-toolbar {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+
+.ctrl-label {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 11px;
+  color: #8b949e;
+  white-space: nowrap;
+}
+
+.ctrl-slider {
+  width: 140px;
+  accent-color: #1f6feb;
+}
+
+.ctrl-val {
+  font-size: 11px;
+  color: #c9d1d9;
+  min-width: 80px;
+  font-variant-numeric: tabular-nums;
+}
+.ctrl-val.muted { color: #8b949e; min-width: 40px; }
+
+.ctrl-reset {
+  background: none;
+  border: none;
+  color: #8b949e;
+  cursor: pointer;
+  font-size: 13px;
+  padding: 0 2px;
+  line-height: 1;
+}
+.ctrl-reset:hover { color: #c9d1d9; }
+.ctrl-reset:disabled { opacity: 0.2; cursor: default; }
+
+/* Metrics table */
+.metrics-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 12px;
+}
+
+.metrics-table th {
+  text-align: left;
+  padding: 4px 8px;
+  color: #8b949e;
+  border-bottom: 1px solid #21262d;
+  font-weight: 500;
+}
+.sortable-th {
+  cursor: pointer;
+  user-select: none;
+  white-space: nowrap;
+}
+.sortable-th:hover { color: #c9d1d9; }
+.sort-icon { margin-left: 4px; font-size: 11px; }
+.sort-icon.muted { opacity: 0.3; }
+
+.metrics-table td { padding: 3px 8px; border-bottom: 1px solid #161b22; }
+.metrics-table tr:hover td { background: #161b22; }
+.metrics-table .active-row td { background: #0d2134; }
+.metrics-table .active-row:hover td { background: #102a42; }
+
+.metrics-table .dead-row td { opacity: 0.35; }
+.metrics-table .dead-row:hover td { opacity: 0.55; background: #161b22; }
+.dead { color: #4a5568 !important; }
+
+.metric-key { color: #8b949e; max-width: 320px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.damped-tag {
+  margin-left: 5px;
+  font-size: 10px;
+  color: #d29922;
+  opacity: 0.7;
+}
+
+.num { color: #e6edf3; text-align: left; white-space: nowrap; }
+.pos { color: #3fb950; }
+.neg { color: #f85149; }
+.contrib { font-weight: 500; }
+
+/* Scalar cell */
+.scalar-cell { display: flex; align-items: center; gap: 6px; min-width: 200px; }
+.scalar-cell input[type=range] { flex: 1; accent-color: #1f6feb; }
+.scalar-input {
+  width: 60px;
+  background: #161b22;
+  border: 1px solid #30363d;
+  border-radius: 4px;
+  color: #e6edf3;
+  padding: 2px 4px;
+  font-size: 12px;
+  font-family: inherit;
+  text-align: right;
+}
+
+.toggle-all {
+  margin-top: 0.5rem;
+  background: none;
+  border: none;
+  color: #8b949e;
+  cursor: pointer;
+  font-size: 11px;
+  font-family: inherit;
+  text-decoration: underline;
+}
+.toggle-all:hover { color: #c9d1d9; }
+
+/* Modal */
+.modal-overlay {
+  position: fixed;
+  inset: 0;
+  background: rgba(0,0,0,0.7);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 100;
+}
+
+.modal {
+  background: #161b22;
+  border: 1px solid #30363d;
+  border-radius: 12px;
+  width: 80vw;
+  max-width: 900px;
+  max-height: 80vh;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+}
+
+.modal-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 1rem 1.5rem;
+  border-bottom: 1px solid #30363d;
+}
+
+.modal-header h3 { color: #e6edf3; }
+
+.modal-header button {
+  padding: 4px 10px;
+  background: #21262d;
+  border: 1px solid #30363d;
+  border-radius: 6px;
+  color: #c9d1d9;
+  cursor: pointer;
+  margin-left: 0.5rem;
+  font-family: inherit;
+}
+.modal-header button:hover { background: #30363d; }
+
+.yaml-output {
+  padding: 1.5rem;
+  overflow: auto;
+  font-size: 12px;
+  line-height: 1.6;
+  color: #a5d6ff;
+  background: #0d1117;
+  flex: 1;
+}
diff --git a/tools/scalar_tuner/src/App.jsx b/tools/scalar_tuner/src/App.jsx
new file mode 100644
index 0000000..8127451
--- /dev/null
+++ b/tools/scalar_tuner/src/App.jsx
@@ -0,0 +1,252 @@
+import { useState, useEffect, useMemo } from 'react'
+import BehaviorCard from './components/BehaviorCard'
+import YamlModal from './components/YamlModal'
+import './App.css'
+
+function computeScore(metricData, scalars, side) {
+  return Object.entries(scalars).reduce((acc, [metricKey, scalar]) => {
+    const val = metricData[metricKey]?.[side] ?? 1.0
+    const safeVal = val > 0 ? val : 1.0
+    return acc * Math.pow(safeVal, scalar)
+  }, 1.0)
+}
+
+export function isIntegerMultiple(a, b) {
+  if (a <= 0 || b <= 0) return false
+  if (a < 1.0 && b < 1.0) return false  // both sub-1 fractions — not meaningful to damp
+  const ratio = Math.max(a, b) / Math.min(a, b)
+  return Math.abs(Math.round(ratio) - ratio) <= 0.05
+}
+
+export function dampedSuggested(vals) {
+  // Raw suggested_scalar from JSON is in [-2, +2]; scale to [-3, +3]
+  const raw = (vals.suggested_scalar ?? 0) * 1.5
+  if (isIntegerMultiple(vals.bad, vals.good)) {
+    return Math.max(-1.5, Math.min(1.5, raw))
+  }
+  return raw
+}
+
+export default function App() {
+  const [data, setData] = useState(null)
+  const [scalars, setScalars] = useState({})
+  const [yamlOpen, setYamlOpen] = useState(false)
+  const [selectedBehavior, setSelectedBehavior] = useState(null)
+  const [reviewed, setReviewed] = useState(() => {
+    try { return new Set(JSON.parse(localStorage.getItem('codeqa-reviewed') ?? '[]')) }
+    catch { return new Set() }
+  })
+
+  useEffect(() => {
+    fetch('/metric_report.json')
+      .then(r => r.json())
+      .then(json => {
+        setData(json)
+        const initial = {}
+        for (const [behavior, metrics] of Object.entries(json)) {
+          initial[behavior] = {}
+          for (const [metric, vals] of Object.entries(metrics)) {
+            initial[behavior][metric] = dampedSuggested(vals)
+          }
+        }
+        setScalars(initial)
+        setSelectedBehavior(Object.keys(json)[0] ?? null)
+      })
+  }, [])
+
+  const scores = useMemo(() => {
+    if (!data) return {}
+    const out = {}
+    for (const [behavior, metrics] of Object.entries(data)) {
+      const s = scalars[behavior] ?? {}
+      const bad = computeScore(metrics, s, 'bad')
+      const good = computeScore(metrics, s, 'good')
+      out[behavior] = { bad, good, ratio: bad > 0 ? good / bad : 0 }
+    }
+    return out
+  }, [data, scalars])
+
+  const summary = useMemo(() => {
+    const total = Object.keys(scores).length
+    const passing = Object.values(scores).filter(s => s.ratio >= 2.0).length
+    const weak = Object.values(scores).filter(s => s.ratio >= 1.0 && s.ratio < 2.0).length
+    const failing = Object.values(scores).filter(s => s.ratio < 1.0).length
+    return { total, passing, weak, failing }
+  }, [scores])
+
+  const touched = useMemo(() => {
+    if (!data) return {}
+    const out = {}
+    for (const [behavior, metrics] of Object.entries(data)) {
+      const current = scalars[behavior] ?? {}
+      out[behavior] = Object.keys(metrics).some(k =>
+        Math.abs((current[k] ?? 0) - dampedSuggested(metrics[k])) > 0.001
+      )
+    }
+    return out
+  }, [data, scalars])
+
+  const behaviorKeys = data ? Object.keys(data) : []
+  const selectedIndex = behaviorKeys.indexOf(selectedBehavior)
+
+  useEffect(() => {
+    if (!data) return
+    const handler = e => {
+      if (e.target.tagName === 'INPUT') return
+      if (e.key === 'j' || e.key === 'ArrowDown') {
+        setSelectedBehavior(prev => behaviorKeys[Math.min(behaviorKeys.indexOf(prev) + 1, behaviorKeys.length - 1)])
+      } else if (e.key === 'k' || e.key === 'ArrowUp') {
+        setSelectedBehavior(prev => behaviorKeys[Math.max(behaviorKeys.indexOf(prev) - 1, 0)])
+      }
+    }
+    window.addEventListener('keydown', handler)
+    return () => window.removeEventListener('keydown', handler)
+  }, [data, behaviorKeys])
+
+  function setScalar(behavior, metric, value) {
+    setScalars(prev => ({
+      ...prev,
+      [behavior]: { ...prev[behavior], [metric]: value }
+    }))
+  }
+
+  function resetCurrent() {
+    if (!data || !selectedBehavior) return
+    const metrics = data[selectedBehavior]
+    setScalars(prev => ({
+      ...prev,
+      [selectedBehavior]: Object.fromEntries(
+        Object.entries(metrics).map(([k, v]) => [k, dampedSuggested(v)])
+      )
+    }))
+  }
+
+  function resetToSuggested() {
+    if (!data) return
+    const next = {}
+    for (const [behavior, metrics] of Object.entries(data)) {
+      next[behavior] = {}
+      for (const [metric, vals] of Object.entries(metrics)) {
+        next[behavior][metric] = dampedSuggested(vals)
+      }
+    }
+    setScalars(next)
+  }
+
+  function resetToZero() {
+    if (!data) return
+    const next = {}
+    for (const [behavior, metrics] of Object.entries(data)) {
+      next[behavior] = {}
+      for (const metric of Object.keys(metrics)) {
+        next[behavior][metric] = 0
+      }
+    }
+    setScalars(next)
+  }
+
+  function toggleReviewed(behavior) {
+    setReviewed(prev => {
+      const next = new Set(prev)
+      if (next.has(behavior)) next.delete(behavior)
+      else next.add(behavior)
+      localStorage.setItem('codeqa-reviewed', JSON.stringify([...next]))
+      return next
+    })
+  }
+
+  if (!data) return <div className="loading">Loading metric report…</div>
+
+  const categories = {}
+  for (const key of behaviorKeys) {
+    const [cat] = key.split('.')
+    if (!categories[cat]) categories[cat] = []
+    categories[cat].push(key)
+  }
+
+  const behavior = selectedBehavior
+
+  return (
+    <div className="app">
+      <header className="header">
+        <h1>Scalar Tuner</h1>
+        <div className="summary">
+          <span className="badge total">{summary.total} behaviors</span>
+          <span className="badge pass">{summary.passing} ≥2x ✓</span>
+          <span className="badge weak">{summary.weak} weak</span>
+          <span className="badge fail">{summary.failing} ✗</span>
+          <span className="badge total">{reviewed.size}/{summary.total} reviewed</span>
+        </div>
+        <div className="actions">
+          <button onClick={resetToSuggested}>Reset all</button>
+          <button onClick={resetToZero}>Zero all</button>
+          <button className="yaml-btn" onClick={() => setYamlOpen(true)}>Copy YAML</button>
+        </div>
+      </header>
+
+      <div className="app-body">
+        <aside className="sidebar">
+          {Object.entries(categories).map(([cat, behaviors]) => (
+            <div key={cat}>
+              <div className="sidebar-category">{cat.replace(/_/g, ' ')}</div>
+              {behaviors.map(b => {
+                const s = scores[b]
+                const isUnderflow = s && s.bad < 1e-10 && s.good < 1e-10
+                const ratioClass = s ? (s.ratio >= 2 ? 'sb-good' : s.ratio >= 1 ? 'sb-weak' : 'sb-bad') : ''
+                const icon = s ? (s.ratio >= 2 ? '✓' : s.ratio >= 1 ? '~' : '✗') : '?'
+                return (
+                  <div
+                    key={b}
+                    className={`sidebar-item ${b === behavior ? 'selected' : ''}`}
+                    onClick={() => setSelectedBehavior(b)}
+                  >
+                    <span className={`sb-icon ${ratioClass}`}>{icon}</span>
+                    <span className="sb-name">{b.split('.').slice(1).join('.')}</span>
+                    <span className="sb-flags">
+                      {isUnderflow && <span className="flag-underflow" title="score underflow">⚠</span>}
+                      {touched[b] && <span className="flag-touched" title="modified">●</span>}
+                      {reviewed.has(b) && <span className="flag-reviewed" title="reviewed">✓</span>}
+                    </span>
+                  </div>
+                )
+              })}
+            </div>
+          ))}
+        </aside>
+
+        <main className="main-panel">
+          <div className="nav-bar">
+            <button onClick={() => setSelectedBehavior(behaviorKeys[selectedIndex - 1])} disabled={selectedIndex <= 0}>← prev</button>
+            <span className="nav-pos">{selectedIndex + 1} / {behaviorKeys.length}</span>
+            <button onClick={() => setSelectedBehavior(behaviorKeys[selectedIndex + 1])} disabled={selectedIndex >= behaviorKeys.length - 1}>next →</button>
+            <span className="nav-name">{behavior?.split('.').slice(1).join('.')}</span>
+            <div className="nav-actions">
+              <button onClick={resetCurrent}>Reset this</button>
+              <button
+                className={reviewed.has(behavior) ? 'btn-reviewed' : ''}
+                onClick={() => toggleReviewed(behavior)}
+              >
+                {reviewed.has(behavior) ? '✓ reviewed' : 'mark reviewed'}
+              </button>
+            </div>
+          </div>
+
+          {behavior && data[behavior] && (
+            <BehaviorCard
+              key={behavior}
+              behavior={behavior}
+              metrics={data[behavior]}
+              scalars={scalars[behavior] ?? {}}
+              score={scores[behavior]}
+              onScalarChange={(metric, val) => setScalar(behavior, metric, val)}
+            />
+          )}
+        </main>
+      </div>
+
+      {yamlOpen && (
+        <YamlModal scalars={scalars} onClose={() => setYamlOpen(false)} />
+      )}
+    </div>
+  )
+}
diff --git a/tools/scalar_tuner/src/assets/hero.png b/tools/scalar_tuner/src/assets/hero.png
new file mode 100644
index 0000000000000000000000000000000000000000..cc51a3d20ad4bc961b596a6adfd686685cd84bb0
GIT binary patch
literal 44919
zcma%i^<UI&(>5TDbT`tlgo2c`(n!ND-Q6MGAYIbZ-QCh5-QC^YozK_ne*b_MKK#O-
zIWy<PF~^3;%Zj5S6Cp!EL7_@Yh$uoqK|_E)GemgcKlH*DJy1{;0+J%a$}Wq?tq97>
zd$aJVZ?rl%;eiC7d#Sl-cWLv9rA0(UOX(@I3k&yyL+3GaQ4xpb1EGC|i|{byaTI>#
zBO=0pyZu5XO!hzGNPch4cx%6XJAJpDa<+<dWb4y9=a!J1>98BOcYNo1=XER1sv!UW
z^>ZDMp%FSmVnt)n^EIR+Nth`vRO^_=UF3EWv75ym{S;#2F8MPot@-y$>ioj!)a1bE
zijXPQY;U`qNwl9|wl{W>{FhMSb<>m4{;8Udp4psl)NwFRo(W-T)Y6-qDf=L#U?g<@
zV+T|3+RuE~!E&nodKrkfPcOpJ)&1|p`Tbtd12@MSE8DjWkD|9M>GZsHLf>TTbLx)B
z#5K5l%gS7s(yWk?Lj{Nvm`Z-s8xb-Xr`5-xRr%w8v>!oSz{dN*MmxbscQl#Z40qSd
z!PQXs-utLEF&$@S#__Lo*pOhG{l(%jyCh-0ME8owiT>U~r&q@MaDRePL(aZAAff9=
zBd@*7RZxmiqK^nZH7`bTjIEQw#Y=V6(h{$>7ZIf=7S0;$8~4NXLd4T;Ai~C8&3k-;
zYEtJWq<v&S#@AmI9jl{*RqKPLuitC7Wk?Tknp;@8--yN@WMqj>6x$#5rrCJ%zspgO
z((R)&>BIkkr^qQSEZljO*B+ZDvTeBKJ9N%8Ej=U+62GI)dc|ZMEM66~W12v&QFAIS
zoDs`J`wjsl?WdE(NTnjCO!^yB>{yU-2UPT`&FOyVQVmxy#un2Po>GiPPfzd0M^d_i
z+Kr}dPhIfsDLd~jOiJ(sHTN;2u)@MaX&0AdXR;BAwr_;1sR;)MM+&{XTzNnKWH@0a
zoy9ApaUt=>jjHICu3W42)5;nzHS!M3?aOv<pQ5}xy$lS-lKVrBEQ4NdvKOs|iVnrh
zn+Va9wnU{WF9=VH>Zfv-sIc%wc9#l0uHFc}aS4JSrIDOQ?4ri_bS?pjH{U{6qr+6m
z--%u=5oc&PxE==-I$~$5gw}yiu_y_o?|ag2+rAgSg%G)}EU}r%*A|v|pjbE`lxJpU
zy0{?;(US(i-TiKq6s_(KTYy|YVi&!plMT)EJ4wMU{C7Y;!Xow1nJ+X@ks@r0v25R;
z*o$8AP*G*f3$UlYR~18PxKyPj9vU#v)4#GgEx4*?KOhlh>0%3M$-LN7&b*0fXgm$k
zH78>bObkx^3_K+RY;G+Usy6L}p9iT!hlnJCmR=;=JL1TdtB#vL!RTJ1TABQx8Ux0w
zl^{Jkf(hU>-jr59iK_v-PkV!WwG!LvW<@{3{IbbSiWBrX@S8^`8JFRrc+(AqsUIvm
zCTstACtCZ~qy-5^Gr@_z#X!N1*1vH=7@8oL4AEOxWl^YW&LW|1$1J?gG061vk1epe
zRI_*s(lrX?-2#tCt_`)p?{zZC+)onl60CU~%4!vPA}h0+fB9ucNkTQ3u29((9Wq=>
z^JUm|{_2-=?dMKu&9)#x{lgPOCM`U1^tXDbmZ%I$0fw7|Y-@3Tyj1LGfk$lvzYC85
z=R()QEER%Dz=mTMZ=7E?K74&?)4b~-uj34rKwb~7vU(48%+1xYc^<CYpxN?!I8mEu
zC=wb21&E{LISjf<M%)nor7?EV1v*zbuIYyX`*=9CNf`6Iyv+5g@<YqLgEci6>VYn|
zncI4NL8xEnmi>eM9EK&~si%*s|BX@zKIUU?cAWA5pdc`xEZIF1Ce=Wcg3#AP?N~p#
zD7mfb{oR=ZPE^jg<f~ahIb)o0rn{FND{0l&eb`abt2^XPv5`MtT%vWL;R34PX@Kpz
zkx#!EnBmrIWAWUOZfiAuS`o)0@GmzUb&7#yT*=Oq_bWeSyvEzu$Bctg#2U4>wD3G<
z#8h1K&u&zKD<f+bAF<784>4q*Pxt0ta#d}bm;QqZ!hFift22a~7c529SkmFQyN-*H
zzQck2cL5iH2@d@Lhq4$~_!wMWL6(&mNq=7HhT}YYI$pVVZeQr>)4>qObE$PPNZ2!0
z&7?y_upwfiefj8-`B$ju)}QKTz*Zs<$Lb?XHBo(jyU(405&`EL({mgxA$Ov49U|rN
z2@(l@n`1vzG(v=!u4AZ*0s}~H4{VgcNOJ1rB?Kg!<anXfVKlD)UdD4|c_?$qA9g0p
z2b$I4cJ`!x|MUACV{0?L12ES>=)mGHKWeC|MHb>aiQ4Qd+gq7|??WH7;?J+kYL8z#
z@juTBhW#n3rN))N7T1~)qr~Es;2rln6_U>_Ejxj(E5%Cpoc^vfw64mua!ADSZ8i|+
zB}g?u(dtve<VQvR+OuFB4YCj%#4%!KW~++97Qbv@u~af?V4UY?+wP#6G84{2{e3BK
z9<C^LFcNE9{OzS9DS4C+f#p|S)*scJx%<4nQ&0q1_F$iKG;P9vulXR0j-GgL(mwnP
zYExcXS*=JlPAkti@~@R~(n4?2MRMjIFFUt!B>sTegnG!9K33T)4eq>)>ZFp?L<x*^
zi7irKE@LdbXkwy@Vk@IB7k!h)a}U|sFZxlz*;OSLJVj3?xHYa4ro0@2qRrs=_eJxp
z0w>>R8Qp#(J=bxz2mscD;ZNoJB@ZUqPpI>o7VgScniW4c()#;@;-9PfR`b(r+#4c;
z;1-)`!?b}4A3v^zVtGa(a;O%bzu(ZG;(l4+W^vU|a&n*xV0kU$uFQ!5!aWy)^q4^r
zn!-6hfj79_B#>GGNvQiKMD?xyW>F&GS>3y?Ric*xp4cz3FH3Gd1z|e+Vuug7*Ya48
zL~K*l5zo1XRuWm%S~GzE4LQyuRsH1&L`Gz-%>!ZTYn9K_Ttz+Pa@9hKob^)gmLVN`
zKJz}C50X$$>G1Q_p;%C}B?<9h`60%vwalt2*Ymd44dGF(oOa2mJQuPQmE~Yurn0UC
z6(+5$posAd@e$nvJQFL^C~E0E4IH`B68)j#L_u|Ex5mNE8a8{>gAGcIFVS|K?g77#
zE@R|9nR>Rw3(5}{d~HnPpooZ*XZC$5F<vzogTo}NyY{*lWG8)dLW23}y|{jI>Yt20
z3Ydvy9t)XHw8qFCd;mt8r$e?<UbQ<FWI0cHw8qd6s&KS&%^64osKDboGtx|9?Y|rX
zN}-T`(#;rLq0pY`Q6DWc;2J6&fCcAN(yaKnK|;%LGCYn>RQ%MiUF@}!oDGG#E6xxV
z=z>11f!msSqb<FILy8j&UKb;h_aT>AZYnSvt}&J+QXZCU5b`0!gi_R}Z@Qq2d2Mwc
z%9aWfp&x2UGbLDvtjGb*p>4O(#}UE<GE8wXWJ`23P<jRB{|VGMe=1G|M%Wd2Yy0<-
zFb0)I9*K1bl5n1)ke*4#)auZ3l>+QhYmf0&Vc_Ay<~3V0zym%`Lk}-3MOz<%)%#Pl
z<=OjGrvuBq318+CJ-{30QA1-O@<-O!-zFNM^&wp}iWGG$B&eIYtF)Rs4;5FK=>Aa9
zyTJdUgpK$di~MI|ZC=Vkd^V6T5h^z))sl~Dq7~stg?&l_LW6N1>0nX=aS46Ks+vj7
zr#P2~h=M-LLX2!W_k&dv^Tm2}o9vK&uKMDMmPkEcj7~C78vw2XJx^s8uo(Lw>9ET2
zzXG^MDxZzwh4y=Hs@h^Y2$ntYP+GSm>#cM9ZiUR^>tiFtIol3wi8=y~L2f@Bun;{B
zr@yZ<GwVn~iC6#Ti&oC0M(S7?jkQqg!OpNt5G%z%^mLjYUO2{ONmCR~s41iNlWNdb
zb&eOIuD?6Bt-tB#As}I}uy7Z;DTe(j2o;&UQHpBC|K%4#Flq+i;S<c)iNDjLW+$k?
zWRYi==GuQwux_-?)4(c@@)Xl@#F;JGBu0_uVA1JMk>Mir9Ur@yw@7ni+Jd*Oc9hFx
zK$M%P9+XKj>`spPB?k6^h1pok(_k*E$fr(SnXlXEnE{ODRWuWqB2u+8*2z?-wl+WC
zntSCtFwpr0nF!avN+7`^Pt@XDvec7%ipuHYXg%5TXDAXv;U-33A(vzDB8V%0%j-R@
zk!2mox%%pJ<_M$o0lf*YButy@IP%9Zz=UDDlr|NuSNW*bYB{&18Xj|$eVP~(lx>y3
zgjJh3l1)5_uw6CTgk`ABQVoCHT$nbFS*edKLAbhRxLyzMI-{#6H!q_O@+mM7#~@Kw
zWFDq#m<+NGVr`grM*Mh=Dq@8Tzl-$WKFWsWruYa^v`B30wDORai8q&__SDBzc?K#o
z^UN`hN&IN;bep+mS1Z}i#zurS+Vl`B&+6`B#XK@l^8+&2+e@&zII(kdzid}Lm^AE5
zqjZ+3N*0O?1%{gl<GR=gwVLBxUlVexXsZg$`i~jiH~*~9`T;@|=Vntw6*a{a1yhTa
zi4t&>ymHcUP?g3vB#mH9MA)__>pUakjX+4jP<q^&8WZn0VzfN+>uRS$9mmbImM8^=
zOGMzKSY0_htZs;&-)|di4DJjSjVQ}hf2vq`u?G4@2@M(y#8xp{#1&$)ZW$rlUwG%{
z-S3I$D5~^(7stnQ#qh(0D6TnSA5R2*0u@x*22u1y%V5wYfW$b@)H*9X9{5!1Gw0`$
z4^fR@T%cw74(zCoPNP98@iS+WaFoE>g!a7#s-iwfRHKJSou%<97*I%619(655MjTr
z6;k$p>T1-|cb9V=`;0i>gjBf%t=3jn_oC874-1o3(J|G-g$c?a=wn!m?U?CAd4WKW
zm>=k4ApUHFtra|}Wl_G|#Y@n(Qv*q-frfU@rg{K1dLr%5(jA(Als7lSt8bue+zbab
zVF0VKb`8x4k`2s^D1=P<^mk&LXhA!1jsr46^sGC@bsZfT)hZq4gnT+I+aHp`_XRE{
zDgx9ExOOSGF^DuVB_iQ8s$S{7agA7rKLtYG0nVl0q1kdJPQ3g#tw9qL?gP!_e~V$R
z7B*H7J0{kp*t0|SM#+|$l6`>>9*GXki2@B!1?#&`s}t$D9D05bdTLaq__DzJ3hhhx
z4>Z*xjuhGkL>lPDr8KhXi~8N*3~eqgebLTG`3g)&9`ESMo4O`<T5uDguT#$)s)Sqm
zOW{w821rA|@3}=oojXftb2F^&d9WPsmwmO6=69_8;SMxPOjMJDE@04V_`m4hylc_f
zSW6PQ=ERVq`ALffRP;<idzg#D>ywJ{RymGvLXG}!Y?yAZ!5^Y19ukC`n~3GM7)2v!
zx|C7WvVV`|+~>K~FRJPdp3VTPY##;_7#_^stFuo>5ewhPn5=<N$#iS9&A}zkx)TG+
zAKEdB_wMsoq*q6{cZ2WEHoIlGboys>@ApsXs_&LT27I&g<HM4v5|zvAU!TYd@&4#2
zf60GZPfo@u27Dy<?b@BboHYoQff|^Ug$?3Xq{Wl+jBfXOT8lQc+tM!mZvT?VB(HeU
z=}opDVi3Z4?8EXX1*31hyO#bPKMHt5m^61of~#A&SUX*8vs6L)T5nfxTwHa9PAVb{
zQJM<~_S>Pv>g~?s5SHzci&*$xeFVsI6?MsNJwojSpg9-+xbDwNanO9CUPbs06^E~@
zW3}{)@boKx;MgISD4?gb;X2~Nzv<j=gXz&96MKyFjg;sB1KL;69Blj&g~=Fcdx46=
z&-8RvU3#0C7GKr~7-djGqRPulMcaEY&b_4H=Es`^S2$6vvF0LC{3Ia?dTh&h{>6Vu
z_d;=oiM*wq!ou(NN8Zrg1ZYYlE==ylKlarfHe9u21xL{BI8t!pRC1^0=DGRrV0_Q@
zC#L85xcROt(T$6-@Y|KI-@7cgFD>WF?-)WG5jRleK;pn&=Rb9nZ+_@Mx-Fk~VSb{E
zq@Ay=ub<df1?DeDN4t5!(K^t}q)STaylr=v%J&#EaEa3l!AO+%+zko1C9|&dOWZ13
zhT_JQ4zqtuE=C4??A2G6A=xULHJ}pO9&e)(n7LeRNZ(!S{4ysCVKQ<@sYEX;E+l(k
zqT6uO_DvWD-4mq4dRMF$@&YKt#E38jMmjuDDv^tma34+-mB9BVybc6D8AO+4hiS$)
zWf{#aWU1W#tnMJ+_<D=WPc8{H=Y!$RH;`SGr50h02OOK*RH3$*1WE8TG-a2JMW86j
zY+)!pO1nf})Ly07PP$=N-L3sOXU{ceGm=h?XW@^IC_g8NYOXTk`roDLglfEsBocy~
z%%3l|_YSSP98IgJ6%8x4p#vn!cg7eTUIdF=l)}ti_VozUnY=506?!nP0PgKg&GX02
z?vGKTUu8~zzh)cu$jLWe=O&jZ_O<8+C0u3vFy%+r9Ba;_iG}acA7hQN{HC>)@<Ry|
z@ugL}PXBWPctZd+S#+hJb=<|yNE2D5KD4cHT9FAN&cKy<zM8gKp?y8@T`<;Y^I$V2
zG*SbJPO+YotKrv&_dqQ6(VnOhms<!XZSmkw^_*l^93uv8IoQFKDceAEi5Ec~wOebo
zmt}>s&Mz*$+FSlG0WrrMKZI+3YuZ5k`RZGGO+r;}6mJy$DM;>AadvNZ=5yf|1r(je
z0NIXNIS||Cv*MHEs<e~n2;q!1k!{<;fP50dvOAWa5+$^sLf@!!TQv-#4yCdG0F-u~
zQlS}V@Q*ssklo)Rp+GqrFJ7+i%^_A!`s7au<F=Xm2981n&?gZsZNTvhTgj}P|EpG4
z%2ia07qI*6HckEbXRkDDoIbipCROR(>{?>y+_cZmakNb+;cq-QqDcP%tMf{NmoE%a
zN}Y33Vukiwxzm0dhmNsZQ>TsfYfZ-XZJv?ZTQ(=j1nt6FMd#;_K1oqQ{yq$GC6%)U
zZU3B>;dh0p{DE?0kaj|iKj8?vvgC|-pv7<_WZBV7+B?`x+~3_las0^52<3d}UOOFD
z7O7yf($skvy4y{NCq)B!Z=x|~NnJN+V(IV6LPL~?ORfvDDj*}q67_<Eg?UrZR_7r)
zQc-~1Tp$LQ(7#y_D;YuYiYYwep!DQuABJF{<SiCT!k!^5^(BTm-YB+3W>9}bTd~ci
zlKmqOV)pG2tgWwY4Xr65@I8rddMwBV71bVAeGxT?v8-f6l9tsu9MFYr4r+BQr%mT;
zO=G1)NW}SP4_kI0273Ew)qtwOw<F4J=3kb&j%cyWDk&+k)LpPOG}ym$Ye!JAb4^eb
zNiKMF!?0!Y@{$wv10j>o=X-`1?bJ^>I^-9FXhSX17W>;{G^F+<9U(<%-*JPc!x>jH
zSpfzK?Tx3%`#8Qlql2)Lf)TAiKHBQ5IOieg6~2NY7g@9IFI!7$DETtUG^srTsi2YS
zc$`cq59-bK0{Yv})|#O4%XrxCkS29A6q~iTWNRlF;SlDMr$~v5hgerQQg_UB>M>2%
zI6J+NtM*`(N7ghI_emz^lYyF_O8LW&&6oX-gU1h39L7r@8tpHA@>FGx*W=fR6E@q@
zg{!zJeVuJaQCuA=1@IE7|3##J$1oumJ5vky^UJEjKU#$)KuHS7B;vs(wJ%$?>4zlr
z<=b*ca@HsJ!Osy3xBOqrn__<iJ?o&(rd+x8ToWD1KR8jQq-el@)UP|Rw7BXY;C4@!
zYC!zC_uiwtvKHBu;sa+-XjEVD?z4N#x5$l8O*}4ix_<XMe0}}#ow7yS#q6$;`SrW0
zxa2R9cpHXW<*h@rT9L4UI|_HFc;2H8*kNV0!qxBeR?2FD3Y3D67x`@YZE=qMBT<ct
zrCJ$N;#-<cUvS-p-iNgMe0>D7pqhw2^7;n0$R~Z;twx??hrssk#C1cMtRHfFzhTG1
zE{;!Tmiq;ZD9#2W4(M?+!*~v>l$%5;__SINKTNAEIBf46X8185dhp4TD9_K#gp?em
zl9d>E%I2x(q#pB8rt!89i!Mi7sMMmaZ?N?eM2!JHoQ{QdAoSm@`@TtaEkw{)WuZe^
zzrVO3sL=ewi4YYv1t!gfQ_Xo()Is9PQtqh!#?v&Mscaiz6wb$F>GjZE1xw7d5)*24
zu~!(MAawsNH*G-kU-c=3l(?|JJl0^q#LV(WKmSHC=#5YKstmI(V=6c4>73kKDwk3F
zD!sjK#(*WYb8j>uP??1gq4SEU63;>Pk_#yOYu7(GAy4!ABPQY-WoeY1I=l2&k9RM(
z;&F-Ki}KoHAb;HXNP-^_3u`-L$+~dmP7L<ORVp|{OW~2ctBHzJ+xuej_`Fb4FtU~<
zDC&JaB?0$7y3k$Mijb({{DOA#&|m?@XGMf?BTL*PIR%#*7vs@!=rHSLLUFnD()L28
z^|z-=R8(Jx5;9+^$E0050&iKmC?qY1!yD@|wZ8teS&C*ZN&Si`Jy7$Fb--=c78`z^
zn3kQ{gpfSXFPvSCR@1kt)nv8^n?WN5sDTdjsIKW!WhIt^m6D=Mv9?AnH?}@yPX{*@
zJJ4nHSD7Cqxkg4GeJ^_ee9&B@I*Rc~a&g0nT7MlciPZ|MYR8a_#|@f*(+PkAwQ2nc
zeC+K^t;;IwQ_;lQNpCL|M<>mypyE23q+IsyIAyGbu{1T^)Y7+m(;oN@;N26N#9X<&
zwqI@>wi=7v)<%<?bekh1S9ztV=G3O}Jigcjt`6@NiLNWF-S!>`#h|WWx1pPuT%3Hx
zTmHj4u@(m6TMc`y;_9#P8As?uJeu-!|Lgzd>}uWMUo5{kA<)1ndxs@UZR32fT<T`7
zbu*@)KkJ7c4PY}j)9#)s!VP3Yif$dTc<$G6{N&Cb8Wq@&^S{kq-){}z0ci0)HgieY
zNyX+Xj5W9_oC8jp4tT`N%BImej9~Jt+W7*hk~raNO84WNc>6pJHGaO!4QH(eAa5+t
zS1N59<g1R6&9fGn$RJbvY9r!iJ{!t{L_wEi0`^(y$nsSkm|8$wXK=1|;G(GaI5b1R
z^8Fpnq-~pO7TfptQMHycJTlm^$KX01wpX*=2|!d4TjA%*H^qK2VM?P<AXh36D1pfl
zOyvm3+*D_^Dh6X%F0K-wT(GZp3B!}w4LV(nroA^LMSvm_m+4&4i`yEXJP#(dc}j~M
z6bmoDWvc7u0>EQ1r6i<Pg6fBcTV#Guh|VaXy%!hUv2uCVhsE?T(XG^*4GBK1UyR3Q
z$$3lyJMZ_Z?B3?HcnvmwXpz1|3_i=3$Is^1#N!pb?<SY4H{Z<C5eB=BvH^*efhxH>
z<(E$QmAL~w+VkGpLI9*Hnm0tLT@_hjW9JWQXev%DVG3YZJ@}x78{*jc{asC?1L_)h
zF^DC#%H`1`O_VrpaQ}@~&1zbs5~&ja^i#ZVXwP!}j8mnEV@;<{Ahw)4%S3LKNFJ3i
zaiK4p7j50(Gg`7o7JU5p$cw9Ok3@$*lZ@g;nFZi|2gmE)4`U4Rnm2m{vKk-zbX%kA
zCoK32`kIhZtyUTzRW&2mT0PG|s|zU{4QPllcC91scP>F97ZXap<9Bv<P7`yg84;&8
zLAT;h{UCQQ{i`#6kg3wVS^4I|hT-1oRuf|kXh?HzER7f9x?RjAeRkGVbKU-M%$@^r
zZz}GXnXrg*fPk#{qBP7d;CyIU{?*9JDnjy+<?5e^q)YxVlu)W2jyx|B0Z#Jx@o-SN
zb6}QVJgMn0qsPN42eaSd@o`Wm>#F$2P|qk;b&2$rxv~0fH76P8hs?SUZLs6n%pW)x
z{94NZ^zuBrMOvmx1jBKr7I^C(e7yj;&kgD*7xRHBhV0n=;gNznW(J%ArEdQ3v2RnW
zr(kstOqa&TJ`*F&kJM}we0``YRAQ>!`T?;}wzZgRk(fa^)#2*9%Z+psyrobKU%nac
znGGN&)Npn`s=}e$R4yL6IsRDDSF=Ps)Z;1?NH}K#C*jVV4dx0@(DMhJqOL*I6)&L4
z9cL<k(GwDN=$hrlo?O|eo!nIE=5GXr?GehHnvLABN;d!iEdZ2*RyH?IO<!j;rd|jJ
z^v&KkUw8l^^;~4sDwH$+ABMG}1g>FcW!bbaiw~-ib4#2tjht6tOE}{zD6zU{xlC2$
zI>jGRD=rdrA25&Qq4jqQAhS4A^TEeuR}+ZLmIn&KRN3!3YkB-ej*-b9-c-AE)S%N>
zf?x6ev<Qq$CCsGEA=mPWRx4xfl^xQY$ut$ew$SK&7&|yRYR{`h=SZ#7{N_D6snY7J
z`KHoD6K6XcC{bD1r`_z~?>rm$2MOQ(b0-<^gvSC_6oBe@p+i`Ajxy1G91_dbm9z>*
z`v6e3>~L1a-C*c2`$0^HXjr4(?IN{jFy+;}uvyb!LNh16HAJ)d@63e8GRMmWrMZ&F
zv_aLU&4#ktx$@=QM^zZSdGAFn^&JpWIEc06k(WFQd*!&PpmY;wf3>)TvXQM+vqd#z
zyU8VT;5@(~T!27u_1N3Z<{-f&SNd-M>^C*BK>cKP5&U7*KXmq@FP2FiN4aT+-1iF~
zfRiPbO{*ky%`uehvD+s~XnH7V{jvXcN8((ts-<3M-#N&I$MX3xlZ!UGg+fiN+}`r5
zkj3AjM%Sj6BRHE5?Q@(GmaEXx+<W%j{btGBDLHkp(pbg0eSA+2Sw@$V7Or&3vvUy1
z={5AP!5*}9LpX_vvOcLsu=?oYFXERG@phO1MswA|zDM^UksSq)RR+8@tZRtTg{pdh
zle<SMywA>0)r!TPtcgyrsy<^`_Wc<X_;^f>*hwyr-;OCdQ4#vF=h5Xj!r_#p6O*Q*
z)GM*S@GP^XHnavtL<^TD>&W%F)LS4nt}T73^w2{aE8S?2vByR~WOdM+N!yff<@?z8
zI#ww-Zu3B+Dw2VJIAV7nOX9!ujfO>l`;d|vXtw#0QXN#ak`$I0n8kN5(2;87J-CD?
zHmL*sL>eCfe*GTXwvDI2D~K%nI37JKu}-!Po8ExO7L8{#pw*RuB`6KEDkQxqNdG4R
zbz*yTL(6Iv2z+#WI#BgSE1!LJckdfI7H#~xxtSQ;JHtJbofI^}g8L7|Kn}2;V?6dd
zK9bChE}t-w#v@|YYe!RB4PsH{@hW<i`qnD&y}W(E5RMyxlnbX)tFE;6@}0n8RW-{T
za~$&JRbhO+vjkLpj!_!e2VX(1f+_K;ycQWS9964C79=Qf$Q{0x<AvW&2GK#8YN@h4
z$Fv5&byBDKyBaT{^0ye|V?HXoMQUre9#Xm5O#@G+Lx(n?nbY>+RWHlR3f&YL23-N7
zB={^p7mTZ^ud}HaFV%4UvxHK!)luf%KBVaoi+}5rSQwa@bCw;vYHCGARWld==<7kL
z=59v02kEeG3Rm_z)Zc3=MXmaA)I9-9T+O+St{6L3)`@2_41VCAA&8E3bj5sZx5x4s
zmtI{uQpw=7HHzdjnUy|za5p(fC=*%NXWhuB(Dh_u6(6Y_e%!8tO&OI$^_@sEYZMc)
z<_`+vf$U0(c!m5aMnvIZvM^uI5SEj)<KZ%z$*XBDHo#YdR=if`c9hMFui05qNzGiC
zUF>Z(;;xrCT_CmpZM4!RQ9U<MA+*4MOP+&Ek?yS{DWr*nE)Frs8I1l`Rjwri1(<Xv
zc~QsAKPZ|mGQHa7U%mtGig@kqw6T<Q`+V75UO$U4y>sISG;<-MiaiPA(v1+;q7waq
z#DaO&yeXX-esRlYcP9QBezojM(;1VYYslzFHa5kqnhTql9tB)(1PR83ymJM)zr}u2
zA!bL-PF~HWs6_&|a2T`59w8gMCgzI0ZUSUfQfl;Ojkd&KMV<)NhcnfxuOH2mUXuwQ
zAM*!OvW!{`M<Ad?#9i#hS6?y<y67z?*5gXyD_ntuxo%Rq-Dl)+$D`dF-q;YF3{w2+
zihaFS^Sj`9WU?mkN;`xNJ__|r?iOahqg*5g>Xjm7TIXfL-k+n%0<XeV$&9>dP~x1%
zi$3~@96_CUQxT;Gzf^B~3kR0u=7eg2I4Fgw5M>k5m~x;XrP_^xUNLYFvz1}cRTX7r
z0lHVaPz&tCq!B@(_+nwtq0RK$#IV+@P;sE{>RX8Bn-rrhrkj}46K*PBvhLdC@?i7h
zJjx#Hk>f+3F<_Y0nG<VK3tBUe>ofcP^IE@)+(L~Q4*1fl-B_6231_D^dqI(^dhIc=
z=LA*Dx+nYb(z7F472oY=W@o*6`ujtJZ|o#z!EAVr%)^Fux|HNxTtvhvDsp6UwTFwJ
zM*F1zvWTTAm<sEK>TD7v5DPy;<hVjyT0(#<r={90cNnxk-(Ct8fCbGTAvfx94@yIA
zJF3zIF$3m3)3-X<Ue?)wP@UCgW~&MSIp+3kW10IF5HsYiH%A)K_+kz3=Txn~tq9+;
z4FMiV-}woFMe)&$Lg-gXz<<?JfrLU|DRFf@OXUY0UDHBk>dkkH$be+d!3z!mh9?~B
zP;G9Vwc=}F40A(Sds~L)9PeFHO$%36su`>ADF4lttX|1!{}kJEkmf<Xa6QemRUX~1
zW@>ex*_yNVfSVdD*&UI|G|lX40rxwlAPgKpuk`23wH2sCfRuKK%fnp1R#=<@<9%+;
zML4y^o|%u9_V0m5cLefgy9n<{uobfvYeu+aZKo0Ktc|gWw&pasMBNnfI2UHbKn{9O
z)8)imqR}+@&r{T;xui0wrvTi{YW)CT-RWebe0G8{202Acf|Llgnqf=$=%XtXfK4Qv
z=zT1j1nI9*CySKsm0?}}<#3SfXM2MsnAkgZs>SG?0o-+s-LK%L80d)#K;3u!6;8=5
zX@g4Fm=G<8m!gGW=R{0399feKC9Xe6!If(%Vf-@0mQ7t<U7Q?kHoA|nfK%TmABto*
zSX({M3=GT{P*9OqQFuAc^3+lS_f+FpBCj9CsjxbEu%w+@zKkNvCvBVSx7ala=@#+X
zYc(%hUVp)^kz8uPZfv8E!9}47*(V2jfo3Lbt`I@Mcf8sIX&Rdc(vOD8+ueyZlbA^v
zg-hMNXGWbeC|2hP)dRl0^p{y=d9|wE{%2C`UI(cWO$Kd``SAVm)vWl{jTUAo+gKQ&
z>BX0NzqmY|9qPu^277yohID3?W6U;XA5NfW2T%outqW~PhQ+n&nro#DcM$Z$THW`N
zvNBz|DwU7qm-tFK?Q`5dA&PTB@?7}m0eDq==<h-wk_LWNYjvYq=ii9<LG-3@q1#7E
z|LifKp;Je{sC?g|HpAcaC}e90MGi1BsG?J%d#lY76r`UU@&}ez->POEw^{A`Fa?qK
z&48UqJjKg|to+>?O{Xf0(K=JOzIa?8#vDp}6Rf^uG9;_RQ>Sv54OQdMjViE9g742S
zMhS8Ye+*}NihDGfGuOzbNvx`CgC7KR%vHu{O-ehz$6LT4Mk3SiWVM?^5C{rNs<(ci
zqw`nSS8I-1*=qA%mSmm%)UgQ`dsW)FynP!Cpz`|ATE_}k?|*Q37_<7=60FiHwB(_h
zw5+MMx={v+RgSy*%jLa^{Rki@+7`ox<LDG1erH1R0chtMIWp<mXh%1^W6^<iWy@+&
z0PQX~kt&UEb#Ay1+g2(fZbni8qH%I^>IZt}@^zY`)n@lMhgAPv!!2u;Sa^;2L@?^x
z%A-Mrjx%teimuzTAPSO;F~lr&gy>_G4IY{^P*NEOF|%r&ntw4|Ix}Z6Za4>|Vq}%A
z6pcxIPQ@tDsnqjX?<ZH^y#!1tp`N8s(fXGty0+{Q(&XSAID<rx5_o_0oI<P(j9<-q
zRAqTLH9LE2!WmXnR!;22z-2>bEekhr8)RQoOi)#Gg%k8s-M;;psx6&rT16qf<BAG*
zfCSL1#cSTG)@#_~MA_O9$=a)$-rFoXDd%5rj0vTiXZ^p$sAu+k4dzc6c`+qP1GAD%
zBIR<p@Tsu!yEf(8NXCadq!(n!M?oi1ueZv?YzI8a;X=z7S$rg3%Q^8uik&t9>|d(x
zQm|i=dq2&*4+`a7Tfs#LSH|);MEHt+!b{0d7;B0PK<1QGH_ynoq!E*2hGkz#6O9hV
z?$@wob1i#9kmr+^>ORB=Br!O}1{@<T1zBZ20PL-MFM%dT+}Y+I=?KoZD|nx|_>=Or
zo%h~IPq;QRxJrZG=B=N=LCa3_ths#xboN?(E~BH<vaZGpM_}t$+ZU-T8wLl@%lT4m
zgGSNTe1pF!xTNVQ#W6T4Z@kxP<g%g;M<BaTl8?vGj^f$+=!NlqL9>D0#-A0HRWBd%
zQcIeW%y@>zZ8l81ks#C7e+hpvP3-w#+7K8!Z#+falSF*kz#{e>Br}RGNxX7AU1lVi
zBM!bs|1pEQkrg!e8V!3s{|$r6OO-b5{0em=IHTj>B%>xTM<U8I;iHbhE81mhQ5)6(
z?os<N>{2fQAz|zH#Py4>+?xni_0O!81gn!QL~C|A^iO>kV^4a_%tZvJM}($5)k4nG
z1`n!DqAq7NrQbVbxd2VW=*}I~?A_RaioH~%?eBYLjJ5@FW1Pu+UAm(%H!%U>%pk7}
ze<yW~d?}VP@lV9+SWuX?sWWPBzXBnOH>jlDzFG%i?NWK}?hzUWsKEW<QS^xNu6KF)
zVY&e|++9UGueAN7+H|NCby@W6X!=~AVPs83&X~Fe?ssle0uWo#HN;W~2Luvak8W{1
z|K(Wt$*e#pjqLN=bLeHQOpni0$N{?oqY#2yX`+Y?6lG&NbTi&j)sr++TvK3xNST$X
zsiG9Bt?+Qg<0>}sW!hRv85emvYXb>bj9PjkEJUSs#y-}~vu{`L=EN&3c~hF@`6?yd
zt*{wD)SEe5tJzqXKE$Yy+1IchWywJgfw_Q4!wv!!5v&6E{)Mf7)=|Ty$5R8b@U^UT
zH*#GGHSYPR@bGZ$75&;Bj!Dh8Z%`1MNltRwF(-lxD(>)-*7(HhmG5nQ+i+Z`;k`|g
z%h9)2??XolklwMj)H3$J>HaS9heUSwj9nb|SnvxxR~23MWzjJ&wWNu0GHR|_`D@uU
zJcWrzlRcU6ndDlgFI8Lbxu<+@@QxstO@yNH$yd+_nh{q=e<M2<G_R2QRjcMq@8ud0
zh5iz7mDu+r1ylMdtfy(}v8k6U_<aT|B|6DX7a9jsv~;9g+S20UEtdePj&x7OH*|vf
z)VQ`gt=1vl5&J!7bqU7%wD~H%K8=2d-x7=`-{#8ZA65f7c-s!ow#|!ZAxms6!nF?f
z{*h&eBcwqMUaS@+UZ3Och(XL&-n@jdg;8a-h3_`|cUHl@-E)(SaZvL-944^M$c{Dw
z<Y#p`g2XN|mZQ!@3*{JXWxsgQO30<-9?#}=TQ->4eP<HI2C3&zOX}M#to1Jfl9CqQ
zt~K;MYyRqPrPwz%x><==cK*H3z8Y(<Jq$4U7&;5-x+DG6DTBA%IV#|+hZMc7^qzSb
z=vUcY$QbR}k(MI^?AmGfsfz-4=i~Fo>t_9COqt4~v_Qlm%pPjo%wZFKfn|@@9(-C_
zTK~A)tQ3f~*E<x;r<`5$a+bN(Yh%}2u^XxRTVY2>*=hg0)-;lGt;ScvIjOMibwZ4x
zJ_UA<G6+8g4xx_>lwx$oR%6XV>upP2|637WYo24&Q}Y_fL*yf-Q)J=sU0Ln?t+}=J
zO{6MCeh7$_?fo>?^zii23s=e9C&jWN+3Wk&N8il?$Rn1TVg8<ZwNV+ykwF!4Xs(|i
zCo(_~?hJHz)mM8<>b_3$+-c4t1EpM3jNP1tx-~ZtZSw|kM3YHhY<3yn%Vn1xhDJu%
z4Dv4H$I&nplNH^mY?|6wy=hopGrWsK{z&zWzg~2L(?_BXd*1qJV>321H#9~{E*{+K
z!e9TFLZas6aujoB{o2~V*B17dvd{&Iqsk3=Epw1yoDK19=8B`6=j}^sM*D%B$mSlQ
zX#nr4DX~ji#!=Nj_)ias_^{Y(lA?qcE`a>{=4^TOc?#56oiVbq2ANi8i&=TNn?&pk
zt`VtbWh*T;WGoa9?%8a=={cj52ay?-Yi9r)62hP4b&xzbC(HecT>GQPlc<;0Z%*7x
zZodr#pCg`OB3`dw!hrntXAoJmo=QMs$@kx$r(L<PPUxQ@uU|edW{)^eHP5ARwmZnR
z*^9Wfj~m!E-Q1o~?p!Y8btYhHaGgG@mNI+g*+iQMEyCYOy`kEGJL>hAPd=epl?(E@
zTyv?TwckxHOeIZy3=>WJv}?OuzDp~badvrF4<iz?E%L(;x+&^r&wbs=Y3kl;%ifxq
z+$rC4B^bqi2^0OPmdv7V)tnvxk|H!J|IF&go(Mi-HCn6KG-&eH)*8IXKYYswh(H>_
zZAYU~d}%i=v{4M<cN^>&=+*K|6X*V2+1Qvjc2Ko9YD}ENS~}lpu>xTCv^#n6e-9qt
zh<QHMJ!T`_a5+WX6LPjGr0A}S7f?_%TC3UIM90U+hh7dw4_gIlSYdii<M%rTsQcaq
zX5GN$+kk(}d(SAlTxlLryZO9!Emr>V_&E$RMR>%`RQ@$54%E!G$j!61RAW<sL+Y*5
z*rvS|R}}6MoRK?uT<B3f>5b~GSPP)}#v)oupgLY4;dEuZK@1+Gg;XV}I$rIL*jyWr
z%#b+Fa2-|41c5tm(GN?a8dVl1zFisqiPky)WPO?`%oSsK(Hf&IDaL(<A`Wp@hkoQS
z&fhVeyz%@V6aS`U6}8Z+`|`m|khs-LO~6LpBO@BQG`v*#XSnWD^7BI%jCg6OG6=_t
zKz*iaH)1kqqKkGeGC@ZY;u*+*IDlkglJntxqz@WERrod)v&shj0q6k*rX2M|lGFIS
zmX`?B#bFhxHXVdnh)M@(zNk6N`*|#^6T^3NzR-W4K1KQ-l;B)Ss(vlsl=<br>r`%S
z-2Wn#BoRnHfqGV*!s*;zG-l;5+rkmw$u*-sA!lNdlNI<wQT5v`npU5QxW4X9piIUd
z{sFq|JO2+nm<gXBn{E0yYhjdahK-?8Ds~zwQV)O2pm(7R8sainbUP+>=^8=bE^h^&
zEODXG-PWduHouXLwjF4F!(35IXa!Q$a@o0)hwQe^4f(f-JAX*4-Cow;VDb*TZdS@H
zqUd9T*+%su%e6L7M5t%M=UJ7V9HyWKQT0MWs3COo66`!uFnY3gmQjYiy2x8XhO@)>
z$~WPw(}UW1aF~<F{LXcDpXMBRu1IING25N#GB-?_T6#xag)ob)+8OBCbClKRdwtX@
zz;8Xc85)=O54u33BCB6)yJ;nXM7D<P5%i%}a@BZiX=rG;CW8{_=dBvtAw}emuvujZ
znY8jH*kztMwFXlub);D(yp%_S<cfilN;I0NGK`6=+n$~PPYs(|ooVNgvN<f=<F76C
z{X_UN&0P6vs<x&wr<k@H|7C>-s=CIaPH+8kG4exyi}ai$+h{shB*3W0rRF7=mD$#s
zvR#Q@SDXD3D^=`Ph`BRQ^{vl_$cFGe&)d~zCy%|q@PdImLSty)@pAQ1>&enPc=}Hc
zxK|095i`i|VQrKL0815&JK&dK9DdZJTv=}cxe}!(rRTVQ<er?C!wR<6+&5TfaXN>A
zz>Br`kSb^ePLUvOWki3xxKlM4deNqbyEV}je3vb|B;s5&FGql9?_#CDoYdH0y-F&x
zmm<i$`=LSmQC4cItJ6%E`(E*9r;t}vvao#}+u9A9apfQgs1QpQtZIk{=!S#~FdY|D
zrjM#2?Fxv-XNl9aa5KLrQCFJHO>EfNh6h@>F{QJ{ho4NR2lD=9hGNH2oIC_rb$IML
zpQS^1(_7Yop5+Vhy%+YHF|E`%=bc9rjv2?=;WM~G<|FyL6?u#%TieI6z;E_?35N=+
z0Ixo25mhW*iKUS!M5jj`B4Aoh4{hmH(BZwuOSArZaffRMr0bkL=(zyx)q{3nGIFCt
zP?|CQYOzYk5rJl?01bIJjV$ahRJVSWd3!3Z>FXU+^up2{FBnzM>P|-;XGsVkL5`RF
z^7=C<f9@(aQ7SC1n{RIDd)pyj%($<hNUBiU`g-EgxWGG?a!iM_M&EdSj?$!n^i$h>
zeC2+{=kIBc)0DD5`G_YoUabnci0OMA>;XphacRZ#+lS*D8?ARGW7fDCOLMwkx#)by
zx#YDL*_I7FjrWyjTBGud;0GL)qpsT(*rB1J-_=`Uw&ydA;1-mYlcj^y@4#eC#Oae{
zJMzbmnKyLiYBU&+6!x)<Cgmj9km91v7t{Jfg@>+AHU8|r(4I|5gXO|yvLXkB8XQ!H
zX2baRkI_{jpLFvC2dRbFcD)-@6RwWk6)$7O2aHGPQ4w5Ljz{X^ANl66!{l)US^OWr
z7AZob!By7dm7H-cRkSe7adHaySI*vu#vJk0AzD%0Oj~;1NL0@B4>hMui3vafOxJH(
z4|j*!N321k^8ELv`Q|voWIy=68f3oF19ight;S<WoJ2XN|Ie=nC{-k%<#~C{_k!|}
zKx?vKL;*<_{vE2d*UTG}7$|@!v%CX&uq|xW8yp}k){8POB>N>tLXSx=j7MN<#sD^G
zXN=O6OXa?}ym}R~{&5qmA3br7O-gH%p>*6pf0>se<q8GWg#y1~G8P%v-<8*!k<K&=
z=0BHE>X8#r;TT_si#b~RwReA-by-m5@KaM)U^CF;34yDGKb(cEIZa6%3o05E4cb7*
z+;9{Ba~%6OZ?QP*qY4Lw{;`lW<I1DepD35yljqy0g)U6eb+)$6-k#r_o=tYanjxA<
zQIMvYFUtli4==F@Zg1X7DlkGCH<=O|BRXX|v5d0s=D&Q$G~?RDKfk{(2)$~1Ykql}
zealNwp@dLEx?*kIRO*VY(tmKuN%y=>{Fw2)eDG(3ZA~DV=!e=H;w!?-D#OdFS1(gG
zyzFg7o63quNB{kdv#R(Yms~Bi4g9(oQwOYZYF`fcDwZ;-e&+u6T3W7QyfyOLH~hV{
zcv{U@RWmFQUhZo-NV~bPb^B)Ma;IYLenRx_^`LpLomh?w_P?t)9#vU4oFt$%US2J7
zG3u77_b6!)XWOBm!OJr?p02gOc^iVO`vx^92<CKcjq5jlp;X?s65k96qXJm)f9I%j
zv$T5(_S~(5X3Ba}IIEi?Re$#)+Ul=4a{DINaq9!^Empp0uFvuJL*py_H#T8s+pe)_
z>i{QobuWO~{!bcylk#?ZolipoAuKZr5iYfc{YDSBTuZQWm0!K#TmjNYXzrs)cQG&h
zs{O^UW3-$Pb6!s4t@cgj;iXW3B7S7t=z3bJhFpwR45Ez8fI41>sx74>ekw!_IkXfy
zaL5ml)#=(w-DY<ZR=(COZxZjR(@q4?*wbJ%UP6!Tv=`Go4mMaOyHKy)Pqk9anC+96
zYYfd?GU220%vHHajE?DX#>W8AfCLQ1e{;|xE}b|M;gTf5I`}KA*Be@mJHPc`IVnmN
zKzM}j2YhkQ(rua?wS`rnM9N_)A*)+I#aruc65|6j1X`K72zoM*5Z~k)`YpJg5u#T#
z1UnK~t?@aOUqv`d{*9m0_V4EBFisI{SFXLr&WL<CJ0^R|NCw%HHoFbZXkPfE>I~tQ
zdF3Fs&^^1nyLsQF`roY8z^SLRWCE{Et)_#r$;h|s@RR6~(s*+?KO^%8-RISZ$H2>s
zU{yd|BIT`kpIB5PjcsOqU)MkLBt+l-ru8wdyMpf<xCt_RP9+&{@nu1a2Kn~aaebRO
zPa7N^XkZxw^CLUJlU|*Dve&xXeUY$4`<V8FEsEv+f8$u!jlokQ%(!dfrUu*_xLNg+
zAu}Fv9@C3=4th7^&FD5$`?!=4m}m>~uKXlS!ZkG8fCc|ZBT$+q#M{L<YBktjmz|C(
zf(8D6t8KVB?c5&}Kam}vkHSjVq3xJgIILbWe|)7tQ|vk=2AIhI6miSJL_}Dk%C-&j
zyD(mZF+z1>XUTT@!$(pFyi+Z!=WrIl!ht(fbk6;GJYVD*)Qw*}LClLT+2yS_;POgF
zq9xDxnSU7MfAAHf5i3~pi3m+?P6Eyb=Wi3&phKKk`PYcAC-FI3!sn7~p9jc`Cj$Q8
zuHDipWtBYU8|yeb(Ipdt&#=;h?}Loqf`0}UBZ!p$r;RqQfsXP)&wO+4Vflp$K6?&Q
z;twAQ9bh;;J&DQ<S5qYL{rcmDwioBt+xP_CCWX*{-#uc|#2o$6?QCM*(%tEs_=Te^
zyrmxePhFm9@Kgr4>?%~cJxeA4^Usg<FPuhOM1W%kjbDS=saF%m|MvV@a-fo|&R8uT
zrp=2WyOj)(r+2Z@QJlU@`PAu<1*jNA#_guD(w>3;(?o`E|Mm8(tG|Ayr6JOM1hW!Z
zqxD=krm74NT!{cb)MHL-r<17RXDy8XM(g;r)EeD?j?WYa&0OkUiQjcxzi13nL8K!H
zeDiiC=kH~xEt7u3fCSK42D#NOh42IayWdgWtoKjlQnwdQM6un!^>Q};JNS3NxvanR
zz__R3*d{xY)ysy%#g0*R>YHm?_pI#R?Qj044R??sFMD2~Kf4zvu{NBA_$usENKfTS
z4Gaw@rs*oK<y0{I)|jUd_s#p?9(eHiIwT0q4+XMwkUGT`z@r0dpZhR;Q*0Y}*eQM#
zxCXy*&xm2h>9f_aLy@FV(2ZI);S8rim-Z8N3*Dz@+q80$8+CUpR`}czcAl9#Nm*w`
z3|4wuio*VcAN5^%L%@{ESF$qq8bp%5q0YxJqK_}<jFwNEUl8d)3V8E8rQa%FO2R6=
zzS3JJ*}|4`V0B(!ajV{mk|4HyLF6?~?Qcm|W{+hd`ggAQJH?Jb_pC+0xS7Gy2uEX}
z4z(O;Cz)cHpb%Up_cEhx^+FMQ(h17>=U17JDLBB@&VnLzg8n{M7<51&(7bIU0jO&t
zore{7s{$>&?z~!j{}cowSNOHUwt9R85(Umm&g{Vt?c}9`e7nV{JA^-{`()zWc}mP<
z`6vz@TnCDyM`=+5RT8M76SsxK1reI)_I0bypU)^%KHehFfB%DUBrq5-5*yhuSmA{K
zg;^?iEVP{?k%jiZ^P{_rUv90*a`V}0T|DlP7nH#NEk?)g@D!tQ88(Hzh=ZT!Ipr*U
z`$%5ehv&a@uTgn1q`VV-gj@&HX?$b+@rmi(FbA5?fQfs@S1S0_0zft0jJDHE{%Koh
zJ}Yt3x&j;YrLThxA1C?y%Im9L>9sWfg@~pxH)IpP6d7j^Rp84-`?w#;l8_>mLOU$b
zsHSafe6DIKD~U7^dD|Fa5hAcEABzc6^Ktz%I<<hETZEBdI>)h8d7rUL$;n|Or^b9<
zreST<lh6fFh&yDr(1K0kI#@;+ZO5BXh}%K}N0JeA{d-qi{%R-j9&RHqo>STbv4S4e
zb+4F~=Rivm>wW8;?bgzr-caIP$L<pEItK)rY*A+Ya~|??okgcw4q9nD1N<IC{5oeV
zCKIhDOiED!VDd!o@?cs!FDhNRhvW+~{A94vDw%F@f`731-Q*svf2zT&_p~F{%%Ao7
zUO~vzhwF3F&;Vs&;QT!d#(C?{Ux;kt_na`<{{n7wA)^`DY5f<_q>Evo{?<~D?wb*f
z<?ANn&vH|QBRd*ht_uNa*r5(Pd&2vpx@w)FPV;3e+u!o2w`+L*rjN`RvNDQfjpk^V
z*ux}05MjTe=<RWFbyzB598U_o1IHS4y7r>ZzmBM!r>(u$Kar};P##{zdSDu1fuBpt
zTQBv*X8N3?H<Vk+N8IW!8Q>akuultkMtd4Q8<Lx**1!AyIWu8FG+m1d_>C_V4LnBc
ze2rw!s6?G6Uf98Phn-$ud5-UQX<bH&;M^mcb?;6*D|Nk{CK}N>r(!yslCjt!C&F2N
z42*25<xX(N0_8A?JSKWi+w_%FQm}nyiJeyJq{nLW&@nvmm0L%=Bt?rdOwe54+c`=)
z#VhcfMh0OvhGFNwJgo1$WE+Z$p4|EG2mbGPpi!|EohCK*jp~7*ftew}a9^u6O_+gW
zbK49RRPfra|ISYf-2w$fG$svPnF^SKBAReh+;z@xXw9F^J598)Es32mMc7aM59YEe
zcf*7L=Rex<&aa5kUGLzRwC;;Fzhx>0>QOtI?~TE?4s8%=3ts;Mezd=8L2BMI?lDT`
zd+-%YaKTWgiUykY6;X$SH8WzJweL&qkIL~-{r2?12=un^tCjyE$j^eWlG=R)b31$4
zkO%>Vx<_(5UEW5hTP8D@Bgr(i{ZlwprU{UL2MxN=FqS}t>rLg&(9wFi5&|a?mrz&#
zoRbHGs<#$=Op@a|-xV_Vm;kCqZ$2nWvjFWH`@0g7A6!LRVA<boUH(&K%j7@gVDCe8
zjXv^s6#;jh;4Mzo@UcBaJP<<5?u;+OkRktWf^UW}v&8PKE%i}zWx8jG#{U76Ky1HY
zt9=S~%}mY^8^s>WKP@LcmdKUJmGD^juJxC{MLX2GZvG;>X!!?68TZ^|$=XepiPnI_
zw7cM~+XO<*d*G+10HH=PNat0<Zrx^Zn_UW9$6f(f#!=o2YC$x$8a!sp!9%AJ+-KB+
zz4jRp&r65xqm|g9r86j8FheyACJpca!y&m~`>7nZYlXwM@rPmO<XG6LnFdnb8g_v7
z;LY9+{)UZQ2J1by3G6kBKs>7qLXF!Qson(VS$82|Sra<}4PZMZ7c8b7fmPo~Zh5UZ
z8?C7AAgO@JmB^Lw$JuK7FPee+iUh%!WLW-D7|TxUKs2)mc23L(zxnOpF{>7~e|-~t
zbXysjma)vW3S8&i124Twu-3@uWC36HbFS0tID++G@BkdO@4}9WIp8^;aod!0VE$I4
z5;fO>p#q#OGeyM@^ah^>oA=vc>$sD!WAYKOo00&|IytaQ`xdy*D`N*(3eq_ZuzOw$
zIBQjakA4H}(SHCUoigxU#J<dudT^an0teP~fTwO1_%Bj`=iGa+?wbH`)Je%aCb?$a
zOyj$WT!~x>zd`lQpGIf8|7aJx@rPiiDYsd|b{%#vtYR4|TP4qD1Ui#tqq>Y+bmSmg
z+z30qxeji#D!^@KHArVQG7@eAhbcu6u%r<rvunU*MhRF?W<N8h6!sc6gY~pju$~eN
z7N6b(6SbR4lm!L_2&Sv-1FeDnpfl(Yta_sWc1^wsk_DOIIwOmbWd;bfuW;$O(~NtZ
zkc?7*aM~^KH)saOsrMjsWjh2JH-pc@T8J?H9)edig2((4@SMj8c5wrE%)1YE+G*gZ
zl?HC}&z(LWAzwx}6_G2EYyU?5{hvm}ZflhtF@A73*`@=eb8oOD><suA6hgq#CJ<?t
zLVzJl(B@Zy>+A~fUC79DP7T;iz6<U;HQ34ujx%n--o>qqP>aA;GauX-0lUmB1ZVAH
z_OsO>oKgUmQ;vh}^my3zVKK~m?Sv9DSJi{!$pfW;*{indelQza2iBidfaQ!sAexo|
zPK*$(r)0pcX@wB7vWcC5TJYAZW`DlNGS@ng&Z~hyBLySeI*x!{=iCE7!y4GTv>AMt
zmVuXk1^f9L2wK_(A#2#*o0AMKbJJ1-)?5j{o7qg$W{F&hT>Bxi_OzG<&uGuwKfjIf
z$8B($p21eRx!}LF0QN3t8K+Sl1g>acoYKfv&v!w}2zD<c+C57f!F!<`9Hth4bapc%
z)^?WR7J+EiJ(k3kg8SSuPL|xIeFvnva<-bTV!uBNHkw&rJoFN1smPRBiWSUlXpMVS
z2-+-zH5i-@w(lvxX?6xUOiP4K;|{{^#d%;q^%{6BDg~#hWh{fe3n9xDoT%($Pz~bg
zEInUP$<>;Lm^6TFX*IadD*~B*3&<8Iz)iOh_N{4x&{fS4xV()0>{SrXIL-de)42zC
zT=V_D`JV&mh9hz%a_#%5IRC#BbG?4r5j;ncCegYJHs2<L{p1v|ns^eNXPf~K-K(&B
zVF_E(7lZqpatJi8<G96X=1mANYKEXywcwz|h;(i_TN%q?&+;np(Q5{WDfd96Q^Z!!
zHQ=UQ2hP(<xWrF7|28;iCxhMB#h^Dh5he_9R35obe%03i$#sUx0nkwKg4u(jK``_V
zIA|1t`S^oiJ}wNzb65sDy?_y^9Q+p7aG9&Ge&<_7q;sFWJzBWBGSTe2;BU|XQazT!
zFJ^C=<+U7k&#wo+rR>kk*xSgs93s}2gYC39u$_8}eepBkHv2-_F}GWG%{AYX9!um(
z<k|<JsQhW@>774GGer*__v8MIZZRi0t{)o=TgM;mtgF{f1@A>Sz*Fx&r<FQSFM;rN
z4`C0>V%=tyvBa#2@k$NsUcfkLVHNCNR0SThtHEXFUGQ5}559VhEa7VgnO+;XOl8R)
z%Wx(0a#?bB4$McCF=BOQNu+&*GB>nFO;-tl$tt@+bD%d&8R!Sg)$+h*Oc|`77zD05
z=fG#tCGgZOV8n^t5G*xc(g?vTo4GIKKD&%d**)j7>{Y)Q0*q_GcafZ(glY&jsRQqM
z)!@Cj7`$|=A!5S=kQ&?p|CQIkb#@k5Pf7rLmK{rG+yvJdSHROK^H{-|CMw+`awT%@
zBWQ2>Wx)0DUyZXwKRL#4{2rn<7lEzz2@uW50;g%|u<6SquzBoJ5PTL4Zu7EX_mb-@
zfvaYuSP3C3Tfl2!IUHQq%CcF;D@!W5l`_f#vPDg>Tfd4+@?2)!WB*nO$4%~YO1av6
z|HX`-3`$wndx0f!=eQ=RDFbDU<8}*PQf5q6@yebw(48^63up|Kz{1zkz~Y^H*g5$u
ztp3awJmzJAXjTqe?pLw{ui~l#b}z)Ge=+P?S`TjX3&C;5ZT98Z7uKs|%l{TQAW*QA
zQ3{?5%D|nyrS`97ZxzETkSr(!kA;`ObzTN+85<27zl>zr@nNvlJPndr*BOalJbldW
zu6yaFmM`e$BoKNp?wt8yTI}ZU_T=vV6@1xJ-`n6Sm`~adn<g9t;nZZ<IWY;gd=&#*
z*z@nFpU24Z2JBtIer{12TP+ttz{+X}GH&1!HP89w;Ki2txM3AwT*r~9M7JE==9GZ*
z%mNTiXTP6!pWFQMTU^UHhY{|K^Nd*IVAChLp#NGbOk|m>_P~fyN+s9%uO*1JRQwsS
zy2CV;K){ZzwL=TRdSV_|>*_e|G<ySFf<U82?n~}n+6bX0P2jhr7Ix_rK=3NI{9jfB
zLCX~E|0y73HT(bT<gjN2BjTks>@89Q9&<}rdS3$v);7U@(+ZF+$p?GQR9N%L0dSh0
z4i*|mVaMbcu$dAM`_~jgqII+MPTY@kTN}S4J(fV|O~%z{ny00>v^pL$ZwolGwgY^%
z8$dj*7|f>zGtxW@J2ayi+2+IMua3g{&%;@gbp!&J-GZ>yb&OL=S!P<vE&U@lbb!y|
za+aW#g3N$%%BnV&*i|#Kt?FDM>osuYp}vM#mDC8kv<unKvjlKq8T&iMV5u1k+b6|>
z={xzL#a84DIWH+YwACWibOs&j&=}|mlLzjGDJs6O;`J-A>x(9^(`HL|t<zww8OOfR
zeb~dY)_~;=;H6gqehV4d&aHxjCf{>a0Y3WG?Dr4Y$zkNVR1QH)TfuKp4eVoC>%nyj
zmd!RpuyGR{SXU3nEf_IRJqs2SPO_651J;w0!C`tTh-RmOn?Wkei0?p>umO%+)p+L}
zRT#9^|D-}UE`h*b)D(8Sm*HPyeqc>Wc+`d_aQ?g*Hmg^{mJjd3?!|Xt<peQUOgaji
z#xp`4e*~<)jR(u|31IncEK9tu!x7U~#w}G4zM&QN8r3tdX@K4HYdOs|WKAu2FDZe2
zCJL@IG+=21OX#Y>-w>+`8rkakE=YB&z+1l(r1Pu5XUQGz-?bWl8CI%Y<5uLF1N{Uq
z^+f2X9JJI?J;Y_Ls7=fnbQG-LYhugy3t&GbnH^+2OSN-BGQWhqL9isEhGn1C?29rY
zHDsi^t_^}$H$a4W3xus}VSjFffK_tvSyT?eYpPkwUkSbjmF%Qd!#?(Nht`*a``k>h
zo0I`A)3aF?n+|3Z!eFP?aR^va0It(2!SS<tILMX-;pX?@l(50|-nsTkbQ2Q@{6a_L
z&jZc})tkmz)c6Lkx(mBB@4@D`tH5e_E7-r?0nU?fGy5L6&QIf(={A~4u<A2^wjxdg
zp+*K<?q6Zc{{lF;wvKU1CF2ve+BK@;%CWrlOF0Q3Y+XAiH@fTH0pW~m;6A^I5iR@k
z>~famu?$wP99*>Tv!5>mAH8~(xn2clZT5LzmBLKbNSHi8lK4_j##EKS?8yVYQS@cx
z8UtI@8(BJk58QM!VB7c@Muu6O*MO&P8OuPM*&BjouZD8i%ib`7#?`Qwy-oHQGcsMt
zvRn3630P6XveibAu~hwlNjvx%RKf10g>Z093&d<wK*)+hkj*ayTaB~q4VDa+8YjSZ
zT0BS=oM-=TIaqysADrH82lq*}5NX~Bhc{R5iCAA2+Hn7e5p+`%2tALxDec<f8w-LX
z*OxI8ybWuI6~p?WHLy*+7A%G}!;ZIF!A*zp#F9M58@aG%oG;jFC4<xSOxXEt3Tz$6
zcx6^L95Std0G4?9E~<iHlUhceg&b%2FR6vV)pC$6WB-3;6@;2JGVW=FJ%$aipYe#F
zVJ+jCT5fMAXcgm~rOhnMm4jq%4%lm-hBd=(vaHopt}#$Jsz=Fn>_G9T$tvD*Eta`X
zRSAG)ujj(Hj|xFF?+kd(y9{o#&w+Se9(XLg12QAbLTe#JAO|n@wg@s|>HNkPh}iHQ
z_%APmgY3kFnKi=E9c>V{z6rb+-G{I>55U{75JJ|<*$FIV+3g*$7=Ik>7`g5oe+F#7
zP2)5YYwZ}=FDQi_U)%+UcOHOX=zS2pQ4YIjH^I?O3fQ+)9(ygaV=3L-1VYc?{^iCm
z4sE+B+h=k+9B1z>`!F1|RS$si>-lUMUceHwI<S7L5p3UY1Ruj9aGsmOR={Ur+qcnN
z=4z*z2Bx1zfYrnV*tg~m1g$7yOZ*D(U>WJ|MP(pmNnGffMmQ*Fhmh6v5VEQX{Fbt;
zl##Fh@(M<}b=>MXbWH;U88t$vaT`c<tJu%7KO2{Ft8JT!SGd~N@vqt$yu^pl7$_Yz
zRmES9C0X-dI|-)4?|}WRGq7pGe(=@3$+^oMG;Lr@d^v=!#tMK+IJmwMb{m$$fi-R5
zv$%r2h1%iJMg_##J%s&ho7k6USjkR=v4YE5Lj;xVty9hZ-aQB~ya^)hi{Lah3mm6r
zz~*sB!9w#W`?m|hWojYVkE(_3>Maayu<nf_*!XS<c<B|v0ps$+36=`)()3?6>1HPo
zl;i_Y(DA`h$D1ypD{me?wBar+dp{B;4R8k?)o{=q6wi{NYA{i|3zowhz;0v{h{v{q
zNcSQLXU4<EaR)#+Ed{K<Jq=b9lE7tpE+g7g;573LoZQ(AhqpB{-e`t>tDCu%@Zl}3
zj3XLguW==W7`HI;t>@}peU=t;yc1^H0=v<m#eikA%h~VsYPn`5kNFqS6dO$6y8?!T
zFAHAcQ)mqIAEm9bPmYxXCU4|}XzE?|COHp6_O|g}a0UF0%3+_NmU~NhEoPahiJUF*
zn<2os7JQ9L;J^kHple{y@=6F@)d+#hYuJfsh6AQ`EL&}cu#GkBXUkys;%jV)a1vZ}
z&a;zt0RoNgvfpQd)uecEUwjsP^lHHUt5&diOTpfRwd}2U9hMEb4*G-BVeyD#5VfHO
z61G2(rMb1*-AZlOqMM&UcyY*ykT3IHbSYlCD3hBOJ$<kbwv)otfqU6XcMmKaoXnol
zn~XCG!HSWq^+-7c%y|g@%WlFhoiuQmnhF*Z;#pRi3T`@=z;a>|NatLE2(x0wA(h~}
z^ghQIK`ZMZa2fk`c|H4mEd;V<f51vP9NGLG*Usv{qynP1wR6o%VS+ZcaxUid*8^+X
zVV`LwNakJuvvCn17?s5@V*NM43P)+G_!Jln$pGOe^&py?4i1wuz(xBU>|-RlcWEtq
zTQozcNi9Tfd;k#}+Zftm?{Yb(vmW3269lfR1liJ32wqbLksBT`(yd`{mPR<Tg`I@e
zO^|5Mve@M;GoEq=9HyLut>47L&PmDOIx~kY4K6{@vN{ld!#?}nA7SgTa`sj%0+ZM8
zv5R;X=BUPij><tW9TN|cYwIClXN%Nh$)(uF>Ic;2MIby!<i?cg`>)824qAEbuy95)
zXulzaZ(g;5X#)dU*6POX(M(qjWzT0NtWqmvxB*+$tHI{I1_(541vlL+u+%&TYrYJE
z9TVfhW7ZXLoR$vTzfS!B*?SM5s+P4~ch_HMF9RwFm=o$+>e6Kn<RBR&i-;gWP?AW_
zIZDnMNrIA-fuMjOhyim>C?YvXFs-%se{Q|^8|^-)>fZYAxqsSwuQ0o+Yfi=-a{^;_
zzx}*lf87HKx_3})+mEaxy~wugWzd#r^on$%pY&u5`8Gqypkuj5N0DaSPa;Y#S^Fi+
z3W(HviA*zY)h9un-fI%^cPKeNgb=yTo&?n%xj+5di@w0EAg7f*2vfNMpS>60E7^iX
zy+@2*Q}l;%+GZT5k4+-O^gSZ!c!AXz@~jB$P5an|NHuwl)7BqQ;xNrHpL;F!P%m<i
z^`pY+BeD)ZVyiX0C7R(bdI`buop2Vff&bpig#J$uCOH7ll|v-1y-Zxq1zy5%-b1MH
zm9P<W&x|1U1$&5f;=J=DiT?AlEbptq-7otV@;U~u^6GzK*QzHUmt|OXW(2C$UX0PY
z36&+`*gYeF`dtF`yI}16&KtYG^JC(wHm3#$=XK$zU^lFVxJ-c|1pGLTSe@5ImhJG8
zsUw=qC5XBVr(L!1m2O6$Tr2X-Uywe$MV3Vm3hjr8Vuz7uGr%UqbB~N8@8}STY99$K
zm*3irbWUK+dXZ&DU`K$)t=`J97-6frGK_{$c(kw0W<!n0pMERFOJq_cM)_Tji)1-`
zr7pAC{B%=7bHa2kZ6fVZKdXs`uTbjz0R`5hM6|suZjx&HlE`)psfS-9op8U%ejGVR
z`%vsKP8aAs&f0b(M*Sv&_jcf<(rtK%HX%@<6<%@|kZ|Y@VpQM5fBhJZgl}Ow{~-+d
zZ(;wucBt}IKxy_Fw#oPI8G)>-EKEeG>UE;$`*4-3ZLLnd!@JcCukz}DunxbU;%kiV
zJrSwhQWdXz1N(o7VFJ42I}Z|69|kj9zjMMadd@9AlAV<X-MOvMn|B2k^Ize}{3q~U
zI)czW9}uG1i2#L5@Q^+aZ>dHW7I5Bq5#jQ;5vzFvr_8vpA`z&0FY+u$3CaeLZSfvC
zM+n^P`;nmEjU;aI(UCzC(>|PW7-7yh!;G8c8ep;3Q)Z(`IsA4qT(8UgPrua?q|{&@
zEPJzui@nAkxJm!;019nB(8w`BLfOZH&m5t0G1e^l=Sxpa;jH5*&e}|o;0_V3zDJek
zr*9XIaKF@PjD+_Uk~JU0N8$=R_B7-8)+z)@cfeb=0rC59BSEVVfg2{^vT%&Z^&u?h
z_rQq%J~ZcCgx1_<CaN60av2UgW_VE}h{2&B&LU3ZC64XR?}{Ni(^1o{#OpM?%B%nX
zwY{KEKlAXTf;8hU*zP(D>3QKS1hD116WILSaY)RFX8mpVcL8iCy&Xia+-`atxth&?
zLFD=dCxl1fw7eUM>YS~A1#bc+FR6NjD7C?PcO6`I)xr9w5+v)~NB+?lNIpp7YSNEF
z>v0qxpC)Y>L8{?<6rC7D43RIFZIo@^hg>4md`nJDhnX8rHtgYC^JI+v)1VqB2>j`{
zUV^sW7YJ5t4T{majRGznLiV2{(cEK$EEJG__#LuLhfwS|fl?CM94q?S;w{dc7-6sH
zSq{?$A0#2}qvLN-e1Z!T+(v{-7yPBJ!%wOe-qM%p%V<E@zGj>{JPMZ|U%_c%FB}&1
z!&2}S)ovOkTUl~2w+}6sHYPqZl15c8HghRS0=wfoPaIxf27kF5aFQtPED3q+@nP@_
zZz(OW^6I})uUGY``0cAb=PFy;>Lq^;G6Eq)roOCC{q$!$Y@gwdT{C=1SVO39xwE?K
zJ3mITTtC$3?}P#WHI{;9E8Gje??;F#2a#ra2Y!1m!$GtHZW8BN*e^)tCQfXtK@sUf
z?vXdhGJlJ_W1NQcp}=+sXNgYpkB%YFx}P*=l<F{Zx@YXikbZ>3)_jb_wjZZ$N84(g
zeir%D@2#{(KqSv{pdjf`H;p<2$h90~IA7^Lg?y_K78c;dw8V7`7kqv}h5HzaY)4S-
zJwc<-2x`5)&?xl*70#nLZP88k|1KQ2*O9n(z-`ZE1S+&3P^lRyMo*EhF$K?6LvUKq
zha-Y7a9H3W^yjs+g$~lQQdoFEj6{~Zn*z58f*Vc6W^f~}2lg$>#esDxY&~<JN?UzH
z+B=J(caywHFJ9$UF16~>)QVFMU9k!Jcgg~lo1wBajQWi$392o&(IXdQ<wTWpg&e7J
z{Yq@cN%pw)&yK9$sqs}qV@@3`1fRos;V|qMyodLXgG8h~IA!z(PJ3$LC0$3La|N!V
z^>EtOh%osZ$TfdLBHDu@>j@S|<wA<pp3_J*eTH=NZbqqRiC*(;dXZr?NRRz2OW^eJ
zp`Id}Nx47$-b<1Fm|VW?U{B7`_eeY3jWqL@C~+jbclbb~P#+Qxy(CKQp^G$vQm1ix
zZ3N}6AJ~ekYR@SW<ku)W@gC{>AHz%Z3cU8Tv8Avl74E}BvL2_bA0tU?5Z-GCVK4lS
z<-D5AzXP3l%~0hlCrXW`8p|qYSGf4kZW?j9y&JioxkkXnizMdx!E*CyBp-N)Gp?^A
zZeD!D+uD#<|FCte|I@6qUQdD(_TMK_y#oF9ao9P-8(U{Mv)!Y(y7kXa*!mqOpeOPD
z|2XjN_)I?*ca@qE#~dSDDnGjfM*I(PRIrBtXb2}3_9I?-nDpQ|eB~~|RxA%T+ltww
zwVP-o{KRg+Pr4aJR^2GJ??WNcYNmM)k?R1m&H9mVJ&e4gBLrikD03yva2`YcF><&D
z1Cv$WlTLs7qm|ra{pQ8TCwel>-Xg)^InqqHT(nW-+r1-vA0)A*3*|C_QujfWoR~l%
z;eIiVN;MwSM6W~0F@6oZ&6V&LZ%3$n7d#|rgcGko-2NMgP<;*mpN8PIWD2%I-;$IK
z`ENsgPA$u?6PpqCO+aUId3P~PV7XD2YXssmBA5Vk!FW*;+e2&f5vbZgcI0hVvHSDz
z{s+IT;&nD&{iD>0v5)`Kakft<La)8TSD^uBKjlMowm;c^R{|1m5>H<eSVu;!9Gq}r
zfNkHoFml~B!;jm^AA7zFhV;xt_Byv0iPG#M0-lHDDj&mP!62NM_99+mki_#nJf$zN
zu)s;hdjw1m$emt9fYeolsWc<U@)43uAK<jzAhZ3atvGi(M#uX|nBO7I^d-w%EwUd%
zo^@YhzD|$8pZ=&N-)T}L<<OhNbYmh_M=t0*OaePXqfs9!J;qrqrN(;_l`hll`T3x6
zlsSGt$?*ZC9l8r2DJ~uBGGbMpB2MiId}J;oQtK*`4PPU8#}GW14Z%w28H@$GsNRLv
zoJOe7sL9=6aW7vc_RI`oGnle7)0wbx4S<UqaU<^b@7(`)V-Y2qwcSyRRHJ9eHhr3V
z<II@O$I*Y~#bbH(cU^Cs@0E+*-&Gc<bQQL{%b>nAnaI=uJ7&6J*Gz(snIYIY(~DJZ
z5^L*s&P20b*h1%Uiv{*@uXE{FGXhztfCHPovvZ(5w~=7yCai^@!DZnPyw?vPQLmrv
zC%|nd%B{e3qkiosO3$TlAyBp*sRwVP*zpxIEnlL{X#zE#pOJ4lOcXneT#F$R*Vm}<
zqUSc<Z8bihxBZD%zLf}_8zT9ZqXnsl-XhDq7ge4UIOj8sYB#!ow%oGUZq&F>qv-e`
z%ALkh>NJ2_mm#F<y@1P(%dp>m4pGVv;3{4RFWEY>1aA>0{T^=1`*2v`4hic`m<c?^
zA^v-iot?%iH;J|TZ{jI6E0)pgwm-XoyZIs)i{1EVOP039O>~LP;)3<wP+ORaAdNQU
zT0TRS%TUDYroT!Iy`2`|bwpnMJ=MEc-)ukScrP|UslCx#wh3~=fs8_T&+=s%0Gq$F
z!;jQII5^=1mCFp+Il~j8vqD+Q6*qUm?e+X^(%28&ZJ{_vC`It1&Q}G!c~_}VK7gHY
zH#`=NAavIR3XTpTPOl5@l67zqy?{`KTX5M`59b|?h*Y_Q(<G|3p5v%;okoEbxml-C
z6xj`<A><2AAMZoPkykwxZa>TM)b#(Oq?z=XSGs)cDY6?wDOrDRLaV}M6a{uYD03ab
zS*Ly?*g;ggllZ!gBGcd%0wiw1aVJ>^>1*(oYC?c)8&XZlQYiMqf898o7xt3{c>puA
zA$oJ$**(9wb<N)<vm#g{*gnIB39J;2tXw1Fa`Cu^!BsAVz@5v*k+?k`rDrEVRX79T
z8duo{5=|k~9&c}c*}&_Ry!xBJ#Y+D#vr2+rcsWbfcX&v)Kxw%@cFb}nQgtEfj3Zk0
z#kQGF3^umTaQH^81RtE(a>UB@qa8E2+*V)qoFmqqM66ueBR8kPIYW)P=W&4l8cYdx
zP6+qIZOIT~l*W*5!rddQ8IGbAu-$nUo}$fg+1?E2?M;Z&xQDaWZ;@m14#f_`<Yp(3
zZTW`a>k~>HM<>tuO$W6mK!B&9|Blk=|5v9<=Z`&Q_LHdg;)2rysBoSjitRy-$0W`=
zzQ;xXG31%NMyUK91WP=mFQW|}VvUGUe1I&=yGYW1i@?nja9lXRtcMX1tl|9YP@H`l
zDtx6xsu}Dq3R1IU*`vaoEV3+F)Hpm@I6#gsm1-slZ5*5YQsB#F;R10Qouy`S?@5ID
zrXr*oJ;p_sPZ4#2<35A0KMM0YDX;z(Yg68P18=3~Mw{)mIIuPg67zhqWrjT@=7g|#
z>aLkS*iCgid+r5^*^zAWN_=J*#AXN5InL~L>A&5fWGBlZk0kdO%*d4s#c^3WYI7=K
zA=pd8Is~VMJqTVuf<*2nfd{(~CVvY-vbR{ydVtJzSZ+LvK<S%^QoDuo?t`fJ|AcDl
z|D{eNECfKXm0uIY6V?BCJl1?jq|$4opds)xsysiS()9ybfguvx4=8sTL0u4839~mW
z-!**iL&U1QVlh_-u@WTe-9@%(A40_X;ks-Pt_w$CCG;LzbL*iw_aa-Z#Zl`X8d*6S
z<r;wKtRP0HZ0+-`C=$_d)@Z)%NFKprv)prWs+=9-#8+lcEF}3(((kN8>5*wvIt@fM
zrS)12zn|peby!~gP23IO-lx??)*q4s74Ka3lx~6f>iTc_sk3~ja*zIyntKx4W;hYS
zx>I{6H%EZ+(|0x`s6?@R0W2)QCbmdyxv&5ibL9k<>sR9B_&CAkZkr;{m(9eL+v%TM
z@@gym9zGlTk;>f$>hKe|iPs}V;|)&iu7KOFD>$*`0wU#}A>ZN!F8B_k+IIkD<Y>!X
z#@jN?pYuWh|J8CoA0kyA!)@ixBe)##5p8k5px*Bbs@#Xr;5+&^aeV-n-3{;*Yi3_e
zIJa}o(RWBv8-<U^1l!KcVZi_n%)3gKqyq}Gb4Wm=S%7`_3_qgQY-abRW`0|?$IW)i
z(rCM9W+1abTtiWrdxiuxjpgy}nHj*uSB~gcdUhP-=A=S<X+DBv?xMne5CO`KjW<e$
zwRoMESAVVb_4SV%s~jg|%N+Y-Pbzi8SNuNG4nD@Q^=)jzYWHjpY@g{wqDpki7m8i8
zJQ$gBvDGc#*^{_h|4oFyP5yG?%CZDVfaUm-p*Sa(&h=n!kAoI&RTh`6qdE5iOy}Q&
z8CBPXqXa<Q64q`+Xtg3(?m7``I~=y3V-7S_?mjuw>nO2%L-zkIN?dw->U@4S=c(d<
zbE)(CY+mI)-cxAbgEF^%BH1xC_>Un`^AY?cI^npj9$pen@Yr(&?oxHgws?%x{iE>v
zVU$M5XE2$6m&IOn=3Rp3ybJ7$-a9Ls=rsT;^9sr4L@+DEG6-h)KxTFlqg!r87nl30
z$d~&qR4_Y*H5i#WTnbk*l=!o$;dwE-<wV$c(KQsAjv+$(YE_!qty6a!-t)FL<ker#
zEmp=p|4U2!giXYbclXlO``{#B0!98zWb7Y7tYIe(EIkJ`p&V?Tc><DigRyyr4GFC$
z^$ULjiC8AG60=V-O5Hmz5wdd<@#CM5uyC3v!N^bF*%6QgLw-&M^(P<Jhm`mVSQt)m
zPCgFu--0;_tINWE_$?nrl+rLV%$_4z_b~$HTj49+3hOOrV6m<QZhM-Ls`~_0&V7?v
zR!@WSoqBj7fWK#{@f!-N3nF0+okXc!A6bUy@RRI>zjznR9Pr%J20t48(v0pRVgGBy
z?3#k@qDMF;^csf*?!rKzlj?P-&M9Fc%84SEHo~nO;cN>RfBlvN8_DuqcQT=k$6lgS
zZgPtwRT(~_T)r6Wq>)^7*0-ELMzgcSuwS?l#}+)Hzvm@RYP2I%<I=g)jt^qT2S4&s
zw|MoRTDvO8RZ5Td#YgPwf!q2A&=#s72X+#ALiNZoBd4eH7TWWxv2}($w#_;LQNC|v
zy6HPBY?@(31RKmIuUH&*rXx1|*$kqy{n+ZP&40FIp|#C3j$<!hI-8e}oD~Pfxu-~U
zLkVW8p~hDZBmUb2IgjAJXb5g1BLqPGh%;_Q;9eqE`D+N1yN85*&*8P_8bYO?;H1i}
zni88H5uWn>qn6SpOp09e`%qBrIz;yW8DdnPBShv7+;%syow6boA0k=r2?~z&Ax35b
zp=-Y2m|!<d1n%Gv{~aRNb3~w-Y*dw`QCNId7!yocqEas2%F!!lW%d%O%Fa#vCZ@Ba
zX*8xrGdqekGRfJIbUcv+HH0-LrFo}l6pw={e<AD_cf(lt26Puz!)SdrV)d>eT)pMu
zrPS9JqwhcR;<3E?53LWc_iXf0ZK^M_8cqw5y9w=udC(JRf%?2MYQu3jxS$15+SlMM
zc^g{%wbbULAwJKKg#~ua@?=80W2P&1&T@z3oKULYh<59YZ^yTP=fWm>C8=+4E3&x0
z!Q36WzyIX`xk+Sh+fP0ICRhkQh2z3r_-=WJ48s9rnLLA=<OOzT5zcw~?qQ(R7Akk2
z7gzmfl?=oCBIORfJ*Umz!DB}!Lga2CRr4)1k`{IkuPlqFNLC+(?UENbD)baqLIbc{
z{2mAAcS31y0m}qXnwLi-YY-DivDv{aF`5%wF7K5)E<QUDl6+A_szkH1!y!E<ni@|8
z6I$_EM7?}e=Md4(iGVDB1k~rBg{jb8vOk?H?j$`s1{w?UaYD2lA?kI=v%Q~qyJ|><
z*Xeon?_J-%8WavQt2w2#+-t~gdjlNB>qsb%LvBtIOqSe)@?2{BWZ@k)JV2hs3wV*Z
z%FRuNq<|k}_(R!b6_-*aKQ9HlXZuj~BC&PHZa#PHne9u|>I><45%k=Tfrb>{$-hBI
z9Lv7pM3n;;4o=kOl|xsc9)|_)v$RNuMQ;!+(T7~iK6aOAZWpXj`CIUn?3nZxZFS<Q
z+pna=X+AO!*z=$#Q0y+k_ufT-<SlqeoyTdL7f2!7;kkMo_QFGCN$$W@@CgiwVE4_f
zrp9%e8o?=|)d;fvY1D{_RH<QbBFhEucg^%>R-cP2$@68=YsvI;D0{w>EiMRz{M;1C
z^QU0zOnVa9lThSO!y(~j78)=Tyic~ukKUKWNLg!nDgu=*AzZ7mChJ&NTIac!3Oo_u
z)xSs03vKn#Tov|SdATR-cAbIdl2m9c%76sF7c_*5p(AvWxh-{pBE%?<pwzA(w(IUd
zfuBfoo;RfUgCIJ`9TIaxNJIl5KF5#UDoJWyFr!(ix#8G3+Zmg_v!>UAp)8Qa(z6t(
zFK}5lGP4ueq%W6KzL)xo`n*c$^IwB5|0UQ6_rQPkDAF`PpxkK)soLG}mZIa^N`mAB
zoOp57Ut0;<)*}!l_d3W=>MDHpbi!5a0>ZT~A<uFMv7#id3;SR$_#9RXUcq|VbExxI
zuxtSqW1W2x8iHj+t0`=zQ+iGm6y~P0_^QVIawe!;u%4Sm)fTQ`6Ia{>m<&-YN3?2!
zc_hH!LI-kl<DoCu0;@$&p)b@(0-jHw6HmXd1bYSI==B5`t<5KjZA83&XIVq+Tf5=+
z6TDCXul~2xhWuv+W;@gGXp2O>H{Fzp3Xg7_wS9}jYb%&w%JE0B39JK)>ZqMZ!brFi
z@tUuYsPPth!sj4HA}S*gitT)MM5r!M6;6k&z)2{~r}jNJjE=ct*KBueo@vEGV%%hw
zvcM_q;q#`?i(zvR9F(wyIOO!W%7q5B1kS-s_#Tc4y`cIEUh9UCa$pFjtRBEes;MpC
zaEKRI{nam}m3uDYw)=8{pF}&Nw6CJfVG2<)18`qDf+K<taY*nQEEYW>i_%EeK8r*&
zi>Ni7&2Dn3S5kbD*e6)Ph*f%SB#Wc&nc+{PaR|{Yjrt4oNnAr%I6#3vmCcMw&k2Vp
zpFdRQXG29W8`|^F!FJJeSS+~@t@$-jqETI${}hpNGE{^zpeRUUyCfd=d&-b*dKcdE
zHO(a_Z#a+iP4PsQSN~J>_SI+Goz?R%>a2==Z?mHm5o)(letZD+zT-&L?1RdJ6zt@4
zf&#TYZNVC-2^2zZUK}iz-XVAQ0`WSJVX(NK03Zf(LLnrm<k;qiLQa5ezCbu+=S5@h
z{3uAw31no;g$VZW`C!WoTQ;e+eTFl0d|cdBab6ZnVU!?pRhXAa?k)p*LUk|^y3e*5
zv?IU?-Pwx*%c-6sr#@a>^|w|$_O$Ax?tj!%Y(Ic(-7oN1(+|f5BQ$EhgrQI?bOr07
zKED_W0?G9FZGTs8a!Yn@JPQ$Uiv?unMl-SHVpOX9IYg_WbSxH1H1caMEQF@eSrXP*
zSgg7Ub-{cVCQzE6O3w>mBzOxJ3m+5J=F`ZYgS~T;sbL1N_bQSos|cq;RKN)`!hWz9
ztw6NyRm7XL<X%7jQjRAUy!!90gFRCM0f(v!bw%RdA6lOQPlZb;ae9j|#T%&e8%3@2
z2iR|IhN=)j#DX9w&QFH^qKni<i=ZQ14fm}tQF6QwiQ4^87tSH!^o7!bc*qN#B-`%_
z>3LyHa7E{OLx%q(k*zPb&vJys+#nL*a3bLdBHC~Lg0*qJQ0Cyci7qj2?qYTdl;;&<
zztCkI7V3iif;Vtl@_sU8S3fVV`kP<rWz%hb+GM&XX6H0Km-WJ2@DUCR-iFD-d(fGG
zfyGf3=A}W2M%#T0a%qH)A#yzfwfXssOjYJ*vYb{Wfebby$~~7PYE==;Bq5HYMtT|=
zg2nW67JIK2iLQb`3Jwc*z<j}7`W+3_=#sEcsE8g@pe~fn60}u>(jX@oid}rpkl^=$
z;krz?%9bNu_hv=vk<P5ASBJLq#DiD=kEvA^V`?@#Ywj3wqN;QrB`3z&j!~74!-$oC
zfyTfIR67me=%xzD%|A(P%>_D(i($6Bi@7MZ`FV&`>O+>%bGZKWnzczOfk14TX^Wk6
z9NC`6asts%m>&z#dG6F+!yrD_2jYBwP!ddr)Vx5JJs>{k+oRs%3O4V+Wz=wcbnKkz
z0mV5vP@Q)chlFpynuOI<@NQy|2ye;i@1~TPLnL6^+XD9`lVsOlkv+MEgY!F}KChgJ
zw1_Nw9*JirON!=bRDFICTO1%sqqExl(<Gt^&|g}?;#J&oSIM~{B&ek<Pf%}B732jH
zS&(014xPV%EYPAF7%jL7zqQlQ6FyI$!7WlC0^m<1D;5n!!9=oHk=XUO2E1=^8dMg>
zL1#q<bk@WmNVy6AN*5YSBW^km^^WuIg21c)kNTwki&VJivzx)HH|j%_?&0+Dw>a<h
z1vMTYQS0#wDjbH8p!ymY-6wE0;xn9gv}4;$I}%q{sE~`&6}kxhCAH+BG7uv340*==
zI3m(PLK=Y`vm78U;Kow1r1%3NCmhU#cIO-iYO~SUGsm4o)0I)H7zwS++$f^k&~Hn{
z`2wLTkoUK+KoFb1ke_`DTJz7rROnfo(SpmotpI<o#Y<#JBw*!uEq7Bi;{{zfAlwS=
z1!Y8(sjQ)?2^2tiKG~<aiEPysce6E_xsj~FaOqd7M5o+@6-TV9^K(f|Ls^D_)`B8v
zE+{0cp91~G)l7)@@t4AC;R{$UzYk5}5~A5eXbBb5`?BeM!BAh6LXDHG*8EWH=05>B
zp<wKqM-5mw1X?RnV7t2n{;KB@so7f7nDh7$PgHpI(Y1k}@?4%o`0coRFIlA<C64b<
z7dVECeiNwj7(=PUB&yv$qUhK=WE#9dtt+>wd_Qy-l|o@r7!-x0u}?T3=BwJ-X7Gl~
zE+Nl!5M_2F(57>?@!1lM20?1RHzfJJAuZ@f?K23{0>KcQ=SkG+OFsu=>nt0hRewgV
zoUn3X16lqU)*sXab69RTN3GmEg#v$8kB-0vUR?E$Qgj3^n;S2^+H+t*6AmqHf#}R&
z$nvF-rHRD81vyZfpH8E1I;8nxAU->otW*inY(5EO0yU~2Xf7;(I-SSmx603tV|jku
z`y}TDu+d#fD3MJLSS@}5GvSBO5I#ennMR~rMvc1wYQmW$tiI4(mJZd0Tzo4W@(aRP
z)m)kdr9~&9x;Pe!ivw{&{4CsLOIyPYE*9Ua<K1fJk66b?rv68gOI?J;rt+sDiuaJF
z^9GeJ?@{aBi?+zGM6BG#MpLMC`h+saK_qHFLa}u(I$}PtHTwG&WkP;o2=*<^hVjxi
z7%aUAy(J~E-f#n_kM-cx!Ex5MrTK%gW!6#bm}`yQd>$mQeoRbv&2@yNfDd-ec4Q#~
z(YfxdjVlVpvQUBS+!!|D^=*#gB%4=I7tEQIm>m%$ClJI70sIk*fpBZk!9|yQSRj6O
zDE0{!u~ZTz!8Ee+1vK&okSG#i&Iy2uP&zx#k*BIqCX3U`%!{P+a-g%Y90n`OS-J{m
zmn7!;lkGYOvn4lRvGg9ah+GdYJI_*Jl!Y>&ESyXYof_c6R3g?;77mahN-$V`8ZyE@
zP+1ZM)umC;SWHyBA{oY;GGVki2FJznZ+fT~T^#5c<89FW2dRb8S5BC0Pq}wwQz5K(
z6(RM&3)Fi~pe1Aq^+7|p6gGu(Uejz7=}M=sM6uIIQ0_*Z=M?IEh7qv0mBsWW1l?Kt
zG+EKc#E^r5AhEYd)p?0P@t4%5v!NgqNzN&l2KxvoFNlZE@>48pU>6^^aKMd`ujm|4
z0)TXu_sT6IP^EsMFh3sqmy|(8Fat^g1Pp@N`EmjYJW>6lmu)k>L=@&F6sS?-(pqo^
za&r>N;uo=5PZ|C&i1P)q6)IdKQ(KS)**P)va}o;?=q;>d@l)+ZMNE9PmgKMr0JVi_
zEM@D+lKZe;{usK#)ht%ag%0!=*FtaU8K^Euh78#)xdnl27WdHFLZ}g~sxKyzT|ktv
zG!Y65=x-46!GX0T=8Hn0yxg1JmDWl8Y-d5xRj&^NUuN+H=y$qgwWDvVyYjh4gCCN+
zjn`$tWm^*>Rqmn6VF;IfKjKRC2Q)>Dp&{TS>ioZ=<oFb-9KYb4#{}Zlo}<QT1Wm!y
z@Y~yo18Yt}VR0}HEUkd~svFey(wUnIk$#Pmqa*N^xrZIIoFFaekNvAoL2+R?Ij2O(
z3!jAad><$+j37ZJ7+A!?Kp3P20wFFyVl5a0-Q@*rgBO+gS=cheu5H&$KVArcSN`83
z>m;&QApZWog`7afu!R8{3ksmWw2}q(rRS13F3g4e{8*w{YIt-GH<`szuh!yxYIq!x
zCPIZoQ(|r)S+N`(THFH1HE*H2s1jNvw%ob<mz2Y7%_Ye4pTyy{<=D3*1scneVX!6#
zdLkJlwtkQj^kOu-i{FMCcnDE!1SEx=p}IU2M(YZozS<vZYuupyeZbp_lxs(MV)Q%O
zU-kLq;zHNA5iYxLb=hn`2fNKxh?IVg2)Rc{GklCvy8&Dd<iY^mxElEt=e;LU<35FA
z+bNVDpC)nrfCA$Iv<8#lT8zVDO$!O3D|A<KFi?yAi!QJ>%;j63u^vasu`!sft!D$d
z%92PDSYH~@1DJp+2~%5NK$N?b+USyW?4IKcjYTA~i&LPoFqYmE!QeuAZusPGJ|A<Q
zitx(+v8W5>n(yUL=us0oMYf+B4_PU0;%V1x53)o)ECowrNd`+>QC*l0MS&C|f=U>z
zswF|qhV1-sXp`6)uc?9QifcHr>Mf3~d<0E8CdVJcLJ6FWGFV+mjg!bgAOLd0L<}NX
zFyB}Pjpg(jk%r;gd?JVt9NkzAll4W=6-mXxwYgATMg+Yq5(j@shyMCdm~Tye5U6#&
zrn%yQ8c&>l+qF4s+$37_RZW=kLnNpUB2lRqQL@hwEB6L@h65<I9zr8WtwgL>qrc#y
z-zd&|d_twm2b{5*Mve0ql-m!Z;LrftB0l1j(QBBktA(_%7bN&SVY{IV#!FkEyQByw
z)^_8R;d`X(z9Ru{hW7F_Cahxf+;QmpGdQrS0DA?)Aw}e>ydVxTf&l~#evn@n3Q7I|
zBGz0ky=zipo?noTNIowFz$^d$VzusS5VzD%V{s-_g;QC|2^TsrTv<g#o5%85xrwR0
zf>C7iONm_5ptrmTh9YHbWy}5*r=h+e8*V?mhw~4;Fj#t?&W(YxU<R9DP!x)W+TsLi
z_}+{dG?vFfb45J#S7$MSRbLuKH5!KNa&Tl*DGBQ-=&nkJ#tNc|CBe{Nla9k1@}aWA
z7luE^!C*t=%K-hVvVphbym;(yEd)?EDs%e8i}*0rd-Wmm_YfxW2+=aH5GD5lNlN{Q
zRep&x=7Xql97S`;B$~p;(GoF<^M2#F=uLv^_z`8c)41UF1$jpAQD!ks;yR5y^Vcx_
zv6$LXEQ_Na5~;yqkp`A7=(*`B%P5H5_kvOE=2;ey5OSfx-VYi}lcByOk=^QL_gqJ4
zEz2Z=jV3V-V@^wJX$DbkLYvskAQ7HY@XCLx7%r|6(OP`E;LyryW~G!DBtVnwzLH=H
z_L0CU6TNcluJu=xv6~j|72q-j5}>#2G!xsSYp%n1aXak3e+VOy^DtOeNewv*`<I_3
zAtrmjBmrtm;-J1Pj%XntmYYeWmy=kpP9ZVPfy8__7_BdW^0HteS8CKEv9Q`)1MO9b
zIPiTc32_<>)}@g+hrxJL5=?$dhT+Ee=SglC!iRb$c_RBOuYHd`t*CSwi7K$@&dNFR
z90`i=5ib6SNVNx%k}r`c-_JxgOLqXp#|BaBI)LWzF*Jnrk+^<Bjr%0dd45K%%P%Og
zqMtn`kbSTR6*gn2bDu_{ZZ8bi6cW8wFmXMwv=;l9mO*D(F5)zLk!$u6ak{UFYW<+F
zFc_MvVsYq)0;nvGWtjq8?A37185-;pAuH?$)kSgK<k<bgA~n3YDzE%E#bf!Lw&^Y@
z?%6%t4O&aG*g9>FJ`I=GKzDHwIPuk5l1Fyy42fzcWckC%_MgSkbuBo$;xSy;_u}yC
z258ec2bPz^YQt5?3x~7DtG_ZIN{hp&hT`a^D#$PPV|1#%A_6MQsBwRv4ZE#%B(gbB
zrJt3T2E%mYX&l>93H8;1&{!FbeJdhi@?$QHf6T<8^~um#8w&fqIn8Y)uX(qc`8B3i
z4Sbq)HD&B*(b0Dq*$3a?ockDZ4BsI^;T__n-y>S`4I)WYW2Ac!A@vNo2ZvDOGJw{Q
zk7y)XZ9VxB&5_e+4E%~3x6i0N{uyOfUs31#85LF^Q13B~O1lX-h}L6|fCEdT;s$)X
zjklq*q=?#JB?^wx?<C3%l6(j4Wm%9Ea%GcLT>78kn$u+ab096`1t}qKBG+_sVX2cU
z!g0JMtGx2}De^+m=0vVNN`i?nSXB!B<t5NvS_s```7l~_4oB8D!DL+})RxA<P^1*c
zHZ;L(bt^nK4#0KW3+!K3M&wWo{Z-V!R~A8ISt@i_rbCk>g9W~@+)~EuKNlj<S(!=%
zn?{66_J3nGj{H;zn{72DtVPgWlL(8SO6YhFbl1i}acKbCl-qbi9`x2E!FFdEwANB5
z*^uzkK_U0@g`!S9o~ZpwcC9+qZJcS;TUhSgi-H5=IAih|mx8B|snd@%<sl?1zek*0
zFA?iYWNVBgO`{KG)+4y+F^QIwV`w6BZBO`w=96D=-uELa9X}DZPUFmx&u9+*j5O_T
zbi_}i%ytMqQk^tNN0GzHrZ!pxi|?;ObMYzYFFcQAy*EhLdyC^6yI`;;7y2SuG{8rE
z8}LPPAS)CAt>q~=w5AAJD-#mUd2v-<`A1|Gs4q?m(pZ{?L#xVhaAg@(7bd`RT@#D9
za<NwJ6&cu14b*B=BOEtAhx<?6FcE2?*NULCw1Cb}#o-^yp}8cJ1U8AKT5+KOo9$KD
zzcvZ_KO{qac_h?VhT+IY`pmV-IJ_wv_PeWa;D=Nk-&qa4?_-EiBVf0y9Q)UBv>J^g
zn+tGkTQO{QmB4s?9(Ak`=zkvz&D8<#GQ69D``?TU@&xXmQ*Tv$P)RlHKNF_>urW&W
z2?C^^!hJ(O&X|8jOV}r5X!Q}LK1YJ=0Fo8@5hM4SYBy5U-l5iMoQQP-*Au>=BkmKf
zM1IEQ@Xx6A{DiZ1lPIy7Mxpr>YFtN=r8SH?pHVu08cusIlid%3>e5J9ZM*{KZI5VR
zFM#9r>nODyp*l{KS`2wQhYJU2uSg~^h=Kf~U=r3099W&(X1F1P7gyz#e{7Lk93f(`
zvbf;z_vO%8LDaam0@{mDLt|+Q4A-7vL4QLU^);4c!+Fy)c<t=QK@wyA6=z|)@fs6Z
z-Ib?czpV+1OZ=g^G8PK-sIrV2wn#MeNo0-J=M%YR!hi(TdRsY;Z7zZGvLGD(F^32?
zAI6(9NK_+XyfKS}m24l0E_Y0Bi95YsK%bF;gX>bEvfK}{iydIFF1|Z6u-<3j?FU{w
z_8(O5cf8%2<M1LjM(b5gka8C+H&?-QO+AcOG$3W~6zbf5L4`9%t8WoYH9@u)NhGfE
za_^C((u*@@BdD|=LR<JJbS4s=Mof?xe@1=aSDbVIL{v-UYWWrAwjWVq*N4=7J*e}V
zK&C-IEH<2j+R7jt5Xr-lADYNXU4h<;9QexJ#+hS%h}C)t!_}qGUX=iC5iS%J$tYG=
zB%?=1B!w4O<&}SKaoX9gLn7OAa1}?bM2<f;!t{p<mK%6*&1p7yaD4q;IB$Lo)76bI
zSXqK2>*$<ywa{5kc5P)QiC`Mcemo0f5>3UWKF}kpf8?jrFyC|rMjK9n+x5sv^dedR
zQzWdpFj$|0!y8XQ=lhf3wwXI2R>?%v?5BK$sdv!p39#N?2162N(@nW>5xopI(KhNl
z!PvJl5cYd>o3B>A;N5EG?^uW4P0mesX^ODjQ`F@kb{;l6t6;vN0@mbayhUHZW7{jF
zDSSb-%QQ}NHwWB1jKsbD2ormXB*g*5%l0Equ^UzPV`%W6MxFl<TBAM^z5WF)Cx1qR
z{})s`OrXf}GYRlVlv+=q-un}(9Y=A&<s*D0uH(p$6>N|-Sx;`}$6GM};UbCbC8TMM
zvsGNal8+!eKMZ2?U7))rj%w1R#>%)LUa#hrUsZ7z>oPa_p{hrFX)c_1U4tG`sp^tw
z99&%t`;E5{B-#t}bq&<P&ckv;6Apb}Oje8pbVDV}Yc=0kj3XqbN4B1Z_G+^7t4_jx
z4~gav8927JjO>329QF{IuFr<;o-@#29|I@xY9^w=N>^Fz)pAQdG}i=?pyt4ET^6ji
zR4{Qh`za4cx0K<;&N?FDWE|WON1q@1-by<2>h1PtTX|ym-#A${I`uCXv+o&Oi>2MP
z-%|t+$xCn)y?|poO6fZ;fz9Si@DRHX@7*M#Y9nY4`2}Y!2av8jiZ}%>OQ0Ju(yx&y
z*N1GaQMS_Ra?l5~M}K4?f%b&YXbR`{6PQBviND~i#YYsGOyHu|M-*E0quiknO+gdz
zmT953Qb2=l1~gVA!gljj8t{{8;6IP-gCoc}{04SgFXPz8dX|Nvu`)K%Nv?($SLKyo
zXE7AX7tvpxS75mIG#s~e;_wfpFkD+i4Z9saJKy5yh8D76#V}f13EgE}icA%Ze>j8v
zt21D=qlC@)ANV02$9Ggwr)-AR_97hGkcI;r5@GTaS^OUpm{3}7D}d?dEVxQufF+5s
zt>_t;Z_b0owp<e7GJ5?q6IG)PnJk8TT(k^U+sfb}eifFR%Hby4z(iVYr5^!<EPT_n
zR)@dK^tuxK?)9)RPaOYiweIY7oyddrXWS$!V74WV1obRV?7o15>(gPexdg#`AHi<h
zWq9s>fnd@1ICGe&H1Gq?m<}UFX%I=WL&#7ZC!rlflyo-=jmFUA{|Rjo6S$fD8SU|(
z(Gu|)&0)Xbf;W-t@vkU3LXSs(#s&AUIDPN~&O3fWD+zXx%1s)m^I`ZyHV%JZi4&V|
zLw7|stVvL7oIau0b`b7jH|h1Pwg^SuT~>MJH&Rp=Cy4k<KCCtTKA%La2=?3B$p*e4
zYknKnL@vf_%Sl+zQ->?Z(M`3~z)2K$)UrHRN6AX)t&M}xk7;n&T?^w4r=Ynygv2!q
zUecFgur3kiTe7f!eH8o^T41&{okTYd2i7N$Ko`POrU3!+?Qj++TH3~mb2<!&RFChf
zA%eO{pPPk%y*J>n<1&eJ6MLWfDnID2O?X?8blYllXmSQmDF1`|t6uNjm~gZq!)Dj1
zI~MePSZ*#LN<E9CTTAIX`6jSj8r}XiX*jXH6+WWfaNYU<Rp$SS=I~D_Ju<}vHBFI3
zR(=@qQUi#VdxIkLL0s@0$F=A$Xbv4md+Zln3Y|hr=wDFf_%qHP{fa{4&qS_Y(CG6S
zDJuPF^qNMo<p&)5sR2i}6hKoX0!KE~!+HB%c59(f`PV2i8^PIQ<2@cbAL;OVE3f<}
zi}~iW=GL1p_Biak3Xkp2$qwFw)lZkOe^m}qZ8ckFcw}Qav{uE!W?L1U_SC^i>^!V@
zoMA+2u_X^4(nOgXGf5b0;iuS4RGI^4i5eKJkH-lyqSPHZ@Y&k{lT8`07cIewJykfV
zc7su^?apEx-jqcIb()c}&CYVTN;JV$tOfQv>TrDLdANwS&}TP5XDt`MO@WjA+2)Sw
zZY7>*{`+caSeL8G#<=Ilcb>-a-6brx>L$?wf7vb~$2{2Ys)ZwcudZU3ad;gKv^$y*
zq1=lIsUcL^lEn|6LZ1EzQkBM#sxXWMxjw{6_aaa411>mC5upy@R_a%DBut|%mfNu9
zD=zwcMfC|1R`bs&F#JRU`vrA=M8GDasQ3PWQ-*J8u)YAJP093~o`S)O3fOMBf+IiH
z;H2!k$qfBBLHRn9ybu7d{Pv6f%G{una{ZHjqVM3a?K;fY*TQaV3yy8R058c~FxhYh
z2iK*+jI8~!?S&+u`Sd&!hCjwrhpnK;M7T+vN3c>m9nZ#bu_8KthU|ScTqLXEuUwC#
zJ9FV7bAdW^Cj8_ZVX`@$Xtj*aD`V+e9JzAD>MM5@{&LsgE!z&;9W_K*<#3UzLzwD4
zmLF^UV+I$R=(dzh>*#qk$O{$x8+Bsr^S@LicN~q>ZmzQ1k$2BxOAZXzXTx2h6;9%f
z@Q`eQuk1BAN>tJJl@I$p6*RaJ#cr!W@ZKlz6@QK}i9wXwki`%Dj7*}|Or=RA$n>$A
zrZ9#a-4S+k!H%fUxSq_#TR-DU6p?GdN1XHeMB+-sYWf*@2S4Jh`4`kUf5171Pq-EL
zugEfd!4{oZkhmMJ%Z0DZ6BeQ}`=KgdN2ErC*CTo5cU7FW4T+qTdtcxw`Vcl-8sRS1
z1(!XYj4+PxK8FMAl8GwoVYR)O1Tq&EM5vAuWw0d?^;Nh8N3m+SOPz!9rbH&9CnV0m
zVmk?`LL;1{N@2IB2v$4u>3yf*y_e`$>=aIjmcxlUxWB>`mLuyS(+FqD^K|Syf|Rep
zQ??l{;!W_A>x8p-13hnqx6Cyd(BERPE&&I=Pk5W=aXECTcanFjnZMN+w+1)(X_r@-
z{gi|gyGm(ryNnQ(M|6#EP;G~oTr)ydZX;6jK927pXR$pW`s?H9JGp{rjb}u)*AS&N
zh!nL^T=e{idjAhZt;2{E?M4QPY|7pdB*_mU-(Vb9LZ)#e@eA6MCU7nOE1FM!!X^K|
zpvr-)ztt4-4}PNh1;s}`q4?-9%8yN=$>(R}m=2QbDIf=Q7H;D0u-ks6&286hUR;$|
ze&?YAA_uKiNj)|{U4fhEb)wg59Q+{*MjLWS46ETof@dR^LjqU<U&T5c-kbz`i9#IO
z6c2yJOJw^?;UHcDJF$G~uovMfQwci~U}wov>d0B}Az=+uX@i4AF|2pzljs)0iRjjg
z&h?PKM4wv=f29_Ls9q<5y$%-=bPu^Y7LRolyNCe!E_(lCgztL@XNfxcyHa4aC$H;5
z)-#how5Z<iU47EBEW>tZ?j0A&a&i)lNIBS#VC4sN%{$2z+(CqP7Y$N%aFed5L8^_#
z!~+ytV7-&RAE^uQl)i#6h1Up?=|PU(6zY9G<D&aCQshUGqBx8s*?uI*^&?Yt93>W$
zXbzepVx7jVl)sR;{){V;KeO!x&stBT(s~L-#*@f7Fo8-U)-<hmsIi~K8M9$TsC3hJ
zSplO>DU<%HUFN)A$18uRa$-lTx$Tbn9(VB$SZ%Gw@ttJRcjhtLwAh&e7ikhr(E^xn
z&W7>UIJipHAW-QtJY;L&qi}%;H49d|v*9CON4CBKmOIjkL@%<?fty@8yyR;Tpwt8h
zNluI_aBN2beB`bWz1Abi@IDc5Gd*v>@m;m>+}nsCrRzk-mtnW-9Erv|Bxt`!f^IMT
zWFNBZ1e+bD_k1-jo$I<V{D-^scS+3E6IMGj?wD_nrE6V_6oWoQX}&<1+G8Z?4j@eV
zG24{dRk8sA%2yDt_Ykhq7jaVa1`TrMuoW$0g6k&Pf|Kgc;Uo4O8G6%b3jT`o&XdSc
z8Yg-k{gy4DFo9H+A=EgH;zkN5tUu#M+Gn&A!8Qf|6&F0dpw8_RicCHud;b&)4t&K0
z_m4PjIEKr<pK;o(mz&I-wBJ<~WWJ5JWR+L`z$HNDZjh@)Gu&h^5KUf#`PM8V(ITSF
z5**u=183<{m~Kr$g!(lS(sM+h=V7xa2kvr}aFs2EyL2_I_hi%KH}O3oUI=gbYId9M
z7_FQ1SV6+sjvy7HCe@pW(YZ}TdJa+AH%S~iiLN@}E87k~`Kv^~7l?Qo;40BV)O-yo
z2ZoTUH->bgqX5~PY$DBJPhD5B&zpdezA3)nyQp3)xS{W(T2}8Ue!A0Lt^y~uy6Bp|
zAYpxp812`H*!L3Any(O|b{C#<%|x*`i1=?IT>S>z_SO)s()U1O9HMp&o-&u|x?Uz{
z(uEYQ5tjJRS^bKm)5uW%fJB*oB+3pTokTW$-w-bQeMEiW09*3f8a0g$I=3l=6Vkt+
z!fqOQhF_3pFom4`pV1oj7Ze(g;(E-#(rd$Q8RpM<aaCU76|UHbm53bOnP1>8caCgi
z6A5btcfTw|s*~`^H<10mKpnM=I&dw#h+N%>YLAQO<G5%cqg!94TEq|~d6W1$OBEBb
zUSyAv8rNVeo`VRD>(uG5AyoM~0#xe}ta1&R=8uSU8%PLlQHO71L>r*eMr2lxP{k)m
zJw)`X^B(b9eTY#VMxy2b;&flaTka}}NEb4U`U^V?#`TBaPyg;j_Vw+tb*abN)10Nw
zcDT@W3{~lXi{vHt|A(qRK$O-~q#F&;HGhjlonE@0w-KaD!m4(gxr0c}E_f@}(?Hlj
z-x=pD&e4EbN!PfUg%aXaxXoCm&>sH@S^GwjC`Z><<{P!9DU2iEU<{p!A8|YFXS794
z;a2+3XpR1gOM$=OywhJ$ZTAJGmYlGTB2#A!7d$6Xe0chPliw#^T$NXN<=-lPa!qnR
z@(n#fO3g&8NhGkRVY54rMDRQUl^ftBUWz3BTVy%QsFqOYt-;Y<X+*K*2v%!^kHR^!
z_*EnVokUBGNZNmoXtj+|tOp%;kSs=u{$sMM?TFWYh?DznAc1~%l&nUy)?EZCTt}G3
zO*;M%QTtwyfb=8d&>-?nrjT`T0vU#VNINuu6vG}8m?wzUdxY~rBVKK#Z}$BjM3viU
zJj0<i)=j$nYOv~MauO|w*6Bjfz7|Ai-KJ~YLDyiAsP!ch4PGPn$T*SfOA^)lNYr~y
z=iETB(lzD^V)oxaph^?`l<J9EFCv&+iLXK%;`QDkQDYEg$3Nj(!dDX4F{H|mAXQ};
zse8werZk3Hhe>p${*12luehG{Gdk$J%RxV*C4i{a{xfP%d_?Ynzal|-5NFLlOkQ;R
z%-af(S9s;$6_1rDG<TLP>G9l4w8IIbY$XY4H4$hVLNy!Mv1pA>oRBz89k`x^wiw}B
z&FmaknG)EEXORfrN4owK1S+(^Pw^t+^@&=Qn~9_@z(ejl32+zL+zxokUm)vRPn67A
z+XiM~{S`aO`aVXHEp>MNaikC-rBTf@oj{h!AYyf&QhiRs{0uRA50Gm7xFA^PLREA5
z-QVo3X0Da=YWb>G*83?};iP&yBDFecKx=}xLIWbTJBik>Bh$Eti2fBa=^7**c#Zh|
z-N-Q;M4a9W_{d*@A6@H{<Q7h9c9PJxBTBb}oIyJ|jdMuUe}oX_+ekHhhm8FLxZp93
zOF<LJ*O@}L+9cBC$C05pfn@n1T=JVjN9;6_>tE^d6FTCET7y30vhTm5(*7$7jK5_H
z<m~^Dc;5-UxGJyk%73IJ=-d}^lF3hWk}iawN;P%v%ZSsuNt9ZKV8zRDmn|hL+K4!v
z8wgQvAfYXQgH#^;73!%IUqZBYI|=0_cq!B{agHQ0j@7$`2%^@6{dW+q(Te0l_vpOq
zNHQQHKEw&;Jw)l;BC+7Y0&kFF(1SelQ6y;hA^pG<N^QRq%?=~)*Z>LhJtQ7@N(A?q
zKKCAy44=SeNA|t5L7iUxJ)^&wUAJx&4{8<KJWCE$X|9jZYNdgy9LWdoAbNiX5j;^S
zk-YWpLL~2hO)lUL@{f$tHRwgE(QBj`y{BvW3P}fF&;axbq3YKVuX`WaCNB}Gd5sNd
zQ97N>dBkfyL+ZhINIB4lLc>pJ3iyJn(Vvm2@&Q>?(-p>%sxXEOm2tF%eMU#jXBH0V
zNce*53IB?gkpGEhzptpWpGJ}C&u!($K5ygo5?<kz|3Wboix7#@YA<k*%4bxXpmUo#
zc@y0C5}`_F!C9&Z{>tazv$qCEb|%7nM*^Ir3K2?{G;Cip3FUQ0xBg0Xh}5}CcAlt8
zyOmzMf|P@gNeEsbl%B`x+@WLFkYWB92}Grdy04LAI*hpeFOhv{0I_O)$TAv7n(;g2
zS`3j8KSP?~TN2erM6OQ|O=25O!t5k=mc+cGwKVv?*YjKb8-A^#TAzFWP=e9b!Wga2
znsk#}h^0X$PWuMj<Vxro+(yokXLNn;(Y0$q5>aQW;WN5Mk5F`c5NRgeH1NEk|Mv+p
z4)+k1J}1F_LD#nf*~YJsV)y|5>gN%uOV{|oJ%p&X(sjH|M0*=~hewcaJc_2UDO_})
z!YS2BCaxJuACR~26G~0Kp!MVw?xg*UdpTTa;1_fz{(^I!Q)u@6OHYZ-&%C%Qukgx$
zXYp66F?W<K><Lz@r%u`o7nw6;@5_i%FC$o`kve)Ce27x*#dG1KSWTU|0}<+1NEmJ-
zibOL}?+$|18;Q8?5NUQG-rzb})(*0__lUOc;jGO&63n|~hp!|4z<qlCA<i5hLxJTm
zD(yZZ%eWsUHlImIUZddHD6-7o;*{w-q#M6RsK!;K8+4PvJVNlkMg*xez*p%UyyUB!
z-Bk<f>kDq{5BE&{(`mN%@zjcjl$S?SjBgeMtJh!jQ>!JxqyfeF0TF!*VszWtwaGSl
zie%$kNH*$X0}^+Q@-2H2yZ;^vtOt;5)r&&AVH#B4Aj_<q2>u!3=o)e%fz(6yiC|mc
ztyoI~&UM7<UqhzJV<a2iW5k<pGKP|)A8;rAf1>jEIPx_<;ncn<B+CvXL-7Mj%qDOp
zVw`0O+{yk0x03&g>v4abYzh9qg7SGG0AAshzhCi?uW$-iz0%_(TL4EQR8GVqHLoH>
zy`HG_D(oe55w3QH#Fd0X>l)GL6Qmt@h#=(#66F>mu)B!gPn2eG4e6$L$O1n=010&N
zv8P0(kC0+?AE!xBGmLsrU^Rp?r%@Cf`G8`ZPbjgS###Ge<R0xK%ljCoju53CA|ayB
zPdoG+nWhhsf9yF5EMCy>xec$q6)@c#54&A?u-lW<buO^S=T`n#gLjW7SNx*{_2sqk
zpXw4{S)DraAd3c|s>B1G@KUHCLglh5E+9s;6G=psN&D|2LH`C4xa(qkpM>*1(hfdE
zmI+-ygXajR!7Ib;ISKAF`v2c^*%FA-d`QImgs$~{oHBcfaE&(Pm_McW--DC%S-Q?Q
zk!*0A1|crwatEmfeROSyQ1AW)o$<e*;@Br7%ZwmXVT#3C6Ql-FZZV0QY16o#`Uy9P
zTCXSkl6XIXw+{fX@X9}=l$Z~RMCn{Dh|s!%#Qj}}&}n9qSMj>H7}0vkR}wi@BUtqk
z(n%n=i7{WLYD8*Zq0Zh#V)=rJNwUFRqOv<EIQp6d@&StvMrqwd`r+p|ZPQN__8R4m
z6DYBsMy>Nl<eQC?P>hktyks%fOw(7$H76RgeuJ~e-;v1NM20C@U$Ym8)@&!yK93;P
z^YB%yftOq*0u<_zr1cD0hn^QkX|>g)**C@4r#~^fd9hpO+0DKUAI2vC<v%N;WBngz
zJ?|LX`l4lW_tT40GL->OeQG`5hUQv6&Is4Mj5r-G4ecDlROlM$-$A4X4L<b$hN@qp
z|MM=9=XK<grT3PvB5J+H1o4d38~UGakj=kO*Q}oiw;M&aLnw9_LIqt9j@omqUb2Cu
z*lG~jX3yxF(sk5shmUeKvJXF^LG2Q`foseW<e846+-eHt_S~KUUr}xI5y^W;ktR2e
z9JOf@*l|?QYg`J}?d-2@w=;Ml0AAshe@e+W?-4m6k=quw?=sxwN|~4v)so$BVnoKp
z`{H!3k+@c{WAO*tNg(cmi!r8?ea-z}v_)bVw2zC)wh&?6Mx6dV6q2}>J58b1a|&g4
zUvSQeNbC47$g>zm_K~;9HYZDL{t}soU*nAJ01`>4i>>;QbnrT|4nJVR606mTOrkh0
zmKmbj1YeaZL};}jN%s-`t}6)LcL{!q=iseS2`{BmBFgg1QTk0~;Rff63q89+tAk#6
zRmVI$(U|tqq9*pS-Gzi_HWw3LST&{gSQPu-52*Be<(FX6mK&|zQI%?V|4bo?VW!y~
zoH_msr!0vkEgm39tq$QTtwi>XNYd{jF{SHZ&`HF3i>}diqW%tqX<dT9BAusonQVM3
zaxFO$zlUm<eq@<G!Wo-h5?lIzO<z-ei+tPnsPg(izh@9B#t)Hr;67c$SBTc_AnX4C
zCH6h^xm<{$4N<yRkY)S~`A2(@YcYUAixISk{}mmPKcnc-1TqzgT1i~f<tC7$JAtdA
zUwc}kKJvB#<P~1|Rm5Xe>&zq6+j@LSsFKKj2C9-!YFs5jZN^CwjL>}zM5s5AZS;hQ
zwTrASQR|_bD71cwY|DEnuzXEoL&wb?lQ`ZbI(vtV!!J?dIEs=JA5i7+7ZTPlR6ioe
zWR$3Fg2Z<aXRYaVhxbS~e}o*%r$n>YNnoy^fP^N=u!E@YD&qAz5v_F<VQS4p#;qU`
zM3njs79S4ZM`EsbozCe(h)NUOWXkDpzkpQw8{)OOl}?=4cQQJUq|b=a?qD&|Jd<uD
z>fNNzYlFWU(J1|&c_j8ZhHnt4QU@PdI;M67@jAB=soTol@2_%>Y&`ufI_)H)O)Qly
zT>T3D-#1yDG>qsrL7$!<zD~ch9oZ(2iRhmp_XrXC;io8~fg{`G4YEz&(_k`&D$fa2
zxK7YDdx?Ca*AycncJo&_W%h)g-$dHsTR3ITWn)}L35jv7_b|>_)B9|H!IjXTaX<Gj
zDA1ewzuUX+rl|Hb{T1dT_z~`(vpYL`5m7QUIb(x>fC!DEVuDtZ<eYPAvW=i33KAM5
zG&#dX8v_D@wp?$RshO&0-}iN@_OGql+M3<H;XGAc4c+IQ?sK4?^StT#p~C7Ih5vqp
zLW@IlrRq>Sq*d~&3Kaa}aL1-kTj{f5W~F-f%m9kLmWbfSh*+ng`BMWL&TWxm96-M3
z1Sz;DcyNhA*}z3qhb#)|)P}61o)lJ*|2&cF7V1LxN!{+FPW=(h!9UP@htNfQ#{H{b
zP!sf?l-nCLN57_HY$4BQ3Z;RwL@JYL4S9nyuN5Ng4I%L&j~P<0Q>3h)A=P0JNw&{$
z&yEzeWhbs$wjtGd5Q(-u^qmGMRG*NW13%xS(E7G@50T_F?QcX5h3NMjheV-EJDJ@O
zV*jN3N}>*9$aEc(Vqd27IO0yWka}JxLVZDD`iP_^QXHNO$uj{nnO-~DPRE^;bV0t$
z0@CPx&bgNQ&7(EqHGQ6euE{D&{7K25e~C8DKHYHM<Nmep(G_=$#tXY>j@l!oZ=}yA
z61}jEn)9UE&(5JNa9R{_)mbL!byBl?s8S!IHS8k{X+IOeenExf5sFV9q1yI)eeNIk
zPALDu3KaZ;QR+P}ty>u`!!or+WQ!`lRU|t+LayrsDoK$gIrJiv-Y@o^qfq`0DaEfT
zf({K4B`L3(&~>z3+(%8wTQr{EqmcM5>I42N>4Ca)2e=>i1@|w1Phsv$v}$%~`)$+(
zzmgm-tGzP6S!AmW^gNGpBI+z6xJ*)@?2V9aKTe;wfa}(zQtf&X`{xD;$&-mFZ=LC(
zM>mSxSBNB^6Nx?{GA6<!<;i*E9G7WQ!Q&|N+#oe-M1kwP<WJ*Ib%_FvKh=&qc73E4
z$LZYrkz`HBu<J*$$10KcLn78e<T}ksYub&I-E_PO<f>+oVAY2_)jZvVjA)M7L{0b{
zo%13JJ!eoIxQ3eGHRvMW(Yd`LmHG<0n73%YctB)(2z~qq6bCGzJ?bs)+CC+s9ieOb
zO3pjqbDVB2Q>gOi-1Pw|*pKLp{24C_e#AiHk0>~~H(Y6BR`RL}6#SZ?*O*V_IL(+!
z{TD^OwuHQ+aGG<Zv&izGP}zGFRe?)FP9?sx6v8f}gGi(9{5nblR!|%IiiqPgy6K^h
zJ%(O$j9T?4+>iYcx~M}m$G)cLJv2q_pelG1#eqDCutZ92naJfON{F!YJPp#pQ0z4)
z?M*4RBgpX>CuKPyQ)8TSWd)mTI}ELDAGG$pq;l!|l2T2uc}T=MMEeYhZ$b)fljk{2
z1U`p+w|S&GJx8%8h2Zo#1@wEas}XnY`{?&sB-;!jkq9%_;|1=KYUN^8rs@Tev=M3c
zBhcE=b}q|A)MKP(pP|xslL&cC+SeMx*3lTbiX!hBQTMgyRwd-`y0VM5m_2mF(Ye!g
zYKt+GQvHOs*gaCPTj;*Lht}{nbi<lOwR#b{^V`UB8<8lXDf~N9u`kg=H>|eE?=e;U
zlX);v8Cg}J;8%?ln?ZHD-MEQKj#X=!&jPp|sfNh3J^Ced;U-BJ6nYye?B~`hBay=<
z>WCog&%Z-c#1UGekI)%?EWV+gM6#`<!WzQ%(0%n2sn+k%c7YV!l><DyzK4n+BWg(n
zb5Sdc6lAumfz;e6^1P;n09j>ndLU0VgA7u!Tv<<7jiSVFiHLAmh_cdeQwm=RXC6t&
zU+lU{g!mX*B0Kh2V8YFJofSgN;DVIhfE3HJRg<J>XXKa#u8YVdm8(7T1lf+$NV0h@
zeXQxK5jw_W$={ZGt;@04lYzG@^fb~<U_q`+P4E&bL#8Fo(G;;wDt(Kt$18NjndQ24
zYQCT)W*^NL-k?78CAu{4&=9&Q1k0pc8A#Welxx-5CFwlied>aaFqHB|$*U?*@LPfU
z8|@#8{f*iRzZL0w&2$+;ZP2=ezPhLlDZJ<|yp#f0Y2X}Mqu)S(?ErO=Cdnx_h8>|P
zY#;UKj?jDk3z5hNv_%uiM7%_G$R_Q(i@I~KNa1nQ{WIhenPxhTN&zj42#`AllI)+z
z2rv616niXFC{CgIsryK_A0%~aK&s;q%Kg?!Wlqq(FC-^g<gtS4fGtwNtCB0_N`Il-
z5-xw+NQ!e%TG06UmSrzWy;q2=CvnGWfJl6XeqR;RPITy&&*W*VbO!^SJ1J$m=R&fn
zc0-cWjsDkK`mSq2sMSP-?NKIDtSh9FCrF9T(D`oB^&r(5`wrdLKcVB28M^3wQT45)
zVq0Qf(zRSBb-F}h|1NS|#))v*>va|lLEFgnHlX3+tKr&klag0epy0QNmhin3jUnrG
zP2p>#4Es@eb^-Zb6VMS!Hk{i=y?Td8caunS9gnqUw8tFDAVG5kg})b%(G>E%cnx%1
zqR=?{E$Sn`qtJLCO&4BE(|tXW5G%imvok30m?okk0uNZC*Onwtnqc(=_v{T)mFJM0
z+oL#7SsA!N<hCW<0h|M6MVVmr2)9r73h`#y8<FJDFZtSR`nf7_lR|h3^IeI|ZO2gT
zvPPl(wiL259LHrMjr|r1J?A7(Tj;(>A^JFy9iAb@W=KA}+;dHeX6cS&@}0C+Po>kM
zk*-5a)F#RTh@gFVpn``YUZRA~fzP`&`jBo&`)H4QPsF-UukF!|hR=Tjts(Ew5xs*F
zQvXGs({xVDXb9diHHMg!ys82PzXz218!f5=R!mHUMZS|1)|+tu(k_L;q*|liqMFoJ
z=f%%xzp@K`ycr!ae?dpoPiT!erqK2idT)Fo;yp$cZCB*Ggs#{lv|f0Raw4GKtNWq=
zn}T1VKKMInmn!y{MODB$DNdabCAU{`=*~T^Om3w<s}i=Sabv&R3rP=f&nUm1V*gAg
z&XQ~frSYG8Q>*>Iqn{1ZOUjBh&%-DroMbbAeAju|Cc|}@2=j?_B&3ll=5#}W+X7NZ
zS*O!}_v}YWl`hJDxsJ1>u(`PP0!`uU6JSJ{zY&cT=9l@-)Ad+GXY9T#u~HZI22B@t
z>3V&U9BSv4w<z+TK@BP0s(>}*dyk?{O*ad_1#?5#qLNotpy2n2T;D-;ZSaz*%zqB$
z>RA-}Orb)(Bn2AIqu#%IB$G&-chz6|5&D?FqAlt(+B9Z#UOPlR&)A3WNP6JG6)y1X
zpf%D&q_jaH{vyhFd^B)@NNrYz9B!O^AYpr!>zJ6zTtBH7<;teuT(rvbn39PoE;ywT
z`Q>{}BhPhCUQaqRK*wB_^}*5{264x>k5np8J{hE^H`{576srLl6z*rL#*ldGvGmMl
z5n&elEQ+^66{%w;b{#3qMC(3DLGVhcm%nY6ylo~OubR%kniPE<k!32W`%X@gT-n2e
zYaj98#wRp}zn5oS<RSFeKhQb9BW1pZLf;9A1j+;ENLkP4X)N?gUR8mD-?fVMo<A{^
zcATe=dxtD{CbTJ(1}vj8cn!@&9QC1l6e|CKZp{}wyz(<TBEO(Im_y=2JiL8O%IyF;
z+OCz<Tu1aSYD1S%8@7N{)e{*YC~}`iP2f86-DZ%j;$GLsM2JL?_QO(uV&7RAG4&!6
zb)S~-zR+V?R4R87aHxOHvV(qpCW8i?H_dgN6GfZpJSnbUMV^b&W|c&*Y3&{%K|EN8
zaNDK_rJk#}dzw`2=_mhC%ROS!lHqKi&zVP#Gv{ZQ=(XphHkV`wf{RhbUPdC=HRvL?
ziAZ0QQr}0j#spmqoombyYJzrAahB5s%gFN?C(_*@#lAdz<MboN3Q&Op1^)?s{N9Pq
z=-s-eh)py_zC>fxw&YX0t{kH|f?J3_qa~ckG~#bWq=z!4)f%;rhV!qXi++bf3bD&c
zxiy~OAVtd_uOp-|hltRIQRFcvrYLMMQ{*>`yAF?0;<Zdf_O<GNhm>l(C41KPi=yQA
zDd|a7&7e@4`{`It&yhl;cuVrIqteQi?au90Q!-l1#jYeLQlkz=<dV{@^xdHEG)E-4
zEK^}+{$B|+kv@y3y;$Yu(7u`MXX`R2J+r!Swpm<8N7QQ+c#oqcW(^&hZPbQrLLYyC
z&dX-$ZSA~7%013ZB)f;F$;W89XfkE03`$;AfdU2pHHy8L)a@~Qrk3cp=#D!^&$XY3
zOh2RJ;#X&^nzNtKd;JF@R939}s0!VZw16&h5A{KBNYSmJi3qluLgi*QbUF8$2=E0;
ziR7{<bWd>{K>V3@Aw}*-<$3>H*D0jhjY!V)mQ9z8#&Rlvy9e08tH5=MRPMMGpbAI{
zr`irtm~Rvnnqb?DZ0BiGuk%Q8d4dv8Qj%`-k{;mpDs}@a@S3LI4dB6wo3xMgysD;U
z{Pwnu9?1?*kx0t6A#@#OzD(u=bc_k;FTFwg#T^v-&p>~TZYUSc=#Dp|>+&bGXx@{u
zKQQa#54E)#lac~Zpg_TY50$|inpVv_Q>*3!p4|EweOLd22b!PIL+Y(2=m1R@KBDL9
zPo(bNqATtYr2(r%I`2vKy^*{nw=k7@Eh5u(Sb9qHJV+tBE+9`e2lhZ<vg0+X*rkf6
zv5LGGq^Nc0%ri*|WV?+c*LhCd{JEbs&304<2X5Ouz#Z#nC?vvVgX?>wV$+D2b3G@C
zEC*yHHplfJz63<(N!CQ*J}*$_wSilwdJy~PCZyA6CtCI+mB_V#4Y7%!a~zFC-UgHh
z&Y>Y>19|S_XpZD@;C0lU+d+M}33U-BI@iylT<gvq)an&~RRszZ{7=BGTMw@OSl1f;
z3GGCt_2)jJ?;01i%+OstK;wB*ZxQc_R4Gip^bs{->nQY_kX$8qB2)*g(EHz^#*h77
znZzE+iU@2V%>^o672)O?y(~wQ>oO|~D(1N?kcu@Bnev$I91-9!GTcUpC|^hm)s0h~
za;y@M6>+ZO@mMZ~@%U?!^#Bs>dL&)IT?$OX9QxM<Z`0>Kq+?7<5lhx0vwbQA&)x!e
zNilP~SatA%OqgZ67*Oav30=e%YJykL5VcL@x`X!Ek7x`(94_@&TB{T&Q1DMcZMgYF
zZP17Ldi4=1{Xd{9>Sxr29H2VHgx1K9XrV`S@GDdWZAoFLI%o+c{?kOp8$wP+9F{v7
zP@tml-gQ!PpX_rQZ>g77D4rf;MVo3jOkw$|7`5=~3d!_4o2+mOAxAYO4*#WIt3;xM
zQUqf+tyqf&$)ED%R+=M|=71EmxW6^UaY*`Ib6t$c^&Lln#~doWwk3Cao3=?OMa_c*
zoNvu>8xz%9<YPpA*b05mQOO(Ehi#xDXaj8*Kbk6n*VW2@g8~H#{^{t^{9Qeo^mkKB
z<Y)B8{|!Aie?*mfN5(+eR6Eam7L}p1xTkuG67PA*zut3vCOOv%BF!@IE!?u|MUn5U
z7_VfhD3qu7+3z&p(}-AJy2i3is`_kj%^`i6|1v#RQ07V7cp1gaCElV7$xcs^=Q)8Q
z_a&Lc;-$p7t&00*OMDiQ>;6JovXbovznZ@|&&jYrmd6<KiR9VCHQJ&|`d@h>tjK*4
zU78(Khs~l{y^Fin{kR|ZnjNyt`R<F_`C26fpg@6w|7EmA9&4M=o6&vaGg@Q!&=B?x
zwe)DD(7EnB_lG{A(0!Ve<ro?QU!msgDk;vd#?^Ny94~fXA!SPBX*(!Ir$pPw$akNY
zm1w!@&s_#=-oohvUXfLLU{yw0=~ip=NXA@mTRoJKST0cUz6qpodCjT<*9DaLEsA><
zdlO_k%%Iqloxq;px>c795^$^6bt}De4ctEU5Y52{NK^HrR=rL)f=Lv5O`-V$6ZNpZ
zRK0#e`HL%1py2-uecGQ-=%Nqm+AhC`F8Tu+LibR4b{n-suEoC7Vh&U7zb-jUcHLs@
zJ~nRQu7C^*w|Taoi%#MZ;QXAz^)1}A?3Hjo{&WZOT;^nufX%eIbD+eVkFzM&g;y<G
zk!1grl<>Or%5vLPp8FKi>_(Azx=-A;_;ntCWu;plNXpk|O~!8XJ!X-3rk_-;frz<V
z3T50qP~<sFH-R-G<{31GZVhL84_PRGWd#Zp{J)`HWB#To;=rVf*+YHEu7vQ_p$q5;
z+d~4W%F@7TQi2nt7H4ESs`BgxN`2Om<Mfq0*(0FRe*-s9^&s74MEnP|Rs&yGv~_qP
z7J?~u!{T0*<urjb$I*Wnz6?lyHP3lL)M$eBLz(8vcb}zgMnuJOil8Crt)vIoUx3%j
z;&sO2PwJ6u^IY=3@uxZ^@0;fIlnZF)A}^ydvZ_FVf?p0ABHyWN&Y4Wr!D~d4gV2S)
zl%CN_3ekDpE_UGJ-qgEi28j%p#2Jf+1Tu(FnIN@R{X~HCM6$i~yo9?BeMq(*lA!=D
zaIx}Cu^B<qnIYV=(M!7(=UaIsmi=M5HH#G}w{Ec#=I!!T^RoH?_powLEjwbxTeZ{s
z!zlOOgx2;k?phDBGnYBZ>5*2iR#sV6pg_Sd6xG4&>h@@piI+S{aeOT4fozW<l>5)2
z#GS%!&lNFUNhT%AD*)uUOd`j5nh3C8icdEzdt@Y)y<pi&kgW*|omWMP=DQnZn+%6Z
zQJ%bVYp(m0^t&dUd58=*1ET+>j>wou+hI)706cPg&9aTuY8Nu>nS5DAFCd;*dG(w#
zr`e5YYgNh+fC2>yekEuOTT`_}Zg%Imj#Ajaj0(SHBF28{HRWOx6WnzQ?^A7grGiBn
zL5=uhIpQt!qFmYBrNDFMt39F0fE4>-Sr(i<2zVHPC%rf=Q0coRBwHS^Ecshb4aiCd
zr+H1Tr*!;bWVso{RqHNo&t~1V>g{2j`cR{>s8vW+fdU1;PSmQ`PxM@QqfU1k94_}>
zm$s+dR=r4fG$74xOnO^W9S3D~fZL}Y%TnLmubSpGfP8OKwXPE~rpjw#C0aj}@SY7<
zcx07Hl}BH%pX?U@ST?@SRvGEI2C*&Fp6)||`+^J{q}V(k&UH6x<NmGDLiwvGP@v#9
z1--`nhg&u+7Nj`yN_>`v6HY%ga|Zzzs+eRs|9MaKTx<w$THVJ@YduOy@$xb(oCaWW
zWt%}>`lZlikqEY5R%}gn7?6;ktN*;b3zPA!(+?J|S$5`SJ5H+=g{nY-g5Mn~Jhr|m
z@tjwcc&%s>tRLj%yUz`$+6@igv3<0Y=`dxEx44hEZ(GE$MQh!MT<2L_`nJ)W?rhje
zw0^vkV*ji=%WbqST{WU*)0rz4?cZoE<`ptkpg@5F1qyzP_zyN4`RKUL%sc=9002ov
JPDHLkV1myZcL)Fg

literal 0
HcmV?d00001

diff --git a/tools/scalar_tuner/src/assets/react.svg b/tools/scalar_tuner/src/assets/react.svg
new file mode 100644
index 0000000..6c87de9
--- /dev/null
+++ b/tools/scalar_tuner/src/assets/react.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="35.93" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 228"><path fill="#00D8FF" d="M210.483 73.824a171.49 171.49 0 0 0-8.24-2.597c.465-1.9.893-3.777 1.273-5.621c6.238-30.281 2.16-54.676-11.769-62.708c-13.355-7.7-35.196.329-57.254 19.526a171.23 171.23 0 0 0-6.375 5.848a155.866 155.866 0 0 0-4.241-3.917C100.759 3.829 77.587-4.822 63.673 3.233C50.33 10.957 46.379 33.89 51.995 62.588a170.974 170.974 0 0 0 1.892 8.48c-3.28.932-6.445 1.924-9.474 2.98C17.309 83.498 0 98.307 0 113.668c0 15.865 18.582 31.778 46.812 41.427a145.52 145.52 0 0 0 6.921 2.165a167.467 167.467 0 0 0-2.01 9.138c-5.354 28.2-1.173 50.591 12.134 58.266c13.744 7.926 36.812-.22 59.273-19.855a145.567 145.567 0 0 0 5.342-4.923a168.064 168.064 0 0 0 6.92 6.314c21.758 18.722 43.246 26.282 56.54 18.586c13.731-7.949 18.194-32.003 12.4-61.268a145.016 145.016 0 0 0-1.535-6.842c1.62-.48 3.21-.974 4.76-1.488c29.348-9.723 48.443-25.443 48.443-41.52c0-15.417-17.868-30.326-45.517-39.844Zm-6.365 70.984c-1.4.463-2.836.91-4.3 1.345c-3.24-10.257-7.612-21.163-12.963-32.432c5.106-11 9.31-21.767 12.459-31.957c2.619.758 5.16 1.557 7.61 2.4c23.69 8.156 38.14 20.213 38.14 29.504c0 9.896-15.606 22.743-40.946 31.14Zm-10.514 20.834c2.562 12.94 2.927 24.64 1.23 33.787c-1.524 8.219-4.59 13.698-8.382 15.893c-8.067 4.67-25.32-1.4-43.927-17.412a156.726 156.726 0 0 1-6.437-5.87c7.214-7.889 14.423-17.06 21.459-27.246c12.376-1.098 24.068-2.894 34.671-5.345a134.17 134.17 0 0 1 1.386 6.193ZM87.276 214.515c-7.882 2.783-14.16 2.863-17.955.675c-8.075-4.657-11.432-22.636-6.853-46.752a156.923 156.923 0 0 1 1.869-8.499c10.486 2.32 22.093 3.988 34.498 4.994c7.084 9.967 14.501 19.128 21.976 27.15a134.668 134.668 0 0 1-4.877 4.492c-9.933 8.682-19.886 14.842-28.658 17.94ZM50.35 144.747c-12.483-4.267-22.792-9.812-29.858-15.863c-6.35-5.437-9.555-10.836-9.555-15.216c0-9.322 13.897-21.212 37.076-29.293c2.813-.98 5.757-1.905 8.812-2.773c3.204 10.42 7.406 21.315 12.477 32.332c-5.137 11.18-9.399 22.249-12.634 32.792a134.718 134.718 0 0 1-6.318-1.979Zm12.378-84.26c-4.811-24.587-1.616-43.134 6.425-47.789c8.564-4.958 27.502 2.111 47.463 19.835a144.318 144.318 0 0 1 3.841 3.545c-7.438 7.987-14.787 17.08-21.808 26.988c-12.04 1.116-23.565 2.908-34.161 5.309a160.342 160.342 0 0 1-1.76-7.887Zm110.427 27.268a347.8 347.8 0 0 0-7.785-12.803c8.168 1.033 15.994 2.404 23.343 4.08c-2.206 7.072-4.956 14.465-8.193 22.045a381.151 381.151 0 0 0-7.365-13.322Zm-45.032-43.861c5.044 5.465 10.096 11.566 15.065 18.186a322.04 322.04 0 0 0-30.257-.006c4.974-6.559 10.069-12.652 15.192-18.18ZM82.802 87.83a323.167 323.167 0 0 0-7.227 13.238c-3.184-7.553-5.909-14.98-8.134-22.152c7.304-1.634 15.093-2.97 23.209-3.984a321.524 321.524 0 0 0-7.848 12.897Zm8.081 65.352c-8.385-.936-16.291-2.203-23.593-3.793c2.26-7.3 5.045-14.885 8.298-22.6a321.187 321.187 0 0 0 7.257 13.246c2.594 4.48 5.28 8.868 8.038 13.147Zm37.542 31.03c-5.184-5.592-10.354-11.779-15.403-18.433c4.902.192 9.899.29 14.978.29c5.218 0 10.376-.117 15.453-.343c-4.985 6.774-10.018 12.97-15.028 18.486Zm52.198-57.817c3.422 7.8 6.306 15.345 8.596 22.52c-7.422 1.694-15.436 3.058-23.88 4.071a382.417 382.417 0 0 0 7.859-13.026a347.403 347.403 0 0 0 7.425-13.565Zm-16.898 8.101a358.557 358.557 0 0 1-12.281 19.815a329.4 329.4 0 0 1-23.444.823c-7.967 0-15.716-.248-23.178-.732a310.202 310.202 0 0 1-12.513-19.846h.001a307.41 307.41 0 0 1-10.923-20.627a310.278 310.278 0 0 1 10.89-20.637l-.001.001a307.318 307.318 0 0 1 12.413-19.761c7.613-.576 15.42-.876 23.31-.876H128c7.926 0 15.743.303 23.354.883a329.357 329.357 0 0 1 12.335 19.695a358.489 358.489 0 0 1 11.036 20.54a329.472 329.472 0 0 1-11 20.722Zm22.56-122.124c8.572 4.944 11.906 24.881 6.52 51.026c-.344 1.668-.73 3.367-1.15 5.09c-10.622-2.452-22.155-4.275-34.23-5.408c-7.034-10.017-14.323-19.124-21.64-27.008a160.789 160.789 0 0 1 5.888-5.4c18.9-16.447 36.564-22.941 44.612-18.3ZM128 90.808c12.625 0 22.86 10.235 22.86 22.86s-10.235 22.86-22.86 22.86s-22.86-10.235-22.86-22.86s10.235-22.86 22.86-22.86Z"></path></svg>
\ No newline at end of file
diff --git a/tools/scalar_tuner/src/assets/vite.svg b/tools/scalar_tuner/src/assets/vite.svg
new file mode 100644
index 0000000..5101b67
--- /dev/null
+++ b/tools/scalar_tuner/src/assets/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="77" height="47" fill="none" aria-labelledby="vite-logo-title" viewBox="0 0 77 47"><title id="vite-logo-title">Vite</title><style>.parenthesis{fill:#000}@media (prefers-color-scheme:dark){.parenthesis{fill:#fff}}</style><path fill="#9135ff" d="M40.151 45.71c-.663.844-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.493c-.92 0-1.457-1.04-.92-1.788l7.479-10.471c1.07-1.498 0-3.578-1.842-3.578H15.443c-.92 0-1.456-1.04-.92-1.788l9.696-13.576c.213-.297.556-.474.92-.474h28.894c.92 0 1.456 1.04.92 1.788l-7.48 10.472c-1.07 1.497 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.087.89 1.83L40.153 45.712z"/><mask id="a" width="48" height="47" x="14" y="0" maskUnits="userSpaceOnUse" style="mask-type:alpha"><path fill="#000" d="M40.047 45.71c-.663.843-2.02.374-2.02-.699V34.708a2.26 2.26 0 0 0-2.262-2.262H24.389c-.92 0-1.457-1.04-.92-1.788l7.479-10.472c1.07-1.497 0-3.578-1.842-3.578H15.34c-.92 0-1.456-1.04-.92-1.788l9.696-13.575c.213-.297.556-.474.92-.474H53.93c.92 0 1.456 1.04.92 1.788L47.37 13.03c-1.07 1.498 0 3.578 1.842 3.578h11.376c.944 0 1.474 1.088.89 1.831L40.049 45.712z"/></mask><g mask="url(#a)"><g filter="url(#b)"><ellipse cx="5.508" cy="14.704" fill="#eee6ff" rx="5.508" ry="14.704" transform="rotate(269.814 20.96 11.29)scale(-1 1)"/></g><g filter="url(#c)"><ellipse cx="10.399" cy="29.851" fill="#eee6ff" rx="10.399" ry="29.851" transform="rotate(89.814 -16.902 -8.275)scale(1 -1)"/></g><g filter="url(#d)"><ellipse cx="5.508" cy="30.487" fill="#8900ff" rx="5.508" ry="30.487" transform="rotate(89.814 -19.197 -7.127)scale(1 -1)"/></g><g filter="url(#e)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.928 4.177)scale(1 -1)"/></g><g filter="url(#f)"><ellipse cx="5.508" cy="30.599" fill="#8900ff" rx="5.508" ry="30.599" transform="rotate(89.814 -25.738 5.52)scale(1 -1)"/></g><g filter="url(#g)"><ellipse cx="14.072" cy="22.078" fill="#eee6ff" rx="14.072" ry="22.078" transform="rotate(93.35 31.245 55.578)scale(-1 1)"/></g><g filter="url(#h)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#i)"><ellipse cx="3.47" cy="21.501" fill="#8900ff" rx="3.47" ry="21.501" transform="rotate(89.009 35.419 55.202)scale(-1 1)"/></g><g filter="url(#j)"><ellipse cx="14.592" cy="9.743" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(39.51 14.592 9.743)"/></g><g filter="url(#k)"><ellipse cx="61.728" cy="-5.321" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 61.728 -5.32)"/></g><g filter="url(#l)"><ellipse cx="55.618" cy="7.104" fill="#00c2ff" rx="5.971" ry="9.665" transform="rotate(37.892 55.618 7.104)"/></g><g filter="url(#m)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#n)"><ellipse cx="12.326" cy="39.103" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 12.326 39.103)"/></g><g filter="url(#o)"><ellipse cx="49.857" cy="30.678" fill="#8900ff" rx="4.407" ry="29.108" transform="rotate(37.892 49.857 30.678)"/></g><g filter="url(#p)"><ellipse cx="52.623" cy="33.171" fill="#00c2ff" rx="5.971" ry="15.297" transform="rotate(37.892 52.623 33.17)"/></g></g><path d="M6.919 0c-9.198 13.166-9.252 33.575 0 46.789h6.215c-9.25-13.214-9.196-33.623 0-46.789zm62.424 0h-6.215c9.198 13.166 9.252 33.575 0 46.789h6.215c9.25-13.214 9.196-33.623 0-46.789" class="parenthesis"/><defs><filter id="b" width="60.045" height="41.654" x="-5.564" y="16.92" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="c" width="90.34" height="51.437" x="-40.407" y="-6.762" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="d" width="79.355" height="29.4" x="-35.435" y="2.801" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="e" width="79.579" height="29.4" x="-30.84" y="20.8" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="f" width="79.579" height="29.4" x="-29.307" y="21.949" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="g" width="74.749" height="58.852" x="29.961" y="-17.13" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="7.659"/></filter><filter id="h" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="i" width="61.377" height="25.362" x="37.754" y="3.055" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="j" width="56.045" height="63.649" x="-13.43" y="-22.082" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="k" width="54.814" height="64.646" x="34.321" y="-37.644" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="l" width="33.541" height="35.313" x="38.847" y="-10.552" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="m" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="n" width="54.814" height="64.646" x="-15.081" y="6.78" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="o" width="54.814" height="64.646" x="22.45" y="-1.645" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter><filter id="p" width="39.409" height="43.623" x="32.919" y="11.36" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_2002_17286" stdDeviation="4.596"/></filter></defs></svg>
diff --git a/tools/scalar_tuner/src/components/BehaviorCard.jsx b/tools/scalar_tuner/src/components/BehaviorCard.jsx
new file mode 100644
index 0000000..0219a09
--- /dev/null
+++ b/tools/scalar_tuner/src/components/BehaviorCard.jsx
@@ -0,0 +1,160 @@
+import { useState, useMemo } from 'react'
+import MetricRow from './MetricRow'
+import ScoreDisplay from './ScoreDisplay'
+import { isIntegerMultiple } from '../App'
+
+function colValue(col, metricKey, vals, effectiveScalar) {
+  switch (col) {
+    case 'metric':  return metricKey
+    case 'bad':     return vals.bad
+    case 'good':    return vals.good
+    case 'ratio':   return vals.ratio
+    case 'logdiff': return vals.log_good - vals.log_bad
+    case 'contrib': return Math.exp(effectiveScalar * (vals.log_good - vals.log_bad))
+    case 'scalar':  return effectiveScalar
+  }
+}
+
+function sortIcon(col, sortCol, sortDir) {
+  if (sortCol !== col) return <span className="sort-icon muted">⇅</span>
+  if (sortDir === 'asc')  return <span className="sort-icon">↑</span>
+  if (sortDir === 'desc') return <span className="sort-icon">↓</span>
+}
+
+function isInDeadzone(effectiveScalar, logDiff, deadzone) {
+  if (effectiveScalar === 0) return true
+  const contrib = Math.exp(effectiveScalar * logDiff)
+  return contrib >= deadzone && contrib <= 2 - deadzone
+}
+
+export default function BehaviorCard({ behavior, metrics, scalars, score, onScalarChange }) {
+  const [showAll, setShowAll] = useState(true)
+  const [sortCol, setSortCol] = useState(null)
+  const [sortDir, setSortDir] = useState(null)
+  const [scale, setScale] = useState(1.0)
+  const [deadzone, setDeadzone] = useState(1.0)
+
+  // Default order: by abs(suggested_scalar), stable, never depends on scalars
+  const defaultEntries = useMemo(
+    () => [...Object.entries(metrics)].sort(([, a], [, b]) =>
+      Math.abs(b.suggested_scalar ?? 0) - Math.abs(a.suggested_scalar ?? 0)
+    ),
+    [metrics]
+  )
+
+  // Virtual score: use scale + deadzone filter, never modifies actual scalars
+  const virtualScore = useMemo(() => {
+    const compute = side => Object.entries(scalars).reduce((acc, [k, scalar]) => {
+      const eff = scalar * scale
+      if (eff === 0) return acc
+      const bv = Math.max(metrics[k]?.bad ?? 1, 1e-300)
+      const gv = Math.max(metrics[k]?.good ?? 1, 1e-300)
+      const logDiff = Math.log(gv) - Math.log(bv)
+      if (isInDeadzone(eff, logDiff, deadzone)) return acc
+      return acc * Math.pow(side === 'bad' ? bv : gv, eff)
+    }, 1.0)
+    const bad = compute('bad')
+    const good = compute('good')
+    return { bad, good, ratio: bad > 0 ? good / bad : 0 }
+  }, [scalars, scale, deadzone, metrics])
+
+  function handleColClick(col) {
+    if (sortCol !== col) { setSortCol(col); setSortDir('asc') }
+    else if (sortDir === 'asc') setSortDir('desc')
+    else { setSortCol(null); setSortDir(null) }
+  }
+
+  const sortedEntries = useMemo(() => {
+    const base = showAll ? defaultEntries : defaultEntries.filter(([k]) => (scalars[k] ?? 0) !== 0)
+    if (!sortCol || !sortDir) return base
+    return [...base].sort(([ka, va], [kb, vb]) => {
+      const a = colValue(sortCol, ka, va, (scalars[ka] ?? 0) * scale)
+      const b = colValue(sortCol, kb, vb, (scalars[kb] ?? 0) * scale)
+      if (typeof a === 'string') return sortDir === 'asc' ? a.localeCompare(b) : b.localeCompare(a)
+      return sortDir === 'asc' ? a - b : b - a
+    })
+  }, [defaultEntries, sortCol, sortDir, showAll, scalars, scale])
+
+  const nonZeroCount = defaultEntries.filter(([k]) => (scalars[k] ?? 0) !== 0).length
+  const deadzoneCount = useMemo(() =>
+    defaultEntries.filter(([k, v]) => {
+      const eff = (scalars[k] ?? 0) * scale
+      const logDiff = v.log_good - v.log_bad
+      return isInDeadzone(eff, logDiff, deadzone)
+    }).length,
+    [defaultEntries, scalars, scale, deadzone]
+  )
+
+  function th(col, label) {
+    return (
+      <th className="sortable-th" onClick={() => handleColClick(col)}>
+        {label}{sortIcon(col, sortCol, sortDir)}
+      </th>
+    )
+  }
+
+  return (
+    <div>
+      <div className="behavior-sticky">
+        <ScoreDisplay score={virtualScore} />
+
+        <div className="table-toolbar">
+          <label className="ctrl-label">
+            scale
+            <input type="range" min="0.1" max="3" step="0.01" value={scale}
+              onChange={e => setScale(parseFloat(e.target.value))} className="ctrl-slider" />
+            <span className="ctrl-val">×{scale.toFixed(2)}</span>
+            <button className="ctrl-reset" onClick={() => setScale(1.0)} disabled={scale === 1.0}>↺</button>
+          </label>
+
+          <label className="ctrl-label">
+            deadzone
+            <input type="range" min="0.9" max="1.0" step="0.001" value={deadzone}
+              onChange={e => setDeadzone(parseFloat(e.target.value))} className="ctrl-slider" />
+            <span className="ctrl-val">[{deadzone.toFixed(3)}, {(2 - deadzone).toFixed(3)}]</span>
+            <span className="ctrl-val muted">{deadzoneCount} cut</span>
+            <button className="ctrl-reset" onClick={() => setDeadzone(1.0)} disabled={deadzone === 1.0}>↺</button>
+          </label>
+        </div>
+      </div>
+
+      <table className="metrics-table">
+        <thead>
+          <tr>
+            {th('metric',  'metric')}
+            {th('bad',     'bad')}
+            {th('good',    'good')}
+            {th('ratio',   'ratio')}
+            {th('logdiff', 'log diff')}
+            {th('contrib', 'contrib')}
+            {th('scalar',  'scalar')}
+          </tr>
+        </thead>
+        <tbody>
+          {sortedEntries.map(([metricKey, vals]) => {
+            const actualScalar = scalars[metricKey] ?? 0
+            const effectiveScalar = actualScalar * scale
+            const logDiff = vals.log_good - vals.log_bad
+            return (
+              <MetricRow
+                key={metricKey}
+                metricKey={metricKey}
+                vals={vals}
+                scalar={actualScalar}
+                effectiveScalar={effectiveScalar}
+                isDeadzoned={isInDeadzone(effectiveScalar, logDiff, deadzone)}
+                isDamped={isIntegerMultiple(vals.bad, vals.good)}
+                onChange={v => onScalarChange(metricKey, v)}
+              />
+            )
+          })}
+        </tbody>
+      </table>
+      <button className="toggle-all" onClick={() => setShowAll(s => !s)}>
+        {showAll
+          ? `Hide zero-scalar metrics`
+          : `Show all metrics (${defaultEntries.length - nonZeroCount} hidden)`}
+      </button>
+    </div>
+  )
+}
diff --git a/tools/scalar_tuner/src/components/Knob.jsx b/tools/scalar_tuner/src/components/Knob.jsx
new file mode 100644
index 0000000..874ca2f
--- /dev/null
+++ b/tools/scalar_tuner/src/components/Knob.jsx
@@ -0,0 +1,68 @@
+import { useEffect, useRef, useState } from 'react'
+
+const MIN_ANGLE = -135
+const MAX_ANGLE = 135
+
+function angleToFactor(angle) {
+  // center (0°) = ×1.0, full CW (+135°) = ×3.0, full CCW (-135°) = ×0.0
+  if (angle >= 0) return 1 + (angle / MAX_ANGLE) * 2
+  else return 1 + (angle / Math.abs(MIN_ANGLE)) * 1
+}
+
+export default function Knob({ onFactor }) {
+  const [angle, setAngle] = useState(0)
+  const [dragging, setDragging] = useState(false)
+  const startRef = useRef(null)
+  const angleRef = useRef(0)
+
+  function onMouseDown(e) {
+    e.preventDefault()
+    startRef.current = { y: e.clientY, startAngle: angleRef.current }
+    setDragging(true)
+  }
+
+  useEffect(() => {
+    if (!dragging) return
+
+    function onMouseMove(e) {
+      const dy = startRef.current.y - e.clientY
+      const newAngle = Math.max(MIN_ANGLE, Math.min(MAX_ANGLE, startRef.current.startAngle + dy))
+      angleRef.current = newAngle
+      setAngle(newAngle)
+      onFactor(angleToFactor(newAngle), false)
+    }
+
+    function onMouseUp() {
+      onFactor(angleToFactor(angleRef.current), true)
+      angleRef.current = 0
+      setAngle(0)
+      setDragging(false)
+    }
+
+    window.addEventListener('mousemove', onMouseMove)
+    window.addEventListener('mouseup', onMouseUp)
+    return () => {
+      window.removeEventListener('mousemove', onMouseMove)
+      window.removeEventListener('mouseup', onMouseUp)
+    }
+  }, [dragging])
+
+  const factor = angleToFactor(angle)
+
+  return (
+    <div className="knob-wrap">
+      <div className="knob-track">
+        <span className="knob-end-label">0</span>
+        <div
+          className={`knob${dragging ? ' knob-active' : ''}`}
+          onMouseDown={onMouseDown}
+          style={{ transform: `rotate(${angle}deg)` }}
+        >
+          <div className="knob-pip" />
+        </div>
+        <span className="knob-end-label">3×</span>
+      </div>
+      <span className="knob-readout">{dragging ? `×${factor.toFixed(2)}` : 'scale all'}</span>
+    </div>
+  )
+}
diff --git a/tools/scalar_tuner/src/components/MetricRow.jsx b/tools/scalar_tuner/src/components/MetricRow.jsx
new file mode 100644
index 0000000..c3339e3
--- /dev/null
+++ b/tools/scalar_tuner/src/components/MetricRow.jsx
@@ -0,0 +1,59 @@
+function fmtContrib(v) {
+  if (v === 1) return '1.000'
+  if (v > 999) return '>999'
+  if (v < 0.001) return v.toExponential(1)
+  return v.toFixed(3)
+}
+
+export default function MetricRow({ metricKey, vals, scalar, effectiveScalar, isDeadzoned, isDamped, onChange }) {
+  const logDiff = (vals.log_good - vals.log_bad).toFixed(3)
+  const ratio = vals.ratio.toFixed(3)
+
+  const contribution = effectiveScalar !== 0
+    ? Math.exp(effectiveScalar * (vals.log_good - vals.log_bad))
+    : 1
+  const contribPositive = contribution > 1
+  const contribNeutral = isDeadzoned || Math.abs(contribution - 1) < 0.001
+
+  return (
+    <tr className={`${scalar !== 0 ? 'active-row' : ''}${isDeadzoned ? ' dead-row' : ''}`}>
+      <td className="metric-key">
+        {metricKey}
+        {isDamped && (
+          <span
+            className="damped-tag"
+            title="good/bad ratio is approximately an integer multiple (e.g. 6→12, 2.5→10). Suggests a trivially scaling metric — suggested scalar capped at ±1.5"
+          >~int</span>
+        )}
+      </td>
+      <td className="num">{vals.bad.toFixed(4)}</td>
+      <td className="num">{vals.good.toFixed(4)}</td>
+      <td className="num">{ratio}x</td>
+      <td className={`num ${parseFloat(logDiff) > 0 ? 'pos' : parseFloat(logDiff) < 0 ? 'neg' : ''}`}>
+        {logDiff}
+      </td>
+      <td className={`num contrib ${isDeadzoned ? 'dead' : contribNeutral ? '' : contribPositive ? 'pos' : 'neg'}`}>
+        {isDeadzoned ? '—' : `${fmtContrib(contribution)}x`}
+      </td>
+      <td className="scalar-cell">
+        <input
+          type="range"
+          min="-3"
+          max="3"
+          step="0.01"
+          value={scalar}
+          onChange={e => onChange(parseFloat(e.target.value))}
+        />
+        <input
+          type="number"
+          min="-3"
+          max="3"
+          step="0.01"
+          value={scalar}
+          onChange={e => onChange(parseFloat(e.target.value) || 0)}
+          className="scalar-input"
+        />
+      </td>
+    </tr>
+  )
+}
diff --git a/tools/scalar_tuner/src/components/ScoreDisplay.jsx b/tools/scalar_tuner/src/components/ScoreDisplay.jsx
new file mode 100644
index 0000000..8d372ec
--- /dev/null
+++ b/tools/scalar_tuner/src/components/ScoreDisplay.jsx
@@ -0,0 +1,52 @@
+function fmt(v) {
+  if (v === 0) return '0'
+  if (v >= 999999999) return '999999999'
+  if (v < 0.0001) return v.toExponential(2)
+  return v.toFixed(4)
+}
+
+function fmtLog(v) {
+  if (v <= 0) return '—'
+  return Math.log(v).toFixed(3)
+}
+
+function fmtRatio(v) {
+  if (v >= 999999999) return '999999999'
+  return v.toFixed(2)
+}
+
+function fmtLog10Ratio(v) {
+  if (v <= 0) return '—'
+  return Math.log10(v).toFixed(2)
+}
+
+export default function ScoreDisplay({ score }) {
+  if (!score) return null
+  const { bad, good, ratio } = score
+
+  const cls = ratio >= 2.0 ? 'ratio-good' : ratio >= 1.0 ? 'ratio-weak' : 'ratio-bad'
+  const icon = ratio >= 2.0 ? '✓' : ratio >= 1.0 ? '~' : '✗'
+  const isUnderflow = bad < 1e-10 && good < 1e-10
+
+  return (
+    <table className={`score-display ${cls}`}>
+      <tbody>
+        <tr>
+          <td className="sd-label">bad</td>
+          <td className="sd-val">{fmt(bad)}</td>
+          <td className="sd-log">ln={fmtLog(bad)}</td>
+        </tr>
+        <tr>
+          <td className="sd-label">good</td>
+          <td className="sd-val">{fmt(good)}</td>
+          <td className="sd-log">ln={fmtLog(good)}</td>
+        </tr>
+        <tr>
+          <td className="sd-label">ratio</td>
+          <td className="sd-val sd-ratio">{fmtRatio(ratio)}x {icon}</td>
+          <td className="sd-log">log₁₀={fmtLog10Ratio(ratio)}{isUnderflow ? ' ⚠' : ''}</td>
+        </tr>
+      </tbody>
+    </table>
+  )
+}
diff --git a/tools/scalar_tuner/src/components/YamlModal.jsx b/tools/scalar_tuner/src/components/YamlModal.jsx
new file mode 100644
index 0000000..875d651
--- /dev/null
+++ b/tools/scalar_tuner/src/components/YamlModal.jsx
@@ -0,0 +1,64 @@
+import { useMemo } from 'react'
+
+function toYaml(scalars) {
+  const categories = {}
+
+  for (const [behaviorKey, metrics] of Object.entries(scalars)) {
+    const dotIdx = behaviorKey.indexOf('.')
+    const category = behaviorKey.slice(0, dotIdx)
+    const behavior = behaviorKey.slice(dotIdx + 1)
+
+    if (!categories[category]) categories[category] = {}
+
+    const nonZero = Object.entries(metrics).filter(([, v]) => v !== 0)
+    if (nonZero.length === 0) continue
+
+    const grouped = {}
+    for (const [metricKey, scalar] of nonZero) {
+      const [group, key] = metricKey.split('.')
+      if (!grouped[group]) grouped[group] = {}
+      grouped[group][key] = scalar
+    }
+
+    categories[category][behavior] = grouped
+  }
+
+  let out = ''
+  for (const [category, behaviors] of Object.entries(categories)) {
+    out += `# ${category}\n`
+    for (const [behavior, groups] of Object.entries(behaviors)) {
+      out += `${behavior}:\n`
+      for (const [group, keys] of Object.entries(groups)) {
+        out += `  ${group}:\n`
+        for (const [key, scalar] of Object.entries(keys)) {
+          out += `    ${key}: ${scalar.toFixed(4)}\n`
+        }
+      }
+      out += '\n'
+    }
+  }
+  return out.trim()
+}
+
+export default function YamlModal({ scalars, onClose }) {
+  const yaml = useMemo(() => toYaml(scalars), [scalars])
+
+  function copy() {
+    navigator.clipboard.writeText(yaml)
+  }
+
+  return (
+    <div className="modal-overlay" onClick={onClose}>
+      <div className="modal" onClick={e => e.stopPropagation()}>
+        <div className="modal-header">
+          <h3>YAML Export</h3>
+          <div>
+            <button onClick={copy}>Copy to clipboard</button>
+            <button onClick={onClose}>✕</button>
+          </div>
+        </div>
+        <pre className="yaml-output">{yaml}</pre>
+      </div>
+    </div>
+  )
+}
diff --git a/tools/scalar_tuner/src/index.css b/tools/scalar_tuner/src/index.css
new file mode 100644
index 0000000..4300cd0
--- /dev/null
+++ b/tools/scalar_tuner/src/index.css
@@ -0,0 +1,106 @@
+:root {
+  --text: #6b6375;
+  --text-h: #08060d;
+  --bg: #fff;
+  --border: #e5e4e7;
+  --code-bg: #f4f3ec;
+  --accent: #aa3bff;
+  --accent-bg: rgba(170, 59, 255, 0.1);
+  --accent-border: rgba(170, 59, 255, 0.5);
+  --social-bg: rgba(244, 243, 236, 0.5);
+  --shadow:
+    rgba(0, 0, 0, 0.1) 0 10px 15px -3px, rgba(0, 0, 0, 0.05) 0 4px 6px -2px;
+
+  --sans: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --heading: system-ui, 'Segoe UI', Roboto, sans-serif;
+  --mono: ui-monospace, Consolas, monospace;
+
+  font: 18px/145% var(--sans);
+  letter-spacing: 0.18px;
+  color-scheme: light dark;
+  color: var(--text);
+  background: var(--bg);
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+
+  @media (max-width: 1024px) {
+    font-size: 16px;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #9ca3af;
+    --text-h: #f3f4f6;
+    --bg: #16171d;
+    --border: #2e303a;
+    --code-bg: #1f2028;
+    --accent: #c084fc;
+    --accent-bg: rgba(192, 132, 252, 0.15);
+    --accent-border: rgba(192, 132, 252, 0.5);
+    --social-bg: rgba(47, 48, 58, 0.5);
+    --shadow:
+      rgba(0, 0, 0, 0.4) 0 10px 15px -3px, rgba(0, 0, 0, 0.25) 0 4px 6px -2px;
+  }
+
+  #social .button-icon {
+    filter: invert(1) brightness(2);
+  }
+}
+
+body {
+  margin: 0;
+}
+
+#root {
+  width: 100%;
+  height: 100vh;
+  display: flex;
+  flex-direction: column;
+}
+
+h1,
+h2 {
+  font-family: var(--heading);
+  font-weight: 500;
+  color: var(--text-h);
+}
+
+h1 {
+  font-size: 56px;
+  letter-spacing: -1.68px;
+  margin: 32px 0;
+  @media (max-width: 1024px) {
+    font-size: 36px;
+    margin: 20px 0;
+  }
+}
+h2 {
+  font-size: 24px;
+  line-height: 118%;
+  letter-spacing: -0.24px;
+  margin: 0 0 8px;
+  @media (max-width: 1024px) {
+    font-size: 20px;
+  }
+}
+p {
+  margin: 0;
+}
+
+code,
+.counter {
+  font-family: var(--mono);
+  display: inline-flex;
+  border-radius: 4px;
+  color: var(--text-h);
+}
+
+code {
+  font-size: 15px;
+  line-height: 135%;
+  padding: 4px 8px;
+  background: var(--code-bg);
+}
diff --git a/tools/scalar_tuner/src/main.jsx b/tools/scalar_tuner/src/main.jsx
new file mode 100644
index 0000000..b9a1a6d
--- /dev/null
+++ b/tools/scalar_tuner/src/main.jsx
@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.jsx'
+
+createRoot(document.getElementById('root')).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)
diff --git a/tools/scalar_tuner/vite.config.js b/tools/scalar_tuner/vite.config.js
new file mode 100644
index 0000000..8b0f57b
--- /dev/null
+++ b/tools/scalar_tuner/vite.config.js
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})

From 5250d22aa36c310e2a4e664fa84613f07b797dd9 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 19 Mar 2026 18:27:52 +0100
Subject: [PATCH 12/71] docs: update README and action configuration

Update README with new feature documentation. Update .codeqa.yml,
action.yml, and run script to reflect the new engine and CLI structure.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .codeqa.yml    |  27 +++++++-
 README.md      | 182 +++++++++++++++++++++++++++++++++++++++----------
 action.yml     |   2 +-
 scripts/run.sh |   6 +-
 4 files changed, 179 insertions(+), 38 deletions(-)

diff --git a/.codeqa.yml b/.codeqa.yml
index e6d5d46..8fa1a5c 100644
--- a/.codeqa.yml
+++ b/.codeqa.yml
@@ -4,4 +4,29 @@
 # Patterns here are merged with any --ignore-paths passed on the command line.
 
 ignore_paths:
-  - priv/combined_metrics/samples/**
+  - priv/**
+  - tools/**
+  - scripts/**
+  - docs/**
+  - plans/**
+  - devenv*
+  - direnv*
+
+# Impact weights for overall score calculation.
+# Combined metric categories default to 1 (can be overridden here).
+impact:
+  complexity: 5
+  file_structure: 4
+  function_design: 4
+  code_smells: 3
+  naming_conventions: 2
+  error_handling: 2
+  consistency: 2
+  documentation: 1
+  testing: 1
+  # combined categories override example:
+  # variable_naming: 2
+
+combined_top: 5 # worst offender files per combined-metric behavior
+
+cosine_significance_threshold: 0.25 # threshold for cosine similarity calculation in behavior categories
diff --git a/README.md b/README.md
index 259ee49..071789b 100644
--- a/README.md
+++ b/README.md
@@ -17,14 +17,14 @@ Works with Python, Ruby, JavaScript, TypeScript, Elixir, C#, Java, C++, Go, Rust
 - [CLI Reference](#cli-reference)
   - [analyze](#analyze)
   - [health-report](#health-report)
+  - [diagnose](#diagnose)
   - [compare](#compare)
   - [history](#history)
   - [correlate](#correlate)
-  - [stopwords](#stopwords)
 - [Metrics Reference](#metrics-reference)
   - [Raw Metrics](#raw-metrics)
   - [Health Report Categories](#health-report-categories)
-  - [Behavior Checks](#behavior-checks)
+  - [Behavior Categories](#behavior-categories)
 - [Output Formats](#output-formats)
 - [Grading](#grading)
 
@@ -112,7 +112,7 @@ jobs:
 
 | Input | Required | Default | Description |
 |-------|----------|---------|-------------|
-| `command` | yes | — | CLI command to run: `health-report`, `compare`, or `analyze` |
+| `command` | yes | — | CLI command to run: `health-report`, `compare`, `analyze`, `history`, `correlate`, or `diagnose` |
 | `path` | no | `.` | Directory to analyze |
 | `comment` | no | `false` | Post results as a sticky PR comment |
 | `fail-grade` | no | — | Fail the action if overall grade is below this (e.g. `C`) |
@@ -153,22 +153,83 @@ ignore_paths:
 
 ```yaml
 categories:
-  - name: Naming
-    weight: 1.5
+  Naming:
+    name: Naming
     metrics:
       - name: vowel_density
-        good: 0.4
-        thresholds: [0.35, 0.3, 0.25]
+        weight: 1.5
+        good: "high"
+        thresholds:
+          a: 0.42
+          b: 0.38
+          c: 0.32
+          d: 0.25
 ```
 
+Category-level keys: `name` (display name), `metrics` (list of metric overrides), `top` (worst-offender count override).
+
+Metric-level keys: `name` (metric key), `weight` (relative weight within the category), `good` (`"high"` or `"low"` — direction where higher values are better or worse), `source` (metric path), `thresholds` (map of letter-grade cutoffs: `a`, `b`, `c`, `d`).
+
 ### Grade scale override
 
 ```yaml
 grade_scale:
-  - [90, "A"]
-  - [80, "B"]
-  - [70, "C"]
-  - [0,  "F"]
+  - min: 90
+    grade: "A"
+  - min: 80
+    grade: "B"
+  - min: 70
+    grade: "C"
+  - min: 0
+    grade: "F"
+```
+
+### impact
+
+Impact weights used when computing the overall score. The 9 keys below are the built-in defaults; any category not listed falls back to `1`. These weights apply to both primary and behavior categories.
+
+```yaml
+impact:
+  complexity: 5
+  file_structure: 4
+  function_design: 4
+  code_smells: 3
+  naming_conventions: 2
+  error_handling: 2
+  consistency: 2
+  documentation: 1
+  testing: 1
+  # override any category key:
+  # variable_naming: 2
+```
+
+### combined_top
+
+Controls how many worst-offender files are shown per behavior category in `health-report` (default: `2`).
+
+```yaml
+combined_top: 3
+```
+
+### near_duplicate_blocks
+
+Configures codebase-level near-duplicate block detection (used by `analyze`).
+
+```yaml
+near_duplicate_blocks:
+  max_pairs_per_bucket: 50
+```
+
+| Key | Description |
+|-----|-------------|
+| `max_pairs_per_bucket` | Maximum duplicate pairs reported per similarity bucket (default: unlimited) |
+
+### cosine_significance_threshold
+
+Minimum cosine similarity required for a behavior category match to be considered significant. Matches below this threshold are treated as noise and excluded from scoring. Default: `0.15`.
+
+```yaml
+cosine_significance_threshold: 0.25
 ```
 
 ## CLI Reference
@@ -228,6 +289,31 @@ Produces a graded quality report grouped into behavior categories with worst-off
 ./codeqa health-report --detail full --top 10 --format github ./lib
 ```
 
+### diagnose
+
+Identifies likely code quality issues by scoring behavior profiles using cosine similarity. Useful for understanding *why* a codebase scores poorly without running a full health report.
+
+```sh
+./codeqa diagnose --path <path> [OPTIONS]
+```
+
+`--path` is **required**. Note: unlike `health-report`, the path is passed as a named flag (`--path`), not a positional argument.
+
+| Option | Description |
+|--------|-------------|
+| `--path PATH` | **(Required)** File or directory to analyze |
+| `--mode MODE` | `aggregate` (default) or `per-file` |
+| `--top N` | Number of top issues to show (default: `15`) |
+| `--format FORMAT` | Output format: `plain` or `json` (default: `plain`) |
+| `--combined-top N` | Worst-offender files per behavior in per-file mode (default: `2`) |
+
+**Example:**
+
+```sh
+./codeqa diagnose --path ./lib --mode aggregate --top 10
+./codeqa diagnose --path ./lib --mode per-file --format json
+```
+
 ### compare
 
 Compares code quality metrics between two git refs. Designed for PR workflows.
@@ -246,6 +332,16 @@ Compares code quality metrics between two git refs. Designed for PR workflows.
 | `--output MODE` | Output mode: `auto`, `summary`, or `changes` (default: `auto`) |
 | `--changes-only` | Only analyze files changed between refs |
 | `--all-files` | Analyze all source files at both refs (default) |
+| `--workers N` | Parallel worker count |
+| `--progress` | Show per-file progress |
+| `--cache` | Cache computed metrics to disk |
+| `--cache-dir PATH` | Directory for cached metrics (default: `.codeqa_cache`) |
+| `--timeout MS` | Per-file timeout in milliseconds (default: `5000`) |
+| `--show-ncd` | Include NCD similarity matrix |
+| `--ncd-top N` | Top similar pairs per file |
+| `--ncd-paths PATHS` | Comma-separated paths to compare for NCD |
+| `--show-files` | Include per-file metrics in output |
+| `--show-file-paths PATHS` | Comma-separated list of specific file paths to include |
 | `--ignore-paths GLOBS` | Comma-separated glob patterns to exclude |
 
 **Example:**
@@ -269,6 +365,16 @@ Tracks codebase metrics across multiple commits, writing per-commit JSON snapsho
 | `--output-dir PATH` | **(Required)** Directory to write JSON snapshots |
 | `--commits N` | Number of recent commits to analyze |
 | `--commit-list SHAS` | Comma-separated list of explicit commit SHAs |
+| `--workers N` | Parallel worker count |
+| `--progress` | Show per-file progress |
+| `--cache` | Cache computed metrics to disk |
+| `--cache-dir PATH` | Directory for cached metrics (default: `.codeqa_cache`) |
+| `--timeout MS` | Per-file timeout in milliseconds (default: `5000`) |
+| `--show-ncd` | Include NCD similarity matrix |
+| `--ncd-top N` | Top similar pairs per file |
+| `--ncd-paths PATHS` | Comma-separated paths to compare for NCD |
+| `--show-files` | Include per-file metrics in output |
+| `--show-file-paths PATHS` | Comma-separated list of specific file paths to include |
 | `--ignore-paths GLOBS` | Comma-separated glob patterns to exclude |
 
 ### correlate
@@ -282,27 +388,12 @@ Finds metric correlations across history snapshots produced by `history`. Run `h
 | Option | Description |
 |--------|-------------|
 | `--top N` | Number of top correlations to show (default: `20`) |
-| `--hide-exact` | Hide perfect 1.0 correlations |
-| `--all-groups` | Show all metric groups |
+| `--hide-exact` | Hide perfect 1.0 and -1.0 correlations |
+| `--all-groups` | Include correlations between metrics in the same group |
 | `--min FLOAT` | Minimum correlation threshold |
 | `--max FLOAT` | Maximum correlation threshold |
 | `--combined-only` | Show only combined-metric correlations |
-| `--max-steps N` | Limit history steps used |
-
-### stopwords
-
-Extracts codebase-specific vocabulary stopwords and fingerprints. Use the output to reduce noise from project-specific boilerplate tokens in subsequent metric analysis.
-
-```sh
-./codeqa stopwords [OPTIONS] <path>
-```
-
-| Option | Description |
-|--------|-------------|
-| `--workers N` | Parallel worker count |
-| `--stopwords-threshold FLOAT` | Minimum frequency ratio (default: `0.01`) |
-| `--progress` | Show per-file progress |
-| `--ignore-paths GLOBS` | Comma-separated glob patterns to exclude |
+| `--max-steps N` | Maximum number of correlation pairs to evaluate |
 
 ## Metrics Reference
 
@@ -329,10 +420,17 @@ All metrics are computed per file and aggregated at the codebase level.
 | **Magic number density** | Ratio of numeric literals that appear to be unnamed constants |
 | **Function metrics** | Function count, average and maximum function line count, average and maximum parameter count |
 | **Cross-file similarity** | `cross_file_density`: overall codebase redundancy via combined compression ratio. `ncd_pairs` (opt-in via `--show-ncd`): Normalized Compression Distance between similar file pairs using winnowing fingerprints |
+| **Near-duplicate blocks** | Codebase-level detection of near- and exact-duplicate code blocks using token-based similarity. Reports duplicate pairs grouped by bucket, with source locations. Configurable via `near_duplicate_blocks:` in `.codeqa.yml`. |
+| **Block impact & refactoring potentials** | Per-file node tree enriched with leave-one-out impact scores and refactoring potentials. Added to each file entry as `"nodes"` in `analyze` JSON output. Surfaces the highest-impact blocks to refactor. |
 
 ### Health Report Categories
 
-The `health-report` command grades your codebase against 6 primary categories. Each category aggregates raw metrics using configurable weights and thresholds.
+The `health-report` command evaluates your codebase using two complementary scoring models:
+
+- **6 primary categories** — graded using configurable thresholds against raw metrics (Readability, Complexity, Structure, Duplication, Naming, Magic Numbers)
+- **12 behavior categories** — graded using cosine similarity against behavior profiles (see [Behavior Categories](#behavior-categories))
+
+The overall score is a weighted average of all 18 categories. Primary category weights are set via `weight:` in `.codeqa.yml`; behavior category weights are configured via [`impact:`](#impact).
 
 | Category | What it measures |
 |----------|-----------------|
@@ -343,11 +441,21 @@ The `health-report` command grades your codebase against 6 primary categories. E
 | **Naming** | Casing entropy, identifier length variance, avg sub-words per identifier |
 | **Magic Numbers** | Magic number density |
 
+**Cosine scoring breakpoints** (used for behavior categories):
+
+| Cosine similarity | Score | Approx. grade |
+|-------------------|-------|---------------|
+| ≥ 0.5             | 90–100 | A             |
+| ≥ 0.2             | 70–90  | B–A-          |
+| ≥ 0.0             | 50–70  | C–B-          |
+| ≥ −0.3            | 30–50  | D–C-          |
+| ≥ −1.0            | 0–30   | F–D-          |
+
 > Category definitions and thresholds are configurable via `.codeqa.yml`.
 
-### Behavior Checks
+### Behavior Categories
 
-In addition to the 6 graded categories, `health-report` evaluates additional behavior check categories using a separate multiplicative scoring model. These appear in the report as "Top Issues" diagnostics.
+In addition to the 6 primary categories, `health-report` grades 12 behavior categories using cosine similarity against behavior profiles. These contribute to the overall score alongside the primary categories.
 
 | Category | Checks |
 |----------|--------|
@@ -364,13 +472,15 @@ In addition to the 6 graded categories, `health-report` evaluates additional beh
 | **Dependencies** | Import and dependency patterns |
 | **Error Handling** | Error handling completeness |
 
+> These categories are graded in the `health-report` output using cosine similarity scoring and contribute to the overall score.
+
 ## Output Formats
 
 | Format | Commands | Description |
 |--------|----------|-------------|
-| `json` | `analyze`, `compare` | Full metrics structure, suitable for tooling |
-| `markdown` | `compare`, `health-report` | GitHub-flavored markdown tables |
-| `plain` | `health-report` | Human-readable terminal output (Markdown) |
+| `json` | `analyze`, `compare`, `diagnose` | Full metrics structure, suitable for tooling |
+| `markdown` | `compare` | GitHub-flavored markdown tables |
+| `plain` | `health-report`, `diagnose` | Human-readable terminal output |
 | `github` | `health-report`, `compare` | Markdown optimized for GitHub PR comments |
 
 ## Grading
@@ -397,6 +507,8 @@ In addition to the 6 graded categories, `health-report` evaluates additional beh
 | E-    | ≥ 6         |
 | F     | < 6         |
 
+The overall score is a weighted average across all categories. Primary category weights use the `weight:` field inside each category definition in `.codeqa.yml`. Behavior category weights are configured via `impact:` (defaults range from 1–5; categories not listed fall back to `1`). See [Configuration](#configuration) for examples.
+
 The `fail-grade` action input causes a non-zero exit when the overall grade falls below the specified threshold.
 
 ## Contributing & Issues
diff --git a/action.yml b/action.yml
index 6be6078..f680469 100644
--- a/action.yml
+++ b/action.yml
@@ -8,7 +8,7 @@ branding:
 
 inputs:
   command:
-    description: "Command to run: health-report, compare, or analyze"
+    description: "Command to run: health-report, compare, analyze, or blocks"
     required: true
   path:
     description: "Directory to analyze"
diff --git a/scripts/run.sh b/scripts/run.sh
index 9804205..cac8046 100755
--- a/scripts/run.sh
+++ b/scripts/run.sh
@@ -38,8 +38,9 @@ case "$INPUT_COMMAND" in
     fi
     ;;
   analyze) OUTPUT_FILE="${OUTPUT_FILE}.json" ;;
+  blocks) OUTPUT_FILE="${OUTPUT_FILE}.json" ;;
   *)
-    echo "::error::Unknown command: $INPUT_COMMAND. Must be health-report, compare, or analyze."
+    echo "::error::Unknown command: $INPUT_COMMAND. Must be health-report, compare, analyze, or blocks."
     exit 1
     ;;
 esac
@@ -82,6 +83,9 @@ case "$INPUT_COMMAND" in
   analyze)
     ARGS+=("--output" "$OUTPUT_FILE")
     ;;
+  blocks)
+    ARGS+=("--output" "$OUTPUT_FILE")
+    ;;
 esac
 
 # Parse ignore-paths YAML list into --ignore-paths flag

From d49f463d32313259ce2597956485f6c767b9532f Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 19 Mar 2026 18:30:04 +0100
Subject: [PATCH 13/71] test(analysis): add tests for OTP analysis servers

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../analysis/behavior_config_server_test.exs  | 75 +++++++++++++++
 .../analysis/file_context_server_test.exs     | 38 ++++++++
 .../analysis/file_metrics_server_test.exs     | 91 +++++++++++++++++++
 3 files changed, 204 insertions(+)
 create mode 100644 test/codeqa/analysis/behavior_config_server_test.exs
 create mode 100644 test/codeqa/analysis/file_context_server_test.exs
 create mode 100644 test/codeqa/analysis/file_metrics_server_test.exs

diff --git a/test/codeqa/analysis/behavior_config_server_test.exs b/test/codeqa/analysis/behavior_config_server_test.exs
new file mode 100644
index 0000000..b8afe6a
--- /dev/null
+++ b/test/codeqa/analysis/behavior_config_server_test.exs
@@ -0,0 +1,75 @@
+defmodule CodeQA.Analysis.BehaviorConfigServerTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.Analysis.BehaviorConfigServer
+
+  setup do
+    {:ok, pid} = BehaviorConfigServer.start_link()
+    {:ok, pid: pid}
+  end
+
+  test "get_all_behaviors/1 returns a non-empty map of categories", %{pid: pid} do
+    behaviors = BehaviorConfigServer.get_all_behaviors(pid)
+    assert is_map(behaviors)
+    assert map_size(behaviors) > 0
+
+    Enum.each(behaviors, fn {category, list} ->
+      assert is_binary(category)
+      assert is_list(list)
+      assert length(list) > 0
+
+      Enum.each(list, fn {behavior, data} ->
+        assert is_binary(behavior)
+        assert is_map(data)
+      end)
+    end)
+  end
+
+  test "get_all_behaviors/1 matches YamlElixir direct reads", %{pid: pid} do
+    behaviors = BehaviorConfigServer.get_all_behaviors(pid)
+    yaml_dir = "priv/combined_metrics"
+
+    {:ok, files} = File.ls(yaml_dir)
+
+    Enum.each(files |> Enum.filter(&String.ends_with?(&1, ".yml")), fn yml_file ->
+      category = String.trim_trailing(yml_file, ".yml")
+      {:ok, data} = YamlElixir.read_from_file(Path.join(yaml_dir, yml_file))
+
+      expected_behaviors =
+        data |> Enum.filter(fn {_k, v} -> is_map(v) end) |> Enum.map(&elem(&1, 0))
+
+      server_behaviors = Map.get(behaviors, category, []) |> Enum.map(&elem(&1, 0))
+      assert Enum.sort(expected_behaviors) == Enum.sort(server_behaviors)
+    end)
+  end
+
+  test "get_scalars/3 returns a map of {group, key} => scalar", %{pid: pid} do
+    behaviors = BehaviorConfigServer.get_all_behaviors(pid)
+    {category, [{behavior, _data} | _]} = Enum.at(behaviors, 0)
+
+    scalars = BehaviorConfigServer.get_scalars(pid, category, behavior)
+    assert is_map(scalars)
+
+    Enum.each(scalars, fn {{group, key}, scalar} ->
+      assert is_binary(group)
+      assert is_binary(key)
+      assert is_float(scalar)
+    end)
+  end
+
+  test "get_scalars/3 returns empty map for unknown behavior", %{pid: pid} do
+    assert BehaviorConfigServer.get_scalars(pid, "nonexistent", "also_nonexistent") == %{}
+  end
+
+  test "get_log_baseline/3 returns a float", %{pid: pid} do
+    behaviors = BehaviorConfigServer.get_all_behaviors(pid)
+    {category, [{behavior, _data} | _]} = Enum.at(behaviors, 0)
+
+    baseline = BehaviorConfigServer.get_log_baseline(pid, category, behavior)
+    assert is_float(baseline)
+  end
+
+  test "get_log_baseline/3 returns 0.0 for unknown behavior", %{pid: pid} do
+    assert BehaviorConfigServer.get_log_baseline(pid, "nonexistent", "also_nonexistent") == 0.0
+  end
+end
diff --git a/test/codeqa/analysis/file_context_server_test.exs b/test/codeqa/analysis/file_context_server_test.exs
new file mode 100644
index 0000000..660bd9a
--- /dev/null
+++ b/test/codeqa/analysis/file_context_server_test.exs
@@ -0,0 +1,38 @@
+defmodule CodeQA.Analysis.FileContextServerTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.Analysis.FileContextServer
+  alias CodeQA.Engine.{FileContext, Pipeline}
+
+  setup do
+    {:ok, pid} = FileContextServer.start_link()
+    {:ok, pid: pid}
+  end
+
+  test "get/2 returns a Pipeline.FileContext", %{pid: pid} do
+    content = "defmodule Foo do\n  def bar, do: :ok\nend\n"
+    ctx = FileContextServer.get(pid, content)
+    assert %FileContext{} = ctx
+    assert is_binary(ctx.content)
+  end
+
+  test "get/2 returns identical struct on second call without rebuilding", %{pid: pid} do
+    content = "defmodule Foo do\n  def bar, do: :ok\nend\n"
+    ctx1 = FileContextServer.get(pid, content)
+    ctx2 = FileContextServer.get(pid, content)
+    assert ctx1 == ctx2
+  end
+
+  test "get/2 with different content returns different results", %{pid: pid} do
+    ctx_a = FileContextServer.get(pid, "defmodule A do\nend\n")
+    ctx_b = FileContextServer.get(pid, "defmodule B do\n  def foo, do: 1\nend\n")
+    assert ctx_a != ctx_b
+  end
+
+  test "get/2 matches Pipeline.build_file_context/1 directly", %{pid: pid} do
+    content = "x = 1\ny = 2\n"
+    expected = Pipeline.build_file_context(content)
+    result = FileContextServer.get(pid, content)
+    assert result == expected
+  end
+end
diff --git a/test/codeqa/analysis/file_metrics_server_test.exs b/test/codeqa/analysis/file_metrics_server_test.exs
new file mode 100644
index 0000000..791c315
--- /dev/null
+++ b/test/codeqa/analysis/file_metrics_server_test.exs
@@ -0,0 +1,91 @@
+defmodule CodeQA.Analysis.FileMetricsServerTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.Analysis.FileMetricsServer
+
+  defp build_registry do
+    CodeQA.Engine.Analyzer.build_registry()
+  end
+
+  setup do
+    {:ok, pid} = FileMetricsServer.start_link()
+    {:ok, pid: pid}
+  end
+
+  describe "populate/3 and get_by_path/2" do
+    test "returns pre-populated baseline metrics for a path", %{pid: pid} do
+      content = "defmodule A do\n  def foo, do: 1\nend\n"
+
+      pipeline_result = %{
+        "files" => %{
+          "lib/a.ex" => %{"metrics" => %{"halstead" => %{"tokens" => 5.0}}}
+        }
+      }
+
+      files_map = %{"lib/a.ex" => content}
+      :ok = FileMetricsServer.populate(pid, pipeline_result, files_map)
+
+      metrics = FileMetricsServer.get_by_path(pid, "lib/a.ex")
+      assert metrics == %{"halstead" => %{"tokens" => 5.0}}
+    end
+
+    test "returns nil for unknown path", %{pid: pid} do
+      :ok = FileMetricsServer.populate(pid, %{"files" => %{}}, %{})
+      assert FileMetricsServer.get_by_path(pid, "nonexistent.ex") == nil
+    end
+  end
+
+  describe "get_for_content/3" do
+    test "computes and caches metrics on first call", %{pid: pid} do
+      registry = build_registry()
+      content = "defmodule A do\n  def foo, do: 1\nend\n"
+
+      metrics = FileMetricsServer.get_for_content(pid, registry, content)
+      assert is_map(metrics)
+      assert map_size(metrics) > 0
+    end
+
+    test "returns identical result on second call (cache hit)", %{pid: pid} do
+      registry = build_registry()
+      content = "defmodule A do\n  def foo, do: 1\nend\n"
+
+      m1 = FileMetricsServer.get_for_content(pid, registry, content)
+      m2 = FileMetricsServer.get_for_content(pid, registry, content)
+      assert m1 == m2
+    end
+
+    test "different content returns different metrics", %{pid: pid} do
+      registry = build_registry()
+      ma = FileMetricsServer.get_for_content(pid, registry, "x = 1\n")
+
+      mb =
+        FileMetricsServer.get_for_content(
+          pid,
+          registry,
+          String.duplicate("def foo(a, b), do: a + b\n", 20)
+        )
+
+      assert ma != mb
+    end
+
+    test "populate cross-indexes hash so get_for_content hits cache", %{pid: pid} do
+      registry = build_registry()
+      content = "defmodule A do\n  def foo, do: 1\nend\n"
+
+      pipeline_result = %{
+        "files" => %{
+          "lib/a.ex" => %{
+            "metrics" => %{"halstead" => %{"tokens" => 99.0}}
+          }
+        }
+      }
+
+      files_map = %{"lib/a.ex" => content}
+      :ok = FileMetricsServer.populate(pid, pipeline_result, files_map)
+
+      # Should hit the hash-keyed cache entry seeded from pipeline_result
+      metrics = FileMetricsServer.get_for_content(pid, registry, content)
+      assert metrics == %{"halstead" => %{"tokens" => 99.0}}
+    end
+  end
+end

From 6678ca79b1b9edbf3e448045ad5e6812cc1161da Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 19 Mar 2026 18:30:09 +0100
Subject: [PATCH 14/71] test(ast): add tests for AST parsing, signals, nodes,
 and enrichment

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../classification/node_classifier_test.exs   | 246 +++++++++++++
 .../ast/classification/node_protocol_test.exs | 114 ++++++
 .../node_type_detector_test.exs               | 143 ++++++++
 ...ompound_node_assertions_languages_test.exs | 136 +++++++
 .../enrichment/compound_node_builder_test.exs | 137 ++++++++
 .../ast/enrichment/node_analyzer_test.exs     |  62 ++++
 test/codeqa/ast/lexing/string_token_test.exs  | 195 ++++++++++
 .../ast/lexing/token_normalizer_test.exs      | 332 ++++++++++++++++++
 .../codeqa/ast/lexing/token_protocol_test.exs | 142 ++++++++
 test/codeqa/ast/nodes/code_node_test.exs      |  55 +++
 test/codeqa/ast/nodes/function_node_test.exs  |  68 ++++
 test/codeqa/ast/nodes/import_node_test.exs    |  74 ++++
 .../ast/parsing/parser_languages_test.exs     | 168 +++++++++
 test/codeqa/ast/parsing/parser_test.exs       | 188 ++++++++++
 .../ast/parsing/signal_registry_test.exs      |  33 ++
 .../codeqa/ast/parsing/signal_stream_test.exs |  43 +++
 test/codeqa/ast/parsing/signal_test.exs       |  56 +++
 .../comment_density_signal_test.exs           |  46 +++
 .../classification/config_signal_test.exs     |  28 ++
 .../classification/data_signal_test.exs       |  28 ++
 .../classification/type_signal_test.exs       |  40 +++
 .../access_modifier_signal_test.exs           |  49 +++
 .../assignment_function_signal_test.exs       |  84 +++++
 .../structural/blank_line_signal_test.exs     |  36 ++
 .../structural/bracket_signal_test.exs        |  43 +++
 .../structural/branch_split_signal_test.exs   |  93 +++++
 .../structural/colon_indent_signal_test.exs   |  29 ++
 .../comment_divider_signal_test.exs           |  52 +++
 .../structural/decorator_signal_test.exs      |  47 +++
 .../structural/dedent_to_zero_signal_test.exs |  55 +++
 .../doc_comment_lead_signal_test.exs          |  44 +++
 .../structural/keyword_signal_test.exs        |  38 ++
 .../structural/sql_block_signal_test.exs      |  60 ++++
 .../structural/triple_quote_signal_test.exs   |  35 ++
 34 files changed, 2999 insertions(+)
 create mode 100644 test/codeqa/ast/classification/node_classifier_test.exs
 create mode 100644 test/codeqa/ast/classification/node_protocol_test.exs
 create mode 100644 test/codeqa/ast/classification/node_type_detector_test.exs
 create mode 100644 test/codeqa/ast/enrichment/compound_node_assertions_languages_test.exs
 create mode 100644 test/codeqa/ast/enrichment/compound_node_builder_test.exs
 create mode 100644 test/codeqa/ast/enrichment/node_analyzer_test.exs
 create mode 100644 test/codeqa/ast/lexing/string_token_test.exs
 create mode 100644 test/codeqa/ast/lexing/token_normalizer_test.exs
 create mode 100644 test/codeqa/ast/lexing/token_protocol_test.exs
 create mode 100644 test/codeqa/ast/nodes/code_node_test.exs
 create mode 100644 test/codeqa/ast/nodes/function_node_test.exs
 create mode 100644 test/codeqa/ast/nodes/import_node_test.exs
 create mode 100644 test/codeqa/ast/parsing/parser_languages_test.exs
 create mode 100644 test/codeqa/ast/parsing/parser_test.exs
 create mode 100644 test/codeqa/ast/parsing/signal_registry_test.exs
 create mode 100644 test/codeqa/ast/parsing/signal_stream_test.exs
 create mode 100644 test/codeqa/ast/parsing/signal_test.exs
 create mode 100644 test/codeqa/ast/signals/classification/comment_density_signal_test.exs
 create mode 100644 test/codeqa/ast/signals/classification/config_signal_test.exs
 create mode 100644 test/codeqa/ast/signals/classification/data_signal_test.exs
 create mode 100644 test/codeqa/ast/signals/classification/type_signal_test.exs
 create mode 100644 test/codeqa/ast/signals/structural/access_modifier_signal_test.exs
 create mode 100644 test/codeqa/ast/signals/structural/assignment_function_signal_test.exs
 create mode 100644 test/codeqa/ast/signals/structural/blank_line_signal_test.exs
 create mode 100644 test/codeqa/ast/signals/structural/bracket_signal_test.exs
 create mode 100644 test/codeqa/ast/signals/structural/branch_split_signal_test.exs
 create mode 100644 test/codeqa/ast/signals/structural/colon_indent_signal_test.exs
 create mode 100644 test/codeqa/ast/signals/structural/comment_divider_signal_test.exs
 create mode 100644 test/codeqa/ast/signals/structural/decorator_signal_test.exs
 create mode 100644 test/codeqa/ast/signals/structural/dedent_to_zero_signal_test.exs
 create mode 100644 test/codeqa/ast/signals/structural/doc_comment_lead_signal_test.exs
 create mode 100644 test/codeqa/ast/signals/structural/keyword_signal_test.exs
 create mode 100644 test/codeqa/ast/signals/structural/sql_block_signal_test.exs
 create mode 100644 test/codeqa/ast/signals/structural/triple_quote_signal_test.exs

diff --git a/test/codeqa/ast/classification/node_classifier_test.exs b/test/codeqa/ast/classification/node_classifier_test.exs
new file mode 100644
index 0000000..5ec0055
--- /dev/null
+++ b/test/codeqa/ast/classification/node_classifier_test.exs
@@ -0,0 +1,246 @@
+defmodule CodeQA.AST.NodeClassifierTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Classification.NodeClassifier
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Lexing.Token
+  alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.AST.Enrichment.Node
+
+  alias CodeQA.AST.Nodes.{
+    CodeNode,
+    DocNode,
+    FunctionNode,
+    ModuleNode,
+    ImportNode,
+    AttributeNode,
+    TestNode
+  }
+
+  alias CodeQA.Languages.Code.Vm.Elixir, as: ElixirLang
+  alias CodeQA.Languages.Code.Scripting.Python
+  alias CodeQA.Languages.Code.Web.JavaScript
+  alias CodeQA.Languages.Code.Native.Go
+  alias CodeQA.Languages.Code.Native.Rust
+  alias CodeQA.Languages.Code.Scripting.Ruby
+  alias CodeQA.Languages.Code.Web.TypeScript
+  alias CodeQA.Languages.Code.Vm.Java
+  alias CodeQA.Languages.Code.Vm.CSharp
+
+  defp classify_first(code, opts \\ []) do
+    lang_mod = opts[:language_module] || CodeQA.Languages.Unknown
+
+    [block | _] =
+      code
+      |> TokenNormalizer.normalize_structural()
+      |> Parser.detect_blocks(lang_mod)
+
+    NodeClassifier.classify(block, lang_mod)
+  end
+
+  defp node_with_tokens(tokens) do
+    %Node{
+      tokens: tokens,
+      line_count: 1,
+      children: []
+    }
+  end
+
+  describe "classify/1 — function detection" do
+    test "def → FunctionNode" do
+      assert %FunctionNode{} =
+               classify_first("def foo(x), do: x + 1", language_module: ElixirLang)
+    end
+
+    test "defp → FunctionNode" do
+      assert %FunctionNode{} = classify_first("defp bar(x), do: x", language_module: ElixirLang)
+    end
+
+    test "defmacro → FunctionNode" do
+      assert %FunctionNode{} =
+               classify_first("defmacro my_macro(x), do: x", language_module: ElixirLang)
+    end
+
+    test "function keyword → FunctionNode" do
+      assert %FunctionNode{} =
+               classify_first("function foo(x) {\n  return x\n}", language_module: JavaScript)
+    end
+
+    test "func keyword → FunctionNode" do
+      assert %FunctionNode{} =
+               classify_first("func Foo(x int) int {\n  return x\n}", language_module: Go)
+    end
+
+    test "fn keyword → FunctionNode" do
+      assert %FunctionNode{} =
+               classify_first("fn main() {\n  println!(\"hello\")\n}", language_module: Rust)
+    end
+  end
+
+  describe "classify/1 — module detection" do
+    test "defmodule → ModuleNode" do
+      assert %ModuleNode{} =
+               classify_first("defmodule Foo do\n  :ok\nend", language_module: ElixirLang)
+    end
+
+    test "class → ModuleNode" do
+      assert %ModuleNode{} = classify_first("class Foo:\n  pass", language_module: Python)
+    end
+
+    test "module → ModuleNode" do
+      assert %ModuleNode{} =
+               classify_first("module Foo\n  def bar; end\nend", language_module: Ruby)
+    end
+
+    test "interface → ModuleNode" do
+      assert %ModuleNode{} =
+               classify_first("interface Foo {\n  bar(): void\n}", language_module: TypeScript)
+    end
+
+    test "struct → ModuleNode" do
+      assert %ModuleNode{} =
+               classify_first("struct Point {\n  x: f64,\n  y: f64,\n}", language_module: Rust)
+    end
+  end
+
+  describe "classify/1 — import detection" do
+    test "import → ImportNode" do
+      assert %ImportNode{} = classify_first("import Foo", language_module: ElixirLang)
+    end
+
+    test "alias → ImportNode" do
+      assert %ImportNode{} = classify_first("alias Foo.Bar", language_module: ElixirLang)
+    end
+
+    test "use → ImportNode" do
+      assert %ImportNode{} =
+               classify_first("use ExUnit.Case, async: true", language_module: ElixirLang)
+    end
+
+    test "require → ImportNode" do
+      assert %ImportNode{} = classify_first("require Logger", language_module: ElixirLang)
+    end
+
+    test "from keyword → ImportNode" do
+      assert %ImportNode{} = classify_first("from os import path", language_module: Python)
+    end
+  end
+
+  describe "classify/1 — test detection" do
+    test "test macro → TestNode" do
+      assert %TestNode{} =
+               classify_first(~s(test "something" do\n  :ok\nend), language_module: ElixirLang)
+    end
+
+    test "describe → TestNode" do
+      assert %TestNode{} =
+               classify_first(~s(describe "some context" do\n  :ok\nend),
+                 language_module: ElixirLang
+               )
+    end
+
+    test "it → TestNode" do
+      code = "it \"behaves correctly\" do\n  :ok\nend"
+      assert %TestNode{} = classify_first(code, language_module: JavaScript)
+    end
+  end
+
+  describe "classify/1 — doc detection" do
+    test "<DOC> token → DocNode" do
+      # A standalone triple-quoted string starts directly with the <DOC> token
+      assert %DocNode{} = classify_first(~s("""\nSome doc.\n"""))
+    end
+
+    test "direct <DOC> token in node → DocNode" do
+      doc_token = %Token{kind: "<DOC>", content: ~s("""), line: 1, col: 0}
+      nl = %Token{kind: "<NL>", content: "\n", line: 2, col: 0}
+      node = node_with_tokens([doc_token, nl])
+      assert %DocNode{} = NodeClassifier.classify(node, CodeQA.Languages.Unknown)
+    end
+  end
+
+  describe "classify/1 — attribute detection" do
+    test "@spec → AttributeNode with kind: :typespec" do
+      result = classify_first("@spec foo(integer()) :: :ok", language_module: ElixirLang)
+      assert %AttributeNode{kind: :typespec} = result
+    end
+
+    test "@type → AttributeNode with kind: :typespec" do
+      result = classify_first("@type user_id :: integer()", language_module: ElixirLang)
+      assert %AttributeNode{kind: :typespec} = result
+    end
+
+    test "@typep → AttributeNode with kind: :typespec" do
+      result = classify_first("@typep internal :: atom()", language_module: ElixirLang)
+      assert %AttributeNode{kind: :typespec} = result
+    end
+
+    test "@callback → AttributeNode with kind: :typespec" do
+      result =
+        classify_first("@callback fetch(term()) :: {:ok, term()}", language_module: ElixirLang)
+
+      assert %AttributeNode{kind: :typespec} = result
+    end
+
+    test "@enforce_keys → AttributeNode with kind: nil" do
+      result = classify_first("@enforce_keys [:name, :age]", language_module: ElixirLang)
+      assert %AttributeNode{kind: nil} = result
+    end
+
+    test "all Elixir typespec attributes are recognized" do
+      for attr <- ~w[spec type typep opaque callback macrocallback] do
+        result = classify_first("@#{attr} foo :: bar", language_module: ElixirLang)
+
+        assert %AttributeNode{kind: :typespec} = result,
+               "expected AttributeNode(kind: :typespec) for @#{attr}"
+      end
+    end
+  end
+
+  describe "classify/1 — code fallback" do
+    test "unrecognized token → CodeNode" do
+      assert %CodeNode{} = classify_first("x = 1 + 2")
+    end
+
+    test "empty-like node with only whitespace tokens → CodeNode" do
+      nl = %Token{kind: "<NL>", content: "\n", line: 1, col: 0}
+      node = node_with_tokens([nl])
+
+      assert %CodeNode{} =
+               NodeClassifier.classify(node, CodeQA.Languages.Unknown)
+    end
+  end
+
+  describe "classify/1 — ambiguity resolution" do
+    test "test beats function (test is not defp-style)" do
+      # 'test' is in TestSignal; FunctionSignal does not include 'test'
+      result = classify_first(~s(test "foo" do\n  :ok\nend), language_module: ElixirLang)
+      assert %TestNode{} = result
+    end
+
+    test "@inside code body at indent > 0 does not make block :attribute" do
+      code = "def foo do\n  @cache true\n  :ok\nend"
+      # FunctionSignal sees 'def' at indent 0 → :function wins
+      # AttributeSignal sees '@cache' but at indent 2, not 0 → no vote
+      result = classify_first(code, language_module: ElixirLang)
+      assert %FunctionNode{} = result
+    end
+  end
+
+  describe "classify/1 — field preservation" do
+    test "preserves tokens, line_count, children, start/end_line" do
+      tokens =
+        "def foo, do: :ok"
+        |> TokenNormalizer.normalize_structural()
+
+      [node] = Parser.detect_blocks(tokens, ElixirLang)
+      result = NodeClassifier.classify(node, ElixirLang)
+
+      assert result.tokens == node.tokens
+      assert result.line_count == node.line_count
+      assert result.children == node.children
+      assert result.start_line == node.start_line
+      assert result.end_line == node.end_line
+    end
+  end
+end
diff --git a/test/codeqa/ast/classification/node_protocol_test.exs b/test/codeqa/ast/classification/node_protocol_test.exs
new file mode 100644
index 0000000..54c922a
--- /dev/null
+++ b/test/codeqa/ast/classification/node_protocol_test.exs
@@ -0,0 +1,114 @@
+defmodule CodeQA.AST.NodeProtocolTest.FakeNode do
+  defstruct [:tokens, :line_count, :children, :start_line, :end_line, :label]
+
+  defimpl CodeQA.AST.Classification.NodeProtocol do
+    def tokens(n), do: n.tokens
+    def line_count(n), do: n.line_count
+    def children(n), do: n.children
+    def start_line(n), do: n.start_line
+    def end_line(n), do: n.end_line
+    def label(n), do: n.label
+
+    def flat_tokens(n) do
+      if Enum.empty?(n.children),
+        do: n.tokens,
+        else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+    end
+  end
+end
+
+defmodule CodeQA.AST.NodeProtocolTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Classification.NodeProtocol
+  alias CodeQA.AST.NodeProtocolTest.FakeNode
+
+  @node %FakeNode{
+    tokens: [:a, :b],
+    line_count: 3,
+    children: [],
+    start_line: 1,
+    end_line: 3,
+    label: "foo.ex:1"
+  }
+
+  test "tokens/1" do
+    assert NodeProtocol.tokens(@node) == [:a, :b]
+  end
+
+  test "line_count/1" do
+    assert NodeProtocol.line_count(@node) == 3
+  end
+
+  test "children/1" do
+    assert NodeProtocol.children(@node) == []
+  end
+
+  test "start_line/1" do
+    assert NodeProtocol.start_line(@node) == 1
+  end
+
+  test "end_line/1" do
+    assert NodeProtocol.end_line(@node) == 3
+  end
+
+  test "label/1" do
+    assert NodeProtocol.label(@node) == "foo.ex:1"
+  end
+
+  describe "flat_tokens/1" do
+    alias CodeQA.AST.Enrichment.Node
+
+    test "leaf node returns own tokens" do
+      leaf = %Node{tokens: [:a, :b], line_count: 1, children: []}
+      assert NodeProtocol.flat_tokens(leaf) == [:a, :b]
+    end
+
+    test "non-leaf node returns flattened descendant tokens" do
+      child_a = %Node{tokens: [:a], line_count: 1, children: []}
+      child_b = %Node{tokens: [:b, :c], line_count: 1, children: []}
+      parent = %Node{tokens: [:x], line_count: 2, children: [child_a, child_b]}
+      assert NodeProtocol.flat_tokens(parent) == [:a, :b, :c]
+    end
+
+    test "deeply nested node returns all leaf tokens" do
+      leaf = %Node{tokens: [:z], line_count: 1, children: []}
+      mid = %Node{tokens: [:y], line_count: 1, children: [leaf]}
+      root = %Node{tokens: [:x], line_count: 2, children: [mid]}
+      assert NodeProtocol.flat_tokens(root) == [:z]
+    end
+  end
+
+  describe "Node implements NodeProtocol" do
+    alias CodeQA.AST.Enrichment.Node
+
+    setup do
+      node = %Node{
+        tokens: [:x, :y],
+        line_count: 3,
+        children: [],
+        start_line: 1,
+        end_line: 3,
+        label: "f.ex:1"
+      }
+
+      %{node: node}
+    end
+
+    test "tokens/1", %{node: node} do
+      assert NodeProtocol.tokens(node) == [:x, :y]
+    end
+
+    test "children/1", %{node: node} do
+      assert NodeProtocol.children(node) == []
+    end
+
+    test "start_line/1", %{node: node} do
+      assert NodeProtocol.start_line(node) == 1
+    end
+
+    test "label/1", %{node: node} do
+      assert NodeProtocol.label(node) == "f.ex:1"
+    end
+  end
+end
diff --git a/test/codeqa/ast/classification/node_type_detector_test.exs b/test/codeqa/ast/classification/node_type_detector_test.exs
new file mode 100644
index 0000000..caf0c7f
--- /dev/null
+++ b/test/codeqa/ast/classification/node_type_detector_test.exs
@@ -0,0 +1,143 @@
+defmodule CodeQA.AST.Classification.NodeTypeDetectorTest do
+  use ExUnit.Case, async: true
+  alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.AST.Classification.NodeTypeDetector
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Nodes.{CodeNode, DocNode, AttributeNode, FunctionNode}
+
+  defp detect_types(code, lang_mod \\ CodeQA.Languages.Code.Vm.Elixir) do
+    code
+    |> TokenNormalizer.normalize_structural()
+    |> Parser.detect_blocks(lang_mod)
+    |> NodeTypeDetector.detect_types(lang_mod)
+  end
+
+  describe "detect_types/1" do
+    test "block with <TRIP_QUOTES> gets type :doc" do
+      code = ~s(@moduledoc """\nSome doc.\n""")
+      [block] = detect_types(code)
+      assert is_struct(block, DocNode)
+    end
+
+    test "block with @spec gets type :typespec" do
+      code = "@spec fetch_user(integer()) :: {:ok, term()}"
+      [block] = detect_types(code)
+      assert is_struct(block, AttributeNode)
+      assert block.kind == :typespec
+    end
+
+    test "block with @type gets type :typespec" do
+      code = "@type user_id :: integer()"
+      [block] = detect_types(code)
+      assert is_struct(block, AttributeNode)
+      assert block.kind == :typespec
+    end
+
+    test "block starting with def gets type :function" do
+      code = "def foo(x), do: x + 1"
+      [block] = detect_types(code)
+      assert is_struct(block, FunctionNode)
+    end
+
+    test "@ attribute inside function body does not make block :attribute" do
+      # FunctionSignal sees 'def' first → :function wins
+      # AttributeSignal sees '@cache' but at indent > 0 → no vote
+      code = "def foo do\n  @cache true\n  :ok\nend"
+      blocks = detect_types(code)
+
+      code_block =
+        Enum.find(blocks, fn b ->
+          Enum.any?(b.tokens, &(&1.kind == "<ID>" and &1.content == "def"))
+        end)
+
+      assert is_struct(code_block, FunctionNode)
+    end
+
+    test "returns same number of blocks as input" do
+      code = "@spec foo() :: :ok\n\n\ndef foo, do: :ok"
+      blocks = detect_types(code)
+      assert length(blocks) == 2
+    end
+
+    test "all @typespec_attributes are recognized" do
+      for attr <- ~w[spec type typep opaque callback macrocallback] do
+        code = "@#{attr} foo :: bar"
+        [block] = detect_types(code)
+
+        assert is_struct(block, AttributeNode) and block.kind == :typespec,
+               "expected AttributeNode with kind: :typespec for @#{attr}"
+      end
+    end
+
+    test "empty list returns empty list" do
+      assert [] == NodeTypeDetector.detect_types([], CodeQA.Languages.Unknown)
+    end
+  end
+
+  describe "detect_types/1 — typed struct output" do
+    test "returns DocNode for doc blocks" do
+      doc_token = %CodeQA.AST.Lexing.Token{kind: "<DOC>", content: ~s("""), line: 1, col: 0}
+      nl = %CodeQA.AST.Lexing.Token{kind: "<NL>", content: "\n", line: 2, col: 0}
+
+      node = %CodeQA.AST.Enrichment.Node{
+        tokens: [doc_token, nl],
+        line_count: 2,
+        children: [],
+        start_line: 1,
+        end_line: 2
+      }
+
+      [result] =
+        CodeQA.AST.Classification.NodeTypeDetector.detect_types(
+          [node],
+          CodeQA.Languages.Code.Vm.Elixir
+        )
+
+      assert is_struct(result, DocNode)
+    end
+
+    test "returns AttributeNode for typespec blocks" do
+      at = %CodeQA.AST.Lexing.Token{kind: "@", content: "@", line: 1, col: 0}
+      spec = %CodeQA.AST.Lexing.Token{kind: "<ID>", content: "spec", line: 1, col: 1}
+      nl = %CodeQA.AST.Lexing.Token{kind: "<NL>", content: "\n", line: 1, col: 5}
+
+      node = %CodeQA.AST.Enrichment.Node{
+        tokens: [at, spec, nl],
+        line_count: 1,
+        children: [],
+        start_line: 1,
+        end_line: 1
+      }
+
+      [result] =
+        CodeQA.AST.Classification.NodeTypeDetector.detect_types(
+          [node],
+          CodeQA.Languages.Code.Vm.Elixir
+        )
+
+      assert is_struct(result, AttributeNode)
+      assert result.kind == :typespec
+    end
+
+    test "returns CodeNode for unclassified blocks" do
+      id = %CodeQA.AST.Lexing.Token{kind: "<ID>", content: "foo", line: 1, col: 0}
+      nl = %CodeQA.AST.Lexing.Token{kind: "<NL>", content: "\n", line: 1, col: 3}
+
+      node = %CodeQA.AST.Enrichment.Node{
+        tokens: [id, nl],
+        line_count: 1,
+        children: [],
+        start_line: 1,
+        end_line: 1
+      }
+
+      [result] =
+        CodeQA.AST.Classification.NodeTypeDetector.detect_types(
+          [node],
+          CodeQA.Languages.Code.Vm.Elixir
+        )
+
+      assert is_struct(result, CodeNode)
+    end
+  end
+end
diff --git a/test/codeqa/ast/enrichment/compound_node_assertions_languages_test.exs b/test/codeqa/ast/enrichment/compound_node_assertions_languages_test.exs
new file mode 100644
index 0000000..d1e1b8f
--- /dev/null
+++ b/test/codeqa/ast/enrichment/compound_node_assertions_languages_test.exs
@@ -0,0 +1,136 @@
+defmodule CodeQA.AST.Enrichment.CompoundNodeAssertionsLanguagesTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.Languages.Unknown
+  alias CodeQA.AST.Classification.NodeTypeDetector
+  alias CodeQA.AST.Classification.NodeProtocol
+  alias CodeQA.AST.Enrichment.CompoundNodeBuilder
+  alias CodeQA.AST.Enrichment.CompoundNode
+  alias CodeQA.AST.Enrichment.Node
+
+  Module.register_attribute(__MODULE__, :fixture, accumulate: true, persist: false)
+
+  # Elixir fixtures
+  use Test.Fixtures.Elixir.Calculator
+  use Test.Fixtures.Elixir.EventBus
+  use Test.Fixtures.Elixir.RateLimiter
+
+  # Python fixtures
+  use Test.Fixtures.Python.Calculator
+  use Test.Fixtures.Python.CsvPipeline
+  use Test.Fixtures.Python.ConfigParser
+
+  # JavaScript fixtures
+  use Test.Fixtures.JavaScript.Calculator
+  use Test.Fixtures.JavaScript.FormValidator
+  use Test.Fixtures.JavaScript.ShoppingCart
+
+  # Go fixtures
+  use Test.Fixtures.Go.Calculator
+  use Test.Fixtures.Go.HttpMiddleware
+  use Test.Fixtures.Go.CliParser
+
+  # Rust fixtures
+  use Test.Fixtures.Rust.Calculator
+  use Test.Fixtures.Rust.Tokenizer
+  use Test.Fixtures.Rust.RingBuffer
+
+  # Ruby fixtures
+  use Test.Fixtures.Ruby.Calculator
+  use Test.Fixtures.Ruby.OrmLite
+  use Test.Fixtures.Ruby.MarkdownRenderer
+
+  # TypeScript fixtures
+  use Test.Fixtures.TypeScript.UserProfileStore
+  use Test.Fixtures.TypeScript.EventEmitter
+  use Test.Fixtures.TypeScript.DependencyInjection
+
+  # Java fixtures
+  use Test.Fixtures.Java.BuilderPattern
+  use Test.Fixtures.Java.RepositoryPattern
+  use Test.Fixtures.Java.StrategyPattern
+
+  # C# fixtures
+  use Test.Fixtures.CSharp.LinqPipeline
+  use Test.Fixtures.CSharp.AsyncTaskManager
+  use Test.Fixtures.CSharp.PluginSystem
+
+  # Swift fixtures
+  use Test.Fixtures.Swift.ResultType
+  use Test.Fixtures.Swift.CombineStream
+  use Test.Fixtures.Swift.ActorModel
+
+  # Kotlin fixtures
+  use Test.Fixtures.Kotlin.SealedState
+  use Test.Fixtures.Kotlin.CoroutineFlow
+  use Test.Fixtures.Kotlin.ExtensionLibrary
+
+  # C++ fixtures
+  use Test.Fixtures.Cpp.SmartPointer
+  use Test.Fixtures.Cpp.TemplateContainer
+  use Test.Fixtures.Cpp.ObserverPattern
+
+  # Scala fixtures
+  use Test.Fixtures.Scala.CaseClassAlgebra
+  use Test.Fixtures.Scala.TypeclassPattern
+  use Test.Fixtures.Scala.ActorMessages
+
+  # Dart fixtures
+  use Test.Fixtures.Dart.WidgetState
+  use Test.Fixtures.Dart.FuturesAsync
+  use Test.Fixtures.Dart.MixinComposition
+
+  # Zig fixtures
+  use Test.Fixtures.Zig.AllocatorInterface
+  use Test.Fixtures.Zig.TaggedUnion
+  use Test.Fixtures.Zig.IteratorProtocol
+
+  # Lua fixtures
+  use Test.Fixtures.Lua.ClassSystem
+  use Test.Fixtures.Lua.EventSystem
+  use Test.Fixtures.Lua.StateMachine
+
+  # Generate tests for fixtures with block_assertions
+  for {language, code, block_assertions} <- @fixture, block_assertion <- block_assertions do
+    test "[#{language}] #{block_assertion.description}" do
+      compounds = compound_nodes(unquote(code))
+      none_of = Map.get(unquote(Macro.escape(block_assertion)), :none_of, [])
+      all_of = unquote(Macro.escape(block_assertion)).all_of
+
+      assert Enum.any?(compounds, fn compound ->
+               tokens = all_tokens(compound)
+               compound_satisfies?(tokens, all_of, none_of)
+             end),
+             "No compound node found matching: #{unquote(block_assertion.description)}"
+    end
+  end
+
+  defp compound_nodes(code) do
+    code
+    |> TokenNormalizer.normalize_structural()
+    |> Parser.detect_blocks(Unknown)
+    |> NodeTypeDetector.detect_types(Unknown)
+    |> CompoundNodeBuilder.build()
+  end
+
+  defp all_tokens(%CompoundNode{docs: docs, typespecs: typespecs, code: code}) do
+    (docs ++ typespecs ++ code)
+    |> Enum.flat_map(&node_tokens/1)
+  end
+
+  defp node_tokens(node) do
+    NodeProtocol.tokens(node)
+  end
+
+  defp matches?({:exact, field, value}, token), do: Map.get(token, field) == value
+
+  defp matches?({:partial, field, value}, token),
+    do: String.contains?(Map.get(token, field, ""), value)
+
+  defp compound_satisfies?(tokens, all_of, none_of) do
+    Enum.all?(all_of, fn matcher -> Enum.any?(tokens, &matches?(matcher, &1)) end) and
+      Enum.all?(none_of, fn matcher -> not Enum.any?(tokens, &matches?(matcher, &1)) end)
+  end
+end
diff --git a/test/codeqa/ast/enrichment/compound_node_builder_test.exs b/test/codeqa/ast/enrichment/compound_node_builder_test.exs
new file mode 100644
index 0000000..3881e9e
--- /dev/null
+++ b/test/codeqa/ast/enrichment/compound_node_builder_test.exs
@@ -0,0 +1,137 @@
+defmodule CodeQA.AST.Enrichment.CompoundNodeBuilderTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.AST.Classification.NodeTypeDetector
+  alias CodeQA.AST.Enrichment.CompoundNode
+  alias CodeQA.AST.Enrichment.CompoundNodeBuilder
+  alias CodeQA.AST.Lexing.TokenNormalizer
+
+  alias CodeQA.AST.Nodes.{DocNode, AttributeNode, CodeNode}
+
+  defp build(code) do
+    lang_mod = CodeQA.Languages.Code.Vm.Elixir
+    opts = [language_module: lang_mod]
+
+    code
+    |> TokenNormalizer.normalize_structural()
+    |> Parser.detect_blocks(lang_mod)
+    |> NodeTypeDetector.detect_types(lang_mod)
+    |> CompoundNodeBuilder.build()
+  end
+
+  describe "build/1" do
+    test "returns CompoundNode structs" do
+      [compound | _] = build("def foo, do: :ok")
+      assert %CompoundNode{} = compound
+    end
+
+    test "bare code block wraps in compound with empty docs and typespecs" do
+      [compound] = build("def foo, do: :ok")
+      assert compound.docs == []
+      assert compound.typespecs == []
+      assert length(compound.code) == 1
+    end
+
+    test "@doc block attaches to following code block" do
+      code = ~s(@doc """\nSome doc.\n"""\ndef foo, do: :ok)
+      [compound] = build(code)
+      assert length(compound.docs) == 1
+      assert length(compound.code) == 1
+    end
+
+    test "@spec block attaches to following code block" do
+      code = "@spec foo() :: :ok\ndef foo, do: :ok"
+      [compound] = build(code)
+      assert length(compound.typespecs) == 1
+      assert length(compound.code) == 1
+    end
+
+    test "consecutive code clauses accumulate in same compound" do
+      code = "def foo(:a), do: 1\ndef foo(:b), do: 2\ndef foo(_), do: 3"
+      [compound] = build(code)
+      assert length(compound.code) == 3
+    end
+
+    test "doc after code starts a new compound" do
+      code = ~s(def foo do\n  :ok\nend\n\n\n@doc """\nSome doc.\n"""\ndef bar, do: :ok)
+      compounds = build(code)
+      assert length(compounds) == 2
+      [first, second] = compounds
+      assert first.docs == []
+      assert length(second.docs) == 1
+    end
+
+    test "two blank lines between code blocks starts a new compound" do
+      code = "def foo, do: :ok\n\n\ndef bar, do: :ok"
+      compounds = build(code)
+      assert length(compounds) == 2
+    end
+
+    test "single blank line between code blocks does NOT start a new compound" do
+      code = "def foo(:a), do: 1\n\ndef foo(:b), do: 2"
+      [compound] = build(code)
+      assert length(compound.code) == 2
+    end
+
+    test "start_line is set from first non-whitespace token" do
+      [compound] = build("def foo, do: :ok")
+      assert is_integer(compound.start_line)
+      assert compound.start_line >= 1
+    end
+
+    test "start_col is set from first non-whitespace token" do
+      [compound] = build("def foo, do: :ok")
+      assert is_integer(compound.start_col)
+    end
+
+    test "typespec block before any code attaches to compound (no flush)" do
+      code = "@spec foo() :: :ok\ndef foo, do: :ok"
+      [compound] = build(code)
+      assert length(compound.typespecs) == 1
+      assert length(compound.code) == 1
+    end
+
+    test "end_line is set from last non-whitespace token" do
+      [compound] = build("def foo, do: :ok")
+      assert is_integer(compound.end_line)
+    end
+
+    test "end_col is set from last non-whitespace token" do
+      [compound] = build("def foo, do: :ok")
+      assert is_integer(compound.end_col)
+    end
+
+    test "empty list returns empty list" do
+      assert [] == CompoundNodeBuilder.build([])
+    end
+  end
+
+  describe "build/1 with typed node structs" do
+    test "routes DocNode to docs bucket" do
+      doc = %DocNode{tokens: [:d], line_count: 1, children: [], start_line: 1, end_line: 1}
+      code = %CodeNode{tokens: [:c], line_count: 2, children: [], start_line: 2, end_line: 3}
+
+      [compound] = CodeQA.AST.Enrichment.CompoundNodeBuilder.build([doc, code])
+      assert length(compound.docs) == 1
+      assert is_struct(hd(compound.docs), DocNode)
+    end
+
+    test "routes AttributeNode to typespecs bucket" do
+      attr = %AttributeNode{
+        tokens: [:a],
+        line_count: 1,
+        children: [],
+        start_line: 1,
+        end_line: 1,
+        kind: :typespec
+      }
+
+      code = %CodeNode{tokens: [:c], line_count: 2, children: [], start_line: 2, end_line: 3}
+
+      [compound] = CodeQA.AST.Enrichment.CompoundNodeBuilder.build([attr, code])
+      assert length(compound.typespecs) == 1
+      assert is_struct(hd(compound.typespecs), AttributeNode)
+    end
+  end
+end
diff --git a/test/codeqa/ast/enrichment/node_analyzer_test.exs b/test/codeqa/ast/enrichment/node_analyzer_test.exs
new file mode 100644
index 0000000..6f3e439
--- /dev/null
+++ b/test/codeqa/ast/enrichment/node_analyzer_test.exs
@@ -0,0 +1,62 @@
+defmodule CodeQA.AST.Enrichment.NodeAnalyzerTest do
+  use ExUnit.Case, async: true
+  alias CodeQA.AST.Enrichment.NodeAnalyzer
+  alias CodeQA.AST.Lexing.TokenNormalizer
+
+  defp tokenize(code), do: TokenNormalizer.normalize_structural(code)
+  defp bound(code), do: code |> tokenize() |> NodeAnalyzer.bound_variables()
+
+  describe "bound_variables/1" do
+    test "simple assignment binds the LHS identifier" do
+      assert "user" in bound("user = Repo.get!(id)")
+    end
+
+    test "assignment RHS identifiers are NOT bound" do
+      result = bound("user = Repo.get!(id)")
+      refute "repo" in result
+      refute "id" in result
+    end
+
+    test "with-clause binding (<-) binds the LHS identifier" do
+      assert "user" in bound("{:ok, user} <- fetch_user(id)")
+    end
+
+    test "multiple assignments in a block are all bound" do
+      code = "a = foo()\nb = bar()\nc = baz()"
+      result = bound(code)
+      assert "a" in result
+      assert "b" in result
+      assert "c" in result
+    end
+
+    test "compound LHS: only the <ID> immediately before = is bound" do
+      # `x.field = val` — `x` is not re-bound; skip non-simple LHS
+      result = bound("result = compute(x)")
+      assert "result" in result
+    end
+
+    test "== operator does not create a binding" do
+      result = bound("x == y")
+      refute "x" in result
+      refute "y" in result
+    end
+
+    test "=> fat arrow does not create a binding" do
+      result = bound("key => value")
+      refute "key" in result
+    end
+
+    test "=~ regex match does not create a binding" do
+      result = bound("str =~ pattern")
+      refute "str" in result
+    end
+
+    test "returns MapSet" do
+      assert %MapSet{} = bound("x = 1")
+    end
+
+    test "empty token list returns empty MapSet" do
+      assert MapSet.new() == NodeAnalyzer.bound_variables([])
+    end
+  end
+end
diff --git a/test/codeqa/ast/lexing/string_token_test.exs b/test/codeqa/ast/lexing/string_token_test.exs
new file mode 100644
index 0000000..0a99e9e
--- /dev/null
+++ b/test/codeqa/ast/lexing/string_token_test.exs
@@ -0,0 +1,195 @@
+defmodule CodeQA.AST.StringTokenTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Lexing.StringToken
+  alias CodeQA.AST.Lexing.TokenNormalizer
+
+  describe "StringToken struct" do
+    test "has kind, content, line, col, interpolations, multiline, and quotes fields" do
+      tok = %StringToken{
+        kind: "<STR>",
+        content: ~s("hello"),
+        line: 1,
+        col: 0,
+        interpolations: nil
+      }
+
+      assert tok.kind == "<STR>"
+      assert tok.content == ~s("hello")
+      assert tok.line == 1
+      assert tok.col == 0
+      assert tok.interpolations == nil
+      assert tok.multiline == false
+      assert tok.quotes == :double
+    end
+
+    test "interpolations defaults to nil" do
+      tok = %StringToken{kind: "<STR>", content: ~s("hello")}
+      assert tok.interpolations == nil
+    end
+
+    test "multiline defaults to false" do
+      tok = %StringToken{kind: "<STR>", content: ~s("hello")}
+      assert tok.multiline == false
+    end
+
+    test "quotes defaults to :double" do
+      tok = %StringToken{kind: "<STR>", content: ~s("hello")}
+      assert tok.quotes == :double
+    end
+
+    test "multiline triple-quote struct" do
+      tok = %StringToken{kind: "<DOC>", content: ~s("""), multiline: true, quotes: :double}
+      assert tok.multiline == true
+      assert tok.quotes == :double
+    end
+  end
+
+  describe "TokenNormalizer emits StringToken for strings" do
+    test "plain string emits a StringToken" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~s("hello"))
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert %StringToken{} = tok
+    end
+
+    test "plain string StringToken has nil interpolations" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~s("hello"))
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.interpolations == nil
+    end
+
+    test "Elixir/Ruby interpolated string emits a StringToken" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|"hello #{name}"|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert %StringToken{} = tok
+    end
+
+    test "JS/TS backtick interpolated string emits a StringToken" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|`hello ${name}`|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert %StringToken{} = tok
+    end
+
+    test "Kotlin/Dart/Scala interpolated string emits a StringToken" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|"hello ${name}"|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert %StringToken{} = tok
+    end
+
+    test "Swift interpolated string emits a StringToken" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|"hello \(name)"|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert %StringToken{} = tok
+    end
+
+    test "plain backtick string emits a StringToken" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|`hello`|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert %StringToken{} = tok
+    end
+
+    test "non-string tokens are still plain Token structs" do
+      tokens = TokenNormalizer.normalize_structural("foo = 42")
+      id = Enum.find(tokens, &(&1.kind == "<ID>"))
+      refute match?(%StringToken{}, id)
+    end
+  end
+
+  describe "quotes field" do
+    test "double-quoted string has quotes :double" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~s("hello"))
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.quotes == :double
+    end
+
+    test "single-quoted string has quotes :single" do
+      [tok] =
+        TokenNormalizer.normalize_structural("'hello'")
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.quotes == :single
+    end
+
+    test "backtick string has quotes :backtick" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|`hello`|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.quotes == :backtick
+    end
+
+    test "backtick interpolated string has quotes :backtick" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|`hello ${name}`|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.quotes == :backtick
+    end
+
+    test "Elixir interpolated string has quotes :double" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|"hello #{name}"|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.quotes == :double
+    end
+  end
+
+  describe "multiline field" do
+    test "regular string has multiline false" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~s("hello"))
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.multiline == false
+    end
+
+    test "double triple-quote token has multiline true" do
+      [tok | _] =
+        TokenNormalizer.normalize_structural(~s("""\nhello\n"""))
+        |> Enum.filter(&(&1.kind == "<DOC>"))
+
+      assert tok.multiline == true
+    end
+
+    test "single triple-quote token has multiline true" do
+      [tok | _] =
+        TokenNormalizer.normalize_structural("'''\nhello\n'''")
+        |> Enum.filter(&(&1.kind == "<DOC>"))
+
+      assert tok.multiline == true
+    end
+
+    test "triple-quote token quotes :double for \"\"\"" do
+      [tok | _] =
+        TokenNormalizer.normalize_structural(~s("""\nhello\n"""))
+        |> Enum.filter(&(&1.kind == "<DOC>"))
+
+      assert tok.quotes == :double
+    end
+
+    test "triple-quote token quotes :single for '''" do
+      [tok | _] =
+        TokenNormalizer.normalize_structural("'''\nhello\n'''")
+        |> Enum.filter(&(&1.kind == "<DOC>"))
+
+      assert tok.quotes == :single
+    end
+  end
+end
diff --git a/test/codeqa/ast/lexing/token_normalizer_test.exs b/test/codeqa/ast/lexing/token_normalizer_test.exs
new file mode 100644
index 0000000..e8264ad
--- /dev/null
+++ b/test/codeqa/ast/lexing/token_normalizer_test.exs
@@ -0,0 +1,332 @@
+defmodule CodeQA.AST.TokenNormalizerTest do
+  use ExUnit.Case, async: true
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Lexing.Token
+  alias CodeQA.AST.Lexing.StringToken
+
+  defp kinds(tokens), do: Enum.map(tokens, & &1.kind)
+
+  describe "normalize_structural/1" do
+    test "emits <NL> between lines" do
+      result = TokenNormalizer.normalize_structural("a\nb")
+      assert "<NL>" in kinds(result)
+    end
+
+    test "two blank lines produce two or more consecutive <NL> tokens" do
+      result = TokenNormalizer.normalize_structural("a\n\nb")
+
+      nl_runs =
+        result
+        |> Enum.chunk_by(&(&1.kind == "<NL>"))
+        |> Enum.filter(fn [h | _] -> h.kind == "<NL>" end)
+        |> Enum.map(&length/1)
+
+      assert Enum.any?(nl_runs, &(&1 >= 2))
+    end
+
+    test "emits one <WS> token per 2 leading spaces" do
+      result = TokenNormalizer.normalize_structural("    foo")
+      assert Enum.count(result, &(&1.kind == "<WS>")) == 2
+    end
+
+    test "emits one <WS> token per tab" do
+      result = TokenNormalizer.normalize_structural("\t\tfoo")
+      assert Enum.count(result, &(&1.kind == "<WS>")) == 2
+    end
+
+    test "normalizes identifiers to <ID>" do
+      result = TokenNormalizer.normalize_structural("foo bar")
+      assert kinds(result) == ["<ID>", "<ID>"]
+    end
+
+    test "normalizes numbers to <NUM>" do
+      result = TokenNormalizer.normalize_structural("x = 42")
+      assert "<NUM>" in kinds(result)
+    end
+
+    test "empty string returns empty list" do
+      assert TokenNormalizer.normalize_structural("") == []
+    end
+
+    test "single leading space produces zero <WS> tokens (below threshold)" do
+      result = TokenNormalizer.normalize_structural(" foo")
+      assert not Enum.any?(result, &(&1.kind == "<WS>"))
+    end
+
+    test "punctuation tokens like ( and : survive as individual tokens" do
+      result = TokenNormalizer.normalize_structural("foo(x):")
+      assert "(" in kinds(result)
+      assert ")" in kinds(result)
+      assert ":" in kinds(result)
+    end
+
+    test "tokens carry line numbers" do
+      result = TokenNormalizer.normalize_structural("foo\nbar")
+      lines = Enum.map(result, & &1.line)
+      assert 1 in lines
+      assert 2 in lines
+    end
+
+    test "tokens carry col offsets" do
+      result = TokenNormalizer.normalize_structural("foo")
+      [tok] = result
+      assert tok.col == 0
+    end
+
+    test "identifier token preserves original content" do
+      result = TokenNormalizer.normalize_structural("myVar")
+      [tok] = result
+      assert tok.kind == "<ID>"
+      assert tok.content == "myVar"
+    end
+
+    test "keyword content is preserved (not normalized away)" do
+      result = TokenNormalizer.normalize_structural("def foo")
+      contents = Enum.map(result, & &1.content)
+      assert "def" in contents
+    end
+
+    test "string token content is the original literal" do
+      result = TokenNormalizer.normalize_structural(~s("hello"))
+      tok = Enum.find(result, &(&1.kind == "<STR>"))
+      assert tok.content == ~s("hello")
+    end
+
+    # multi-char operator tests
+
+    test ">= is a single token" do
+      result = TokenNormalizer.normalize_structural("x >= y")
+      assert ">=" in kinds(result)
+      refute ">" in kinds(result)
+    end
+
+    test "<= is a single token" do
+      result = TokenNormalizer.normalize_structural("x <= y")
+      assert "<=" in kinds(result)
+      refute "<" in kinds(result)
+    end
+
+    test "== is a single token" do
+      result = TokenNormalizer.normalize_structural("x == y")
+      assert "==" in kinds(result)
+    end
+
+    test "!= is a single token" do
+      result = TokenNormalizer.normalize_structural("x != y")
+      assert "!=" in kinds(result)
+      refute "!" in kinds(result)
+    end
+
+    test "=== is a single token (not == + =)" do
+      result = TokenNormalizer.normalize_structural("x === y")
+      assert "===" in kinds(result)
+      refute "==" in kinds(result)
+    end
+
+    test "!== is a single token" do
+      result = TokenNormalizer.normalize_structural("x !== y")
+      assert "!==" in kinds(result)
+      refute "!=" in kinds(result)
+    end
+
+    test "|> is a single token (Elixir pipe)" do
+      result = TokenNormalizer.normalize_structural("x |> f")
+      assert "|>" in kinds(result)
+      refute "|" in kinds(result)
+    end
+
+    test "<> is a single token (Elixir concat)" do
+      result = TokenNormalizer.normalize_structural(~s("a" <> "b"))
+      assert "<>" in kinds(result)
+    end
+
+    test "<- is a single token (Elixir/Go arrow)" do
+      result = TokenNormalizer.normalize_structural("x <- y")
+      assert "<-" in kinds(result)
+      refute "<" in kinds(result)
+    end
+
+    test "-> is a single token" do
+      result = TokenNormalizer.normalize_structural("x -> y")
+      assert "->" in kinds(result)
+      refute "-" in kinds(result)
+    end
+
+    test "=> is a single token (fat arrow)" do
+      result = TokenNormalizer.normalize_structural("k => v")
+      assert "=>" in kinds(result)
+    end
+
+    test "=~ is a single token (regex match)" do
+      result = TokenNormalizer.normalize_structural("x =~ y")
+      assert "=~" in kinds(result)
+    end
+
+    test "&& is a single token" do
+      result = TokenNormalizer.normalize_structural("a && b")
+      assert "&&" in kinds(result)
+      refute "&" in kinds(result)
+    end
+
+    test "|| is a single token" do
+      result = TokenNormalizer.normalize_structural("a || b")
+      assert "||" in kinds(result)
+      refute "|" in kinds(result)
+    end
+
+    test ":: is a single token" do
+      result = TokenNormalizer.normalize_structural("Foo::Bar")
+      assert "::" in kinds(result)
+      refute ":" in kinds(result)
+    end
+
+    test ".. is a single token" do
+      result = TokenNormalizer.normalize_structural("1..10")
+      assert ".." in kinds(result)
+    end
+
+    test "... is a single token (not .. + .)" do
+      result = TokenNormalizer.normalize_structural("1...10")
+      assert "..." in kinds(result)
+      refute ".." in kinds(result)
+    end
+
+    test "multi-char operator value equals content (no normalization)" do
+      result = TokenNormalizer.normalize_structural("x >= y")
+      tok = Enum.find(result, &(&1.kind == ">="))
+      assert tok.content == ">="
+    end
+  end
+
+  describe "interpolated string tokens are normalised to <STR>" do
+    test "Elixir/Ruby #{} emits <STR> with interpolations" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|"hello #{name}"|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.interpolations == ["name"]
+    end
+
+    test "JS/TS backtick with \${} emits <STR> with interpolations" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|`hello ${name}`|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.interpolations == ["name"]
+    end
+
+    test "JS/TS backtick static content has interpolation stripped" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|`hello ${name} world`|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.content == "`hello  world`"
+    end
+
+    test "JS/TS backtick two interpolations are both captured" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|`${a} and ${b}`|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.interpolations == ["a", "b"]
+    end
+
+    test "plain backtick string without interpolation emits <STR> with nil interpolations" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|`hello world`|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.interpolations == nil
+    end
+
+    test "Kotlin/Dart/Scala \${} emits <STR> with interpolations" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|"hello ${name}"|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.interpolations == ["name"]
+    end
+
+    test "Kotlin/Dart/Scala static content has interpolation stripped" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|"hello ${name} world"|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.content == ~S|"hello  world"|
+    end
+
+    test "Kotlin/Dart/Scala two interpolations are both captured" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|"${a} and ${b}"|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.interpolations == ["a", "b"]
+    end
+
+    test "Swift \\(...) emits <STR> with interpolations" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|"hello \(name)"|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.interpolations == ["name"]
+    end
+
+    test "Swift static content has interpolation stripped" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|"hello \(name) world"|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.content == ~S|"hello  world"|
+    end
+
+    test "Swift two interpolations are both captured" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~S|"\(a) and \(b)"|)
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.interpolations == ["a", "b"]
+    end
+
+    test "plain double-quoted string has nil interpolations" do
+      [tok] =
+        TokenNormalizer.normalize_structural(~s("hello"))
+        |> Enum.filter(&(&1.kind == "<STR>"))
+
+      assert tok.interpolations == nil
+    end
+  end
+
+  describe "<TRIP_QUOTES> token" do
+    test "triple double-quotes emits a StringToken with kind <DOC>" do
+      tokens = TokenNormalizer.normalize_structural(~s("""))
+
+      assert [%StringToken{kind: "<DOC>", content: ~s("""), multiline: true, quotes: :double}] =
+               tokens
+    end
+
+    test "triple single-quotes emits a StringToken with kind <DOC>" do
+      tokens = TokenNormalizer.normalize_structural("'''")
+
+      assert [%StringToken{kind: "<DOC>", content: "'''", multiline: true, quotes: :single}] =
+               tokens
+    end
+
+    test "triple-quote is not consumed as empty string + bare quote" do
+      tokens = TokenNormalizer.normalize_structural(~s("""))
+      refute Enum.any?(tokens, &(&1.kind == "<STR>"))
+    end
+
+    test "content between triple-quotes is tokenized normally" do
+      code = ~s("""\nhello world\n""")
+      tokens = TokenNormalizer.normalize_structural(code)
+      trip_count = Enum.count(tokens, &(&1.kind == "<DOC>"))
+      assert trip_count == 2
+      assert Enum.any?(tokens, &(&1.kind == "<ID>" and &1.content == "hello"))
+    end
+
+    test "regular double-quoted string still works" do
+      tokens = TokenNormalizer.normalize_structural(~s("hello"))
+      assert [%StringToken{kind: "<STR>"}] = tokens
+    end
+  end
+end
diff --git a/test/codeqa/ast/lexing/token_protocol_test.exs b/test/codeqa/ast/lexing/token_protocol_test.exs
new file mode 100644
index 0000000..5534d10
--- /dev/null
+++ b/test/codeqa/ast/lexing/token_protocol_test.exs
@@ -0,0 +1,142 @@
+defmodule CodeQA.AST.Lexing.TokenProtocolTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Lexing.Token
+  alias CodeQA.AST.Lexing.StringToken
+  alias CodeQA.AST.Lexing.TokenProtocol
+
+  describe "Token implementation" do
+    setup do
+      {:ok, token: %Token{kind: "<ID>", content: "foo", line: 3, col: 7}}
+    end
+
+    test "kind/1", %{token: t} do
+      assert TokenProtocol.kind(t) == "<ID>"
+    end
+
+    test "content/1", %{token: t} do
+      assert TokenProtocol.content(t) == "foo"
+    end
+
+    test "line/1", %{token: t} do
+      assert TokenProtocol.line(t) == 3
+    end
+
+    test "col/1", %{token: t} do
+      assert TokenProtocol.col(t) == 7
+    end
+
+    test "nil location fields are preserved" do
+      t = %Token{kind: "<NL>", content: "\n", line: nil, col: nil}
+      assert TokenProtocol.line(t) == nil
+      assert TokenProtocol.col(t) == nil
+    end
+  end
+
+  describe "StringToken implementation" do
+    setup do
+      {:ok,
+       token: %StringToken{
+         kind: "<STR>",
+         content: "\"hello\"",
+         line: 10,
+         col: 2,
+         interpolations: nil
+       }}
+    end
+
+    test "kind/1", %{token: t} do
+      assert TokenProtocol.kind(t) == "<STR>"
+    end
+
+    test "content/1", %{token: t} do
+      assert TokenProtocol.content(t) == "\"hello\""
+    end
+
+    test "line/1", %{token: t} do
+      assert TokenProtocol.line(t) == 10
+    end
+
+    test "col/1", %{token: t} do
+      assert TokenProtocol.col(t) == 2
+    end
+
+    test "works with interpolated string token" do
+      t = %StringToken{
+        kind: "<STR>",
+        content: "\"\#{x}\"",
+        line: 5,
+        col: 0,
+        interpolations: ["x"]
+      }
+
+      assert TokenProtocol.kind(t) == "<STR>"
+      assert TokenProtocol.content(t) == "\"\#{x}\""
+    end
+  end
+
+  describe "StringToken <DOC> (multiline) via protocol" do
+    setup do
+      {:ok,
+       token: %StringToken{
+         kind: "<DOC>",
+         content: ~s("""),
+         line: 2,
+         col: 0,
+         multiline: true,
+         quotes: :double
+       }}
+    end
+
+    test "kind/1", %{token: t} do
+      assert TokenProtocol.kind(t) == "<DOC>"
+    end
+
+    test "content/1", %{token: t} do
+      assert TokenProtocol.content(t) == ~s(""")
+    end
+
+    test "line/1", %{token: t} do
+      assert TokenProtocol.line(t) == 2
+    end
+
+    test "col/1", %{token: t} do
+      assert TokenProtocol.col(t) == 0
+    end
+
+    test "single-quote variant" do
+      t = %StringToken{
+        kind: "<DOC>",
+        content: "'''",
+        line: 5,
+        col: 0,
+        multiline: true,
+        quotes: :single
+      }
+
+      assert TokenProtocol.kind(t) == "<DOC>"
+      assert t.quotes == :single
+    end
+  end
+
+  describe "polymorphic use" do
+    test "mixed token list can be processed uniformly" do
+      tokens = [
+        %Token{kind: "<ID>", content: "x", line: 1, col: 0},
+        %StringToken{kind: "<STR>", content: "\"hi\"", line: 1, col: 4},
+        %StringToken{
+          kind: "<DOC>",
+          content: ~s("""),
+          line: 2,
+          col: 0,
+          multiline: true,
+          quotes: :double
+        },
+        %Token{kind: "<NL>", content: "\n", line: 2, col: 3}
+      ]
+
+      kinds = Enum.map(tokens, &TokenProtocol.kind/1)
+      assert kinds == ["<ID>", "<STR>", "<DOC>", "<NL>"]
+    end
+  end
+end
diff --git a/test/codeqa/ast/nodes/code_node_test.exs b/test/codeqa/ast/nodes/code_node_test.exs
new file mode 100644
index 0000000..f161ad8
--- /dev/null
+++ b/test/codeqa/ast/nodes/code_node_test.exs
@@ -0,0 +1,55 @@
+defmodule CodeQA.AST.Nodes.CodeNodeTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Nodes.{CodeNode, DocNode}
+  alias CodeQA.AST.Classification.NodeProtocol
+
+  @tokens [:a, :b, :c]
+
+  describe "CodeNode" do
+    setup do
+      node = %CodeNode{
+        tokens: @tokens,
+        line_count: 2,
+        children: [],
+        start_line: 1,
+        end_line: 2,
+        label: "f.ex:1"
+      }
+
+      %{node: node}
+    end
+
+    test "implements NodeProtocol", %{node: node} do
+      assert NodeProtocol.tokens(node) == @tokens
+      assert NodeProtocol.line_count(node) == 2
+      assert NodeProtocol.children(node) == []
+      assert NodeProtocol.start_line(node) == 1
+      assert NodeProtocol.end_line(node) == 2
+      assert NodeProtocol.label(node) == "f.ex:1"
+    end
+
+    test "all common fields default to nil except children" do
+      node = %CodeNode{tokens: [], line_count: 0, children: []}
+      assert NodeProtocol.start_line(node) == nil
+      assert NodeProtocol.end_line(node) == nil
+      assert NodeProtocol.label(node) == nil
+    end
+  end
+
+  describe "DocNode" do
+    test "implements NodeProtocol" do
+      node = %DocNode{
+        tokens: @tokens,
+        line_count: 1,
+        children: [],
+        start_line: 5,
+        end_line: 5,
+        label: nil
+      }
+
+      assert NodeProtocol.tokens(node) == @tokens
+      assert NodeProtocol.children(node) == []
+    end
+  end
+end
diff --git a/test/codeqa/ast/nodes/function_node_test.exs b/test/codeqa/ast/nodes/function_node_test.exs
new file mode 100644
index 0000000..029a2a7
--- /dev/null
+++ b/test/codeqa/ast/nodes/function_node_test.exs
@@ -0,0 +1,68 @@
+defmodule CodeQA.AST.Nodes.FunctionNodeTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Nodes.{FunctionNode, ModuleNode}
+  alias CodeQA.AST.Classification.NodeProtocol
+
+  describe "FunctionNode" do
+    setup do
+      node = %FunctionNode{
+        tokens: [:a],
+        line_count: 5,
+        children: [],
+        start_line: 10,
+        end_line: 14,
+        label: "foo.ex:10",
+        name: "calculate",
+        arity: 2,
+        visibility: :public
+      }
+
+      %{node: node}
+    end
+
+    test "implements NodeProtocol", %{node: node} do
+      assert NodeProtocol.tokens(node) == [:a]
+      assert NodeProtocol.line_count(node) == 5
+      assert NodeProtocol.start_line(node) == 10
+    end
+
+    test "specific fields are accessible", %{node: node} do
+      assert node.name == "calculate"
+      assert node.arity == 2
+      assert node.visibility == :public
+    end
+
+    test "specific fields default to nil" do
+      node = %FunctionNode{tokens: [], line_count: 0, children: []}
+      assert node.name == nil
+      assert node.arity == nil
+      assert node.visibility == nil
+    end
+  end
+
+  describe "ModuleNode" do
+    test "implements NodeProtocol" do
+      node = %ModuleNode{
+        tokens: [:m],
+        line_count: 20,
+        children: [],
+        start_line: 1,
+        end_line: 20,
+        label: nil,
+        name: "MyApp.Foo",
+        kind: :module
+      }
+
+      assert NodeProtocol.tokens(node) == [:m]
+      assert node.name == "MyApp.Foo"
+      assert node.kind == :module
+    end
+
+    test "specific fields default to nil" do
+      node = %ModuleNode{tokens: [], line_count: 0, children: []}
+      assert node.name == nil
+      assert node.kind == nil
+    end
+  end
+end
diff --git a/test/codeqa/ast/nodes/import_node_test.exs b/test/codeqa/ast/nodes/import_node_test.exs
new file mode 100644
index 0000000..16c6771
--- /dev/null
+++ b/test/codeqa/ast/nodes/import_node_test.exs
@@ -0,0 +1,74 @@
+defmodule CodeQA.AST.Nodes.ImportNodeTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Nodes.{ImportNode, AttributeNode, TestNode}
+  alias CodeQA.AST.Classification.NodeProtocol
+
+  describe "ImportNode" do
+    test "implements NodeProtocol" do
+      node = %ImportNode{
+        tokens: [:i],
+        line_count: 1,
+        children: [],
+        start_line: 3,
+        end_line: 3,
+        label: nil,
+        target: "MyApp.Repo"
+      }
+
+      assert NodeProtocol.tokens(node) == [:i]
+      assert node.target == "MyApp.Repo"
+    end
+
+    test "target defaults to nil" do
+      node = %ImportNode{tokens: [], line_count: 0, children: []}
+      assert node.target == nil
+    end
+  end
+
+  describe "AttributeNode" do
+    test "implements NodeProtocol" do
+      node = %AttributeNode{
+        tokens: [:a],
+        line_count: 1,
+        children: [],
+        start_line: 2,
+        end_line: 2,
+        label: nil,
+        name: "moduledoc",
+        kind: :annotation
+      }
+
+      assert NodeProtocol.tokens(node) == [:a]
+      assert node.name == "moduledoc"
+      assert node.kind == :annotation
+    end
+
+    test "supports :typespec kind" do
+      node = %AttributeNode{tokens: [], line_count: 0, children: [], kind: :typespec}
+      assert node.kind == :typespec
+    end
+  end
+
+  describe "TestNode" do
+    test "implements NodeProtocol" do
+      node = %TestNode{
+        tokens: [:t],
+        line_count: 4,
+        children: [],
+        start_line: 10,
+        end_line: 13,
+        label: nil,
+        description: "returns the sum"
+      }
+
+      assert NodeProtocol.tokens(node) == [:t]
+      assert node.description == "returns the sum"
+    end
+
+    test "description defaults to nil" do
+      node = %TestNode{tokens: [], line_count: 0, children: []}
+      assert node.description == nil
+    end
+  end
+end
diff --git a/test/codeqa/ast/parsing/parser_languages_test.exs b/test/codeqa/ast/parsing/parser_languages_test.exs
new file mode 100644
index 0000000..e2f3040
--- /dev/null
+++ b/test/codeqa/ast/parsing/parser_languages_test.exs
@@ -0,0 +1,168 @@
+defmodule CodeQA.AST.Parsing.ParserLanguagesTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.Language
+  alias CodeQA.Languages.Unknown
+
+  Module.register_attribute(__MODULE__, :fixture, accumulate: true, persist: false)
+
+  # Elixir fixtures
+  use Test.Fixtures.Elixir.Calculator
+  use Test.Fixtures.Elixir.EventBus
+  use Test.Fixtures.Elixir.RateLimiter
+
+  # Python fixtures
+  use Test.Fixtures.Python.Calculator
+  use Test.Fixtures.Python.CsvPipeline
+  use Test.Fixtures.Python.ConfigParser
+
+  # JavaScript fixtures
+  use Test.Fixtures.JavaScript.Calculator
+  use Test.Fixtures.JavaScript.FormValidator
+  use Test.Fixtures.JavaScript.ShoppingCart
+
+  # Go fixtures
+  use Test.Fixtures.Go.Calculator
+  use Test.Fixtures.Go.HttpMiddleware
+  use Test.Fixtures.Go.CliParser
+
+  # Rust fixtures
+  use Test.Fixtures.Rust.Calculator
+  use Test.Fixtures.Rust.Tokenizer
+  use Test.Fixtures.Rust.RingBuffer
+
+  # Ruby fixtures
+  use Test.Fixtures.Ruby.Calculator
+  use Test.Fixtures.Ruby.OrmLite
+  use Test.Fixtures.Ruby.MarkdownRenderer
+
+  # TypeScript fixtures
+  use Test.Fixtures.TypeScript.UserProfileStore
+  use Test.Fixtures.TypeScript.EventEmitter
+  use Test.Fixtures.TypeScript.DependencyInjection
+
+  # Java fixtures
+  use Test.Fixtures.Java.BuilderPattern
+  use Test.Fixtures.Java.RepositoryPattern
+  use Test.Fixtures.Java.StrategyPattern
+
+  # C# fixtures
+  use Test.Fixtures.CSharp.LinqPipeline
+  use Test.Fixtures.CSharp.AsyncTaskManager
+  use Test.Fixtures.CSharp.PluginSystem
+
+  # Swift fixtures
+  use Test.Fixtures.Swift.ResultType
+  use Test.Fixtures.Swift.CombineStream
+  use Test.Fixtures.Swift.ActorModel
+
+  # Kotlin fixtures
+  use Test.Fixtures.Kotlin.SealedState
+  use Test.Fixtures.Kotlin.CoroutineFlow
+  use Test.Fixtures.Kotlin.ExtensionLibrary
+
+  # C++ fixtures
+  use Test.Fixtures.Cpp.SmartPointer
+  use Test.Fixtures.Cpp.TemplateContainer
+  use Test.Fixtures.Cpp.ObserverPattern
+
+  # Scala fixtures
+  use Test.Fixtures.Scala.CaseClassAlgebra
+  use Test.Fixtures.Scala.TypeclassPattern
+  use Test.Fixtures.Scala.ActorMessages
+
+  # Dart fixtures
+  use Test.Fixtures.Dart.WidgetState
+  use Test.Fixtures.Dart.FuturesAsync
+  use Test.Fixtures.Dart.MixinComposition
+
+  # Zig fixtures
+  use Test.Fixtures.Zig.AllocatorInterface
+  use Test.Fixtures.Zig.TaggedUnion
+  use Test.Fixtures.Zig.IteratorProtocol
+
+  # Lua fixtures
+  use Test.Fixtures.Lua.ClassSystem
+  use Test.Fixtures.Lua.EventSystem
+  use Test.Fixtures.Lua.StateMachine
+
+  # Note: accumulate: true prepends, so Enum.at(0) is the LAST registered fixture.
+  # All @code values use 0 leading spaces, so @indentation_level will always be 0
+  # and the normalization branch below is never taken.
+  @indentation_level @fixture
+                     |> Enum.at(0)
+                     |> elem(1)
+                     |> String.split("\n")
+                     |> List.first()
+                     |> then(&Regex.run(~r/^\s*/, &1))
+                     |> List.first()
+                     |> String.length()
+
+  @normalized_fixtures for {language, code, block_assertions} <- @fixture,
+                           do:
+                             {language,
+                              if @indentation_level > 0 do
+                                code
+                                |> String.split("\n")
+                                |> Enum.map_join(
+                                  "\n",
+                                  &String.replace_leading(
+                                    &1,
+                                    String.duplicate(" ", @indentation_level),
+                                    ""
+                                  )
+                                )
+                              else
+                                code
+                              end, block_assertions}
+
+  defp blocks(code, lang_mod \\ CodeQA.Languages.Unknown) do
+    code
+    |> TokenNormalizer.normalize_structural()
+    |> Parser.detect_blocks(lang_mod)
+  end
+
+  defp children(code, lang_mod \\ CodeQA.Languages.Unknown) do
+    code
+    |> TokenNormalizer.normalize_structural()
+    |> Parser.detect_blocks(lang_mod)
+    |> Enum.flat_map(& &1.children)
+  end
+
+  describe "blocks/2" do
+    for {language, code, _block_assertions} <- @normalized_fixtures do
+      lang_name = language |> String.split() |> hd()
+      lang_mod = Language.find(lang_name)
+
+      test "detects at least 3 blocks for #{language} code" do
+        lang_mod = unquote(lang_mod)
+        result = blocks(unquote(code), lang_mod)
+
+        if unquote(lang_mod) == Unknown do
+          assert length(result) >= 1
+        else
+          assert length(result) >= 3
+        end
+      end
+
+      test "detects at least 3 sub-blocks for #{language} code" do
+        lang_mod = unquote(lang_mod)
+        result = children(unquote(code), lang_mod)
+
+        if unquote(lang_mod) == Unknown do
+          assert length(result) >= 0
+        else
+          assert length(result) >= 3
+        end
+      end
+
+      test "detects less sub-blocks than line-numbers for #{language} code" do
+        lang_mod = unquote(lang_mod)
+        result = children(unquote(code), lang_mod)
+        assert length(result) < length(String.split(unquote(code), "\n"))
+      end
+    end
+  end
+end
diff --git a/test/codeqa/ast/parsing/parser_test.exs b/test/codeqa/ast/parsing/parser_test.exs
new file mode 100644
index 0000000..c37a8a8
--- /dev/null
+++ b/test/codeqa/ast/parsing/parser_test.exs
@@ -0,0 +1,188 @@
+defmodule CodeQA.AST.Parsing.ParserTest do
+  use ExUnit.Case, async: true
+  alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.Languages.Code.Vm.Elixir, as: ElixirLang
+  alias CodeQA.Languages.Code.Scripting.Python
+  alias CodeQA.Languages.Unknown
+
+  defp tokenize(code), do: TokenNormalizer.normalize_structural(code)
+
+  describe "detect_blocks/2" do
+    test "single block for file with no blank lines" do
+      tokens = tokenize("def foo\n  x = 1\nend\n")
+      blocks = Parser.detect_blocks(tokens, ElixirLang)
+      assert length(blocks) == 1
+    end
+
+    test "splits into two blocks at blank line" do
+      tokens = tokenize("def foo\n  x\nend\n\n\ndef bar\n  y\nend\n")
+      blocks = Parser.detect_blocks(tokens, ElixirLang)
+      assert length(blocks) == 2
+    end
+
+    test "each block has correct line_count" do
+      tokens = tokenize("def foo\n  x\nend\n\n\ndef bar\n  y\nend\n")
+      [b1, b2] = Parser.detect_blocks(tokens, ElixirLang)
+      assert b1.line_count >= 3
+      assert b2.line_count >= 3
+    end
+
+    test "empty input returns empty list" do
+      assert Parser.detect_blocks([], Unknown) == []
+    end
+
+    test "detects bracket sub-blocks" do
+      tokens = tokenize("foo(a, b)\nbar(c)\n")
+      [block] = Parser.detect_blocks(tokens, Unknown)
+      assert block.children != []
+    end
+
+    test "detects colon-indent sub-blocks for python language hint" do
+      tokens = tokenize("def foo:\n    return 1\n")
+      [block] = Parser.detect_blocks(tokens, Python)
+      assert block.children != []
+    end
+
+    test "fewer sub-blocks without python hint than with it (colon rule not applied)" do
+      tokens = tokenize("def foo:\n    return 1\n")
+      without_hint = Parser.detect_blocks(tokens, Unknown)
+      with_hint = Parser.detect_blocks(tokens, Python)
+      count_without = without_hint |> Enum.map(&length(&1.children)) |> Enum.sum()
+      count_with = with_hint |> Enum.map(&length(&1.children)) |> Enum.sum()
+      assert count_with >= count_without
+    end
+
+    test "block has children_count accessible via Node.children_count/1" do
+      alias CodeQA.AST.Enrichment.Node
+      tokens = tokenize("foo(a)\nbar(b)\n")
+      [block] = Parser.detect_blocks(tokens, Unknown)
+      assert Node.children_count(block) == length(block.children)
+    end
+  end
+
+  describe "recursive sub-block nesting" do
+    test "nested bracket calls produce a multi-level sub-block tree" do
+      # def foo(bar(x, y), baz) — the arg list contains another call with its own args
+      tokens = tokenize("def foo(bar(x, y), baz)\n  result\nend\n")
+      [block] = Parser.detect_blocks(tokens, Unknown)
+
+      # depth 1 — the outer argument list
+      args =
+        Enum.find(block.children, fn b ->
+          Enum.any?(b.tokens, &(&1.content == "bar"))
+        end)
+
+      assert args != nil, "expected an arg-list sub-block containing 'bar'"
+
+      # depth 2 — the inner call (x, y) inside bar(...)
+      inner =
+        Enum.find(args.children, fn b ->
+          Enum.any?(b.tokens, &(&1.content == "x"))
+        end)
+
+      assert inner != nil, "expected a sub-block for the inner call (x, y)"
+
+      # depth 3 — (x, y) is a leaf: no further bracket structure inside
+      assert inner.children == []
+    end
+
+    test "triply nested brackets produce three levels of sub-blocks" do
+      tokens = tokenize("def outer(inner(deep(value)))\n  :ok\nend\n")
+      [block] = Parser.detect_blocks(tokens, Unknown)
+
+      # depth 1: (inner(deep(value)))
+      d1 =
+        Enum.find(block.children, fn b ->
+          Enum.any?(b.tokens, &(&1.content == "inner"))
+        end)
+
+      assert d1 != nil
+
+      # depth 2: (deep(value))
+      d2 =
+        Enum.find(d1.children, fn b ->
+          Enum.any?(b.tokens, &(&1.content == "deep"))
+        end)
+
+      assert d2 != nil
+
+      # depth 3: (value) — leaf
+      d3 =
+        Enum.find(d2.children, fn b ->
+          Enum.any?(b.tokens, &(&1.content == "value"))
+        end)
+
+      assert d3 != nil
+      assert d3.children == []
+    end
+  end
+
+  describe "triple-quote protection" do
+    test "blank lines inside a heredoc do not create a new block" do
+      code = """
+      before
+
+
+      \"""
+      Some doc.
+
+      More doc.
+      \"""
+
+      after
+      """
+
+      tokens = TokenNormalizer.normalize_structural(code)
+      blocks = Parser.detect_blocks(tokens, Unknown)
+      # The heredoc (including its blank line) should be ONE block, not split
+      heredoc_block =
+        Enum.find(blocks, fn b ->
+          Enum.any?(b.tokens, &(&1.kind == "<DOC>"))
+        end)
+
+      assert heredoc_block != nil
+      # Ensure no split happened inside — the heredoc block contains both "Some" and "More"
+      contents = Enum.filter(heredoc_block.tokens, &(&1.kind == "<ID>"))
+      names = Enum.map(contents, & &1.content)
+      assert "Some" in names
+      assert "More" in names
+    end
+
+    test "content before and after a heredoc becomes separate blocks" do
+      code = """
+      def foo do
+        :ok
+      end
+
+
+      \"""
+      doc here
+      \"""
+
+
+      def bar do
+        :ok
+      end
+      """
+
+      tokens = TokenNormalizer.normalize_structural(code)
+      blocks = Parser.detect_blocks(tokens, Unknown)
+      # Expect exactly 3 blocks: code-before, heredoc, code-after
+      assert length(blocks) == 3
+      assert Enum.any?(Enum.at(blocks, 0).tokens, &(&1.content == "foo"))
+      assert Enum.any?(Enum.at(blocks, 1).tokens, &(&1.kind == "<DOC>"))
+      assert Enum.any?(Enum.at(blocks, 2).tokens, &(&1.content == "bar"))
+    end
+  end
+
+  describe "language_from_path/1" do
+    test "returns :python for .py files" do
+      assert Parser.language_from_path("lib/foo.py") == :python
+    end
+
+    test "returns :unknown for unknown extensions" do
+      assert Parser.language_from_path("lib/foo.xyz") == :unknown
+    end
+  end
+end
diff --git a/test/codeqa/ast/parsing/signal_registry_test.exs b/test/codeqa/ast/parsing/signal_registry_test.exs
new file mode 100644
index 0000000..f0c0788
--- /dev/null
+++ b/test/codeqa/ast/parsing/signal_registry_test.exs
@@ -0,0 +1,33 @@
+defmodule CodeQA.AST.Parsing.SignalRegistryTest do
+  use ExUnit.Case, async: true
+  alias CodeQA.AST.Parsing.SignalRegistry
+
+  test "new/0 returns empty registry" do
+    r = SignalRegistry.new()
+    assert r.structural == []
+    assert r.classification == []
+  end
+
+  test "register_structural/2 appends signal" do
+    alias CodeQA.AST.Signals.Structural.BlankLineSignal
+    r = SignalRegistry.new() |> SignalRegistry.register_structural(%BlankLineSignal{})
+    assert length(r.structural) == 1
+  end
+
+  test "register_classification/2 appends signal" do
+    alias CodeQA.AST.Signals.Classification.FunctionSignal
+    r = SignalRegistry.new() |> SignalRegistry.register_classification(%FunctionSignal{})
+    assert length(r.classification) == 1
+  end
+
+  test "default/0 includes all built-in signals" do
+    r = SignalRegistry.default()
+    assert length(r.structural) >= 4
+    assert length(r.classification) >= 6
+  end
+
+  test "default/0 has exactly 10 classification signals" do
+    r = SignalRegistry.default()
+    assert length(r.classification) == 10
+  end
+end
diff --git a/test/codeqa/ast/parsing/signal_stream_test.exs b/test/codeqa/ast/parsing/signal_stream_test.exs
new file mode 100644
index 0000000..20c9226
--- /dev/null
+++ b/test/codeqa/ast/parsing/signal_stream_test.exs
@@ -0,0 +1,43 @@
+defmodule CodeQA.AST.SignalStreamTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Lexing.Token
+  alias CodeQA.Support.CounterSignal
+
+  defp tok(kind, content), do: %Token{kind: kind, content: content, line: 1, col: 0}
+
+  test "returns one emission list per signal" do
+    tokens = [tok("<ID>", "foo"), tok("<NL>", "\n"), tok("<ID>", "bar")]
+    results = SignalStream.run(tokens, [%CounterSignal{}], [])
+    assert length(results) == 1
+  end
+
+  test "emissions list contains all emitted values from the signal" do
+    tokens = [tok("<ID>", "foo"), tok("<NL>", "\n"), tok("<ID>", "bar")]
+
+    [
+      [
+        {CodeQA.Support.CounterSignal, :test, :id_seen, 0},
+        {CodeQA.Support.CounterSignal, :test, :id_seen, 2}
+      ]
+    ] =
+      SignalStream.run(tokens, [%CounterSignal{}], [])
+  end
+
+  test "non-emitting tokens produce no entries" do
+    tokens = [tok("<NL>", "\n"), tok("<NL>", "\n")]
+    [[]] = SignalStream.run(tokens, [%CounterSignal{}], [])
+  end
+
+  test "multiple signals run independently" do
+    tokens = [tok("<ID>", "x")]
+    results = SignalStream.run(tokens, [%CounterSignal{}, %CounterSignal{}], [])
+    assert length(results) == 2
+  end
+
+  test "empty token stream returns empty emissions per signal" do
+    results = SignalStream.run([], [%CounterSignal{}], [])
+    assert results == [[]]
+  end
+end
diff --git a/test/codeqa/ast/parsing/signal_test.exs b/test/codeqa/ast/parsing/signal_test.exs
new file mode 100644
index 0000000..47d72ad
--- /dev/null
+++ b/test/codeqa/ast/parsing/signal_test.exs
@@ -0,0 +1,56 @@
+defmodule CodeQA.AST.SignalTest do
+  use ExUnit.Case, async: true
+
+  defmodule TestSignal do
+    defstruct []
+
+    defimpl CodeQA.AST.Parsing.Signal do
+      def source(_), do: TestSignal
+      def group(_), do: :split
+      def init(_, _opts), do: %{count: 0}
+
+      def emit(_, _token, state) do
+        new_state = %{state | count: state.count + 1}
+        {MapSet.new([{:tick, state.count}]), new_state}
+      end
+    end
+  end
+
+  defmodule SilentSignal do
+    defstruct []
+
+    defimpl CodeQA.AST.Parsing.Signal do
+      def source(_), do: SilentSignal
+      def group(_), do: :split
+      def init(_, _), do: %{}
+      def emit(_, _token, state), do: {MapSet.new(), state}
+    end
+  end
+
+  alias CodeQA.AST.Parsing.Signal
+
+  test "source returns the implementing module" do
+    assert Signal.source(%TestSignal{}) == TestSignal
+  end
+
+  test "group returns the signal's group atom" do
+    assert Signal.group(%TestSignal{}) == :split
+  end
+
+  test "init returns initial state" do
+    assert Signal.init(%TestSignal{}, []) == %{count: 0}
+  end
+
+  test "emit returns {MapSet of {name, value} pairs, new_state}" do
+    token = %CodeQA.AST.Lexing.Token{kind: "<ID>", content: "foo", line: 1, col: 0}
+    {emissions, new_state} = Signal.emit(%TestSignal{}, token, %{count: 0})
+    assert MapSet.member?(emissions, {:tick, 0})
+    assert new_state == %{count: 1}
+  end
+
+  test "emit may return empty MapSet for no emission" do
+    token = %CodeQA.AST.Lexing.Token{kind: "<NL>", content: "\n", line: 1, col: 0}
+    {emissions, _state} = Signal.emit(%SilentSignal{}, token, %{})
+    assert MapSet.size(emissions) == 0
+  end
+end
diff --git a/test/codeqa/ast/signals/classification/comment_density_signal_test.exs b/test/codeqa/ast/signals/classification/comment_density_signal_test.exs
new file mode 100644
index 0000000..71069d7
--- /dev/null
+++ b/test/codeqa/ast/signals/classification/comment_density_signal_test.exs
@@ -0,0 +1,46 @@
+defmodule CodeQA.AST.Signals.Classification.CommentDensitySignalTest do
+  use ExUnit.Case, async: true
+  alias CodeQA.AST.Signals.Classification.CommentDensitySignal
+  alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.Languages.Code.Scripting.Python
+  alias CodeQA.Languages.Unknown
+
+  defp run(tokens, lang_mod \\ Unknown),
+    do: SignalStream.run(tokens, [%CommentDensitySignal{}], lang_mod) |> List.flatten()
+
+  defp t(content, kind \\ "<ID>"), do: %{kind: kind, content: content, line: 1, col: 0}
+  defp nl, do: %{kind: "<NL>", content: "\n", line: 1, col: 0}
+  defp on_line(tokens, line), do: Enum.map(tokens, &%{&1 | line: line})
+
+  test "votes comment when >60% of lines start with #" do
+    tokens =
+      on_line([t("#"), t("license")], 1) ++
+        [nl()] ++
+        on_line([t("#"), t("copyright")], 2) ++
+        [nl()] ++
+        on_line([t("#"), t("author")], 3) ++
+        [nl()] ++
+        on_line([t("def"), t("foo")], 4)
+
+    emissions = run(tokens, Python)
+    assert [{CommentDensitySignal, :classification, :comment_vote, _}] = emissions
+  end
+
+  test "does not vote when comment density is low" do
+    tokens =
+      on_line([t("def"), t("foo")], 1) ++
+        [nl()] ++
+        on_line([t("#"), t("note")], 2)
+
+    assert run(tokens, Python) == []
+  end
+
+  test "does not vote when no comment_prefixes provided" do
+    tokens =
+      on_line([t("#"), t("comment")], 1) ++
+        [nl()] ++
+        on_line([t("#"), t("comment")], 2)
+
+    assert run(tokens, Unknown) == []
+  end
+end
diff --git a/test/codeqa/ast/signals/classification/config_signal_test.exs b/test/codeqa/ast/signals/classification/config_signal_test.exs
new file mode 100644
index 0000000..5c63672
--- /dev/null
+++ b/test/codeqa/ast/signals/classification/config_signal_test.exs
@@ -0,0 +1,28 @@
+defmodule CodeQA.AST.Signals.Classification.ConfigSignalTest do
+  use ExUnit.Case, async: true
+  alias CodeQA.AST.Signals.Classification.ConfigSignal
+  alias CodeQA.AST.Parsing.SignalStream
+
+  defp run(tokens), do: SignalStream.run(tokens, [%ConfigSignal{}], []) |> List.flatten()
+  defp t(content, kind \\ "<ID>"), do: %{kind: kind, content: content, line: 1, col: 0}
+
+  test "emits config_vote for 'config' keyword at indent 0" do
+    emissions = run([t("config"), t(":app"), t(","), t("key:"), t("val")])
+    assert [{ConfigSignal, :classification, :config_vote, 3}] = emissions
+  end
+
+  test "emits config_vote for 'configure' keyword" do
+    emissions = run([t("configure")])
+    assert [{ConfigSignal, :classification, :config_vote, 3}] = emissions
+  end
+
+  test "does not emit when indented" do
+    emissions = run([t("<WS>", "<WS>"), t("config")])
+    assert emissions == []
+  end
+
+  test "does not emit for 'config' inside brackets" do
+    tokens = [t("(", "("), t("config"), t(")", ")")]
+    assert run(tokens) == []
+  end
+end
diff --git a/test/codeqa/ast/signals/classification/data_signal_test.exs b/test/codeqa/ast/signals/classification/data_signal_test.exs
new file mode 100644
index 0000000..c537f95
--- /dev/null
+++ b/test/codeqa/ast/signals/classification/data_signal_test.exs
@@ -0,0 +1,28 @@
+defmodule CodeQA.AST.Signals.Classification.DataSignalTest do
+  use ExUnit.Case, async: true
+  alias CodeQA.AST.Signals.Classification.DataSignal
+  alias CodeQA.AST.Parsing.SignalStream
+
+  defp run(tokens), do: SignalStream.run(tokens, [%DataSignal{}], []) |> List.flatten()
+
+  defp t(content, kind), do: %{kind: kind, content: content, line: 1, col: 0}
+  defp str(v), do: t(v, "<STR>")
+  defp num(v), do: t(v, "<NUM>")
+  defp id(v), do: t(v, "<ID>")
+
+  test "votes data for high-literal token stream" do
+    tokens = [str("foo"), str("bar"), num("1"), num("2"), id("key")]
+    emissions = run(tokens)
+    assert [{DataSignal, :classification, :data_vote, _}] = emissions
+  end
+
+  test "does not vote when control-flow keyword present" do
+    tokens = [str("foo"), id("if"), str("bar")]
+    assert run(tokens) == []
+  end
+
+  test "does not vote when literal ratio is low" do
+    tokens = [id("foo"), id("bar"), id("baz"), str("one")]
+    assert run(tokens) == []
+  end
+end
diff --git a/test/codeqa/ast/signals/classification/type_signal_test.exs b/test/codeqa/ast/signals/classification/type_signal_test.exs
new file mode 100644
index 0000000..96811e6
--- /dev/null
+++ b/test/codeqa/ast/signals/classification/type_signal_test.exs
@@ -0,0 +1,40 @@
+defmodule CodeQA.AST.Signals.Classification.TypeSignalTest do
+  use ExUnit.Case, async: true
+  alias CodeQA.AST.Signals.Classification.TypeSignal
+  alias CodeQA.AST.Parsing.SignalStream
+
+  defp run(tokens), do: SignalStream.run(tokens, [%TypeSignal{}], []) |> List.flatten()
+
+  defp t(content, kind \\ "<ID>"), do: %{kind: kind, content: content, line: 1, col: 0}
+
+  test "emits type_vote weight 3 for @type at indent 0" do
+    emissions = run([t("@", "@"), t("type"), t("t"), t("::"), t("integer")])
+    assert [{TypeSignal, :classification, :type_vote, 3}] = emissions
+  end
+
+  test "emits type_vote for @typep" do
+    emissions = run([t("@", "@"), t("typep"), t("t"), t("::")])
+    assert [{TypeSignal, :classification, :type_vote, 3}] = emissions
+  end
+
+  test "emits type_vote for @opaque" do
+    emissions = run([t("@", "@"), t("opaque"), t("t"), t("::")])
+    assert [{TypeSignal, :classification, :type_vote, 3}] = emissions
+  end
+
+  test "does not emit for @spec" do
+    emissions = run([t("@", "@"), t("spec"), t("foo"), t("()")])
+    assert emissions == []
+  end
+
+  test "does not emit for @type inside indented block" do
+    emissions = run([t("<WS>", "<WS>"), t("@", "@"), t("type"), t("t")])
+    assert emissions == []
+  end
+
+  test "emits at most one vote" do
+    tokens = [t("@", "@"), t("type"), t("a"), t("<NL>", "<NL>"), t("@", "@"), t("typep"), t("b")]
+    emissions = run(tokens)
+    assert length(emissions) == 1
+  end
+end
diff --git a/test/codeqa/ast/signals/structural/access_modifier_signal_test.exs b/test/codeqa/ast/signals/structural/access_modifier_signal_test.exs
new file mode 100644
index 0000000..5300881
--- /dev/null
+++ b/test/codeqa/ast/signals/structural/access_modifier_signal_test.exs
@@ -0,0 +1,49 @@
+defmodule CodeQA.AST.Signals.Structural.AccessModifierSignalTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Signals.Structural.AccessModifierSignal
+  alias CodeQA.AST.Parsing.Signal
+  alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.Languages.Code.Vm.Java
+
+  defp split_values(code, lang_mod) do
+    tokens = TokenNormalizer.normalize_structural(code)
+    [emissions] = SignalStream.run(tokens, [%AccessModifierSignal{}], lang_mod)
+    for {_src, :split, :access_modifier_split, v} <- emissions, do: v
+  end
+
+  test "no split for first modifier (seen_content == false)" do
+    assert split_values("public void foo() {}\n", Java) == []
+  end
+
+  test "emits split at second public modifier after content" do
+    splits = split_values("public void foo() {}\npublic void bar() {}\n", Java)
+    assert length(splits) == 1
+  end
+
+  test "emits split at private modifier after content" do
+    splits = split_values("public void foo() {}\nprivate void bar() {}\n", Java)
+    assert length(splits) == 1
+  end
+
+  test "does not split when modifier is inside brackets" do
+    splits = split_values("public void foo(private int x) {}\n", Java)
+    assert splits == []
+  end
+
+  test "does not split on identifier that matches modifier but is not at line start" do
+    splits = split_values("public void foo() {}\nfoo.public.bar()\n", Java)
+    assert splits == []
+  end
+
+  test "works at indent > 0 (unlike KeywordSignal)" do
+    # Two indented public declarations, no enclosing brackets — should split
+    splits = split_values("  public void foo() {}\n  public void bar() {}\n", Java)
+    assert length(splits) == 1
+  end
+
+  test "group is :split" do
+    assert Signal.group(%AccessModifierSignal{}) == :split
+  end
+end
diff --git a/test/codeqa/ast/signals/structural/assignment_function_signal_test.exs b/test/codeqa/ast/signals/structural/assignment_function_signal_test.exs
new file mode 100644
index 0000000..534b735
--- /dev/null
+++ b/test/codeqa/ast/signals/structural/assignment_function_signal_test.exs
@@ -0,0 +1,84 @@
+defmodule CodeQA.AST.Signals.Structural.AssignmentFunctionSignalTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Signals.Structural.AssignmentFunctionSignal
+  alias CodeQA.AST.Parsing.Signal
+  alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Lexing.TokenNormalizer
+
+  defp split_indices(code) do
+    tokens = TokenNormalizer.normalize_structural(code)
+    [emissions] = SignalStream.run(tokens, [%AssignmentFunctionSignal{}], [])
+    for {_src, :split, :assignment_function_split, v} <- emissions, do: v
+  end
+
+  test "emits split for identifier = function() pattern (second in file)" do
+    code = """
+    const first = function() {}
+    const foo = function() {}
+    """
+
+    splits = split_indices(code)
+    assert length(splits) == 1
+  end
+
+  test "emits split for arrow function pattern: bar = () => {}" do
+    code = """
+    const first = function() {}
+    const bar = () => {}
+    """
+
+    splits = split_indices(code)
+    assert length(splits) == 1
+  end
+
+  test "emits split for async function pattern: baz = async function() {}" do
+    code = """
+    const first = function() {}
+    const baz = async function() {}
+    """
+
+    splits = split_indices(code)
+    assert length(splits) == 1
+  end
+
+  test "does NOT emit for the first assignment in file (seen_content == false)" do
+    code = "const foo = function() {}\n"
+    splits = split_indices(code)
+    assert splits == []
+  end
+
+  test "does NOT emit for plain assignment: x = 1" do
+    code = """
+    const first = function() {}
+    x = 1
+    """
+
+    splits = split_indices(code)
+    assert splits == []
+  end
+
+  test "does NOT emit when identifier is indented (indent > 0)" do
+    code = """
+    const first = function() {}
+      foo = function() {}
+    """
+
+    splits = split_indices(code)
+    assert splits == []
+  end
+
+  test "emits split for module.exports = function() pattern" do
+    code = """
+    const first = function() {}
+    module.exports = function() {}
+    """
+
+    splits = split_indices(code)
+    assert length(splits) == 1
+  end
+
+  test "group/1 returns :split" do
+    assert Signal.group(%AssignmentFunctionSignal{}) == :split
+  end
+end
diff --git a/test/codeqa/ast/signals/structural/blank_line_signal_test.exs b/test/codeqa/ast/signals/structural/blank_line_signal_test.exs
new file mode 100644
index 0000000..464ca46
--- /dev/null
+++ b/test/codeqa/ast/signals/structural/blank_line_signal_test.exs
@@ -0,0 +1,36 @@
+defmodule CodeQA.AST.Signals.Structural.BlankLineSignalTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Signals.Structural.BlankLineSignal
+  alias CodeQA.AST.Parsing.Signal
+  alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.Languages.Code.Vm.Elixir, as: ElixirLang
+
+  defp split_values(code, lang_mod) do
+    tokens = TokenNormalizer.normalize_structural(code)
+    [emissions] = SignalStream.run(tokens, [%BlankLineSignal{}], lang_mod)
+    for {_src, :split, :blank_split, v} <- emissions, do: v
+  end
+
+  test "no splits for single block" do
+    assert split_values("def foo\n  x\nend\n", ElixirLang) == []
+  end
+
+  test "emits split after blank line following block-end token" do
+    splits = split_values("def foo\n  x\nend\n\n\ndef bar\n  y\nend\n", ElixirLang)
+    assert length(splits) == 1
+  end
+
+  test "no split when blank line does not follow block-end token" do
+    assert split_values("x = 1\n\n\ny = 2\n", ElixirLang) == []
+  end
+
+  test "group is :split" do
+    assert Signal.group(%BlankLineSignal{}) == :split
+  end
+
+  test "source is BlankLineSignal" do
+    assert Signal.source(%BlankLineSignal{}) == BlankLineSignal
+  end
+end
diff --git a/test/codeqa/ast/signals/structural/bracket_signal_test.exs b/test/codeqa/ast/signals/structural/bracket_signal_test.exs
new file mode 100644
index 0000000..4159b6b
--- /dev/null
+++ b/test/codeqa/ast/signals/structural/bracket_signal_test.exs
@@ -0,0 +1,43 @@
+defmodule CodeQA.AST.Signals.Structural.BracketSignalTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Signals.Structural.BracketSignal
+  alias CodeQA.AST.Parsing.Signal
+  alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Lexing.TokenNormalizer
+
+  defp enclosure_values(code) do
+    tokens = TokenNormalizer.normalize_structural(code)
+    [emissions] = SignalStream.run(tokens, [%BracketSignal{}], [])
+    for {_src, :enclosure, :bracket_enclosure, v} <- emissions, do: v
+  end
+
+  test "no enclosures for code without brackets" do
+    assert enclosure_values("foo\n") == []
+  end
+
+  test "emits enclosure for a single bracketed expression" do
+    enclosures = enclosure_values("foo(a, b)\n")
+    assert length(enclosures) == 1
+  end
+
+  test "emits only outermost enclosure for nested brackets" do
+    enclosures = enclosure_values("foo(bar(x))\n")
+    assert length(enclosures) == 1
+  end
+
+  test "enclosure value is {start_idx, end_idx} tuple" do
+    [{start, stop}] = enclosure_values("foo(a)\n")
+    assert is_integer(start)
+    assert is_integer(stop)
+    assert stop > start
+  end
+
+  test "mismatched closing bracket is silently skipped" do
+    assert enclosure_values("foo)\n") == []
+  end
+
+  test "group is :enclosure" do
+    assert Signal.group(%BracketSignal{}) == :enclosure
+  end
+end
diff --git a/test/codeqa/ast/signals/structural/branch_split_signal_test.exs b/test/codeqa/ast/signals/structural/branch_split_signal_test.exs
new file mode 100644
index 0000000..7a7eb94
--- /dev/null
+++ b/test/codeqa/ast/signals/structural/branch_split_signal_test.exs
@@ -0,0 +1,93 @@
+defmodule CodeQA.AST.Signals.Structural.BranchSplitSignalTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Signals.Structural.BranchSplitSignal
+  alias CodeQA.AST.Parsing.{Signal, SignalStream}
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.Languages.Code.Vm.Elixir, as: ElixirLang
+  alias CodeQA.Languages.Code.Scripting.Python
+  alias CodeQA.Languages.Code.Scripting.Ruby
+  alias CodeQA.Languages.Code.Scripting.PHP
+  alias CodeQA.Languages.Code.Vm.Java
+
+  defp split_values(code, lang_mod) do
+    tokens = TokenNormalizer.normalize_structural(code)
+    [emissions] = SignalStream.run(tokens, [%BranchSplitSignal{}], lang_mod)
+    for {_src, :branch_split, :branch_split, v} <- emissions, do: v
+  end
+
+  test "group is :branch_split" do
+    assert Signal.group(%BranchSplitSignal{}) == :branch_split
+  end
+
+  test "no split for code with no branch keywords" do
+    assert split_values("x = 1\ny = 2\n", ElixirLang) == []
+  end
+
+  test "emits split at else after seen content" do
+    splits = split_values("if x do\n  :a\nelse\n  :b\nend\n", ElixirLang)
+    assert length(splits) == 1
+  end
+
+  test "emits split at elif" do
+    splits = split_values("if x:\n  pass\nelif y:\n  pass\n", Python)
+    assert length(splits) == 1
+  end
+
+  test "emits split at multiple branch keywords" do
+    splits = split_values("if x do\n  :a\nelsif y\n  :b\nelse\n  :c\nend\n", Ruby)
+    assert length(splits) == 2
+  end
+
+  test "does not emit at first keyword (no seen_content yet)" do
+    splits = split_values("if x do\n  :a\nend\n", ElixirLang)
+    assert splits == []
+  end
+
+  test "does not emit when keyword is inside brackets" do
+    splits = split_values("foo(if x do 1 else 2 end)\n", ElixirLang)
+    assert splits == []
+  end
+
+  test "emits split at rescue" do
+    splits = split_values("try do\n  :ok\nrescue\n  _ -> :error\nend\n", ElixirLang)
+    assert length(splits) == 1
+  end
+
+  test "emits split at cond branch" do
+    splits = split_values("x = 1\ncond do\n  x -> :a\nend\n", ElixirLang)
+    assert length(splits) == 1
+  end
+
+  test "emits split at except (Python)" do
+    splits = split_values("try:\n  pass\nexcept ValueError:\n  pass\n", Python)
+    assert length(splits) == 1
+  end
+
+  test "emits split at ensure (Elixir)" do
+    splits =
+      split_values(
+        "try do\n  :ok\nrescue\n  _ -> :error\nensure\n  cleanup()\nend\n",
+        ElixirLang
+      )
+
+    assert length(splits) == 2
+  end
+
+  test "emits split at elseif (PHP)" do
+    splits = split_values("if x then\n  :a\nelseif y then\n  :b\nend\n", PHP)
+    assert length(splits) == 1
+  end
+
+  test "emits split at case label (switch body)" do
+    splits =
+      split_values("switch x\n  case 1:\n    :a\n  case 2:\n    :b\nend\n", Java)
+
+    assert length(splits) >= 1
+  end
+
+  test "emits split at when keyword" do
+    splits = split_values("x = 1\nwhen x > 0 do\n  :pos\nend\n", ElixirLang)
+    assert length(splits) == 1
+  end
+end
diff --git a/test/codeqa/ast/signals/structural/colon_indent_signal_test.exs b/test/codeqa/ast/signals/structural/colon_indent_signal_test.exs
new file mode 100644
index 0000000..484edf6
--- /dev/null
+++ b/test/codeqa/ast/signals/structural/colon_indent_signal_test.exs
@@ -0,0 +1,29 @@
+defmodule CodeQA.AST.Signals.Structural.ColonIndentSignalTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Signals.Structural.ColonIndentSignal
+  alias CodeQA.AST.Parsing.Signal
+  alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.Languages.Code.Scripting.Python
+
+  defp enclosure_values(code, lang_mod \\ Python) do
+    tokens = TokenNormalizer.normalize_structural(code)
+    [emissions] = SignalStream.run(tokens, [%ColonIndentSignal{}], lang_mod)
+    for {_src, :enclosure, :colon_indent_enclosure, v} <- emissions, do: v
+  end
+
+  test "no enclosures for non-python language" do
+    assert enclosure_values("def foo:\n    return 1\n", CodeQA.Languages.Unknown) ==
+             []
+  end
+
+  test "emits enclosure for colon-indented block in python" do
+    enclosures = enclosure_values("def foo:\n    return 1\n")
+    assert enclosures != []
+  end
+
+  test "group is :enclosure" do
+    assert Signal.group(%ColonIndentSignal{}) == :enclosure
+  end
+end
diff --git a/test/codeqa/ast/signals/structural/comment_divider_signal_test.exs b/test/codeqa/ast/signals/structural/comment_divider_signal_test.exs
new file mode 100644
index 0000000..329c910
--- /dev/null
+++ b/test/codeqa/ast/signals/structural/comment_divider_signal_test.exs
@@ -0,0 +1,52 @@
+defmodule CodeQA.AST.Signals.Structural.CommentDividerSignalTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Signals.Structural.CommentDividerSignal
+  alias CodeQA.AST.Parsing.Signal
+  alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.Languages.Code.Vm.Elixir, as: ElixirLang
+  alias CodeQA.Languages.Code.Vm.Java
+  alias CodeQA.Languages.Data.Sql
+
+  defp split_values(code, lang_mod) do
+    tokens = TokenNormalizer.normalize_structural(code)
+    [emissions] = SignalStream.run(tokens, [%CommentDividerSignal{}], lang_mod)
+    for {_src, :split, :comment_divider_split, v} <- emissions, do: v
+  end
+
+  test "no split for first divider comment (seen_content == false at start of file)" do
+    assert split_values("# ---\n", ElixirLang) == []
+  end
+
+  test "emits split at # --- after prior content" do
+    splits = split_values("x = 1\n# ---\ny = 2\n", ElixirLang)
+    assert length(splits) == 1
+  end
+
+  test "emits split at // === after prior content" do
+    splits = split_values("x = 1\n// ===\ny = 2\n", Java)
+    assert length(splits) == 1
+  end
+
+  test "emits split at -- --- after prior content (SQL style)" do
+    splits = split_values("x = 1\n-- ---\ny = 2\n", Sql)
+    assert length(splits) == 1
+  end
+
+  test "does NOT emit for # followed by identifier (real comment)" do
+    assert split_values("x = 1\n# This is a real comment\n", ElixirLang) == []
+  end
+
+  test "does NOT emit when # is not at line start" do
+    assert split_values("x = 1\nx # ---\n", ElixirLang) == []
+  end
+
+  test "does NOT emit for indented divider comment (inside a block)" do
+    assert split_values("x = 1\n  # ---\n", ElixirLang) == []
+  end
+
+  test "group is :split" do
+    assert Signal.group(%CommentDividerSignal{}) == :split
+  end
+end
diff --git a/test/codeqa/ast/signals/structural/decorator_signal_test.exs b/test/codeqa/ast/signals/structural/decorator_signal_test.exs
new file mode 100644
index 0000000..b1474d7
--- /dev/null
+++ b/test/codeqa/ast/signals/structural/decorator_signal_test.exs
@@ -0,0 +1,47 @@
+defmodule CodeQA.AST.Signals.Structural.DecoratorSignalTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Signals.Structural.DecoratorSignal
+  alias CodeQA.AST.Parsing.Signal
+  alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Lexing.TokenNormalizer
+
+  defp split_values(code) do
+    tokens = TokenNormalizer.normalize_structural(code)
+    [emissions] = SignalStream.run(tokens, [%DecoratorSignal{}], [])
+    for {_src, :split, :decorator_split, v} <- emissions, do: v
+  end
+
+  test "no split for first @ (seen_content == false at start of file)" do
+    assert split_values("@decorator\ndef foo() {}\n") == []
+  end
+
+  test "emits split at second @decorator after content" do
+    splits = split_values("@decorator\ndef foo() {}\n@decorator\ndef bar() {}\n")
+    assert length(splits) == 1
+  end
+
+  test "does not emit when @ is inside brackets" do
+    splits = split_values("@decorator\ndef foo(@param x) {}\n")
+    assert splits == []
+  end
+
+  test "does not emit when @ is not at line start (mid-expression)" do
+    splits = split_values("@decorator\ndef foo() { x@y }\n")
+    assert splits == []
+  end
+
+  test "emits split for Rust #[ pattern at line start after content" do
+    splits = split_values("#[derive(Debug)]\nstruct Foo {}\n#[derive(Clone)]\nstruct Bar {}\n")
+    assert length(splits) == 1
+  end
+
+  test "does not emit for # at line start when next token is not [" do
+    splits = split_values("@decorator\ndef foo() {}\n# comment\ndef bar() {}\n")
+    assert splits == []
+  end
+
+  test "group is :split" do
+    assert Signal.group(%DecoratorSignal{}) == :split
+  end
+end
diff --git a/test/codeqa/ast/signals/structural/dedent_to_zero_signal_test.exs b/test/codeqa/ast/signals/structural/dedent_to_zero_signal_test.exs
new file mode 100644
index 0000000..749e165
--- /dev/null
+++ b/test/codeqa/ast/signals/structural/dedent_to_zero_signal_test.exs
@@ -0,0 +1,55 @@
+defmodule CodeQA.AST.Signals.Structural.DedentToZeroSignalTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Signals.Structural.DedentToZeroSignal
+  alias CodeQA.AST.Parsing.Signal
+  alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Lexing.TokenNormalizer
+
+  defp split_count(code) do
+    tokens = TokenNormalizer.normalize_structural(code)
+    [emissions] = SignalStream.run(tokens, [%DedentToZeroSignal{}], [])
+    length(for {_src, :split, :dedent_split, _v} <- emissions, do: true)
+  end
+
+  test "no split in a single flat block (no indentation change)" do
+    code = "foo\nbar\nbaz\n"
+    assert split_count(code) == 0
+  end
+
+  test "emits split when first token of a new line at indent 0 after indented content" do
+    code = "def foo:\n  return 1\ndef bar:\n"
+    assert split_count(code) == 1
+  end
+
+  test "does NOT emit when returning to indent 0 from same-level content (no prior indent)" do
+    code = "foo\nbar\n"
+    assert split_count(code) == 0
+  end
+
+  test "does NOT emit at the very start of file (seen_content == false)" do
+    code = "foo\n  bar\n"
+    # The very first line has no prior indent, so no split should fire
+    assert split_count(code) == 0
+  end
+
+  test "handles multiple indented blocks with splits" do
+    code = "foo:\n  x = 1\nbar:\n  y = 2\nbaz:\n"
+    # split at "bar" and "baz"
+    assert split_count(code) == 2
+  end
+
+  test "does NOT split if current line also has indent (both lines indented)" do
+    code = "foo:\n  x = 1\n  y = 2\n"
+    assert split_count(code) == 0
+  end
+
+  test "emits split when a blank line separates an indented block from a new block at indent 0" do
+    code = "def foo:\n  return 1\n\ndef bar:\n"
+    assert split_count(code) == 1
+  end
+
+  test "group/1 returns :split" do
+    assert Signal.group(%DedentToZeroSignal{}) == :split
+  end
+end
diff --git a/test/codeqa/ast/signals/structural/doc_comment_lead_signal_test.exs b/test/codeqa/ast/signals/structural/doc_comment_lead_signal_test.exs
new file mode 100644
index 0000000..28965c4
--- /dev/null
+++ b/test/codeqa/ast/signals/structural/doc_comment_lead_signal_test.exs
@@ -0,0 +1,44 @@
+defmodule CodeQA.AST.Signals.Structural.DocCommentLeadSignalTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Signals.Structural.DocCommentLeadSignal
+  alias CodeQA.AST.Parsing.Signal
+  alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Lexing.TokenNormalizer
+
+  defp split_values(code) do
+    tokens = TokenNormalizer.normalize_structural(code)
+    [emissions] = SignalStream.run(tokens, [%DocCommentLeadSignal{}], [])
+    for {_src, :split, :doc_comment_split, v} <- emissions, do: v
+  end
+
+  test "no split for first /// (seen_content == false at start of file)" do
+    assert split_values("/// doc\n") == []
+  end
+
+  test "emits split at /// after prior content (Rust/C# doc comment)" do
+    splits = split_values("fn foo() {}\n/// doc\n")
+    assert length(splits) == 1
+  end
+
+  test "emits split at /** after prior content (Java/JS JSDoc)" do
+    splits = split_values("function foo() {}\n/**\n * doc\n */\n")
+    assert length(splits) == 1
+  end
+
+  test "does NOT emit for // followed by identifier (regular line comment)" do
+    assert split_values("x = 1\n// regular comment\n") == []
+  end
+
+  test "does NOT emit for // that is not at line start" do
+    assert split_values("x = 1\nx // doc\n") == []
+  end
+
+  test "does NOT emit for / at line start when next is not *" do
+    assert split_values("x = 1\n/ something\n") == []
+  end
+
+  test "group is :split" do
+    assert Signal.group(%DocCommentLeadSignal{}) == :split
+  end
+end
diff --git a/test/codeqa/ast/signals/structural/keyword_signal_test.exs b/test/codeqa/ast/signals/structural/keyword_signal_test.exs
new file mode 100644
index 0000000..4aecba6
--- /dev/null
+++ b/test/codeqa/ast/signals/structural/keyword_signal_test.exs
@@ -0,0 +1,38 @@
+defmodule CodeQA.AST.Signals.Structural.KeywordSignalTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Signals.Structural.KeywordSignal
+  alias CodeQA.AST.Parsing.Signal
+  alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.Languages.Code.Vm.Elixir, as: ElixirLang
+
+  defp split_values(code, lang_mod) do
+    tokens = TokenNormalizer.normalize_structural(code)
+    [emissions] = SignalStream.run(tokens, [%KeywordSignal{}], lang_mod)
+    for {_src, :split, :keyword_split, v} <- emissions, do: v
+  end
+
+  test "no split for single def" do
+    assert split_values("def foo\n  x\nend\n", ElixirLang) == []
+  end
+
+  test "emits split at second def keyword at depth 0 indent 0" do
+    splits = split_values("def foo\n  x\nend\ndef bar\n  y\nend\n", ElixirLang)
+    assert length(splits) == 1
+  end
+
+  test "does not split on def inside a module (indented)" do
+    splits = split_values("defmodule Foo do\n  def foo, do: 1\nend\n", ElixirLang)
+    assert splits == []
+  end
+
+  test "does not split on keyword inside brackets" do
+    splits = split_values("foo(def, bar)\n", ElixirLang)
+    assert splits == []
+  end
+
+  test "group is :split" do
+    assert Signal.group(%KeywordSignal{}) == :split
+  end
+end
diff --git a/test/codeqa/ast/signals/structural/sql_block_signal_test.exs b/test/codeqa/ast/signals/structural/sql_block_signal_test.exs
new file mode 100644
index 0000000..e655f8d
--- /dev/null
+++ b/test/codeqa/ast/signals/structural/sql_block_signal_test.exs
@@ -0,0 +1,60 @@
+defmodule CodeQA.AST.Signals.Structural.SQLBlockSignalTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Signals.Structural.SQLBlockSignal
+  alias CodeQA.AST.Parsing.Signal
+  alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.Languages.Data.Sql
+
+  defp split_values(code) do
+    tokens = TokenNormalizer.normalize_structural(code)
+    [emissions] = SignalStream.run(tokens, [%SQLBlockSignal{}], Sql)
+    for {_src, :split, :sql_block_split, v} <- emissions, do: v
+  end
+
+  test "no split for the first statement (seen_content == false)" do
+    assert split_values("CREATE TABLE users (id INT);\n") == []
+  end
+
+  test "emits split at second CREATE TABLE DDL statement" do
+    code = "CREATE TABLE users (id INT);\nCREATE TABLE orders (id INT);\n"
+    splits = split_values(code)
+    assert length(splits) == 1
+  end
+
+  test "emits split at SELECT when a query follows other content" do
+    code = "CREATE TABLE users (id INT);\nSELECT id FROM users;\n"
+    splits = split_values(code)
+    assert length(splits) == 1
+  end
+
+  test "emits split at lowercase create (case-insensitive match)" do
+    code = "create table users (id INT);\ncreate table orders (id INT);\n"
+    splits = split_values(code)
+    assert length(splits) == 1
+  end
+
+  test "emits split at INSERT after prior content" do
+    code = "CREATE TABLE users (id INT);\nINSERT INTO users VALUES (1);\n"
+    splits = split_values(code)
+    assert length(splits) == 1
+  end
+
+  test "does NOT emit for SQL keyword mid-statement (not at line start)" do
+    # FROM is not at line start; only SELECT is, but it's the first statement
+    code = "SELECT id FROM users;\n"
+    splits = split_values(code)
+    assert splits == []
+  end
+
+  test "does NOT emit for non-SQL identifier at line start" do
+    code = "CREATE TABLE users (id INT);\nusername VARCHAR(255);\n"
+    splits = split_values(code)
+    assert splits == []
+  end
+
+  test "group/1 returns :split" do
+    assert Signal.group(%SQLBlockSignal{}) == :split
+  end
+end
diff --git a/test/codeqa/ast/signals/structural/triple_quote_signal_test.exs b/test/codeqa/ast/signals/structural/triple_quote_signal_test.exs
new file mode 100644
index 0000000..fed5f3f
--- /dev/null
+++ b/test/codeqa/ast/signals/structural/triple_quote_signal_test.exs
@@ -0,0 +1,35 @@
+defmodule CodeQA.AST.Signals.Structural.TripleQuoteSignalTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.AST.Signals.Structural.TripleQuoteSignal
+  alias CodeQA.AST.Parsing.Signal
+  alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Lexing.TokenNormalizer
+
+  defp split_values(code) do
+    tokens = TokenNormalizer.normalize_structural(code)
+    [emissions] = SignalStream.run(tokens, [%TripleQuoteSignal{}], [])
+    for {_src, :split, :triple_split, v} <- emissions, do: v
+  end
+
+  test "no splits for plain code" do
+    assert split_values("def foo\n  :ok\nend\n") == []
+  end
+
+  test "emits two splits for a complete heredoc" do
+    code = "\"\"\"\nhello\n\"\"\"\n"
+    splits = split_values(code)
+    assert length(splits) == 2
+  end
+
+  test "emits one split for unclosed heredoc (mismatch tolerance)" do
+    # single <DOC> token with no closing pair
+    code = "\"\"\"\nhello\n"
+    splits = split_values(code)
+    assert length(splits) == 1
+  end
+
+  test "group is :split" do
+    assert Signal.group(%TripleQuoteSignal{}) == :split
+  end
+end

From 45ae2b28175b4b65f02f7b8dc3e11229f1b8ea63 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 19 Mar 2026 18:31:09 +0100
Subject: [PATCH 15/71] chore(gitignore): ignore scripts/*.exs and docs plan
 directories

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .gitignore | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitignore b/.gitignore
index 81b993d..4ef9df3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -19,6 +19,9 @@ devenv.lock
 # Git worktrees
 .worktrees/
 docs/plans/
+docs/superpowers/
+plans/
+scripts/*.exs
 
 # Claude Code
 .claude/

From b58c8bf813dc53a99b44acfd4c38a417112e579e Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Fri, 20 Mar 2026 13:06:54 +0100
Subject: [PATCH 16/71] feat(combined-metrics): detect and persist language
 coverage per behavior

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/combined_metrics/sample_runner.ex  | 83 ++++++++++++++++++-
 .../combined_metrics/sample_runner_test.exs   | 43 ++++++++++
 2 files changed, 124 insertions(+), 2 deletions(-)

diff --git a/lib/codeqa/combined_metrics/sample_runner.ex b/lib/codeqa/combined_metrics/sample_runner.ex
index 4bd078c..e4c163c 100644
--- a/lib/codeqa/combined_metrics/sample_runner.ex
+++ b/lib/codeqa/combined_metrics/sample_runner.ex
@@ -467,10 +467,17 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
             hint -> ["  _fix_hint: #{inspect(hint)}"]
           end
 
+        languages_line =
+          case Map.get(groups, "_languages") do
+            nil -> []
+            [] -> []
+            langs -> ["  _languages: [#{Enum.join(langs, ", ")}]"]
+          end
+
         group_lines =
           groups
           |> Enum.filter(fn {k, v} ->
-            k not in ["_doc", "_log_baseline", "_fix_hint"] and is_map(v)
+            k not in ["_doc", "_log_baseline", "_fix_hint", "_languages"] and is_map(v)
           end)
           |> Enum.sort_by(fn {group, _} -> group end)
           |> Enum.flat_map(fn {group, keys} ->
@@ -482,7 +489,8 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
             ["  #{group}:" | key_lines]
           end)
 
-        ["#{behavior}:" | doc_line] ++ fix_hint_line ++ baseline_line ++ group_lines ++ [""]
+        ["#{behavior}:" | doc_line] ++
+          fix_hint_line ++ languages_line ++ baseline_line ++ group_lines ++ [""]
       end)
 
     Enum.join(lines, "\n") <> "\n"
@@ -496,4 +504,75 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
   defp sample_path(category, behavior, kind) do
     Path.join([@samples_root, category, behavior, kind])
   end
+
+  defp dir_languages(dir) do
+    case File.ls(dir) do
+      {:ok, files} ->
+        files
+        |> Enum.map(&CodeQA.Language.detect/1)
+        |> Enum.map(& &1.name())
+        |> MapSet.new()
+
+      _ ->
+        MapSet.new()
+    end
+  end
+
+  defp languages_for_behavior(category, behavior) do
+    bad_langs = dir_languages(sample_path(category, behavior, "bad"))
+    good_langs = dir_languages(sample_path(category, behavior, "good"))
+
+    bad_langs
+    |> MapSet.intersection(good_langs)
+    |> MapSet.to_list()
+    |> Enum.reject(&(&1 == "unknown"))
+    |> Enum.sort()
+  end
+
+  defp maybe_put_languages(groups, []), do: groups
+  defp maybe_put_languages(groups, langs), do: Map.put(groups, "_languages", langs)
+
+  @doc """
+  Updates only the `_languages` field in YAML config files based on sample data.
+
+  Scans `bad/` and `good/` sample directories for each behavior, detects languages
+  from file extensions via `CodeQA.Language.detect/1`, and writes the intersection
+  as `_languages` to the YAML. Behaviors without sample data are left without a
+  `_languages` key (treated as applying to all languages at scoring time).
+  All existing scalars and baselines are preserved.
+
+  Returns a list of `%{category: String.t(), behaviors_with_languages: non_neg_integer()}`.
+  """
+  @spec apply_languages(keyword()) :: [map()]
+  def apply_languages(opts \\ []) do
+    filter_category = opts[:category]
+
+    @yaml_dir
+    |> File.ls!()
+    |> Enum.filter(&String.ends_with?(&1, ".yml"))
+    |> Enum.filter(fn yml_file ->
+      filter_category == nil or String.trim_trailing(yml_file, ".yml") == filter_category
+    end)
+    |> Enum.sort()
+    |> Enum.map(fn yml_file ->
+      category = String.trim_trailing(yml_file, ".yml")
+      yaml_path = Path.join(@yaml_dir, yml_file)
+      {:ok, existing} = YamlElixir.read_from_file(yaml_path)
+
+      updated =
+        existing
+        |> Enum.filter(fn {_k, v} -> is_map(v) end)
+        |> Map.new(fn {behavior, groups} ->
+          langs = languages_for_behavior(category, behavior)
+          {behavior, maybe_put_languages(groups, langs)}
+        end)
+
+      File.write!(yaml_path, format_yaml(updated))
+
+      behaviors_with_languages =
+        Enum.count(updated, fn {_b, groups} -> Map.has_key?(groups, "_languages") end)
+
+      %{category: category, behaviors_with_languages: behaviors_with_languages}
+    end)
+  end
 end
diff --git a/test/codeqa/combined_metrics/sample_runner_test.exs b/test/codeqa/combined_metrics/sample_runner_test.exs
index ea582d2..84bc4a0 100644
--- a/test/codeqa/combined_metrics/sample_runner_test.exs
+++ b/test/codeqa/combined_metrics/sample_runner_test.exs
@@ -8,6 +8,49 @@ defmodule CodeQA.CombinedMetrics.SampleRunnerTest do
     %{results: results}
   end
 
+  describe "apply_languages/1" do
+    test "returns one entry per requested category" do
+      stats = SampleRunner.apply_languages(category: "variable_naming")
+      assert length(stats) == 1
+      [entry] = stats
+      assert entry.category == "variable_naming"
+      assert is_integer(entry.behaviors_with_languages)
+    end
+
+    test "writes _languages to behaviors that have samples" do
+      SampleRunner.apply_languages(category: "variable_naming")
+      {:ok, data} = YamlElixir.read_from_file("priv/combined_metrics/variable_naming.yml")
+      langs = get_in(data, ["name_is_generic", "_languages"])
+      assert is_list(langs)
+      assert length(langs) > 0
+      assert Enum.all?(langs, &is_binary/1)
+    end
+
+    test "behaviors without sample dirs get no _languages key" do
+      SampleRunner.apply_languages(category: "variable_naming")
+      {:ok, data} = YamlElixir.read_from_file("priv/combined_metrics/variable_naming.yml")
+
+      Enum.each(data, fn {_behavior, groups} ->
+        if is_map(groups) do
+          case Map.get(groups, "_languages") do
+            nil -> :ok
+            langs -> assert is_list(langs) and length(langs) > 0
+          end
+        end
+      end)
+    end
+
+    test "only includes languages with both good and bad samples" do
+      # uses code_smells which has single-language behaviors
+      SampleRunner.apply_languages(category: "code_smells")
+      {:ok, data} = YamlElixir.read_from_file("priv/combined_metrics/code_smells.yml")
+
+      # no_dead_code_after_return has only .ex samples
+      langs = get_in(data, ["no_dead_code_after_return", "_languages"])
+      assert langs == ["elixir"]
+    end
+  end
+
   describe "run/1" do
     test "returns a list of results with required keys", %{results: results} do
       assert is_list(results)

From a8267d374f9df72d723cdd41dc622d9d1668da84 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Fri, 20 Mar 2026 13:11:45 +0100
Subject: [PATCH 17/71] feat(combined-metrics): filter diagnose_aggregate by
 language

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/combined_metrics/sample_runner.ex  | 102 +++++++++++-------
 .../combined_metrics/sample_runner_test.exs   |  35 ++++++
 2 files changed, 98 insertions(+), 39 deletions(-)

diff --git a/lib/codeqa/combined_metrics/sample_runner.ex b/lib/codeqa/combined_metrics/sample_runner.ex
index e4c163c..3d33c30 100644
--- a/lib/codeqa/combined_metrics/sample_runner.ex
+++ b/lib/codeqa/combined_metrics/sample_runner.ex
@@ -275,6 +275,8 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
   @spec diagnose_aggregate(map(), keyword()) :: [map()]
   def diagnose_aggregate(aggregate, opts \\ []) do
     top_n = Keyword.get(opts, :top, 15)
+    language = Keyword.get(opts, :language)
+    languages = Keyword.get(opts, :languages)
 
     Scorer.all_yamls()
     |> Enum.sort_by(fn {path, _} -> path end)
@@ -284,48 +286,54 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
       data
       |> Enum.filter(fn {_k, v} -> is_map(v) end)
       |> Enum.flat_map(fn {behavior, behavior_data} ->
-        scalars = Scorer.scalars_for(yaml_path, behavior)
+        behavior_langs = Map.get(behavior_data, "_languages", [])
 
-        if map_size(scalars) == 0 do
+        if not behavior_language_applies?(behavior_langs, language, languages) do
           []
         else
-          log_baseline = Map.get(behavior_data, "_log_baseline", 0.0) / 1.0
-
-          {dot, norm_s_sq, norm_v_sq, contributions} =
-            Enum.reduce(scalars, {0.0, 0.0, 0.0, []}, fn {{group, key}, scalar},
-                                                         {d, ns, nv, contribs} ->
-              log_m = :math.log(Scorer.get(aggregate, group, key))
-              contrib = scalar * log_m
-
-              {d + contrib, ns + scalar * scalar, nv + log_m * log_m,
-               [{:"#{group}.#{key}", contrib} | contribs]}
-            end)
-
-          cos_sim =
-            if norm_s_sq > 0 and norm_v_sq > 0,
-              do: dot / (:math.sqrt(norm_s_sq) * :math.sqrt(norm_v_sq)),
-              else: 0.0
-
-          raw_score = Scorer.compute_score(yaml_path, behavior, aggregate)
-          calibrated = :math.log(max(raw_score, 1.0e-300)) - log_baseline
-
-          top_metrics =
-            contributions
-            |> Enum.sort_by(fn {_, c} -> c end)
-            |> Enum.take(5)
-            |> Enum.map(fn {metric, contribution} ->
-              %{metric: to_string(metric), contribution: Float.round(contribution, 4)}
-            end)
-
-          [
-            %{
-              category: category,
-              behavior: behavior,
-              cosine: Float.round(cos_sim, 4),
-              score: Float.round(calibrated, 4),
-              top_metrics: top_metrics
-            }
-          ]
+          scalars = Scorer.scalars_for(yaml_path, behavior)
+
+          if map_size(scalars) == 0 do
+            []
+          else
+            log_baseline = Map.get(behavior_data, "_log_baseline", 0.0) / 1.0
+
+            {dot, norm_s_sq, norm_v_sq, contributions} =
+              Enum.reduce(scalars, {0.0, 0.0, 0.0, []}, fn {{group, key}, scalar},
+                                                           {d, ns, nv, contribs} ->
+                log_m = :math.log(Scorer.get(aggregate, group, key))
+                contrib = scalar * log_m
+
+                {d + contrib, ns + scalar * scalar, nv + log_m * log_m,
+                 [{:"#{group}.#{key}", contrib} | contribs]}
+              end)
+
+            cos_sim =
+              if norm_s_sq > 0 and norm_v_sq > 0,
+                do: dot / (:math.sqrt(norm_s_sq) * :math.sqrt(norm_v_sq)),
+                else: 0.0
+
+            raw_score = Scorer.compute_score(yaml_path, behavior, aggregate)
+            calibrated = :math.log(max(raw_score, 1.0e-300)) - log_baseline
+
+            top_metrics =
+              contributions
+              |> Enum.sort_by(fn {_, c} -> c end)
+              |> Enum.take(5)
+              |> Enum.map(fn {metric, contribution} ->
+                %{metric: to_string(metric), contribution: Float.round(contribution, 4)}
+              end)
+
+            [
+              %{
+                category: category,
+                behavior: behavior,
+                cosine: Float.round(cos_sim, 4),
+                score: Float.round(calibrated, 4),
+                top_metrics: top_metrics
+              }
+            ]
+          end
         end
       end)
     end)
@@ -444,6 +452,22 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
 
   defp deadzone?(ratio), do: ratio >= @deadzone_low and ratio <= @deadzone_high
 
+  # Returns true if the behavior should be included for the given language context.
+  # behavior_langs: the "_languages" list from the YAML ([] = applies to all)
+  # language: single language string from :language opt (nil = no filter)
+  # languages: project language list from :languages opt (nil = no filter)
+  defp behavior_language_applies?(_behavior_langs, nil, nil), do: true
+  defp behavior_language_applies?([], _language, _languages), do: true
+
+  defp behavior_language_applies?(behavior_langs, language, nil) when is_binary(language),
+    do: language in behavior_langs
+
+  defp behavior_language_applies?(behavior_langs, nil, languages) when is_list(languages),
+    do: Enum.any?(behavior_langs, &(&1 in languages))
+
+  defp behavior_language_applies?(behavior_langs, language, languages),
+    do: language in behavior_langs or Enum.any?(behavior_langs, &(&1 in languages))
+
   defp format_yaml(data) do
     lines =
       data
diff --git a/test/codeqa/combined_metrics/sample_runner_test.exs b/test/codeqa/combined_metrics/sample_runner_test.exs
index 84bc4a0..fcf1dc4 100644
--- a/test/codeqa/combined_metrics/sample_runner_test.exs
+++ b/test/codeqa/combined_metrics/sample_runner_test.exs
@@ -51,6 +51,41 @@ defmodule CodeQA.CombinedMetrics.SampleRunnerTest do
     end
   end
 
+  describe "diagnose_aggregate/2 language option" do
+    test "accepts :language option without crashing" do
+      # minimal aggregate — behavior will be scored but most will have no scalars
+      agg = %{}
+      result = SampleRunner.diagnose_aggregate(agg, top: 5, language: "elixir")
+      assert is_list(result)
+    end
+
+    test "accepts :languages option without crashing" do
+      agg = %{}
+      result = SampleRunner.diagnose_aggregate(agg, top: 5, languages: ["elixir", "rust"])
+      assert is_list(result)
+    end
+
+    # NOTE: This test uses `<=` intentionally. Before Task 7 + `mix compile --force`,
+    # all behaviors have empty `_languages` in the compiled cache, so no filtering
+    # occurs and all three counts are equal. The `<=` assertion passes in both
+    # pre- and post-Task-7 states.
+    test "with language option returns subset of unfiltered results" do
+      agg =
+        "priv/combined_metrics/samples/variable_naming/name_is_generic/bad"
+        |> CodeQA.Engine.Collector.collect_files()
+        |> CodeQA.Engine.Analyzer.analyze_codebase()
+        |> get_in(["codebase", "aggregate"])
+
+      all = SampleRunner.diagnose_aggregate(agg, top: 999)
+      elixir_only = SampleRunner.diagnose_aggregate(agg, top: 999, language: "elixir")
+      rust_only = SampleRunner.diagnose_aggregate(agg, top: 999, language: "rust")
+
+      # Filtered sets are subsets (or equal, pre-Task-7) of unfiltered
+      assert length(elixir_only) <= length(all)
+      assert length(rust_only) <= length(all)
+    end
+  end
+
   describe "run/1" do
     test "returns a list of results with required keys", %{results: results} do
       assert is_list(results)

From 4e1262087f0055d216960157f3459b998c2d0af5 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Fri, 20 Mar 2026 13:14:26 +0100
Subject: [PATCH 18/71] fix(combined-metrics): improve
 behavior_language_applies? guards and docs

- Add guard (is_binary/is_list) to catch-all clause of behavior_language_applies?/3
- Add explicit clause for (_, nil, []) to treat empty languages list as "no filter"
- Add comment on the [] catch-all clause clarifying priority semantics
- Document :language and :languages options in diagnose_aggregate/2 @doc

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/combined_metrics/sample_runner.ex | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/lib/codeqa/combined_metrics/sample_runner.ex b/lib/codeqa/combined_metrics/sample_runner.ex
index 3d33c30..9afb513 100644
--- a/lib/codeqa/combined_metrics/sample_runner.ex
+++ b/lib/codeqa/combined_metrics/sample_runner.ex
@@ -260,7 +260,11 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
 
   ## Options
 
-    * `:top` - number of results to return (default 15)
+    * `:top`       - number of results to return (default 15)
+    * `:language`  - single language string for per-file filtering; when set, only
+                     behaviors whose `_languages` list includes this language are scored
+    * `:languages` - list of language strings for project-level filtering; when set, only
+                     behaviors whose `_languages` list overlaps with this list are scored
 
   ## Result shape
 
@@ -457,16 +461,22 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
   # language: single language string from :language opt (nil = no filter)
   # languages: project language list from :languages opt (nil = no filter)
   defp behavior_language_applies?(_behavior_langs, nil, nil), do: true
+
+  # Empty behavior_langs means "applies to all languages" — always include.
+  # This clause takes priority over all non-nil filter cases.
   defp behavior_language_applies?([], _language, _languages), do: true
 
+  defp behavior_language_applies?(_behavior_langs, nil, []), do: true
+
   defp behavior_language_applies?(behavior_langs, language, nil) when is_binary(language),
     do: language in behavior_langs
 
   defp behavior_language_applies?(behavior_langs, nil, languages) when is_list(languages),
     do: Enum.any?(behavior_langs, &(&1 in languages))
 
-  defp behavior_language_applies?(behavior_langs, language, languages),
-    do: language in behavior_langs or Enum.any?(behavior_langs, &(&1 in languages))
+  defp behavior_language_applies?(behavior_langs, language, languages)
+       when is_binary(language) and is_list(languages),
+       do: language in behavior_langs or Enum.any?(behavior_langs, &(&1 in languages))
 
   defp format_yaml(data) do
     lines =

From bca01a2f6978d592480de852a9a9b7ef29a694f3 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Fri, 20 Mar 2026 13:16:29 +0100
Subject: [PATCH 19/71] feat(combined-metrics): filter score_aggregate by
 project languages

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/combined_metrics/sample_runner.ex  | 10 +++++--
 .../combined_metrics/sample_runner_test.exs   | 26 +++++++++++++++++++
 2 files changed, 34 insertions(+), 2 deletions(-)

diff --git a/lib/codeqa/combined_metrics/sample_runner.ex b/lib/codeqa/combined_metrics/sample_runner.ex
index 9afb513..bcf3375 100644
--- a/lib/codeqa/combined_metrics/sample_runner.ex
+++ b/lib/codeqa/combined_metrics/sample_runner.ex
@@ -216,8 +216,10 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
         ...
       ]
   """
-  @spec score_aggregate(map()) :: [map()]
-  def score_aggregate(aggregate) do
+  @spec score_aggregate(map(), keyword()) :: [map()]
+  def score_aggregate(aggregate, opts \\ []) do
+    languages = Keyword.get(opts, :languages)
+
     Scorer.all_yamls()
     |> Enum.sort_by(fn {path, _} -> path end)
     |> Enum.map(fn {yaml_path, data} ->
@@ -226,6 +228,10 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
       behaviors =
         data
         |> Enum.filter(fn {_k, v} -> is_map(v) end)
+        |> Enum.reject(fn {_behavior, behavior_data} ->
+          behavior_langs = Map.get(behavior_data, "_languages", [])
+          not behavior_language_applies?(behavior_langs, nil, languages)
+        end)
         |> Enum.map(fn {behavior, behavior_data} ->
           log_baseline = Map.get(behavior_data, "_log_baseline", 0.0) / 1.0
           raw_score = Scorer.compute_score(yaml_path, behavior, aggregate)
diff --git a/test/codeqa/combined_metrics/sample_runner_test.exs b/test/codeqa/combined_metrics/sample_runner_test.exs
index fcf1dc4..8332d3f 100644
--- a/test/codeqa/combined_metrics/sample_runner_test.exs
+++ b/test/codeqa/combined_metrics/sample_runner_test.exs
@@ -86,6 +86,32 @@ defmodule CodeQA.CombinedMetrics.SampleRunnerTest do
     end
   end
 
+  describe "score_aggregate/2 language filtering" do
+    test "accepts :languages option without crashing" do
+      result = SampleRunner.score_aggregate(%{}, languages: ["elixir"])
+      assert is_list(result)
+      assert Enum.all?(result, &Map.has_key?(&1, :behaviors))
+    end
+
+    test "with languages option returns fewer behaviors than unfiltered" do
+      agg =
+        "priv/combined_metrics/samples/variable_naming/name_is_generic/bad"
+        |> CodeQA.Engine.Collector.collect_files()
+        |> CodeQA.Engine.Analyzer.analyze_codebase()
+        |> get_in(["codebase", "aggregate"])
+
+      all_count = SampleRunner.score_aggregate(agg) |> Enum.flat_map(& &1.behaviors) |> length()
+
+      elixir_count =
+        SampleRunner.score_aggregate(agg, languages: ["elixir"])
+        |> Enum.flat_map(& &1.behaviors)
+        |> length()
+
+      # elixir-only project sees fewer or equal behaviors
+      assert elixir_count <= all_count
+    end
+  end
+
   describe "run/1" do
     test "returns a list of results with required keys", %{results: results} do
       assert is_list(results)

From a9f017b266c62eee221bfd690e1cb3990ceecc91 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Fri, 20 Mar 2026 13:18:19 +0100
Subject: [PATCH 20/71] feat(file-scorer): detect file language and filter
 behaviors accordingly

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/combined_metrics/file_scorer.ex    |  3 ++-
 .../combined_metrics/file_scorer_test.exs     | 27 +++++++++++++++++++
 2 files changed, 29 insertions(+), 1 deletion(-)

diff --git a/lib/codeqa/combined_metrics/file_scorer.ex b/lib/codeqa/combined_metrics/file_scorer.ex
index 368d163..4ea54b4 100644
--- a/lib/codeqa/combined_metrics/file_scorer.ex
+++ b/lib/codeqa/combined_metrics/file_scorer.ex
@@ -65,11 +65,12 @@ defmodule CodeQA.CombinedMetrics.FileScorer do
     end)
     |> Enum.reduce(%{}, fn {path, file_data}, acc ->
       top_nodes = CodeQA.HealthReport.Grader.top_3_nodes(Map.get(file_data, "nodes"))
+      language = CodeQA.Language.detect(path).name()
 
       file_data
       |> Map.get("metrics", %{})
       |> file_to_aggregate()
-      |> SampleRunner.diagnose_aggregate(top: 99_999)
+      |> SampleRunner.diagnose_aggregate(top: 99_999, language: language)
       |> Enum.reduce(acc, fn %{
                                category: category,
                                behavior: behavior,
diff --git a/test/codeqa/combined_metrics/file_scorer_test.exs b/test/codeqa/combined_metrics/file_scorer_test.exs
index b863693..c280cd3 100644
--- a/test/codeqa/combined_metrics/file_scorer_test.exs
+++ b/test/codeqa/combined_metrics/file_scorer_test.exs
@@ -188,6 +188,33 @@ defmodule CodeQA.CombinedMetrics.FileScorerTest do
     end
   end
 
+  describe "worst_files_per_behavior/2 language filtering" do
+    test "does not include rust-only behaviors when scoring an elixir file" do
+      fake_metrics = %{"halstead" => %{"tokens" => 100.0, "difficulty" => 5.0}}
+      files_map = %{"lib/foo.ex" => %{"metrics" => fake_metrics}}
+
+      results = FileScorer.worst_files_per_behavior(files_map)
+
+      # Any behavior that only applies to rust should not have this .ex file in results
+      rust_only_keys =
+        Enum.filter(results, fn {key, entries} ->
+          [cat, beh] = String.split(key, ".", parts: 2)
+          yaml_path = "priv/combined_metrics/#{cat}.yml"
+
+          case YamlElixir.read_from_file(yaml_path) do
+            {:ok, data} ->
+              langs = get_in(data, [beh, "_languages"]) || []
+              langs != [] and "elixir" not in langs and entries != []
+
+            _ ->
+              false
+          end
+        end)
+
+      assert rust_only_keys == []
+    end
+  end
+
   # Build a realistic files_map using a real project file so diagnose_aggregate
   # has real metric values to work with. We use a small fixed map rather than
   # running the full analyzer to keep tests fast.

From 5556a304ac3608b30e1d2d1560683cdffca59cfe Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Fri, 20 Mar 2026 13:22:36 +0100
Subject: [PATCH 21/71] feat: thread project languages through all
 codebase-level scoring call sites

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../block_impact/refactoring_potentials.ex    | 14 +++++++------
 lib/codeqa/block_impact_analyzer.ex           | 21 ++++++++++++++++---
 lib/codeqa/diagnostics.ex                     | 18 +++++++++++++---
 lib/codeqa/health_report.ex                   | 13 ++++++++++--
 lib/codeqa/health_report/grader.ex            |  8 ++++---
 .../combined_metrics/sample_runner_test.exs   |  7 +++++++
 6 files changed, 64 insertions(+), 17 deletions(-)

diff --git a/lib/codeqa/block_impact/refactoring_potentials.ex b/lib/codeqa/block_impact/refactoring_potentials.ex
index 34ca366..1c0c89d 100644
--- a/lib/codeqa/block_impact/refactoring_potentials.ex
+++ b/lib/codeqa/block_impact/refactoring_potentials.ex
@@ -40,9 +40,11 @@ defmodule CodeQA.BlockImpact.RefactoringPotentials do
         opts \\ []
       ) do
     top_n = Keyword.get(opts, :top, 3)
+    language = Keyword.get(opts, :language)
+    languages = Keyword.get(opts, :languages)
 
-    file_delta = compute_file_delta(baseline_file_cosines, without_file_metrics)
-    codebase_delta = compute_codebase_delta(baseline_codebase_cosines, without_codebase_agg)
+    file_delta = compute_file_delta(baseline_file_cosines, without_file_metrics, language)
+    codebase_delta = compute_codebase_delta(baseline_codebase_cosines, without_codebase_agg, languages)
 
     all_keys = Enum.uniq(Map.keys(file_delta) ++ Map.keys(codebase_delta))
 
@@ -64,14 +66,14 @@ defmodule CodeQA.BlockImpact.RefactoringPotentials do
     end)
   end
 
-  defp compute_file_delta(baseline_cosines, without_metrics) do
+  defp compute_file_delta(baseline_cosines, without_metrics, language) do
     without_agg = FileScorer.file_to_aggregate(without_metrics)
-    without_cosines = SampleRunner.diagnose_aggregate(without_agg, top: 99_999)
+    without_cosines = SampleRunner.diagnose_aggregate(without_agg, top: 99_999, language: language)
     cosines_to_delta(baseline_cosines, without_cosines)
   end
 
-  defp compute_codebase_delta(baseline_cosines, without_agg) do
-    without_cosines = SampleRunner.diagnose_aggregate(without_agg, top: 99_999)
+  defp compute_codebase_delta(baseline_cosines, without_agg, languages) do
+    without_cosines = SampleRunner.diagnose_aggregate(without_agg, top: 99_999, languages: languages)
     cosines_to_delta(baseline_cosines, without_cosines)
   end
 
diff --git a/lib/codeqa/block_impact_analyzer.ex b/lib/codeqa/block_impact_analyzer.ex
index f4b17e4..37578b3 100644
--- a/lib/codeqa/block_impact_analyzer.ex
+++ b/lib/codeqa/block_impact_analyzer.ex
@@ -41,9 +41,10 @@ defmodule CodeQA.BlockImpactAnalyzer do
     workers = Keyword.get(opts, :workers, System.schedulers_online())
 
     baseline_codebase_agg = Analyzer.analyze_codebase_aggregate(files_map)
+    project_langs = project_languages(files_map)
 
     baseline_codebase_cosines =
-      SampleRunner.diagnose_aggregate(baseline_codebase_agg, top: 99_999)
+      SampleRunner.diagnose_aggregate(baseline_codebase_agg, top: 99_999, languages: project_langs)
 
     file_results = pipeline_result["files"]
 
@@ -90,7 +91,8 @@ defmodule CodeQA.BlockImpactAnalyzer do
       top_level_nodes = Parser.detect_blocks(root_tokens, Unknown)
 
       baseline_file_agg = FileScorer.file_to_aggregate(baseline_file_metrics)
-      baseline_file_cosines = SampleRunner.diagnose_aggregate(baseline_file_agg, top: 99_999)
+      language = CodeQA.Language.detect(path).name()
+      baseline_file_cosines = SampleRunner.diagnose_aggregate(baseline_file_agg, top: 99_999, language: language)
 
       top_level_nodes
       |> Enum.map(fn node ->
@@ -181,12 +183,25 @@ defmodule CodeQA.BlockImpactAnalyzer do
       |> Map.put(path, %{"metrics" => without_file_metrics})
       |> Analyzer.aggregate_file_metrics()
 
+    language = CodeQA.Language.detect(path).name()
+    project_langs = project_languages(file_results)
+
     RefactoringPotentials.compute(
       baseline_file_cosines,
       without_file_metrics,
       baseline_codebase_cosines,
       without_codebase_agg,
-      top: nodes_top
+      top: nodes_top,
+      language: language,
+      languages: project_langs
     )
   end
+
+  defp project_languages(files_map) do
+    files_map
+    |> Map.keys()
+    |> Enum.map(&CodeQA.Language.detect(&1).name())
+    |> Enum.reject(&(&1 == "unknown"))
+    |> Enum.uniq()
+  end
 end
diff --git a/lib/codeqa/diagnostics.ex b/lib/codeqa/diagnostics.ex
index 6b3956e..6f4c0d3 100644
--- a/lib/codeqa/diagnostics.ex
+++ b/lib/codeqa/diagnostics.ex
@@ -36,8 +36,11 @@ defmodule CodeQA.Diagnostics do
 
   defp run_aggregate(result, top, format) do
     aggregate = get_in(result, ["codebase", "aggregate"])
-    issues_task = Task.async(fn -> SampleRunner.diagnose_aggregate(aggregate, top: top) end)
-    categories_task = Task.async(fn -> SampleRunner.score_aggregate(aggregate) end)
+    files = Map.get(result, "files", %{})
+    project_langs = project_languages(files)
+
+    issues_task = Task.async(fn -> SampleRunner.diagnose_aggregate(aggregate, top: top, languages: project_langs) end)
+    categories_task = Task.async(fn -> SampleRunner.score_aggregate(aggregate, languages: project_langs) end)
     issues = Task.await(issues_task)
     categories = Task.await(categories_task)
 
@@ -60,7 +63,8 @@ defmodule CodeQA.Diagnostics do
       Map.new(files, fn {file_path, file_data} ->
         metrics = Map.get(file_data, "metrics", %{})
         file_agg = FileScorer.file_to_aggregate(metrics)
-        diagnoses = SampleRunner.diagnose_aggregate(file_agg, top: top)
+        language = CodeQA.Language.detect(file_path).name()
+        diagnoses = SampleRunner.diagnose_aggregate(file_agg, top: top, language: language)
         {file_path, diagnoses}
       end)
 
@@ -94,6 +98,14 @@ defmodule CodeQA.Diagnostics do
     end
   end
 
+  defp project_languages(files_map) do
+    files_map
+    |> Map.keys()
+    |> Enum.map(&CodeQA.Language.detect(&1).name())
+    |> Enum.reject(&(&1 == "unknown"))
+    |> Enum.uniq()
+  end
+
   defp issues_table(issues) do
     rows =
       Enum.map(issues, fn %{category: cat, behavior: beh, cosine: cosine, score: score} ->
diff --git a/lib/codeqa/health_report.ex b/lib/codeqa/health_report.ex
index 4a521e2..24b3365 100644
--- a/lib/codeqa/health_report.ex
+++ b/lib/codeqa/health_report.ex
@@ -20,6 +20,7 @@ defmodule CodeQA.HealthReport do
 
     aggregate = get_in(analysis_results, ["codebase", "aggregate"]) || %{}
     files = Map.get(analysis_results, "files", %{})
+    project_langs = project_languages(files)
 
     threshold_grades =
       categories
@@ -43,7 +44,7 @@ defmodule CodeQA.HealthReport do
 
     worst_files_map = FileScorer.worst_files_per_behavior(files, combined_top: combined_top)
 
-    cosine_grades = Grader.grade_cosine_categories(aggregate, worst_files_map, grade_scale)
+    cosine_grades = Grader.grade_cosine_categories(aggregate, worst_files_map, grade_scale, project_langs)
 
     # TODO(option-c): a unified flat issues list would replace the current per-category worst offenders loop; all category results would be flattened, deduplicated by file+line, and re-ranked by a cross-category severity score before rendering.
     all_categories =
@@ -56,7 +57,7 @@ defmodule CodeQA.HealthReport do
 
     metadata = build_metadata(analysis_results)
 
-    top_issues = SampleRunner.diagnose_aggregate(aggregate, top: 10)
+    top_issues = SampleRunner.diagnose_aggregate(aggregate, top: 10, languages: project_langs)
 
     %{
       metadata: metadata,
@@ -82,6 +83,14 @@ defmodule CodeQA.HealthReport do
     }
   end
 
+  defp project_languages(files_map) do
+    files_map
+    |> Map.keys()
+    |> Enum.map(&CodeQA.Language.detect(&1).name())
+    |> Enum.reject(&(&1 == "unknown"))
+    |> Enum.uniq()
+  end
+
   defp build_category_summary(%{type: :cosine}), do: ""
 
   defp build_category_summary(graded) do
diff --git a/lib/codeqa/health_report/grader.ex b/lib/codeqa/health_report/grader.ex
index 94259d6..20413c9 100644
--- a/lib/codeqa/health_report/grader.ex
+++ b/lib/codeqa/health_report/grader.ex
@@ -234,17 +234,19 @@ defmodule CodeQA.HealthReport.Grader do
   @spec grade_cosine_categories(
           aggregate :: map(),
           worst_files :: %{String.t() => [map()]},
-          grade_scale :: [{number(), String.t()}]
+          grade_scale :: [{number(), String.t()}],
+          languages :: [String.t()]
         ) :: [map()]
   def grade_cosine_categories(
         aggregate,
         worst_files,
-        scale \\ CodeQA.HealthReport.Categories.default_grade_scale()
+        scale \\ CodeQA.HealthReport.Categories.default_grade_scale(),
+        languages \\ []
       ) do
     threshold = CodeQA.Config.cosine_significance_threshold()
 
     aggregate
-    |> SampleRunner.diagnose_aggregate(top: 99_999)
+    |> SampleRunner.diagnose_aggregate(top: 99_999, languages: languages)
     |> Enum.group_by(& &1.category)
     |> Enum.map(fn {category, behaviors} ->
       behavior_entries =
diff --git a/test/codeqa/combined_metrics/sample_runner_test.exs b/test/codeqa/combined_metrics/sample_runner_test.exs
index 8332d3f..103b805 100644
--- a/test/codeqa/combined_metrics/sample_runner_test.exs
+++ b/test/codeqa/combined_metrics/sample_runner_test.exs
@@ -112,6 +112,13 @@ defmodule CodeQA.CombinedMetrics.SampleRunnerTest do
     end
   end
 
+  describe "grade_cosine_categories/4 languages wiring" do
+    test "accepts languages argument" do
+      result = CodeQA.HealthReport.Grader.grade_cosine_categories(%{}, %{}, [], ["elixir"])
+      assert is_list(result)
+    end
+  end
+
   describe "run/1" do
     test "returns a list of results with required keys", %{results: results} do
       assert is_list(results)

From d8d448ac6fe669c193cb23f8e57865295fb077f8 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Fri, 20 Mar 2026 13:41:00 +0100
Subject: [PATCH 22/71] fix(block-impact-analyzer): avoid redundant language
 detection, clarify project_languages param

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../block_impact/refactoring_potentials.ex    | 13 +++++++--
 lib/codeqa/block_impact_analyzer.ex           | 29 ++++++++++++-------
 lib/codeqa/diagnostics.ex                     | 10 +++++--
 lib/codeqa/health_report.ex                   |  3 +-
 4 files changed, 39 insertions(+), 16 deletions(-)

diff --git a/lib/codeqa/block_impact/refactoring_potentials.ex b/lib/codeqa/block_impact/refactoring_potentials.ex
index 1c0c89d..092d97b 100644
--- a/lib/codeqa/block_impact/refactoring_potentials.ex
+++ b/lib/codeqa/block_impact/refactoring_potentials.ex
@@ -44,7 +44,9 @@ defmodule CodeQA.BlockImpact.RefactoringPotentials do
     languages = Keyword.get(opts, :languages)
 
     file_delta = compute_file_delta(baseline_file_cosines, without_file_metrics, language)
-    codebase_delta = compute_codebase_delta(baseline_codebase_cosines, without_codebase_agg, languages)
+
+    codebase_delta =
+      compute_codebase_delta(baseline_codebase_cosines, without_codebase_agg, languages)
 
     all_keys = Enum.uniq(Map.keys(file_delta) ++ Map.keys(codebase_delta))
 
@@ -68,12 +70,17 @@ defmodule CodeQA.BlockImpact.RefactoringPotentials do
 
   defp compute_file_delta(baseline_cosines, without_metrics, language) do
     without_agg = FileScorer.file_to_aggregate(without_metrics)
-    without_cosines = SampleRunner.diagnose_aggregate(without_agg, top: 99_999, language: language)
+
+    without_cosines =
+      SampleRunner.diagnose_aggregate(without_agg, top: 99_999, language: language)
+
     cosines_to_delta(baseline_cosines, without_cosines)
   end
 
   defp compute_codebase_delta(baseline_cosines, without_agg, languages) do
-    without_cosines = SampleRunner.diagnose_aggregate(without_agg, top: 99_999, languages: languages)
+    without_cosines =
+      SampleRunner.diagnose_aggregate(without_agg, top: 99_999, languages: languages)
+
     cosines_to_delta(baseline_cosines, without_cosines)
   end
 
diff --git a/lib/codeqa/block_impact_analyzer.ex b/lib/codeqa/block_impact_analyzer.ex
index 37578b3..d743184 100644
--- a/lib/codeqa/block_impact_analyzer.ex
+++ b/lib/codeqa/block_impact_analyzer.ex
@@ -44,7 +44,10 @@ defmodule CodeQA.BlockImpactAnalyzer do
     project_langs = project_languages(files_map)
 
     baseline_codebase_cosines =
-      SampleRunner.diagnose_aggregate(baseline_codebase_agg, top: 99_999, languages: project_langs)
+      SampleRunner.diagnose_aggregate(baseline_codebase_agg,
+        top: 99_999,
+        languages: project_langs
+      )
 
     file_results = pipeline_result["files"]
 
@@ -92,7 +95,9 @@ defmodule CodeQA.BlockImpactAnalyzer do
 
       baseline_file_agg = FileScorer.file_to_aggregate(baseline_file_metrics)
       language = CodeQA.Language.detect(path).name()
-      baseline_file_cosines = SampleRunner.diagnose_aggregate(baseline_file_agg, top: 99_999, language: language)
+
+      baseline_file_cosines =
+        SampleRunner.diagnose_aggregate(baseline_file_agg, top: 99_999, language: language)
 
       top_level_nodes
       |> Enum.map(fn node ->
@@ -104,7 +109,8 @@ defmodule CodeQA.BlockImpactAnalyzer do
           baseline_file_cosines,
           file_results,
           baseline_codebase_cosines,
-          nodes_top
+          nodes_top,
+          language
         )
       end)
       |> Enum.sort_by(fn n -> {n["start_line"], n["column_start"]} end)
@@ -119,7 +125,8 @@ defmodule CodeQA.BlockImpactAnalyzer do
          baseline_file_cosines,
          file_results,
          baseline_codebase_cosines,
-         nodes_top
+         nodes_top,
+         language
        ) do
     potentials =
       if length(node.tokens) < @min_tokens do
@@ -132,7 +139,8 @@ defmodule CodeQA.BlockImpactAnalyzer do
           baseline_file_cosines,
           file_results,
           baseline_codebase_cosines,
-          nodes_top
+          nodes_top,
+          language
         )
       end
 
@@ -147,7 +155,8 @@ defmodule CodeQA.BlockImpactAnalyzer do
           baseline_file_cosines,
           file_results,
           baseline_codebase_cosines,
-          nodes_top
+          nodes_top,
+          language
         )
       end)
       |> Enum.sort_by(fn n -> {n["start_line"], n["column_start"]} end)
@@ -173,7 +182,8 @@ defmodule CodeQA.BlockImpactAnalyzer do
          baseline_file_cosines,
          file_results,
          baseline_codebase_cosines,
-         nodes_top
+         nodes_top,
+         language
        ) do
     reconstructed = FileImpact.reconstruct_without(root_tokens, node)
     without_file_metrics = Analyzer.analyze_file(path, reconstructed)
@@ -183,7 +193,6 @@ defmodule CodeQA.BlockImpactAnalyzer do
       |> Map.put(path, %{"metrics" => without_file_metrics})
       |> Analyzer.aggregate_file_metrics()
 
-    language = CodeQA.Language.detect(path).name()
     project_langs = project_languages(file_results)
 
     RefactoringPotentials.compute(
@@ -197,8 +206,8 @@ defmodule CodeQA.BlockImpactAnalyzer do
     )
   end
 
-  defp project_languages(files_map) do
-    files_map
+  defp project_languages(path_keyed_map) do
+    path_keyed_map
     |> Map.keys()
     |> Enum.map(&CodeQA.Language.detect(&1).name())
     |> Enum.reject(&(&1 == "unknown"))
diff --git a/lib/codeqa/diagnostics.ex b/lib/codeqa/diagnostics.ex
index 6f4c0d3..d086e44 100644
--- a/lib/codeqa/diagnostics.ex
+++ b/lib/codeqa/diagnostics.ex
@@ -39,8 +39,14 @@ defmodule CodeQA.Diagnostics do
     files = Map.get(result, "files", %{})
     project_langs = project_languages(files)
 
-    issues_task = Task.async(fn -> SampleRunner.diagnose_aggregate(aggregate, top: top, languages: project_langs) end)
-    categories_task = Task.async(fn -> SampleRunner.score_aggregate(aggregate, languages: project_langs) end)
+    issues_task =
+      Task.async(fn ->
+        SampleRunner.diagnose_aggregate(aggregate, top: top, languages: project_langs)
+      end)
+
+    categories_task =
+      Task.async(fn -> SampleRunner.score_aggregate(aggregate, languages: project_langs) end)
+
     issues = Task.await(issues_task)
     categories = Task.await(categories_task)
 
diff --git a/lib/codeqa/health_report.ex b/lib/codeqa/health_report.ex
index 24b3365..6b5c4d6 100644
--- a/lib/codeqa/health_report.ex
+++ b/lib/codeqa/health_report.ex
@@ -44,7 +44,8 @@ defmodule CodeQA.HealthReport do
 
     worst_files_map = FileScorer.worst_files_per_behavior(files, combined_top: combined_top)
 
-    cosine_grades = Grader.grade_cosine_categories(aggregate, worst_files_map, grade_scale, project_langs)
+    cosine_grades =
+      Grader.grade_cosine_categories(aggregate, worst_files_map, grade_scale, project_langs)
 
     # TODO(option-c): a unified flat issues list would replace the current per-category worst offenders loop; all category results would be flattened, deduplicated by file+line, and re-ranked by a cross-category severity score before rendering.
     all_categories =

From 1e5718712b6f695c537770846d3c1c70642e2346 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Fri, 20 Mar 2026 13:43:16 +0100
Subject: [PATCH 23/71] feat(cli): add --apply-languages flag to sample_report
 mix task

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/mix/tasks/codeqa/sample_report.ex | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/lib/mix/tasks/codeqa/sample_report.ex b/lib/mix/tasks/codeqa/sample_report.ex
index 0246777..e4a1ba5 100644
--- a/lib/mix/tasks/codeqa/sample_report.ex
+++ b/lib/mix/tasks/codeqa/sample_report.ex
@@ -11,6 +11,8 @@ defmodule Mix.Tasks.Codeqa.SampleReport do
       mix codeqa.sample_report --verbose
       mix codeqa.sample_report --output results.json
       mix codeqa.sample_report --apply-scalars
+      mix codeqa.sample_report --apply-languages
+      mix codeqa.sample_report --apply-languages --category variable_naming
       mix codeqa.sample_report --file path/to/file.ex
 
   A ratio ≥ 2x means the formula meaningfully separates good from bad code.
@@ -31,6 +33,7 @@ defmodule Mix.Tasks.Codeqa.SampleReport do
     output: :string,
     report: :string,
     apply_scalars: :boolean,
+    apply_languages: :boolean,
     file: :string,
     top: :integer
   ]
@@ -62,6 +65,15 @@ defmodule Mix.Tasks.Codeqa.SampleReport do
       Enum.each(stats, &print_scalar_stats/1)
     end
 
+    if opts[:apply_languages] do
+      stats = CodeQA.CombinedMetrics.SampleRunner.apply_languages(opts)
+      IO.puts("\nApplied language coverage to YAML configs:")
+
+      Enum.each(stats, fn %{category: cat, behaviors_with_languages: n} ->
+        IO.puts("  #{cat}: #{n} behaviors with language coverage")
+      end)
+    end
+
     if path = opts[:file] do
       print_file_scores(path, opts)
     end

From 76fc86cf769a94c5eb1c666c959aeb284a72ac88 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Fri, 20 Mar 2026 13:45:57 +0100
Subject: [PATCH 24/71] chore(combined-metrics): populate _languages coverage
 from samples

---
 priv/combined_metrics/code_smells.yml          |  5 +++++
 priv/combined_metrics/consistency.yml          |  4 ++++
 priv/combined_metrics/dependencies.yml         |  3 +++
 priv/combined_metrics/documentation.yml        |  6 ++++++
 priv/combined_metrics/error_handling.yml       |  3 +++
 priv/combined_metrics/file_structure.yml       |  6 ++++++
 priv/combined_metrics/function_design.yml      |  9 +++++++++
 priv/combined_metrics/naming_conventions.yml   |  5 +++++
 priv/combined_metrics/scope_and_assignment.yml |  6 ++++++
 priv/combined_metrics/testing.yml              |  4 ++++
 priv/combined_metrics/type_and_value.yml       |  5 +++++
 priv/combined_metrics/variable_naming.yml      | 14 ++++++++++++++
 12 files changed, 70 insertions(+)

diff --git a/priv/combined_metrics/code_smells.yml b/priv/combined_metrics/code_smells.yml
index d8fe1b8..6be13fa 100644
--- a/priv/combined_metrics/code_smells.yml
+++ b/priv/combined_metrics/code_smells.yml
@@ -1,6 +1,7 @@
 consistent_string_quote_style:
   _doc: "Files should use a single, consistent string quoting style throughout."
   _fix_hint: "Use a single quote style (e.g., double quotes) consistently throughout the file"
+  _languages: [elixir]
   _log_baseline: -18.9505
   branching:
     mean_branching_density: 0.0243
@@ -98,6 +99,7 @@ consistent_string_quote_style:
 no_dead_code_after_return:
   _doc: "There should be no unreachable statements after a return or early exit."
   _fix_hint: "Remove unreachable statements after return/raise/exit — they can never execute"
+  _languages: [elixir]
   _log_baseline: -57.2281
   branching:
     mean_branch_count: -2.0000
@@ -204,6 +206,7 @@ no_dead_code_after_return:
 no_debug_print_statements:
   _doc: "Debug output (`console.log`, `IO.inspect`, `fmt.Println`) must not be left in committed code."
   _fix_hint: "Remove IO.inspect/IO.puts/console.log debug output — use Logger or remove entirely"
+  _languages: [elixir]
   _log_baseline: -86.5160
   branching:
     mean_branch_count: -0.3540
@@ -314,6 +317,7 @@ no_debug_print_statements:
 no_fixme_comments:
   _doc: "FIXME, XXX, and HACK comments indicate known problems that should be resolved before merging."
   _fix_hint: "Resolve FIXME/XXX/HACK comments before merging — they indicate known unresolved issues"
+  _languages: [elixir]
   _log_baseline: -2.1522
   branching:
     mean_branch_count: 0.1755
@@ -428,6 +432,7 @@ no_fixme_comments:
 no_nested_ternary:
   _doc: "Nested conditional expressions (ternary-within-ternary) are harder to read than a plain if-else."
   _fix_hint: "Replace nested ternary/conditional expressions with if-else blocks or pattern matching"
+  _languages: [elixir]
   _log_baseline: 7.2208
   branching:
     mean_branch_count: -0.5662
diff --git a/priv/combined_metrics/consistency.yml b/priv/combined_metrics/consistency.yml
index 8dbd172..426e360 100644
--- a/priv/combined_metrics/consistency.yml
+++ b/priv/combined_metrics/consistency.yml
@@ -1,6 +1,7 @@
 consistent_casing_within_file:
   _doc: "A file should use one naming convention throughout — no mixing of camelCase and snake_case for the same kind of identifier."
   _fix_hint: "Pick one casing convention (snake_case or camelCase) and apply it uniformly"
+  _languages: [elixir]
   _log_baseline: -2.4622
   brevity:
     mean_sample_size: -0.0471
@@ -60,6 +61,7 @@ consistent_casing_within_file:
 consistent_error_return_shape:
   _doc: "All functions in a module should return errors in the same shape — mixed `nil`, `false`, and `{:error, _}` returns are confusing."
   _fix_hint: "Use a single error return format (e.g., {:error, reason}) consistently throughout"
+  _languages: [elixir]
   _log_baseline: 31.6243
   branching:
     mean_branch_count: -0.2178
@@ -157,6 +159,7 @@ consistent_error_return_shape:
 consistent_function_style:
   _doc: "A module should not mix one-liner and multi-clause function definitions for the same concern."
   _fix_hint: "Use a consistent function definition style — all def or all defp, one-liner or block form"
+  _languages: [elixir]
   _log_baseline: -2.0498
   branching:
     mean_branch_count: -0.1610
@@ -251,6 +254,7 @@ consistent_function_style:
 same_concept_same_name:
   _doc: "The same domain concept should use the same name throughout a file — mixing `user`, `usr`, and `u` for the same thing harms readability."
   _fix_hint: "Use the same name for the same concept everywhere — avoid synonyms like user/account/member"
+  _languages: [elixir]
   _log_baseline: -10.7039
   brevity:
     mean_sample_size: -1.3837
diff --git a/priv/combined_metrics/dependencies.yml b/priv/combined_metrics/dependencies.yml
index 000ecbf..fbc3591 100644
--- a/priv/combined_metrics/dependencies.yml
+++ b/priv/combined_metrics/dependencies.yml
@@ -1,6 +1,7 @@
 import_count_under_10:
   _doc: "Files should import fewer than 10 modules; high import counts signal excessive coupling."
   _fix_hint: "Reduce imports — split large modules or use fully-qualified names for rarely-used deps"
+  _languages: [elixir]
   _log_baseline: 7.0687
   branching:
     mean_branch_count: 0.2110
@@ -115,6 +116,7 @@ import_count_under_10:
 low_coupling:
   _doc: "Modules should depend on few external symbols — a low unique-operand count relative to total is a proxy for tight coupling."
   _fix_hint: "Reduce dependencies between modules — introduce interfaces or narrow the public API"
+  _languages: [elixir]
   _log_baseline: -38.4249
   branching:
     mean_branch_count: 0.0745
@@ -226,6 +228,7 @@ low_coupling:
 no_wildcard_imports:
   _doc: "Wildcard imports (`import *`, `using Module`) pollute the local namespace and hide dependencies."
   _fix_hint: "Replace wildcard imports with explicit named imports for clarity and reduced scope pollution"
+  _languages: [elixir]
   _log_baseline: -9.4788
   branching:
     mean_branching_density: 0.0249
diff --git a/priv/combined_metrics/documentation.yml b/priv/combined_metrics/documentation.yml
index 75b19fd..66ca037 100644
--- a/priv/combined_metrics/documentation.yml
+++ b/priv/combined_metrics/documentation.yml
@@ -1,6 +1,7 @@
 docstring_is_nonempty:
   _doc: "Docstrings must contain meaningful content, not just a placeholder or empty string."
   _fix_hint: "Replace placeholder docstrings with a real description of what the function does"
+  _languages: [elixir]
   _log_baseline: 29.4288
   branching:
     mean_branch_count: 0.3089
@@ -112,6 +113,7 @@ docstring_is_nonempty:
 file_has_license_header:
   _doc: "Source files should begin with a license or copyright header."
   _fix_hint: "Add a license header comment at the top of the file"
+  _languages: [elixir]
   _log_baseline: 5.7261
   branching:
     mean_branching_density: -0.0081
@@ -200,6 +202,7 @@ file_has_license_header:
 file_has_module_docstring:
   _doc: "Files should have a module-level docstring explaining purpose and usage."
   _fix_hint: "Add a @moduledoc string describing the module's purpose"
+  _languages: [elixir]
   _log_baseline: 24.2268
   branching:
     mean_branch_count: 0.3854
@@ -304,6 +307,7 @@ file_has_module_docstring:
 file_has_no_commented_out_code:
   _doc: "Files should not contain commented-out code blocks left from development."
   _fix_hint: "Remove commented-out code — use version control to track deleted code"
+  _languages: [elixir]
   _log_baseline: -8.1616
   branching:
     mean_branching_density: 0.0368
@@ -411,6 +415,7 @@ file_has_no_commented_out_code:
 function_has_docstring:
   _doc: "Public functions should have a docstring describing behaviour, params, and return value."
   _fix_hint: "Add @doc strings to public functions describing parameters, return value, and purpose"
+  _languages: [elixir]
   _log_baseline: 43.0440
   branching:
     mean_branch_count: 0.5279
@@ -529,6 +534,7 @@ function_has_docstring:
 function_todo_comment_in_body:
   _doc: "Functions should not contain TODO/FIXME comments indicating unfinished work."
   _fix_hint: "Resolve or extract TODO comments — create a tracked issue instead of leaving them inline"
+  _languages: [elixir]
   _log_baseline: 7.0511
   branching:
     mean_branch_count: -0.0287
diff --git a/priv/combined_metrics/error_handling.yml b/priv/combined_metrics/error_handling.yml
index 1398a3d..a0b8b49 100644
--- a/priv/combined_metrics/error_handling.yml
+++ b/priv/combined_metrics/error_handling.yml
@@ -1,6 +1,7 @@
 does_not_swallow_errors:
   _doc: "Errors must be handled or re-raised — empty rescue/catch blocks silently hide failures."
   _fix_hint: "Propagate or log errors — do not silently discard {:error, _} tuples or rescue clauses"
+  _languages: [elixir]
   _log_baseline: 87.3594
   branching:
     mean_branch_count: -0.1041
@@ -111,6 +112,7 @@ does_not_swallow_errors:
 error_message_is_descriptive:
   _doc: "Error values should carry a meaningful message, not just a bare atom or empty string."
   _fix_hint: "Include context in error messages — describe what failed, not just that it failed"
+  _languages: [elixir]
   _log_baseline: 52.7594
   branching:
     mean_branch_count: 0.0664
@@ -215,6 +217,7 @@ error_message_is_descriptive:
 returns_typed_error:
   _doc: "Functions should signal failure via a typed return (e.g. `{:error, reason}`) rather than returning `nil` or `false`."
   _fix_hint: "Return typed errors like {:error, :not_found} instead of bare :error or nil"
+  _languages: [elixir]
   _log_baseline: 208.7673
   branching:
     mean_branch_count: -0.2092
diff --git a/priv/combined_metrics/file_structure.yml b/priv/combined_metrics/file_structure.yml
index 19418d4..73376ce 100644
--- a/priv/combined_metrics/file_structure.yml
+++ b/priv/combined_metrics/file_structure.yml
@@ -1,6 +1,7 @@
 has_consistent_indentation:
   _doc: "Files should use a single, consistent indentation style with no mixed tabs and spaces."
   _fix_hint: "Use a consistent indentation width throughout the file (2 or 4 spaces, not mixed)"
+  _languages: [elixir]
   _log_baseline: -12.7016
   branching:
     mean_branching_density: 0.1994
@@ -37,6 +38,7 @@ has_consistent_indentation:
 line_count_under_300:
   _doc: "Files should be under 300 lines; longer files typically violate single responsibility."
   _fix_hint: "Split large files — extract cohesive groups of functions into separate modules"
+  _languages: [elixir]
   _log_baseline: -49.2655
   branching:
     mean_branch_count: -0.4508
@@ -154,6 +156,7 @@ line_count_under_300:
 line_length_under_120:
   _doc: "Lines should be under 120 characters to avoid horizontal scrolling."
   _fix_hint: "Wrap lines at 80–120 characters — break long expressions into multiple lines"
+  _languages: [elixir]
   _log_baseline: -6.2404
   branching:
     mean_branching_density: -0.1942
@@ -257,6 +260,7 @@ line_length_under_120:
 no_magic_numbers:
   _doc: "Numeric literals should be extracted to named constants rather than used inline."
   _fix_hint: "Replace literal numbers with named constants or module attributes"
+  _languages: [elixir]
   _log_baseline: 107.5222
   branching:
     mean_branch_count: -0.4352
@@ -361,6 +365,7 @@ no_magic_numbers:
 single_responsibility:
   _doc: "Each file should have one primary concern — low complexity spread across few, focused functions."
   _fix_hint: "Split the module — each file should have one primary purpose"
+  _languages: [elixir]
   _log_baseline: -35.4996
   branching:
     mean_branch_count: -0.0678
@@ -475,6 +480,7 @@ single_responsibility:
 uses_standard_indentation_width:
   _doc: "Indentation should use consistent multiples of 2 or 4 spaces throughout the file."
   _fix_hint: "Use the project-standard 2-space indentation throughout"
+  _languages: [elixir]
   _log_baseline: -17.9172
   compression:
     mean_raw_bytes: -0.2512
diff --git a/priv/combined_metrics/function_design.yml b/priv/combined_metrics/function_design.yml
index 6824ebb..b97868b 100644
--- a/priv/combined_metrics/function_design.yml
+++ b/priv/combined_metrics/function_design.yml
@@ -1,6 +1,7 @@
 boolean_function_has_question_mark:
   _doc: "Functions returning a boolean should end with `?` (Elixir/Ruby) or start with `is_`/`has_` (JS/Python)."
   _fix_hint: "Add a ? suffix to boolean-returning functions (e.g., valid? instead of is_valid)"
+  _languages: [elixir]
   _log_baseline: 7.0991
   brevity:
     mean_sample_size: 0.0085
@@ -47,6 +48,7 @@ boolean_function_has_question_mark:
 cyclomatic_complexity_under_10:
   _doc: "Functions should have a cyclomatic complexity under 10."
   _fix_hint: "Reduce branching — extract complex conditionals into helper functions"
+  _languages: [elixir]
   _log_baseline: -1.6476
   branching:
     mean_branch_count: -0.2373
@@ -151,6 +153,7 @@ cyclomatic_complexity_under_10:
 has_verb_in_name:
   _doc: "Function names should contain a verb describing the action performed."
   _fix_hint: "Start function names with a verb (get_, fetch_, build_, compute_, validate_)"
+  _languages: [elixir]
   _log_baseline: 15.9117
   compression:
     mean_raw_bytes: 0.0990
@@ -177,6 +180,7 @@ has_verb_in_name:
 is_less_than_20_lines:
   _doc: "Functions should be 20 lines or fewer."
   _fix_hint: "Split long functions — each function should fit on one screen (under 20 lines)"
+  _languages: [elixir]
   _log_baseline: 23.1945
   branching:
     mean_branch_count: -0.0820
@@ -289,6 +293,7 @@ is_less_than_20_lines:
 nesting_depth_under_4:
   _doc: "Code should not nest deeper than 4 levels."
   _fix_hint: "Reduce nesting — use early returns, guards, or extract inner blocks"
+  _languages: [elixir]
   _log_baseline: 1.1322
   branching:
     mean_branch_count: -0.3267
@@ -400,6 +405,7 @@ nesting_depth_under_4:
 no_boolean_parameter:
   _doc: "Functions should not take boolean parameters — a flag usually means the function does two things."
   _fix_hint: "Replace boolean parameters with two separate functions or use an options map"
+  _languages: [elixir]
   _log_baseline: 3.0928
   branching:
     mean_branch_count: -2.0000
@@ -507,6 +513,7 @@ no_boolean_parameter:
 no_magic_numbers:
   _doc: "Numeric literals should be named constants, not inline magic numbers."
   _fix_hint: "Replace magic numbers inside functions with named module attributes or constants"
+  _languages: [elixir]
   _log_baseline: 48.6069
   branching:
     mean_branch_count: -0.2708
@@ -611,6 +618,7 @@ no_magic_numbers:
 parameter_count_under_4:
   _doc: "Functions should take fewer than 4 parameters."
   _fix_hint: "Reduce parameter count — group related params into a struct or options map"
+  _languages: [elixir]
   _log_baseline: 1.6218
   branching:
     mean_non_blank_count: 0.0967
@@ -717,6 +725,7 @@ parameter_count_under_4:
 uses_ternary_expression:
   _doc: "Simple conditional assignments should use inline expressions rather than full if-blocks."
   _fix_hint: "Replace verbose if-else blocks with concise ternary/conditional expressions where readable"
+  _languages: [elixir]
   _log_baseline: -0.3649
   branching:
     mean_branch_count: -0.4693
diff --git a/priv/combined_metrics/naming_conventions.yml b/priv/combined_metrics/naming_conventions.yml
index 33e5d8a..4f3693d 100644
--- a/priv/combined_metrics/naming_conventions.yml
+++ b/priv/combined_metrics/naming_conventions.yml
@@ -1,6 +1,7 @@
 class_name_is_noun:
   _doc: "Class and module names should be nouns describing what they represent, not verbs or gerunds."
   _fix_hint: "Name modules/classes with nouns (User, OrderProcessor) not verbs"
+  _languages: [elixir]
   _log_baseline: 4.2909
   brevity:
     mean_sample_size: 0.7106
@@ -58,6 +59,7 @@ class_name_is_noun:
 file_name_matches_primary_export:
   _doc: "The file name should match the primary class or module it exports (e.g. `user.js` exports `User`)."
   _fix_hint: "Rename the file to match the primary module it defines"
+  _languages: [elixir]
   _log_baseline: 0.0000
   casing_entropy:
     mean_pascal_case_count: 0.0000
@@ -67,6 +69,7 @@ file_name_matches_primary_export:
 function_name_is_not_single_word:
   _doc: "Single-word function names like `run`, `process`, or `handle` are too vague to convey intent."
   _fix_hint: "Use at least two words in function names to convey intent (e.g., fetch_user not fetch)"
+  _languages: [elixir]
   _log_baseline: 17.4874
   compression:
     mean_raw_bytes: 0.2480
@@ -94,6 +97,7 @@ function_name_is_not_single_word:
 function_name_matches_return_type:
   _doc: "Functions prefixed with `get_`, `fetch_`, or `find_` should return the thing they name."
   _fix_hint: "Align the function name with what it returns (get_ for values, is_/has_ for booleans)"
+  _languages: [elixir]
   _log_baseline: 7.9532
   branching:
     mean_max_nesting_depth: 0.1335
@@ -188,6 +192,7 @@ function_name_matches_return_type:
 test_name_starts_with_verb:
   _doc: "Test descriptions should start with a verb: `creates`, `raises`, `returns`, not a noun phrase."
   _fix_hint: "Start test descriptions with a verb (returns, raises, creates, validates)"
+  _languages: [elixir]
   _log_baseline: 7.8702
   branching:
     mean_branch_count: 1.9977
diff --git a/priv/combined_metrics/scope_and_assignment.yml b/priv/combined_metrics/scope_and_assignment.yml
index 507e8ae..c21c6dd 100644
--- a/priv/combined_metrics/scope_and_assignment.yml
+++ b/priv/combined_metrics/scope_and_assignment.yml
@@ -1,6 +1,7 @@
 declared_close_to_use:
   _doc: "Variables should be declared near their first use, not hoisted to the top of the function."
   _fix_hint: "Move variable declarations closer to their first use to reduce cognitive scope"
+  _languages: [elixir]
   _log_baseline: -59.6022
   branching:
     mean_branch_count: -0.4906
@@ -107,6 +108,7 @@ declared_close_to_use:
 mutated_after_initial_assignment:
   _doc: "Variables should not be reassigned after their initial value — prefer introducing a new name."
   _fix_hint: "Avoid reassigning variables — introduce a new name for each transformed value"
+  _languages: [elixir]
   _log_baseline: 6.6347
   branching:
     mean_branch_count: 0.1519
@@ -217,6 +219,7 @@ mutated_after_initial_assignment:
 reassigned_multiple_times:
   _doc: "A variable reassigned many times is a sign the name is too generic or the function does too much."
   _fix_hint: "Refactor repeated reassignment into a pipeline or named intermediate values"
+  _languages: [elixir]
   _log_baseline: -107.5659
   branching:
     mean_non_blank_count: -0.2287
@@ -316,6 +319,7 @@ reassigned_multiple_times:
 scope_is_minimal:
   _doc: "Variables should be scoped as narrowly as possible — not declared at a wider scope than needed."
   _fix_hint: "Narrow the scope of variables — declare them in the innermost block where they are used"
+  _languages: [elixir]
   _log_baseline: -6.7522
   branching:
     mean_branch_count: -0.1072
@@ -424,6 +428,7 @@ scope_is_minimal:
 shadowed_by_inner_scope:
   _doc: "Inner-scope names that shadow outer-scope names cause confusion about which value is in play."
   _fix_hint: "Rename the inner variable to avoid shadowing the outer one"
+  _languages: [elixir]
   _log_baseline: -33.9501
   branching:
     mean_branching_density: 2.0000
@@ -529,6 +534,7 @@ shadowed_by_inner_scope:
 used_only_once:
   _doc: "A variable used only once is a candidate for inlining — it rarely adds clarity over a direct expression."
   _fix_hint: "Inline single-use variables directly into their only use site"
+  _languages: [elixir]
   _log_baseline: -116.4649
   branching:
     mean_non_blank_count: -0.5385
diff --git a/priv/combined_metrics/testing.yml b/priv/combined_metrics/testing.yml
index ef74557..6b1d5e9 100644
--- a/priv/combined_metrics/testing.yml
+++ b/priv/combined_metrics/testing.yml
@@ -1,6 +1,7 @@
 reasonable_test_to_code_ratio:
   _doc: "There should be an adequate number of test cases relative to the code being tested."
   _fix_hint: "Add more tests — aim for at least one test per public function"
+  _languages: [elixir]
   _log_baseline: 8.2261
   branching:
     mean_branch_count: 0.1869
@@ -111,6 +112,7 @@ reasonable_test_to_code_ratio:
 test_has_assertion:
   _doc: "Every test body must contain at least one assertion — a test without assertions proves nothing."
   _fix_hint: "Add at least one assert/refute to every test — a test without assertions proves nothing"
+  _languages: [elixir]
   _log_baseline: -9.6007
   branching:
     mean_branch_count: 0.0918
@@ -214,6 +216,7 @@ test_has_assertion:
 test_name_describes_behavior:
   _doc: "Test names should describe the expected behaviour, not just the method under test."
   _fix_hint: "Describe expected behavior in test names: 'returns {:error, :not_found} when user missing'"
+  _languages: [elixir]
   _log_baseline: 56.4575
   branching:
     mean_branch_count: 2.0000
@@ -307,6 +310,7 @@ test_name_describes_behavior:
 test_single_concept:
   _doc: "Each test should verify a single concept — tests covering multiple things are harder to diagnose when they fail."
   _fix_hint: "Test one thing per test — split tests covering multiple behaviors into separate test cases"
+  _languages: [elixir]
   _log_baseline: 35.9646
   branching:
     mean_branch_count: 0.3696
diff --git a/priv/combined_metrics/type_and_value.yml b/priv/combined_metrics/type_and_value.yml
index dc85081..f3e061c 100644
--- a/priv/combined_metrics/type_and_value.yml
+++ b/priv/combined_metrics/type_and_value.yml
@@ -1,6 +1,7 @@
 boolean_assigned_from_comparison:
   _doc: "Boolean variables should be assigned directly from comparisons or predicate calls, not set via conditionals."
   _fix_hint: "Assign the comparison result directly — bool = x > 0 not if x > 0 do true else false end"
+  _languages: [elixir]
   _log_baseline: 3.2119
   branching:
     mean_branch_count: -0.8402
@@ -113,6 +114,7 @@ boolean_assigned_from_comparison:
 hardcoded_url_or_path:
   _doc: "URLs, file paths, and host names should be configuration values, not inline string literals."
   _fix_hint: "Move hardcoded URLs and file paths to configuration or module attributes"
+  _languages: [elixir]
   _log_baseline: 119.8203
   branching:
     mean_max_nesting_depth: 0.9571
@@ -216,6 +218,7 @@ hardcoded_url_or_path:
 no_empty_string_initial:
   _doc: "Initialising a variable to an empty string and reassigning later signals missing structure."
   _fix_hint: "Replace initial empty string assignments with nil or a meaningful default value"
+  _languages: [elixir]
   _log_baseline: -11.4915
   branching:
     mean_branch_count: -0.1786
@@ -320,6 +323,7 @@ no_empty_string_initial:
 no_implicit_null_initial:
   _doc: "Initialising a variable to `nil`/`null` and assigning it later in a branch signals missing structure."
   _fix_hint: "Use nil explicitly when a variable starts null — or restructure to avoid nil initialization"
+  _languages: [elixir]
   _log_baseline: -3.2196
   branching:
     mean_branch_count: 0.0293
@@ -424,6 +428,7 @@ no_implicit_null_initial:
 no_magic_value_assigned:
   _doc: "Literal strings and numbers assigned to variables should be named constants, not inline values."
   _fix_hint: "Replace magic value assignments with named constants or module attributes"
+  _languages: [elixir]
   _log_baseline: -6.5439
   branching:
     mean_branch_count: -0.2035
diff --git a/priv/combined_metrics/variable_naming.yml b/priv/combined_metrics/variable_naming.yml
index 8b9a7dc..4d68d74 100644
--- a/priv/combined_metrics/variable_naming.yml
+++ b/priv/combined_metrics/variable_naming.yml
@@ -1,6 +1,7 @@
 boolean_has_is_has_prefix:
   _doc: "Boolean variables should be prefixed with `is_`, `has_`, or `can_`."
   _fix_hint: "Prefix boolean variables with is_, has_, or can_ (e.g., is_valid, has_errors)"
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 15.9674
   brevity:
     mean_sample_size: 0.0752
@@ -64,6 +65,7 @@ boolean_has_is_has_prefix:
 collection_name_is_plural:
   _doc: "Variables holding a collection should use a plural name."
   _fix_hint: "Use plural names for collections (users, orders, ids not user, order, id)"
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 32.4645
   brevity:
     mean_sample_size: -0.6992
@@ -126,6 +128,7 @@ collection_name_is_plural:
 loop_var_is_single_letter:
   _doc: "Loop index variables (`i`, `j`, `k`) are acceptable inside loop bodies."
   _fix_hint: "Use descriptive loop variable names instead of single letters (user not u)"
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -28.4780
   brevity:
     mean_sample_size: -0.1049
@@ -206,6 +209,7 @@ loop_var_is_single_letter:
 name_contains_and:
   _doc: "Variable names containing `and` signal a variable that holds two concerns."
   _fix_hint: "Split variables with 'and' into two focused variables (user_and_role → user + role)"
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -11.0411
   branching:
     mean_branch_count: -0.7789
@@ -316,6 +320,7 @@ name_contains_and:
 name_contains_type_suffix:
   _doc: "Type suffixes in names (`userString`, `nameList`) are redundant noise."
   _fix_hint: "Remove type suffixes from names (userList → users, dataMap → data)"
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -26.2345
   branching:
     mean_branch_count: -0.4150
@@ -402,6 +407,7 @@ name_contains_type_suffix:
 name_is_abbreviation:
   _doc: "Abbreviated names (`usr`, `cfg`, `mgr`) reduce readability."
   _fix_hint: "Expand abbreviations to full words (usr → user, cnt → count, idx → index)"
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 23.1000
   brevity:
     mean_sample_size: -0.2397
@@ -488,6 +494,7 @@ name_is_abbreviation:
 name_is_generic:
   _doc: "Generic names (`data`, `result`, `tmp`, `val`, `obj`) convey no domain meaning."
   _fix_hint: "Replace generic names (data, result, tmp, info) with domain-specific names"
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 37.2228
   branching:
     mean_branch_count: 0.5193
@@ -600,6 +607,7 @@ name_is_generic:
 name_is_number_like:
   _doc: "Number-suffixed names (`var1`, `thing2`) signal a missing abstraction."
   _fix_hint: "Replace number-like names (x1, y2) with descriptive names indicating purpose"
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 1.7668
   brevity:
     mean_sample_size: -0.0262
@@ -680,6 +688,7 @@ name_is_number_like:
 name_is_single_letter:
   _doc: "Single-letter names outside loop indices are too opaque."
   _fix_hint: "Replace single-letter names with descriptive names (n → count, s → status)"
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 25.4977
   branching:
     mean_branching_density: -0.0458
@@ -779,6 +788,7 @@ name_is_single_letter:
 name_is_too_long:
   _doc: "Names longer than ~30 characters harm readability."
   _fix_hint: "Shorten overly long names — aim for 2–3 descriptive words, drop redundant context"
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -7.5164
   branching:
     mean_branch_count: 0.0340
@@ -894,6 +904,7 @@ name_is_too_long:
 name_is_too_short:
   _doc: "Names shorter than 3 characters (outside loops) are too opaque."
   _fix_hint: "Use at least 3 characters — replace very short names with full words"
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -0.4484
   branching:
     mean_branch_count: -0.2327
@@ -980,6 +991,7 @@ name_is_too_short:
 negated_boolean_name:
   _doc: "Negated boolean names (`isNotValid`, `notActive`) are harder to reason about."
   _fix_hint: "Rename negated booleans positively (is_not_active → is_inactive, not_found → missing)"
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -15.6244
   brevity:
     mean_sample_size: -0.3765
@@ -1049,6 +1061,7 @@ negated_boolean_name:
 no_hungarian_notation:
   _doc: "Hungarian notation prefixes (`strName`, `bFlag`) add noise without type safety."
   _fix_hint: "Remove type prefixes from names (strName → name, intCount → count)"
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -15.0940
   brevity:
     mean_sample_size: -0.0814
@@ -1121,6 +1134,7 @@ no_hungarian_notation:
 screaming_snake_for_constants:
   _doc: "Module-level constants should use SCREAMING_SNAKE_CASE."
   _fix_hint: "Use SCREAMING_SNAKE_CASE for module-level constants (@MAX_SIZE not @max_size)"
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -6.3000
   branching:
     mean_branching_density: 0.0176

From db764fc01069c8b1dae5475f92af93d4cfdd31bd Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Fri, 20 Mar 2026 14:09:37 +0100
Subject: [PATCH 25/71] feat(ci): add workflow to auto-sync behavior language
 coverage and scalars

---
 .github/workflows/sync-behavior-coverage.yml | 65 ++++++++++++++++++++
 1 file changed, 65 insertions(+)
 create mode 100644 .github/workflows/sync-behavior-coverage.yml

diff --git a/.github/workflows/sync-behavior-coverage.yml b/.github/workflows/sync-behavior-coverage.yml
new file mode 100644
index 0000000..8529dcc
--- /dev/null
+++ b/.github/workflows/sync-behavior-coverage.yml
@@ -0,0 +1,65 @@
+name: Sync Behavior Coverage
+
+on:
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: write
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    if: github.event.pull_request.head.repo.full_name == github.repository
+
+    steps:
+      - name: Checkout PR branch
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.head_ref }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set up Elixir
+        uses: erlef/setup-beam@v1
+        with:
+          otp-version: "27.3"
+          elixir-version: "1.19"
+
+      - name: Cache deps
+        uses: actions/cache@v4
+        with:
+          path: |
+            deps
+            _build
+          key: ${{ runner.os }}-mix-${{ hashFiles('mix.lock') }}
+          restore-keys: ${{ runner.os }}-mix-
+
+      - name: Install dependencies
+        run: mix deps.get
+
+      - name: Compile
+        run: mix compile --warnings-as-errors
+
+      - name: Regenerate language coverage
+        run: mix codeqa.sample_report --apply-languages
+
+      - name: Regenerate scalar vectors
+        run: mix codeqa.sample_report --apply-scalars
+
+      - name: Check for YAML drift
+        id: diff
+        run: |
+          if git diff --quiet priv/combined_metrics/; then
+            echo "changed=false" >> $GITHUB_OUTPUT
+          else
+            echo "changed=true" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Commit and push updated YAMLs
+        if: steps.diff.outputs.changed == 'true'
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add priv/combined_metrics/*.yml
+          git commit -m "chore(combined-metrics): sync language coverage and scalar vectors [skip ci]"
+          git push

From 1d10f533554413ac38df67fd5e9d15364a327815 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Fri, 20 Mar 2026 13:16:42 +0000
Subject: [PATCH 26/71] chore(combined-metrics): sync language coverage and
 scalar vectors [skip ci]

---
 priv/combined_metrics/code_smells.yml         | 135 +--
 priv/combined_metrics/consistency.yml         | 162 ++--
 priv/combined_metrics/dependencies.yml        |  75 +-
 priv/combined_metrics/documentation.yml       | 161 ++--
 priv/combined_metrics/error_handling.yml      | 234 +++---
 priv/combined_metrics/file_structure.yml      | 111 +--
 priv/combined_metrics/function_design.yml     | 359 ++++----
 priv/combined_metrics/naming_conventions.yml  |  97 +--
 .../combined_metrics/scope_and_assignment.yml | 273 +++----
 priv/combined_metrics/testing.yml             | 113 +--
 priv/combined_metrics/type_and_value.yml      | 251 +++---
 priv/combined_metrics/variable_naming.yml     | 771 +++++++++---------
 12 files changed, 1370 insertions(+), 1372 deletions(-)

diff --git a/priv/combined_metrics/code_smells.yml b/priv/combined_metrics/code_smells.yml
index 6be13fa..f1c73c5 100644
--- a/priv/combined_metrics/code_smells.yml
+++ b/priv/combined_metrics/code_smells.yml
@@ -1,17 +1,15 @@
 consistent_string_quote_style:
   _doc: "Files should use a single, consistent string quoting style throughout."
-  _fix_hint: "Use a single quote style (e.g., double quotes) consistently throughout the file"
-  _languages: [elixir]
-  _log_baseline: -18.9505
+  _log_baseline: -18.2553
   branching:
     mean_branching_density: 0.0243
     mean_non_blank_count: -0.0248
   brevity:
     mean_sample_size: -0.0656
   casing_entropy:
-    mean_entropy: -0.0493
+    mean_entropy: -0.0405
     mean_pascal_case_count: -0.1743
-    mean_snake_case_count: -0.0451
+    mean_snake_case_count: -0.0505
   compression:
     mean_raw_bytes: -0.0672
     mean_redundancy: 0.0207
@@ -43,9 +41,9 @@ consistent_string_quote_style:
     mean_k: -0.0368
     mean_r_squared: -0.0080
   identifier_length_variance:
-    mean_mean: 0.0058
-    mean_std_dev: 0.0158
-    mean_variance: 0.0316
+    mean_mean: 0.0059
+    mean_std_dev: 0.0235
+    mean_variance: 0.0470
   indentation:
     mean_blank_line_ratio: 0.0205
     mean_variance: 0.0246
@@ -56,6 +54,11 @@ consistent_string_quote_style:
   magic_number_density:
     mean_string_literal_ratio: 0.3018
   near_duplicate_blocks_file:
+    mean_near_dup_block_d2: 0.9542
+    mean_near_dup_block_d3: -0.6021
+    mean_near_dup_block_d4: -0.9542
+    mean_near_dup_block_d5: 0.9542
+    mean_near_dup_block_d6: -0.6021
     mean_sub_block_count: -0.1804
   ngram:
     mean_bigram_hapax_fraction: -0.0101
@@ -86,21 +89,19 @@ consistent_string_quote_style:
     mean_distinct_symbol_types: -0.0966
     mean_symbol_count: -0.0999
   vocabulary:
-    mean_mattr: -0.0304
-    mean_raw_ttr: -0.0079
-    mean_total_identifiers: -0.0589
-    mean_unique_identifiers: -0.0668
+    mean_mattr: -0.0187
+    mean_raw_ttr: -0.0050
+    mean_total_identifiers: -0.0666
+    mean_unique_identifiers: -0.0714
   vowel_density:
-    mean_total_chars: -0.0531
+    mean_total_chars: -0.0607
   zipf:
     mean_total_tokens: -0.0783
     mean_vocab_size: -0.0656
 
 no_dead_code_after_return:
   _doc: "There should be no unreachable statements after a return or early exit."
-  _fix_hint: "Remove unreachable statements after return/raise/exit — they can never execute"
-  _languages: [elixir]
-  _log_baseline: -57.2281
+  _log_baseline: -55.8435
   branching:
     mean_branch_count: -2.0000
     mean_branching_density: -1.4201
@@ -108,10 +109,10 @@ no_dead_code_after_return:
   brevity:
     mean_sample_size: -0.2610
   casing_entropy:
-    mean_entropy: -0.2355
+    mean_entropy: -0.2430
     mean_other_count: -0.8708
     mean_pascal_case_count: -0.5752
-    mean_snake_case_count: -0.3869
+    mean_snake_case_count: -0.3559
   compression:
     mean_raw_bytes: -0.4531
     mean_redundancy: -0.0467
@@ -147,9 +148,9 @@ no_dead_code_after_return:
     mean_k: -0.1169
   identifier_length_variance:
     mean_max: -0.4367
-    mean_mean: 0.0078
-    mean_std_dev: -0.2478
-    mean_variance: -0.4957
+    mean_mean: -0.0159
+    mean_std_dev: -0.2804
+    mean_variance: -0.5607
   indentation:
     mean_blank_line_ratio: 0.2883
     mean_mean_depth: -0.4448
@@ -162,6 +163,11 @@ no_dead_code_after_return:
     mean_density: 0.2821
     mean_string_literal_ratio: -0.8289
   near_duplicate_blocks_file:
+    mean_block_count: -0.1083
+    mean_near_dup_block_d0: 1.1292
+    mean_near_dup_block_d5: 1.1292
+    mean_near_dup_block_d7: -0.7124
+    mean_near_dup_block_d8: 1.1292
     mean_sub_block_count: -0.3612
   ngram:
     mean_bigram_hapax_fraction: 0.0142
@@ -192,12 +198,12 @@ no_dead_code_after_return:
     mean_density: 0.2141
     mean_symbol_count: -0.2386
   vocabulary:
-    mean_mattr: -0.0870
-    mean_raw_ttr: 0.0851
-    mean_total_identifiers: -0.4256
-    mean_unique_identifiers: -0.3406
+    mean_mattr: -0.0424
+    mean_raw_ttr: 0.0435
+    mean_total_identifiers: -0.4061
+    mean_unique_identifiers: -0.3626
   vowel_density:
-    mean_total_chars: -0.4179
+    mean_total_chars: -0.4220
   zipf:
     mean_exponent: -0.0067
     mean_total_tokens: -0.3093
@@ -205,9 +211,7 @@ no_dead_code_after_return:
 
 no_debug_print_statements:
   _doc: "Debug output (`console.log`, `IO.inspect`, `fmt.Println`) must not be left in committed code."
-  _fix_hint: "Remove IO.inspect/IO.puts/console.log debug output — use Logger or remove entirely"
-  _languages: [elixir]
-  _log_baseline: -86.5160
+  _log_baseline: -88.0844
   branching:
     mean_branch_count: -0.3540
     mean_branching_density: 0.0181
@@ -216,10 +220,10 @@ no_debug_print_statements:
   brevity:
     mean_sample_size: -0.2128
   casing_entropy:
-    mean_entropy: 0.0285
+    mean_entropy: 0.0841
     mean_other_count: 0.1169
     mean_pascal_case_count: -1.0141
-    mean_snake_case_count: -0.5844
+    mean_snake_case_count: -0.6773
   compression:
     mean_raw_bytes: -0.4490
     mean_redundancy: -0.0518
@@ -254,9 +258,9 @@ no_debug_print_statements:
     mean_k: 0.0324
     mean_r_squared: -0.0077
   identifier_length_variance:
-    mean_mean: 0.1266
-    mean_std_dev: 0.0871
-    mean_variance: 0.1743
+    mean_mean: 0.1804
+    mean_std_dev: 0.0496
+    mean_variance: 0.0993
   indentation:
     mean_blank_line_ratio: -0.0499
     mean_max_depth: -0.2215
@@ -271,6 +275,7 @@ no_debug_print_statements:
     mean_density: 0.5227
     mean_string_literal_ratio: -1.0798
   near_duplicate_blocks_file:
+    mean_block_count: -0.2856
     mean_sub_block_count: -0.4114
   ngram:
     mean_bigram_hapax_fraction: -0.0183
@@ -302,12 +307,12 @@ no_debug_print_statements:
     mean_distinct_symbol_types: -0.1242
     mean_symbol_count: -0.5369
   vocabulary:
-    mean_mattr: 0.2274
-    mean_raw_ttr: 0.3523
-    mean_total_identifiers: -0.5867
-    mean_unique_identifiers: -0.2346
+    mean_mattr: 0.3160
+    mean_raw_ttr: 0.4438
+    mean_total_identifiers: -0.6654
+    mean_unique_identifiers: -0.2215
   vowel_density:
-    mean_total_chars: -0.4601
+    mean_total_chars: -0.4850
   zipf:
     mean_exponent: -0.1196
     mean_r_squared: 0.0127
@@ -316,9 +321,7 @@ no_debug_print_statements:
 
 no_fixme_comments:
   _doc: "FIXME, XXX, and HACK comments indicate known problems that should be resolved before merging."
-  _fix_hint: "Resolve FIXME/XXX/HACK comments before merging — they indicate known unresolved issues"
-  _languages: [elixir]
-  _log_baseline: -2.1522
+  _log_baseline: -2.0233
   branching:
     mean_branch_count: 0.1755
     mean_branching_density: 0.1504
@@ -326,9 +329,9 @@ no_fixme_comments:
   brevity:
     mean_sample_size: -0.0887
   casing_entropy:
-    mean_entropy: -0.0225
-    mean_pascal_case_count: -0.0769
-    mean_snake_case_count: -0.0130
+    mean_entropy: 0.0286
+    mean_pascal_case_count: 0.0129
+    mean_snake_case_count: -0.0450
   comment_structure:
     mean_comment_line_count: -0.6667
     mean_comment_line_ratio: 0.5464
@@ -369,9 +372,9 @@ no_fixme_comments:
     mean_beta: -0.0665
     mean_k: 0.1089
   identifier_length_variance:
-    mean_mean: 0.0027
-    mean_std_dev: 0.0259
-    mean_variance: 0.0517
+    mean_mean: 0.0159
+    mean_std_dev: 0.0203
+    mean_variance: 0.0407
   indentation:
     mean_blank_line_ratio: 0.0697
     mean_max_depth: 0.0646
@@ -385,6 +388,7 @@ no_fixme_comments:
     mean_density: -0.0646
     mean_string_literal_ratio: 0.0564
   near_duplicate_blocks_file:
+    mean_block_count: 0.0305
     mean_sub_block_count: 0.1090
   ngram:
     mean_bigram_hapax_fraction: -0.0378
@@ -417,12 +421,12 @@ no_fixme_comments:
     mean_density: 0.1041
     mean_symbol_count: 0.1218
   vocabulary:
-    mean_mattr: -0.1086
-    mean_raw_ttr: -0.1007
-    mean_total_identifiers: -0.0217
-    mean_unique_identifiers: -0.1224
+    mean_mattr: -0.0826
+    mean_raw_ttr: -0.0781
+    mean_total_identifiers: -0.0352
+    mean_unique_identifiers: -0.1133
   vowel_density:
-    mean_total_chars: -0.0190
+    mean_total_chars: -0.0193
   zipf:
     mean_exponent: 0.0584
     mean_r_squared: 0.0015
@@ -431,9 +435,7 @@ no_fixme_comments:
 
 no_nested_ternary:
   _doc: "Nested conditional expressions (ternary-within-ternary) are harder to read than a plain if-else."
-  _fix_hint: "Replace nested ternary/conditional expressions with if-else blocks or pattern matching"
-  _languages: [elixir]
-  _log_baseline: 7.2208
+  _log_baseline: 7.6475
   branching:
     mean_branch_count: -0.5662
     mean_branching_density: -0.3441
@@ -442,10 +444,10 @@ no_nested_ternary:
   brevity:
     mean_sample_size: 0.0486
   casing_entropy:
-    mean_entropy: 0.2495
+    mean_entropy: 0.2311
     mean_other_count: 0.7455
     mean_pascal_case_count: 0.1237
-    mean_snake_case_count: 0.0885
+    mean_snake_case_count: 0.1138
   compression:
     mean_raw_bytes: -0.0141
     mean_redundancy: -0.0117
@@ -483,8 +485,9 @@ no_nested_ternary:
     mean_k: 0.0563
   identifier_length_variance:
     mean_max: 0.0170
-    mean_std_dev: -0.0032
-    mean_variance: -0.0065
+    mean_mean: -0.0112
+    mean_std_dev: -0.0060
+    mean_variance: -0.0120
   indentation:
     mean_blank_line_ratio: 0.3825
     mean_max_depth: -0.2891
@@ -500,6 +503,8 @@ no_nested_ternary:
     mean_magic_number_count: -0.0310
     mean_string_literal_ratio: 0.0146
   near_duplicate_blocks_file:
+    mean_block_count: 0.0885
+    mean_near_dup_block_d7: -0.1824
     mean_sub_block_count: 0.5472
   ngram:
     mean_bigram_hapax_fraction: -0.0464
@@ -531,12 +536,12 @@ no_nested_ternary:
     mean_distinct_symbol_types: 0.0377
     mean_symbol_count: 0.2475
   vocabulary:
-    mean_mattr: -0.0453
-    mean_raw_ttr: -0.0380
-    mean_total_identifiers: 0.1302
-    mean_unique_identifiers: 0.0921
+    mean_mattr: -0.0587
+    mean_raw_ttr: -0.0515
+    mean_total_identifiers: 0.1551
+    mean_unique_identifiers: 0.1036
   vowel_density:
-    mean_total_chars: 0.1293
+    mean_total_chars: 0.1439
   zipf:
     mean_exponent: 0.0240
     mean_r_squared: 0.0111
diff --git a/priv/combined_metrics/consistency.yml b/priv/combined_metrics/consistency.yml
index 426e360..25026ea 100644
--- a/priv/combined_metrics/consistency.yml
+++ b/priv/combined_metrics/consistency.yml
@@ -1,14 +1,12 @@
 consistent_casing_within_file:
   _doc: "A file should use one naming convention throughout — no mixing of camelCase and snake_case for the same kind of identifier."
-  _fix_hint: "Pick one casing convention (snake_case or camelCase) and apply it uniformly"
-  _languages: [elixir]
-  _log_baseline: -2.4622
+  _log_baseline: -2.4826
   brevity:
     mean_sample_size: -0.0471
   casing_entropy:
     mean_camel_case_count: -2.0000
-    mean_entropy: -0.4219
-    mean_snake_case_count: 0.2745
+    mean_entropy: -0.4254
+    mean_snake_case_count: 0.2663
   compression:
     mean_raw_bytes: 0.0213
     mean_redundancy: 0.0219
@@ -33,9 +31,9 @@ consistent_casing_within_file:
     mean_beta: -0.0232
     mean_k: 0.0253
   identifier_length_variance:
-    mean_mean: 0.0342
-    mean_std_dev: 0.0123
-    mean_variance: 0.0246
+    mean_mean: 0.0337
+    mean_std_dev: 0.0139
+    mean_variance: 0.0278
   ngram:
     mean_bigram_hapax_fraction: -0.0071
     mean_bigram_repetition_rate: 0.0267
@@ -49,20 +47,18 @@ consistent_casing_within_file:
   symbol_density:
     mean_density: -0.0214
   vocabulary:
-    mean_mattr: -0.0679
-    mean_raw_ttr: -0.0715
-    mean_unique_identifiers: -0.0714
+    mean_mattr: -0.0680
+    mean_raw_ttr: -0.0735
+    mean_unique_identifiers: -0.0735
   vowel_density:
-    mean_total_chars: 0.0342
+    mean_total_chars: 0.0337
   zipf:
     mean_exponent: 0.0265
     mean_vocab_size: -0.0471
 
 consistent_error_return_shape:
   _doc: "All functions in a module should return errors in the same shape — mixed `nil`, `false`, and `{:error, _}` returns are confusing."
-  _fix_hint: "Use a single error return format (e.g., {:error, reason}) consistently throughout"
-  _languages: [elixir]
-  _log_baseline: 31.6243
+  _log_baseline: 30.7874
   branching:
     mean_branch_count: -0.2178
     mean_branching_density: -0.1258
@@ -70,8 +66,8 @@ consistent_error_return_shape:
   brevity:
     mean_sample_size: 0.0231
   casing_entropy:
-    mean_entropy: -0.0372
-    mean_snake_case_count: 0.0582
+    mean_entropy: 0.0245
+    mean_snake_case_count: -0.0406
   compression:
     mean_raw_bytes: -0.0234
     mean_redundancy: 0.0058
@@ -103,8 +99,9 @@ consistent_error_return_shape:
     mean_beta: -0.0402
     mean_k: 0.0903
   identifier_length_variance:
-    mean_std_dev: 0.0324
-    mean_variance: 0.0648
+    mean_mean: 0.0455
+    mean_std_dev: 0.0308
+    mean_variance: 0.0616
   indentation:
     mean_blank_line_ratio: 0.0185
     mean_mean_depth: -0.0638
@@ -117,6 +114,8 @@ consistent_error_return_shape:
     mean_density: -0.0557
     mean_string_literal_ratio: -2.0000
   near_duplicate_blocks_file:
+    mean_near_dup_block_d7: 0.7522
+    mean_near_dup_block_d8: -0.4400
     mean_sub_block_count: 0.1553
   ngram:
     mean_bigram_hapax_fraction: -0.0430
@@ -145,12 +144,12 @@ consistent_error_return_shape:
     mean_density: 0.1360
     mean_symbol_count: 0.1121
   vocabulary:
-    mean_mattr: 0.0268
-    mean_raw_ttr: -0.0151
-    mean_total_identifiers: 0.0519
-    mean_unique_identifiers: 0.0368
+    mean_mattr: 0.0877
+    mean_raw_ttr: 0.0733
+    mean_total_identifiers: -0.0353
+    mean_unique_identifiers: 0.0381
   vowel_density:
-    mean_total_chars: 0.0479
+    mean_total_chars: 0.0102
   zipf:
     mean_exponent: 0.0181
     mean_total_tokens: 0.0361
@@ -158,9 +157,7 @@ consistent_error_return_shape:
 
 consistent_function_style:
   _doc: "A module should not mix one-liner and multi-clause function definitions for the same concern."
-  _fix_hint: "Use a consistent function definition style — all def or all defp, one-liner or block form"
-  _languages: [elixir]
-  _log_baseline: -2.0498
+  _log_baseline: 0.1374
   branching:
     mean_branch_count: -0.1610
     mean_branching_density: -0.3349
@@ -169,10 +166,10 @@ consistent_function_style:
   brevity:
     mean_sample_size: 0.0028
   casing_entropy:
-    mean_entropy: -0.0562
+    mean_entropy: -0.0534
     mean_other_count: -0.2753
     mean_pascal_case_count: -0.0379
-    mean_snake_case_count: 0.0228
+    mean_snake_case_count: 0.0199
   compression:
     mean_raw_bytes: 0.0313
     mean_redundancy: 0.0188
@@ -204,9 +201,8 @@ consistent_function_style:
   heaps:
     mean_beta: 0.0024
   identifier_length_variance:
-    mean_mean: 0.0040
-    mean_std_dev: 0.0053
-    mean_variance: 0.0106
+    mean_mean: 0.0076
+    mean_variance: 0.0038
   indentation:
     mean_blank_line_ratio: -0.0991
     mean_max_depth: -0.1143
@@ -217,6 +213,10 @@ consistent_function_style:
     mean_max_nesting_depth: -0.1610
     mean_unique_line_ratio: -0.0456
   near_duplicate_blocks_file:
+    mean_block_count: 0.2753
+    mean_near_dup_block_d0: 0.9145
+    mean_near_dup_block_d7: 0.1610
+    mean_near_dup_block_d8: 0.5506
     mean_sub_block_count: 0.0594
   ngram:
     mean_bigram_hapax_fraction: 0.0037
@@ -241,74 +241,72 @@ consistent_function_style:
     mean_density: -0.0473
     mean_symbol_count: -0.0159
   vocabulary:
-    mean_mattr: -0.0035
-    mean_raw_ttr: -0.0090
-    mean_total_identifiers: 0.0133
-    mean_unique_identifiers: 0.0042
+    mean_mattr: -0.0025
+    mean_raw_ttr: -0.0051
+    mean_total_identifiers: 0.0098
+    mean_unique_identifiers: 0.0047
   vowel_density:
-    mean_total_chars: 0.0173
+    mean_total_chars: 0.0175
   zipf:
     mean_exponent: -0.0054
     mean_vocab_size: 0.0028
 
 same_concept_same_name:
   _doc: "The same domain concept should use the same name throughout a file — mixing `user`, `usr`, and `u` for the same thing harms readability."
-  _fix_hint: "Use the same name for the same concept everywhere — avoid synonyms like user/account/member"
-  _languages: [elixir]
-  _log_baseline: -10.7039
+  _log_baseline: -12.4109
   brevity:
-    mean_sample_size: -1.3837
+    mean_sample_size: -1.3457
   compression:
-    mean_raw_bytes: 0.1823
-    mean_redundancy: 0.4046
-    mean_unique_line_ratio: -0.3343
-    mean_zlib_bytes: -0.8496
-    mean_zlib_ratio: 1.0316
+    mean_raw_bytes: 0.1773
+    mean_redundancy: 0.3935
+    mean_unique_line_ratio: -0.3251
+    mean_zlib_bytes: -0.8263
+    mean_zlib_ratio: 1.0033
   entropy:
-    mean_char_entropy: -0.1859
-    mean_char_normalized: -0.1851
-    mean_token_entropy: -0.3646
-    mean_token_max_entropy: -0.2981
-    mean_vocab_size: -1.3837
+    mean_char_entropy: -0.1808
+    mean_char_normalized: -0.1800
+    mean_token_entropy: -0.3546
+    mean_token_max_entropy: -0.2899
+    mean_vocab_size: -1.3457
   halstead:
-    mean_difficulty: 1.9192
-    mean_effort: 1.6104
-    mean_estimated_bugs: -0.3082
-    mean_n2_unique_operands: -1.9192
-    mean_time_to_implement_seconds: 1.6104
-    mean_vocabulary: -1.4248
-    mean_volume: -0.3088
+    mean_difficulty: 1.8665
+    mean_effort: 1.5662
+    mean_estimated_bugs: -0.2997
+    mean_n2_unique_operands: -1.8665
+    mean_time_to_implement_seconds: 1.5662
+    mean_vocabulary: -1.3857
+    mean_volume: -0.3003
   heaps:
-    mean_beta: -0.6035
-    mean_k: 0.5246
+    mean_beta: -0.5870
+    mean_k: 0.5102
   identifier_length_variance:
-    mean_mean: 0.3369
-    mean_std_dev: -0.2793
-    mean_variance: -0.5589
+    mean_mean: 0.3431
+    mean_std_dev: -0.4791
+    mean_variance: -0.9580
   line_patterns:
-    mean_unique_line_ratio: -0.7135
+    mean_unique_line_ratio: -0.6939
   ngram:
-    mean_bigram_hapax_fraction: -0.6648
-    mean_bigram_repeated_unique: -0.2150
-    mean_bigram_repetition_rate: 0.6714
-    mean_bigram_unique: -1.2077
-    mean_trigram_hapax_fraction: -0.6812
-    mean_trigram_repeated_unique: 1.3250
-    mean_trigram_repetition_rate: 1.6604
-    mean_trigram_unique: -1.0154
+    mean_bigram_hapax_fraction: -0.6466
+    mean_bigram_repeated_unique: -0.2091
+    mean_bigram_repetition_rate: 0.6530
+    mean_bigram_unique: -1.1746
+    mean_trigram_hapax_fraction: -0.6625
+    mean_trigram_repeated_unique: 1.2887
+    mean_trigram_repetition_rate: 1.6149
+    mean_trigram_unique: -0.9875
   readability:
-    mean_avg_line_length: 0.1889
-    mean_avg_sub_words_per_id: -0.1821
-    mean_flesch_adapted: 0.2414
+    mean_avg_line_length: 0.1837
+    mean_avg_sub_words_per_id: -0.1771
+    mean_flesch_adapted: 0.2348
   symbol_density:
-    mean_density: -0.1858
+    mean_density: -0.1807
   vocabulary:
-    mean_mattr: -1.7927
-    mean_raw_ttr: -2.0000
-    mean_unique_identifiers: -1.9992
+    mean_mattr: -1.8899
+    mean_raw_ttr: -1.9969
+    mean_unique_identifiers: -2.0000
   vowel_density:
-    mean_total_chars: 0.3371
+    mean_total_chars: 0.3432
   zipf:
-    mean_exponent: 0.7915
-    mean_vocab_size: -1.3837
+    mean_exponent: 0.7698
+    mean_vocab_size: -1.3457
 
diff --git a/priv/combined_metrics/dependencies.yml b/priv/combined_metrics/dependencies.yml
index fbc3591..7bcfacf 100644
--- a/priv/combined_metrics/dependencies.yml
+++ b/priv/combined_metrics/dependencies.yml
@@ -1,8 +1,6 @@
 import_count_under_10:
   _doc: "Files should import fewer than 10 modules; high import counts signal excessive coupling."
-  _fix_hint: "Reduce imports — split large modules or use fully-qualified names for rarely-used deps"
-  _languages: [elixir]
-  _log_baseline: 7.0687
+  _log_baseline: 7.1916
   branching:
     mean_branch_count: 0.2110
     mean_branching_density: -1.0683
@@ -11,9 +9,9 @@ import_count_under_10:
   brevity:
     mean_sample_size: 0.0119
   casing_entropy:
-    mean_entropy: -0.0396
+    mean_entropy: -0.0389
     mean_pascal_case_count: -0.1657
-    mean_snake_case_count: 0.0025
+    mean_snake_case_count: -0.0025
   comment_structure:
     mean_comment_line_ratio: -1.2802
   compression:
@@ -54,9 +52,9 @@ import_count_under_10:
     mean_r_squared: 0.0101
   identifier_length_variance:
     mean_max: 0.0679
-    mean_mean: 0.0712
-    mean_std_dev: 0.0609
-    mean_variance: 0.1218
+    mean_mean: 0.0648
+    mean_std_dev: 0.0688
+    mean_variance: 0.1375
   indentation:
     mean_blank_line_ratio: 0.1478
     mean_max_depth: -0.0876
@@ -72,6 +70,7 @@ import_count_under_10:
     mean_magic_number_count: 0.4898
     mean_string_literal_ratio: 0.0265
   near_duplicate_blocks_file:
+    mean_block_count: 0.0765
     mean_sub_block_count: 0.1110
   ngram:
     mean_bigram_repeated_unique: 0.0034
@@ -101,12 +100,11 @@ import_count_under_10:
     mean_distinct_symbol_types: 0.0643
     mean_symbol_count: 0.0087
   vocabulary:
-    mean_mattr: 0.0037
-    mean_raw_ttr: 0.0453
-    mean_total_identifiers: -0.0543
-    mean_unique_identifiers: -0.0090
+    mean_mattr: -0.0031
+    mean_raw_ttr: 0.0573
+    mean_total_identifiers: -0.0573
   vowel_density:
-    mean_total_chars: 0.0169
+    mean_total_chars: 0.0075
   zipf:
     mean_exponent: -0.0152
     mean_r_squared: 0.0050
@@ -115,9 +113,7 @@ import_count_under_10:
 
 low_coupling:
   _doc: "Modules should depend on few external symbols — a low unique-operand count relative to total is a proxy for tight coupling."
-  _fix_hint: "Reduce dependencies between modules — introduce interfaces or narrow the public API"
-  _languages: [elixir]
-  _log_baseline: -38.4249
+  _log_baseline: -38.2335
   branching:
     mean_branch_count: 0.0745
     mean_branching_density: 0.2097
@@ -126,9 +122,9 @@ low_coupling:
   brevity:
     mean_sample_size: -0.1276
   casing_entropy:
-    mean_entropy: -0.0947
+    mean_entropy: -0.0870
     mean_pascal_case_count: -0.3722
-    mean_snake_case_count: -0.1208
+    mean_snake_case_count: -0.1302
   compression:
     mean_raw_bytes: -0.1657
     mean_redundancy: 0.0126
@@ -166,8 +162,9 @@ low_coupling:
     mean_r_squared: -0.0234
   identifier_length_variance:
     mean_max: -0.0427
-    mean_std_dev: -0.0173
-    mean_variance: -0.0345
+    mean_mean: 0.0133
+    mean_std_dev: -0.0321
+    mean_variance: -0.0642
   indentation:
     mean_blank_line_ratio: -0.0752
     mean_max_depth: -0.0352
@@ -182,6 +179,9 @@ low_coupling:
     mean_density: -2.0000
     mean_string_literal_ratio: 0.1282
   near_duplicate_blocks_file:
+    mean_block_count: 0.1123
+    mean_near_dup_block_d4: 0.2314
+    mean_near_dup_block_d8: 0.2314
     mean_sub_block_count: -0.0902
   ngram:
     mean_bigram_hapax_fraction: -0.0247
@@ -213,12 +213,12 @@ low_coupling:
     mean_distinct_symbol_types: -0.0960
     mean_symbol_count: -0.1794
   vocabulary:
-    mean_mattr: -0.0983
-    mean_raw_ttr: 0.0304
-    mean_total_identifiers: -0.1705
-    mean_unique_identifiers: -0.1402
+    mean_mattr: -0.0823
+    mean_raw_ttr: 0.0349
+    mean_total_identifiers: -0.1801
+    mean_unique_identifiers: -0.1453
   vowel_density:
-    mean_total_chars: -0.1694
+    mean_total_chars: -0.1669
   zipf:
     mean_exponent: 0.0065
     mean_r_squared: -0.0205
@@ -227,17 +227,15 @@ low_coupling:
 
 no_wildcard_imports:
   _doc: "Wildcard imports (`import *`, `using Module`) pollute the local namespace and hide dependencies."
-  _fix_hint: "Replace wildcard imports with explicit named imports for clarity and reduced scope pollution"
-  _languages: [elixir]
-  _log_baseline: -9.4788
+  _log_baseline: -8.9685
   branching:
     mean_branching_density: 0.0249
     mean_non_blank_count: -0.0268
   brevity:
     mean_sample_size: -0.0077
   casing_entropy:
-    mean_entropy: -0.0070
-    mean_snake_case_count: 0.0189
+    mean_entropy: -0.0054
+    mean_snake_case_count: 0.0163
   compression:
     mean_raw_bytes: 0.0310
     mean_unique_line_ratio: -0.0046
@@ -263,9 +261,9 @@ no_wildcard_imports:
     mean_k: 0.1998
     mean_r_squared: -0.0155
   identifier_length_variance:
-    mean_mean: 0.0387
-    mean_std_dev: 0.0490
-    mean_variance: 0.0979
+    mean_mean: 0.0438
+    mean_std_dev: 0.0473
+    mean_variance: 0.0945
   indentation:
     mean_blank_line_ratio: 0.0763
     mean_mean_depth: -0.0117
@@ -279,6 +277,9 @@ no_wildcard_imports:
     mean_magic_number_count: 1.1312
     mean_string_literal_ratio: -0.3463
   near_duplicate_blocks_file:
+    mean_near_dup_block_d6: -0.3309
+    mean_near_dup_block_d7: 0.3309
+    mean_near_dup_block_d8: 0.3309
     mean_sub_block_count: 0.0355
   ngram:
     mean_bigram_hapax_fraction: 0.0182
@@ -310,11 +311,11 @@ no_wildcard_imports:
     mean_distinct_symbol_types: -0.0817
     mean_symbol_count: 0.0042
   vocabulary:
-    mean_mattr: 0.0212
-    mean_raw_ttr: -0.0140
-    mean_total_identifiers: 0.0140
+    mean_mattr: 0.0259
+    mean_raw_ttr: -0.0117
+    mean_total_identifiers: 0.0116
   vowel_density:
-    mean_total_chars: 0.0527
+    mean_total_chars: 0.0554
   zipf:
     mean_exponent: -0.0270
     mean_total_tokens: 0.0131
diff --git a/priv/combined_metrics/documentation.yml b/priv/combined_metrics/documentation.yml
index 66ca037..4e3333c 100644
--- a/priv/combined_metrics/documentation.yml
+++ b/priv/combined_metrics/documentation.yml
@@ -1,8 +1,6 @@
 docstring_is_nonempty:
   _doc: "Docstrings must contain meaningful content, not just a placeholder or empty string."
-  _fix_hint: "Replace placeholder docstrings with a real description of what the function does"
-  _languages: [elixir]
-  _log_baseline: 29.4288
+  _log_baseline: 28.4942
   branching:
     mean_branch_count: 0.3089
     mean_branching_density: 0.2652
@@ -10,10 +8,10 @@ docstring_is_nonempty:
   brevity:
     mean_sample_size: 0.1931
   casing_entropy:
-    mean_entropy: 0.0560
+    mean_entropy: 0.0676
     mean_other_count: 0.0709
     mean_pascal_case_count: 0.3089
-    mean_snake_case_count: 0.1585
+    mean_snake_case_count: 0.1382
   compression:
     mean_raw_bytes: 0.1245
     mean_redundancy: -0.0198
@@ -49,9 +47,9 @@ docstring_is_nonempty:
     mean_beta: 0.0242
     mean_k: 0.0556
   identifier_length_variance:
-    mean_mean: -0.0039
-    mean_std_dev: -0.0154
-    mean_variance: -0.0307
+    mean_mean: 0.0042
+    mean_std_dev: -0.0168
+    mean_variance: -0.0336
   indentation:
     mean_blank_line_ratio: 0.0413
     mean_mean_depth: -0.0330
@@ -65,8 +63,9 @@ docstring_is_nonempty:
     mean_magic_number_count: 0.1709
     mean_string_literal_ratio: 0.1078
   near_duplicate_blocks_file:
-    mean_block_count: 0.5417
-    mean_near_dup_block_d8: 0.2709
+    mean_block_count: 0.0907
+    mean_near_dup_block_d5: -0.2709
+    mean_near_dup_block_d8: 0.1000
     mean_sub_block_count: -0.0061
   ngram:
     mean_bigram_hapax_fraction: 0.0378
@@ -98,12 +97,12 @@ docstring_is_nonempty:
     mean_distinct_symbol_types: 0.0505
     mean_symbol_count: 0.0664
   vocabulary:
-    mean_mattr: 0.1408
-    mean_raw_ttr: 0.0942
-    mean_total_identifiers: 0.1709
-    mean_unique_identifiers: 0.2651
+    mean_mattr: 0.1382
+    mean_raw_ttr: 0.0976
+    mean_total_identifiers: 0.1534
+    mean_unique_identifiers: 0.2510
   vowel_density:
-    mean_total_chars: 0.1670
+    mean_total_chars: 0.1576
   zipf:
     mean_exponent: -0.0353
     mean_r_squared: 0.0037
@@ -112,18 +111,16 @@ docstring_is_nonempty:
 
 file_has_license_header:
   _doc: "Source files should begin with a license or copyright header."
-  _fix_hint: "Add a license header comment at the top of the file"
-  _languages: [elixir]
-  _log_baseline: 5.7261
+  _log_baseline: 5.8777
   branching:
     mean_branching_density: -0.0081
     mean_non_blank_count: 0.0080
   brevity:
     mean_sample_size: 0.0263
   casing_entropy:
-    mean_entropy: 0.0312
+    mean_entropy: 0.0296
     mean_pascal_case_count: 0.0957
-    mean_snake_case_count: 0.0036
+    mean_snake_case_count: 0.0039
   comment_structure:
     mean_comment_line_ratio: -2.0000
   compression:
@@ -153,8 +150,7 @@ file_has_license_header:
     mean_beta: -0.0113
     mean_k: 0.0614
   identifier_length_variance:
-    mean_mean: -0.0037
-    mean_variance: -0.0031
+    mean_mean: -0.0048
   indentation:
     mean_blank_line_ratio: 0.0206
     mean_mean_depth: -0.0080
@@ -167,6 +163,7 @@ file_has_license_header:
     mean_magic_number_count: 0.1973
     mean_string_literal_ratio: -0.0104
   near_duplicate_blocks_file:
+    mean_block_count: 0.0650
     mean_sub_block_count: 0.0089
   ngram:
     mean_bigram_hapax_fraction: 0.0086
@@ -188,12 +185,12 @@ file_has_license_header:
     mean_density: -0.0042
     mean_symbol_count: 0.0065
   vocabulary:
-    mean_mattr: 0.0121
-    mean_raw_ttr: 0.0200
-    mean_total_identifiers: 0.0175
-    mean_unique_identifiers: 0.0374
+    mean_mattr: 0.0108
+    mean_raw_ttr: 0.0207
+    mean_total_identifiers: 0.0187
+    mean_unique_identifiers: 0.0395
   vowel_density:
-    mean_total_chars: 0.0138
+    mean_total_chars: 0.0139
   zipf:
     mean_exponent: -0.0055
     mean_total_tokens: 0.0091
@@ -201,9 +198,7 @@ file_has_license_header:
 
 file_has_module_docstring:
   _doc: "Files should have a module-level docstring explaining purpose and usage."
-  _fix_hint: "Add a @moduledoc string describing the module's purpose"
-  _languages: [elixir]
-  _log_baseline: 24.2268
+  _log_baseline: 24.1681
   branching:
     mean_branch_count: 0.3854
     mean_branching_density: -2.0000
@@ -211,9 +206,9 @@ file_has_module_docstring:
   brevity:
     mean_sample_size: 0.2219
   casing_entropy:
-    mean_entropy: -0.0217
+    mean_entropy: -0.0210
     mean_pascal_case_count: 0.0929
-    mean_snake_case_count: 0.1492
+    mean_snake_case_count: 0.1544
   compression:
     mean_raw_bytes: 0.1161
     mean_redundancy: -0.0256
@@ -247,9 +242,9 @@ file_has_module_docstring:
     mean_k: 0.5760
     mean_r_squared: -0.0049
   identifier_length_variance:
-    mean_mean: -0.0059
-    mean_std_dev: -0.0462
-    mean_variance: -0.0924
+    mean_mean: -0.0101
+    mean_std_dev: -0.0477
+    mean_variance: -0.0954
   indentation:
     mean_blank_line_ratio: 0.0686
     mean_mean_depth: -0.0240
@@ -263,7 +258,7 @@ file_has_module_docstring:
     mean_magic_number_count: 0.1599
     mean_string_literal_ratio: 0.1425
   near_duplicate_blocks_file:
-    mean_block_count: 0.3854
+    mean_block_count: 0.0586
     mean_sub_block_count: 0.0098
   ngram:
     mean_bigram_hapax_fraction: 0.0500
@@ -293,12 +288,12 @@ file_has_module_docstring:
     mean_distinct_symbol_types: 0.0618
     mean_symbol_count: 0.0433
   vocabulary:
-    mean_mattr: 0.0527
-    mean_raw_ttr: 0.1365
-    mean_total_identifiers: 0.1309
-    mean_unique_identifiers: 0.2674
+    mean_mattr: 0.0532
+    mean_raw_ttr: 0.1353
+    mean_total_identifiers: 0.1326
+    mean_unique_identifiers: 0.2679
   vowel_density:
-    mean_total_chars: 0.1250
+    mean_total_chars: 0.1226
   zipf:
     mean_exponent: -0.0467
     mean_total_tokens: 0.0837
@@ -306,18 +301,16 @@ file_has_module_docstring:
 
 file_has_no_commented_out_code:
   _doc: "Files should not contain commented-out code blocks left from development."
-  _fix_hint: "Remove commented-out code — use version control to track deleted code"
-  _languages: [elixir]
-  _log_baseline: -8.1616
+  _log_baseline: -8.5677
   branching:
     mean_branching_density: 0.0368
     mean_non_blank_count: -0.0367
   brevity:
     mean_sample_size: -0.0046
   casing_entropy:
-    mean_entropy: -0.0252
-    mean_pascal_case_count: -0.0657
-    mean_snake_case_count: 0.0160
+    mean_entropy: -0.0091
+    mean_pascal_case_count: -0.0597
+    mean_snake_case_count: -0.0126
   comment_structure:
     mean_comment_line_count: -0.9901
     mean_comment_line_ratio: 0.3578
@@ -353,9 +346,9 @@ file_has_no_commented_out_code:
     mean_k: 0.1958
     mean_r_squared: -0.0200
   identifier_length_variance:
-    mean_mean: 0.0074
-    mean_std_dev: 0.0252
-    mean_variance: 0.0503
+    mean_mean: 0.0169
+    mean_std_dev: 0.0264
+    mean_variance: 0.0527
   indentation:
     mean_blank_line_ratio: 0.0551
     mean_max_depth: 0.0324
@@ -369,6 +362,7 @@ file_has_no_commented_out_code:
     mean_density: 2.0000
     mean_string_literal_ratio: -0.0818
   near_duplicate_blocks_file:
+    mean_block_count: -0.0474
     mean_sub_block_count: -0.0454
   ngram:
     mean_bigram_hapax_fraction: 0.0101
@@ -401,12 +395,12 @@ file_has_no_commented_out_code:
     mean_density: -0.0172
     mean_symbol_count: -0.0237
   vocabulary:
-    mean_mattr: -0.0404
-    mean_raw_ttr: -0.0140
-    mean_total_identifiers: -0.0030
-    mean_unique_identifiers: -0.0170
+    mean_mattr: -0.0327
+    mean_raw_ttr: 0.0060
+    mean_total_identifiers: -0.0246
+    mean_unique_identifiers: -0.0186
   vowel_density:
-    mean_total_chars: 0.0044
+    mean_total_chars: -0.0077
   zipf:
     mean_exponent: -0.0043
     mean_total_tokens: -0.0158
@@ -414,9 +408,7 @@ file_has_no_commented_out_code:
 
 function_has_docstring:
   _doc: "Public functions should have a docstring describing behaviour, params, and return value."
-  _fix_hint: "Add @doc strings to public functions describing parameters, return value, and purpose"
-  _languages: [elixir]
-  _log_baseline: 43.0440
+  _log_baseline: 41.6283
   branching:
     mean_branch_count: 0.5279
     mean_branching_density: 0.3832
@@ -424,10 +416,10 @@ function_has_docstring:
   brevity:
     mean_sample_size: 0.2608
   casing_entropy:
-    mean_entropy: -0.0193
+    mean_entropy: -0.0026
     mean_other_count: 0.3105
     mean_pascal_case_count: 0.1852
-    mean_snake_case_count: 0.3052
+    mean_snake_case_count: 0.2708
   comment_structure:
     mean_comment_line_ratio: -2.0000
   compression:
@@ -467,9 +459,9 @@ function_has_docstring:
     mean_k: -0.0612
     mean_r_squared: -0.0041
   identifier_length_variance:
-    mean_mean: -0.0412
-    mean_std_dev: -0.0363
-    mean_variance: -0.0727
+    mean_mean: -0.0191
+    mean_std_dev: -0.0493
+    mean_variance: -0.0985
   indentation:
     mean_blank_line_ratio: 0.1003
     mean_max_depth: -0.1288
@@ -484,9 +476,10 @@ function_has_docstring:
     mean_magic_number_count: 0.4104
     mean_string_literal_ratio: 0.5931
   near_duplicate_blocks_file:
-    mean_block_count: 0.6209
-    mean_near_dup_block_d6: 0.3105
-    mean_near_dup_block_d8: 0.3105
+    mean_block_count: 0.2288
+    mean_near_dup_block_d6: -0.3105
+    mean_near_dup_block_d7: 0.3105
+    mean_near_dup_block_d8: -0.1816
     mean_sub_block_count: 0.0349
   ngram:
     mean_bigram_hapax_fraction: 0.0560
@@ -520,12 +513,12 @@ function_has_docstring:
     mean_distinct_symbol_types: 0.0427
     mean_symbol_count: 0.1896
   vocabulary:
-    mean_mattr: 0.1771
-    mean_raw_ttr: 0.0544
-    mean_total_identifiers: 0.2819
-    mean_unique_identifiers: 0.3363
+    mean_mattr: 0.1769
+    mean_raw_ttr: 0.0666
+    mean_total_identifiers: 0.2541
+    mean_unique_identifiers: 0.3207
   vowel_density:
-    mean_total_chars: 0.2407
+    mean_total_chars: 0.2350
   zipf:
     mean_exponent: 0.0025
     mean_total_tokens: 0.2284
@@ -533,9 +526,7 @@ function_has_docstring:
 
 function_todo_comment_in_body:
   _doc: "Functions should not contain TODO/FIXME comments indicating unfinished work."
-  _fix_hint: "Resolve or extract TODO comments — create a tracked issue instead of leaving them inline"
-  _languages: [elixir]
-  _log_baseline: 7.0511
+  _log_baseline: 7.2394
   branching:
     mean_branch_count: -0.0287
     mean_branching_density: -0.0435
@@ -543,9 +534,9 @@ function_todo_comment_in_body:
   brevity:
     mean_sample_size: -0.0084
   casing_entropy:
-    mean_entropy: 0.0039
-    mean_pascal_case_count: 0.0055
-    mean_snake_case_count: -0.0047
+    mean_entropy: 0.0157
+    mean_pascal_case_count: 0.0410
+    mean_snake_case_count: -0.0125
   comment_structure:
     mean_comment_line_count: -0.5392
     mean_comment_line_ratio: 0.7796
@@ -582,9 +573,9 @@ function_todo_comment_in_body:
     mean_k: 0.1608
     mean_r_squared: -0.0095
   identifier_length_variance:
-    mean_mean: 0.0058
-    mean_std_dev: 0.0154
-    mean_variance: 0.0309
+    mean_mean: 0.0061
+    mean_std_dev: 0.0128
+    mean_variance: 0.0257
   indentation:
     mean_blank_line_ratio: 0.0593
     mean_mean_depth: -0.0184
@@ -597,6 +588,7 @@ function_todo_comment_in_body:
     mean_density: -2.0000
     mean_string_literal_ratio: -0.0151
   near_duplicate_blocks_file:
+    mean_block_count: 0.0317
     mean_sub_block_count: 0.0281
   ngram:
     mean_bigram_hapax_fraction: -0.0187
@@ -628,12 +620,11 @@ function_todo_comment_in_body:
     mean_distinct_symbol_types: -0.0140
     mean_symbol_count: 0.0200
   vocabulary:
-    mean_mattr: -0.0437
-    mean_raw_ttr: -0.0159
-    mean_total_identifiers: -0.0024
-    mean_unique_identifiers: -0.0182
+    mean_mattr: -0.0525
+    mean_raw_ttr: -0.0250
+    mean_unique_identifiers: -0.0236
   vowel_density:
-    mean_total_chars: 0.0035
+    mean_total_chars: 0.0076
   zipf:
     mean_total_tokens: 0.0157
     mean_vocab_size: -0.0084
diff --git a/priv/combined_metrics/error_handling.yml b/priv/combined_metrics/error_handling.yml
index a0b8b49..ce7d040 100644
--- a/priv/combined_metrics/error_handling.yml
+++ b/priv/combined_metrics/error_handling.yml
@@ -1,8 +1,6 @@
 does_not_swallow_errors:
   _doc: "Errors must be handled or re-raised — empty rescue/catch blocks silently hide failures."
-  _fix_hint: "Propagate or log errors — do not silently discard {:error, _} tuples or rescue clauses"
-  _languages: [elixir]
-  _log_baseline: 87.3594
+  _log_baseline: 86.0584
   branching:
     mean_branch_count: -0.1041
     mean_branching_density: -0.2095
@@ -11,10 +9,10 @@ does_not_swallow_errors:
   brevity:
     mean_sample_size: 0.2830
   casing_entropy:
-    mean_entropy: -0.1673
+    mean_entropy: -0.1412
     mean_other_count: -1.6214
     mean_pascal_case_count: 0.8391
-    mean_snake_case_count: 0.5551
+    mean_snake_case_count: 0.4785
   compression:
     mean_raw_bytes: 0.3818
     mean_redundancy: 0.0202
@@ -49,9 +47,8 @@ does_not_swallow_errors:
     mean_beta: -0.0869
     mean_k: 0.2466
   identifier_length_variance:
-    mean_mean: -0.0142
-    mean_std_dev: -0.1252
-    mean_variance: -0.2505
+    mean_std_dev: -0.1168
+    mean_variance: -0.2335
   indentation:
     mean_blank_line_ratio: 0.0451
     mean_max_depth: 0.1740
@@ -65,6 +62,9 @@ does_not_swallow_errors:
   magic_number_density:
     mean_string_literal_ratio: 0.2524
   near_duplicate_blocks_file:
+    mean_near_dup_block_d0: -0.5405
+    mean_near_dup_block_d7: -0.3162
+    mean_near_dup_block_d8: 0.8566
     mean_sub_block_count: 0.3065
   ngram:
     mean_bigram_hapax_fraction: -0.0373
@@ -98,12 +98,12 @@ does_not_swallow_errors:
     mean_distinct_symbol_types: 0.0400
     mean_symbol_count: 0.6378
   vocabulary:
-    mean_mattr: 0.0190
-    mean_raw_ttr: -0.1464
-    mean_total_identifiers: 0.5481
-    mean_unique_identifiers: 0.4017
+    mean_mattr: 0.0350
+    mean_raw_ttr: -0.0769
+    mean_total_identifiers: 0.4896
+    mean_unique_identifiers: 0.4127
   vowel_density:
-    mean_total_chars: 0.5339
+    mean_total_chars: 0.4927
   zipf:
     mean_exponent: 0.0933
     mean_total_tokens: 0.4926
@@ -111,9 +111,7 @@ does_not_swallow_errors:
 
 error_message_is_descriptive:
   _doc: "Error values should carry a meaningful message, not just a bare atom or empty string."
-  _fix_hint: "Include context in error messages — describe what failed, not just that it failed"
-  _languages: [elixir]
-  _log_baseline: 52.7594
+  _log_baseline: 52.7053
   branching:
     mean_branch_count: 0.0664
     mean_branching_density: -0.0540
@@ -122,9 +120,9 @@ error_message_is_descriptive:
   brevity:
     mean_sample_size: 0.3136
   casing_entropy:
-    mean_entropy: 0.1513
+    mean_entropy: 0.1147
     mean_pascal_case_count: 2.0000
-    mean_snake_case_count: 0.4347
+    mean_snake_case_count: 0.5117
   compression:
     mean_raw_bytes: 0.3028
     mean_redundancy: 0.0104
@@ -160,9 +158,9 @@ error_message_is_descriptive:
     mean_k: 0.1259
     mean_r_squared: 0.0073
   identifier_length_variance:
-    mean_mean: -0.0598
-    mean_std_dev: -0.0787
-    mean_variance: -0.1573
+    mean_mean: -0.0908
+    mean_std_dev: -0.0799
+    mean_variance: -0.1597
   indentation:
     mean_blank_line_ratio: -0.1098
     mean_max_depth: 0.1754
@@ -176,6 +174,8 @@ error_message_is_descriptive:
   magic_number_density:
     mean_string_literal_ratio: 0.3673
   near_duplicate_blocks_file:
+    mean_near_dup_block_d6: -1.0566
+    mean_near_dup_block_d8: -0.6667
     mean_sub_block_count: 0.0621
   ngram:
     mean_bigram_hapax_fraction: -0.0059
@@ -203,12 +203,12 @@ error_message_is_descriptive:
     mean_distinct_symbol_types: 0.0664
     mean_symbol_count: 0.3056
   vocabulary:
-    mean_mattr: 0.0721
-    mean_raw_ttr: -0.0454
-    mean_total_identifiers: 0.4472
-    mean_unique_identifiers: 0.4018
+    mean_mattr: -0.0179
+    mean_raw_ttr: -0.1153
+    mean_total_identifiers: 0.5114
+    mean_unique_identifiers: 0.3962
   vowel_density:
-    mean_total_chars: 0.3874
+    mean_total_chars: 0.4207
   zipf:
     mean_r_squared: 0.0056
     mean_total_tokens: 0.3002
@@ -216,113 +216,117 @@ error_message_is_descriptive:
 
 returns_typed_error:
   _doc: "Functions should signal failure via a typed return (e.g. `{:error, reason}`) rather than returning `nil` or `false`."
-  _fix_hint: "Return typed errors like {:error, :not_found} instead of bare :error or nil"
-  _languages: [elixir]
-  _log_baseline: 208.7673
+  _log_baseline: 120.8554
   branching:
-    mean_branch_count: -0.2092
-    mean_branching_density: -0.3081
-    mean_max_nesting_depth: 1.8360
-    mean_non_blank_count: 0.0989
+    mean_branch_count: -0.1286
+    mean_branching_density: -0.1895
+    mean_max_nesting_depth: 1.1292
+    mean_non_blank_count: 0.0608
   brevity:
-    mean_sample_size: 0.3776
+    mean_sample_size: 0.2322
   casing_entropy:
-    mean_entropy: -0.7806
-    mean_other_count: -0.4385
-    mean_pascal_case_count: 1.1584
-    mean_snake_case_count: 1.2656
+    mean_entropy: -0.3072
+    mean_other_count: -0.2697
+    mean_pascal_case_count: 0.7124
+    mean_snake_case_count: 0.6125
   compression:
-    mean_raw_bytes: 0.7114
-    mean_redundancy: 0.0542
-    mean_unique_line_ratio: 0.2391
-    mean_zlib_bytes: 0.5668
-    mean_zlib_ratio: 0.1446
+    mean_raw_bytes: 0.4375
+    mean_redundancy: 0.0334
+    mean_unique_line_ratio: 0.1471
+    mean_zlib_bytes: 0.3486
+    mean_zlib_ratio: 0.0889
   entropy:
-    mean_char_entropy: 0.1388
-    mean_char_max_entropy: 0.0695
-    mean_char_normalized: 0.0692
-    mean_token_entropy: -0.0195
-    mean_token_max_entropy: 0.0863
-    mean_token_normalized: -0.1059
-    mean_total_tokens: 1.0937
-    mean_vocab_size: 0.3776
+    mean_char_entropy: 0.0854
+    mean_char_max_entropy: 0.0427
+    mean_char_normalized: 0.0426
+    mean_token_entropy: -0.0120
+    mean_token_max_entropy: 0.0531
+    mean_token_normalized: -0.0651
+    mean_total_tokens: 0.6727
+    mean_vocab_size: 0.2322
   function_metrics:
-    mean_avg_function_lines: 0.1470
-    mean_avg_param_count: 0.0087
-    mean_function_count: -0.0904
-    mean_max_function_lines: 0.1338
+    mean_avg_function_lines: 0.0904
+    mean_avg_param_count: 0.0054
+    mean_function_count: -0.0556
+    mean_max_function_lines: 0.0823
   halstead:
-    mean_N1_total_operators: 1.2868
-    mean_N2_total_operands: 0.8935
-    mean_difficulty: 0.7343
-    mean_effort: 2.0000
-    mean_estimated_bugs: 1.2657
-    mean_length: 1.1609
-    mean_n1_unique_operators: 0.3422
-    mean_n2_unique_operands: 0.5015
-    mean_time_to_implement_seconds: 2.0000
-    mean_vocabulary: 0.4467
-    mean_volume: 1.2657
+    mean_N1_total_operators: 0.7914
+    mean_N2_total_operands: 0.5495
+    mean_difficulty: 0.4516
+    mean_effort: 1.2300
+    mean_estimated_bugs: 0.7784
+    mean_length: 0.7139
+    mean_n1_unique_operators: 0.2105
+    mean_n2_unique_operands: 0.3084
+    mean_time_to_implement_seconds: 1.2300
+    mean_vocabulary: 0.2747
+    mean_volume: 0.7785
   heaps:
-    mean_beta: -0.3791
-    mean_k: 0.7841
-    mean_r_squared: 0.0178
+    mean_beta: -0.2332
+    mean_k: 0.4822
+    mean_r_squared: 0.0110
   identifier_length_variance:
-    mean_max: 0.3245
-    mean_std_dev: 0.3851
-    mean_variance: 0.7704
+    mean_max: 0.1996
+    mean_mean: 0.1313
+    mean_std_dev: 0.2519
+    mean_variance: 0.5039
   indentation:
-    mean_blank_line_ratio: -0.2464
-    mean_mean_depth: -0.0466
-    mean_variance: 0.0604
+    mean_blank_line_ratio: -0.1515
+    mean_mean_depth: -0.0287
+    mean_variance: 0.0372
   line_patterns:
-    mean_blank_line_ratio: -0.2464
-    mean_max_nesting_depth: 1.8360
-    mean_string_literal_ratio: -1.0976
-    mean_unique_line_ratio: 0.2365
+    mean_blank_line_ratio: -0.1515
+    mean_max_nesting_depth: 1.1292
+    mean_string_literal_ratio: -0.6750
+    mean_unique_line_ratio: 0.1454
   magic_number_density:
-    mean_string_literal_ratio: -1.0976
+    mean_string_literal_ratio: -0.6750
   near_duplicate_blocks_file:
-    mean_sub_block_count: 1.2007
+    mean_block_count: -0.0980
+    mean_near_dup_block_d0: -1.4248
+    mean_near_dup_block_d6: 0.7124
+    mean_near_dup_block_d7: -1.0081
+    mean_near_dup_block_d8: -2.0000
+    mean_sub_block_count: 0.7384
   ngram:
-    mean_bigram_hapax_fraction: -0.2293
-    mean_bigram_repeated_unique: 0.7952
-    mean_bigram_repetition_rate: 0.2117
-    mean_bigram_total: 1.0959
-    mean_bigram_unique: 0.5042
-    mean_trigram_hapax_fraction: -0.0889
-    mean_trigram_repeated_unique: 0.8135
-    mean_trigram_repetition_rate: 0.3853
-    mean_trigram_total: 1.0981
-    mean_trigram_unique: 0.5821
+    mean_bigram_hapax_fraction: -0.1410
+    mean_bigram_repeated_unique: 0.4891
+    mean_bigram_repetition_rate: 0.1302
+    mean_bigram_total: 0.6740
+    mean_bigram_unique: 0.3101
+    mean_trigram_hapax_fraction: -0.0547
+    mean_trigram_repeated_unique: 0.5003
+    mean_trigram_repetition_rate: 0.2370
+    mean_trigram_total: 0.6753
+    mean_trigram_unique: 0.3580
   punctuation_density:
-    mean_arrow_density: -1.3061
-    mean_bracket_nonalpha_prefix_count: -0.3047
-    mean_colon_suffix_density: -1.3955
-    mean_dot_count: 1.8360
-    mean_id_nonalpha_suffix_density: 0.1318
-    mean_question_mark_density: -1.0680
+    mean_arrow_density: -0.8033
+    mean_bracket_nonalpha_prefix_count: -0.1874
+    mean_colon_suffix_density: -0.8583
+    mean_dot_count: 1.1292
+    mean_id_nonalpha_suffix_density: 0.0810
+    mean_question_mark_density: -0.6568
   readability:
-    mean_avg_line_length: 0.6431
-    mean_avg_sub_words_per_id: 0.1542
-    mean_avg_tokens_per_line: 0.9948
-    mean_flesch_adapted: -0.2067
-    mean_fog_adapted: 1.0791
-    mean_total_lines: 0.0989
+    mean_avg_line_length: 0.3955
+    mean_avg_sub_words_per_id: 0.0948
+    mean_avg_tokens_per_line: 0.6118
+    mean_flesch_adapted: -0.1272
+    mean_fog_adapted: 0.6637
+    mean_total_lines: 0.0608
   symbol_density:
-    mean_density: 0.9451
-    mean_distinct_symbol_types: 0.3470
-    mean_symbol_count: 1.6563
+    mean_density: 0.5813
+    mean_distinct_symbol_types: 0.2134
+    mean_symbol_count: 1.0187
   vocabulary:
-    mean_mattr: -0.4659
-    mean_raw_ttr: -0.6552
-    mean_total_identifiers: 1.1152
-    mean_unique_identifiers: 0.4603
+    mean_mattr: -0.2229
+    mean_raw_ttr: -0.2020
+    mean_total_identifiers: 0.4979
+    mean_unique_identifiers: 0.2957
   vowel_density:
-    mean_total_chars: 1.1198
+    mean_total_chars: 0.6292
   zipf:
-    mean_exponent: 0.1702
-    mean_r_squared: 0.0411
-    mean_total_tokens: 1.0937
-    mean_vocab_size: 0.3776
+    mean_exponent: 0.1047
+    mean_r_squared: 0.0253
+    mean_total_tokens: 0.6727
+    mean_vocab_size: 0.2322
 
diff --git a/priv/combined_metrics/file_structure.yml b/priv/combined_metrics/file_structure.yml
index 73376ce..b38fc00 100644
--- a/priv/combined_metrics/file_structure.yml
+++ b/priv/combined_metrics/file_structure.yml
@@ -1,7 +1,5 @@
 has_consistent_indentation:
   _doc: "Files should use a single, consistent indentation style with no mixed tabs and spaces."
-  _fix_hint: "Use a consistent indentation width throughout the file (2 or 4 spaces, not mixed)"
-  _languages: [elixir]
   _log_baseline: -12.7016
   branching:
     mean_branching_density: 0.1994
@@ -37,9 +35,7 @@ has_consistent_indentation:
 
 line_count_under_300:
   _doc: "Files should be under 300 lines; longer files typically violate single responsibility."
-  _fix_hint: "Split large files — extract cohesive groups of functions into separate modules"
-  _languages: [elixir]
-  _log_baseline: -49.2655
+  _log_baseline: -45.8565
   branching:
     mean_branch_count: -0.4508
     mean_branching_density: -0.2446
@@ -47,10 +43,10 @@ line_count_under_300:
   brevity:
     mean_sample_size: -0.2062
   casing_entropy:
-    mean_entropy: 0.0366
+    mean_entropy: 0.0413
     mean_other_count: -0.6011
     mean_pascal_case_count: 0.1036
-    mean_snake_case_count: -0.1860
+    mean_snake_case_count: -0.2080
   compression:
     mean_raw_bytes: -0.2263
     mean_redundancy: -0.0026
@@ -90,9 +86,9 @@ line_count_under_300:
     mean_r_squared: -0.0094
   identifier_length_variance:
     mean_max: -0.0671
-    mean_mean: -0.0670
-    mean_std_dev: 0.0028
-    mean_variance: 0.0055
+    mean_mean: -0.0614
+    mean_std_dev: 0.0205
+    mean_variance: 0.0411
   indentation:
     mean_blank_line_ratio: -0.4899
     mean_max_depth: 0.0301
@@ -107,8 +103,10 @@ line_count_under_300:
     mean_magic_number_count: -0.4114
     mean_string_literal_ratio: 0.0039
   near_duplicate_blocks_file:
-    mean_block_count: 0.1772
-    mean_sub_block_count: -0.1378
+    mean_block_count: 0.5617
+    mean_near_dup_block_d7: 0.1772
+    mean_near_dup_block_d8: 0.1772
+    mean_sub_block_count: 1.0591
   ngram:
     mean_bigram_hapax_fraction: -0.0655
     mean_bigram_repeated_unique: -0.1356
@@ -141,12 +139,12 @@ line_count_under_300:
     mean_distinct_symbol_types: -0.0604
     mean_symbol_count: -0.1504
   vocabulary:
-    mean_mattr: -0.1338
-    mean_raw_ttr: -0.0761
-    mean_total_identifiers: -0.1689
-    mean_unique_identifiers: -0.2450
+    mean_mattr: -0.1396
+    mean_raw_ttr: -0.0669
+    mean_total_identifiers: -0.1838
+    mean_unique_identifiers: -0.2507
   vowel_density:
-    mean_total_chars: -0.2359
+    mean_total_chars: -0.2452
   zipf:
     mean_exponent: 0.0102
     mean_r_squared: -0.0067
@@ -155,17 +153,15 @@ line_count_under_300:
 
 line_length_under_120:
   _doc: "Lines should be under 120 characters to avoid horizontal scrolling."
-  _fix_hint: "Wrap lines at 80–120 characters — break long expressions into multiple lines"
-  _languages: [elixir]
-  _log_baseline: -6.2404
+  _log_baseline: -6.2041
   branching:
     mean_branching_density: -0.1942
     mean_non_blank_count: 0.1944
   brevity:
     mean_sample_size: -0.0200
   casing_entropy:
-    mean_entropy: -0.0025
-    mean_snake_case_count: 0.0039
+    mean_entropy: -0.0047
+    mean_snake_case_count: 0.0074
   compression:
     mean_raw_bytes: 0.0170
     mean_redundancy: 0.0140
@@ -200,9 +196,9 @@ line_length_under_120:
     mean_beta: -0.0068
     mean_k: 0.0086
   identifier_length_variance:
-    mean_mean: -0.0176
-    mean_std_dev: -0.0468
-    mean_variance: -0.0936
+    mean_mean: -0.0207
+    mean_std_dev: -0.0480
+    mean_variance: -0.0960
   indentation:
     mean_blank_line_ratio: -0.0420
     mean_max_depth: 0.1137
@@ -246,10 +242,10 @@ line_length_under_120:
     mean_distinct_symbol_types: -0.0130
     mean_symbol_count: -0.0078
   vocabulary:
-    mean_mattr: -0.0207
-    mean_raw_ttr: -0.0312
-    mean_total_identifiers: 0.0036
-    mean_unique_identifiers: -0.0276
+    mean_mattr: -0.0231
+    mean_raw_ttr: -0.0300
+    mean_total_identifiers: 0.0067
+    mean_unique_identifiers: -0.0232
   vowel_density:
     mean_total_chars: -0.0140
   zipf:
@@ -259,9 +255,7 @@ line_length_under_120:
 
 no_magic_numbers:
   _doc: "Numeric literals should be extracted to named constants rather than used inline."
-  _fix_hint: "Replace literal numbers with named constants or module attributes"
-  _languages: [elixir]
-  _log_baseline: 107.5222
+  _log_baseline: 105.2910
   branching:
     mean_branch_count: -0.4352
     mean_branching_density: -0.9103
@@ -269,8 +263,8 @@ no_magic_numbers:
   brevity:
     mean_sample_size: 0.3955
   casing_entropy:
-    mean_entropy: -0.4640
-    mean_snake_case_count: 0.7640
+    mean_entropy: -0.5234
+    mean_snake_case_count: 0.9072
   compression:
     mean_raw_bytes: 0.7713
     mean_redundancy: 0.1328
@@ -307,9 +301,9 @@ no_magic_numbers:
     mean_r_squared: -0.0645
   identifier_length_variance:
     mean_max: 0.2172
-    mean_mean: 0.5105
-    mean_std_dev: 0.5395
-    mean_variance: 1.0791
+    mean_mean: 0.4886
+    mean_std_dev: 0.4918
+    mean_variance: 0.9835
   indentation:
     mean_blank_line_ratio: 0.3137
     mean_mean_depth: -0.4612
@@ -323,6 +317,9 @@ no_magic_numbers:
     mean_magic_number_count: -0.8032
     mean_string_literal_ratio: -0.5060
   near_duplicate_blocks_file:
+    mean_block_count: -0.1911
+    mean_near_dup_block_d0: -1.6546
+    mean_near_dup_block_d7: -1.0789
     mean_sub_block_count: 0.3466
   ngram:
     mean_bigram_hapax_fraction: -0.1520
@@ -351,11 +348,12 @@ no_magic_numbers:
     mean_density: -0.3071
     mean_symbol_count: 0.4654
   vocabulary:
-    mean_mattr: 0.3317
-    mean_total_identifiers: 0.6600
-    mean_unique_identifiers: 0.6581
+    mean_mattr: 0.3553
+    mean_raw_ttr: -0.0669
+    mean_total_identifiers: 0.7640
+    mean_unique_identifiers: 0.6968
   vowel_density:
-    mean_total_chars: 1.1705
+    mean_total_chars: 1.2526
   zipf:
     mean_exponent: -0.1353
     mean_r_squared: -0.0320
@@ -364,9 +362,7 @@ no_magic_numbers:
 
 single_responsibility:
   _doc: "Each file should have one primary concern — low complexity spread across few, focused functions."
-  _fix_hint: "Split the module — each file should have one primary purpose"
-  _languages: [elixir]
-  _log_baseline: -35.4996
+  _log_baseline: -36.0617
   branching:
     mean_branch_count: -0.0678
     mean_branching_density: 0.1364
@@ -375,9 +371,10 @@ single_responsibility:
   brevity:
     mean_sample_size: -0.0864
   casing_entropy:
+    mean_entropy: -0.0206
     mean_other_count: -0.7475
     mean_pascal_case_count: 0.0470
-    mean_snake_case_count: -0.1816
+    mean_snake_case_count: -0.1543
   compression:
     mean_raw_bytes: -0.1908
     mean_redundancy: -0.0351
@@ -416,9 +413,9 @@ single_responsibility:
     mean_r_squared: -0.0163
   identifier_length_variance:
     mean_max: -0.0836
-    mean_mean: -0.0346
-    mean_std_dev: -0.0825
-    mean_variance: -0.1650
+    mean_mean: -0.0508
+    mean_std_dev: -0.0865
+    mean_variance: -0.1729
   indentation:
     mean_blank_line_ratio: 0.0458
     mean_mean_depth: -0.0476
@@ -432,6 +429,9 @@ single_responsibility:
     mean_density: 0.1469
     mean_string_literal_ratio: -0.1759
   near_duplicate_blocks_file:
+    mean_block_count: -0.2284
+    mean_near_dup_block_d0: -0.2962
+    mean_near_dup_block_d7: -0.3737
     mean_sub_block_count: -0.1348
   ngram:
     mean_bigram_hapax_fraction: 0.0075
@@ -465,12 +465,12 @@ single_responsibility:
     mean_distinct_symbol_types: 0.0284
     mean_symbol_count: -0.1225
   vocabulary:
-    mean_mattr: -0.0474
-    mean_raw_ttr: 0.0249
-    mean_total_identifiers: -0.1662
-    mean_unique_identifiers: -0.1414
+    mean_mattr: -0.0285
+    mean_raw_ttr: 0.0110
+    mean_total_identifiers: -0.1419
+    mean_unique_identifiers: -0.1309
   vowel_density:
-    mean_total_chars: -0.2009
+    mean_total_chars: -0.1927
   zipf:
     mean_exponent: -0.0209
     mean_r_squared: -0.0043
@@ -479,8 +479,6 @@ single_responsibility:
 
 uses_standard_indentation_width:
   _doc: "Indentation should use consistent multiples of 2 or 4 spaces throughout the file."
-  _fix_hint: "Use the project-standard 2-space indentation throughout"
-  _languages: [elixir]
   _log_baseline: -17.9172
   compression:
     mean_raw_bytes: -0.2512
@@ -499,6 +497,9 @@ uses_standard_indentation_width:
     mean_variance: -2.0000
   line_patterns:
     mean_blank_line_ratio: 0.2077
+  near_duplicate_blocks_file:
+    mean_near_dup_block_d3: -1.0000
+    mean_near_dup_block_d4: 1.0000
   punctuation_density:
     mean_exclamation_density: 0.2630
     mean_question_mark_density: 0.2630
diff --git a/priv/combined_metrics/function_design.yml b/priv/combined_metrics/function_design.yml
index b97868b..cb1d808 100644
--- a/priv/combined_metrics/function_design.yml
+++ b/priv/combined_metrics/function_design.yml
@@ -1,7 +1,5 @@
 boolean_function_has_question_mark:
   _doc: "Functions returning a boolean should end with `?` (Elixir/Ruby) or start with `is_`/`has_` (JS/Python)."
-  _fix_hint: "Add a ? suffix to boolean-returning functions (e.g., valid? instead of is_valid)"
-  _languages: [elixir]
   _log_baseline: 7.0991
   brevity:
     mean_sample_size: 0.0085
@@ -47,17 +45,15 @@ boolean_function_has_question_mark:
 
 cyclomatic_complexity_under_10:
   _doc: "Functions should have a cyclomatic complexity under 10."
-  _fix_hint: "Reduce branching — extract complex conditionals into helper functions"
-  _languages: [elixir]
-  _log_baseline: -1.6476
+  _log_baseline: -1.4896
   branching:
     mean_branch_count: -0.2373
     mean_branching_density: -0.1952
     mean_non_blank_count: -0.0421
   casing_entropy:
-    mean_entropy: 0.1030
+    mean_entropy: 0.0964
     mean_other_count: 0.3306
-    mean_snake_case_count: 0.0284
+    mean_snake_case_count: 0.0321
   compression:
     mean_raw_bytes: -0.0162
     mean_redundancy: -0.0172
@@ -91,9 +87,9 @@ cyclomatic_complexity_under_10:
     mean_k: 0.0672
     mean_r_squared: 0.0049
   identifier_length_variance:
-    mean_mean: 0.0092
-    mean_std_dev: 0.0209
-    mean_variance: 0.0418
+    mean_mean: 0.0130
+    mean_std_dev: 0.0120
+    mean_variance: 0.0240
   indentation:
     mean_blank_line_ratio: 0.1655
     mean_max_depth: -0.2086
@@ -107,6 +103,8 @@ cyclomatic_complexity_under_10:
     mean_density: -0.0329
     mean_string_literal_ratio: -0.0439
   near_duplicate_blocks_file:
+    mean_block_count: 0.1013
+    mean_near_dup_block_d8: -0.2086
     mean_sub_block_count: 0.0994
   ngram:
     mean_bigram_hapax_fraction: -0.0068
@@ -139,12 +137,12 @@ cyclomatic_complexity_under_10:
     mean_distinct_symbol_types: -0.0172
     mean_symbol_count: 0.0391
   vocabulary:
-    mean_mattr: -0.0325
-    mean_raw_ttr: -0.0309
-    mean_total_identifiers: 0.0382
-    mean_unique_identifiers: 0.0074
+    mean_mattr: -0.0361
+    mean_raw_ttr: -0.0361
+    mean_total_identifiers: 0.0441
+    mean_unique_identifiers: 0.0080
   vowel_density:
-    mean_total_chars: 0.0474
+    mean_total_chars: 0.0572
   zipf:
     mean_exponent: 0.0120
     mean_r_squared: 0.0057
@@ -152,36 +150,32 @@ cyclomatic_complexity_under_10:
 
 has_verb_in_name:
   _doc: "Function names should contain a verb describing the action performed."
-  _fix_hint: "Start function names with a verb (get_, fetch_, build_, compute_, validate_)"
-  _languages: [elixir]
-  _log_baseline: 15.9117
+  _log_baseline: 14.8350
   compression:
-    mean_raw_bytes: 0.0990
-    mean_redundancy: -0.0473
-    mean_zlib_bytes: 0.2439
-    mean_zlib_ratio: -0.1449
+    mean_raw_bytes: 0.0816
+    mean_redundancy: -0.0390
+    mean_zlib_bytes: 0.2011
+    mean_zlib_ratio: -0.1195
   identifier_length_variance:
-    mean_max: 0.9396
-    mean_mean: 0.1989
-    mean_std_dev: 1.0001
+    mean_max: 0.7747
+    mean_mean: 0.2058
+    mean_std_dev: 1.0000
     mean_variance: 2.0000
   punctuation_density:
-    mean_exclamation_density: -0.1305
+    mean_exclamation_density: -0.1076
   readability:
-    mean_avg_line_length: 0.1026
-    mean_avg_sub_words_per_id: 0.1614
-    mean_flesch_adapted: -0.1605
-    mean_fog_adapted: 1.6084
+    mean_avg_line_length: 0.0846
+    mean_avg_sub_words_per_id: 0.1330
+    mean_flesch_adapted: -0.1324
+    mean_fog_adapted: 1.3261
   symbol_density:
-    mean_density: -0.1005
+    mean_density: -0.0828
   vowel_density:
-    mean_total_chars: 0.1989
+    mean_total_chars: 0.2058
 
 is_less_than_20_lines:
   _doc: "Functions should be 20 lines or fewer."
-  _fix_hint: "Split long functions — each function should fit on one screen (under 20 lines)"
-  _languages: [elixir]
-  _log_baseline: 23.1945
+  _log_baseline: 23.9658
   branching:
     mean_branch_count: -0.0820
     mean_branching_density: -0.1010
@@ -190,10 +184,10 @@ is_less_than_20_lines:
   brevity:
     mean_sample_size: 0.0165
   casing_entropy:
-    mean_entropy: 0.0640
+    mean_entropy: 0.0577
     mean_other_count: 0.6266
     mean_pascal_case_count: 0.0440
-    mean_snake_case_count: 0.0800
+    mean_snake_case_count: 0.0910
   compression:
     mean_raw_bytes: 0.0746
     mean_redundancy: 0.0227
@@ -228,9 +222,9 @@ is_less_than_20_lines:
   heaps:
     mean_k: -0.0254
   identifier_length_variance:
-    mean_mean: 0.0149
-    mean_std_dev: 0.0313
-    mean_variance: 0.0625
+    mean_mean: 0.0122
+    mean_std_dev: 0.0297
+    mean_variance: 0.0593
   indentation:
     mean_blank_line_ratio: -0.0440
     mean_mean_depth: -0.0962
@@ -245,6 +239,8 @@ is_less_than_20_lines:
     mean_magic_number_count: 0.1156
     mean_string_literal_ratio: -0.0774
   near_duplicate_blocks_file:
+    mean_block_count: 0.2797
+    mean_near_dup_block_d8: 0.3133
     mean_sub_block_count: 0.1886
   ngram:
     mean_bigram_hapax_fraction: -0.0508
@@ -278,12 +274,12 @@ is_less_than_20_lines:
     mean_distinct_symbol_types: 0.0127
     mean_symbol_count: 0.0662
   vocabulary:
-    mean_mattr: -0.0368
-    mean_raw_ttr: -0.0647
-    mean_total_identifiers: 0.0864
-    mean_unique_identifiers: 0.0218
+    mean_mattr: -0.0390
+    mean_raw_ttr: -0.0717
+    mean_total_identifiers: 0.0965
+    mean_unique_identifiers: 0.0248
   vowel_density:
-    mean_total_chars: 0.1013
+    mean_total_chars: 0.1087
   zipf:
     mean_exponent: 0.0225
     mean_r_squared: 0.0030
@@ -292,9 +288,7 @@ is_less_than_20_lines:
 
 nesting_depth_under_4:
   _doc: "Code should not nest deeper than 4 levels."
-  _fix_hint: "Reduce nesting — use early returns, guards, or extract inner blocks"
-  _languages: [elixir]
-  _log_baseline: 1.1322
+  _log_baseline: 1.0611
   branching:
     mean_branch_count: -0.3267
     mean_branching_density: -0.2061
@@ -303,10 +297,10 @@ nesting_depth_under_4:
   brevity:
     mean_sample_size: 0.0178
   casing_entropy:
-    mean_entropy: -0.0358
+    mean_entropy: -0.0207
     mean_other_count: 0.2917
     mean_pascal_case_count: -0.2725
-    mean_snake_case_count: 0.1015
+    mean_snake_case_count: 0.0787
   compression:
     mean_raw_bytes: -0.0069
     mean_redundancy: -0.0076
@@ -342,9 +336,9 @@ nesting_depth_under_4:
     mean_beta: -0.0464
     mean_k: 0.0845
   identifier_length_variance:
-    mean_mean: 0.0488
-    mean_std_dev: 0.1849
-    mean_variance: 0.3698
+    mean_mean: 0.0770
+    mean_std_dev: 0.1858
+    mean_variance: 0.3716
   indentation:
     mean_blank_line_ratio: 0.5622
     mean_max_depth: -0.3155
@@ -358,6 +352,7 @@ nesting_depth_under_4:
   magic_number_density:
     mean_string_literal_ratio: -0.1046
   near_duplicate_blocks_file:
+    mean_block_count: 0.0856
     mean_sub_block_count: 0.1999
   ngram:
     mean_bigram_hapax_fraction: -0.0645
@@ -390,12 +385,12 @@ nesting_depth_under_4:
     mean_density: 0.1426
     mean_symbol_count: 0.1355
   vocabulary:
-    mean_mattr: -0.0321
-    mean_raw_ttr: -0.0555
-    mean_total_identifiers: 0.0987
-    mean_unique_identifiers: 0.0432
+    mean_mattr: -0.0269
+    mean_raw_ttr: -0.0269
+    mean_total_identifiers: 0.0774
+    mean_unique_identifiers: 0.0505
   vowel_density:
-    mean_total_chars: 0.1475
+    mean_total_chars: 0.1544
   zipf:
     mean_exponent: 0.0250
     mean_r_squared: 0.0156
@@ -404,9 +399,7 @@ nesting_depth_under_4:
 
 no_boolean_parameter:
   _doc: "Functions should not take boolean parameters — a flag usually means the function does two things."
-  _fix_hint: "Replace boolean parameters with two separate functions or use an options map"
-  _languages: [elixir]
-  _log_baseline: 3.0928
+  _log_baseline: 13.6290
   branching:
     mean_branch_count: -2.0000
     mean_branching_density: 1.0271
@@ -415,9 +408,9 @@ no_boolean_parameter:
   brevity:
     mean_sample_size: -0.0253
   casing_entropy:
-    mean_entropy: 0.0155
+    mean_entropy: 0.0049
     mean_pascal_case_count: 0.1180
-    mean_snake_case_count: 0.0762
+    mean_snake_case_count: 0.0931
   compression:
     mean_raw_bytes: 0.0435
     mean_redundancy: 0.0777
@@ -453,9 +446,9 @@ no_boolean_parameter:
     mean_beta: -0.0314
     mean_k: 0.0620
   identifier_length_variance:
-    mean_mean: 0.0178
-    mean_std_dev: 0.1693
-    mean_variance: 0.3386
+    mean_mean: 0.0125
+    mean_std_dev: 0.1858
+    mean_variance: 0.3715
   indentation:
     mean_blank_line_ratio: 0.4402
     mean_max_depth: -0.5579
@@ -469,6 +462,14 @@ no_boolean_parameter:
   magic_number_density:
     mean_string_literal_ratio: 0.0206
   near_duplicate_blocks_file:
+    mean_block_count: 0.4338
+    mean_near_dup_block_d0: 1.7685
+    mean_near_dup_block_d2: 1.1158
+    mean_near_dup_block_d4: 1.6737
+    mean_near_dup_block_d5: 1.6737
+    mean_near_dup_block_d6: 1.7685
+    mean_near_dup_block_d7: -0.8842
+    mean_near_dup_block_d8: 0.5579
     mean_sub_block_count: 0.2775
   ngram:
     mean_bigram_hapax_fraction: -0.1940
@@ -499,12 +500,12 @@ no_boolean_parameter:
     mean_density: 0.0479
     mean_symbol_count: 0.0916
   vocabulary:
-    mean_mattr: -0.0611
-    mean_raw_ttr: -0.0924
-    mean_total_identifiers: 0.0811
-    mean_unique_identifiers: -0.0114
+    mean_mattr: -0.0916
+    mean_raw_ttr: -0.1091
+    mean_total_identifiers: 0.0962
+    mean_unique_identifiers: -0.0129
   vowel_density:
-    mean_total_chars: 0.0989
+    mean_total_chars: 0.1087
   zipf:
     mean_exponent: 0.0374
     mean_total_tokens: 0.0692
@@ -512,9 +513,7 @@ no_boolean_parameter:
 
 no_magic_numbers:
   _doc: "Numeric literals should be named constants, not inline magic numbers."
-  _fix_hint: "Replace magic numbers inside functions with named module attributes or constants"
-  _languages: [elixir]
-  _log_baseline: 48.6069
+  _log_baseline: 45.8808
   branching:
     mean_branch_count: -0.2708
     mean_branching_density: -0.1682
@@ -522,8 +521,8 @@ no_magic_numbers:
   brevity:
     mean_sample_size: 0.1527
   casing_entropy:
-    mean_entropy: -0.2876
-    mean_snake_case_count: 0.4222
+    mean_entropy: -0.2908
+    mean_snake_case_count: 0.4279
   compression:
     mean_raw_bytes: 0.3823
     mean_redundancy: 0.0584
@@ -559,9 +558,9 @@ no_magic_numbers:
     mean_r_squared: -0.0256
   identifier_length_variance:
     mean_max: 0.0987
-    mean_mean: 0.3701
-    mean_std_dev: 0.3918
-    mean_variance: 0.7835
+    mean_mean: 0.3721
+    mean_std_dev: 0.3878
+    mean_variance: 0.7757
   indentation:
     mean_blank_line_ratio: 0.2374
     mean_mean_depth: -0.3518
@@ -574,6 +573,9 @@ no_magic_numbers:
     mean_density: -0.2831
     mean_string_literal_ratio: -0.2880
   near_duplicate_blocks_file:
+    mean_block_count: -0.7894
+    mean_near_dup_block_d0: -1.1158
+    mean_near_dup_block_d7: -1.1158
     mean_sub_block_count: 0.2708
   ngram:
     mean_bigram_hapax_fraction: -0.1437
@@ -603,12 +605,12 @@ no_magic_numbers:
     mean_distinct_symbol_types: 0.0644
     mean_symbol_count: 0.3512
   vocabulary:
-    mean_mattr: 0.0054
-    mean_raw_ttr: -0.0161
-    mean_total_identifiers: 0.3860
-    mean_unique_identifiers: 0.3699
+    mean_mattr: 0.0058
+    mean_raw_ttr: -0.0081
+    mean_total_identifiers: 0.3908
+    mean_unique_identifiers: 0.3826
   vowel_density:
-    mean_total_chars: 0.7561
+    mean_total_chars: 0.7629
   zipf:
     mean_exponent: 0.0164
     mean_r_squared: 0.0321
@@ -617,18 +619,16 @@ no_magic_numbers:
 
 parameter_count_under_4:
   _doc: "Functions should take fewer than 4 parameters."
-  _fix_hint: "Reduce parameter count — group related params into a struct or options map"
-  _languages: [elixir]
-  _log_baseline: 1.6218
+  _log_baseline: 1.9637
   branching:
     mean_non_blank_count: 0.0967
   brevity:
     mean_sample_size: 0.0261
   casing_entropy:
-    mean_entropy: 0.5987
+    mean_entropy: 0.5731
     mean_other_count: 0.5408
     mean_pascal_case_count: 0.2329
-    mean_snake_case_count: -0.0580
+    mean_snake_case_count: -0.0351
   compression:
     mean_raw_bytes: -0.0343
     mean_redundancy: -0.0308
@@ -667,9 +667,9 @@ parameter_count_under_4:
     mean_k: -0.0082
     mean_r_squared: -0.0062
   identifier_length_variance:
-    mean_mean: -0.0044
-    mean_std_dev: -0.0221
-    mean_variance: -0.0442
+    mean_mean: -0.0239
+    mean_std_dev: -0.0185
+    mean_variance: -0.0371
   indentation:
     mean_blank_line_ratio: 0.0518
     mean_max_depth: 0.1362
@@ -682,6 +682,9 @@ parameter_count_under_4:
   magic_number_density:
     mean_density: -2.0000
     mean_string_literal_ratio: 0.1674
+  near_duplicate_blocks_file:
+    mean_block_count: 0.0967
+    mean_near_dup_block_d7: -0.4658
   ngram:
     mean_bigram_hapax_fraction: 0.0479
     mean_bigram_repeated_unique: -0.0222
@@ -711,11 +714,11 @@ parameter_count_under_4:
     mean_distinct_symbol_types: 0.1042
     mean_symbol_count: -0.0218
   vocabulary:
-    mean_mattr: 0.0175
-    mean_raw_ttr: 0.0416
-    mean_total_identifiers: -0.0416
+    mean_mattr: 0.0150
+    mean_raw_ttr: 0.0153
+    mean_total_identifiers: -0.0153
   vowel_density:
-    mean_total_chars: -0.0460
+    mean_total_chars: -0.0393
   zipf:
     mean_exponent: 0.0101
     mean_r_squared: -0.0074
@@ -724,106 +727,106 @@ parameter_count_under_4:
 
 uses_ternary_expression:
   _doc: "Simple conditional assignments should use inline expressions rather than full if-blocks."
-  _fix_hint: "Replace verbose if-else blocks with concise ternary/conditional expressions where readable"
-  _languages: [elixir]
-  _log_baseline: -0.3649
+  _log_baseline: -4.5289
   branching:
-    mean_branch_count: -0.4693
-    mean_branching_density: 0.1280
-    mean_non_blank_count: -0.5975
+    mean_branch_count: -0.4160
+    mean_branching_density: 0.1134
+    mean_non_blank_count: -0.5296
   brevity:
-    mean_sample_size: 0.0107
+    mean_sample_size: 0.0095
   casing_entropy:
-    mean_entropy: -0.0141
-    mean_snake_case_count: 0.0271
+    mean_entropy: 0.0068
+    mean_snake_case_count: -0.0141
   compression:
-    mean_raw_bytes: -0.0924
-    mean_redundancy: -0.0709
-    mean_unique_line_ratio: 0.1809
-    mean_zlib_bytes: 0.0167
-    mean_zlib_ratio: -0.1090
+    mean_raw_bytes: -0.0819
+    mean_redundancy: -0.0629
+    mean_unique_line_ratio: 0.1604
+    mean_zlib_bytes: 0.0148
+    mean_zlib_ratio: -0.0967
   entropy:
-    mean_char_entropy: 0.0749
-    mean_char_normalized: 0.0717
-    mean_token_entropy: -0.0088
-    mean_token_normalized: -0.0114
-    mean_total_tokens: 0.0969
-    mean_vocab_size: 0.0107
+    mean_char_entropy: 0.0664
+    mean_char_normalized: 0.0636
+    mean_token_entropy: -0.0078
+    mean_token_normalized: -0.0101
+    mean_total_tokens: 0.0859
+    mean_vocab_size: 0.0095
   function_metrics:
-    mean_avg_function_lines: -0.7654
-    mean_function_count: 0.2745
-    mean_max_function_lines: -0.4693
+    mean_avg_function_lines: -0.6785
+    mean_function_count: 0.2434
+    mean_max_function_lines: -0.4160
   halstead:
-    mean_N1_total_operators: 0.1767
-    mean_N2_total_operands: 0.0622
-    mean_difficulty: 0.0952
-    mean_effort: 0.2409
-    mean_estimated_bugs: 0.1456
-    mean_length: 0.1429
-    mean_n1_unique_operators: 0.0330
-    mean_time_to_implement_seconds: 0.2409
-    mean_vocabulary: 0.0114
-    mean_volume: 0.1457
+    mean_N1_total_operators: 0.1567
+    mean_N2_total_operands: 0.0551
+    mean_difficulty: 0.0844
+    mean_effort: 0.2135
+    mean_estimated_bugs: 0.1291
+    mean_length: 0.1267
+    mean_n1_unique_operators: 0.0293
+    mean_time_to_implement_seconds: 0.2135
+    mean_vocabulary: 0.0101
+    mean_volume: 0.1291
   heaps:
-    mean_beta: -0.0340
-    mean_k: 0.0670
+    mean_beta: -0.0301
+    mean_k: 0.0594
   identifier_length_variance:
-    mean_mean: 0.0616
-    mean_std_dev: 0.0617
-    mean_variance: 0.1234
+    mean_mean: 0.0749
+    mean_std_dev: 0.0535
+    mean_variance: 0.1070
   indentation:
-    mean_blank_line_ratio: 0.5702
-    mean_max_depth: -0.2745
-    mean_mean_depth: -0.3658
-    mean_variance: -0.6153
+    mean_blank_line_ratio: 0.5054
+    mean_max_depth: -0.2434
+    mean_mean_depth: -0.3243
+    mean_variance: -0.5454
   line_patterns:
-    mean_blank_line_ratio: 0.5702
-    mean_string_literal_ratio: -0.0964
-    mean_unique_line_ratio: 0.1839
+    mean_blank_line_ratio: 0.5054
+    mean_string_literal_ratio: -0.0855
+    mean_unique_line_ratio: 0.1630
   magic_number_density:
-    mean_density: -0.0969
-    mean_string_literal_ratio: -0.0964
+    mean_density: -0.0859
+    mean_string_literal_ratio: -0.0855
   near_duplicate_blocks_file:
-    mean_sub_block_count: 0.2745
+    mean_block_count: -0.2821
+    mean_near_dup_block_d0: -2.0000
+    mean_sub_block_count: 0.2434
   ngram:
-    mean_bigram_hapax_fraction: -0.0616
-    mean_bigram_repeated_unique: 0.2415
-    mean_bigram_repetition_rate: 0.0886
-    mean_bigram_total: 0.0973
-    mean_bigram_unique: 0.0487
-    mean_trigram_hapax_fraction: -0.0186
-    mean_trigram_repeated_unique: 0.1511
-    mean_trigram_repetition_rate: 0.1328
-    mean_trigram_total: 0.0977
-    mean_trigram_unique: 0.0452
+    mean_bigram_hapax_fraction: -0.0546
+    mean_bigram_repeated_unique: 0.2141
+    mean_bigram_repetition_rate: 0.0785
+    mean_bigram_total: 0.0863
+    mean_bigram_unique: 0.0432
+    mean_trigram_hapax_fraction: -0.0165
+    mean_trigram_repeated_unique: 0.1339
+    mean_trigram_repetition_rate: 0.1178
+    mean_trigram_total: 0.0866
+    mean_trigram_unique: 0.0400
   punctuation_density:
-    mean_bracket_nonalpha_prefix_count: 0.3060
-    mean_bracket_nonalpha_suffix_count: 0.5928
-    mean_bracket_number_pair_count: 0.4693
-    mean_colon_suffix_density: 2.0000
-    mean_dot_count: -1.3176
-    mean_id_nonalpha_suffix_density: 0.2152
+    mean_bracket_nonalpha_prefix_count: 0.2713
+    mean_bracket_nonalpha_suffix_count: 0.5255
+    mean_bracket_number_pair_count: 0.4160
+    mean_colon_suffix_density: 1.7729
+    mean_dot_count: -1.1679
+    mean_id_nonalpha_suffix_density: 0.1908
   readability:
-    mean_avg_line_length: 0.5254
-    mean_avg_sub_words_per_id: 0.0352
-    mean_avg_tokens_per_line: 0.6944
-    mean_flesch_adapted: -0.0769
-    mean_fog_adapted: 0.6047
-    mean_total_lines: -0.5975
+    mean_avg_line_length: 0.4657
+    mean_avg_sub_words_per_id: 0.0312
+    mean_avg_tokens_per_line: 0.6155
+    mean_flesch_adapted: -0.0682
+    mean_fog_adapted: 0.5360
+    mean_total_lines: -0.5296
   symbol_density:
-    mean_density: 0.3573
-    mean_distinct_symbol_types: 0.0410
-    mean_symbol_count: 0.2651
+    mean_density: 0.3167
+    mean_distinct_symbol_types: 0.0364
+    mean_symbol_count: 0.2350
   vocabulary:
-    mean_mattr: -0.0421
-    mean_raw_ttr: -0.0421
-    mean_total_identifiers: 0.0230
-    mean_unique_identifiers: -0.0191
+    mean_mattr: -0.0068
+    mean_raw_ttr: -0.0068
+    mean_total_identifiers: -0.0117
+    mean_unique_identifiers: -0.0185
   vowel_density:
-    mean_total_chars: 0.0845
+    mean_total_chars: 0.0632
   zipf:
-    mean_exponent: 0.0361
-    mean_r_squared: 0.0150
-    mean_total_tokens: 0.0969
-    mean_vocab_size: 0.0107
+    mean_exponent: 0.0320
+    mean_r_squared: 0.0133
+    mean_total_tokens: 0.0859
+    mean_vocab_size: 0.0095
 
diff --git a/priv/combined_metrics/naming_conventions.yml b/priv/combined_metrics/naming_conventions.yml
index 4f3693d..aa6c6d5 100644
--- a/priv/combined_metrics/naming_conventions.yml
+++ b/priv/combined_metrics/naming_conventions.yml
@@ -1,8 +1,6 @@
 class_name_is_noun:
   _doc: "Class and module names should be nouns describing what they represent, not verbs or gerunds."
-  _fix_hint: "Name modules/classes with nouns (User, OrderProcessor) not verbs"
-  _languages: [elixir]
-  _log_baseline: 4.2909
+  _log_baseline: 2.9861
   brevity:
     mean_sample_size: 0.7106
   compression:
@@ -28,9 +26,9 @@ class_name_is_noun:
     mean_k: -0.6266
   identifier_length_variance:
     mean_max: -0.4031
-    mean_mean: 0.3059
-    mean_std_dev: -0.5093
-    mean_variance: -1.0187
+    mean_mean: 0.3287
+    mean_std_dev: -0.8347
+    mean_variance: -1.6695
   ngram:
     mean_bigram_hapax_fraction: 0.2542
     mean_bigram_repeated_unique: -0.5967
@@ -47,11 +45,11 @@ class_name_is_noun:
   symbol_density:
     mean_density: -0.1381
   vocabulary:
-    mean_mattr: 1.2109
-    mean_raw_ttr: 1.2109
-    mean_unique_identifiers: 1.2116
+    mean_mattr: 1.4020
+    mean_raw_ttr: 1.4020
+    mean_unique_identifiers: 1.4020
   vowel_density:
-    mean_total_chars: 0.3059
+    mean_total_chars: 0.3287
   zipf:
     mean_exponent: -0.2180
     mean_vocab_size: 0.7106
@@ -68,45 +66,41 @@ file_name_matches_primary_export:
 
 function_name_is_not_single_word:
   _doc: "Single-word function names like `run`, `process`, or `handle` are too vague to convey intent."
-  _fix_hint: "Use at least two words in function names to convey intent (e.g., fetch_user not fetch)"
-  _languages: [elixir]
-  _log_baseline: 17.4874
+  _log_baseline: 17.8470
   compression:
-    mean_raw_bytes: 0.2480
-    mean_redundancy: 0.0791
-    mean_zlib_bytes: 0.1049
-    mean_zlib_ratio: 0.1431
+    mean_raw_bytes: 0.2434
+    mean_redundancy: 0.0776
+    mean_zlib_bytes: 0.1029
+    mean_zlib_ratio: 0.1405
   entropy:
-    mean_char_entropy: 0.0245
-    mean_char_normalized: 0.0246
+    mean_char_entropy: 0.0241
+    mean_char_normalized: 0.0241
   identifier_length_variance:
-    mean_max: 0.7830
-    mean_mean: 0.5357
+    mean_max: 0.7685
+    mean_mean: 0.5825
     mean_std_dev: 1.0000
     mean_variance: 2.0000
   readability:
-    mean_avg_line_length: 0.2607
-    mean_avg_sub_words_per_id: 0.3141
-    mean_flesch_adapted: -0.3241
-    mean_fog_adapted: 1.3508
+    mean_avg_line_length: 0.2559
+    mean_avg_sub_words_per_id: 0.3083
+    mean_flesch_adapted: -0.3181
+    mean_fog_adapted: 1.3258
   symbol_density:
-    mean_density: -0.2477
+    mean_density: -0.2431
   vowel_density:
-    mean_total_chars: 0.5357
+    mean_total_chars: 0.5825
 
 function_name_matches_return_type:
   _doc: "Functions prefixed with `get_`, `fetch_`, or `find_` should return the thing they name."
-  _fix_hint: "Align the function name with what it returns (get_ for values, is_/has_ for booleans)"
-  _languages: [elixir]
-  _log_baseline: 7.9532
+  _log_baseline: 7.5638
   branching:
     mean_max_nesting_depth: 0.1335
   brevity:
     mean_sample_size: 0.0257
   casing_entropy:
-    mean_entropy: 0.0452
+    mean_entropy: 0.0310
     mean_other_count: 0.0347
-    mean_snake_case_count: -0.0493
+    mean_snake_case_count: -0.0296
   compression:
     mean_raw_bytes: -0.0190
     mean_redundancy: -0.0180
@@ -137,9 +131,8 @@ function_name_matches_return_type:
     mean_r_squared: 0.0038
   identifier_length_variance:
     mean_max: 0.1082
-    mean_mean: 0.0200
-    mean_std_dev: 0.0081
-    mean_variance: 0.0162
+    mean_std_dev: 0.0326
+    mean_variance: 0.0653
   line_patterns:
     mean_max_nesting_depth: 0.1335
     mean_string_literal_ratio: -0.0027
@@ -148,6 +141,9 @@ function_name_matches_return_type:
     mean_density: -0.0108
     mean_string_literal_ratio: -0.0027
   near_duplicate_blocks_file:
+    mean_near_dup_block_d0: -0.5899
+    mean_near_dup_block_d5: -0.2282
+    mean_near_dup_block_d7: 0.2282
     mean_sub_block_count: 0.0314
   ngram:
     mean_bigram_hapax_fraction: 0.0106
@@ -177,12 +173,12 @@ function_name_matches_return_type:
     mean_distinct_symbol_types: 0.0639
     mean_symbol_count: 0.0442
   vocabulary:
-    mean_mattr: 0.0228
-    mean_raw_ttr: 0.0478
-    mean_total_identifiers: -0.0410
-    mean_unique_identifiers: 0.0068
+    mean_mattr: 0.0350
+    mean_raw_ttr: 0.0299
+    mean_total_identifiers: -0.0225
+    mean_unique_identifiers: 0.0074
   vowel_density:
-    mean_total_chars: -0.0210
+    mean_total_chars: -0.0235
   zipf:
     mean_exponent: -0.0047
     mean_r_squared: 0.0105
@@ -191,17 +187,15 @@ function_name_matches_return_type:
 
 test_name_starts_with_verb:
   _doc: "Test descriptions should start with a verb: `creates`, `raises`, `returns`, not a noun phrase."
-  _fix_hint: "Start test descriptions with a verb (returns, raises, creates, validates)"
-  _languages: [elixir]
-  _log_baseline: 7.8702
+  _log_baseline: 7.8915
   branching:
     mean_branch_count: 1.9977
     mean_branching_density: 2.0000
   brevity:
     mean_sample_size: 0.0694
   casing_entropy:
-    mean_entropy: -0.0749
-    mean_snake_case_count: 0.1317
+    mean_entropy: -0.0711
+    mean_snake_case_count: 0.1381
   compression:
     mean_raw_bytes: 0.0914
     mean_redundancy: 0.0182
@@ -230,8 +224,8 @@ test_name_starts_with_verb:
     mean_k: 0.0795
     mean_r_squared: -0.0081
   identifier_length_variance:
-    mean_std_dev: -0.0221
-    mean_variance: -0.0441
+    mean_std_dev: -0.0192
+    mean_variance: -0.0384
   line_patterns:
     mean_string_literal_ratio: -0.0611
   magic_number_density:
@@ -258,12 +252,11 @@ test_name_starts_with_verb:
   symbol_density:
     mean_density: -0.0912
   vocabulary:
-    mean_mattr: 0.0427
-    mean_raw_ttr: -0.0298
-    mean_total_identifiers: 0.1126
-    mean_unique_identifiers: 0.0828
+    mean_mattr: 0.0463
+    mean_total_identifiers: 0.1129
+    mean_unique_identifiers: 0.1161
   vowel_density:
-    mean_total_chars: 0.1150
+    mean_total_chars: 0.1122
   zipf:
     mean_exponent: -0.0239
     mean_total_tokens: 0.0600
diff --git a/priv/combined_metrics/scope_and_assignment.yml b/priv/combined_metrics/scope_and_assignment.yml
index c21c6dd..9654cc9 100644
--- a/priv/combined_metrics/scope_and_assignment.yml
+++ b/priv/combined_metrics/scope_and_assignment.yml
@@ -1,8 +1,6 @@
 declared_close_to_use:
   _doc: "Variables should be declared near their first use, not hoisted to the top of the function."
-  _fix_hint: "Move variable declarations closer to their first use to reduce cognitive scope"
-  _languages: [elixir]
-  _log_baseline: -59.6022
+  _log_baseline: -59.7486
   branching:
     mean_branch_count: -0.4906
     mean_branching_density: -0.2814
@@ -10,9 +8,9 @@ declared_close_to_use:
   brevity:
     mean_sample_size: -0.2189
   casing_entropy:
-    mean_entropy: 0.1835
+    mean_entropy: 0.1911
     mean_pascal_case_count: -0.1139
-    mean_snake_case_count: -0.3839
+    mean_snake_case_count: -0.4005
   comment_structure:
     mean_comment_line_count: -2.0000
     mean_comment_line_ratio: 1.9655
@@ -50,9 +48,9 @@ declared_close_to_use:
     mean_k: 0.0180
     mean_r_squared: 0.0061
   identifier_length_variance:
-    mean_mean: 0.0259
-    mean_std_dev: 0.0252
-    mean_variance: 0.0505
+    mean_mean: 0.0337
+    mean_std_dev: 0.0216
+    mean_variance: 0.0433
   indentation:
     mean_blank_line_ratio: 0.0720
     mean_mean_depth: 0.0139
@@ -94,12 +92,12 @@ declared_close_to_use:
     mean_distinct_symbol_types: -0.0387
     mean_symbol_count: -0.1541
   vocabulary:
-    mean_mattr: -0.0662
-    mean_raw_ttr: 0.0986
-    mean_total_identifiers: -0.3537
-    mean_unique_identifiers: -0.2551
+    mean_mattr: -0.0812
+    mean_raw_ttr: 0.1048
+    mean_total_identifiers: -0.3668
+    mean_unique_identifiers: -0.2619
   vowel_density:
-    mean_total_chars: -0.3278
+    mean_total_chars: -0.3330
   zipf:
     mean_exponent: -0.0151
     mean_total_tokens: -0.2436
@@ -107,9 +105,7 @@ declared_close_to_use:
 
 mutated_after_initial_assignment:
   _doc: "Variables should not be reassigned after their initial value — prefer introducing a new name."
-  _fix_hint: "Avoid reassigning variables — introduce a new name for each transformed value"
-  _languages: [elixir]
-  _log_baseline: 6.6347
+  _log_baseline: 6.6896
   branching:
     mean_branch_count: 0.1519
     mean_branching_density: 0.2073
@@ -118,9 +114,9 @@ mutated_after_initial_assignment:
   brevity:
     mean_sample_size: 0.0068
   casing_entropy:
-    mean_entropy: -0.0957
+    mean_entropy: -0.0947
     mean_pascal_case_count: -0.2061
-    mean_snake_case_count: -0.0467
+    mean_snake_case_count: -0.0436
   compression:
     mean_raw_bytes: -0.0496
     mean_redundancy: -0.0291
@@ -156,9 +152,9 @@ mutated_after_initial_assignment:
     mean_k: -0.0775
     mean_r_squared: 0.0063
   identifier_length_variance:
-    mean_mean: -0.0225
-    mean_std_dev: 0.0262
-    mean_variance: 0.0525
+    mean_mean: -0.0249
+    mean_std_dev: 0.0286
+    mean_variance: 0.0571
   indentation:
     mean_blank_line_ratio: -0.1139
     mean_max_depth: 0.2725
@@ -204,12 +200,12 @@ mutated_after_initial_assignment:
     mean_distinct_symbol_types: 0.0436
     mean_symbol_count: -0.0402
   vocabulary:
-    mean_mattr: 0.0742
-    mean_raw_ttr: 0.0464
-    mean_total_identifiers: -0.0634
-    mean_unique_identifiers: -0.0170
+    mean_mattr: 0.0885
+    mean_raw_ttr: 0.0564
+    mean_total_identifiers: -0.0623
+    mean_unique_identifiers: -0.0059
   vowel_density:
-    mean_total_chars: -0.0859
+    mean_total_chars: -0.0872
   zipf:
     mean_exponent: -0.0305
     mean_r_squared: 0.0040
@@ -218,109 +214,106 @@ mutated_after_initial_assignment:
 
 reassigned_multiple_times:
   _doc: "A variable reassigned many times is a sign the name is too generic or the function does too much."
-  _fix_hint: "Refactor repeated reassignment into a pipeline or named intermediate values"
-  _languages: [elixir]
-  _log_baseline: -107.5659
+  _log_baseline: -63.1779
   branching:
-    mean_non_blank_count: -0.2287
+    mean_non_blank_count: -0.1343
   brevity:
-    mean_sample_size: 0.0287
+    mean_sample_size: 0.0169
   casing_entropy:
-    mean_entropy: 0.2150
-    mean_pascal_case_count: -0.3434
-    mean_snake_case_count: -0.9136
+    mean_entropy: 0.0898
+    mean_pascal_case_count: -0.2016
+    mean_snake_case_count: -0.4475
   compression:
-    mean_raw_bytes: -0.4804
-    mean_redundancy: -0.2638
-    mean_unique_line_ratio: -0.0172
-    mean_zlib_bytes: 0.0205
-    mean_zlib_ratio: -0.5009
+    mean_raw_bytes: -0.2821
+    mean_redundancy: -0.1549
+    mean_unique_line_ratio: -0.0101
+    mean_zlib_bytes: 0.0121
+    mean_zlib_ratio: -0.2942
   entropy:
-    mean_char_entropy: 0.0869
-    mean_char_max_entropy: 0.0234
-    mean_char_normalized: 0.0636
-    mean_token_entropy: 0.0534
-    mean_token_normalized: 0.0470
-    mean_total_tokens: -0.4852
-    mean_vocab_size: 0.0287
+    mean_char_entropy: 0.0510
+    mean_char_max_entropy: 0.0137
+    mean_char_normalized: 0.0373
+    mean_token_entropy: 0.0313
+    mean_token_normalized: 0.0276
+    mean_total_tokens: -0.2849
+    mean_vocab_size: 0.0169
   function_metrics:
-    mean_avg_function_lines: -0.1143
+    mean_avg_function_lines: -0.0671
   halstead:
-    mean_N1_total_operators: -0.2160
-    mean_N2_total_operands: -0.9103
-    mean_difficulty: -1.1372
-    mean_effort: -1.6318
-    mean_estimated_bugs: -0.4946
-    mean_length: -0.5017
-    mean_n1_unique_operators: -0.1489
-    mean_n2_unique_operands: 0.0780
-    mean_time_to_implement_seconds: -1.6318
-    mean_vocabulary: 0.0309
-    mean_volume: -0.4946
+    mean_N1_total_operators: -0.1269
+    mean_N2_total_operands: -0.5345
+    mean_difficulty: -0.6678
+    mean_effort: -0.9583
+    mean_estimated_bugs: -0.2905
+    mean_length: -0.2946
+    mean_n1_unique_operators: -0.0875
+    mean_n2_unique_operands: 0.0458
+    mean_time_to_implement_seconds: -0.9583
+    mean_vocabulary: 0.0181
+    mean_volume: -0.2905
   heaps:
-    mean_beta: 0.2282
-    mean_k: -0.3898
-    mean_r_squared: 0.0349
+    mean_beta: 0.1340
+    mean_k: -0.2289
+    mean_r_squared: 0.0205
   identifier_length_variance:
-    mean_max: 0.3280
-    mean_mean: 0.3212
-    mean_std_dev: 0.8224
-    mean_variance: 1.6450
+    mean_max: 0.1926
+    mean_mean: 0.1821
+    mean_std_dev: 0.4688
+    mean_variance: 0.9376
   indentation:
-    mean_blank_line_ratio: 1.1002
-    mean_mean_depth: -0.0484
-    mean_variance: 0.1417
+    mean_blank_line_ratio: 0.6461
+    mean_mean_depth: -0.0284
+    mean_variance: 0.0832
   line_patterns:
-    mean_blank_line_ratio: 1.1002
-    mean_string_literal_ratio: 0.4958
-    mean_unique_line_ratio: -0.0236
+    mean_blank_line_ratio: 0.6461
+    mean_string_literal_ratio: 0.2911
+    mean_unique_line_ratio: -0.0138
   magic_number_density:
-    mean_density: 0.4930
-    mean_string_literal_ratio: 0.4958
+    mean_density: 0.2895
+    mean_string_literal_ratio: 0.2911
   near_duplicate_blocks_file:
-    mean_sub_block_count: 0.3280
+    mean_near_dup_block_d8: -2.0000
+    mean_sub_block_count: 0.1926
   ngram:
-    mean_bigram_hapax_fraction: 0.4509
-    mean_bigram_repeated_unique: -1.1755
-    mean_bigram_repetition_rate: -0.4690
-    mean_bigram_total: -0.4861
-    mean_bigram_unique: 0.0798
-    mean_trigram_hapax_fraction: 0.4536
-    mean_trigram_repeated_unique: -2.0000
-    mean_trigram_repetition_rate: -0.7942
-    mean_trigram_total: -0.4871
-    mean_trigram_unique: -0.0423
+    mean_bigram_hapax_fraction: 0.2648
+    mean_bigram_repeated_unique: -0.6903
+    mean_bigram_repetition_rate: -0.2754
+    mean_bigram_total: -0.2855
+    mean_bigram_unique: 0.0469
+    mean_trigram_hapax_fraction: 0.2664
+    mean_trigram_repeated_unique: -1.1745
+    mean_trigram_repetition_rate: -0.4664
+    mean_trigram_total: -0.2861
+    mean_trigram_unique: -0.0248
   punctuation_density:
-    mean_colon_suffix_density: 0.4930
-    mean_dot_count: -0.4849
-    mean_id_nonalpha_suffix_density: -0.3517
+    mean_colon_suffix_density: 0.2895
+    mean_dot_count: -0.2847
+    mean_id_nonalpha_suffix_density: -0.2066
   readability:
-    mean_avg_line_length: -0.2630
-    mean_avg_sub_words_per_id: 0.1974
-    mean_avg_tokens_per_line: -0.2565
-    mean_flesch_adapted: -0.1476
-    mean_fog_adapted: -0.2565
-    mean_total_lines: -0.2287
+    mean_avg_line_length: -0.1544
+    mean_avg_sub_words_per_id: 0.1159
+    mean_avg_tokens_per_line: -0.1506
+    mean_flesch_adapted: -0.0867
+    mean_fog_adapted: -0.1506
+    mean_total_lines: -0.1343
   symbol_density:
-    mean_density: 0.2755
-    mean_symbol_count: -0.2056
+    mean_density: 0.1618
+    mean_symbol_count: -0.1207
   vocabulary:
-    mean_mattr: 0.9538
-    mean_raw_ttr: 0.9009
-    mean_total_identifiers: -0.7749
-    mean_unique_identifiers: 0.1260
+    mean_mattr: 0.4975
+    mean_raw_ttr: 0.4909
+    mean_total_identifiers: -0.3859
+    mean_unique_identifiers: 0.1050
   vowel_density:
-    mean_total_chars: -0.4538
+    mean_total_chars: -0.2038
   zipf:
-    mean_exponent: -0.2377
-    mean_total_tokens: -0.4852
-    mean_vocab_size: 0.0287
+    mean_exponent: -0.1396
+    mean_total_tokens: -0.2849
+    mean_vocab_size: 0.0169
 
 scope_is_minimal:
   _doc: "Variables should be scoped as narrowly as possible — not declared at a wider scope than needed."
-  _fix_hint: "Narrow the scope of variables — declare them in the innermost block where they are used"
-  _languages: [elixir]
-  _log_baseline: -6.7522
+  _log_baseline: -7.8286
   branching:
     mean_branch_count: -0.1072
     mean_branching_density: -0.0452
@@ -328,9 +321,9 @@ scope_is_minimal:
   brevity:
     mean_sample_size: -0.0368
   casing_entropy:
-    mean_entropy: -0.0721
+    mean_entropy: -0.0341
     mean_other_count: -0.1823
-    mean_snake_case_count: 0.0081
+    mean_snake_case_count: -0.0471
   comment_structure:
     mean_comment_line_count: -0.4075
     mean_comment_line_ratio: 2.0000
@@ -369,9 +362,9 @@ scope_is_minimal:
     mean_k: -0.0341
     mean_r_squared: 0.0103
   identifier_length_variance:
-    mean_mean: -0.0389
-    mean_std_dev: 0.0545
-    mean_variance: 0.1090
+    mean_mean: -0.0320
+    mean_std_dev: 0.0864
+    mean_variance: 0.1729
   indentation:
     mean_blank_line_ratio: -0.1076
     mean_max_depth: -0.4694
@@ -384,6 +377,7 @@ scope_is_minimal:
   magic_number_density:
     mean_string_literal_ratio: -0.0144
   near_duplicate_blocks_file:
+    mean_block_count: -0.1691
     mean_sub_block_count: 0.0447
   ngram:
     mean_bigram_hapax_fraction: -0.0078
@@ -414,12 +408,11 @@ scope_is_minimal:
     mean_distinct_symbol_types: 0.0336
     mean_symbol_count: 0.0316
   vocabulary:
-    mean_mattr: -0.0277
-    mean_raw_ttr: -0.0643
-    mean_total_identifiers: -0.0071
-    mean_unique_identifiers: -0.0713
+    mean_raw_ttr: -0.0313
+    mean_total_identifiers: -0.0577
+    mean_unique_identifiers: -0.0891
   vowel_density:
-    mean_total_chars: -0.0460
+    mean_total_chars: -0.0897
   zipf:
     mean_exponent: 0.0070
     mean_total_tokens: 0.0143
@@ -427,9 +420,7 @@ scope_is_minimal:
 
 shadowed_by_inner_scope:
   _doc: "Inner-scope names that shadow outer-scope names cause confusion about which value is in play."
-  _fix_hint: "Rename the inner variable to avoid shadowing the outer one"
-  _languages: [elixir]
-  _log_baseline: -33.9501
+  _log_baseline: -33.8958
   branching:
     mean_branching_density: 2.0000
     mean_max_nesting_depth: -0.1450
@@ -437,9 +428,9 @@ shadowed_by_inner_scope:
   brevity:
     mean_sample_size: -0.0786
   casing_entropy:
-    mean_entropy: 0.1125
+    mean_entropy: 0.1132
     mean_pascal_case_count: -0.0306
-    mean_snake_case_count: -0.2319
+    mean_snake_case_count: -0.2452
   comment_structure:
     mean_comment_line_count: -1.1073
     mean_comment_line_ratio: 0.8936
@@ -476,9 +467,9 @@ shadowed_by_inner_scope:
     mean_k: -0.0817
     mean_r_squared: -0.0030
   identifier_length_variance:
-    mean_mean: 0.1455
-    mean_std_dev: 0.2453
-    mean_variance: 0.4905
+    mean_mean: 0.1622
+    mean_std_dev: 0.2441
+    mean_variance: 0.4883
   indentation:
     mean_blank_line_ratio: 0.0798
     mean_mean_depth: -0.0595
@@ -519,12 +510,12 @@ shadowed_by_inner_scope:
     mean_distinct_symbol_types: -0.0561
     mean_symbol_count: -0.1275
   vocabulary:
-    mean_mattr: 0.0829
-    mean_raw_ttr: 0.1254
-    mean_total_identifiers: -0.2059
-    mean_unique_identifiers: -0.0804
+    mean_mattr: 0.1103
+    mean_raw_ttr: 0.1343
+    mean_total_identifiers: -0.2135
+    mean_unique_identifiers: -0.0792
   vowel_density:
-    mean_total_chars: -0.0604
+    mean_total_chars: -0.0513
   zipf:
     mean_exponent: -0.0364
     mean_r_squared: 0.0058
@@ -533,16 +524,14 @@ shadowed_by_inner_scope:
 
 used_only_once:
   _doc: "A variable used only once is a candidate for inlining — it rarely adds clarity over a direct expression."
-  _fix_hint: "Inline single-use variables directly into their only use site"
-  _languages: [elixir]
-  _log_baseline: -116.4649
+  _log_baseline: -115.3539
   branching:
     mean_non_blank_count: -0.5385
   brevity:
     mean_sample_size: -0.4955
   casing_entropy:
-    mean_entropy: 0.6972
-    mean_snake_case_count: -1.1633
+    mean_entropy: 0.6530
+    mean_snake_case_count: -1.1336
   compression:
     mean_raw_bytes: -0.8394
     mean_redundancy: -0.1990
@@ -573,9 +562,9 @@ used_only_once:
   heaps:
     mean_k: -0.1674
   identifier_length_variance:
-    mean_mean: -0.2014
-    mean_std_dev: 0.1846
-    mean_variance: 0.3694
+    mean_mean: -0.1940
+    mean_std_dev: 0.1753
+    mean_variance: 0.3505
   indentation:
     mean_blank_line_ratio: 0.4750
     mean_max_depth: 1.2798
@@ -617,12 +606,12 @@ used_only_once:
     mean_density: 0.6227
     mean_symbol_count: -0.2178
   vocabulary:
-    mean_mattr: 0.2063
-    mean_raw_ttr: 0.2647
-    mean_total_identifiers: -0.9999
-    mean_unique_identifiers: -0.7352
+    mean_mattr: 0.0846
+    mean_raw_ttr: 0.1945
+    mean_total_identifiers: -0.9555
+    mean_unique_identifiers: -0.7612
   vowel_density:
-    mean_total_chars: -1.2013
+    mean_total_chars: -1.1494
   zipf:
     mean_exponent: 0.1820
     mean_r_squared: -0.0230
diff --git a/priv/combined_metrics/testing.yml b/priv/combined_metrics/testing.yml
index 6b1d5e9..33175c4 100644
--- a/priv/combined_metrics/testing.yml
+++ b/priv/combined_metrics/testing.yml
@@ -1,8 +1,6 @@
 reasonable_test_to_code_ratio:
   _doc: "There should be an adequate number of test cases relative to the code being tested."
-  _fix_hint: "Add more tests — aim for at least one test per public function"
-  _languages: [elixir]
-  _log_baseline: 8.2261
+  _log_baseline: 11.2157
   branching:
     mean_branch_count: 0.1869
     mean_branching_density: 0.0352
@@ -10,9 +8,9 @@ reasonable_test_to_code_ratio:
   brevity:
     mean_sample_size: 0.0290
   casing_entropy:
-    mean_entropy: 0.0597
+    mean_entropy: 0.0656
     mean_pascal_case_count: 0.2097
-    mean_snake_case_count: 0.0671
+    mean_snake_case_count: 0.0455
   comment_structure:
     mean_comment_line_count: -0.5246
     mean_comment_line_ratio: 0.5016
@@ -51,9 +49,9 @@ reasonable_test_to_code_ratio:
     mean_k: 0.0107
     mean_r_squared: 0.0171
   identifier_length_variance:
-    mean_mean: 0.0231
-    mean_std_dev: 0.0069
-    mean_variance: 0.0139
+    mean_mean: 0.0278
+    mean_std_dev: 0.0092
+    mean_variance: 0.0185
   indentation:
     mean_blank_line_ratio: -0.0175
     mean_max_depth: 0.1093
@@ -68,6 +66,13 @@ reasonable_test_to_code_ratio:
     mean_magic_number_count: 0.4248
     mean_string_literal_ratio: 0.2536
   near_duplicate_blocks_file:
+    mean_block_count: 0.3136
+    mean_near_dup_block_d0: 0.6699
+    mean_near_dup_block_d3: 0.1869
+    mean_near_dup_block_d4: 0.5246
+    mean_near_dup_block_d5: 0.1869
+    mean_near_dup_block_d7: 0.7475
+    mean_near_dup_block_d8: 0.1869
     mean_sub_block_count: 0.0723
   ngram:
     mean_bigram_hapax_fraction: -0.0173
@@ -97,12 +102,12 @@ reasonable_test_to_code_ratio:
     mean_distinct_symbol_types: -0.0284
     mean_symbol_count: 0.0960
   vocabulary:
-    mean_mattr: -0.0209
-    mean_raw_ttr: -0.0657
-    mean_total_identifiers: 0.0853
-    mean_unique_identifiers: 0.0196
+    mean_mattr: -0.0271
+    mean_raw_ttr: -0.0488
+    mean_total_identifiers: 0.0704
+    mean_unique_identifiers: 0.0216
   vowel_density:
-    mean_total_chars: 0.1084
+    mean_total_chars: 0.0982
   zipf:
     mean_exponent: 0.0408
     mean_r_squared: -0.0086
@@ -111,9 +116,7 @@ reasonable_test_to_code_ratio:
 
 test_has_assertion:
   _doc: "Every test body must contain at least one assertion — a test without assertions proves nothing."
-  _fix_hint: "Add at least one assert/refute to every test — a test without assertions proves nothing"
-  _languages: [elixir]
-  _log_baseline: -9.6007
+  _log_baseline: -10.8081
   branching:
     mean_branch_count: 0.0918
     mean_branching_density: 0.1642
@@ -121,10 +124,10 @@ test_has_assertion:
   brevity:
     mean_sample_size: -0.0555
   casing_entropy:
-    mean_entropy: -0.0130
+    mean_entropy: -0.0026
     mean_other_count: -0.1294
     mean_pascal_case_count: -0.0450
-    mean_snake_case_count: -0.0338
+    mean_snake_case_count: -0.0568
   comment_structure:
     mean_comment_line_count: -0.6211
     mean_comment_line_ratio: 0.6522
@@ -158,9 +161,9 @@ test_has_assertion:
     mean_k: 0.0917
     mean_r_squared: -0.0091
   identifier_length_variance:
-    mean_mean: 0.0104
-    mean_std_dev: 0.0277
-    mean_variance: 0.0553
+    mean_mean: 0.0215
+    mean_std_dev: 0.0214
+    mean_variance: 0.0429
   indentation:
     mean_blank_line_ratio: 0.0261
     mean_max_depth: -0.1294
@@ -173,6 +176,12 @@ test_has_assertion:
   magic_number_density:
     mean_string_literal_ratio: -0.0139
   near_duplicate_blocks_file:
+    mean_block_count: -0.0376
+    mean_near_dup_block_d0: -0.3507
+    mean_near_dup_block_d5: 0.2212
+    mean_near_dup_block_d6: -0.4425
+    mean_near_dup_block_d7: 0.2212
+    mean_near_dup_block_d8: -0.5719
     mean_sub_block_count: 0.0228
   ngram:
     mean_bigram_hapax_fraction: -0.0509
@@ -202,12 +211,12 @@ test_has_assertion:
     mean_distinct_symbol_types: -0.0194
     mean_symbol_count: 0.0126
   vocabulary:
-    mean_mattr: -0.0644
-    mean_raw_ttr: -0.0389
-    mean_total_identifiers: -0.0370
-    mean_unique_identifiers: -0.0760
+    mean_mattr: -0.0607
+    mean_raw_ttr: -0.0243
+    mean_total_identifiers: -0.0553
+    mean_unique_identifiers: -0.0796
   vowel_density:
-    mean_total_chars: -0.0266
+    mean_total_chars: -0.0338
   zipf:
     mean_exponent: 0.0248
     mean_r_squared: -0.0049
@@ -215,9 +224,7 @@ test_has_assertion:
 
 test_name_describes_behavior:
   _doc: "Test names should describe the expected behaviour, not just the method under test."
-  _fix_hint: "Describe expected behavior in test names: 'returns {:error, :not_found} when user missing'"
-  _languages: [elixir]
-  _log_baseline: 56.4575
+  _log_baseline: 57.2080
   branching:
     mean_branch_count: 2.0000
     mean_branching_density: -1.5965
@@ -225,9 +232,9 @@ test_name_describes_behavior:
   brevity:
     mean_sample_size: 0.1814
   casing_entropy:
-    mean_entropy: -0.1587
+    mean_entropy: -0.1610
     mean_pascal_case_count: 0.0729
-    mean_snake_case_count: 0.3604
+    mean_snake_case_count: 0.4125
   compression:
     mean_raw_bytes: 0.3524
     mean_redundancy: 0.0412
@@ -258,7 +265,9 @@ test_name_describes_behavior:
     mean_beta: 0.0106
     mean_k: -0.0084
   identifier_length_variance:
-    mean_mean: 0.0465
+    mean_mean: 0.0422
+    mean_std_dev: -0.0249
+    mean_variance: -0.0498
   indentation:
     mean_blank_line_ratio: -0.1184
     mean_max_depth: 0.3691
@@ -271,6 +280,9 @@ test_name_describes_behavior:
   magic_number_density:
     mean_string_literal_ratio: -0.1419
   near_duplicate_blocks_file:
+    mean_block_count: 0.0868
+    mean_near_dup_block_d0: 0.6309
+    mean_near_dup_block_d7: -0.2619
     mean_sub_block_count: 0.0868
   ngram:
     mean_bigram_hapax_fraction: 0.0841
@@ -296,12 +308,12 @@ test_name_describes_behavior:
     mean_distinct_symbol_types: 0.0729
     mean_symbol_count: 0.2136
   vocabulary:
-    mean_mattr: 0.0068
-    mean_raw_ttr: -0.1629
-    mean_total_identifiers: 0.3034
-    mean_unique_identifiers: 0.1403
+    mean_mattr: -0.0698
+    mean_raw_ttr: -0.1544
+    mean_total_identifiers: 0.3273
+    mean_unique_identifiers: 0.1730
   vowel_density:
-    mean_total_chars: 0.3498
+    mean_total_chars: 0.3695
   zipf:
     mean_r_squared: 0.0095
     mean_total_tokens: 0.2704
@@ -309,9 +321,7 @@ test_name_describes_behavior:
 
 test_single_concept:
   _doc: "Each test should verify a single concept — tests covering multiple things are harder to diagnose when they fail."
-  _fix_hint: "Test one thing per test — split tests covering multiple behaviors into separate test cases"
-  _languages: [elixir]
-  _log_baseline: 35.9646
+  _log_baseline: 37.2588
   branching:
     mean_branch_count: 0.3696
     mean_branching_density: -2.0000
@@ -320,10 +330,10 @@ test_single_concept:
   brevity:
     mean_sample_size: 0.0495
   casing_entropy:
-    mean_entropy: -0.0975
+    mean_entropy: -0.0830
     mean_other_count: 0.3696
     mean_pascal_case_count: -0.0146
-    mean_snake_case_count: 0.2046
+    mean_snake_case_count: 0.1912
   comment_structure:
     mean_comment_line_count: -1.0376
     mean_comment_line_ratio: 1.0694
@@ -363,9 +373,9 @@ test_single_concept:
     mean_k: 0.1502
     mean_r_squared: 0.0046
   identifier_length_variance:
-    mean_mean: 0.0149
-    mean_std_dev: 0.0642
-    mean_variance: 0.1285
+    mean_mean: 0.0255
+    mean_std_dev: 0.0733
+    mean_variance: 0.1466
   indentation:
     mean_blank_line_ratio: -0.0702
     mean_max_depth: 0.2162
@@ -381,6 +391,9 @@ test_single_concept:
     mean_magic_number_count: 0.1534
     mean_string_literal_ratio: 0.3581
   near_duplicate_blocks_file:
+    mean_block_count: 0.5858
+    mean_near_dup_block_d0: 0.3696
+    mean_near_dup_block_d4: 0.3696
     mean_sub_block_count: 0.1857
   ngram:
     mean_bigram_hapax_fraction: -0.0471
@@ -410,12 +423,12 @@ test_single_concept:
     mean_density: -0.0634
     mean_symbol_count: 0.1338
   vocabulary:
-    mean_mattr: -0.0722
-    mean_raw_ttr: -0.1338
-    mean_total_identifiers: 0.1750
-    mean_unique_identifiers: 0.0410
+    mean_mattr: -0.0701
+    mean_raw_ttr: -0.1129
+    mean_total_identifiers: 0.1594
+    mean_unique_identifiers: 0.0464
   vowel_density:
-    mean_total_chars: 0.1898
+    mean_total_chars: 0.1849
   zipf:
     mean_exponent: 0.0281
     mean_r_squared: -0.0039
diff --git a/priv/combined_metrics/type_and_value.yml b/priv/combined_metrics/type_and_value.yml
index f3e061c..986b994 100644
--- a/priv/combined_metrics/type_and_value.yml
+++ b/priv/combined_metrics/type_and_value.yml
@@ -1,8 +1,6 @@
 boolean_assigned_from_comparison:
   _doc: "Boolean variables should be assigned directly from comparisons or predicate calls, not set via conditionals."
-  _fix_hint: "Assign the comparison result directly — bool = x > 0 not if x > 0 do true else false end"
-  _languages: [elixir]
-  _log_baseline: 3.2119
+  _log_baseline: 2.5801
   branching:
     mean_branch_count: -0.8402
     mean_branching_density: 0.3349
@@ -51,9 +49,9 @@ boolean_assigned_from_comparison:
     mean_r_squared: 0.0046
   identifier_length_variance:
     mean_max: 0.0208
-    mean_mean: 0.0195
-    mean_std_dev: -0.0085
-    mean_variance: -0.0171
+    mean_mean: 0.0168
+    mean_std_dev: -0.0019
+    mean_variance: -0.0038
   indentation:
     mean_blank_line_ratio: 0.1081
     mean_max_depth: -0.2570
@@ -69,6 +67,8 @@ boolean_assigned_from_comparison:
     mean_magic_number_count: 0.1944
     mean_string_literal_ratio: -0.0182
   near_duplicate_blocks_file:
+    mean_block_count: -0.2570
+    mean_near_dup_block_d0: -0.3081
     mean_sub_block_count: 0.2455
   ngram:
     mean_bigram_hapax_fraction: 0.0123
@@ -104,7 +104,7 @@ boolean_assigned_from_comparison:
     mean_total_identifiers: 0.1004
     mean_unique_identifiers: 0.0953
   vowel_density:
-    mean_total_chars: 0.1199
+    mean_total_chars: 0.1172
   zipf:
     mean_exponent: -0.0211
     mean_r_squared: 0.0120
@@ -113,113 +113,111 @@ boolean_assigned_from_comparison:
 
 hardcoded_url_or_path:
   _doc: "URLs, file paths, and host names should be configuration values, not inline string literals."
-  _fix_hint: "Move hardcoded URLs and file paths to configuration or module attributes"
-  _languages: [elixir]
-  _log_baseline: 119.8203
+  _log_baseline: 54.3750
   branching:
-    mean_max_nesting_depth: 0.9571
+    mean_max_nesting_depth: 0.4526
   brevity:
-    mean_sample_size: 0.3152
+    mean_sample_size: 0.1491
   casing_entropy:
-    mean_entropy: -0.1421
-    mean_other_count: -2.0000
-    mean_pascal_case_count: 0.9571
-    mean_snake_case_count: 0.1889
+    mean_entropy: -0.0622
+    mean_other_count: -0.9458
+    mean_pascal_case_count: 0.4526
+    mean_snake_case_count: 0.0807
   compression:
-    mean_raw_bytes: 0.6634
-    mean_redundancy: 0.1246
-    mean_unique_line_ratio: 0.1310
-    mean_zlib_bytes: 0.4741
-    mean_zlib_ratio: 0.1894
+    mean_raw_bytes: 0.3137
+    mean_redundancy: 0.0589
+    mean_unique_line_ratio: 0.0620
+    mean_zlib_bytes: 0.2242
+    mean_zlib_ratio: 0.0896
   entropy:
-    mean_char_entropy: 0.0190
-    mean_char_normalized: 0.0281
-    mean_token_entropy: 0.0674
-    mean_token_max_entropy: 0.0678
-    mean_total_tokens: 0.4785
-    mean_vocab_size: 0.3152
+    mean_char_entropy: 0.0090
+    mean_char_normalized: 0.0133
+    mean_token_entropy: 0.0319
+    mean_token_max_entropy: 0.0321
+    mean_total_tokens: 0.2263
+    mean_vocab_size: 0.1491
   function_metrics:
-    mean_avg_function_lines: -0.8947
-    mean_avg_param_count: 0.9571
-    mean_function_count: 0.7942
-    mean_max_param_count: 0.9571
+    mean_avg_function_lines: -0.4231
+    mean_avg_param_count: 0.4526
+    mean_function_count: 0.3756
+    mean_max_param_count: 0.4526
   halstead:
-    mean_N1_total_operators: 0.5692
-    mean_N2_total_operands: 0.7517
-    mean_difficulty: 0.1642
-    mean_effort: 0.9625
-    mean_estimated_bugs: 0.7982
-    mean_length: 0.6248
-    mean_n1_unique_operators: 0.3299
-    mean_n2_unique_operands: 0.9174
-    mean_time_to_implement_seconds: 0.9625
-    mean_vocabulary: 0.7373
-    mean_volume: 0.7983
+    mean_N1_total_operators: 0.2692
+    mean_N2_total_operands: 0.3555
+    mean_difficulty: 0.0776
+    mean_effort: 0.4552
+    mean_estimated_bugs: 0.3775
+    mean_length: 0.2955
+    mean_n1_unique_operators: 0.1560
+    mean_n2_unique_operands: 0.4338
+    mean_time_to_implement_seconds: 0.4552
+    mean_vocabulary: 0.3487
+    mean_volume: 0.3775
   heaps:
-    mean_beta: 0.0461
-    mean_k: -0.1568
+    mean_beta: 0.0218
+    mean_k: -0.0742
   identifier_length_variance:
-    mean_mean: 0.6914
-    mean_std_dev: 0.5873
-    mean_variance: 1.1745
+    mean_mean: 0.3229
+    mean_std_dev: 0.2786
+    mean_variance: 0.5571
   indentation:
-    mean_blank_line_ratio: 0.3864
-    mean_mean_depth: -0.2779
-    mean_variance: -0.3554
+    mean_blank_line_ratio: 0.1827
+    mean_mean_depth: -0.1314
+    mean_variance: -0.1681
   line_patterns:
-    mean_blank_line_ratio: 0.3864
-    mean_max_nesting_depth: 0.9571
-    mean_string_literal_ratio: -0.0201
-    mean_unique_line_ratio: 0.1351
+    mean_blank_line_ratio: 0.1827
+    mean_max_nesting_depth: 0.4526
+    mean_string_literal_ratio: -0.0095
+    mean_unique_line_ratio: 0.0639
   magic_number_density:
-    mean_density: -0.4116
-    mean_string_literal_ratio: -0.0201
+    mean_density: -0.1946
+    mean_string_literal_ratio: -0.0095
   near_duplicate_blocks_file:
-    mean_sub_block_count: 0.8771
+    mean_near_dup_block_d0: -0.7737
+    mean_near_dup_block_d7: -2.0000
+    mean_sub_block_count: 0.4147
   ngram:
-    mean_bigram_hapax_fraction: -0.1563
-    mean_bigram_repeated_unique: 0.8894
-    mean_bigram_repetition_rate: 0.0704
-    mean_bigram_total: 0.4796
-    mean_bigram_unique: 0.5223
-    mean_trigram_repeated_unique: 0.6908
-    mean_trigram_repetition_rate: -0.2750
-    mean_trigram_total: 0.4807
-    mean_trigram_unique: 0.7019
+    mean_bigram_hapax_fraction: -0.0739
+    mean_bigram_repeated_unique: 0.4206
+    mean_bigram_repetition_rate: 0.0333
+    mean_bigram_total: 0.2268
+    mean_bigram_unique: 0.2470
+    mean_trigram_repeated_unique: 0.3267
+    mean_trigram_repetition_rate: -0.1301
+    mean_trigram_total: 0.2273
+    mean_trigram_unique: 0.3319
   punctuation_density:
-    mean_bracket_nonalpha_prefix_count: 1.1094
-    mean_bracket_nonalpha_suffix_count: 2.0000
-    mean_colon_suffix_density: -0.4737
-    mean_dot_count: 0.1098
-    mean_exclamation_density: 0.2954
-    mean_id_nonalpha_suffix_density: -0.1516
-    mean_question_mark_density: -0.7321
+    mean_bracket_nonalpha_prefix_count: 0.5246
+    mean_bracket_nonalpha_suffix_count: 0.9458
+    mean_colon_suffix_density: -0.2240
+    mean_dot_count: 0.0519
+    mean_exclamation_density: 0.1397
+    mean_id_nonalpha_suffix_density: -0.0717
+    mean_question_mark_density: -0.3462
   readability:
-    mean_avg_line_length: 0.6849
-    mean_avg_sub_words_per_id: 0.4262
-    mean_avg_tokens_per_line: 0.4785
-    mean_flesch_adapted: -0.4974
-    mean_fog_adapted: 1.0160
+    mean_avg_line_length: 0.3239
+    mean_avg_sub_words_per_id: 0.2015
+    mean_avg_tokens_per_line: 0.2263
+    mean_flesch_adapted: -0.2352
+    mean_fog_adapted: 0.4805
   symbol_density:
-    mean_density: -0.0213
-    mean_symbol_count: 0.6424
+    mean_density: -0.0101
+    mean_symbol_count: 0.3038
   vocabulary:
-    mean_mattr: 0.3608
-    mean_raw_ttr: 0.1636
-    mean_total_identifiers: 0.1955
-    mean_unique_identifiers: 0.3588
+    mean_mattr: 0.1813
+    mean_raw_ttr: 0.0726
+    mean_total_identifiers: 0.0850
+    mean_unique_identifiers: 0.1575
   vowel_density:
-    mean_total_chars: 0.8868
+    mean_total_chars: 0.4079
   zipf:
-    mean_r_squared: 0.0346
-    mean_total_tokens: 0.4785
-    mean_vocab_size: 0.3152
+    mean_r_squared: 0.0163
+    mean_total_tokens: 0.2263
+    mean_vocab_size: 0.1491
 
 no_empty_string_initial:
   _doc: "Initialising a variable to an empty string and reassigning later signals missing structure."
-  _fix_hint: "Replace initial empty string assignments with nil or a meaningful default value"
-  _languages: [elixir]
-  _log_baseline: -11.4915
+  _log_baseline: -12.5778
   branching:
     mean_branch_count: -0.1786
     mean_max_nesting_depth: -0.1294
@@ -227,10 +225,10 @@ no_empty_string_initial:
   brevity:
     mean_sample_size: -0.0035
   casing_entropy:
-    mean_entropy: -0.1033
+    mean_entropy: -0.1014
     mean_other_count: -0.6637
     mean_pascal_case_count: 0.0802
-    mean_snake_case_count: -0.0041
+    mean_snake_case_count: -0.0082
   compression:
     mean_raw_bytes: -0.0782
     mean_redundancy: -0.0287
@@ -265,9 +263,9 @@ no_empty_string_initial:
     mean_k: -0.0214
     mean_r_squared: -0.0034
   identifier_length_variance:
-    mean_mean: -0.0210
-    mean_std_dev: -0.0040
-    mean_variance: -0.0080
+    mean_mean: -0.0193
+    mean_std_dev: -0.0030
+    mean_variance: -0.0059
   indentation:
     mean_blank_line_ratio: -0.0652
     mean_mean_depth: -0.0937
@@ -280,6 +278,8 @@ no_empty_string_initial:
   magic_number_density:
     mean_string_literal_ratio: -0.2412
   near_duplicate_blocks_file:
+    mean_block_count: -0.1976
+    mean_near_dup_block_d0: -0.6211
     mean_sub_block_count: 0.2212
   ngram:
     mean_bigram_hapax_fraction: -0.0336
@@ -310,10 +310,12 @@ no_empty_string_initial:
     mean_distinct_symbol_types: 0.0164
     mean_symbol_count: -0.0101
   vocabulary:
-    mean_total_identifiers: -0.0164
-    mean_unique_identifiers: -0.0167
+    mean_mattr: 0.0022
+    mean_raw_ttr: 0.0025
+    mean_total_identifiers: -0.0195
+    mean_unique_identifiers: -0.0170
   vowel_density:
-    mean_total_chars: -0.0374
+    mean_total_chars: -0.0388
   zipf:
     mean_exponent: -0.0054
     mean_r_squared: -0.0034
@@ -322,9 +324,7 @@ no_empty_string_initial:
 
 no_implicit_null_initial:
   _doc: "Initialising a variable to `nil`/`null` and assigning it later in a branch signals missing structure."
-  _fix_hint: "Use nil explicitly when a variable starts null — or restructure to avoid nil initialization"
-  _languages: [elixir]
-  _log_baseline: -3.2196
+  _log_baseline: -3.6430
   branching:
     mean_branch_count: 0.0293
     mean_branching_density: 0.0871
@@ -332,10 +332,10 @@ no_implicit_null_initial:
   brevity:
     mean_sample_size: 0.0132
   casing_entropy:
-    mean_entropy: 0.0619
+    mean_entropy: 0.0660
     mean_other_count: 0.1247
-    mean_screaming_snake_density: 0.0422
-    mean_snake_case_count: -0.0452
+    mean_screaming_snake_density: 0.0448
+    mean_snake_case_count: -0.0534
   compression:
     mean_raw_bytes: -0.0246
     mean_redundancy: -0.0100
@@ -370,9 +370,9 @@ no_implicit_null_initial:
     mean_k: 0.0418
     mean_r_squared: -0.0034
   identifier_length_variance:
-    mean_mean: 0.0130
-    mean_std_dev: 0.0211
-    mean_variance: 0.0423
+    mean_mean: 0.0185
+    mean_std_dev: 0.0177
+    mean_variance: 0.0354
   indentation:
     mean_blank_line_ratio: -0.1146
     mean_mean_depth: 0.0089
@@ -385,6 +385,7 @@ no_implicit_null_initial:
     mean_density: -0.0066
     mean_string_literal_ratio: -0.0022
   near_duplicate_blocks_file:
+    mean_block_count: -0.1493
     mean_sub_block_count: 0.0422
   ngram:
     mean_bigram_hapax_fraction: -0.0181
@@ -414,12 +415,11 @@ no_implicit_null_initial:
     mean_distinct_symbol_types: 0.0342
     mean_symbol_count: 0.0303
   vocabulary:
-    mean_mattr: 0.0148
-    mean_raw_ttr: 0.0350
-    mean_total_identifiers: -0.0402
-    mean_unique_identifiers: -0.0052
+    mean_mattr: 0.0540
+    mean_raw_ttr: 0.0466
+    mean_total_identifiers: -0.0466
   vowel_density:
-    mean_total_chars: -0.0272
+    mean_total_chars: -0.0281
   zipf:
     mean_exponent: -0.0074
     mean_r_squared: 0.0047
@@ -427,9 +427,7 @@ no_implicit_null_initial:
 
 no_magic_value_assigned:
   _doc: "Literal strings and numbers assigned to variables should be named constants, not inline values."
-  _fix_hint: "Replace magic value assignments with named constants or module attributes"
-  _languages: [elixir]
-  _log_baseline: -6.5439
+  _log_baseline: -6.3129
   branching:
     mean_branch_count: -0.2035
     mean_branching_density: -0.1140
@@ -437,9 +435,9 @@ no_magic_value_assigned:
   brevity:
     mean_sample_size: -0.0122
   casing_entropy:
-    mean_entropy: -0.0570
+    mean_entropy: -0.0411
     mean_other_count: -0.3211
-    mean_snake_case_count: -0.0248
+    mean_snake_case_count: -0.0502
   compression:
     mean_raw_bytes: -0.1800
     mean_redundancy: -0.0342
@@ -476,9 +474,9 @@ no_magic_value_assigned:
     mean_r_squared: 0.0230
   identifier_length_variance:
     mean_max: -0.0438
-    mean_mean: -0.1573
-    mean_std_dev: -0.2110
-    mean_variance: -0.4220
+    mean_mean: -0.1501
+    mean_std_dev: -0.2041
+    mean_variance: -0.4083
   indentation:
     mean_blank_line_ratio: -0.1918
     mean_mean_depth: -0.2808
@@ -490,6 +488,8 @@ no_magic_value_assigned:
   magic_number_density:
     mean_string_literal_ratio: -1.7484
   near_duplicate_blocks_file:
+    mean_block_count: 0.1491
+    mean_near_dup_block_d0: 0.7737
     mean_sub_block_count: 0.2805
   ngram:
     mean_bigram_hapax_fraction: 0.0998
@@ -520,11 +520,12 @@ no_magic_value_assigned:
     mean_density: -0.0945
     mean_symbol_count: -0.2742
   vocabulary:
-    mean_mattr: 0.0329
-    mean_raw_ttr: 0.0328
-    mean_total_identifiers: -0.0327
+    mean_mattr: 0.0346
+    mean_raw_ttr: 0.0360
+    mean_total_identifiers: -0.0550
+    mean_unique_identifiers: -0.0191
   vowel_density:
-    mean_total_chars: -0.1899
+    mean_total_chars: -0.2051
   zipf:
     mean_exponent: -0.0525
     mean_r_squared: 0.0208
diff --git a/priv/combined_metrics/variable_naming.yml b/priv/combined_metrics/variable_naming.yml
index 4d68d74..1be9c6b 100644
--- a/priv/combined_metrics/variable_naming.yml
+++ b/priv/combined_metrics/variable_naming.yml
@@ -1,14 +1,12 @@
 boolean_has_is_has_prefix:
   _doc: "Boolean variables should be prefixed with `is_`, `has_`, or `can_`."
-  _fix_hint: "Prefix boolean variables with is_, has_, or can_ (e.g., is_valid, has_errors)"
-  _languages: [elixir, javascript, ruby]
-  _log_baseline: 15.9674
+  _log_baseline: 15.9481
   brevity:
     mean_sample_size: 0.0752
   casing_entropy:
     mean_camel_case_count: 2.0000
-    mean_entropy: 0.5244
-    mean_snake_case_count: -0.2159
+    mean_entropy: 0.4870
+    mean_snake_case_count: -0.2309
   compression:
     mean_raw_bytes: 0.1698
     mean_redundancy: 0.0581
@@ -31,9 +29,9 @@ boolean_has_is_has_prefix:
     mean_k: 0.1146
   identifier_length_variance:
     mean_max: 0.3229
-    mean_mean: 0.3020
-    mean_std_dev: 0.3453
-    mean_variance: 0.6908
+    mean_mean: 0.3109
+    mean_std_dev: 0.3325
+    mean_variance: 0.6646
   ngram:
     mean_bigram_hapax_fraction: 0.0164
     mean_bigram_repeated_unique: -0.0209
@@ -52,11 +50,11 @@ boolean_has_is_has_prefix:
   symbol_density:
     mean_density: -0.1660
   vocabulary:
-    mean_mattr: 0.1133
-    mean_raw_ttr: 0.1095
-    mean_unique_identifiers: 0.1095
+    mean_mattr: 0.1186
+    mean_raw_ttr: 0.1173
+    mean_unique_identifiers: 0.1175
   vowel_density:
-    mean_total_chars: 0.3030
+    mean_total_chars: 0.3117
   zipf:
     mean_exponent: -0.0403
     mean_r_squared: 0.0110
@@ -64,78 +62,74 @@ boolean_has_is_has_prefix:
 
 collection_name_is_plural:
   _doc: "Variables holding a collection should use a plural name."
-  _fix_hint: "Use plural names for collections (users, orders, ids not user, order, id)"
-  _languages: [elixir, javascript, ruby]
-  _log_baseline: 32.4645
+  _log_baseline: 21.8380
   brevity:
-    mean_sample_size: -0.6992
+    mean_sample_size: -0.5320
   casing_entropy:
-    mean_camel_case_count: 0.6209
-    mean_entropy: 0.2223
-    mean_snake_case_count: -0.1349
+    mean_camel_case_count: 0.4724
+    mean_entropy: 0.1726
+    mean_snake_case_count: -0.2009
   compression:
-    mean_raw_bytes: 1.0908
-    mean_redundancy: 0.4215
-    mean_zlib_bytes: 0.1628
-    mean_zlib_ratio: 0.9437
+    mean_raw_bytes: 0.8299
+    mean_redundancy: 0.3207
+    mean_zlib_bytes: 0.1239
+    mean_zlib_ratio: 0.7180
   entropy:
-    mean_token_entropy: -0.1350
-    mean_token_max_entropy: -0.1629
-    mean_vocab_size: -0.6992
+    mean_token_entropy: -0.1027
+    mean_token_max_entropy: -0.1240
+    mean_vocab_size: -0.5320
   halstead:
-    mean_N2_total_operands: -0.0666
-    mean_difficulty: 0.9299
-    mean_effort: 0.6844
-    mean_estimated_bugs: -0.2047
-    mean_n2_unique_operands: -1.0118
-    mean_time_to_implement_seconds: 0.6844
-    mean_vocabulary: -0.6902
-    mean_volume: -0.2049
+    mean_N2_total_operands: -0.0506
+    mean_difficulty: 0.7075
+    mean_effort: 0.5207
+    mean_estimated_bugs: -0.1558
+    mean_n2_unique_operands: -0.7698
+    mean_time_to_implement_seconds: 0.5207
+    mean_vocabulary: -0.5251
+    mean_volume: -0.1559
   heaps:
-    mean_k: -0.9514
+    mean_k: -0.7238
   identifier_length_variance:
-    mean_mean: 2.0000
-    mean_std_dev: -0.8154
-    mean_variance: -1.6626
+    mean_mean: 1.6364
+    mean_std_dev: -0.9858
+    mean_variance: -2.0000
   ngram:
-    mean_bigram_hapax_fraction: -0.1830
-    mean_bigram_repetition_rate: 0.1958
-    mean_bigram_unique: -0.2431
-    mean_trigram_repeated_unique: -0.2204
+    mean_bigram_hapax_fraction: -0.1392
+    mean_bigram_repetition_rate: 0.1490
+    mean_bigram_unique: -0.1850
+    mean_trigram_repeated_unique: -0.1677
   punctuation_density:
-    mean_arrow_density: 0.0922
-    mean_colon_suffix_density: -1.0500
-    mean_question_mark_density: -0.7411
+    mean_arrow_density: 0.0702
+    mean_colon_suffix_density: -0.7988
+    mean_question_mark_density: -0.5639
   readability:
-    mean_avg_line_length: 1.1368
-    mean_avg_sub_words_per_id: 0.1688
-    mean_flesch_adapted: -0.1723
-    mean_fog_adapted: 1.0561
+    mean_avg_line_length: 0.8649
+    mean_avg_sub_words_per_id: 0.1285
+    mean_flesch_adapted: -0.1311
+    mean_fog_adapted: 0.8035
   symbol_density:
-    mean_density: -1.1302
+    mean_density: -0.8598
   vocabulary:
-    mean_mattr: -0.8764
-    mean_raw_ttr: -1.0193
-    mean_total_identifiers: -0.0701
-    mean_unique_identifiers: -1.0655
+    mean_mattr: -0.6972
+    mean_raw_ttr: -0.7582
+    mean_total_identifiers: -0.1337
+    mean_unique_identifiers: -0.8807
   vowel_density:
-    mean_total_chars: 1.9266
+    mean_total_chars: 1.4857
   zipf:
-    mean_exponent: 0.2071
-    mean_r_squared: -0.1226
-    mean_vocab_size: -0.6992
+    mean_exponent: 0.1576
+    mean_r_squared: -0.0933
+    mean_vocab_size: -0.5320
 
 loop_var_is_single_letter:
   _doc: "Loop index variables (`i`, `j`, `k`) are acceptable inside loop bodies."
-  _fix_hint: "Use descriptive loop variable names instead of single letters (user not u)"
-  _languages: [elixir, javascript, ruby]
-  _log_baseline: -28.4780
+  _log_baseline: -28.3218
   brevity:
     mean_sample_size: -0.1049
   casing_entropy:
     mean_camel_case_count: -2.0000
-    mean_entropy: -0.3852
-    mean_snake_case_count: 0.2130
+    mean_entropy: -0.3919
+    mean_snake_case_count: 0.2033
   comment_structure:
     mean_comment_line_ratio: 0.0080
   compression:
@@ -167,9 +161,9 @@ loop_var_is_single_letter:
     mean_r_squared: -0.0216
   identifier_length_variance:
     mean_max: -0.5833
-    mean_mean: -0.8534
-    mean_std_dev: -0.9223
-    mean_variance: -1.8497
+    mean_mean: -0.8498
+    mean_std_dev: -0.9251
+    mean_variance: -1.8576
   indentation:
     mean_max_depth: -0.0956
     mean_mean_depth: -0.0126
@@ -196,11 +190,11 @@ loop_var_is_single_letter:
     mean_distinct_symbol_types: 0.0533
     mean_symbol_count: 0.0087
   vocabulary:
-    mean_mattr: -0.1051
-    mean_raw_ttr: -0.1591
-    mean_unique_identifiers: -0.1594
+    mean_mattr: -0.1052
+    mean_raw_ttr: -0.1626
+    mean_unique_identifiers: -0.1618
   vowel_density:
-    mean_total_chars: -0.8588
+    mean_total_chars: -0.8389
   zipf:
     mean_exponent: 0.0112
     mean_r_squared: -0.0134
@@ -208,120 +202,125 @@ loop_var_is_single_letter:
 
 name_contains_and:
   _doc: "Variable names containing `and` signal a variable that holds two concerns."
-  _fix_hint: "Split variables with 'and' into two focused variables (user_and_role → user + role)"
-  _languages: [elixir, javascript, ruby]
-  _log_baseline: -11.0411
+  _log_baseline: 0.4689
   branching:
-    mean_branch_count: -0.7789
-    mean_branching_density: -0.8340
-    mean_non_blank_count: 0.0514
+    mean_branch_count: -0.3666
+    mean_branching_density: -0.3925
+    mean_non_blank_count: 0.0242
   brevity:
-    mean_sample_size: 0.0228
+    mean_sample_size: 0.0107
   casing_entropy:
-    mean_camel_case_count: -0.4615
-    mean_entropy: 0.1436
-    mean_other_count: 1.3389
-    mean_pascal_case_count: 0.1900
-    mean_snake_case_count: 0.1975
+    mean_camel_case_count: -0.2172
+    mean_entropy: 0.0678
+    mean_other_count: 0.6301
+    mean_pascal_case_count: 0.0894
+    mean_snake_case_count: 0.1042
   comment_structure:
-    mean_comment_line_ratio: -0.0598
+    mean_comment_line_ratio: -0.0282
   compression:
-    mean_raw_bytes: -0.1329
-    mean_redundancy: -0.0509
-    mean_unique_line_ratio: 0.1427
-    mean_zlib_bytes: -0.0335
-    mean_zlib_ratio: -0.1016
+    mean_raw_bytes: -0.0626
+    mean_redundancy: -0.0240
+    mean_unique_line_ratio: 0.0672
+    mean_zlib_bytes: -0.0158
+    mean_zlib_ratio: -0.0478
   entropy:
-    mean_char_max_entropy: 0.0179
-    mean_char_normalized: -0.0146
-    mean_token_normalized: -0.0144
-    mean_total_tokens: 0.1238
-    mean_vocab_size: 0.0228
+    mean_char_max_entropy: 0.0084
+    mean_char_normalized: -0.0068
+    mean_token_normalized: -0.0068
+    mean_total_tokens: 0.0583
+    mean_vocab_size: 0.0107
   function_metrics:
-    mean_avg_function_lines: -0.6838
-    mean_avg_param_count: -0.1995
-    mean_function_count: 0.7156
-    mean_max_function_lines: 0.0491
+    mean_avg_function_lines: -0.3218
+    mean_avg_param_count: -0.0939
+    mean_function_count: 0.3368
+    mean_max_function_lines: 0.0231
   halstead:
-    mean_N1_total_operators: 0.1087
-    mean_N2_total_operands: 0.1710
-    mean_difficulty: 0.1849
-    mean_effort: 0.3281
-    mean_estimated_bugs: 0.1413
-    mean_length: 0.1329
-    mean_n1_unique_operators: 0.0560
-    mean_n2_unique_operands: 0.0401
-    mean_time_to_implement_seconds: 0.3281
-    mean_vocabulary: 0.0436
-    mean_volume: 0.1414
+    mean_N1_total_operators: 0.0512
+    mean_N2_total_operands: 0.0805
+    mean_difficulty: 0.0870
+    mean_effort: 0.1544
+    mean_estimated_bugs: 0.0665
+    mean_length: 0.0626
+    mean_n1_unique_operators: 0.0264
+    mean_n2_unique_operands: 0.0189
+    mean_time_to_implement_seconds: 0.1544
+    mean_vocabulary: 0.0205
+    mean_volume: 0.0665
   heaps:
-    mean_beta: -0.1359
-    mean_k: 0.4287
+    mean_beta: -0.0639
+    mean_k: 0.2017
   identifier_length_variance:
-    mean_max: -0.7789
-    mean_mean: -0.4671
-    mean_std_dev: -0.9757
-    mean_variance: -1.9585
+    mean_max: -0.3666
+    mean_mean: -0.2347
+    mean_std_dev: -0.4600
+    mean_variance: -0.9236
   indentation:
-    mean_blank_line_ratio: -0.1265
-    mean_max_depth: -0.2572
-    mean_mean_depth: -0.2927
-    mean_variance: -0.5976
+    mean_blank_line_ratio: -0.0595
+    mean_max_depth: -0.1211
+    mean_mean_depth: -0.1378
+    mean_variance: -0.2812
   line_patterns:
-    mean_blank_line_ratio: -0.1265
-    mean_string_literal_ratio: -0.7394
-    mean_unique_line_ratio: 0.1718
+    mean_blank_line_ratio: -0.0595
+    mean_string_literal_ratio: -0.3480
+    mean_unique_line_ratio: 0.0808
   magic_number_density:
-    mean_density: 0.8439
-    mean_magic_number_count: 0.9649
-    mean_string_literal_ratio: -0.1285
+    mean_density: 0.3971
+    mean_magic_number_count: 0.4541
+    mean_string_literal_ratio: -0.0605
   near_duplicate_blocks_file:
-    mean_sub_block_count: 0.5838
+    mean_block_count: 0.1874
+    mean_near_dup_block_d0: 1.2114
+    mean_near_dup_block_d3: 1.3353
+    mean_near_dup_block_d4: 1.7204
+    mean_near_dup_block_d5: 2.0000
+    mean_near_dup_block_d6: 0.3458
+    mean_near_dup_block_d7: -0.2294
+    mean_near_dup_block_d8: 0.5102
+    mean_sub_block_count: 0.2831
   ngram:
-    mean_bigram_hapax_fraction: 0.0227
-    mean_bigram_repeated_unique: 0.0307
-    mean_bigram_total: 0.1240
-    mean_bigram_unique: 0.0872
-    mean_trigram_hapax_fraction: -0.0343
-    mean_trigram_repeated_unique: 0.2280
-    mean_trigram_repetition_rate: 0.1771
-    mean_trigram_total: 0.1242
-    mean_trigram_unique: 0.0527
+    mean_bigram_hapax_fraction: 0.0107
+    mean_bigram_repeated_unique: 0.0144
+    mean_bigram_total: 0.0584
+    mean_bigram_unique: 0.0410
+    mean_trigram_hapax_fraction: -0.0161
+    mean_trigram_repeated_unique: 0.1073
+    mean_trigram_repetition_rate: 0.0834
+    mean_trigram_total: 0.0585
+    mean_trigram_unique: 0.0248
   punctuation_density:
-    mean_arrow_density: -0.1900
-    mean_bracket_nonalpha_suffix_count: -0.2572
-    mean_colon_suffix_density: -1.0487
-    mean_dot_count: -0.5320
-    mean_exclamation_density: 1.5137
-    mean_id_nonalpha_suffix_density: -0.0594
-    mean_question_mark_density: 1.5137
+    mean_arrow_density: -0.0894
+    mean_bracket_nonalpha_suffix_count: -0.1211
+    mean_colon_suffix_density: -0.4936
+    mean_dot_count: -0.2504
+    mean_exclamation_density: 0.7124
+    mean_id_nonalpha_suffix_density: -0.0280
+    mean_question_mark_density: 0.7124
   readability:
-    mean_avg_line_length: -0.1965
-    mean_avg_sub_words_per_id: -0.5151
-    mean_avg_tokens_per_line: 0.0675
-    mean_flesch_adapted: 0.8109
-    mean_fog_adapted: -2.0000
-    mean_total_lines: 0.0519
+    mean_avg_line_length: -0.0925
+    mean_avg_sub_words_per_id: -0.2424
+    mean_avg_tokens_per_line: 0.0317
+    mean_flesch_adapted: 0.3817
+    mean_fog_adapted: -0.9412
+    mean_total_lines: 0.0244
   symbol_density:
-    mean_density: 0.1769
-    mean_distinct_symbol_types: 0.1589
-    mean_symbol_count: 0.0451
+    mean_density: 0.0832
+    mean_distinct_symbol_types: 0.0748
+    mean_symbol_count: 0.0212
   vocabulary:
-    mean_mattr: -0.2049
-    mean_raw_ttr: -0.1504
-    mean_total_identifiers: 0.1499
+    mean_mattr: -0.0887
+    mean_raw_ttr: -0.0633
+    mean_total_identifiers: 0.0782
+    mean_unique_identifiers: 0.0162
   vowel_density:
-    mean_total_chars: -0.3180
+    mean_total_chars: -0.1561
   zipf:
-    mean_exponent: 0.0125
-    mean_total_tokens: 0.1238
-    mean_vocab_size: 0.0228
+    mean_exponent: 0.0059
+    mean_total_tokens: 0.0583
+    mean_vocab_size: 0.0107
 
 name_contains_type_suffix:
   _doc: "Type suffixes in names (`userString`, `nameList`) are redundant noise."
-  _fix_hint: "Remove type suffixes from names (userList → users, dataMap → data)"
-  _languages: [elixir, javascript, ruby]
-  _log_baseline: -26.2345
+  _log_baseline: -26.6817
   branching:
     mean_branch_count: -0.4150
     mean_branching_density: -0.4125
@@ -329,10 +328,10 @@ name_contains_type_suffix:
     mean_sample_size: -0.1936
   casing_entropy:
     mean_camel_case_count: -1.4300
-    mean_entropy: -0.3896
+    mean_entropy: -0.3631
     mean_other_count: -2.0000
     mean_pascal_case_count: -0.1660
-    mean_snake_case_count: 0.1802
+    mean_snake_case_count: 0.1449
   compression:
     mean_raw_bytes: -0.2768
     mean_redundancy: -0.1061
@@ -362,9 +361,9 @@ name_contains_type_suffix:
     mean_k: 0.1792
   identifier_length_variance:
     mean_max: -0.3735
-    mean_mean: -0.4843
-    mean_std_dev: -0.6059
-    mean_variance: -1.2170
+    mean_mean: -0.4788
+    mean_std_dev: -0.5916
+    mean_variance: -1.1882
   line_patterns:
     mean_string_literal_ratio: 0.0109
   ngram:
@@ -392,12 +391,12 @@ name_contains_type_suffix:
     mean_density: 0.2546
     mean_symbol_count: -0.0213
   vocabulary:
-    mean_mattr: -0.2341
-    mean_raw_ttr: -0.2567
-    mean_total_identifiers: -0.0421
-    mean_unique_identifiers: -0.2988
+    mean_mattr: -0.2373
+    mean_raw_ttr: -0.2260
+    mean_total_identifiers: -0.0765
+    mean_unique_identifiers: -0.3022
   vowel_density:
-    mean_total_chars: -0.5247
+    mean_total_chars: -0.5536
   zipf:
     mean_exponent: 0.0794
     mean_r_squared: 0.0102
@@ -406,96 +405,93 @@ name_contains_type_suffix:
 
 name_is_abbreviation:
   _doc: "Abbreviated names (`usr`, `cfg`, `mgr`) reduce readability."
-  _fix_hint: "Expand abbreviations to full words (usr → user, cnt → count, idx → index)"
-  _languages: [elixir, javascript, ruby]
-  _log_baseline: 23.1000
+  _log_baseline: 10.7370
   brevity:
-    mean_sample_size: -0.2397
+    mean_sample_size: -0.1542
   casing_entropy:
-    mean_camel_case_count: 0.4951
-    mean_entropy: 0.1951
-    mean_snake_case_count: -0.2645
+    mean_camel_case_count: 0.3184
+    mean_entropy: 0.2713
+    mean_snake_case_count: -0.4803
   compression:
-    mean_raw_bytes: 0.8246
-    mean_redundancy: 0.3054
-    mean_unique_line_ratio: 0.1893
-    mean_zlib_bytes: 0.1088
-    mean_zlib_ratio: 0.7116
+    mean_raw_bytes: 0.5303
+    mean_redundancy: 0.1964
+    mean_unique_line_ratio: 0.1217
+    mean_zlib_bytes: 0.0699
+    mean_zlib_ratio: 0.4576
   entropy:
-    mean_char_entropy: -0.0619
-    mean_char_normalized: -0.0892
-    mean_token_entropy: -0.0583
-    mean_token_max_entropy: -0.0514
-    mean_total_tokens: -0.1699
-    mean_vocab_size: -0.2397
+    mean_char_entropy: -0.0398
+    mean_char_normalized: -0.0573
+    mean_token_entropy: -0.0375
+    mean_token_max_entropy: -0.0330
+    mean_total_tokens: -0.1093
+    mean_vocab_size: -0.1542
   halstead:
-    mean_N1_total_operators: -0.1681
-    mean_N2_total_operands: -0.1679
-    mean_difficulty: 0.3150
-    mean_effort: 0.0480
-    mean_estimated_bugs: -0.2403
-    mean_length: -0.1680
-    mean_n2_unique_operands: -0.4607
-    mean_time_to_implement_seconds: 0.0480
-    mean_vocabulary: -0.3410
-    mean_volume: -0.2405
+    mean_N1_total_operators: -0.1081
+    mean_N2_total_operands: -0.1080
+    mean_difficulty: 0.2026
+    mean_effort: 0.0309
+    mean_estimated_bugs: -0.1545
+    mean_length: -0.1081
+    mean_n2_unique_operands: -0.2963
+    mean_time_to_implement_seconds: 0.0309
+    mean_vocabulary: -0.2193
+    mean_volume: -0.1547
   heaps:
-    mean_beta: -0.1643
-    mean_k: 0.3581
-    mean_r_squared: -0.0412
+    mean_beta: -0.1056
+    mean_k: 0.2303
+    mean_r_squared: -0.0265
   identifier_length_variance:
-    mean_max: 2.0000
-    mean_mean: 1.8274
-    mean_std_dev: 0.3959
-    mean_variance: 0.7880
+    mean_max: 1.2862
+    mean_mean: 1.3727
+    mean_variance: 0.0294
   line_patterns:
-    mean_string_literal_ratio: -0.1475
-    mean_unique_line_ratio: 0.1981
+    mean_string_literal_ratio: -0.0949
+    mean_unique_line_ratio: 0.1274
   magic_number_density:
-    mean_density: 0.5685
-    mean_string_literal_ratio: -0.3380
+    mean_density: 0.3656
+    mean_string_literal_ratio: -0.2174
+  near_duplicate_blocks_file:
+    mean_near_dup_block_d8: -2.0000
   ngram:
-    mean_bigram_repeated_unique: -0.0944
-    mean_bigram_total: -0.1701
-    mean_bigram_unique: -0.0528
-    mean_trigram_hapax_fraction: 0.1423
-    mean_trigram_repeated_unique: -0.3139
-    mean_trigram_repetition_rate: -0.1310
-    mean_trigram_total: -0.1703
-    mean_trigram_unique: -0.0522
+    mean_bigram_repeated_unique: -0.0607
+    mean_bigram_total: -0.1094
+    mean_bigram_unique: -0.0339
+    mean_trigram_hapax_fraction: 0.0915
+    mean_trigram_repeated_unique: -0.2019
+    mean_trigram_repetition_rate: -0.0842
+    mean_trigram_total: -0.1095
+    mean_trigram_unique: -0.0336
   punctuation_density:
-    mean_arrow_density: 0.3569
-    mean_bracket_nonalpha_prefix_count: -0.4746
-    mean_bracket_nonalpha_suffix_count: -0.1763
-    mean_colon_suffix_density: -0.6554
-    mean_dot_count: -0.1834
-    mean_exclamation_density: -0.7311
-    mean_id_nonalpha_suffix_density: -0.0637
-    mean_question_mark_density: -0.9035
+    mean_arrow_density: 0.2295
+    mean_bracket_nonalpha_prefix_count: -0.3052
+    mean_bracket_nonalpha_suffix_count: -0.1134
+    mean_colon_suffix_density: -0.4215
+    mean_dot_count: -0.1179
+    mean_exclamation_density: -0.4702
+    mean_id_nonalpha_suffix_density: -0.0410
+    mean_question_mark_density: -0.5810
   readability:
-    mean_avg_line_length: 0.8581
-    mean_avg_tokens_per_line: -0.1700
-    mean_fog_adapted: -0.1492
+    mean_avg_line_length: 0.5519
+    mean_avg_tokens_per_line: -0.1093
+    mean_fog_adapted: -0.0959
   symbol_density:
-    mean_density: -1.0085
-    mean_symbol_count: -0.1894
+    mean_density: -0.6485
+    mean_symbol_count: -0.1218
   vocabulary:
-    mean_mattr: -0.5807
-    mean_raw_ttr: -0.1377
-    mean_total_identifiers: -0.1967
-    mean_unique_identifiers: -0.3487
+    mean_mattr: -0.1900
+    mean_raw_ttr: 0.1813
+    mean_total_identifiers: -0.3611
+    mean_unique_identifiers: -0.2161
   vowel_density:
-    mean_total_chars: 1.6488
+    mean_total_chars: 1.0156
   zipf:
-    mean_exponent: 0.0937
-    mean_total_tokens: -0.1699
-    mean_vocab_size: -0.2397
+    mean_exponent: 0.0603
+    mean_total_tokens: -0.1093
+    mean_vocab_size: -0.1542
 
 name_is_generic:
   _doc: "Generic names (`data`, `result`, `tmp`, `val`, `obj`) convey no domain meaning."
-  _fix_hint: "Replace generic names (data, result, tmp, info) with domain-specific names"
-  _languages: [elixir, javascript, ruby]
-  _log_baseline: 37.2228
+  _log_baseline: 37.4815
   branching:
     mean_branch_count: 0.5193
     mean_branching_density: 0.3889
@@ -505,8 +501,8 @@ name_is_generic:
     mean_sample_size: 0.2053
   casing_entropy:
     mean_camel_case_count: 2.0000
-    mean_entropy: 0.3865
-    mean_snake_case_count: 0.0835
+    mean_entropy: 0.3582
+    mean_snake_case_count: 0.0915
   compression:
     mean_raw_bytes: 0.3477
     mean_redundancy: 0.0524
@@ -544,9 +540,9 @@ name_is_generic:
     mean_r_squared: 0.0145
   identifier_length_variance:
     mean_max: 0.4477
-    mean_mean: 0.5561
-    mean_std_dev: 0.6865
-    mean_variance: 1.3793
+    mean_mean: 0.5582
+    mean_std_dev: 0.6755
+    mean_variance: 1.3586
   indentation:
     mean_blank_line_ratio: 0.0556
     mean_max_depth: -0.1451
@@ -561,7 +557,12 @@ name_is_generic:
     mean_density: -0.0624
     mean_string_literal_ratio: -0.1451
   near_duplicate_blocks_file:
-    mean_sub_block_count: 0.2270
+    mean_block_count: 0.1243
+    mean_near_dup_block_d0: 0.9543
+    mean_near_dup_block_d6: -0.3521
+    mean_near_dup_block_d7: 0.6021
+    mean_near_dup_block_d8: 0.0644
+    mean_sub_block_count: 0.1831
   ngram:
     mean_bigram_hapax_fraction: 0.1528
     mean_bigram_repeated_unique: -0.1344
@@ -592,12 +593,12 @@ name_is_generic:
     mean_distinct_symbol_types: 0.0252
     mean_symbol_count: 0.0858
   vocabulary:
-    mean_mattr: 0.1805
-    mean_raw_ttr: 0.1632
-    mean_total_identifiers: 0.2060
-    mean_unique_identifiers: 0.3675
+    mean_mattr: 0.1932
+    mean_raw_ttr: 0.1681
+    mean_total_identifiers: 0.2205
+    mean_unique_identifiers: 0.3862
   vowel_density:
-    mean_total_chars: 0.7602
+    mean_total_chars: 0.7766
   zipf:
     mean_exponent: -0.0977
     mean_r_squared: 0.0316
@@ -606,16 +607,14 @@ name_is_generic:
 
 name_is_number_like:
   _doc: "Number-suffixed names (`var1`, `thing2`) signal a missing abstraction."
-  _fix_hint: "Replace number-like names (x1, y2) with descriptive names indicating purpose"
-  _languages: [elixir, javascript, ruby]
-  _log_baseline: 1.7668
+  _log_baseline: 1.7611
   brevity:
     mean_sample_size: -0.0262
   casing_entropy:
     mean_camel_case_count: 0.6902
-    mean_entropy: -0.4709
+    mean_entropy: -0.4687
     mean_other_count: -2.0000
-    mean_snake_case_count: 0.1755
+    mean_snake_case_count: 0.1969
   compression:
     mean_raw_bytes: 0.1098
     mean_redundancy: 0.0379
@@ -646,9 +645,9 @@ name_is_number_like:
     mean_r_squared: 0.0046
   identifier_length_variance:
     mean_max: 0.0623
-    mean_mean: 0.2201
-    mean_std_dev: 0.2399
-    mean_variance: 0.4803
+    mean_mean: 0.2335
+    mean_std_dev: 0.2269
+    mean_variance: 0.4543
   line_patterns:
     mean_string_literal_ratio: 0.0201
   ngram:
@@ -674,12 +673,11 @@ name_is_number_like:
     mean_distinct_symbol_types: -0.0272
     mean_symbol_count: -0.0042
   vocabulary:
-    mean_mattr: -0.0101
-    mean_raw_ttr: -0.0152
-    mean_total_identifiers: -0.0159
-    mean_unique_identifiers: -0.0307
+    mean_mattr: -0.0033
+    mean_total_identifiers: -0.0235
+    mean_unique_identifiers: -0.0258
   vowel_density:
-    mean_total_chars: 0.2031
+    mean_total_chars: 0.2085
   zipf:
     mean_exponent: 0.0060
     mean_total_tokens: -0.0075
@@ -687,9 +685,7 @@ name_is_number_like:
 
 name_is_single_letter:
   _doc: "Single-letter names outside loop indices are too opaque."
-  _fix_hint: "Replace single-letter names with descriptive names (n → count, s → status)"
-  _languages: [elixir, javascript, ruby]
-  _log_baseline: 25.4977
+  _log_baseline: 26.2113
   branching:
     mean_branching_density: -0.0458
     mean_non_blank_count: 0.0439
@@ -697,8 +693,8 @@ name_is_single_letter:
     mean_sample_size: 0.2432
   casing_entropy:
     mean_camel_case_count: 2.0000
-    mean_entropy: 0.4023
-    mean_snake_case_count: -0.1981
+    mean_entropy: 0.3295
+    mean_snake_case_count: -0.1106
   comment_structure:
     mean_comment_line_ratio: -0.0675
   compression:
@@ -735,9 +731,8 @@ name_is_single_letter:
     mean_k: -0.4973
     mean_r_squared: 0.0625
   identifier_length_variance:
-    mean_mean: 1.3809
-    mean_std_dev: 0.0433
-    mean_variance: 0.0855
+    mean_mean: 1.3002
+    mean_variance: 0.0148
   indentation:
     mean_blank_line_ratio: -0.0414
     mean_mean_depth: 0.0281
@@ -773,12 +768,12 @@ name_is_single_letter:
     mean_density: -0.6602
     mean_symbol_count: -0.0262
   vocabulary:
-    mean_mattr: 0.5595
-    mean_raw_ttr: 0.5013
-    mean_total_identifiers: -0.0367
-    mean_unique_identifiers: 0.4625
+    mean_mattr: 0.5024
+    mean_raw_ttr: 0.4133
+    mean_total_identifiers: 0.0496
+    mean_unique_identifiers: 0.4588
   vowel_density:
-    mean_total_chars: 1.3325
+    mean_total_chars: 1.3310
   zipf:
     mean_exponent: -0.2161
     mean_r_squared: 0.1041
@@ -787,9 +782,7 @@ name_is_single_letter:
 
 name_is_too_long:
   _doc: "Names longer than ~30 characters harm readability."
-  _fix_hint: "Shorten overly long names — aim for 2–3 descriptive words, drop redundant context"
-  _languages: [elixir, javascript, ruby]
-  _log_baseline: -7.5164
+  _log_baseline: -7.8322
   branching:
     mean_branch_count: 0.0340
     mean_branching_density: 0.0916
@@ -799,10 +792,10 @@ name_is_too_long:
     mean_sample_size: -0.0167
   casing_entropy:
     mean_camel_case_count: -0.1082
-    mean_entropy: 0.0111
+    mean_entropy: 0.0194
     mean_other_count: 0.0922
     mean_pascal_case_count: 0.0340
-    mean_snake_case_count: 0.1201
+    mean_snake_case_count: 0.1095
   comment_structure:
     mean_comment_line_ratio: 0.1321
   compression:
@@ -840,9 +833,9 @@ name_is_too_long:
     mean_r_squared: -0.0095
   identifier_length_variance:
     mean_max: -0.4664
-    mean_mean: -0.4075
-    mean_std_dev: -0.5860
-    mean_variance: -1.1740
+    mean_mean: -0.4056
+    mean_std_dev: -0.5951
+    mean_variance: -1.1923
   indentation:
     mean_blank_line_ratio: 0.0206
     mean_max_depth: -0.2280
@@ -857,7 +850,13 @@ name_is_too_long:
     mean_density: -0.0708
     mean_string_literal_ratio: -0.1025
   near_duplicate_blocks_file:
-    mean_sub_block_count: 0.1015
+    mean_block_count: 0.0593
+    mean_near_dup_block_d0: 0.3891
+    mean_near_dup_block_d4: 0.6367
+    mean_near_dup_block_d6: 0.5046
+    mean_near_dup_block_d7: -0.5046
+    mean_near_dup_block_d8: 0.9550
+    mean_sub_block_count: 0.1005
   ngram:
     mean_bigram_hapax_fraction: -0.0613
     mean_bigram_repeated_unique: 0.1532
@@ -890,12 +889,12 @@ name_is_too_long:
     mean_distinct_symbol_types: 0.0446
     mean_symbol_count: 0.0831
   vocabulary:
-    mean_mattr: -0.0845
-    mean_raw_ttr: -0.1058
-    mean_total_identifiers: 0.0719
-    mean_unique_identifiers: -0.0383
+    mean_mattr: -0.0939
+    mean_raw_ttr: -0.1041
+    mean_total_identifiers: 0.0610
+    mean_unique_identifiers: -0.0445
   vowel_density:
-    mean_total_chars: -0.3320
+    mean_total_chars: -0.3409
   zipf:
     mean_exponent: 0.0555
     mean_total_tokens: 0.0756
@@ -903,9 +902,7 @@ name_is_too_long:
 
 name_is_too_short:
   _doc: "Names shorter than 3 characters (outside loops) are too opaque."
-  _fix_hint: "Use at least 3 characters — replace very short names with full words"
-  _languages: [elixir, javascript, ruby]
-  _log_baseline: -0.4484
+  _log_baseline: -2.7224
   branching:
     mean_branch_count: -0.2327
     mean_branching_density: -0.2381
@@ -913,9 +910,9 @@ name_is_too_short:
     mean_sample_size: -0.1256
   casing_entropy:
     mean_camel_case_count: -0.0450
-    mean_entropy: -0.4953
+    mean_entropy: -0.4018
     mean_other_count: -2.0000
-    mean_snake_case_count: 0.0286
+    mean_snake_case_count: -0.1480
   comment_structure:
     mean_comment_line_ratio: -0.0092
   compression:
@@ -948,13 +945,15 @@ name_is_too_short:
     mean_k: -0.1166
     mean_r_squared: 0.0306
   identifier_length_variance:
-    mean_mean: 0.5797
-    mean_std_dev: -0.1344
-    mean_variance: -0.2709
+    mean_mean: 0.6923
+    mean_std_dev: -0.2499
+    mean_variance: -0.5009
   indentation:
     mean_variance: 0.0168
   line_patterns:
     mean_string_literal_ratio: 0.0229
+  near_duplicate_blocks_file:
+    mean_near_dup_block_d6: -1.2621
   ngram:
     mean_bigram_hapax_fraction: 0.0137
     mean_bigram_repeated_unique: -0.0944
@@ -977,12 +976,12 @@ name_is_too_short:
     mean_distinct_symbol_types: 0.0241
     mean_symbol_count: -0.0137
   vocabulary:
-    mean_mattr: -0.2548
-    mean_raw_ttr: -0.1285
-    mean_total_identifiers: -0.0370
-    mean_unique_identifiers: -0.1640
+    mean_mattr: -0.2556
+    mean_raw_ttr: -0.1188
+    mean_total_identifiers: -0.1971
+    mean_unique_identifiers: -0.3128
   vowel_density:
-    mean_total_chars: 0.5403
+    mean_total_chars: 0.4916
   zipf:
     mean_exponent: 0.0521
     mean_total_tokens: -0.0256
@@ -990,85 +989,83 @@ name_is_too_short:
 
 negated_boolean_name:
   _doc: "Negated boolean names (`isNotValid`, `notActive`) are harder to reason about."
-  _fix_hint: "Rename negated booleans positively (is_not_active → is_inactive, not_found → missing)"
-  _languages: [elixir, javascript, ruby]
-  _log_baseline: -15.6244
+  _log_baseline: -4.4565
   brevity:
-    mean_sample_size: -0.3765
+    mean_sample_size: -0.0998
   casing_entropy:
-    mean_camel_case_count: -0.4213
+    mean_camel_case_count: -0.1117
   compression:
-    mean_raw_bytes: -0.1561
-    mean_zlib_bytes: -0.2426
-    mean_zlib_ratio: 0.0872
+    mean_raw_bytes: -0.0414
+    mean_zlib_bytes: -0.0643
+    mean_zlib_ratio: 0.0231
   entropy:
-    mean_token_max_entropy: -0.0741
-    mean_vocab_size: -0.3765
+    mean_token_max_entropy: -0.0196
+    mean_vocab_size: -0.0998
   halstead:
-    mean_difficulty: 0.3608
-    mean_effort: 0.2913
-    mean_estimated_bugs: -0.0613
-    mean_n2_unique_operands: -0.4082
-    mean_time_to_implement_seconds: 0.2913
-    mean_vocabulary: -0.3088
-    mean_volume: -0.0612
+    mean_difficulty: 0.0956
+    mean_effort: 0.0772
+    mean_estimated_bugs: -0.0162
+    mean_n2_unique_operands: -0.1082
+    mean_time_to_implement_seconds: 0.0772
+    mean_vocabulary: -0.0818
+    mean_volume: -0.0162
   heaps:
-    mean_beta: 0.1348
-    mean_k: -0.7753
+    mean_beta: 0.0357
+    mean_k: -0.2055
   identifier_length_variance:
-    mean_max: -0.1714
-    mean_mean: -0.4077
-    mean_std_dev: -0.9919
-    mean_variance: -2.0000
+    mean_max: -0.0454
+    mean_mean: -0.1116
+    mean_std_dev: -0.2685
+    mean_variance: -0.5427
   line_patterns:
-    mean_string_literal_ratio: 0.1212
+    mean_string_literal_ratio: 0.0321
   magic_number_density:
-    mean_string_literal_ratio: 0.2446
+    mean_string_literal_ratio: 0.0648
   near_duplicate_blocks_file:
-    mean_sub_block_count: -0.2060
+    mean_near_dup_block_d4: -2.0000
+    mean_near_dup_block_d5: 2.0000
+    mean_sub_block_count: -0.0546
   ngram:
-    mean_bigram_hapax_fraction: -0.1145
-    mean_bigram_repeated_unique: 0.1809
-    mean_bigram_repetition_rate: 0.1382
-    mean_bigram_unique: -0.1039
-    mean_trigram_hapax_fraction: -0.0761
-    mean_trigram_repeated_unique: 0.1656
-    mean_trigram_repetition_rate: 0.2761
-    mean_trigram_unique: -0.1381
+    mean_bigram_hapax_fraction: -0.0303
+    mean_bigram_repeated_unique: 0.0479
+    mean_bigram_repetition_rate: 0.0366
+    mean_bigram_unique: -0.0275
+    mean_trigram_hapax_fraction: -0.0202
+    mean_trigram_repeated_unique: 0.0439
+    mean_trigram_repetition_rate: 0.0732
+    mean_trigram_unique: -0.0366
   punctuation_density:
-    mean_bracket_nonalpha_prefix_count: -0.9075
-    mean_bracket_nonalpha_suffix_count: -0.1522
-    mean_colon_suffix_density: -0.4874
-    mean_exclamation_density: -1.5354
-    mean_id_nonalpha_suffix_density: -0.1055
+    mean_bracket_nonalpha_prefix_count: -0.2405
+    mean_bracket_nonalpha_suffix_count: -0.0403
+    mean_colon_suffix_density: -0.1292
+    mean_exclamation_density: -0.4070
+    mean_id_nonalpha_suffix_density: -0.0280
   readability:
-    mean_avg_line_length: -0.1581
-    mean_avg_sub_words_per_id: -0.4843
-    mean_flesch_adapted: 0.6639
-    mean_fog_adapted: -0.4551
+    mean_avg_line_length: -0.0419
+    mean_avg_sub_words_per_id: -0.1284
+    mean_flesch_adapted: 0.1760
+    mean_fog_adapted: -0.1206
   symbol_density:
-    mean_density: 0.1413
+    mean_density: 0.0375
   vocabulary:
-    mean_mattr: -0.0722
-    mean_raw_ttr: -0.4365
-    mean_unique_identifiers: -0.4305
+    mean_mattr: -0.0261
+    mean_raw_ttr: -0.1352
+    mean_unique_identifiers: -0.1462
   vowel_density:
-    mean_total_chars: -0.4070
+    mean_total_chars: -0.1238
   zipf:
-    mean_exponent: 0.0569
-    mean_vocab_size: -0.3765
+    mean_exponent: 0.0151
+    mean_vocab_size: -0.0998
 
 no_hungarian_notation:
   _doc: "Hungarian notation prefixes (`strName`, `bFlag`) add noise without type safety."
-  _fix_hint: "Remove type prefixes from names (strName → name, intCount → count)"
-  _languages: [elixir, javascript, ruby]
-  _log_baseline: -15.0940
+  _log_baseline: -15.5962
   brevity:
     mean_sample_size: -0.0814
   casing_entropy:
     mean_camel_case_count: -2.0000
-    mean_entropy: -0.1319
-    mean_snake_case_count: 0.3573
+    mean_entropy: 0.0152
+    mean_snake_case_count: 0.2611
   compression:
     mean_raw_bytes: -0.1982
     mean_redundancy: -0.0699
@@ -1097,11 +1094,14 @@ no_hungarian_notation:
     mean_k: 0.0692
   identifier_length_variance:
     mean_max: -0.1067
-    mean_mean: -0.3583
-    mean_std_dev: -0.0131
-    mean_variance: -0.0329
+    mean_mean: -0.3201
+    mean_std_dev: 0.0630
+    mean_variance: 0.1176
   magic_number_density:
     mean_density: 0.0312
+  near_duplicate_blocks_file:
+    mean_near_dup_block_d4: -1.9732
+    mean_near_dup_block_d7: -0.5166
   ngram:
     mean_bigram_hapax_fraction: -0.0158
     mean_bigram_repeated_unique: 0.0179
@@ -1122,20 +1122,19 @@ no_hungarian_notation:
     mean_density: 0.1919
     mean_distinct_symbol_types: 0.0849
   vocabulary:
-    mean_mattr: -0.1437
-    mean_raw_ttr: -0.1556
-    mean_unique_identifiers: -0.1488
+    mean_mattr: -0.1598
+    mean_raw_ttr: -0.1444
+    mean_total_identifiers: -0.1028
+    mean_unique_identifiers: -0.2466
   vowel_density:
-    mean_total_chars: -0.3491
+    mean_total_chars: -0.4192
   zipf:
     mean_exponent: 0.0655
     mean_vocab_size: -0.0814
 
 screaming_snake_for_constants:
   _doc: "Module-level constants should use SCREAMING_SNAKE_CASE."
-  _fix_hint: "Use SCREAMING_SNAKE_CASE for module-level constants (@MAX_SIZE not @max_size)"
-  _languages: [elixir, javascript, ruby]
-  _log_baseline: -6.3000
+  _log_baseline: -5.9884
   branching:
     mean_branching_density: 0.0176
     mean_non_blank_count: -0.0180
@@ -1143,9 +1142,9 @@ screaming_snake_for_constants:
     mean_sample_size: -0.0136
   casing_entropy:
     mean_camel_case_count: 0.0302
-    mean_entropy: 0.0224
-    mean_macro_case_count: 1.9927
-    mean_pascal_case_count: -0.1675
+    mean_entropy: 0.0261
+    mean_macro_case_count: 1.9913
+    mean_pascal_case_count: -0.1674
     mean_screaming_snake_density: 2.0000
   comment_structure:
     mean_comment_line_ratio: 0.0267
@@ -1156,9 +1155,9 @@ screaming_snake_for_constants:
     mean_zlib_bytes: 0.0081
     mean_zlib_ratio: -0.0168
   entropy:
-    mean_char_entropy: 0.0306
+    mean_char_entropy: 0.0305
     mean_char_max_entropy: 0.0092
-    mean_char_normalized: 0.0214
+    mean_char_normalized: 0.0213
     mean_total_tokens: -0.0066
     mean_vocab_size: -0.0136
   halstead:
@@ -1173,9 +1172,9 @@ screaming_snake_for_constants:
     mean_vocabulary: -0.0115
     mean_volume: -0.0088
   identifier_length_variance:
-    mean_mean: 0.0041
-    mean_std_dev: 0.0225
-    mean_variance: 0.0446
+    mean_mean: 0.0048
+    mean_std_dev: 0.0244
+    mean_variance: 0.0482
   indentation:
     mean_blank_line_ratio: 0.0078
     mean_mean_depth: 0.0069
@@ -1194,7 +1193,7 @@ screaming_snake_for_constants:
     mean_bigram_unique: -0.0131
     mean_trigram_hapax_fraction: -0.0045
     mean_trigram_repetition_rate: 0.0072
-    mean_trigram_total: -0.0067
+    mean_trigram_total: -0.0066
     mean_trigram_unique: -0.0101
   punctuation_density:
     mean_arrow_density: 0.0071
@@ -1203,19 +1202,19 @@ screaming_snake_for_constants:
   readability:
     mean_avg_line_length: 0.0087
     mean_avg_sub_words_per_id: -0.0090
-    mean_avg_tokens_per_line: 0.0103
+    mean_avg_tokens_per_line: 0.0102
     mean_flesch_adapted: 0.0095
-    mean_fog_adapted: -0.0083
+    mean_fog_adapted: -0.0082
     mean_total_lines: -0.0182
   symbol_density:
     mean_symbol_count: -0.0036
   vocabulary:
-    mean_mattr: -0.0045
-    mean_raw_ttr: -0.0077
-    mean_total_identifiers: -0.0145
-    mean_unique_identifiers: -0.0226
+    mean_mattr: -0.0037
+    mean_raw_ttr: -0.0055
+    mean_total_identifiers: -0.0157
+    mean_unique_identifiers: -0.0212
   vowel_density:
-    mean_total_chars: -0.0105
+    mean_total_chars: -0.0111
   zipf:
     mean_exponent: 0.0038
     mean_total_tokens: -0.0066

From f6d1b97031a0ff67b28d042fee3c91f1519e314d Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Fri, 20 Mar 2026 22:34:44 +0100
Subject: [PATCH 27/71] docs(spec): health report block impact section, PR
 delta, and compare consolidation

---
 ...26-03-20-health-report-blocks-and-delta.md | 272 ++++++++++++++++++
 1 file changed, 272 insertions(+)
 create mode 100644 docs/superpowers/specs/2026-03-20-health-report-blocks-and-delta.md

diff --git a/docs/superpowers/specs/2026-03-20-health-report-blocks-and-delta.md b/docs/superpowers/specs/2026-03-20-health-report-blocks-and-delta.md
new file mode 100644
index 0000000..d525260
--- /dev/null
+++ b/docs/superpowers/specs/2026-03-20-health-report-blocks-and-delta.md
@@ -0,0 +1,272 @@
+# Health Report: Block Impact Section, PR Delta, and Compare Consolidation
+
+**Date:** 2026-03-20
+**Status:** Approved for implementation
+
+---
+
+## Goal
+
+Unify the health-report and compare commands into a single PR-aware report that:
+
+1. Shows impactful code blocks per changed file with severity and fix hints
+2. Shows a before/after metric delta with bar graphs when a base ref is provided
+3. Shows a PR impact summary at the top of the report
+4. Removes file-level worst_offenders (replaced by block-level view)
+5. Deletes the compare command entirely
+
+---
+
+## User Stories Addressed
+
+| User | Need | How addressed |
+|------|------|---------------|
+| PR author | Find antipatterns by file and line | Block section: file-grouped, line-precise, behavior + fix hint |
+| Reviewer | Estimate merge risk quickly | PR impact summary: score drift, blocks flagged, files changed |
+| Reviewer | Spot quality regressions | Block severity label + delta bar graphs |
+| New repo user | Assess overall code quality | Overall grade + category breakdown (unchanged) |
+
+---
+
+## Architecture
+
+### What Changes
+
+| Component | Change |
+|-----------|--------|
+| `CLI.HealthReport` | Add `--base-ref`, `--head-ref` flags; wire git diff and dual analysis |
+| `HealthReport.generate/2` | Accept `changed_files` + `base_results` opts; add `top_blocks` and `codebase_delta` keys; drop `worst_offenders` |
+| `HealthReport.Delta` | New module — wraps delta computation (logic ported from `Comparator`) |
+| `HealthReport.Formatter` | Remove worst_offenders rendering; add PR summary, delta bar graphs, block section |
+| `CLI.Compare` | **Deleted** |
+| `Comparator` | **Deleted** (logic moved to `HealthReport.Delta`) |
+| Compare-specific `Formatter` | **Deleted** |
+| `Summarizer` | **Deleted** if compare-only (verify at implementation time) |
+
+### What Stays the Same
+
+- Overall score, grade, categories (threshold + cosine)
+- `top_issues` (SampleRunner diagnose_aggregate)
+- Metadata section
+- All analysis options (workers, cache, timeout, NCD flags)
+- Backward compatibility: running without `--base-ref` produces the existing report minus worst_offenders
+
+---
+
+## Data Flow
+
+### With `--base-ref`
+
+```
+CLI.HealthReport
+  ├── Git.collect_files_at_ref(path, base_ref) → base_files_map
+  ├── Git.collect_files_at_ref(path, head_ref) → head_files_map  (head_ref defaults to HEAD)
+  ├── Git.changed_files(path, base_ref, head_ref) → [%ChangedFile{path, status}]
+  ├── Analyzer.analyze_codebase(head_files_map) → head_results
+  ├── BlockImpactAnalyzer.analyze(head_results, head_files_map) → head_results_with_nodes
+  ├── Analyzer.analyze_codebase(base_files_map) → base_results
+  └── HealthReport.generate(head_results_with_nodes,
+        base_results: base_results,
+        changed_files: [path, ...])
+```
+
+### Without `--base-ref`
+
+```
+CLI.HealthReport
+  ├── Analyzer.analyze_codebase(files_map) → results
+  ├── BlockImpactAnalyzer.analyze(results, files_map) → results_with_nodes
+  └── HealthReport.generate(results_with_nodes)
+      (no delta, blocks shown for all files with significant impact)
+```
+
+---
+
+## CLI Options
+
+Added to `codeqa health-report <path>`:
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `--base-ref REF` | (none) | Base git ref to compare from. Enables delta and PR scoping. |
+| `--head-ref REF` | `HEAD` | Head git ref for comparison |
+
+Removed: `--changes-only` (never used; always analyzes all files).
+
+---
+
+## `HealthReport.generate/2` Output Shape
+
+```elixir
+%{
+  metadata: %{path, timestamp, total_files},
+  pr_summary: %{                          # nil when no base_results
+    base_score: integer(),
+    head_score: integer(),
+    score_delta: integer(),               # head - base
+    base_grade: String.t(),
+    head_grade: String.t(),
+    blocks_flagged: integer(),            # total blocks above threshold
+    files_changed: integer(),
+    files_added: integer(),
+    files_modified: integer()
+  },
+  overall_score: integer(),
+  overall_grade: String.t(),
+  codebase_delta: map() | nil,            # nil when no base_results
+  categories: [category_map],            # worst_offenders removed from each
+  top_issues: [behavior_map],
+  top_blocks: [file_block_group]         # new
+}
+```
+
+### `top_blocks` Shape
+
+```elixir
+[
+  %{
+    path: String.t(),
+    status: "added" | "modified" | nil,  # nil when no base_results
+    blocks: [
+      %{
+        start_line: integer(),
+        end_line: integer(),             # derived from node
+        type: String.t(),               # "code" | "doc" | "typespec"
+        token_count: integer(),
+        potentials: [
+          %{
+            category: String.t(),
+            behavior: String.t(),
+            cosine_delta: float(),
+            severity: :critical | :high | :medium,
+            fix_hint: String.t()         # from behavior definition
+          }
+        ]
+      }
+    ]
+  }
+]
+```
+
+### Severity Computation
+
+For each `{behavior, cosine_delta}` on a block:
+
+```
+codebase_cosine = current codebase cosine score for that behavior
+gap = 1.0 - codebase_cosine           # how far below ideal the codebase already is
+severity_ratio = cosine_delta / gap   # what fraction of existing gap this block causes
+
+:critical  when severity_ratio > 0.50
+:high      when severity_ratio > 0.25
+:medium    when severity_ratio > 0.10
+(filtered) when severity_ratio <= 0.10  (below significance, not shown)
+```
+
+`gap` is floored at `0.01` to avoid division by zero when the codebase already scores perfectly on a behavior.
+
+### Block Filtering
+
+A block appears in `top_blocks` when:
+- `token_count >= 10`
+- At least one potential has `severity != filtered` (i.e. `severity_ratio > 0.10`)
+- File is in `changed_files` (when `--base-ref` given) or any file (when not)
+
+Blocks within a file are ordered by their highest `cosine_delta` descending.
+
+---
+
+## `HealthReport.Delta` Module
+
+New module wrapping delta computation, ported from `Comparator`:
+
+```elixir
+@spec compute(base_results :: map(), head_results :: map()) :: map()
+def compute(base_results, head_results)
+```
+
+Returns per-metric aggregate delta (head minus base), same shape as `Comparator.compare_results/3` currently produces for the `"codebase"` key. File-level deltas are not included (that was compare-only, now removed).
+
+---
+
+## Fix Hints per Behavior
+
+Fix hints are sourced from the combined_metrics YAML behavior definitions. The `SampleRunner` / `CombinedMetrics` modules are responsible for resolving a `{category, behavior}` key to its fix_hint string. If no fix_hint is defined for a behavior, the field is omitted from the potential map.
+
+Implementation note: verify at implementation time whether fix_hint is already present in the YAML behavior definitions or needs to be added.
+
+---
+
+## Formatter Changes
+
+### Removed
+
+- Worst offenders tables in all category sections (both threshold and cosine)
+- All compare-command formatting code
+
+### Added
+
+**1. PR Impact Summary** (top of report, only when `pr_summary` present)
+
+```
+Score: B+ → C  |  Δ −8 pts  |  6 blocks flagged across 3 files  |  4 modified, 1 added
+```
+
+**2. Delta Bar Graphs** (after PR summary, before categories; only when `codebase_delta` present)
+
+Bar graphs per major category (complexity, readability, duplication, structure) showing base vs head values. Ported from compare's GitHub formatter. Plain formatter uses ASCII, GitHub formatter uses mermaid.
+
+**3. Block Section** (after top_issues)
+
+```
+## Blocks  (6 flagged across 3 files)
+
+### path/to/file.ex  [modified]
+
+**lines 42–67** · function · 84 tokens
+  🔴 CRITICAL  function_design / cyclomatic_complexity_under_10  (Δ 0.41)
+    → Break this function into smaller single-responsibility functions.
+  🟠 HIGH      structure / deep_nesting  (Δ 0.18)
+    → Flatten nested conditionals using early returns or pattern matching.
+
+**lines 120–134** · code · 31 tokens
+  🟡 MEDIUM    naming / identifier_length  (Δ 0.12)
+    → Use descriptive names that convey intent without abbreviation.
+```
+
+Severity icons: 🔴 CRITICAL, 🟠 HIGH, 🟡 MEDIUM.
+GitHub formatter wraps each file in a `<details>` block.
+
+---
+
+## Deletions
+
+The following files are deleted as part of this work:
+
+- `lib/codeqa/cli/compare.ex`
+- `lib/codeqa/comparator.ex`
+- `lib/codeqa/formatter.ex` (compare formatter — verify no health-report usage first)
+- `lib/codeqa/summarizer.ex` (verify compare-only before deleting)
+- All compare-related tests
+
+---
+
+## Testing
+
+- Unit tests for `HealthReport.Delta.compute/2`
+- Unit tests for severity computation (all three thresholds + filter boundary)
+- Unit tests for `top_blocks` assembly (filtering, ordering, fix_hint inclusion)
+- Unit tests for PR summary computation
+- Integration test: `HealthReport.generate/2` with and without `base_results`
+- Formatter tests: block section renders correctly for plain and github formats
+- CLI test: `--base-ref` wires through to git calls and generate correctly
+- Deletion verification: no references to deleted modules remain
+
+---
+
+## Out of Scope
+
+- Per-block raw metric values (blocks carry cosine_delta only, not raw metrics)
+- File-level delta details (compare's per-file before/after table is dropped)
+- Near-duplicate block pairs in the block section (they exist as metrics but are not surfaced here)
+- Relative severity across blocks (no "this block is Nx worse than average block")

From 3af09e94ae18f09ae6c02e3e55af513f6b03d93b Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Fri, 20 Mar 2026 22:40:37 +0100
Subject: [PATCH 28/71] =?UTF-8?q?docs(spec):=20address=20review=20findings?=
 =?UTF-8?q?=20=E2=80=94=20fix=20changed=5Ffiles=20interface,=20end=5Fline,?=
 =?UTF-8?q?=20codebase=5Fcosine=20source,=20fix=20hints,=20severity=20cave?=
 =?UTF-8?q?ats?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...26-03-20-health-report-blocks-and-delta.md | 124 ++++++++++++------
 1 file changed, 82 insertions(+), 42 deletions(-)

diff --git a/docs/superpowers/specs/2026-03-20-health-report-blocks-and-delta.md b/docs/superpowers/specs/2026-03-20-health-report-blocks-and-delta.md
index d525260..75f2013 100644
--- a/docs/superpowers/specs/2026-03-20-health-report-blocks-and-delta.md
+++ b/docs/superpowers/specs/2026-03-20-health-report-blocks-and-delta.md
@@ -38,10 +38,11 @@ Unify the health-report and compare commands into a single PR-aware report that:
 | `HealthReport.generate/2` | Accept `changed_files` + `base_results` opts; add `top_blocks` and `codebase_delta` keys; drop `worst_offenders` |
 | `HealthReport.Delta` | New module — wraps delta computation (logic ported from `Comparator`) |
 | `HealthReport.Formatter` | Remove worst_offenders rendering; add PR summary, delta bar graphs, block section |
+| `BlockImpactAnalyzer` | Add `end_line` to serialized node output |
 | `CLI.Compare` | **Deleted** |
 | `Comparator` | **Deleted** (logic moved to `HealthReport.Delta`) |
-| Compare-specific `Formatter` | **Deleted** |
-| `Summarizer` | **Deleted** if compare-only (verify at implementation time) |
+| `lib/codeqa/formatter.ex` | **Deleted** (compare-only formatter — confirmed no health-report usage) |
+| `Summarizer` | **Deleted** (confirmed compare-only) |
 
 ### What Stays the Same
 
@@ -67,7 +68,7 @@ CLI.HealthReport
   ├── Analyzer.analyze_codebase(base_files_map) → base_results
   └── HealthReport.generate(head_results_with_nodes,
         base_results: base_results,
-        changed_files: [path, ...])
+        changed_files: [%ChangedFile{path, status}])   # full structs, not just paths
 ```
 
 ### Without `--base-ref`
@@ -77,7 +78,7 @@ CLI.HealthReport
   ├── Analyzer.analyze_codebase(files_map) → results
   ├── BlockImpactAnalyzer.analyze(results, files_map) → results_with_nodes
   └── HealthReport.generate(results_with_nodes)
-      (no delta, blocks shown for all files with significant impact)
+      (no delta, blocks shown for all files with significant impact, status: nil)
 ```
 
 ---
@@ -106,7 +107,7 @@ Removed: `--changes-only` (never used; always analyzes all files).
     score_delta: integer(),               # head - base
     base_grade: String.t(),
     head_grade: String.t(),
-    blocks_flagged: integer(),            # total blocks above threshold
+    blocks_flagged: integer(),            # derived: Enum.sum(Enum.map(top_blocks, &length(&1.blocks)))
     files_changed: integer(),
     files_added: integer(),
     files_modified: integer()
@@ -114,24 +115,30 @@ Removed: `--changes-only` (never used; always analyzes all files).
   overall_score: integer(),
   overall_grade: String.t(),
   codebase_delta: map() | nil,            # nil when no base_results
-  categories: [category_map],            # worst_offenders removed from each
+  categories: [category_map],             # worst_offenders removed from each
   top_issues: [behavior_map],
-  top_blocks: [file_block_group]         # new
+  top_blocks: [file_block_group]          # new
 }
 ```
 
+### `pr_summary` Computation Notes
+
+- `base_score` / `base_grade`: requires running the full grading pipeline on `base_results` (same `Grader.grade_aggregate` + `Grader.overall_score` calls as for head). This is a second pass over base data — not a shortcut.
+- `blocks_flagged`: computed after `top_blocks` is assembled (sum of all blocks across all file groups).
+- `files_added` / `files_modified`: counted from `changed_files` structs (`:status` field).
+
 ### `top_blocks` Shape
 
 ```elixir
 [
   %{
     path: String.t(),
-    status: "added" | "modified" | nil,  # nil when no base_results
+    status: "added" | "modified" | nil,  # nil when no base_results (no --base-ref)
     blocks: [
       %{
         start_line: integer(),
-        end_line: integer(),             # derived from node
-        type: String.t(),               # "code" | "doc" | "typespec"
+        end_line: integer(),
+        type: String.t(),                 # "code" | "doc" | "typespec"
         token_count: integer(),
         potentials: [
           %{
@@ -139,7 +146,7 @@ Removed: `--changes-only` (never used; always analyzes all files).
             behavior: String.t(),
             cosine_delta: float(),
             severity: :critical | :high | :medium,
-            fix_hint: String.t()         # from behavior definition
+            fix_hint: String.t() | nil    # nil if not defined for that behavior
           }
         ]
       }
@@ -150,50 +157,66 @@ Removed: `--changes-only` (never used; always analyzes all files).
 
 ### Severity Computation
 
+Severity is computed during `top_blocks` assembly in `HealthReport.generate/2`, not in `BlockImpactAnalyzer`. The baseline codebase cosine scores are already available via `SampleRunner.diagnose_aggregate(baseline_codebase_agg, top: 99_999, languages: project_langs)` — the same call already made for `top_issues`. Pass these as a lookup map `%{{category, behavior} => codebase_cosine}` into the block assembly step.
+
 For each `{behavior, cosine_delta}` on a block:
 
 ```
-codebase_cosine = current codebase cosine score for that behavior
-gap = 1.0 - codebase_cosine           # how far below ideal the codebase already is
-severity_ratio = cosine_delta / gap   # what fraction of existing gap this block causes
+codebase_cosine = lookup codebase cosine for that {category, behavior}
+                  (default to 0.0 if behavior not found in codebase diagnose)
+gap = max(0.01, 1.0 - codebase_cosine)   # floor prevents division by zero
+severity_ratio = cosine_delta / gap       # fraction of existing gap this block causes
 
 :critical  when severity_ratio > 0.50
 :high      when severity_ratio > 0.25
 :medium    when severity_ratio > 0.10
-(filtered) when severity_ratio <= 0.10  (below significance, not shown)
+(filtered) when severity_ratio <= 0.10   (below significance, not shown)
 ```
 
-`gap` is floored at `0.01` to avoid division by zero when the codebase already scores perfectly on a behavior.
+**Note on thresholds:** These are initial defaults. The gap-relative formula means a block with `cosine_delta = 0.12` may be `:critical` in a healthy codebase (small gap) and `:medium` in a poor one (large gap). This is intentional — severity reflects impact relative to where the codebase currently stands. Thresholds should be validated against real codebases and are configurable in future iterations.
+
+### Fix Hint Enrichment
+
+Fix hints are sourced from the combined_metrics YAMLs (`priv/combined_metrics/<category>.yml`, `_fix_hint` key per behavior). All 12 category YAMLs have `_fix_hint` fields. Enrichment happens during `top_blocks` assembly in `HealthReport.generate/2` using `CombinedMetrics.Scorer.all_yamls()` (compiled at module load time). Pattern mirrors the existing `cosine_fix_hint/2` in formatters. If a behavior has no `_fix_hint`, the field is `nil`.
 
 ### Block Filtering
 
 A block appears in `top_blocks` when:
-- `token_count >= 10`
+- `token_count >= 10` (already guaranteed by BlockImpactAnalyzer, but re-checked for safety)
 - At least one potential has `severity != filtered` (i.e. `severity_ratio > 0.10`)
-- File is in `changed_files` (when `--base-ref` given) or any file (when not)
+- File path is in `changed_files` paths (when `--base-ref` given) or any file (when not)
 
 Blocks within a file are ordered by their highest `cosine_delta` descending.
 
 ---
 
-## `HealthReport.Delta` Module
+## `BlockImpactAnalyzer` Change: Add `end_line`
 
-New module wrapping delta computation, ported from `Comparator`:
+The serialized node map in `serialize_node/9` (`block_impact_analyzer.ex:167-175`) currently omits `end_line`. Add it:
 
 ```elixir
-@spec compute(base_results :: map(), head_results :: map()) :: map()
-def compute(base_results, head_results)
+%{
+  "start_line"  => node.start_line,
+  "end_line"    => node.end_line,       # ADD THIS
+  "column_start" => ...,
+  ...
+}
 ```
 
-Returns per-metric aggregate delta (head minus base), same shape as `Comparator.compare_results/3` currently produces for the `"codebase"` key. File-level deltas are not included (that was compare-only, now removed).
+The `Node` struct already has `end_line` — this is a one-line addition. The existing test in `block_impact_analyzer_test.exs` must also assert `Map.has_key?(node, "end_line")`.
 
 ---
 
-## Fix Hints per Behavior
+## `HealthReport.Delta` Module
 
-Fix hints are sourced from the combined_metrics YAML behavior definitions. The `SampleRunner` / `CombinedMetrics` modules are responsible for resolving a `{category, behavior}` key to its fix_hint string. If no fix_hint is defined for a behavior, the field is omitted from the potential map.
+New module wrapping delta computation, ported from `Comparator`:
+
+```elixir
+@spec compute(base_results :: map(), head_results :: map()) :: map()
+def compute(base_results, head_results)
+```
 
-Implementation note: verify at implementation time whether fix_hint is already present in the YAML behavior definitions or needs to be added.
+Returns per-metric aggregate delta (head minus base), porting `compute_aggregate_delta/2` and `compute_numeric_delta/2` from `Comparator`. File-level deltas are not included (compare-only, now removed).
 
 ---
 
@@ -201,12 +224,14 @@ Implementation note: verify at implementation time whether fix_hint is already p
 
 ### Removed
 
-- Worst offenders tables in all category sections (both threshold and cosine)
-- All compare-command formatting code
+- Worst offenders tables in all category sections (both threshold and cosine):
+  - `plain.ex`: remove calls at lines 60, 64 and functions `cosine_worst_offenders/2` (91-117), `worst_offenders_section/2` (204-245)
+  - `github.ex`: remove calls at lines 249, 381 and functions `cosine_worst_offenders/2` (254-304), `worst_offenders/2` (384-435)
+- All compare-command formatting code (`lib/codeqa/formatter.ex` deleted)
 
 ### Added
 
-**1. PR Impact Summary** (top of report, only when `pr_summary` present)
+**1. PR Impact Summary** (top of report, only when `pr_summary` present; omitted entirely when nil)
 
 ```
 Score: B+ → C  |  Δ −8 pts  |  6 blocks flagged across 3 files  |  4 modified, 1 added
@@ -214,7 +239,7 @@ Score: B+ → C  |  Δ −8 pts  |  6 blocks flagged across 3 files  |  4 modifi
 
 **2. Delta Bar Graphs** (after PR summary, before categories; only when `codebase_delta` present)
 
-Bar graphs per major category (complexity, readability, duplication, structure) showing base vs head values. Ported from compare's GitHub formatter. Plain formatter uses ASCII, GitHub formatter uses mermaid.
+Bar graphs per major category (complexity, readability, duplication, structure) showing base vs head values. Port `progress_bars/2` and `mermaid_chart/1` logic from `lib/codeqa/formatter.ex`. Plain formatter uses ASCII, GitHub formatter uses mermaid.
 
 **3. Block Section** (after top_issues)
 
@@ -235,32 +260,46 @@ Bar graphs per major category (complexity, readability, duplication, structure)
 ```
 
 Severity icons: 🔴 CRITICAL, 🟠 HIGH, 🟡 MEDIUM.
-GitHub formatter wraps each file in a `<details>` block.
+GitHub formatter wraps each file in a `<details><summary>` block (consistent with how categories are already wrapped in `github.ex:137-195`).
 
 ---
 
 ## Deletions
 
-The following files are deleted as part of this work:
+The following files are deleted as part of this work (all confirmed compare-only, no health-report dependencies):
 
 - `lib/codeqa/cli/compare.ex`
 - `lib/codeqa/comparator.ex`
-- `lib/codeqa/formatter.ex` (compare formatter — verify no health-report usage first)
-- `lib/codeqa/summarizer.ex` (verify compare-only before deleting)
-- All compare-related tests
+- `lib/codeqa/formatter.ex`
+- `lib/codeqa/summarizer.ex`
+- `test/codeqa/cli_compare_test.exs`
 
 ---
 
 ## Testing
 
+### New tests required
+
 - Unit tests for `HealthReport.Delta.compute/2`
-- Unit tests for severity computation (all three thresholds + filter boundary)
-- Unit tests for `top_blocks` assembly (filtering, ordering, fix_hint inclusion)
-- Unit tests for PR summary computation
-- Integration test: `HealthReport.generate/2` with and without `base_results`
-- Formatter tests: block section renders correctly for plain and github formats
-- CLI test: `--base-ref` wires through to git calls and generate correctly
-- Deletion verification: no references to deleted modules remain
+- Unit tests for severity computation: all three thresholds, filter boundary, gap floor (gap=0 → floored to 0.01), behavior not found in codebase diagnose (default 0.0)
+- Unit tests for `top_blocks` assembly: filtering by token_count, severity, changed_files; ordering by cosine_delta; fix_hint inclusion and nil case
+- Unit tests for PR summary computation: score/grade computation from base+head, blocks_flagged derivation, file status counts
+- Integration test: `HealthReport.generate/2` with and without `base_results` — verify output keys present/nil correctly
+- Formatter tests: block section renders correctly for plain and github formats; pr_summary nil omits summary and delta sections gracefully
+- CLI test: `--base-ref` wires through to `Git.collect_files_at_ref`, `Git.changed_files`, and `HealthReport.generate` correctly
+- `BlockImpactAnalyzer` test: assert `end_line` present in serialized node
+
+### Tests to delete
+
+- `test/codeqa/cli_compare_test.exs` (entire file)
+- `test/codeqa/health_report/formatter_test.exs:186-194` — "includes worst offenders section"
+- `test/codeqa/health_report/formatter_test.exs:216-226` — "renders cosine worst offenders per behavior"
+
+### Tests to update
+
+- `test/codeqa/health_report/formatter_test.exs:196-200` — "summary detail omits category sections" (refute reason changes)
+- Any test referencing `worst_offenders` in the generate output shape
+- `test/codeqa/block_impact_analyzer_test.exs` — add `end_line` assertion
 
 ---
 
@@ -270,3 +309,4 @@ The following files are deleted as part of this work:
 - File-level delta details (compare's per-file before/after table is dropped)
 - Near-duplicate block pairs in the block section (they exist as metrics but are not surfaced here)
 - Relative severity across blocks (no "this block is Nx worse than average block")
+- Configurable severity thresholds (hardcoded defaults for now; future iteration)

From 6d1042f27e1cb2994068fb7f21f1c91c56b759c4 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 12:40:29 +0100
Subject: [PATCH 29/71] docs(plan): health report block impact, PR delta, and
 compare consolidation

---
 ...26-03-21-health-report-blocks-and-delta.md | 1679 +++++++++++++++++
 1 file changed, 1679 insertions(+)
 create mode 100644 docs/superpowers/plans/2026-03-21-health-report-blocks-and-delta.md

diff --git a/docs/superpowers/plans/2026-03-21-health-report-blocks-and-delta.md b/docs/superpowers/plans/2026-03-21-health-report-blocks-and-delta.md
new file mode 100644
index 0000000..1d6e9d0
--- /dev/null
+++ b/docs/superpowers/plans/2026-03-21-health-report-blocks-and-delta.md
@@ -0,0 +1,1679 @@
+# Health Report: Block Impact, PR Delta, and Compare Consolidation
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Unify health-report and compare commands into a single PR-aware report showing impactful blocks per changed file, before/after metric delta, and a PR impact summary — while deleting the compare command entirely.
+
+**Architecture:** `HealthReport.generate/2` gains `base_results:` and `changed_files:` opts; a new `HealthReport.TopBlocks` module assembles severity-classified blocks from node data; a new `HealthReport.Delta` module wraps aggregate delta computation ported from `Comparator`; formatters gain PR summary, delta, and block sections and lose worst_offenders rendering; `CLI.HealthReport` gains `--base-ref`/`--head-ref` and runs dual analysis when provided.
+
+**Tech Stack:** Elixir, ExUnit, `CodeQA.Git`, `CodeQA.CombinedMetrics.{SampleRunner, Scorer}`, `CodeQA.HealthReport.Grader`, `CodeQA.BlockImpactAnalyzer`
+
+---
+
+## File Map
+
+| File | Change |
+|------|--------|
+| `lib/codeqa/block_impact_analyzer.ex` | Add `"end_line"` to `serialize_node/9` output |
+| `lib/codeqa/health_report/delta.ex` | **Create** — aggregate delta computation (ported from `Comparator`) |
+| `lib/codeqa/health_report/top_blocks.ex` | **Create** — block assembly, severity, fix hint enrichment |
+| `lib/codeqa/health_report.ex` | Accept new opts, wire `Delta` + `TopBlocks`, drop `worst_offenders` computation |
+| `lib/codeqa/health_report/formatter/plain.ex` | Remove worst_offenders rendering; add PR summary, delta table, block section |
+| `lib/codeqa/health_report/formatter/github.ex` | Remove worst_offenders rendering; add PR summary, delta table, block section |
+| `lib/codeqa/cli/health_report.ex` | Add `--base-ref`/`--head-ref`; dual analysis when base-ref given |
+| `lib/codeqa/cli.ex` | Remove compare entry |
+| `lib/codeqa/cli/compare.ex` | **Delete** |
+| `lib/codeqa/comparator.ex` | **Delete** |
+| `lib/codeqa/formatter.ex` | **Delete** |
+| `lib/codeqa/summarizer.ex` | **Delete** |
+| `test/codeqa/block_impact_analyzer_test.exs` | Add `end_line` assertion |
+| `test/codeqa/health_report/delta_test.exs` | **Create** |
+| `test/codeqa/health_report/top_blocks_test.exs` | **Create** |
+| `test/codeqa/health_report_test.exs` | Add: `top_blocks`, `pr_summary`, `codebase_delta` keys; remove worst_offenders assertions |
+| `test/codeqa/health_report/formatter_test.exs` | Delete worst_offenders tests; add block/delta/summary tests |
+| `test/codeqa/cli_compare_test.exs` | **Delete** |
+
+---
+
+## Task 1: Add `end_line` to BlockImpactAnalyzer node serialization
+
+**Files:**
+- Modify: `lib/codeqa/block_impact_analyzer.ex:167-175`
+- Test: `test/codeqa/block_impact_analyzer_test.exs:42-52`
+
+- [ ] **Step 1: Add `end_line` assertion to the existing "each node has required fields" test**
+
+In `test/codeqa/block_impact_analyzer_test.exs`, inside the `Enum.each(nodes, fn node ->` block (line 42), add after line 43:
+
+```elixir
+assert Map.has_key?(node, "end_line")
+```
+
+- [ ] **Step 2: Run the test to confirm it fails**
+
+```bash
+mix test test/codeqa/block_impact_analyzer_test.exs --trace
+```
+
+Expected: FAIL — `"end_line"` key missing.
+
+- [ ] **Step 3: Add `end_line` to the serialized node map**
+
+In `lib/codeqa/block_impact_analyzer.ex`, edit the map at line 167:
+
+```elixir
+%{
+  "start_line" => node.start_line,
+  "end_line" => node.end_line,
+  "column_start" => (first_token && first_token.col) || 0,
+  "char_length" => char_length,
+  "type" => Atom.to_string(node.type),
+  "token_count" => length(node.tokens),
+  "refactoring_potentials" => potentials,
+  "children" => children
+}
+```
+
+- [ ] **Step 4: Run the test to confirm it passes**
+
+```bash
+mix test test/codeqa/block_impact_analyzer_test.exs --trace
+```
+
+Expected: all tests PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add lib/codeqa/block_impact_analyzer.ex test/codeqa/block_impact_analyzer_test.exs
+git commit -m "feat(block-impact): serialize end_line in node output"
+```
+
+---
+
+## Task 2: Create `HealthReport.Delta`
+
+**Files:**
+- Create: `lib/codeqa/health_report/delta.ex`
+- Create: `test/codeqa/health_report/delta_test.exs`
+
+- [ ] **Step 1: Write the test file**
+
+```elixir
+# test/codeqa/health_report/delta_test.exs
+defmodule CodeQA.HealthReport.DeltaTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.HealthReport.Delta
+
+  defp make_results(aggregate) do
+    %{"codebase" => %{"aggregate" => aggregate}}
+  end
+
+  test "returns base, head, and delta aggregates" do
+    base = make_results(%{"entropy" => %{"mean_value" => 5.0}})
+    head = make_results(%{"entropy" => %{"mean_value" => 6.0}})
+
+    result = Delta.compute(base, head)
+
+    assert result.base.aggregate == %{"entropy" => %{"mean_value" => 5.0}}
+    assert result.head.aggregate == %{"entropy" => %{"mean_value" => 6.0}}
+    assert result.delta.aggregate == %{"entropy" => %{"mean_value" => 1.0}}
+  end
+
+  test "rounds delta to 4 decimal places" do
+    base = make_results(%{"entropy" => %{"mean_value" => 1.0}})
+    head = make_results(%{"entropy" => %{"mean_value" => 4.3333}})
+
+    result = Delta.compute(base, head)
+    assert result.delta.aggregate["entropy"]["mean_value"] == 3.3333
+  end
+
+  test "handles missing base codebase gracefully" do
+    base = %{}
+    head = make_results(%{"entropy" => %{"mean_value" => 6.0}})
+
+    result = Delta.compute(base, head)
+    assert result.delta.aggregate == %{}
+  end
+
+  test "handles missing head codebase gracefully" do
+    base = make_results(%{"entropy" => %{"mean_value" => 5.0}})
+    head = %{}
+
+    result = Delta.compute(base, head)
+    assert result.delta.aggregate == %{}
+  end
+
+  test "skips non-numeric metric keys" do
+    base = make_results(%{"entropy" => %{"mean_value" => 5.0, "label" => "x"}})
+    head = make_results(%{"entropy" => %{"mean_value" => 6.0, "label" => "y"}})
+
+    result = Delta.compute(base, head)
+    refute Map.has_key?(result.delta.aggregate["entropy"], "label")
+    assert result.delta.aggregate["entropy"]["mean_value"] == 1.0
+  end
+end
+```
+
+- [ ] **Step 2: Run test to confirm it fails**
+
+```bash
+mix test test/codeqa/health_report/delta_test.exs --trace
+```
+
+Expected: FAIL — module not found.
+
+- [ ] **Step 3: Create the module**
+
+```elixir
+# lib/codeqa/health_report/delta.ex
+defmodule CodeQA.HealthReport.Delta do
+  @moduledoc "Computes aggregate metric delta between two codebase analysis results."
+
+  @spec compute(map(), map()) :: %{
+          base: %{aggregate: map()},
+          head: %{aggregate: map()},
+          delta: %{aggregate: map()}
+        }
+  def compute(base_results, head_results) do
+    base_agg = get_in(base_results, ["codebase", "aggregate"]) || %{}
+    head_agg = get_in(head_results, ["codebase", "aggregate"]) || %{}
+
+    %{
+      base: %{aggregate: base_agg},
+      head: %{aggregate: head_agg},
+      delta: %{aggregate: compute_aggregate_delta(base_agg, head_agg)}
+    }
+  end
+
+  defp compute_aggregate_delta(base_agg, head_agg) do
+    MapSet.new(Map.keys(base_agg) ++ Map.keys(head_agg))
+    |> Enum.reduce(%{}, fn metric_name, acc ->
+      base_m = Map.get(base_agg, metric_name, %{})
+      head_m = Map.get(head_agg, metric_name, %{})
+      delta = compute_numeric_delta(base_m, head_m)
+      if delta == %{}, do: acc, else: Map.put(acc, metric_name, delta)
+    end)
+  end
+
+  defp compute_numeric_delta(base, head) do
+    MapSet.new(Map.keys(base) ++ Map.keys(head))
+    |> Enum.reduce(%{}, fn key, acc ->
+      case {Map.get(base, key), Map.get(head, key)} do
+        {b, h} when is_number(b) and is_number(h) ->
+          Map.put(acc, key, Float.round(h - b, 4))
+
+        _ ->
+          acc
+      end
+    end)
+  end
+end
+```
+
+- [ ] **Step 4: Run tests to confirm they pass**
+
+```bash
+mix test test/codeqa/health_report/delta_test.exs --trace
+```
+
+Expected: all PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add lib/codeqa/health_report/delta.ex test/codeqa/health_report/delta_test.exs
+git commit -m "feat(health-report): add Delta module for aggregate metric comparison"
+```
+
+---
+
+## Task 3: Create `HealthReport.TopBlocks`
+
+**Files:**
+- Create: `lib/codeqa/health_report/top_blocks.ex`
+- Create: `test/codeqa/health_report/top_blocks_test.exs`
+
+- [ ] **Step 1: Write the test file**
+
+```elixir
+# test/codeqa/health_report/top_blocks_test.exs
+defmodule CodeQA.HealthReport.TopBlocksTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.HealthReport.TopBlocks
+  alias CodeQA.Git.ChangedFile
+
+  # A node with cosine_delta 0.60 — will be :critical when codebase_cosine = 0.0 (gap=1.0, ratio=0.60)
+  defp make_node(cosine_delta, token_count \\ 20) do
+    %{
+      "start_line" => 1,
+      "end_line" => 10,
+      "type" => "code",
+      "token_count" => token_count,
+      "refactoring_potentials" => [
+        %{
+          "category" => "function_design",
+          "behavior" => "cyclomatic_complexity_under_10",
+          "cosine_delta" => cosine_delta
+        }
+      ],
+      "children" => []
+    }
+  end
+
+  defp make_results(nodes) do
+    %{"files" => %{"lib/foo.ex" => %{"nodes" => nodes}}}
+  end
+
+  defp lookup(cosine \\ 0.0) do
+    %{{"function_design", "cyclomatic_complexity_under_10"} => cosine}
+  end
+
+  describe "severity classification" do
+    test ":critical when severity_ratio > 0.50" do
+      # gap = max(0.01, 1.0 - 0.0) = 1.0, ratio = 0.60 / 1.0 = 0.60 > 0.50
+      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup())
+      assert hd(hd(group.blocks).potentials).severity == :critical
+    end
+
+    test ":high when severity_ratio > 0.25 and <= 0.50" do
+      # ratio = 0.30 / 1.0 = 0.30
+      [group] = TopBlocks.build(make_results([make_node(0.30)]), [], lookup())
+      assert hd(hd(group.blocks).potentials).severity == :high
+    end
+
+    test ":medium when severity_ratio > 0.10 and <= 0.25" do
+      # ratio = 0.15 / 1.0 = 0.15
+      [group] = TopBlocks.build(make_results([make_node(0.15)]), [], lookup())
+      assert hd(hd(group.blocks).potentials).severity == :medium
+    end
+
+    test "filtered when severity_ratio <= 0.10" do
+      # ratio = 0.05 / 1.0 = 0.05 — block should not appear
+      assert TopBlocks.build(make_results([make_node(0.05)]), [], lookup()) == []
+    end
+
+    test "gap floor prevents division by zero when codebase_cosine = 1.0" do
+      # gap = max(0.01, 1.0 - 1.0) = 0.01, ratio = 0.02 / 0.01 = 2.0 → :critical
+      [group] = TopBlocks.build(make_results([make_node(0.02)]), [], lookup(1.0))
+      assert hd(hd(group.blocks).potentials).severity == :critical
+    end
+
+    test "gap handles negative codebase_cosine" do
+      # codebase_cosine = -0.5, gap = max(0.01, 1.0 - (-0.5)) = 1.5
+      # ratio = 0.60 / 1.5 = 0.40 → :high
+      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup(-0.5))
+      assert hd(hd(group.blocks).potentials).severity == :high
+    end
+
+    test "unknown behavior defaults codebase_cosine to 0.0" do
+      lookup_empty = %{}
+      # gap = 1.0, ratio = 0.60 → :critical
+      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup_empty)
+      assert hd(hd(group.blocks).potentials).severity == :critical
+    end
+  end
+
+  describe "changed_files filtering" do
+    test "when changed_files is empty, shows all files" do
+      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup())
+      assert group.path == "lib/foo.ex"
+      assert group.status == nil
+    end
+
+    test "when changed_files given, only shows matching files" do
+      changed = [%ChangedFile{path: "lib/other.ex", status: "added"}]
+      assert TopBlocks.build(make_results([make_node(0.60)]), changed, lookup()) == []
+    end
+
+    test "status comes from ChangedFile struct" do
+      changed = [%ChangedFile{path: "lib/foo.ex", status: "modified"}]
+      [group] = TopBlocks.build(make_results([make_node(0.60)]), changed, lookup())
+      assert group.status == "modified"
+    end
+  end
+
+  describe "block filtering" do
+    test "blocks with token_count < 10 are excluded" do
+      assert TopBlocks.build(make_results([make_node(0.60, 9)]), [], lookup()) == []
+    end
+
+    test "blocks are ordered by highest cosine_delta descending" do
+      node_low = make_node(0.20)
+      node_high = put_in(make_node(0.60), ["start_line"], 20)
+      results = %{"files" => %{"lib/foo.ex" => %{"nodes" => [node_low, node_high]}}}
+
+      [group] = TopBlocks.build(results, [], lookup())
+      deltas = Enum.map(group.blocks, fn b -> hd(b.potentials).cosine_delta end)
+      assert deltas == Enum.sort(deltas, :desc)
+    end
+
+    test "children nodes are included" do
+      parent = %{
+        "start_line" => 1, "end_line" => 20,
+        "type" => "code", "token_count" => 5,
+        "refactoring_potentials" => [],
+        "children" => [make_node(0.60)]
+      }
+      [group] = TopBlocks.build(make_results([parent]), [], lookup())
+      assert length(group.blocks) == 1
+    end
+  end
+
+  describe "fix hints" do
+    test "includes fix_hint string for known behavior" do
+      # function_design/cyclomatic_complexity_under_10 has _fix_hint in YAML
+      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup())
+      potential = hd(hd(group.blocks).potentials)
+      assert is_binary(potential.fix_hint)
+    end
+
+    test "fix_hint is nil for unknown behavior" do
+      node = %{
+        "start_line" => 1, "end_line" => 10, "type" => "code",
+        "token_count" => 20,
+        "refactoring_potentials" => [
+          %{"category" => "unknown_cat", "behavior" => "unknown_beh", "cosine_delta" => 0.60}
+        ],
+        "children" => []
+      }
+      [group] = TopBlocks.build(make_results([node]), [], %{})
+      assert hd(hd(group.blocks).potentials).fix_hint == nil
+    end
+  end
+end
+```
+
+- [ ] **Step 2: Run tests to confirm they fail**
+
+```bash
+mix test test/codeqa/health_report/top_blocks_test.exs --trace
+```
+
+Expected: FAIL — module not found.
+
+- [ ] **Step 3: Create the module**
+
+```elixir
+# lib/codeqa/health_report/top_blocks.ex
+defmodule CodeQA.HealthReport.TopBlocks do
+  @moduledoc "Assembles the top_blocks report section from analysis node data."
+
+  alias CodeQA.CombinedMetrics.Scorer
+
+  @min_tokens 10
+  @severity_critical 0.50
+  @severity_high 0.25
+  @severity_medium 0.10
+  @gap_floor 0.01
+
+  @spec build(map(), [struct()], map()) :: [map()]
+  def build(analysis_results, changed_files, codebase_cosine_lookup) do
+    files = Map.get(analysis_results, "files", %{})
+    fix_hints = build_fix_hint_lookup()
+
+    file_entries =
+      if changed_files == [] do
+        Enum.map(files, fn {path, data} -> {path, nil, data} end)
+      else
+        changed_index = Map.new(changed_files, &{&1.path, &1.status})
+
+        files
+        |> Enum.filter(fn {path, _} -> Map.has_key?(changed_index, path) end)
+        |> Enum.map(fn {path, data} -> {path, Map.get(changed_index, path), data} end)
+      end
+
+    file_entries
+    |> Enum.map(fn {path, status, file_data} ->
+      blocks =
+        file_data
+        |> Map.get("nodes", [])
+        |> Enum.flat_map(&collect_nodes/1)
+        |> Enum.filter(&(&1["token_count"] >= @min_tokens))
+        |> Enum.map(&enrich_block(&1, codebase_cosine_lookup, fix_hints))
+        |> Enum.reject(&(&1.potentials == []))
+        |> Enum.sort_by(&(-max_delta(&1)))
+
+      %{path: path, status: status, blocks: blocks}
+    end)
+    |> Enum.reject(&(&1.blocks == []))
+    |> Enum.sort_by(& &1.path)
+  end
+
+  defp collect_nodes(node) do
+    children = node |> Map.get("children", []) |> Enum.flat_map(&collect_nodes/1)
+    [node | children]
+  end
+
+  defp enrich_block(node, cosine_lookup, fix_hints) do
+    potentials =
+      node
+      |> Map.get("refactoring_potentials", [])
+      |> Enum.map(&enrich_potential(&1, cosine_lookup, fix_hints))
+      |> Enum.reject(&is_nil/1)
+      |> Enum.sort_by(& &1.cosine_delta, :desc)
+
+    %{
+      start_line: node["start_line"],
+      end_line: node["end_line"],
+      type: node["type"],
+      token_count: node["token_count"],
+      potentials: potentials
+    }
+  end
+
+  defp enrich_potential(p, cosine_lookup, fix_hints) do
+    category = p["category"]
+    behavior = p["behavior"]
+    cosine_delta = p["cosine_delta"]
+
+    codebase_cosine = Map.get(cosine_lookup, {category, behavior}, 0.0)
+    gap = max(@gap_floor, 1.0 - codebase_cosine)
+    severity = classify(cosine_delta / gap)
+
+    if severity == :filtered do
+      nil
+    else
+      %{
+        category: category,
+        behavior: behavior,
+        cosine_delta: cosine_delta,
+        severity: severity,
+        fix_hint: Map.get(fix_hints, {category, behavior})
+      }
+    end
+  end
+
+  defp classify(ratio) when ratio > @severity_critical, do: :critical
+  defp classify(ratio) when ratio > @severity_high, do: :high
+  defp classify(ratio) when ratio > @severity_medium, do: :medium
+  defp classify(_ratio), do: :filtered
+
+  defp max_delta(%{potentials: []}), do: 0.0
+  defp max_delta(%{potentials: potentials}), do: Enum.max_by(potentials, & &1.cosine_delta).cosine_delta
+
+  defp build_fix_hint_lookup do
+    Scorer.all_yamls()
+    |> Enum.flat_map(fn {yaml_path, data} ->
+      category = yaml_path |> Path.basename() |> String.trim_trailing(".yml")
+
+      Enum.flat_map(data, fn {behavior, behavior_data} ->
+        case get_in(behavior_data, ["_fix_hint"]) do
+          nil -> []
+          hint -> [{{category, behavior}, hint}]
+        end
+      end)
+    end)
+    |> Map.new()
+  end
+end
+```
+
+- [ ] **Step 4: Run tests to confirm they pass**
+
+```bash
+mix test test/codeqa/health_report/top_blocks_test.exs --trace
+```
+
+Expected: all PASS.
+
+- [ ] **Step 5: Run full suite**
+
+```bash
+mix test
+```
+
+Expected: all passing.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add lib/codeqa/health_report/top_blocks.ex test/codeqa/health_report/top_blocks_test.exs
+git commit -m "feat(health-report): add TopBlocks module for severity-classified block assembly"
+```
+
+---
+
+## Task 4: Update `HealthReport.generate/2`
+
+**Files:**
+- Modify: `lib/codeqa/health_report.ex`
+- Modify: `test/codeqa/health_report_test.exs`
+
+- [ ] **Step 1: Add tests for new output keys**
+
+Open `test/codeqa/health_report_test.exs`. Add a describe block (create the file if it doesn't exist):
+
+```elixir
+describe "generate/2 output keys" do
+  @tag :slow
+  test "without base_results: pr_summary and codebase_delta are nil" do
+    files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
+    results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+    results = CodeQA.BlockImpactAnalyzer.analyze(results, files)
+
+    report = CodeQA.HealthReport.generate(results)
+
+    assert report.pr_summary == nil
+    assert report.codebase_delta == nil
+    assert is_list(report.top_blocks)
+    assert Map.has_key?(report, :overall_score)
+    assert Map.has_key?(report, :overall_grade)
+    assert Map.has_key?(report, :categories)
+    assert Map.has_key?(report, :top_issues)
+  end
+
+  @tag :slow
+  test "without base_results: top_blocks shows all files with significant blocks" do
+    files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
+    results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+    results = CodeQA.BlockImpactAnalyzer.analyze(results, files)
+
+    report = CodeQA.HealthReport.generate(results)
+
+    # top_blocks is a list of file groups (may be empty if no blocks above threshold)
+    assert is_list(report.top_blocks)
+    Enum.each(report.top_blocks, fn group ->
+      assert Map.has_key?(group, :path)
+      assert Map.has_key?(group, :status)
+      assert Map.has_key?(group, :blocks)
+      assert group.status == nil
+    end)
+  end
+
+  test "worst_offenders is always empty in categories" do
+    files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
+    results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+    results = CodeQA.BlockImpactAnalyzer.analyze(results, files)
+
+    report = CodeQA.HealthReport.generate(results)
+
+    Enum.each(report.categories, fn cat ->
+      assert Map.get(cat, :worst_offenders, []) == []
+    end)
+  end
+end
+
+describe "generate/2 with base_results" do
+  @tag :slow
+  test "pr_summary is populated" do
+    files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
+    head_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+    head_results = CodeQA.BlockImpactAnalyzer.analyze(head_results, files)
+    base_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+
+    changed = [%CodeQA.Git.ChangedFile{path: "lib/foo.ex", status: "modified"}]
+
+    report = CodeQA.HealthReport.generate(head_results,
+      base_results: base_results,
+      changed_files: changed
+    )
+
+    assert %{
+      base_score: base_score,
+      head_score: head_score,
+      score_delta: delta,
+      base_grade: _,
+      head_grade: _,
+      blocks_flagged: flagged,
+      files_changed: 1,
+      files_added: 0,
+      files_modified: 1
+    } = report.pr_summary
+
+    assert is_integer(base_score)
+    assert is_integer(head_score)
+    assert delta == head_score - base_score
+    assert is_integer(flagged)
+  end
+
+  @tag :slow
+  test "codebase_delta is populated" do
+    files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
+    head_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+    head_results = CodeQA.BlockImpactAnalyzer.analyze(head_results, files)
+    base_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+
+    report = CodeQA.HealthReport.generate(head_results, base_results: base_results)
+
+    assert %{base: %{aggregate: _}, head: %{aggregate: _}, delta: %{aggregate: _}} =
+             report.codebase_delta
+  end
+
+  @tag :slow
+  test "top_blocks scoped to changed_files" do
+    files = %{
+      "lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n",
+      "lib/bar.ex" => "defmodule Bar do\n  def baz, do: :ok\nend\n"
+    }
+    head_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+    head_results = CodeQA.BlockImpactAnalyzer.analyze(head_results, files)
+    base_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+
+    changed = [%CodeQA.Git.ChangedFile{path: "lib/foo.ex", status: "modified"}]
+
+    report = CodeQA.HealthReport.generate(head_results,
+      base_results: base_results,
+      changed_files: changed
+    )
+
+    paths = Enum.map(report.top_blocks, & &1.path)
+    refute "lib/bar.ex" in paths
+  end
+end
+```
+
+- [ ] **Step 2: Run new tests to confirm they fail**
+
+```bash
+mix test test/codeqa/health_report_test.exs --trace
+```
+
+Expected: FAIL — `pr_summary` key missing, etc.
+
+- [ ] **Step 3: Update `lib/codeqa/health_report.ex`**
+
+Replace the entire file:
+
+```elixir
+defmodule CodeQA.HealthReport do
+  @moduledoc "Orchestrates health report generation from analysis results."
+
+  alias CodeQA.HealthReport.{Config, Grader, Formatter, Delta, TopBlocks}
+  alias CodeQA.CombinedMetrics.{FileScorer, SampleRunner}
+
+  @spec generate(map(), keyword()) :: map()
+  def generate(analysis_results, opts \\ []) do
+    config_path = Keyword.get(opts, :config)
+    detail = Keyword.get(opts, :detail, :default)
+    base_results = Keyword.get(opts, :base_results)
+    changed_files = Keyword.get(opts, :changed_files, [])
+
+    %{
+      categories: categories,
+      grade_scale: grade_scale,
+      impact_map: impact_map,
+      combined_top: combined_top
+    } =
+      Config.load(config_path)
+
+    aggregate = get_in(analysis_results, ["codebase", "aggregate"]) || %{}
+    files = Map.get(analysis_results, "files", %{})
+    project_langs = project_languages(files)
+
+    threshold_grades =
+      categories
+      |> Grader.grade_aggregate(aggregate, grade_scale)
+      |> Enum.zip(categories)
+      |> Enum.map(fn {graded, _cat_def} ->
+        summary = build_category_summary(graded)
+
+        graded
+        |> Map.put(:type, :threshold)
+        |> Map.merge(%{summary: summary, worst_offenders: []})
+      end)
+
+    worst_files_map = FileScorer.worst_files_per_behavior(files, combined_top: combined_top)
+
+    cosine_grades =
+      Grader.grade_cosine_categories(aggregate, worst_files_map, grade_scale, project_langs)
+
+    all_categories =
+      (threshold_grades ++ cosine_grades)
+      |> Enum.map(fn cat ->
+        Map.put(cat, :impact, Map.get(impact_map, to_string(cat.key), 1))
+      end)
+
+    {overall_score, overall_grade} = Grader.overall_score(all_categories, grade_scale, impact_map)
+
+    metadata = build_metadata(analysis_results)
+
+    all_cosines =
+      SampleRunner.diagnose_aggregate(aggregate, top: 99_999, languages: project_langs)
+
+    top_issues = Enum.take(all_cosines, 10)
+
+    codebase_cosine_lookup =
+      Map.new(all_cosines, fn i -> {{i.category, i.behavior}, i.cosine} end)
+
+    top_blocks = TopBlocks.build(analysis_results, changed_files, codebase_cosine_lookup)
+
+    {codebase_delta, pr_summary} =
+      if base_results do
+        build_delta_and_summary(
+          base_results,
+          analysis_results,
+          overall_score,
+          overall_grade,
+          all_categories,
+          categories,
+          grade_scale,
+          impact_map,
+          combined_top,
+          changed_files,
+          top_blocks
+        )
+      else
+        {nil, nil}
+      end
+
+    %{
+      metadata: metadata,
+      pr_summary: pr_summary,
+      overall_score: overall_score,
+      overall_grade: overall_grade,
+      codebase_delta: codebase_delta,
+      categories: all_categories,
+      top_issues: top_issues,
+      top_blocks: top_blocks
+    }
+  end
+
+  @spec to_markdown(map(), atom(), atom()) :: String.t()
+  def to_markdown(report, detail \\ :default, format \\ :plain) do
+    Formatter.format_markdown(report, detail, format)
+  end
+
+  defp build_delta_and_summary(
+         base_results,
+         head_results,
+         head_score,
+         head_grade,
+         head_categories,
+         category_defs,
+         grade_scale,
+         impact_map,
+         combined_top,
+         changed_files,
+         top_blocks
+       ) do
+    delta = Delta.compute(base_results, head_results)
+
+    base_aggregate = get_in(base_results, ["codebase", "aggregate"]) || %{}
+    base_files = Map.get(base_results, "files", %{})
+    base_project_langs = project_languages(base_files)
+
+    base_threshold_grades =
+      category_defs
+      |> Grader.grade_aggregate(base_aggregate, grade_scale)
+      |> Enum.zip(category_defs)
+      |> Enum.map(fn {graded, _cat_def} ->
+        graded
+        |> Map.put(:type, :threshold)
+        |> Map.merge(%{summary: "", worst_offenders: []})
+      end)
+
+    base_worst_files_map =
+      FileScorer.worst_files_per_behavior(base_files, combined_top: combined_top)
+
+    base_cosine_grades =
+      Grader.grade_cosine_categories(
+        base_aggregate,
+        base_worst_files_map,
+        grade_scale,
+        base_project_langs
+      )
+
+    base_all_categories =
+      (base_threshold_grades ++ base_cosine_grades)
+      |> Enum.map(fn cat ->
+        Map.put(cat, :impact, Map.get(impact_map, to_string(cat.key), 1))
+      end)
+
+    {base_score, base_grade} = Grader.overall_score(base_all_categories, grade_scale, impact_map)
+
+    blocks_flagged = Enum.sum(Enum.map(top_blocks, fn g -> length(g.blocks) end))
+    files_added = Enum.count(changed_files, &(&1.status == "added"))
+    files_modified = Enum.count(changed_files, &(&1.status == "modified"))
+
+    summary = %{
+      base_score: base_score,
+      head_score: head_score,
+      score_delta: head_score - base_score,
+      base_grade: base_grade,
+      head_grade: head_grade,
+      blocks_flagged: blocks_flagged,
+      files_changed: length(changed_files),
+      files_added: files_added,
+      files_modified: files_modified
+    }
+
+    {delta, summary}
+  end
+
+  defp build_metadata(analysis_results) do
+    meta = Map.get(analysis_results, "metadata", %{})
+
+    %{
+      path: meta["path"] || "unknown",
+      timestamp: meta["timestamp"] || DateTime.utc_now() |> DateTime.to_iso8601(),
+      total_files: meta["total_files"] || map_size(Map.get(analysis_results, "files", %{}))
+    }
+  end
+
+  defp project_languages(files_map) do
+    files_map
+    |> Map.keys()
+    |> Enum.map(&CodeQA.Language.detect(&1).name())
+    |> Enum.reject(&(&1 == "unknown"))
+    |> Enum.uniq()
+  end
+
+  defp build_category_summary(%{type: :cosine}), do: ""
+
+  defp build_category_summary(graded) do
+    low_scorers =
+      graded.metric_scores
+      |> Enum.filter(fn m -> m.score < 60 end)
+      |> length()
+
+    cond do
+      graded.score >= 90 -> "Excellent"
+      graded.score >= 70 and low_scorers == 0 -> "Good"
+      graded.score >= 70 -> "Good overall, #{low_scorers} metric(s) need attention"
+      graded.score >= 50 -> "Needs improvement"
+      true -> "Critical — requires attention"
+    end
+  end
+end
+```
+
+- [ ] **Step 4: Run tests**
+
+```bash
+mix test test/codeqa/health_report_test.exs --trace
+```
+
+Expected: new tests PASS.
+
+- [ ] **Step 5: Run full suite to check for regressions**
+
+```bash
+mix test
+```
+
+Fix any test that asserts on `worst_offenders` being non-empty in the report output — those assertions should now expect `[]`.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add lib/codeqa/health_report.ex test/codeqa/health_report_test.exs
+git commit -m "feat(health-report): add top_blocks, pr_summary, codebase_delta; drop worst_offenders"
+```
+
+---
+
+## Task 5: Update plain formatter
+
+**Files:**
+- Modify: `lib/codeqa/health_report/formatter/plain.ex`
+- Modify: `test/codeqa/health_report/formatter_test.exs`
+
+- [ ] **Step 1: Delete failing worst_offenders tests and add new tests**
+
+In `test/codeqa/health_report/formatter_test.exs`:
+
+**Delete** these tests (they assert on worst_offenders rendering that is now gone):
+- `"includes worst offenders section"` (lines 186–194)
+- `"renders cosine worst offenders per behavior"` (lines 216–226)
+
+**Update** `"summary detail omits category sections"` (line 196) — change to:
+```elixir
+test "summary detail omits category sections" do
+  result = Formatter.format_markdown(@sample_report, :summary, :plain)
+  refute result =~ "Codebase averages"
+end
+```
+
+**Add** these tests after the existing plain describe blocks:
+
+```elixir
+describe "plain formatter: PR summary section" do
+  @sample_report_with_pr Map.put(@sample_report, :pr_summary, %{
+    base_score: 85,
+    head_score: 77,
+    score_delta: -8,
+    base_grade: "B+",
+    head_grade: "C+",
+    blocks_flagged: 6,
+    files_changed: 3,
+    files_added: 1,
+    files_modified: 2
+  })
+
+  test "renders PR summary line when pr_summary present" do
+    result = Formatter.format_markdown(@sample_report_with_pr, :default, :plain)
+    assert result =~ "B+"
+    assert result =~ "C+"
+    assert result =~ "-8"
+    assert result =~ "6"
+    assert result =~ "1 added"
+    assert result =~ "2 modified"
+  end
+
+  test "omits PR summary when pr_summary is nil" do
+    result = Formatter.format_markdown(@sample_report, :default, :plain)
+    refute result =~ "Score:"
+  end
+end
+
+describe "plain formatter: delta section" do
+  @delta %{
+    base: %{aggregate: %{"readability" => %{"mean_flesch_adapted" => 65.0}, "halstead" => %{"mean_difficulty" => 12.0}}},
+    head: %{aggregate: %{"readability" => %{"mean_flesch_adapted" => 61.0}, "halstead" => %{"mean_difficulty" => 15.0}}}
+  }
+
+  @sample_report_with_delta Map.put(@sample_report, :codebase_delta, @delta)
+
+  test "renders metric changes table when codebase_delta present" do
+    result = Formatter.format_markdown(@sample_report_with_delta, :default, :plain)
+    assert result =~ "Metric Changes"
+    assert result =~ "Readability"
+    assert result =~ "65.00"
+    assert result =~ "61.00"
+  end
+
+  test "omits delta section when codebase_delta is nil" do
+    result = Formatter.format_markdown(@sample_report, :default, :plain)
+    refute result =~ "Metric Changes"
+  end
+end
+
+describe "plain formatter: block section" do
+  @block_potential %{
+    category: "function_design",
+    behavior: "cyclomatic_complexity_under_10",
+    cosine_delta: 0.41,
+    severity: :critical,
+    fix_hint: "Reduce branching"
+  }
+
+  @top_blocks [
+    %{
+      path: "lib/foo.ex",
+      status: "modified",
+      blocks: [
+        %{
+          start_line: 42,
+          end_line: 67,
+          type: "code",
+          token_count: 84,
+          potentials: [@block_potential]
+        }
+      ]
+    }
+  ]
+
+  @sample_report_with_blocks Map.put(@sample_report, :top_blocks, @top_blocks)
+
+  test "renders block section header" do
+    result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
+    assert result =~ "Blocks"
+    assert result =~ "1 flagged"
+  end
+
+  test "renders file group with status" do
+    result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
+    assert result =~ "lib/foo.ex"
+    assert result =~ "modified"
+  end
+
+  test "renders block location and type" do
+    result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
+    assert result =~ "lines 42"
+    assert result =~ "67"
+    assert result =~ "84 tokens"
+  end
+
+  test "renders severity icon and behavior" do
+    result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
+    assert result =~ "🔴"
+    assert result =~ "CRITICAL"
+    assert result =~ "cyclomatic_complexity_under_10"
+    assert result =~ "0.41"
+  end
+
+  test "renders fix hint" do
+    result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
+    assert result =~ "Reduce branching"
+  end
+
+  test "omits block section when top_blocks is empty" do
+    report = Map.put(@sample_report, :top_blocks, [])
+    result = Formatter.format_markdown(report, :default, :plain)
+    refute result =~ "## Blocks"
+  end
+
+  test "omits block section when top_blocks key absent" do
+    result = Formatter.format_markdown(@sample_report, :default, :plain)
+    refute result =~ "## Blocks"
+  end
+end
+```
+
+- [ ] **Step 2: Run formatter tests to confirm failures**
+
+```bash
+mix test test/codeqa/health_report/formatter_test.exs --trace
+```
+
+Expected: new tests FAIL, deleted tests no longer present.
+
+- [ ] **Step 3: Update `lib/codeqa/health_report/formatter/plain.ex`**
+
+Replace the `render/2` function and remove `cosine_worst_offenders/2` + `worst_offenders_section/2`. Add new section functions:
+
+```elixir
+@spec render(map(), atom()) :: String.t()
+def render(report, detail) do
+  [
+    pr_summary_section(Map.get(report, :pr_summary)),
+    header(report),
+    cosine_legend(),
+    delta_section(Map.get(report, :codebase_delta)),
+    overall_table(report),
+    top_issues_section(Map.get(report, :top_issues, []), detail),
+    blocks_section(Map.get(report, :top_blocks, [])),
+    category_sections(report.categories, detail)
+  ]
+  |> List.flatten()
+  |> Enum.join("\n")
+end
+```
+
+Remove `cosine_worst_offenders/2` (lines 91–116) and `worst_offenders_section/2` (lines 196–235) entirely.
+
+Update `render_category/2` for cosine — remove the `cosine_worst_offenders` call:
+
+```elixir
+defp render_category(%{type: :cosine} = cat, _detail) do
+  cosine_section_header(cat) ++ cosine_behaviors_table(cat)
+end
+
+defp render_category(cat, _detail) do
+  section_header(cat) ++ metric_detail(cat)
+end
+```
+
+Add the three new private functions at the bottom of the module:
+
+```elixir
+defp pr_summary_section(nil), do: []
+
+defp pr_summary_section(summary) do
+  delta_str =
+    if summary.score_delta >= 0,
+      do: "+#{summary.score_delta}",
+      else: "#{summary.score_delta}"
+
+  status_str = "#{summary.files_modified} modified, #{summary.files_added} added"
+
+  [
+    "> **Score:** #{summary.base_grade} → #{summary.head_grade}  |  **Δ** #{delta_str} pts  |  **#{summary.blocks_flagged}** blocks flagged across #{summary.files_changed} files  |  #{status_str}",
+    ""
+  ]
+end
+
+defp delta_section(nil), do: []
+
+defp delta_section(delta) do
+  base_agg = delta.base.aggregate
+  head_agg = delta.head.aggregate
+
+  metrics = [
+    {"Readability", "readability", "mean_flesch_adapted"},
+    {"Complexity", "halstead", "mean_difficulty"},
+    {"Duplication", "compression", "mean_redundancy"},
+    {"Structure", "branching", "mean_branch_count"}
+  ]
+
+  rows =
+    Enum.flat_map(metrics, fn {label, group, key} ->
+      base_val = get_in(base_agg, [group, key])
+      head_val = get_in(head_agg, [group, key])
+
+      if is_number(base_val) and is_number(head_val) do
+        diff = Float.round(head_val - base_val, 2)
+        diff_str = if diff >= 0, do: "+#{format_num(diff)}", else: "#{format_num(diff)}"
+        ["| #{label} | #{format_num(base_val)} | #{format_num(head_val)} | #{diff_str} |"]
+      else
+        []
+      end
+    end)
+
+  if rows == [] do
+    []
+  else
+    [
+      "## Metric Changes",
+      "",
+      "| Category | Base | Head | Δ |",
+      "|----------|------|------|---|"
+      | rows
+    ] ++ [""]
+  end
+end
+
+defp blocks_section([]), do: []
+
+defp blocks_section(top_blocks) do
+  total = Enum.sum(Enum.map(top_blocks, fn g -> length(g.blocks) end))
+
+  file_parts =
+    Enum.flat_map(top_blocks, fn group ->
+      status_str = if group.status, do: "  [#{group.status}]", else: ""
+
+      block_lines =
+        Enum.flat_map(group.blocks, fn block ->
+          end_line = block.end_line || block.start_line
+          header = "**lines #{block.start_line}–#{end_line}** · #{block.type} · #{block.token_count} tokens"
+
+          potential_lines =
+            Enum.flat_map(block.potentials, fn p ->
+              icon = severity_icon(p.severity)
+              delta_str = format_num(p.cosine_delta)
+              label = "#{String.upcase(to_string(p.severity))}"
+              line = "  #{icon} #{label}  #{p.category} / #{p.behavior}  (Δ #{delta_str})"
+              fix = if p.fix_hint, do: ["    → #{p.fix_hint}"], else: []
+              [line | fix]
+            end)
+
+          [header | potential_lines] ++ [""]
+        end)
+
+      ["### #{group.path}#{status_str}", "" | block_lines]
+    end)
+
+  [
+    "## Blocks  (#{total} flagged across #{length(top_blocks)} files)",
+    ""
+    | file_parts
+  ]
+end
+
+defp severity_icon(:critical), do: "🔴"
+defp severity_icon(:high), do: "🟠"
+defp severity_icon(:medium), do: "🟡"
+```
+
+- [ ] **Step 4: Run formatter tests**
+
+```bash
+mix test test/codeqa/health_report/formatter_test.exs --trace
+```
+
+Expected: all PASS.
+
+- [ ] **Step 5: Run full suite**
+
+```bash
+mix test
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add lib/codeqa/health_report/formatter/plain.ex test/codeqa/health_report/formatter_test.exs
+git commit -m "feat(formatter): add block, delta, PR summary sections; remove worst_offenders (plain)"
+```
+
+---
+
+## Task 6: Update GitHub formatter
+
+**Files:**
+- Modify: `lib/codeqa/health_report/formatter/github.ex`
+- Modify: `test/codeqa/health_report/formatter_test.exs`
+
+- [ ] **Step 1: Add GitHub formatter tests**
+
+In `test/codeqa/health_report/formatter_test.exs`, add a new describe block:
+
+```elixir
+describe "github formatter: block section" do
+  @block_potential %{
+    category: "function_design",
+    behavior: "cyclomatic_complexity_under_10",
+    cosine_delta: 0.41,
+    severity: :critical,
+    fix_hint: "Reduce branching"
+  }
+
+  @top_blocks_gh [
+    %{
+      path: "lib/foo.ex",
+      status: "modified",
+      blocks: [
+        %{start_line: 42, end_line: 67, type: "code", token_count: 84, potentials: [@block_potential]}
+      ]
+    }
+  ]
+
+  @report_with_blocks_gh Map.put(@sample_report, :top_blocks, @top_blocks_gh)
+
+  test "renders block section with details wrapper per file" do
+    result = Formatter.format_markdown(@report_with_blocks_gh, :default, :github)
+    assert result =~ "Blocks"
+    assert result =~ "<details>"
+    assert result =~ "lib/foo.ex"
+    assert result =~ "modified"
+  end
+
+  test "renders severity and fix hint" do
+    result = Formatter.format_markdown(@report_with_blocks_gh, :default, :github)
+    assert result =~ "🔴"
+    assert result =~ "cyclomatic_complexity_under_10"
+    assert result =~ "Reduce branching"
+  end
+end
+
+describe "github formatter: PR summary and delta" do
+  @pr_summary_gh %{
+    base_score: 85, head_score: 77, score_delta: -8,
+    base_grade: "B+", head_grade: "C+",
+    blocks_flagged: 6, files_changed: 3, files_added: 1, files_modified: 2
+  }
+
+  @delta_gh %{
+    base: %{aggregate: %{"readability" => %{"mean_flesch_adapted" => 65.0}}},
+    head: %{aggregate: %{"readability" => %{"mean_flesch_adapted" => 61.0}}}
+  }
+
+  test "renders PR summary" do
+    report = @sample_report |> Map.put(:pr_summary, @pr_summary_gh)
+    result = Formatter.format_markdown(report, :default, :github)
+    assert result =~ "B+"
+    assert result =~ "C+"
+    assert result =~ "-8"
+  end
+
+  test "renders delta section" do
+    report = @sample_report |> Map.put(:codebase_delta, @delta_gh)
+    result = Formatter.format_markdown(report, :default, :github)
+    assert result =~ "Metric Changes"
+    assert result =~ "65.00"
+    assert result =~ "61.00"
+  end
+end
+```
+
+- [ ] **Step 2: Run tests to confirm failures**
+
+```bash
+mix test test/codeqa/health_report/formatter_test.exs --trace 2>&1 | grep -E "FAILED|failure"
+```
+
+- [ ] **Step 3: Update `lib/codeqa/health_report/formatter/github.ex`**
+
+Update `render/3` to include new sections and remove worst_offenders:
+
+```elixir
+def render(report, detail, opts \\ []) do
+  chart? = Keyword.get(opts, :chart, true)
+  display_categories = merge_cosine_categories(report.categories)
+
+  [
+    pr_summary_section(Map.get(report, :pr_summary)),
+    header(report),
+    cosine_legend(),
+    delta_section(Map.get(report, :codebase_delta)),
+    if(chart?, do: mermaid_chart(display_categories), else: []),
+    progress_bars(display_categories),
+    top_issues_section(Map.get(report, :top_issues, []), detail),
+    blocks_section(Map.get(report, :top_blocks, [])),
+    category_sections(display_categories, detail),
+    footer()
+  ]
+  |> List.flatten()
+  |> Enum.join("\n")
+end
+```
+
+Remove `cosine_worst_offenders/2` (lines 254–304) and `worst_offenders/2` (lines 384–435).
+
+Update `cosine_section_content/2` — remove the call to `cosine_worst_offenders`:
+
+```elixir
+defp cosine_section_content(cat, _detail) do
+  # ... existing behaviors_table code ...
+  behaviors_table ++ [""]
+end
+```
+
+Update `section_content/2` — remove the `++ worst_offenders(cat)` at the end (line 381):
+
+```elixir
+defp section_content(cat, _detail) do
+  # ... existing code without worst_offenders ...
+  [
+    "Codebase averages: #{metric_summary}",
+    ""
+    | metrics_table
+  ] ++ [""]
+end
+```
+
+Add new private functions at the bottom:
+
+```elixir
+defp pr_summary_section(nil), do: []
+
+defp pr_summary_section(summary) do
+  delta_str =
+    if summary.score_delta >= 0,
+      do: "+#{summary.score_delta}",
+      else: "#{summary.score_delta}"
+
+  status_str = "#{summary.files_modified} modified, #{summary.files_added} added"
+
+  [
+    "> **Score:** #{summary.base_grade} → #{summary.head_grade}  |  **Δ** #{delta_str} pts  |  **#{summary.blocks_flagged}** blocks flagged across #{summary.files_changed} files  |  #{status_str}",
+    ""
+  ]
+end
+
+defp delta_section(nil), do: []
+
+defp delta_section(delta) do
+  base_agg = delta.base.aggregate
+  head_agg = delta.head.aggregate
+
+  metrics = [
+    {"Readability", "readability", "mean_flesch_adapted"},
+    {"Complexity", "halstead", "mean_difficulty"},
+    {"Duplication", "compression", "mean_redundancy"},
+    {"Structure", "branching", "mean_branch_count"}
+  ]
+
+  rows =
+    Enum.flat_map(metrics, fn {label, group, key} ->
+      base_val = get_in(base_agg, [group, key])
+      head_val = get_in(head_agg, [group, key])
+
+      if is_number(base_val) and is_number(head_val) do
+        diff = Float.round(head_val - base_val, 2)
+        diff_str = if diff >= 0, do: "+#{format_num(diff)}", else: "#{format_num(diff)}"
+        ["| #{label} | #{format_num(base_val)} | #{format_num(head_val)} | #{diff_str} |"]
+      else
+        []
+      end
+    end)
+
+  if rows == [] do
+    []
+  else
+    [
+      "## Metric Changes",
+      "",
+      "| Category | Base | Head | Δ |",
+      "|----------|------|------|---|"
+      | rows
+    ] ++ [""]
+  end
+end
+
+defp blocks_section([]), do: []
+
+defp blocks_section(top_blocks) do
+  total = Enum.sum(Enum.map(top_blocks, fn g -> length(g.blocks) end))
+
+  file_cards =
+    Enum.flat_map(top_blocks, fn group ->
+      status_str = if group.status, do: " [#{group.status}]", else: ""
+      summary_line = "🔍 #{group.path}#{status_str} — #{length(group.blocks)} block(s)"
+
+      block_lines =
+        Enum.flat_map(group.blocks, fn block ->
+          end_line = block.end_line || block.start_line
+
+          potential_lines =
+            Enum.flat_map(block.potentials, fn p ->
+              icon = severity_icon(p.severity)
+              delta_str = format_num(p.cosine_delta)
+              label = String.upcase(to_string(p.severity))
+              line = "**#{icon} #{label}** `#{p.category}/#{p.behavior}` (Δ #{delta_str})"
+              fix = if p.fix_hint, do: ["> #{p.fix_hint}"], else: []
+              [line | fix]
+            end)
+
+          ["**lines #{block.start_line}–#{end_line}** · #{block.type} · #{block.token_count} tokens"] ++
+            potential_lines ++ [""]
+        end)
+
+      inner = List.flatten(block_lines) |> Enum.join("\n")
+
+      [
+        "<details>",
+        "<summary>#{summary_line}</summary>",
+        "",
+        inner,
+        "</details>",
+        ""
+      ]
+    end)
+
+  [
+    "## 🔍 Blocks  (#{total} flagged across #{length(top_blocks)} files)",
+    ""
+    | file_cards
+  ]
+end
+
+defp severity_icon(:critical), do: "🔴"
+defp severity_icon(:high), do: "🟠"
+defp severity_icon(:medium), do: "🟡"
+```
+
+- [ ] **Step 4: Run formatter tests**
+
+```bash
+mix test test/codeqa/health_report/formatter_test.exs --trace
+```
+
+Expected: all PASS.
+
+- [ ] **Step 5: Run full suite**
+
+```bash
+mix test
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add lib/codeqa/health_report/formatter/github.ex test/codeqa/health_report/formatter_test.exs
+git commit -m "feat(formatter): add block, delta, PR summary sections; remove worst_offenders (github)"
+```
+
+---
+
+## Task 7: Update `CLI.HealthReport`
+
+**Files:**
+- Modify: `lib/codeqa/cli/health_report.ex`
+
+- [ ] **Step 1: Update `@command_options` and usage string**
+
+In `lib/codeqa/cli/health_report.ex`, add to `@command_options`:
+
+```elixir
+@command_options [
+  output: :string,
+  config: :string,
+  detail: :string,
+  top: :integer,
+  format: :string,
+  ignore_paths: :string,
+  base_ref: :string,
+  head_ref: :string
+]
+```
+
+Add to the usage string:
+
+```
+      --base-ref REF        Base git ref for PR comparison (enables delta and block scoping)
+      --head-ref REF        Head git ref (default: HEAD)
+```
+
+- [ ] **Step 2: Update `run/1` to wire dual analysis**
+
+Replace the `run/1` body (keeping the existing single-pass as the fallback when no `--base-ref`). The full updated `run/1`:
+
+```elixir
+def run(args) do
+  {opts, [path], _} = Options.parse(args, @command_options, o: :output)
+  Options.validate_dir!(path)
+  extra_ignore_patterns = Options.parse_ignore_paths(opts[:ignore_paths])
+
+  base_ref = opts[:base_ref]
+  head_ref = opts[:head_ref] || "HEAD"
+
+  files =
+    CodeQA.Engine.Collector.collect_files(path, extra_ignore_patterns)
+
+  if map_size(files) == 0 do
+    IO.puts(:stderr, "Warning: no source files found in '#{path}'")
+    exit({:shutdown, 1})
+  end
+
+  IO.puts(:stderr, "Analyzing #{map_size(files)} files for health report...")
+
+  analyze_opts =
+    Options.build_analyze_opts(opts) ++ CodeQA.Config.near_duplicate_blocks_opts()
+
+  start_time = System.monotonic_time(:millisecond)
+  results = CodeQA.Engine.Analyzer.analyze_codebase(files, analyze_opts)
+  end_time = System.monotonic_time(:millisecond)
+
+  IO.puts(:stderr, "Analysis completed in #{end_time - start_time}ms")
+
+  nodes_top = opts[:nodes_top] || 3
+  results = CodeQA.BlockImpactAnalyzer.analyze(results, files, nodes_top: nodes_top)
+
+  total_bytes = results["files"] |> Map.values() |> Enum.map(& &1["bytes"]) |> Enum.sum()
+
+  results =
+    Map.put(results, "metadata", %{
+      "path" => Path.expand(path),
+      "timestamp" => DateTime.utc_now() |> DateTime.to_iso8601(),
+      "total_files" => map_size(files),
+      "total_bytes" => total_bytes
+    })
+
+  {base_results, changed_files} =
+    if base_ref do
+      IO.puts(:stderr, "Collecting base snapshot at #{base_ref}...")
+      base_files = CodeQA.Git.collect_files_at_ref(path, base_ref)
+      changed = CodeQA.Git.changed_files(path, base_ref, head_ref)
+
+      IO.puts(:stderr, "Analyzing base snapshot (#{map_size(base_files)} files)...")
+      base_res = CodeQA.Engine.Analyzer.analyze_codebase(base_files, analyze_opts)
+
+      {base_res, changed}
+    else
+      {nil, []}
+    end
+
+  detail = parse_detail(opts[:detail])
+  format = parse_format(opts[:format])
+  top_n = opts[:top] || 5
+
+  report =
+    CodeQA.HealthReport.generate(results,
+      config: opts[:config],
+      detail: detail,
+      top: top_n,
+      base_results: base_results,
+      changed_files: changed_files
+    )
+
+  markdown = CodeQA.HealthReport.to_markdown(report, detail, format)
+
+  case opts[:output] do
+    nil ->
+      markdown
+
+    file ->
+      File.write!(file, markdown)
+      IO.puts(:stderr, "Health report written to #{file}")
+      ""
+  end
+end
+```
+
+- [ ] **Step 3: Run full test suite**
+
+```bash
+mix test
+```
+
+Expected: all PASS (no tests for git integration at this stage — the git calls require an actual repo with refs, which integration tests would mock or skip).
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add lib/codeqa/cli/health_report.ex
+git commit -m "feat(cli): add --base-ref/--head-ref to health-report for PR delta and block scoping"
+```
+
+---
+
+## Task 8: Delete compare command and related files
+
+**Files:**
+- Delete: `lib/codeqa/cli/compare.ex`
+- Delete: `lib/codeqa/comparator.ex`
+- Delete: `lib/codeqa/formatter.ex`
+- Delete: `lib/codeqa/summarizer.ex`
+- Delete: `test/codeqa/cli_compare_test.exs`
+- Modify: `lib/codeqa/cli.ex`
+
+- [ ] **Step 1: Remove compare from the CLI router**
+
+Read `lib/codeqa/cli.ex` and remove the line that registers `compare` (line 6). It will look like:
+
+```elixir
+"compare" => CodeQA.CLI.Compare,
+```
+
+Remove that entry entirely.
+
+- [ ] **Step 2: Delete the four source files**
+
+```bash
+rm lib/codeqa/cli/compare.ex lib/codeqa/comparator.ex lib/codeqa/formatter.ex lib/codeqa/summarizer.ex
+```
+
+- [ ] **Step 3: Delete compare tests**
+
+```bash
+rm test/codeqa/cli_compare_test.exs
+```
+
+- [ ] **Step 4: Verify no remaining references**
+
+```bash
+grep -r "CLI\.Compare\|CodeQA\.Comparator\|CodeQA\.Formatter\b\|CodeQA\.Summarizer" lib/ test/ --include="*.ex" --include="*.exs"
+```
+
+Expected: no output.
+
+- [ ] **Step 5: Run full test suite**
+
+```bash
+mix test
+```
+
+Expected: all PASS, no references to deleted modules.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add -A
+git commit -m "feat(cli): delete compare command — absorbed into health-report"
+```
+
+---

From 34a118f8860119a7cece02884db5fc375e1d3891 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 12:50:54 +0100
Subject: [PATCH 30/71] feat(block-impact): serialize end_line in node output

Add end_line field to serialized node map in BlockImpactAnalyzer.serialize_node/9.
This field is required by the upcoming HealthReport.TopBlocks module to display
block location ranges in reports.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/block_impact_analyzer.ex        | 1 +
 test/codeqa/block_impact_analyzer_test.exs | 1 +
 2 files changed, 2 insertions(+)

diff --git a/lib/codeqa/block_impact_analyzer.ex b/lib/codeqa/block_impact_analyzer.ex
index d743184..4f62549 100644
--- a/lib/codeqa/block_impact_analyzer.ex
+++ b/lib/codeqa/block_impact_analyzer.ex
@@ -166,6 +166,7 @@ defmodule CodeQA.BlockImpactAnalyzer do
 
     %{
       "start_line" => node.start_line,
+      "end_line" => node.end_line,
       "column_start" => (first_token && first_token.col) || 0,
       "char_length" => char_length,
       "type" => Atom.to_string(node.type),
diff --git a/test/codeqa/block_impact_analyzer_test.exs b/test/codeqa/block_impact_analyzer_test.exs
index 98aaecb..a8341e9 100644
--- a/test/codeqa/block_impact_analyzer_test.exs
+++ b/test/codeqa/block_impact_analyzer_test.exs
@@ -41,6 +41,7 @@ defmodule CodeQA.BlockImpactAnalyzerTest do
 
       Enum.each(nodes, fn node ->
         assert Map.has_key?(node, "start_line")
+        assert Map.has_key?(node, "end_line")
         assert Map.has_key?(node, "column_start")
         assert Map.has_key?(node, "char_length")
         assert Map.has_key?(node, "type")

From 5b46e98e28cac2d2b5c073aad23cf114345b26bb Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 12:52:35 +0100
Subject: [PATCH 31/71] feat(health-report): add Delta module for aggregate
 metric comparison

Implements CodeQA.HealthReport.Delta to compute delta metrics between
base and head codebase analysis results. Only numeric metric values are
included in the delta; string/label fields are skipped. Delta values are
rounded to 4 decimal places.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/health_report/delta.ex        | 42 +++++++++++++++++++
 test/codeqa/health_report/delta_test.exs | 53 ++++++++++++++++++++++++
 2 files changed, 95 insertions(+)
 create mode 100644 lib/codeqa/health_report/delta.ex
 create mode 100644 test/codeqa/health_report/delta_test.exs

diff --git a/lib/codeqa/health_report/delta.ex b/lib/codeqa/health_report/delta.ex
new file mode 100644
index 0000000..fc014db
--- /dev/null
+++ b/lib/codeqa/health_report/delta.ex
@@ -0,0 +1,42 @@
+defmodule CodeQA.HealthReport.Delta do
+  @moduledoc "Computes aggregate metric delta between two codebase analysis results."
+
+  @spec compute(map(), map()) :: %{
+          base: %{aggregate: map()},
+          head: %{aggregate: map()},
+          delta: %{aggregate: map()}
+        }
+  def compute(base_results, head_results) do
+    base_agg = get_in(base_results, ["codebase", "aggregate"]) || %{}
+    head_agg = get_in(head_results, ["codebase", "aggregate"]) || %{}
+
+    %{
+      base: %{aggregate: base_agg},
+      head: %{aggregate: head_agg},
+      delta: %{aggregate: compute_aggregate_delta(base_agg, head_agg)}
+    }
+  end
+
+  defp compute_aggregate_delta(base_agg, head_agg) do
+    MapSet.new(Map.keys(base_agg) ++ Map.keys(head_agg))
+    |> Enum.reduce(%{}, fn metric_name, acc ->
+      base_m = Map.get(base_agg, metric_name, %{})
+      head_m = Map.get(head_agg, metric_name, %{})
+      delta = compute_numeric_delta(base_m, head_m)
+      if delta == %{}, do: acc, else: Map.put(acc, metric_name, delta)
+    end)
+  end
+
+  defp compute_numeric_delta(base, head) do
+    MapSet.new(Map.keys(base) ++ Map.keys(head))
+    |> Enum.reduce(%{}, fn key, acc ->
+      case {Map.get(base, key), Map.get(head, key)} do
+        {b, h} when is_number(b) and is_number(h) ->
+          Map.put(acc, key, Float.round(h - b, 4))
+
+        _ ->
+          acc
+      end
+    end)
+  end
+end
diff --git a/test/codeqa/health_report/delta_test.exs b/test/codeqa/health_report/delta_test.exs
new file mode 100644
index 0000000..f13a74d
--- /dev/null
+++ b/test/codeqa/health_report/delta_test.exs
@@ -0,0 +1,53 @@
+defmodule CodeQA.HealthReport.DeltaTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.HealthReport.Delta
+
+  defp make_results(aggregate) do
+    %{"codebase" => %{"aggregate" => aggregate}}
+  end
+
+  test "returns base, head, and delta aggregates" do
+    base = make_results(%{"entropy" => %{"mean_value" => 5.0}})
+    head = make_results(%{"entropy" => %{"mean_value" => 6.0}})
+
+    result = Delta.compute(base, head)
+
+    assert result.base.aggregate == %{"entropy" => %{"mean_value" => 5.0}}
+    assert result.head.aggregate == %{"entropy" => %{"mean_value" => 6.0}}
+    assert result.delta.aggregate == %{"entropy" => %{"mean_value" => 1.0}}
+  end
+
+  test "rounds delta to 4 decimal places" do
+    base = make_results(%{"entropy" => %{"mean_value" => 1.0}})
+    head = make_results(%{"entropy" => %{"mean_value" => 4.3333}})
+
+    result = Delta.compute(base, head)
+    assert result.delta.aggregate["entropy"]["mean_value"] == 3.3333
+  end
+
+  test "handles missing base codebase gracefully" do
+    base = %{}
+    head = make_results(%{"entropy" => %{"mean_value" => 6.0}})
+
+    result = Delta.compute(base, head)
+    assert result.delta.aggregate == %{}
+  end
+
+  test "handles missing head codebase gracefully" do
+    base = make_results(%{"entropy" => %{"mean_value" => 5.0}})
+    head = %{}
+
+    result = Delta.compute(base, head)
+    assert result.delta.aggregate == %{}
+  end
+
+  test "skips non-numeric metric keys" do
+    base = make_results(%{"entropy" => %{"mean_value" => 5.0, "label" => "x"}})
+    head = make_results(%{"entropy" => %{"mean_value" => 6.0, "label" => "y"}})
+
+    result = Delta.compute(base, head)
+    refute Map.has_key?(result.delta.aggregate["entropy"], "label")
+    assert result.delta.aggregate["entropy"]["mean_value"] == 1.0
+  end
+end

From fa96b53e46d0d99dab39392a5f5b4fc5d5cfe3c6 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 12:54:46 +0100
Subject: [PATCH 32/71] fix(health-report/delta): coerce Float.round operand;
 document asymmetric key behaviour

---
 lib/codeqa/health_report/delta.ex        | 2 +-
 test/codeqa/health_report/delta_test.exs | 8 ++++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/lib/codeqa/health_report/delta.ex b/lib/codeqa/health_report/delta.ex
index fc014db..52b0085 100644
--- a/lib/codeqa/health_report/delta.ex
+++ b/lib/codeqa/health_report/delta.ex
@@ -32,7 +32,7 @@ defmodule CodeQA.HealthReport.Delta do
     |> Enum.reduce(%{}, fn key, acc ->
       case {Map.get(base, key), Map.get(head, key)} do
         {b, h} when is_number(b) and is_number(h) ->
-          Map.put(acc, key, Float.round(h - b, 4))
+          Map.put(acc, key, Float.round((h - b) * 1.0, 4))
 
         _ ->
           acc
diff --git a/test/codeqa/health_report/delta_test.exs b/test/codeqa/health_report/delta_test.exs
index f13a74d..6932e0c 100644
--- a/test/codeqa/health_report/delta_test.exs
+++ b/test/codeqa/health_report/delta_test.exs
@@ -50,4 +50,12 @@ defmodule CodeQA.HealthReport.DeltaTest do
     refute Map.has_key?(result.delta.aggregate["entropy"], "label")
     assert result.delta.aggregate["entropy"]["mean_value"] == 1.0
   end
+
+  test "metric key present only in head produces no delta entry" do
+    base = make_results(%{"entropy" => %{"mean_value" => 5.0}})
+    head = make_results(%{"entropy" => %{"mean_value" => 6.0, "new_metric" => 3.0}})
+
+    result = Delta.compute(base, head)
+    refute Map.has_key?(result.delta.aggregate["entropy"], "new_metric")
+  end
 end

From 321143990cbd78fba791dcd8d71b33c2c6ba2f43 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 12:57:18 +0100
Subject: [PATCH 33/71] feat(health-report): add TopBlocks module for
 severity-classified block assembly

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/health_report/top_blocks.ex        | 113 +++++++++++++
 test/codeqa/health_report/top_blocks_test.exs | 151 ++++++++++++++++++
 2 files changed, 264 insertions(+)
 create mode 100644 lib/codeqa/health_report/top_blocks.ex
 create mode 100644 test/codeqa/health_report/top_blocks_test.exs

diff --git a/lib/codeqa/health_report/top_blocks.ex b/lib/codeqa/health_report/top_blocks.ex
new file mode 100644
index 0000000..cc38299
--- /dev/null
+++ b/lib/codeqa/health_report/top_blocks.ex
@@ -0,0 +1,113 @@
+defmodule CodeQA.HealthReport.TopBlocks do
+  @moduledoc "Assembles the top_blocks report section from analysis node data."
+
+  alias CodeQA.CombinedMetrics.Scorer
+
+  @min_tokens 10
+  @severity_critical 0.50
+  @severity_high 0.25
+  @severity_medium 0.10
+  @gap_floor 0.01
+
+  @spec build(map(), [struct()], map()) :: [map()]
+  def build(analysis_results, changed_files, codebase_cosine_lookup) do
+    files = Map.get(analysis_results, "files", %{})
+    fix_hints = build_fix_hint_lookup()
+
+    file_entries =
+      if changed_files == [] do
+        Enum.map(files, fn {path, data} -> {path, nil, data} end)
+      else
+        changed_index = Map.new(changed_files, &{&1.path, &1.status})
+
+        files
+        |> Enum.filter(fn {path, _} -> Map.has_key?(changed_index, path) end)
+        |> Enum.map(fn {path, data} -> {path, Map.get(changed_index, path), data} end)
+      end
+
+    file_entries
+    |> Enum.map(fn {path, status, file_data} ->
+      blocks =
+        file_data
+        |> Map.get("nodes", [])
+        |> Enum.flat_map(&collect_nodes/1)
+        |> Enum.filter(&(&1["token_count"] >= @min_tokens))
+        |> Enum.map(&enrich_block(&1, codebase_cosine_lookup, fix_hints))
+        |> Enum.reject(&(&1.potentials == []))
+        |> Enum.sort_by(&(-max_delta(&1)))
+
+      %{path: path, status: status, blocks: blocks}
+    end)
+    |> Enum.reject(&(&1.blocks == []))
+    |> Enum.sort_by(& &1.path)
+  end
+
+  defp collect_nodes(node) do
+    children = node |> Map.get("children", []) |> Enum.flat_map(&collect_nodes/1)
+    [node | children]
+  end
+
+  defp enrich_block(node, cosine_lookup, fix_hints) do
+    potentials =
+      node
+      |> Map.get("refactoring_potentials", [])
+      |> Enum.map(&enrich_potential(&1, cosine_lookup, fix_hints))
+      |> Enum.reject(&is_nil/1)
+      |> Enum.sort_by(& &1.cosine_delta, :desc)
+
+    %{
+      start_line: node["start_line"],
+      end_line: node["end_line"],
+      type: node["type"],
+      token_count: node["token_count"],
+      potentials: potentials
+    }
+  end
+
+  defp enrich_potential(p, cosine_lookup, fix_hints) do
+    category = p["category"]
+    behavior = p["behavior"]
+    cosine_delta = p["cosine_delta"]
+
+    codebase_cosine = Map.get(cosine_lookup, {category, behavior}, 0.0)
+    gap = max(@gap_floor, 1.0 - codebase_cosine)
+    severity = classify(cosine_delta / gap)
+
+    if severity == :filtered do
+      nil
+    else
+      %{
+        category: category,
+        behavior: behavior,
+        cosine_delta: cosine_delta,
+        severity: severity,
+        fix_hint: Map.get(fix_hints, {category, behavior})
+      }
+    end
+  end
+
+  defp classify(ratio) when ratio > @severity_critical, do: :critical
+  defp classify(ratio) when ratio > @severity_high, do: :high
+  defp classify(ratio) when ratio > @severity_medium, do: :medium
+  defp classify(_ratio), do: :filtered
+
+  defp max_delta(%{potentials: []}), do: 0.0
+
+  defp max_delta(%{potentials: potentials}),
+    do: Enum.max_by(potentials, & &1.cosine_delta).cosine_delta
+
+  defp build_fix_hint_lookup do
+    Scorer.all_yamls()
+    |> Enum.flat_map(fn {yaml_path, data} ->
+      category = yaml_path |> Path.basename() |> String.trim_trailing(".yml")
+
+      Enum.flat_map(data, fn {behavior, behavior_data} ->
+        case get_in(behavior_data, ["_fix_hint"]) do
+          nil -> []
+          hint -> [{{category, behavior}, hint}]
+        end
+      end)
+    end)
+    |> Map.new()
+  end
+end
diff --git a/test/codeqa/health_report/top_blocks_test.exs b/test/codeqa/health_report/top_blocks_test.exs
new file mode 100644
index 0000000..c5f1bdb
--- /dev/null
+++ b/test/codeqa/health_report/top_blocks_test.exs
@@ -0,0 +1,151 @@
+defmodule CodeQA.HealthReport.TopBlocksTest do
+  use ExUnit.Case, async: true
+
+  alias CodeQA.HealthReport.TopBlocks
+  alias CodeQA.Git.ChangedFile
+
+  # A node with cosine_delta 0.60 — will be :critical when codebase_cosine = 0.0 (gap=1.0, ratio=0.60)
+  defp make_node(cosine_delta, token_count \\ 20) do
+    %{
+      "start_line" => 1,
+      "end_line" => 10,
+      "type" => "code",
+      "token_count" => token_count,
+      "refactoring_potentials" => [
+        %{
+          "category" => "function_design",
+          "behavior" => "cyclomatic_complexity_under_10",
+          "cosine_delta" => cosine_delta
+        }
+      ],
+      "children" => []
+    }
+  end
+
+  defp make_results(nodes) do
+    %{"files" => %{"lib/foo.ex" => %{"nodes" => nodes}}}
+  end
+
+  defp lookup(cosine \\ 0.0) do
+    %{{"function_design", "cyclomatic_complexity_under_10"} => cosine}
+  end
+
+  describe "severity classification" do
+    test ":critical when severity_ratio > 0.50" do
+      # gap = max(0.01, 1.0 - 0.0) = 1.0, ratio = 0.60 / 1.0 = 0.60 > 0.50
+      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup())
+      assert hd(hd(group.blocks).potentials).severity == :critical
+    end
+
+    test ":high when severity_ratio > 0.25 and <= 0.50" do
+      # ratio = 0.30 / 1.0 = 0.30
+      [group] = TopBlocks.build(make_results([make_node(0.30)]), [], lookup())
+      assert hd(hd(group.blocks).potentials).severity == :high
+    end
+
+    test ":medium when severity_ratio > 0.10 and <= 0.25" do
+      # ratio = 0.15 / 1.0 = 0.15
+      [group] = TopBlocks.build(make_results([make_node(0.15)]), [], lookup())
+      assert hd(hd(group.blocks).potentials).severity == :medium
+    end
+
+    test "filtered when severity_ratio <= 0.10" do
+      # ratio = 0.05 / 1.0 = 0.05 — block should not appear
+      assert TopBlocks.build(make_results([make_node(0.05)]), [], lookup()) == []
+    end
+
+    test "gap floor prevents division by zero when codebase_cosine = 1.0" do
+      # gap = max(0.01, 1.0 - 1.0) = 0.01, ratio = 0.02 / 0.01 = 2.0 → :critical
+      [group] = TopBlocks.build(make_results([make_node(0.02)]), [], lookup(1.0))
+      assert hd(hd(group.blocks).potentials).severity == :critical
+    end
+
+    test "gap handles negative codebase_cosine" do
+      # codebase_cosine = -0.5, gap = max(0.01, 1.0 - (-0.5)) = 1.5
+      # ratio = 0.60 / 1.5 = 0.40 → :high
+      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup(-0.5))
+      assert hd(hd(group.blocks).potentials).severity == :high
+    end
+
+    test "unknown behavior defaults codebase_cosine to 0.0" do
+      lookup_empty = %{}
+      # gap = 1.0, ratio = 0.60 → :critical
+      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup_empty)
+      assert hd(hd(group.blocks).potentials).severity == :critical
+    end
+  end
+
+  describe "changed_files filtering" do
+    test "when changed_files is empty, shows all files" do
+      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup())
+      assert group.path == "lib/foo.ex"
+      assert group.status == nil
+    end
+
+    test "when changed_files given, only shows matching files" do
+      changed = [%ChangedFile{path: "lib/other.ex", status: "added"}]
+      assert TopBlocks.build(make_results([make_node(0.60)]), changed, lookup()) == []
+    end
+
+    test "status comes from ChangedFile struct" do
+      changed = [%ChangedFile{path: "lib/foo.ex", status: "modified"}]
+      [group] = TopBlocks.build(make_results([make_node(0.60)]), changed, lookup())
+      assert group.status == "modified"
+    end
+  end
+
+  describe "block filtering" do
+    test "blocks with token_count < 10 are excluded" do
+      assert TopBlocks.build(make_results([make_node(0.60, 9)]), [], lookup()) == []
+    end
+
+    test "blocks are ordered by highest cosine_delta descending" do
+      node_low = make_node(0.20)
+      node_high = put_in(make_node(0.60), ["start_line"], 20)
+      results = %{"files" => %{"lib/foo.ex" => %{"nodes" => [node_low, node_high]}}}
+
+      [group] = TopBlocks.build(results, [], lookup())
+      deltas = Enum.map(group.blocks, fn b -> hd(b.potentials).cosine_delta end)
+      assert deltas == Enum.sort(deltas, :desc)
+    end
+
+    test "children nodes are included" do
+      parent = %{
+        "start_line" => 1,
+        "end_line" => 20,
+        "type" => "code",
+        "token_count" => 5,
+        "refactoring_potentials" => [],
+        "children" => [make_node(0.60)]
+      }
+
+      [group] = TopBlocks.build(make_results([parent]), [], lookup())
+      assert length(group.blocks) == 1
+    end
+  end
+
+  describe "fix hints" do
+    test "includes fix_hint string for known behavior" do
+      # function_design/cyclomatic_complexity_under_10 has _fix_hint in YAML
+      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup())
+      potential = hd(hd(group.blocks).potentials)
+      assert is_binary(potential.fix_hint)
+    end
+
+    test "fix_hint is nil for unknown behavior" do
+      node = %{
+        "start_line" => 1,
+        "end_line" => 10,
+        "type" => "code",
+        "token_count" => 20,
+        "refactoring_potentials" => [
+          %{"category" => "unknown_cat", "behavior" => "unknown_beh", "cosine_delta" => 0.60}
+        ],
+        "children" => []
+      }
+
+      [group] = TopBlocks.build(make_results([node]), [], %{})
+      assert hd(hd(group.blocks).potentials).fix_hint == nil
+    end
+  end
+end

From 10dba0908731976cc4e0f2c372c22b6269704ea6 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 13:01:29 +0100
Subject: [PATCH 34/71] fix(top-blocks): guard non-map YAML entries in
 build_fix_hint_lookup

---
 lib/codeqa/health_report/top_blocks.ex | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/lib/codeqa/health_report/top_blocks.ex b/lib/codeqa/health_report/top_blocks.ex
index cc38299..dda0bb8 100644
--- a/lib/codeqa/health_report/top_blocks.ex
+++ b/lib/codeqa/health_report/top_blocks.ex
@@ -101,11 +101,15 @@ defmodule CodeQA.HealthReport.TopBlocks do
     |> Enum.flat_map(fn {yaml_path, data} ->
       category = yaml_path |> Path.basename() |> String.trim_trailing(".yml")
 
-      Enum.flat_map(data, fn {behavior, behavior_data} ->
-        case get_in(behavior_data, ["_fix_hint"]) do
-          nil -> []
-          hint -> [{{category, behavior}, hint}]
-        end
+      Enum.flat_map(data, fn
+        {behavior, behavior_data} when is_map(behavior_data) ->
+          case Map.get(behavior_data, "_fix_hint") do
+            nil -> []
+            hint -> [{{category, behavior}, hint}]
+          end
+
+        _ ->
+          []
       end)
     end)
     |> Map.new()

From 7d47f69fbdecaf6be18f0763dd94b233f00df773 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 13:05:33 +0100
Subject: [PATCH 35/71] feat(health-report): add top_blocks, pr_summary,
 codebase_delta; drop worst_offenders

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/health_report.ex        | 121 ++++++++++++++++++++++++----
 test/codeqa/health_report_test.exs | 124 +++++++++++++++++++++++++++++
 2 files changed, 229 insertions(+), 16 deletions(-)
 create mode 100644 test/codeqa/health_report_test.exs

diff --git a/lib/codeqa/health_report.ex b/lib/codeqa/health_report.ex
index 6b5c4d6..6ba09ac 100644
--- a/lib/codeqa/health_report.ex
+++ b/lib/codeqa/health_report.ex
@@ -1,14 +1,15 @@
 defmodule CodeQA.HealthReport do
   @moduledoc "Orchestrates health report generation from analysis results."
 
-  alias CodeQA.HealthReport.{Config, Grader, Formatter}
+  alias CodeQA.HealthReport.{Config, Grader, Formatter, Delta, TopBlocks}
   alias CodeQA.CombinedMetrics.{FileScorer, SampleRunner}
 
   @spec generate(map(), keyword()) :: map()
   def generate(analysis_results, opts \\ []) do
     config_path = Keyword.get(opts, :config)
-    detail = Keyword.get(opts, :detail, :default)
-    top_n = Keyword.get(opts, :top, 5)
+    _detail = Keyword.get(opts, :detail, :default)
+    base_results = Keyword.get(opts, :base_results)
+    changed_files = Keyword.get(opts, :changed_files, [])
 
     %{
       categories: categories,
@@ -26,20 +27,12 @@ defmodule CodeQA.HealthReport do
       categories
       |> Grader.grade_aggregate(aggregate, grade_scale)
       |> Enum.zip(categories)
-      |> Enum.map(fn {graded, cat_def} ->
+      |> Enum.map(fn {graded, _cat_def} ->
         summary = build_category_summary(graded)
-        cat_top = Map.get(cat_def, :top, top_n)
-
-        worst =
-          case detail do
-            :summary -> []
-            :full -> Grader.worst_offenders(cat_def, files, map_size(files), grade_scale)
-            _default -> Grader.worst_offenders(cat_def, files, cat_top, grade_scale)
-          end
 
         graded
         |> Map.put(:type, :threshold)
-        |> Map.merge(%{summary: summary, worst_offenders: worst})
+        |> Map.merge(%{summary: summary, worst_offenders: []})
       end)
 
     worst_files_map = FileScorer.worst_files_per_behavior(files, combined_top: combined_top)
@@ -47,7 +40,6 @@ defmodule CodeQA.HealthReport do
     cosine_grades =
       Grader.grade_cosine_categories(aggregate, worst_files_map, grade_scale, project_langs)
 
-    # TODO(option-c): a unified flat issues list would replace the current per-category worst offenders loop; all category results would be flattened, deduplicated by file+line, and re-ranked by a cross-category severity score before rendering.
     all_categories =
       (threshold_grades ++ cosine_grades)
       |> Enum.map(fn cat ->
@@ -58,14 +50,44 @@ defmodule CodeQA.HealthReport do
 
     metadata = build_metadata(analysis_results)
 
-    top_issues = SampleRunner.diagnose_aggregate(aggregate, top: 10, languages: project_langs)
+    all_cosines =
+      SampleRunner.diagnose_aggregate(aggregate, top: 99_999, languages: project_langs)
+
+    top_issues = Enum.take(all_cosines, 10)
+
+    codebase_cosine_lookup =
+      Map.new(all_cosines, fn i -> {{i.category, i.behavior}, i.cosine} end)
+
+    top_blocks = TopBlocks.build(analysis_results, changed_files, codebase_cosine_lookup)
+
+    {codebase_delta, pr_summary} =
+      if base_results do
+        build_delta_and_summary(
+          base_results,
+          analysis_results,
+          overall_score,
+          overall_grade,
+          all_categories,
+          categories,
+          grade_scale,
+          impact_map,
+          combined_top,
+          changed_files,
+          top_blocks
+        )
+      else
+        {nil, nil}
+      end
 
     %{
       metadata: metadata,
+      pr_summary: pr_summary,
       overall_score: overall_score,
       overall_grade: overall_grade,
+      codebase_delta: codebase_delta,
       categories: all_categories,
-      top_issues: top_issues
+      top_issues: top_issues,
+      top_blocks: top_blocks
     }
   end
 
@@ -74,6 +96,73 @@ defmodule CodeQA.HealthReport do
     Formatter.format_markdown(report, detail, format)
   end
 
+  defp build_delta_and_summary(
+         base_results,
+         head_results,
+         head_score,
+         head_grade,
+         _head_categories,
+         category_defs,
+         grade_scale,
+         impact_map,
+         combined_top,
+         changed_files,
+         top_blocks
+       ) do
+    delta = Delta.compute(base_results, head_results)
+
+    base_aggregate = get_in(base_results, ["codebase", "aggregate"]) || %{}
+    base_files = Map.get(base_results, "files", %{})
+    base_project_langs = project_languages(base_files)
+
+    base_threshold_grades =
+      category_defs
+      |> Grader.grade_aggregate(base_aggregate, grade_scale)
+      |> Enum.zip(category_defs)
+      |> Enum.map(fn {graded, _cat_def} ->
+        graded
+        |> Map.put(:type, :threshold)
+        |> Map.merge(%{summary: "", worst_offenders: []})
+      end)
+
+    base_worst_files_map =
+      FileScorer.worst_files_per_behavior(base_files, combined_top: combined_top)
+
+    base_cosine_grades =
+      Grader.grade_cosine_categories(
+        base_aggregate,
+        base_worst_files_map,
+        grade_scale,
+        base_project_langs
+      )
+
+    base_all_categories =
+      (base_threshold_grades ++ base_cosine_grades)
+      |> Enum.map(fn cat ->
+        Map.put(cat, :impact, Map.get(impact_map, to_string(cat.key), 1))
+      end)
+
+    {base_score, base_grade} = Grader.overall_score(base_all_categories, grade_scale, impact_map)
+
+    blocks_flagged = Enum.sum(Enum.map(top_blocks, fn g -> length(g.blocks) end))
+    files_added = Enum.count(changed_files, &(&1.status == "added"))
+    files_modified = Enum.count(changed_files, &(&1.status == "modified"))
+
+    summary = %{
+      base_score: base_score,
+      head_score: head_score,
+      score_delta: head_score - base_score,
+      base_grade: base_grade,
+      head_grade: head_grade,
+      blocks_flagged: blocks_flagged,
+      files_changed: length(changed_files),
+      files_added: files_added,
+      files_modified: files_modified
+    }
+
+    {delta, summary}
+  end
+
   defp build_metadata(analysis_results) do
     meta = Map.get(analysis_results, "metadata", %{})
 
diff --git a/test/codeqa/health_report_test.exs b/test/codeqa/health_report_test.exs
new file mode 100644
index 0000000..5455a73
--- /dev/null
+++ b/test/codeqa/health_report_test.exs
@@ -0,0 +1,124 @@
+defmodule CodeQA.HealthReportTest do
+  use ExUnit.Case, async: true
+
+  describe "generate/2 output keys" do
+    @tag :slow
+    test "without base_results: pr_summary and codebase_delta are nil" do
+      files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
+      results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      results = CodeQA.BlockImpactAnalyzer.analyze(results, files)
+
+      report = CodeQA.HealthReport.generate(results)
+
+      assert report.pr_summary == nil
+      assert report.codebase_delta == nil
+      assert is_list(report.top_blocks)
+      assert Map.has_key?(report, :overall_score)
+      assert Map.has_key?(report, :overall_grade)
+      assert Map.has_key?(report, :categories)
+      assert Map.has_key?(report, :top_issues)
+    end
+
+    @tag :slow
+    test "without base_results: top_blocks shows all files with significant blocks" do
+      files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
+      results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      results = CodeQA.BlockImpactAnalyzer.analyze(results, files)
+
+      report = CodeQA.HealthReport.generate(results)
+
+      # top_blocks is a list of file groups (may be empty if no blocks above threshold)
+      assert is_list(report.top_blocks)
+
+      Enum.each(report.top_blocks, fn group ->
+        assert Map.has_key?(group, :path)
+        assert Map.has_key?(group, :status)
+        assert Map.has_key?(group, :blocks)
+        assert group.status == nil
+      end)
+    end
+
+    test "worst_offenders is always empty in categories" do
+      files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
+      results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      results = CodeQA.BlockImpactAnalyzer.analyze(results, files)
+
+      report = CodeQA.HealthReport.generate(results)
+
+      Enum.each(report.categories, fn cat ->
+        assert Map.get(cat, :worst_offenders, []) == []
+      end)
+    end
+  end
+
+  describe "generate/2 with base_results" do
+    @tag :slow
+    test "pr_summary is populated" do
+      files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
+      head_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      head_results = CodeQA.BlockImpactAnalyzer.analyze(head_results, files)
+      base_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+
+      changed = [%CodeQA.Git.ChangedFile{path: "lib/foo.ex", status: "modified"}]
+
+      report =
+        CodeQA.HealthReport.generate(head_results,
+          base_results: base_results,
+          changed_files: changed
+        )
+
+      assert %{
+               base_score: base_score,
+               head_score: head_score,
+               score_delta: delta,
+               base_grade: _,
+               head_grade: _,
+               blocks_flagged: flagged,
+               files_changed: 1,
+               files_added: 0,
+               files_modified: 1
+             } = report.pr_summary
+
+      assert is_integer(base_score)
+      assert is_integer(head_score)
+      assert delta == head_score - base_score
+      assert is_integer(flagged)
+    end
+
+    @tag :slow
+    test "codebase_delta is populated" do
+      files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
+      head_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      head_results = CodeQA.BlockImpactAnalyzer.analyze(head_results, files)
+      base_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+
+      report = CodeQA.HealthReport.generate(head_results, base_results: base_results)
+
+      assert %{base: %{aggregate: _}, head: %{aggregate: _}, delta: %{aggregate: _}} =
+               report.codebase_delta
+    end
+
+    @tag :slow
+    test "top_blocks scoped to changed_files" do
+      files = %{
+        "lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n",
+        "lib/bar.ex" => "defmodule Bar do\n  def baz, do: :ok\nend\n"
+      }
+
+      head_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      head_results = CodeQA.BlockImpactAnalyzer.analyze(head_results, files)
+      base_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+
+      changed = [%CodeQA.Git.ChangedFile{path: "lib/foo.ex", status: "modified"}]
+
+      report =
+        CodeQA.HealthReport.generate(head_results,
+          base_results: base_results,
+          changed_files: changed
+        )
+
+      paths = Enum.map(report.top_blocks, & &1.path)
+      refute "lib/bar.ex" in paths
+    end
+  end
+end

From d563d6236e65bafb006bf7c2581a56515354bc1b Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 13:08:11 +0100
Subject: [PATCH 36/71] fix(health-report): remove dead _detail binding; tag
 slow test

---
 lib/codeqa/health_report.ex        | 1 -
 test/codeqa/health_report_test.exs | 1 +
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/codeqa/health_report.ex b/lib/codeqa/health_report.ex
index 6ba09ac..1e8be12 100644
--- a/lib/codeqa/health_report.ex
+++ b/lib/codeqa/health_report.ex
@@ -7,7 +7,6 @@ defmodule CodeQA.HealthReport do
   @spec generate(map(), keyword()) :: map()
   def generate(analysis_results, opts \\ []) do
     config_path = Keyword.get(opts, :config)
-    _detail = Keyword.get(opts, :detail, :default)
     base_results = Keyword.get(opts, :base_results)
     changed_files = Keyword.get(opts, :changed_files, [])
 
diff --git a/test/codeqa/health_report_test.exs b/test/codeqa/health_report_test.exs
index 5455a73..1eb4c64 100644
--- a/test/codeqa/health_report_test.exs
+++ b/test/codeqa/health_report_test.exs
@@ -38,6 +38,7 @@ defmodule CodeQA.HealthReportTest do
       end)
     end
 
+    @tag :slow
     test "worst_offenders is always empty in categories" do
       files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
       results = CodeQA.Engine.Analyzer.analyze_codebase(files)

From b9f1bd7d98e149e561642f2b86150b744e53a685 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 13:12:47 +0100
Subject: [PATCH 37/71] feat(formatter): add block, delta, PR summary sections;
 remove worst_offenders (plain)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/health_report/formatter/plain.ex  | 188 ++++++++++++----
 test/codeqa/health_report/formatter_test.exs | 216 ++++++++++++++++---
 2 files changed, 332 insertions(+), 72 deletions(-)

diff --git a/lib/codeqa/health_report/formatter/plain.ex b/lib/codeqa/health_report/formatter/plain.ex
index f0e0a8a..f33a139 100644
--- a/lib/codeqa/health_report/formatter/plain.ex
+++ b/lib/codeqa/health_report/formatter/plain.ex
@@ -4,10 +4,13 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
   @spec render(map(), atom()) :: String.t()
   def render(report, detail) do
     [
+      pr_summary_section(Map.get(report, :pr_summary)),
       header(report),
       cosine_legend(),
+      delta_section(Map.get(report, :codebase_delta)),
       overall_table(report),
       top_issues_section(Map.get(report, :top_issues, []), detail),
+      blocks_section(Map.get(report, :top_blocks, [])),
       category_sections(report.categories, detail)
     ]
     |> List.flatten()
@@ -116,6 +119,49 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
     end)
   end
 
+  defp worst_offenders_section(_cat, :summary), do: []
+
+  defp worst_offenders_section(cat, _detail) do
+    offenders = Map.get(cat, :worst_offenders, [])
+
+    if offenders == [] do
+      []
+    else
+      averages = Map.new(cat.metric_scores, &{&1.name, &1.value})
+
+      rows =
+        Enum.map(offenders, fn f ->
+          metric_issues =
+            Enum.map_join(f.metric_scores, "<br>", fn m ->
+              avg = Map.get(averages, m.name)
+              avg_str = if avg, do: " (avg: #{format_num(avg)})", else: ""
+              "#{direction(m.good)}#{m.name}=#{format_num(m.value)}#{avg_str}"
+            end)
+
+          where_part = format_where_part(Map.get(f, :top_nodes, []))
+          fix_hint = threshold_fix_hint(f.metric_scores)
+          fix_part = if fix_hint, do: "**Fix:** #{fix_hint}", else: nil
+
+          extra =
+            [where_part, fix_part]
+            |> Enum.reject(&is_nil/1)
+            |> Enum.map_join("", &"<br>#{&1}")
+
+          issues = metric_issues <> extra
+
+          "| #{format_path(f.path)}<br>#{format_lines(f[:lines])} lines · #{format_size(f[:bytes])} | #{f.grade} | #{issues} |"
+        end)
+
+      [
+        "### Worst Offenders",
+        "",
+        "| File | Grade | Issues |",
+        "|------|-------|--------|"
+        | rows
+      ] ++ [""]
+    end
+  end
+
   defp format_cosine_details(f, fix_hint) do
     why_part = format_why_part(Map.get(f, :top_metrics, []))
     where_part = format_where_part(Map.get(f, :top_nodes, []))
@@ -201,49 +247,6 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
     end
   end
 
-  defp worst_offenders_section(_cat, :summary), do: []
-
-  defp worst_offenders_section(cat, _detail) do
-    offenders = Map.get(cat, :worst_offenders, [])
-
-    if offenders == [] do
-      []
-    else
-      averages = Map.new(cat.metric_scores, &{&1.name, &1.value})
-
-      rows =
-        Enum.map(offenders, fn f ->
-          metric_issues =
-            Enum.map_join(f.metric_scores, "<br>", fn m ->
-              avg = Map.get(averages, m.name)
-              avg_str = if avg, do: " (avg: #{format_num(avg)})", else: ""
-              "#{direction(m.good)}#{m.name}=#{format_num(m.value)}#{avg_str}"
-            end)
-
-          where_part = format_where_part(Map.get(f, :top_nodes, []))
-          fix_hint = threshold_fix_hint(f.metric_scores)
-          fix_part = if fix_hint, do: "**Fix:** #{fix_hint}", else: nil
-
-          extra =
-            [where_part, fix_part]
-            |> Enum.reject(&is_nil/1)
-            |> Enum.map_join("", &"<br>#{&1}")
-
-          issues = metric_issues <> extra
-
-          "| #{format_path(f.path)}<br>#{format_lines(f[:lines])} lines · #{format_size(f[:bytes])} | #{f.grade} | #{issues} |"
-        end)
-
-      [
-        "### Worst Offenders",
-        "",
-        "| File | Grade | Issues |",
-        "|------|-------|--------|"
-        | rows
-      ] ++ [""]
-    end
-  end
-
   defp threshold_fix_hint(metric_scores) do
     worst = Enum.min_by(metric_scores, & &1.score, fn -> nil end)
 
@@ -308,4 +311,103 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
       | rows
     ] ++ [""]
   end
+
+  defp pr_summary_section(nil), do: []
+
+  defp pr_summary_section(summary) do
+    delta_str =
+      if summary.score_delta >= 0,
+        do: "+#{summary.score_delta}",
+        else: "#{summary.score_delta}"
+
+    status_str = "#{summary.files_modified} modified, #{summary.files_added} added"
+
+    [
+      "> **Score:** #{summary.base_grade} → #{summary.head_grade}  |  **Δ** #{delta_str} pts  |  **#{summary.blocks_flagged}** blocks flagged across #{summary.files_changed} files  |  #{status_str}",
+      ""
+    ]
+  end
+
+  defp delta_section(nil), do: []
+
+  defp delta_section(delta) do
+    base_agg = delta.base.aggregate
+    head_agg = delta.head.aggregate
+
+    metrics = [
+      {"Readability", "readability", "mean_flesch_adapted"},
+      {"Complexity", "halstead", "mean_difficulty"},
+      {"Duplication", "compression", "mean_redundancy"},
+      {"Structure", "branching", "mean_branch_count"}
+    ]
+
+    rows =
+      Enum.flat_map(metrics, fn {label, group, key} ->
+        base_val = get_in(base_agg, [group, key])
+        head_val = get_in(head_agg, [group, key])
+
+        if is_number(base_val) and is_number(head_val) do
+          diff = Float.round(head_val - base_val, 2)
+          diff_str = if diff >= 0, do: "+#{format_num(diff)}", else: "#{format_num(diff)}"
+          ["| #{label} | #{format_num(base_val)} | #{format_num(head_val)} | #{diff_str} |"]
+        else
+          []
+        end
+      end)
+
+    if rows == [] do
+      []
+    else
+      [
+        "## Metric Changes",
+        "",
+        "| Category | Base | Head | Δ |",
+        "|----------|------|------|---|"
+        | rows
+      ] ++ [""]
+    end
+  end
+
+  defp blocks_section([]), do: []
+
+  defp blocks_section(top_blocks) do
+    total = Enum.sum(Enum.map(top_blocks, fn g -> length(g.blocks) end))
+
+    file_parts =
+      Enum.flat_map(top_blocks, fn group ->
+        status_str = if group.status, do: "  [#{group.status}]", else: ""
+
+        block_lines =
+          Enum.flat_map(group.blocks, fn block ->
+            end_line = block.end_line || block.start_line
+
+            header =
+              "**lines #{block.start_line}–#{end_line}** · #{block.type} · #{block.token_count} tokens"
+
+            potential_lines =
+              Enum.flat_map(block.potentials, fn p ->
+                icon = severity_icon(p.severity)
+                delta_str = format_num(p.cosine_delta)
+                label = "#{String.upcase(to_string(p.severity))}"
+                line = "  #{icon} #{label}  #{p.category} / #{p.behavior}  (Δ #{delta_str})"
+                fix = if p.fix_hint, do: ["    → #{p.fix_hint}"], else: []
+                [line | fix]
+              end)
+
+            [header | potential_lines] ++ [""]
+          end)
+
+        ["### #{group.path}#{status_str}", "" | block_lines]
+      end)
+
+    [
+      "## Blocks  (#{total} flagged across #{length(top_blocks)} files)",
+      ""
+      | file_parts
+    ]
+  end
+
+  defp severity_icon(:critical), do: "🔴"
+  defp severity_icon(:high), do: "🟠"
+  defp severity_icon(:medium), do: "🟡"
 end
diff --git a/test/codeqa/health_report/formatter_test.exs b/test/codeqa/health_report/formatter_test.exs
index 52c6e30..d7eaf95 100644
--- a/test/codeqa/health_report/formatter_test.exs
+++ b/test/codeqa/health_report/formatter_test.exs
@@ -183,19 +183,8 @@ defmodule CodeQA.HealthReport.FormatterTest do
       assert result =~ "| Complexity | D | 35 | 5 |"
     end
 
-    test "includes worst offenders section" do
-      result = Formatter.format_markdown(@sample_report, :default, :plain)
-      assert result =~ "### Worst Offenders"
-      refute result =~ "lib/<br>`foo.ex`"
-      assert result =~ "`lib/foo.ex`"
-      assert result =~ "120 lines · 3.8 KB"
-      assert result =~ "↑ flesch_adapted=65.00 (avg: 102.50)"
-      refute result =~ "↑ flesch_adapted=65.00, "
-    end
-
     test "summary detail omits category sections" do
       result = Formatter.format_markdown(@sample_report, :summary, :plain)
-      refute result =~ "### Worst Offenders"
       refute result =~ "Codebase averages"
     end
   end
@@ -213,13 +202,6 @@ defmodule CodeQA.HealthReport.FormatterTest do
       assert result =~ "| single_responsibility | 0.45 | 78 | B+ |"
     end
 
-    test "renders cosine worst offenders per behavior" do
-      result = Formatter.format_markdown(@report_with_cosine, :default, :plain)
-      assert result =~ "### Worst Offenders: no_boolean_parameter"
-      assert result =~ "| File | Cosine | Details |"
-      assert result =~ "| `lib/foo/bar.ex` | -0.71 |"
-    end
-
     test "omits behaviors with no worst offenders" do
       result = Formatter.format_markdown(@report_with_cosine, :default, :plain)
       refute result =~ "### Worst Offenders: single_responsibility"
@@ -236,6 +218,138 @@ defmodule CodeQA.HealthReport.FormatterTest do
     end
   end
 
+  describe "plain formatter: PR summary section" do
+    @sample_report_with_pr Map.put(@sample_report, :pr_summary, %{
+                             base_score: 85,
+                             head_score: 77,
+                             score_delta: -8,
+                             base_grade: "B+",
+                             head_grade: "C+",
+                             blocks_flagged: 6,
+                             files_changed: 3,
+                             files_added: 1,
+                             files_modified: 2
+                           })
+
+    test "renders PR summary line when pr_summary present" do
+      result = Formatter.format_markdown(@sample_report_with_pr, :default, :plain)
+      assert result =~ "B+"
+      assert result =~ "C+"
+      assert result =~ "-8"
+      assert result =~ "6"
+      assert result =~ "1 added"
+      assert result =~ "2 modified"
+    end
+
+    test "omits PR summary when pr_summary is nil" do
+      result = Formatter.format_markdown(@sample_report, :default, :plain)
+      refute result =~ "Score:"
+    end
+  end
+
+  describe "plain formatter: delta section" do
+    @delta %{
+      base: %{
+        aggregate: %{
+          "readability" => %{"mean_flesch_adapted" => 65.0},
+          "halstead" => %{"mean_difficulty" => 12.0}
+        }
+      },
+      head: %{
+        aggregate: %{
+          "readability" => %{"mean_flesch_adapted" => 61.0},
+          "halstead" => %{"mean_difficulty" => 15.0}
+        }
+      }
+    }
+
+    @sample_report_with_delta Map.put(@sample_report, :codebase_delta, @delta)
+
+    test "renders metric changes table when codebase_delta present" do
+      result = Formatter.format_markdown(@sample_report_with_delta, :default, :plain)
+      assert result =~ "Metric Changes"
+      assert result =~ "Readability"
+      assert result =~ "65.00"
+      assert result =~ "61.00"
+    end
+
+    test "omits delta section when codebase_delta is nil" do
+      result = Formatter.format_markdown(@sample_report, :default, :plain)
+      refute result =~ "Metric Changes"
+    end
+  end
+
+  describe "plain formatter: block section" do
+    @block_potential %{
+      category: "function_design",
+      behavior: "cyclomatic_complexity_under_10",
+      cosine_delta: 0.41,
+      severity: :critical,
+      fix_hint: "Reduce branching"
+    }
+
+    @top_blocks [
+      %{
+        path: "lib/foo.ex",
+        status: "modified",
+        blocks: [
+          %{
+            start_line: 42,
+            end_line: 67,
+            type: "code",
+            token_count: 84,
+            potentials: [@block_potential]
+          }
+        ]
+      }
+    ]
+
+    @sample_report_with_blocks Map.put(@sample_report, :top_blocks, @top_blocks)
+
+    test "renders block section header" do
+      result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
+      assert result =~ "Blocks"
+      assert result =~ "1 flagged"
+    end
+
+    test "renders file group with status" do
+      result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
+      assert result =~ "lib/foo.ex"
+      assert result =~ "modified"
+    end
+
+    test "renders block location and type" do
+      result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
+      assert result =~ "lines 42"
+      assert result =~ "67"
+      assert result =~ "84 tokens"
+    end
+
+    test "renders severity icon and behavior" do
+      result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
+      assert result =~ "🔴"
+      assert result =~ "CRITICAL"
+      assert result =~ "cyclomatic_complexity_under_10"
+      assert result =~ "0.41"
+    end
+
+    test "renders fix hint" do
+      result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
+      assert result =~ "Reduce branching"
+    end
+
+    test "omits block section when top_blocks is empty" do
+      report = Map.put(@sample_report, :top_blocks, [])
+      result = Formatter.format_markdown(report, :default, :plain)
+      refute result =~ "## Blocks"
+    end
+
+    test "omits block section when top_blocks key absent" do
+      result = Formatter.format_markdown(@sample_report, :default, :plain)
+      refute result =~ "## Blocks"
+    end
+  end
+
   describe "plain formatter: cosine offenders with enriched data" do
     defp report_with_enriched_cosine_plain do
       %{
@@ -283,7 +397,11 @@ defmodule CodeQA.HealthReport.FormatterTest do
       }
 
       report = %{
-        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
         overall_score: 42,
         overall_grade: "D+",
         categories: [category]
@@ -321,7 +439,11 @@ defmodule CodeQA.HealthReport.FormatterTest do
       }
 
       report = %{
-        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
         overall_score: 42,
         overall_grade: "D+",
         categories: [category]
@@ -347,7 +469,11 @@ defmodule CodeQA.HealthReport.FormatterTest do
       }
 
       report = %{
-        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
         overall_score: 42,
         overall_grade: "D+",
         categories: [category]
@@ -384,7 +510,11 @@ defmodule CodeQA.HealthReport.FormatterTest do
       }
 
       report = %{
-        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
         overall_score: 42,
         overall_grade: "D+",
         categories: [category]
@@ -421,7 +551,11 @@ defmodule CodeQA.HealthReport.FormatterTest do
       }
 
       report = %{
-        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
         overall_score: 42,
         overall_grade: "D+",
         categories: [category]
@@ -472,7 +606,11 @@ defmodule CodeQA.HealthReport.FormatterTest do
       }
 
       report = %{
-        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
         overall_score: 32,
         overall_grade: "F",
         categories: [category]
@@ -500,7 +638,11 @@ defmodule CodeQA.HealthReport.FormatterTest do
       }
 
       report = %{
-        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
         overall_score: 32,
         overall_grade: "F",
         categories: [category]
@@ -542,7 +684,11 @@ defmodule CodeQA.HealthReport.FormatterTest do
       }
 
       report = %{
-        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
         overall_score: 10,
         overall_grade: "F",
         categories: [category]
@@ -861,7 +1007,11 @@ defmodule CodeQA.HealthReport.FormatterTest do
       }
 
       report = %{
-        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
         overall_score: 42,
         overall_grade: "D+",
         categories: [category]
@@ -898,7 +1048,11 @@ defmodule CodeQA.HealthReport.FormatterTest do
       }
 
       report = %{
-        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
         overall_score: 42,
         overall_grade: "D+",
         categories: [category]
@@ -1025,7 +1179,11 @@ defmodule CodeQA.HealthReport.FormatterTest do
       }
 
       report = %{
-        metadata: %{path: "/home/user/project", timestamp: "2026-03-11T00:00:00Z", total_files: 10},
+        metadata: %{
+          path: "/home/user/project",
+          timestamp: "2026-03-11T00:00:00Z",
+          total_files: 10
+        },
         overall_score: 10,
         overall_grade: "F",
         categories: [category]

From 248bd300692e7c263b95979b7abf113e31668efb Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 13:16:38 +0100
Subject: [PATCH 38/71] feat(formatter): remove worst_offenders rendering and
 tests from plain formatter

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/health_report/formatter/plain.ex  | 171 +--------
 test/codeqa/health_report/formatter_test.exs | 359 -------------------
 2 files changed, 4 insertions(+), 526 deletions(-)

diff --git a/lib/codeqa/health_report/formatter/plain.ex b/lib/codeqa/health_report/formatter/plain.ex
index f33a139..37c7dfb 100644
--- a/lib/codeqa/health_report/formatter/plain.ex
+++ b/lib/codeqa/health_report/formatter/plain.ex
@@ -58,13 +58,12 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
     end)
   end
 
-  defp render_category(%{type: :cosine} = cat, detail) do
-    cosine_section_header(cat) ++
-      cosine_behaviors_table(cat) ++ cosine_worst_offenders(cat, detail)
+  defp render_category(%{type: :cosine} = cat, _detail) do
+    cosine_section_header(cat) ++ cosine_behaviors_table(cat)
   end
 
-  defp render_category(cat, detail) do
-    section_header(cat) ++ metric_detail(cat) ++ worst_offenders_section(cat, detail)
+  defp render_category(cat, _detail) do
+    section_header(cat) ++ metric_detail(cat)
   end
 
   defp cosine_section_header(cat) do
@@ -91,133 +90,6 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
     ] ++ [""]
   end
 
-  defp cosine_worst_offenders(_cat, :summary), do: []
-
-  defp cosine_worst_offenders(cat, _detail) do
-    Enum.flat_map(cat.behaviors, fn b ->
-      offenders = Map.get(b, :worst_offenders, [])
-
-      if offenders == [] do
-        []
-      else
-        fix_hint = cosine_fix_hint(cat.key, b.behavior)
-
-        rows =
-          Enum.map(offenders, fn f ->
-            details = format_cosine_details(f, fix_hint)
-            "| #{format_path(f.file)} | #{format_num(f.cosine)} | #{details} |"
-          end)
-
-        [
-          "### Worst Offenders: #{b.behavior}",
-          "",
-          "| File | Cosine | Details |",
-          "|------|--------|---------|"
-          | rows
-        ] ++ [""]
-      end
-    end)
-  end
-
-  defp worst_offenders_section(_cat, :summary), do: []
-
-  defp worst_offenders_section(cat, _detail) do
-    offenders = Map.get(cat, :worst_offenders, [])
-
-    if offenders == [] do
-      []
-    else
-      averages = Map.new(cat.metric_scores, &{&1.name, &1.value})
-
-      rows =
-        Enum.map(offenders, fn f ->
-          metric_issues =
-            Enum.map_join(f.metric_scores, "<br>", fn m ->
-              avg = Map.get(averages, m.name)
-              avg_str = if avg, do: " (avg: #{format_num(avg)})", else: ""
-              "#{direction(m.good)}#{m.name}=#{format_num(m.value)}#{avg_str}"
-            end)
-
-          where_part = format_where_part(Map.get(f, :top_nodes, []))
-          fix_hint = threshold_fix_hint(f.metric_scores)
-          fix_part = if fix_hint, do: "**Fix:** #{fix_hint}", else: nil
-
-          extra =
-            [where_part, fix_part]
-            |> Enum.reject(&is_nil/1)
-            |> Enum.map_join("", &"<br>#{&1}")
-
-          issues = metric_issues <> extra
-
-          "| #{format_path(f.path)}<br>#{format_lines(f[:lines])} lines · #{format_size(f[:bytes])} | #{f.grade} | #{issues} |"
-        end)
-
-      [
-        "### Worst Offenders",
-        "",
-        "| File | Grade | Issues |",
-        "|------|-------|--------|"
-        | rows
-      ] ++ [""]
-    end
-  end
-
-  defp format_cosine_details(f, fix_hint) do
-    why_part = format_why_part(Map.get(f, :top_metrics, []))
-    where_part = format_where_part(Map.get(f, :top_nodes, []))
-    fix_part = if fix_hint, do: "**Fix:** #{fix_hint}", else: nil
-
-    [why_part, where_part, fix_part]
-    |> Enum.reject(&is_nil/1)
-    |> Enum.join("<br>")
-  end
-
-  defp format_why_part([]), do: nil
-
-  defp format_why_part(top_metrics) do
-    parts =
-      Enum.map(top_metrics, fn %{metric: metric, contribution: contribution} ->
-        sign = if contribution < 0, do: "↓", else: "↑"
-        abs_val = abs(contribution)
-
-        value_str =
-          if contribution < 0,
-            do: "−#{format_num(abs_val)}",
-            else: "+#{format_num(abs_val)}"
-
-        "#{sign} #{metric} (#{value_str})"
-      end)
-
-    "**Why:** #{Enum.join(parts, ", ")}"
-  end
-
-  defp format_where_part([]), do: nil
-
-  defp format_where_part(top_nodes) do
-    parts =
-      Enum.map(top_nodes, fn node ->
-        line = node["start_line"] || "?"
-        type = node["type"] || "unknown"
-        "line #{line} (#{type})"
-      end)
-
-    "**Where:** #{Enum.join(parts, ", ")}"
-  end
-
-  defp cosine_fix_hint(category_key, behavior) do
-    yaml_path = "priv/combined_metrics/#{category_key}.yml"
-
-    case YamlElixir.read_from_file(yaml_path) do
-      {:ok, data} ->
-        get_in(data, [behavior, "_fix_hint"])
-
-      {:error, reason} ->
-        require Logger
-        Logger.debug("cosine_fix_hint: could not read #{yaml_path}: #{inspect(reason)}")
-        nil
-    end
-  end
-
   defp section_header(cat) do
     metric_summary =
       Enum.map_join(cat.metric_scores, ", ", fn m -> "#{m.name}=#{format_num(m.value)}" end)
@@ -247,41 +119,6 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
     end
   end
 
-  defp threshold_fix_hint(metric_scores) do
-    worst = Enum.min_by(metric_scores, & &1.score, fn -> nil end)
-
-    if worst do
-      categories = CodeQA.HealthReport.Categories.defaults()
-      all_metrics = Enum.flat_map(categories, & &1.metrics)
-
-      found =
-        Enum.find(all_metrics, fn m ->
-          m.name == worst.name and m.source == worst.source
-        end)
-
-      if found, do: Map.get(found, :fix_hint), else: nil
-    end
-  end
-
-  defp format_path(path) when byte_size(path) < 80, do: "`#{path}`"
-
-  defp format_path(path) do
-    case String.split(path, "/") do
-      [file] -> "`#{file}`"
-      parts -> Enum.join(Enum.drop(parts, -1), "/") <> "/<br>`#{List.last(parts)}`"
-    end
-  end
-
-  defp direction(:high), do: "↑ "
-  defp direction(_), do: "↓ "
-
-  defp format_lines(nil), do: "—"
-  defp format_lines(n), do: to_string(n)
-
-  defp format_size(nil), do: "—"
-  defp format_size(bytes) when bytes < 1024, do: "#{bytes} B"
-  defp format_size(bytes), do: "#{Float.round(bytes / 1024, 1)} KB"
-
   defp format_num(value) when is_float(value), do: :erlang.float_to_binary(value, decimals: 2)
   defp format_num(value) when is_integer(value), do: to_string(value)
   defp format_num(value), do: to_string(value)
diff --git a/test/codeqa/health_report/formatter_test.exs b/test/codeqa/health_report/formatter_test.exs
index d7eaf95..c3166b9 100644
--- a/test/codeqa/health_report/formatter_test.exs
+++ b/test/codeqa/health_report/formatter_test.exs
@@ -202,20 +202,10 @@ defmodule CodeQA.HealthReport.FormatterTest do
       assert result =~ "| single_responsibility | 0.45 | 78 | B+ |"
     end
 
-    test "omits behaviors with no worst offenders" do
-      result = Formatter.format_markdown(@report_with_cosine, :default, :plain)
-      refute result =~ "### Worst Offenders: single_responsibility"
-    end
-
     test "cosine category impact shown in overall table" do
       result = Formatter.format_markdown(@report_with_cosine, :default, :plain)
       assert result =~ "| Function Design | C | 64 | 1 |"
     end
-
-    test "summary detail omits cosine worst offenders" do
-      result = Formatter.format_markdown(@report_with_cosine, :summary, :plain)
-      refute result =~ "### Worst Offenders: no_boolean_parameter"
-    end
   end
 
   describe "plain formatter: PR summary section" do
@@ -350,355 +340,6 @@ defmodule CodeQA.HealthReport.FormatterTest do
     end
   end
 
-  describe "plain formatter: cosine offenders with enriched data" do
-    defp report_with_enriched_cosine_plain do
-      %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 64,
-        overall_grade: "C",
-        categories: [@enriched_cosine_category]
-      }
-    end
-
-    test "cosine offenders table has 3 columns (File | Cosine | Details)" do
-      result = Formatter.format_markdown(report_with_enriched_cosine_plain(), :default, :plain)
-      assert result =~ "| File | Cosine | Details |"
-      assert result =~ "|------|--------|---------|"
-    end
-
-    test "Details cell contains Why with direction indicators" do
-      result = Formatter.format_markdown(report_with_enriched_cosine_plain(), :default, :plain)
-      assert result =~ "**Why:** ↓ branching.mean_depth (−4.10), ↓ halstead.effort (−3.22)"
-    end
-
-    test "Details cell omits Why when top_metrics empty" do
-      category = %{
-        @enriched_cosine_category
-        | behaviors: [
-            %{
-              behavior: "no_boolean_parameter",
-              cosine: -0.5,
-              score: 42,
-              grade: "D+",
-              worst_offenders: [
-                %{
-                  file: "lib/foo.ex",
-                  cosine: -0.5,
-                  top_metrics: [],
-                  top_nodes: [%{"start_line" => 10, "type" => "block"}]
-                }
-              ]
-            }
-          ]
-      }
-
-      report = %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 42,
-        overall_grade: "D+",
-        categories: [category]
-      }
-
-      result = Formatter.format_markdown(report, :default, :plain)
-      refute result =~ "**Why:**"
-      assert result =~ "**Where:**"
-    end
-
-    test "Details cell contains Where" do
-      result = Formatter.format_markdown(report_with_enriched_cosine_plain(), :default, :plain)
-      assert result =~ "**Where:** line 89 (block), line 134 (block)"
-    end
-
-    test "Details cell omits Where when top_nodes empty" do
-      category = %{
-        @enriched_cosine_category
-        | behaviors: [
-            %{
-              behavior: "no_boolean_parameter",
-              cosine: -0.5,
-              score: 42,
-              grade: "D+",
-              worst_offenders: [
-                %{
-                  file: "lib/foo.ex",
-                  cosine: -0.5,
-                  top_metrics: [%{metric: "branching.mean_depth", contribution: -4.10}],
-                  top_nodes: []
-                }
-              ]
-            }
-          ]
-      }
-
-      report = %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 42,
-        overall_grade: "D+",
-        categories: [category]
-      }
-
-      result = Formatter.format_markdown(report, :default, :plain)
-      refute result =~ "**Where:**"
-      assert result =~ "**Why:**"
-    end
-
-    test "Details cell omits Where when top_nodes key absent" do
-      category = %{
-        @enriched_cosine_category
-        | behaviors: [
-            %{
-              behavior: "no_boolean_parameter",
-              cosine: -0.5,
-              score: 42,
-              grade: "D+",
-              worst_offenders: [%{file: "lib/foo.ex", cosine: -0.5}]
-            }
-          ]
-      }
-
-      report = %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 42,
-        overall_grade: "D+",
-        categories: [category]
-      }
-
-      result = Formatter.format_markdown(report, :default, :plain)
-      refute result =~ "**Where:**"
-    end
-
-    test "Fix in Details when hint present" do
-      category = %{
-        type: :cosine,
-        key: "variable_naming",
-        name: "Variable Naming",
-        score: 50,
-        grade: "C",
-        impact: 1,
-        behaviors: [
-          %{
-            behavior: "name_is_generic",
-            cosine: -0.5,
-            score: 42,
-            grade: "D+",
-            worst_offenders: [
-              %{
-                file: "lib/foo.ex",
-                cosine: -0.5,
-                top_metrics: [%{metric: "some.metric", contribution: -1.0}],
-                top_nodes: []
-              }
-            ]
-          }
-        ]
-      }
-
-      report = %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 42,
-        overall_grade: "D+",
-        categories: [category]
-      }
-
-      result = Formatter.format_markdown(report, :default, :plain)
-      assert result =~ "**Fix:**"
-    end
-
-    test "Fix omitted when hint absent" do
-      category = %{
-        type: :cosine,
-        key: "nonexistent",
-        name: "Nonexistent",
-        score: 50,
-        grade: "C",
-        impact: 1,
-        behaviors: [
-          %{
-            behavior: "nonexistent_behavior",
-            cosine: -0.5,
-            score: 42,
-            grade: "D+",
-            worst_offenders: [
-              %{
-                file: "lib/foo.ex",
-                cosine: -0.5,
-                top_metrics: [%{metric: "some.metric", contribution: -1.0}],
-                top_nodes: []
-              }
-            ]
-          }
-        ]
-      }
-
-      report = %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 42,
-        overall_grade: "D+",
-        categories: [category]
-      }
-
-      result = Formatter.format_markdown(report, :default, :plain)
-      refute result =~ "**Fix:**"
-    end
-  end
-
-  describe "plain formatter: threshold offenders with enriched data" do
-    defp report_with_enriched_threshold_plain do
-      %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 32,
-        overall_grade: "F",
-        categories: [@enriched_threshold_category]
-      }
-    end
-
-    test "threshold Issues cell contains Where when top_nodes present" do
-      result =
-        Formatter.format_markdown(report_with_enriched_threshold_plain(), :default, :plain)
-
-      assert result =~ "**Where:** line 201 (block), line 312 (block)"
-    end
-
-    test "threshold Issues cell omits Where when top_nodes empty" do
-      category = %{
-        @enriched_threshold_category
-        | worst_offenders: [
-            %{
-              path: "lib/bar.ex",
-              score: 32,
-              grade: "F",
-              lines: 100,
-              bytes: 3000,
-              metric_scores: [
-                %{name: "difficulty", source: "halstead", good: :low, value: 99.0, score: 0}
-              ],
-              top_nodes: []
-            }
-          ]
-      }
-
-      report = %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 32,
-        overall_grade: "F",
-        categories: [category]
-      }
-
-      result = Formatter.format_markdown(report, :default, :plain)
-      refute result =~ "**Where:**"
-    end
-
-    test "threshold Issues cell omits Where when top_nodes key absent" do
-      category = %{
-        @enriched_threshold_category
-        | worst_offenders: [
-            %{
-              path: "lib/bar.ex",
-              score: 32,
-              grade: "F",
-              lines: 100,
-              bytes: 3000,
-              metric_scores: [
-                %{name: "difficulty", source: "halstead", good: :low, value: 99.0, score: 0}
-              ]
-            }
-          ]
-      }
-
-      report = %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 32,
-        overall_grade: "F",
-        categories: [category]
-      }
-
-      result = Formatter.format_markdown(report, :default, :plain)
-      refute result =~ "**Where:**"
-    end
-
-    test "Fix in threshold Issues when hint present" do
-      result =
-        Formatter.format_markdown(report_with_enriched_threshold_plain(), :default, :plain)
-
-      assert result =~ "**Fix:** High operator/operand ratio"
-    end
-
-    test "Fix omitted from threshold Issues when hint absent" do
-      category = %{
-        @enriched_threshold_category
-        | worst_offenders: [
-            %{
-              path: "lib/bar.ex",
-              score: 10,
-              grade: "F",
-              lines: 200,
-              bytes: 6000,
-              metric_scores: [
-                %{
-                  name: "nonexistent_metric",
-                  source: "nonexistent_source",
-                  good: :low,
-                  value: 99.0,
-                  score: 10
-                }
-              ],
-              top_nodes: []
-            }
-          ]
-      }
-
-      report = %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 10,
-        overall_grade: "F",
-        categories: [category]
-      }
-
-      result = Formatter.format_markdown(report, :default, :plain)
-      refute result =~ "**Fix:**"
-    end
-  end
-
   describe "format_markdown/3 defaults to :plain" do
     test "two-arity call matches plain output" do
       plain = Formatter.format_markdown(@sample_report, :default, :plain)

From 86a901426d9cd41a33f38f8baba59dfe0b263233 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 13:24:25 +0100
Subject: [PATCH 39/71] feat(formatter): add block, delta, PR summary sections;
 remove worst_offenders (github)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/health_report/formatter/github.ex | 310 +++++--------
 test/codeqa/health_report/formatter_test.exs | 461 +++----------------
 2 files changed, 173 insertions(+), 598 deletions(-)

diff --git a/lib/codeqa/health_report/formatter/github.ex b/lib/codeqa/health_report/formatter/github.ex
index 90c7c18..48a6071 100644
--- a/lib/codeqa/health_report/formatter/github.ex
+++ b/lib/codeqa/health_report/formatter/github.ex
@@ -11,11 +11,14 @@ defmodule CodeQA.HealthReport.Formatter.Github do
     display_categories = merge_cosine_categories(report.categories)
 
     [
+      pr_summary_section(Map.get(report, :pr_summary)),
       header(report),
       cosine_legend(),
+      delta_section(Map.get(report, :codebase_delta)),
       if(chart?, do: mermaid_chart(display_categories), else: []),
       progress_bars(display_categories),
       top_issues_section(Map.get(report, :top_issues, []), detail),
+      blocks_section(Map.get(report, :top_blocks, [])),
       category_sections(display_categories, detail),
       footer()
     ]
@@ -230,7 +233,7 @@ defmodule CodeQA.HealthReport.Formatter.Github do
     summary_table ++ [""] ++ sub_sections
   end
 
-  defp cosine_section_content(cat, detail) do
+  defp cosine_section_content(cat, _detail) do
     n = length(cat.behaviors)
 
     behaviors_rows =
@@ -246,112 +249,7 @@ defmodule CodeQA.HealthReport.Formatter.Github do
       | behaviors_rows
     ]
 
-    offenders_sections = cosine_worst_offenders(cat, detail)
-
-    behaviors_table ++ [""] ++ offenders_sections
-  end
-
-  defp cosine_worst_offenders(_cat, :summary), do: []
-
-  defp cosine_worst_offenders(cat, _detail) do
-    Enum.flat_map(cat.behaviors, fn b ->
-      offenders = Map.get(b, :worst_offenders, [])
-
-      if offenders == [] do
-        []
-      else
-        fix_hint = cosine_fix_hint(cat.key, b.behavior)
-
-        cards =
-          Enum.flat_map(offenders, fn f ->
-            score_str = format_cosine_score(f.cosine)
-            summary = "<code>#{f.file}</code> — #{score_str}"
-
-            why_line = format_why_line(Map.get(f, :top_metrics, []))
-            where_line = format_where_line(Map.get(f, :top_nodes, []))
-            fix_line = if fix_hint, do: "**Fix:** #{fix_hint}", else: nil
-
-            body_lines =
-              [why_line, where_line, fix_line]
-              |> Enum.reject(&is_nil/1)
-
-            if body_lines == [] do
-              [
-                "<details>",
-                "<summary>#{summary}</summary>",
-                "",
-                "</details>",
-                ""
-              ]
-            else
-              [
-                "<details>",
-                "<summary>#{summary}</summary>",
-                ""
-              ] ++
-                body_lines ++
-                [
-                  "",
-                  "</details>",
-                  ""
-                ]
-            end
-          end)
-
-        ["**Worst Offenders: #{b.behavior}**", "" | cards]
-      end
-    end)
-  end
-
-  defp cosine_fix_hint(category_key, behavior) do
-    yaml_path = "priv/combined_metrics/#{category_key}.yml"
-
-    case YamlElixir.read_from_file(yaml_path) do
-      {:ok, data} ->
-        get_in(data, [behavior, "_fix_hint"])
-
-      {:error, reason} ->
-        require Logger
-        Logger.debug("cosine_fix_hint: could not read #{yaml_path}: #{inspect(reason)}")
-        nil
-    end
-  end
-
-  defp format_cosine_score(cosine) when cosine < 0,
-    do: "−#{format_num(abs(cosine))}"
-
-  defp format_cosine_score(cosine), do: format_num(cosine)
-
-  defp format_why_line([]), do: nil
-
-  defp format_why_line(top_metrics) do
-    parts =
-      Enum.map(top_metrics, fn %{metric: metric, contribution: contribution} ->
-        sign = if contribution < 0, do: "↓", else: "↑"
-        abs_val = abs(contribution)
-
-        value_str =
-          if contribution < 0,
-            do: "−#{format_num(abs_val)}",
-            else: "+#{format_num(abs_val)}"
-
-        "#{sign} #{metric} (#{value_str})"
-      end)
-
-    "**Why:** #{Enum.join(parts, ", ")}"
-  end
-
-  defp format_where_line([]), do: nil
-
-  defp format_where_line(top_nodes) do
-    parts =
-      Enum.map(top_nodes, fn node ->
-        line = node["start_line"] || "?"
-        type = node["type"] || "unknown"
-        "line #{line} (#{type})"
-      end)
-
-    "**Where:** #{Enum.join(parts, ", ")}"
+    behaviors_table ++ [""]
   end
 
   defp section_content(cat, _detail) do
@@ -378,84 +276,7 @@ defmodule CodeQA.HealthReport.Formatter.Github do
       "Codebase averages: #{metric_summary}",
       ""
       | metrics_table
-    ] ++ [""] ++ worst_offenders(cat)
-  end
-
-  defp worst_offenders(cat) do
-    # TODO(option-c): the flat issues list alternative would replace the per-category worst offenders loop with a single table sorted by severity: each row is one specific issue at one location (file:line — behavior — fix), not one file with multiple behaviors collapsed into it.
-    offenders = Map.get(cat, :worst_offenders, [])
-
-    if offenders == [] do
-      []
-    else
-      averages = Map.new(cat.metric_scores, &{&1.name, &1.value})
-
-      cards =
-        Enum.flat_map(offenders, fn f ->
-          size_str = "#{format_lines(f[:lines])} lines · #{format_size(f[:bytes])}"
-          summary = "<code>#{f.path}</code> — #{size_str} — #{f.grade} (#{f.score})"
-
-          why_str = format_threshold_why(f.metric_scores, averages)
-          why_line = if why_str != "", do: "**Why:** #{why_str}", else: nil
-
-          where_line = format_where_line(Map.get(f, :top_nodes, []))
-
-          fix_hint = threshold_fix_hint(f.metric_scores)
-          fix_line = if fix_hint, do: "**Fix:** #{fix_hint}", else: nil
-
-          body_lines =
-            [why_line, where_line, fix_line]
-            |> Enum.reject(&is_nil/1)
-
-          if body_lines == [] do
-            [
-              "<details>",
-              "<summary>#{summary}</summary>",
-              "",
-              "</details>",
-              ""
-            ]
-          else
-            [
-              "<details>",
-              "<summary>#{summary}</summary>",
-              ""
-            ] ++
-              body_lines ++
-              [
-                "",
-                "</details>",
-                ""
-              ]
-          end
-        end)
-
-      ["**Worst Offenders**", "" | cards]
-    end
-  end
-
-  defp format_threshold_why(metric_scores, averages) do
-    Enum.map_join(metric_scores, " · ", fn m ->
-      avg = Map.get(averages, m.name)
-      avg_str = if avg, do: " (avg: #{format_num(avg)})", else: ""
-      "#{direction(m.good)}#{m.name}=#{format_num(m.value)}#{avg_str}"
-    end)
-  end
-
-  defp threshold_fix_hint(metric_scores) do
-    worst = Enum.min_by(metric_scores, & &1.score, fn -> nil end)
-
-    if worst do
-      categories = CodeQA.HealthReport.Categories.defaults()
-      all_metrics = Enum.flat_map(categories, & &1.metrics)
-
-      found =
-        Enum.find(all_metrics, fn m ->
-          m.name == worst.name and m.source == worst.source
-        end)
-
-      if found, do: Map.get(found, :fix_hint), else: nil
-    end
+    ] ++ [""]
   end
 
   defp top_issues_section([], _detail), do: []
@@ -504,20 +325,119 @@ defmodule CodeQA.HealthReport.Formatter.Github do
 
   defp extract_project_name(_), do: "unknown"
 
-  defp direction(:high), do: "↑ "
-  defp direction(_), do: "↓ "
-
-  defp format_lines(nil), do: "—"
-  defp format_lines(n), do: to_string(n)
-
-  defp format_size(nil), do: "—"
-  defp format_size(bytes) when bytes < 1024, do: "#{bytes} B"
-  defp format_size(bytes), do: "#{Float.round(bytes / 1024, 1)} KB"
-
   defp format_num(value) when is_float(value), do: :erlang.float_to_binary(value, decimals: 2)
   defp format_num(value) when is_integer(value), do: to_string(value)
   defp format_num(value), do: to_string(value)
 
   defp format_date(timestamp) when is_binary(timestamp), do: String.slice(timestamp, 0, 10)
   defp format_date(_), do: "unknown"
+
+  defp pr_summary_section(nil), do: []
+
+  defp pr_summary_section(summary) do
+    delta_str =
+      if summary.score_delta >= 0,
+        do: "+#{summary.score_delta}",
+        else: "#{summary.score_delta}"
+
+    status_str = "#{summary.files_modified} modified, #{summary.files_added} added"
+
+    [
+      "> **Score:** #{summary.base_grade} → #{summary.head_grade}  |  **Δ** #{delta_str} pts  |  **#{summary.blocks_flagged}** blocks flagged across #{summary.files_changed} files  |  #{status_str}",
+      ""
+    ]
+  end
+
+  defp delta_section(nil), do: []
+
+  defp delta_section(delta) do
+    base_agg = delta.base.aggregate
+    head_agg = delta.head.aggregate
+
+    metrics = [
+      {"Readability", "readability", "mean_flesch_adapted"},
+      {"Complexity", "halstead", "mean_difficulty"},
+      {"Duplication", "compression", "mean_redundancy"},
+      {"Structure", "branching", "mean_branch_count"}
+    ]
+
+    rows =
+      Enum.flat_map(metrics, fn {label, group, key} ->
+        base_val = get_in(base_agg, [group, key])
+        head_val = get_in(head_agg, [group, key])
+
+        if is_number(base_val) and is_number(head_val) do
+          diff = Float.round(head_val - base_val, 2)
+          diff_str = if diff >= 0, do: "+#{format_num(diff)}", else: "#{format_num(diff)}"
+          ["| #{label} | #{format_num(base_val)} | #{format_num(head_val)} | #{diff_str} |"]
+        else
+          []
+        end
+      end)
+
+    if rows == [] do
+      []
+    else
+      [
+        "## Metric Changes",
+        "",
+        "| Category | Base | Head | Δ |",
+        "|----------|------|------|---|"
+        | rows
+      ] ++ [""]
+    end
+  end
+
+  defp blocks_section([]), do: []
+
+  defp blocks_section(top_blocks) do
+    total = Enum.sum(Enum.map(top_blocks, fn g -> length(g.blocks) end))
+
+    file_cards =
+      Enum.flat_map(top_blocks, fn group ->
+        status_str = if group.status, do: " [#{group.status}]", else: ""
+        summary_line = "🔍 #{group.path}#{status_str} — #{length(group.blocks)} block(s)"
+
+        block_lines =
+          Enum.flat_map(group.blocks, fn block ->
+            end_line = block.end_line || block.start_line
+
+            potential_lines =
+              Enum.flat_map(block.potentials, fn p ->
+                icon = severity_icon(p.severity)
+                delta_str = format_num(p.cosine_delta)
+                label = String.upcase(to_string(p.severity))
+                line = "**#{icon} #{label}** `#{p.category}/#{p.behavior}` (Δ #{delta_str})"
+                fix = if p.fix_hint, do: ["> #{p.fix_hint}"], else: []
+                [line | fix]
+              end)
+
+            [
+              "**lines #{block.start_line}–#{end_line}** · #{block.type} · #{block.token_count} tokens"
+            ] ++
+              potential_lines ++ [""]
+          end)
+
+        inner = List.flatten(block_lines) |> Enum.join("\n")
+
+        [
+          "<details>",
+          "<summary>#{summary_line}</summary>",
+          "",
+          inner,
+          "</details>",
+          ""
+        ]
+      end)
+
+    [
+      "## 🔍 Blocks  (#{total} flagged across #{length(top_blocks)} files)",
+      ""
+      | file_cards
+    ]
+  end
+
+  defp severity_icon(:critical), do: "🔴"
+  defp severity_icon(:high), do: "🟠"
+  defp severity_icon(:medium), do: "🟡"
 end
diff --git a/test/codeqa/health_report/formatter_test.exs b/test/codeqa/health_report/formatter_test.exs
index c3166b9..39ce63a 100644
--- a/test/codeqa/health_report/formatter_test.exs
+++ b/test/codeqa/health_report/formatter_test.exs
@@ -411,25 +411,6 @@ defmodule CodeQA.HealthReport.FormatterTest do
       assert result =~ "| Behavior | Cosine | Score | Grade |"
       assert result =~ "| no_boolean_parameter | 0.12 | 56 | C |"
     end
-
-    test "renders cosine worst offenders per behavior as details cards" do
-      result = Formatter.format_markdown(@report_with_cosine, :default, :github)
-      assert result =~ "**Worst Offenders: no_boolean_parameter**"
-      assert result =~ "<code>lib/foo/bar.ex</code>"
-      assert result =~ "−0.71"
-      refute result =~ "| File | Cosine |"
-      refute result =~ "| `lib/foo/bar.ex` |"
-    end
-
-    test "omits behaviors with no worst offenders" do
-      result = Formatter.format_markdown(@report_with_cosine, :default, :github)
-      refute result =~ "**Worst Offenders: single_responsibility**"
-    end
-
-    test "summary detail omits cosine worst offenders" do
-      result = Formatter.format_markdown(@report_with_cosine, :summary, :github)
-      refute result =~ "**Worst Offenders: no_boolean_parameter**"
-    end
   end
 
   describe "format_markdown/4 with :github format and chart: false" do
@@ -440,407 +421,81 @@ defmodule CodeQA.HealthReport.FormatterTest do
     end
   end
 
-  describe "github cosine worst offender <details> cards" do
-    defp report_with_enriched_cosine do
-      %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 64,
-        overall_grade: "C",
-        categories: [@enriched_cosine_category]
-      }
-    end
-
-    test "renders <details> card for each worst offender" do
-      result = Formatter.format_markdown(report_with_enriched_cosine(), :default, :github)
-      assert result =~ "<details>"
-      assert result =~ "<code>lib/codeqa/formatter.ex</code>"
-    end
-
-    test "renders score with Unicode minus for negative cosine in card summary" do
-      result = Formatter.format_markdown(report_with_enriched_cosine(), :default, :github)
-      assert result =~ "<summary><code>lib/codeqa/formatter.ex</code> — −0.65</summary>"
-    end
-
-    test "renders Why row with ↓ for negative contributions" do
-      result = Formatter.format_markdown(report_with_enriched_cosine(), :default, :github)
-      assert result =~ "**Why:** ↓ branching.mean_depth (−4.10), ↓ halstead.effort (−3.22)"
-    end
-
-    test "renders Why row with ↑ for positive contributions" do
-      category = %{
-        @enriched_cosine_category
-        | behaviors: [
-            %{
-              behavior: "no_boolean_parameter",
-              cosine: 0.5,
-              score: 90,
-              grade: "A",
-              worst_offenders: [
-                %{
-                  file: "lib/foo.ex",
-                  cosine: 0.5,
-                  top_metrics: [%{metric: "halstead.effort", contribution: 2.5}],
-                  top_nodes: []
-                }
-              ]
-            }
-          ]
-      }
-
-      report = %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 90,
-        overall_grade: "A",
-        categories: [category]
-      }
-
-      result = Formatter.format_markdown(report, :default, :github)
-      assert result =~ "↑ halstead.effort (+2.50)"
-    end
-
-    test "omits Why row when top_metrics is empty" do
-      category = %{
-        @enriched_cosine_category
-        | behaviors: [
-            %{
-              behavior: "no_boolean_parameter",
-              cosine: -0.5,
-              score: 42,
-              grade: "D+",
-              worst_offenders: [
-                %{
-                  file: "lib/foo.ex",
-                  cosine: -0.5,
-                  top_metrics: [],
-                  top_nodes: [%{"start_line" => 10, "type" => "block"}]
-                }
-              ]
-            }
-          ]
-      }
-
-      report = %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 42,
-        overall_grade: "D+",
-        categories: [category]
-      }
-
-      result = Formatter.format_markdown(report, :default, :github)
-      refute result =~ "**Why:**"
-      assert result =~ "**Where:**"
-    end
-
-    test "renders Where row as 'line N (type)'" do
-      result = Formatter.format_markdown(report_with_enriched_cosine(), :default, :github)
-      assert result =~ "**Where:** line 89 (block), line 134 (block)"
-    end
-
-    test "omits Where row when top_nodes is empty" do
-      category = %{
-        @enriched_cosine_category
-        | behaviors: [
-            %{
-              behavior: "no_boolean_parameter",
-              cosine: -0.5,
-              score: 42,
-              grade: "D+",
-              worst_offenders: [
-                %{
-                  file: "lib/foo.ex",
-                  cosine: -0.5,
-                  top_metrics: [%{metric: "branching.mean_depth", contribution: -4.10}],
-                  top_nodes: []
-                }
-              ]
-            }
-          ]
-      }
-
-      report = %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 42,
-        overall_grade: "D+",
-        categories: [category]
-      }
-
-      result = Formatter.format_markdown(report, :default, :github)
-      refute result =~ "**Where:**"
-      assert result =~ "**Why:**"
-    end
-
-    test "omits Where row when top_nodes key is absent" do
-      category = %{
-        @enriched_cosine_category
-        | behaviors: [
-            %{
-              behavior: "no_boolean_parameter",
-              cosine: -0.5,
-              score: 42,
-              grade: "D+",
-              worst_offenders: [
-                %{file: "lib/foo.ex", cosine: -0.5}
-              ]
-            }
-          ]
-      }
-
-      report = %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 42,
-        overall_grade: "D+",
-        categories: [category]
-      }
-
-      result = Formatter.format_markdown(report, :default, :github)
-      refute result =~ "**Where:**"
-    end
-
-    test "does not render old table format" do
-      result = Formatter.format_markdown(report_with_enriched_cosine(), :default, :github)
-      refute result =~ "| File | Cosine |"
-    end
-
-    test "omits Fix row when cosine fix_hint is nil" do
-      category = %{
-        type: :cosine,
-        key: "nonexistent",
-        name: "Nonexistent",
-        score: 50,
-        grade: "C",
-        impact: 1,
-        behaviors: [
-          %{
-            behavior: "nonexistent_behavior",
-            cosine: -0.5,
-            score: 42,
-            grade: "D+",
-            worst_offenders: [
-              %{
-                file: "lib/foo.ex",
-                cosine: -0.5,
-                top_metrics: [%{metric: "some.metric", contribution: -1.0}],
-                top_nodes: []
-              }
-            ]
-          }
-        ]
-      }
-
-      report = %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 42,
-        overall_grade: "D+",
-        categories: [category]
-      }
-
-      result = Formatter.format_markdown(report, :default, :github)
-      refute result =~ "**Fix:**"
-    end
+  describe "github formatter: block section" do
+    @block_potential %{
+      category: "function_design",
+      behavior: "cyclomatic_complexity_under_10",
+      cosine_delta: 0.41,
+      severity: :critical,
+      fix_hint: "Reduce branching"
+    }
 
-    test "renders Fix row for cosine when hint is present" do
-      category = %{
-        type: :cosine,
-        key: "variable_naming",
-        name: "Variable Naming",
-        score: 50,
-        grade: "C",
-        impact: 1,
-        behaviors: [
+    @top_blocks_gh [
+      %{
+        path: "lib/foo.ex",
+        status: "modified",
+        blocks: [
           %{
-            behavior: "name_is_generic",
-            cosine: -0.5,
-            score: 42,
-            grade: "D+",
-            worst_offenders: [
-              %{
-                file: "lib/foo.ex",
-                cosine: -0.5,
-                top_metrics: [%{metric: "some.metric", contribution: -1.0}],
-                top_nodes: []
-              }
-            ]
+            start_line: 42,
+            end_line: 67,
+            type: "code",
+            token_count: 84,
+            potentials: [@block_potential]
           }
         ]
       }
+    ]
 
-      report = %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 42,
-        overall_grade: "D+",
-        categories: [category]
-      }
-
-      result = Formatter.format_markdown(report, :default, :github)
-      assert result =~ "**Fix:**"
-    end
-
-    test "snapshot: full enriched cosine offender card" do
-      result = Formatter.format_markdown(report_with_enriched_cosine(), :default, :github)
-      assert result =~ "<details>"
-      assert result =~ "<summary>"
-      assert result =~ "**Why:**"
-      assert result =~ "↓"
-      assert result =~ "**Where:**"
-      assert result =~ "line"
-      assert result =~ "("
-      assert result =~ "</details>"
-    end
-  end
-
-  describe "github threshold worst offender <details> cards" do
-    defp report_with_enriched_threshold do
-      %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 32,
-        overall_grade: "F",
-        categories: [@enriched_threshold_category]
-      }
-    end
+    @report_with_blocks_gh Map.put(@sample_report, :top_blocks, @top_blocks_gh)
 
-    test "renders <details> card for each threshold worst offender" do
-      result = Formatter.format_markdown(report_with_enriched_threshold(), :default, :github)
+    test "renders block section with details wrapper per file" do
+      result = Formatter.format_markdown(@report_with_blocks_gh, :default, :github)
+      assert result =~ "Blocks"
       assert result =~ "<details>"
-      assert result =~ "<code>lib/foo.ex</code>"
-    end
-
-    test "summary line includes lines, size and grade" do
-      result = Formatter.format_markdown(report_with_enriched_threshold(), :default, :github)
-      assert result =~ "491 lines"
-      assert result =~ "F (32)"
-    end
-
-    test "renders Why row with · separator for threshold metrics" do
-      result = Formatter.format_markdown(report_with_enriched_threshold(), :default, :github)
-      assert result =~ "**Why:** ↓ difficulty=99.00 (avg: 39.00)"
-    end
-
-    test "renders Where row for threshold worst offenders" do
-      result = Formatter.format_markdown(report_with_enriched_threshold(), :default, :github)
-      assert result =~ "**Where:** line 201 (block), line 312 (block)"
+      assert result =~ "lib/foo.ex"
+      assert result =~ "modified"
     end
 
-    test "renders Fix row from Categories.defaults when hint available" do
-      result = Formatter.format_markdown(report_with_enriched_threshold(), :default, :github)
-      assert result =~ "**Fix:** High operator/operand ratio"
+    test "renders severity and fix hint" do
+      result = Formatter.format_markdown(@report_with_blocks_gh, :default, :github)
+      assert result =~ "🔴"
+      assert result =~ "cyclomatic_complexity_under_10"
+      assert result =~ "Reduce branching"
     end
+  end
 
-    test "omits Where row when top_nodes is empty" do
-      category = %{
-        @enriched_threshold_category
-        | worst_offenders: [
-            %{
-              path: "lib/bar.ex",
-              score: 32,
-              grade: "F",
-              lines: 100,
-              bytes: 3000,
-              metric_scores: [
-                %{name: "difficulty", source: "halstead", good: :low, value: 99.0, score: 0}
-              ],
-              top_nodes: []
-            }
-          ]
-      }
-
-      report = %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 32,
-        overall_grade: "F",
-        categories: [category]
-      }
-
-      result = Formatter.format_markdown(report, :default, :github)
-      refute result =~ "**Where:**"
-    end
-
-    test "does not render old table format" do
-      result = Formatter.format_markdown(report_with_enriched_threshold(), :default, :github)
-      refute result =~ "| File | Grade | Issues |"
-    end
-
-    test "omits Fix row when threshold fix_hint is nil" do
-      category = %{
-        @enriched_threshold_category
-        | worst_offenders: [
-            %{
-              path: "lib/bar.ex",
-              score: 10,
-              grade: "F",
-              lines: 200,
-              bytes: 6000,
-              metric_scores: [
-                %{
-                  name: "nonexistent_metric",
-                  source: "nonexistent_source",
-                  good: :low,
-                  value: 99.0,
-                  score: 10
-                }
-              ],
-              top_nodes: []
-            }
-          ]
-      }
+  describe "github formatter: PR summary and delta" do
+    @pr_summary_gh %{
+      base_score: 85,
+      head_score: 77,
+      score_delta: -8,
+      base_grade: "B+",
+      head_grade: "C+",
+      blocks_flagged: 6,
+      files_changed: 3,
+      files_added: 1,
+      files_modified: 2
+    }
 
-      report = %{
-        metadata: %{
-          path: "/home/user/project",
-          timestamp: "2026-03-11T00:00:00Z",
-          total_files: 10
-        },
-        overall_score: 10,
-        overall_grade: "F",
-        categories: [category]
-      }
+    @delta_gh %{
+      base: %{aggregate: %{"readability" => %{"mean_flesch_adapted" => 65.0}}},
+      head: %{aggregate: %{"readability" => %{"mean_flesch_adapted" => 61.0}}}
+    }
 
+    test "renders PR summary" do
+      report = @sample_report |> Map.put(:pr_summary, @pr_summary_gh)
       result = Formatter.format_markdown(report, :default, :github)
-      refute result =~ "**Fix:**"
+      assert result =~ "B+"
+      assert result =~ "C+"
+      assert result =~ "-8"
     end
 
-    test "snapshot: full enriched threshold offender card" do
-      result = Formatter.format_markdown(report_with_enriched_threshold(), :default, :github)
-      assert result =~ "<details>"
-      assert result =~ "<summary>"
-      assert result =~ "**Why:**"
-      assert result =~ "**Where:**"
-      assert result =~ "</details>"
+    test "renders delta section" do
+      report = @sample_report |> Map.put(:codebase_delta, @delta_gh)
+      result = Formatter.format_markdown(report, :default, :github)
+      assert result =~ "Metric Changes"
+      assert result =~ "65.00"
+      assert result =~ "61.00"
     end
   end
 end

From ec2bc51e5e3c448e99e2cdbd9e673a3d29a65fbb Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 13:28:34 +0100
Subject: [PATCH 40/71] fix(formatter): add fallback clause to severity_icon/1

---
 lib/codeqa/health_report/formatter/github.ex | 1 +
 lib/codeqa/health_report/formatter/plain.ex  | 1 +
 2 files changed, 2 insertions(+)

diff --git a/lib/codeqa/health_report/formatter/github.ex b/lib/codeqa/health_report/formatter/github.ex
index 48a6071..694b7ff 100644
--- a/lib/codeqa/health_report/formatter/github.ex
+++ b/lib/codeqa/health_report/formatter/github.ex
@@ -440,4 +440,5 @@ defmodule CodeQA.HealthReport.Formatter.Github do
   defp severity_icon(:critical), do: "🔴"
   defp severity_icon(:high), do: "🟠"
   defp severity_icon(:medium), do: "🟡"
+  defp severity_icon(_), do: "⚪"
 end
diff --git a/lib/codeqa/health_report/formatter/plain.ex b/lib/codeqa/health_report/formatter/plain.ex
index 37c7dfb..25117a3 100644
--- a/lib/codeqa/health_report/formatter/plain.ex
+++ b/lib/codeqa/health_report/formatter/plain.ex
@@ -247,4 +247,5 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
   defp severity_icon(:critical), do: "🔴"
   defp severity_icon(:high), do: "🟠"
   defp severity_icon(:medium), do: "🟡"
+  defp severity_icon(_), do: "⚪"
 end

From 980860c151242135a87d8a0ca7f45c8264e6b241 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 13:30:16 +0100
Subject: [PATCH 41/71] feat(cli): add --base-ref/--head-ref to health-report
 for PR delta and block scoping

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/cli/health_report.ex | 30 +++++++++++++++++++++++++-----
 1 file changed, 25 insertions(+), 5 deletions(-)

diff --git a/lib/codeqa/cli/health_report.ex b/lib/codeqa/cli/health_report.ex
index 525e2e0..680bbbc 100644
--- a/lib/codeqa/cli/health_report.ex
+++ b/lib/codeqa/cli/health_report.ex
@@ -24,6 +24,8 @@ defmodule CodeQA.CLI.HealthReport do
       --cache-dir DIR       Directory to store cache (default: .codeqa_cache)
       -t, --timeout MS      Timeout for similarity analysis (default: 5000)
       --ignore-paths PATHS  Comma-separated list of path patterns to ignore (supports wildcards, e.g. "test/*,docs/*")
+      --base-ref REF        Base git ref for PR comparison (enables delta and block scoping)
+      --head-ref REF        Head git ref (default: HEAD)
     """
   end
 
@@ -38,7 +40,9 @@ defmodule CodeQA.CLI.HealthReport do
     detail: :string,
     top: :integer,
     format: :string,
-    ignore_paths: :string
+    ignore_paths: :string,
+    base_ref: :string,
+    head_ref: :string
   ]
 
   def run(args) do
@@ -46,12 +50,12 @@ defmodule CodeQA.CLI.HealthReport do
     Options.validate_dir!(path)
     extra_ignore_patterns = Options.parse_ignore_paths(opts[:ignore_paths])
 
+    base_ref = opts[:base_ref]
+    head_ref = opts[:head_ref] || "HEAD"
+
     files =
       CodeQA.Engine.Collector.collect_files(path, extra_ignore_patterns)
 
-    # IO.inspect(files |> Map.keys(), label: "files", limit: :infinity)
-    # Process.exit(Process.get(:codeqa_config), :kill)
-
     if map_size(files) == 0 do
       IO.puts(:stderr, "Warning: no source files found in '#{path}'")
       exit({:shutdown, 1})
@@ -81,6 +85,20 @@ defmodule CodeQA.CLI.HealthReport do
         "total_bytes" => total_bytes
       })
 
+    {base_results, changed_files} =
+      if base_ref do
+        IO.puts(:stderr, "Collecting base snapshot at #{base_ref}...")
+        base_files = CodeQA.Git.collect_files_at_ref(path, base_ref)
+        changed = CodeQA.Git.changed_files(path, base_ref, head_ref)
+
+        IO.puts(:stderr, "Analyzing base snapshot (#{map_size(base_files)} files)...")
+        base_res = CodeQA.Engine.Analyzer.analyze_codebase(base_files, analyze_opts)
+
+        {base_res, changed}
+      else
+        {nil, []}
+      end
+
     detail = parse_detail(opts[:detail])
     format = parse_format(opts[:format])
     top_n = opts[:top] || 5
@@ -89,7 +107,9 @@ defmodule CodeQA.CLI.HealthReport do
       CodeQA.HealthReport.generate(results,
         config: opts[:config],
         detail: detail,
-        top: top_n
+        top: top_n,
+        base_results: base_results,
+        changed_files: changed_files
       )
 
     markdown = CodeQA.HealthReport.to_markdown(report, detail, format)

From 110f4397002e0201856d97ec1a2bebb0400d4ad5 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 13:33:34 +0100
Subject: [PATCH 42/71] =?UTF-8?q?feat(cli):=20delete=20compare=20command?=
 =?UTF-8?q?=20=E2=80=94=20absorbed=20into=20health-report?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib/codeqa/cli.ex                |   1 -
 lib/codeqa/cli/compare.ex        | 239 ---------------------
 lib/codeqa/comparator.ex         | 109 ----------
 lib/codeqa/formatter.ex          | 346 -------------------------------
 lib/codeqa/summarizer.ex         | 126 -----------
 test/codeqa/cli_compare_test.exs |  91 --------
 test/codeqa/formatter_test.exs   | 150 --------------
 7 files changed, 1062 deletions(-)
 delete mode 100644 lib/codeqa/cli/compare.ex
 delete mode 100644 lib/codeqa/comparator.ex
 delete mode 100644 lib/codeqa/formatter.ex
 delete mode 100644 lib/codeqa/summarizer.ex
 delete mode 100644 test/codeqa/cli_compare_test.exs
 delete mode 100644 test/codeqa/formatter_test.exs

diff --git a/lib/codeqa/cli.ex b/lib/codeqa/cli.ex
index 85daa5e..fcb8e01 100644
--- a/lib/codeqa/cli.ex
+++ b/lib/codeqa/cli.ex
@@ -3,7 +3,6 @@ defmodule CodeQA.CLI do
 
   @commands %{
     "analyze" => CodeQA.CLI.Analyze,
-    "compare" => CodeQA.CLI.Compare,
     "history" => CodeQA.CLI.History,
     "correlate" => CodeQA.CLI.Correlate,
     "health-report" => CodeQA.CLI.HealthReport,
diff --git a/lib/codeqa/cli/compare.ex b/lib/codeqa/cli/compare.ex
deleted file mode 100644
index 9adc0c9..0000000
--- a/lib/codeqa/cli/compare.ex
+++ /dev/null
@@ -1,239 +0,0 @@
-defmodule CodeQA.CLI.Compare do
-  @moduledoc false
-
-  @behaviour CodeQA.CLI.Command
-
-  alias CodeQA.CLI.Options
-
-  @version "0.1.0"
-
-  @impl CodeQA.CLI.Command
-  def usage do
-    """
-    Usage: codeqa compare <path> [options]
-
-      Compare code quality metrics between two git refs.
-
-    Options:
-      --base-ref REF        Base git ref to compare from (required)
-      --head-ref REF        Head git ref to compare to (default: HEAD)
-      --changes-only        Only analyze changed files
-      --all-files           Analyze all source files (default)
-      --format FORMAT       Output format: json, markdown, or github (default: json)
-      --output MODE         Output mode: auto, summary, or changes (default: auto)
-      --progress            Show per-file progress on stderr
-      -w, --workers N       Number of parallel workers
-      --cache               Enable caching file metrics
-      --cache-dir DIR       Directory to store cache (default: .codeqa_cache)
-      -t, --timeout MS      Timeout for similarity analysis (default: 5000)
-      --show-ncd            Compute and show NCD similarity metric
-      --ncd-top N           Number of top similar files to show per file
-      --ncd-paths PATHS     Comma-separated list of paths to compute NCD for
-      --show-files          Include individual file metrics in the output
-      --show-file-paths P   Comma-separated list of paths to include in the output
-      --ignore-paths PATHS  Comma-separated list of path patterns to ignore (supports wildcards, e.g. "test/*,docs/*")
-    """
-  end
-
-  @impl CodeQA.CLI.Command
-  def run(args) when args in [["--help"], ["-h"]] do
-    usage()
-  end
-
-  def run(args) do
-    {opts, [path], _} =
-      Options.parse(
-        args,
-        [
-          base_ref: :string,
-          head_ref: :string,
-          changes_only: :boolean,
-          all_files: :boolean,
-          format: :string,
-          output: :string
-        ],
-        []
-      )
-
-    base_ref = opts[:base_ref] || raise "Missing --base-ref"
-    head_ref = opts[:head_ref] || "HEAD"
-    changes_only = if opts[:changes_only], do: true, else: false
-    format = opts[:format] || "json"
-    output_mode = opts[:output] || "auto"
-
-    Options.validate_dir!(path)
-    CodeQA.Config.load(path)
-
-    ignore_patterns = Options.parse_ignore_paths(opts[:ignore_paths])
-    opts = Keyword.put(opts, :ignore_patterns, ignore_patterns)
-
-    {base_result, head_result, changes} =
-      run_comparison(path, base_ref, head_ref, changes_only, opts)
-
-    comparison =
-      CodeQA.Comparator.compare_results(base_result, head_result, changes)
-      |> enrich_metadata(base_ref, head_ref, changes_only)
-      |> filter_files_for_output(opts, format)
-
-    output_comparison(comparison, format, output_mode)
-  end
-
-  defp run_comparison(path, base_ref, head_ref, changes_only, opts) do
-    ignore_patterns = opts[:ignore_patterns] || []
-    changes = CodeQA.Git.changed_files(path, base_ref, head_ref)
-    changes = CodeQA.Engine.Collector.reject_ignored(changes, & &1.path, ignore_patterns)
-
-    file_paths =
-      if changes_only do
-        IO.puts(:stderr, "Comparing #{length(changes)} changed files...")
-        Enum.map(changes, & &1.path)
-      else
-        IO.puts(:stderr, "Comparing all source files...")
-        nil
-      end
-
-    empty = %{"files" => %{}, "codebase" => %{"aggregate" => %{}, "similarity" => %{}}}
-
-    if changes_only and length(changes) == 0 do
-      IO.puts(:stderr, "No source files changed — nothing to compare.")
-      {empty, empty, []}
-    else
-      base_files = CodeQA.Git.collect_files_at_ref(path, base_ref, file_paths)
-      head_files = CodeQA.Git.collect_files_at_ref(path, head_ref, file_paths)
-      base_files = CodeQA.Engine.Collector.reject_ignored_map(base_files, ignore_patterns)
-      head_files = CodeQA.Engine.Collector.reject_ignored_map(head_files, ignore_patterns)
-
-      if map_size(base_files) == 0 and map_size(head_files) == 0 do
-        IO.puts(:stderr, "Warning: no source files found at either ref")
-        exit({:shutdown, 1})
-      end
-
-      print_progress(opts, base_files, head_files)
-
-      analyze_opts =
-        Options.build_analyze_opts(opts) ++ CodeQA.Config.near_duplicate_blocks_opts()
-
-      base_result =
-        if map_size(base_files) > 0,
-          do: CodeQA.Engine.Analyzer.analyze_codebase(base_files, analyze_opts),
-          else: empty
-
-      head_result =
-        if map_size(head_files) > 0,
-          do: CodeQA.Engine.Analyzer.analyze_codebase(head_files, analyze_opts),
-          else: empty
-
-      changes = if changes_only, do: changes, else: synthesize_changes(base_files, head_files)
-
-      {base_result, head_result, changes}
-    end
-  end
-
-  defp print_progress(opts, base_files, head_files) do
-    if opts[:progress] do
-      step_prefix = if opts[:show_ncd], do: "1/5 ", else: "1/1 "
-
-      IO.puts(
-        :stderr,
-        "  #{step_prefix}Analyzing base (#{map_size(base_files)} files) and head (#{map_size(head_files)} files)..."
-      )
-    else
-      IO.puts(
-        :stderr,
-        "Analyzing base (#{map_size(base_files)} files) and head (#{map_size(head_files)} files)..."
-      )
-    end
-  end
-
-  defp enrich_metadata(comparison, base_ref, head_ref, changes_only) do
-    comparison
-    |> put_in(["metadata", "base_ref"], base_ref)
-    |> put_in(["metadata", "head_ref"], head_ref)
-    |> put_in(["metadata", "changes_only"], changes_only)
-    |> put_in(["metadata", "version"], @version)
-    |> put_in(["metadata", "timestamp"], DateTime.utc_now() |> DateTime.to_iso8601())
-  end
-
-  defp output_comparison(comparison, "markdown", output_mode) do
-    CodeQA.Formatter.format_markdown(comparison, output_mode)
-  end
-
-  defp output_comparison(comparison, "github", output_mode) do
-    CodeQA.Formatter.format_github(comparison, output_mode)
-  end
-
-  defp output_comparison(comparison, _format, output_mode) do
-    codebase_summary = CodeQA.Summarizer.summarize_codebase(comparison)
-
-    file_summaries =
-      Map.new(Map.get(comparison, "files", %{}), fn {path, data} ->
-        {path, CodeQA.Summarizer.summarize_file(path, data)}
-      end)
-
-    Jason.encode!(build_json_output(comparison, codebase_summary, file_summaries, output_mode),
-      pretty: true
-    )
-  end
-
-  defp build_json_output(comparison, codebase_summary, file_summaries, output_mode) do
-    result = %{"metadata" => comparison["metadata"]}
-
-    result =
-      if output_mode in ["auto", "summary"] do
-        result
-        |> Map.put("summary", codebase_summary)
-        |> Map.put("codebase", comparison["codebase"])
-      else
-        result
-      end
-
-    if output_mode in ["auto", "changes"] and Map.has_key?(comparison, "files") do
-      files_with_summaries =
-        Map.new(comparison["files"], fn {path, data} ->
-          {path, Map.put(data, "summary", Map.get(file_summaries, path, %{}))}
-        end)
-
-      Map.put(result, "files", files_with_summaries)
-    else
-      result
-    end
-  end
-
-  defp synthesize_changes(base_files, head_files) do
-    all_paths = MapSet.union(MapSet.new(Map.keys(base_files)), MapSet.new(Map.keys(head_files)))
-
-    all_paths
-    |> Enum.sort()
-    |> Enum.map(fn path ->
-      status =
-        cond do
-          Map.has_key?(base_files, path) and Map.has_key?(head_files, path) -> "modified"
-          Map.has_key?(head_files, path) -> "added"
-          true -> "deleted"
-        end
-
-      %CodeQA.Git.ChangedFile{path: path, status: status}
-    end)
-  end
-
-  defp filter_files_for_output(results, _opts, format) when format in ["github", "markdown"],
-    do: results
-
-  defp filter_files_for_output(results, opts, _format) do
-    cond do
-      opts[:show_files] ->
-        results
-
-      opts[:show_file_paths] ->
-        target_paths = String.split(opts[:show_file_paths], ",") |> MapSet.new()
-
-        filtered =
-          Map.filter(results["files"], fn {path, _} -> MapSet.member?(target_paths, path) end)
-
-        Map.put(results, "files", filtered)
-
-      true ->
-        Map.delete(results, "files")
-    end
-  end
-end
diff --git a/lib/codeqa/comparator.ex b/lib/codeqa/comparator.ex
deleted file mode 100644
index 4fbfa40..0000000
--- a/lib/codeqa/comparator.ex
+++ /dev/null
@@ -1,109 +0,0 @@
-defmodule CodeQA.Comparator do
-  @moduledoc "Compare two analysis results and compute metric deltas."
-
-  def compare_results(base_result, head_result, changes) do
-    base_files = Map.get(base_result, "files", %{})
-    head_files = Map.get(head_result, "files", %{})
-
-    {file_comparisons, status_counts} =
-      changes
-      |> Enum.reduce({%{}, %{"added" => 0, "modified" => 0, "deleted" => 0}}, fn change,
-                                                                                 {files, counts} ->
-        base_data = Map.get(base_files, change.path)
-        head_data = Map.get(head_files, change.path)
-        delta = compute_file_delta(base_data, head_data)
-
-        file_entry = %{
-          "status" => change.status,
-          "base" => base_data,
-          "head" => head_data,
-          "delta" => delta
-        }
-
-        {Map.put(files, change.path, file_entry), Map.update!(counts, change.status, &(&1 + 1))}
-      end)
-
-    base_agg = get_in(base_result, ["codebase", "aggregate"]) || %{}
-    head_agg = get_in(head_result, ["codebase", "aggregate"]) || %{}
-    agg_delta = compute_aggregate_delta(base_agg, head_agg)
-
-    summary = build_summary(status_counts)
-
-    %{
-      "metadata" => %{
-        "total_files_compared" => length(changes),
-        "summary" => summary
-      },
-      "files" => file_comparisons,
-      "codebase" => %{
-        "base" => %{"aggregate" => base_agg},
-        "head" => %{"aggregate" => head_agg},
-        "delta" => %{"aggregate" => agg_delta}
-      }
-    }
-  end
-
-  defp compute_file_delta(nil, _head), do: nil
-  defp compute_file_delta(_base, nil), do: nil
-
-  defp compute_file_delta(base_data, head_data) do
-    top_delta =
-      ["bytes", "lines"]
-      |> Enum.reduce(%{}, fn key, acc ->
-        case {Map.get(base_data, key), Map.get(head_data, key)} do
-          {b, h} when is_number(b) and is_number(h) -> Map.put(acc, key, h - b)
-          _ -> acc
-        end
-      end)
-
-    base_metrics = Map.get(base_data, "metrics", %{})
-    head_metrics = Map.get(head_data, "metrics", %{})
-
-    metrics_delta =
-      MapSet.new(Map.keys(base_metrics) ++ Map.keys(head_metrics))
-      |> Enum.reduce(%{}, fn metric_name, acc ->
-        base_m = Map.get(base_metrics, metric_name, %{})
-        head_m = Map.get(head_metrics, metric_name, %{})
-        delta = compute_numeric_delta(base_m, head_m)
-        if delta == %{}, do: acc, else: Map.put(acc, metric_name, delta)
-      end)
-
-    Map.put(top_delta, "metrics", metrics_delta)
-  end
-
-  defp compute_aggregate_delta(base_agg, head_agg) do
-    MapSet.new(Map.keys(base_agg) ++ Map.keys(head_agg))
-    |> Enum.reduce(%{}, fn metric_name, acc ->
-      base_m = Map.get(base_agg, metric_name, %{})
-      head_m = Map.get(head_agg, metric_name, %{})
-      delta = compute_numeric_delta(base_m, head_m)
-      if delta == %{}, do: acc, else: Map.put(acc, metric_name, delta)
-    end)
-  end
-
-  defp compute_numeric_delta(base, head) do
-    MapSet.new(Map.keys(base) ++ Map.keys(head))
-    |> Enum.reduce(%{}, fn key, acc ->
-      case {Map.get(base, key), Map.get(head, key)} do
-        {b, h} when is_number(b) and is_number(h) ->
-          Map.put(acc, key, Float.round((h - b) / 1, 4))
-
-        _ ->
-          acc
-      end
-    end)
-  end
-
-  defp build_summary(counts) do
-    parts =
-      [
-        {"added", counts["added"]},
-        {"modified", counts["modified"]},
-        {"deleted", counts["deleted"]}
-      ]
-      |> Enum.filter(fn {_, c} -> c > 0 end)
-      |> Enum.map(fn {status, count} -> "#{count} #{status}" end)
-
-    if parts == [], do: "no changes", else: Enum.join(parts, ", ")
-  end
-end
diff --git a/lib/codeqa/formatter.ex b/lib/codeqa/formatter.ex
deleted file mode 100644
index 14c1992..0000000
--- a/lib/codeqa/formatter.ex
+++ /dev/null
@@ -1,346 +0,0 @@
-defmodule CodeQA.Formatter do
-  @moduledoc false
-
-  @summary_metrics [
-    {"entropy", "char_entropy", "Entropy"},
-    {"halstead", "volume", "Halstead Vol."},
-    {"halstead", "difficulty", "Difficulty"},
-    {"readability", "flesch_adapted", "Readability"},
-    {"compression", "redundancy", "Redundancy"}
-  ]
-
-  @bar_width 20
-  @filled "█"
-  @empty "░"
-
-  def format_github(comparison, output_mode \\ "auto") do
-    metadata = comparison["metadata"]
-    files = comparison["files"] || %{}
-    codebase = comparison["codebase"] || %{}
-
-    if metadata["total_files_compared"] == 0 do
-      "## Code Quality: PR Comparison\n\nNo file changes detected."
-    else
-      build_github_report(metadata, files, codebase, output_mode)
-    end
-  end
-
-  defp build_github_report(metadata, files, codebase, output_mode) do
-    categories = CodeQA.HealthReport.Categories.defaults()
-    scale = CodeQA.HealthReport.Categories.default_grade_scale()
-
-    base_agg = get_in(codebase, ["base", "aggregate"]) || %{}
-    head_agg = get_in(codebase, ["head", "aggregate"]) || %{}
-
-    base_grades = CodeQA.HealthReport.Grader.grade_aggregate(categories, base_agg, scale)
-    head_grades = CodeQA.HealthReport.Grader.grade_aggregate(categories, head_agg, scale)
-
-    paired = Enum.zip(base_grades, head_grades)
-
-    lines =
-      [
-        "## Code Quality: PR Comparison",
-        "",
-        "**#{metadata["total_files_compared"]} files compared** (#{metadata["summary"]})",
-        ""
-      ] ++
-        mermaid_chart(head_grades) ++
-        progress_bars(paired) ++
-        [""] ++
-        file_details(files, codebase, output_mode) ++
-        aggregate_details(codebase)
-
-    Enum.join(lines, "\n")
-  end
-
-  defp mermaid_chart(head_grades) do
-    names = Enum.map_join(head_grades, ", ", fn g -> ~s("#{g.name}") end)
-    scores = Enum.map_join(head_grades, ", ", fn g -> to_string(g.score) end)
-
-    [
-      "```mermaid",
-      "%%{init: {'theme': 'neutral'}}%%",
-      "xychart-beta",
-      "    title \"Code Health After PR\"",
-      "    x-axis [#{names}]",
-      "    y-axis \"Score\" 0 --> 100",
-      "    bar [#{scores}]",
-      "```",
-      ""
-    ]
-  end
-
-  defp progress_bars(paired) do
-    max_name_len =
-      Enum.reduce(paired, 0, fn {_base, head}, acc ->
-        max(acc, String.length(head.name))
-      end)
-
-    rows =
-      Enum.map(paired, fn {base, head} ->
-        name = String.pad_trailing(head.name, max_name_len)
-        base_bar = build_bar(base.score)
-        head_bar = build_bar(head.score)
-        emoji = grade_emoji(head.grade)
-        delta = head.score - base.score
-        delta_str = if delta >= 0, do: "+#{delta}", else: to_string(delta)
-        "#{name}  #{base_bar} #{base.score} → #{head_bar} #{head.score}  #{emoji} #{delta_str}"
-      end)
-
-    ["```"] ++ rows ++ ["```"]
-  end
-
-  defp file_details(files, codebase, _output_mode) do
-    codebase_summary =
-      CodeQA.Summarizer.summarize_codebase(%{"files" => files, "codebase" => codebase})
-
-    file_summaries =
-      Map.new(files, fn {path, data} ->
-        {path, CodeQA.Summarizer.summarize_file(path, data)}
-      end)
-
-    inner =
-      (format_file_table(files, file_summaries) ++ [""])
-      |> Enum.join("\n")
-
-    [
-      "<details>",
-      "<summary><strong>File changes — #{codebase_summary["gist"]}</strong></summary>",
-      "",
-      inner,
-      "</details>",
-      ""
-    ]
-  end
-
-  defp aggregate_details(codebase) do
-    inner =
-      format_aggregate_table(codebase, build_direction_map())
-      |> Enum.join("\n")
-
-    if inner == "" do
-      []
-    else
-      [
-        "<details>",
-        "<summary><strong>Aggregate metrics</strong></summary>",
-        "",
-        inner,
-        "",
-        "</details>",
-        ""
-      ]
-    end
-  end
-
-  defp build_bar(score) do
-    filled = round(score / 100 * @bar_width)
-    filled = min(max(filled, 0), @bar_width)
-    empty = @bar_width - filled
-    String.duplicate(@filled, filled) <> String.duplicate(@empty, empty)
-  end
-
-  defp grade_emoji(grade) do
-    cond do
-      grade in ["A", "A-"] -> "🟢"
-      grade in ["B+", "B", "B-"] -> "🟡"
-      grade in ["C+", "C", "C-"] -> "🟠"
-      true -> "🔴"
-    end
-  end
-
-  def format_markdown(comparison, output_mode \\ "auto") do
-    metadata = comparison["metadata"]
-    files = comparison["files"] || %{}
-    codebase = comparison["codebase"]
-
-    if metadata["total_files_compared"] == 0 do
-      "## Code Quality: PR Comparison\n\nNo file changes detected."
-    else
-      build_report(metadata, files, codebase, output_mode)
-    end
-  end
-
-  defp build_report(metadata, files, codebase, output_mode) do
-    codebase_summary =
-      CodeQA.Summarizer.summarize_codebase(%{"files" => files, "codebase" => codebase})
-
-    lines = [
-      "## Code Quality: PR Comparison",
-      "",
-      "**#{metadata["total_files_compared"]} files compared** (#{metadata["summary"]})",
-      ""
-    ]
-
-    lines =
-      if output_mode in ["auto", "summary"] do
-        lines ++ ["> #{codebase_summary["gist"]}", ""]
-      else
-        lines
-      end
-
-    lines =
-      if output_mode in ["auto", "changes"] do
-        file_summaries =
-          Map.new(files, fn {path, data} ->
-            {path, CodeQA.Summarizer.summarize_file(path, data)}
-          end)
-
-        lines ++ format_file_table(files, file_summaries) ++ [""]
-      else
-        lines
-      end
-
-    lines =
-      if output_mode in ["auto", "summary"] do
-        lines ++ format_aggregate_table(codebase)
-      else
-        lines
-      end
-
-    Enum.join(lines, "\n")
-  end
-
-  defp format_file_table(files, file_summaries) do
-    columns = detect_columns(files)
-
-    if columns == [],
-      do: ["No metric data available."],
-      else: build_file_rows(files, file_summaries, columns)
-  end
-
-  defp build_file_rows(files, file_summaries, columns) do
-    header =
-      "| File | Status | Summary | " <>
-        Enum.map_join(columns, " | ", fn {_, _, label} -> label end) <> " |"
-
-    separator =
-      "|------|--------|---------|" <> Enum.map_join(columns, "", fn _ -> "--------|" end)
-
-    rows =
-      files
-      |> Enum.sort_by(fn {path, _} -> path end)
-      |> Enum.map(fn {path, data} ->
-        gist = get_in(file_summaries, [path, "gist"]) || ""
-        cells = format_file_row(data, columns)
-        "| `#{path}` | #{data["status"]} | #{gist} | " <> Enum.join(cells, " | ") <> " |"
-      end)
-
-    [header, separator | rows]
-  end
-
-  defp format_file_row(data, columns) do
-    Enum.map(columns, fn {metric_name, key, _label} ->
-      case data["status"] do
-        "modified" -> format_modified_cell(data, metric_name, key)
-        "added" -> format_added_cell(data, metric_name, key)
-        "deleted" -> format_deleted_cell(data, metric_name, key)
-        _ -> "—"
-      end
-    end)
-  end
-
-  defp format_modified_cell(data, metric_name, key) do
-    case get_in(data, ["delta", "metrics", metric_name, key]) do
-      nil -> "—"
-      val -> format_delta(val)
-    end
-  end
-
-  defp format_added_cell(data, metric_name, key) do
-    case get_in(data, ["head", "metrics", metric_name, key]) do
-      nil -> "—"
-      val -> "*#{format_value(val)}*"
-    end
-  end
-
-  defp format_deleted_cell(data, metric_name, key) do
-    case get_in(data, ["base", "metrics", metric_name, key]) do
-      nil -> "—"
-      val -> "~~#{format_value(val)}~~"
-    end
-  end
-
-  defp format_aggregate_table(codebase, direction_map \\ %{}) do
-    base_agg = get_in(codebase, ["base", "aggregate"]) || %{}
-    head_agg = get_in(codebase, ["head", "aggregate"]) || %{}
-    delta_agg = get_in(codebase, ["delta", "aggregate"]) || %{}
-
-    if base_agg == %{} and head_agg == %{},
-      do: [],
-      else: build_aggregate_rows(base_agg, head_agg, delta_agg, direction_map)
-  end
-
-  defp build_aggregate_rows(base_agg, head_agg, delta_agg, direction_map) do
-    header = [
-      "### Aggregate Metrics",
-      "",
-      "| Metric | Base | Head | Delta |",
-      "|--------|------|------|-------|"
-    ]
-
-    rows =
-      MapSet.new(Map.keys(base_agg) ++ Map.keys(head_agg))
-      |> Enum.sort()
-      |> Enum.flat_map(fn metric_name ->
-        base_m = Map.get(base_agg, metric_name, %{})
-        head_m = Map.get(head_agg, metric_name, %{})
-        delta_m = Map.get(delta_agg, metric_name, %{})
-
-        MapSet.new(Map.keys(base_m) ++ Map.keys(head_m))
-        |> Enum.sort()
-        |> Enum.map(fn key ->
-          direction = Map.get(direction_map, "#{metric_name}.#{key}")
-          delta_cell = format_delta_with_direction(delta_m[key], direction)
-
-          "| #{metric_name}.#{key} | #{format_value(base_m[key])} | #{format_value(head_m[key])} | #{delta_cell} |"
-        end)
-      end)
-
-    header ++ rows
-  end
-
-  defp build_direction_map do
-    CodeQA.HealthReport.Categories.defaults()
-    |> Enum.flat_map(fn cat ->
-      Enum.map(cat.metrics, fn m -> {"#{m.source}.mean_#{m.name}", m.good} end)
-    end)
-    |> Map.new()
-  end
-
-  defp format_delta_with_direction(nil, _direction), do: "—"
-
-  defp format_delta_with_direction(value, direction) do
-    formatted = format_delta(value)
-    emoji = delta_emoji(value, direction)
-    if emoji, do: "#{emoji} #{formatted}", else: formatted
-  end
-
-  defp delta_emoji(_value, nil), do: nil
-  defp delta_emoji(value, :high) when value > 0, do: "🟢"
-  defp delta_emoji(value, :high) when value < 0, do: "🔴"
-  defp delta_emoji(value, :low) when value < 0, do: "🟢"
-  defp delta_emoji(value, :low) when value > 0, do: "🔴"
-  defp delta_emoji(_value, _direction), do: nil
-
-  defp detect_columns(files) do
-    Enum.filter(@summary_metrics, fn {metric_name, key, _label} ->
-      Enum.any?(files, fn {_path, data} ->
-        source = data["head"] || data["base"]
-        source && get_in(source, ["metrics", metric_name, key]) != nil
-      end)
-    end)
-  end
-
-  defp format_delta(nil), do: "—"
-
-  defp format_delta(value) when value > 0,
-    do: "+#{:erlang.float_to_binary(value / 1, decimals: 2)}"
-
-  defp format_delta(value) when value < 0, do: :erlang.float_to_binary(value / 1, decimals: 2)
-  defp format_delta(_), do: "0.00"
-
-  defp format_value(nil), do: "—"
-  defp format_value(value) when is_float(value), do: :erlang.float_to_binary(value, decimals: 2)
-  defp format_value(value), do: to_string(value)
-end
diff --git a/lib/codeqa/summarizer.ex b/lib/codeqa/summarizer.ex
deleted file mode 100644
index d6d9c92..0000000
--- a/lib/codeqa/summarizer.ex
+++ /dev/null
@@ -1,126 +0,0 @@
-defmodule CodeQA.Summarizer do
-  @moduledoc false
-
-  @codebase_direction_metrics [
-    {"complexity", "halstead", "mean_volume"},
-    {"readability", "readability", "mean_flesch_adapted"},
-    {"entropy", "entropy", "mean_char_entropy"},
-    {"redundancy", "compression", "mean_redundancy"}
-  ]
-
-  @file_direction_metrics [
-    {"complexity", "halstead", "volume"},
-    {"readability", "readability", "flesch_adapted"},
-    {"entropy", "entropy", "char_entropy"},
-    {"redundancy", "compression", "redundancy"}
-  ]
-
-  @threshold_stable 0.05
-  @threshold_slight 0.20
-
-  def summarize_codebase(comparison) do
-    files = Map.get(comparison, "files", %{})
-    codebase = Map.get(comparison, "codebase", %{})
-
-    file_counts = count_statuses(files)
-    directions = compute_codebase_directions(codebase)
-    gist = build_codebase_gist(file_counts, directions)
-
-    %{"gist" => gist, "file_counts" => file_counts, "directions" => directions}
-  end
-
-  def summarize_file(_path, %{"status" => "added"} = data) do
-    lines = get_in(data, ["head", "lines"]) || 0
-    %{"gist" => "new file (#{lines} lines)", "status" => "added", "lines" => lines}
-  end
-
-  def summarize_file(_path, %{"status" => "deleted"} = data) do
-    lines = get_in(data, ["base", "lines"]) || 0
-    %{"gist" => "removed (#{lines} lines)", "status" => "deleted", "lines" => lines}
-  end
-
-  def summarize_file(_path, %{"status" => "modified"} = data) do
-    directions = compute_file_directions(data)
-    gist = build_file_gist(directions)
-    %{"gist" => gist, "status" => "modified", "directions" => directions}
-  end
-
-  defp count_statuses(files) do
-    Enum.reduce(files, %{"added" => 0, "modified" => 0, "deleted" => 0}, fn {_path, data}, acc ->
-      status = Map.get(data, "status", "modified")
-      Map.update!(acc, status, &(&1 + 1))
-    end)
-  end
-
-  defp compute_codebase_directions(codebase) do
-    base_agg = get_in(codebase, ["base", "aggregate"]) || %{}
-    delta_agg = get_in(codebase, ["delta", "aggregate"]) || %{}
-
-    Map.new(@codebase_direction_metrics, fn {dir_key, metric, agg_key} ->
-      base_val = get_in(base_agg, [metric, agg_key])
-      delta_val = get_in(delta_agg, [metric, agg_key])
-      {dir_key, classify_change(base_val, delta_val)}
-    end)
-  end
-
-  defp compute_file_directions(file_data) do
-    base_metrics = get_in(file_data, ["base", "metrics"]) || %{}
-    delta_metrics = get_in(file_data, ["delta", "metrics"]) || %{}
-
-    Map.new(@file_direction_metrics, fn {dir_key, metric, key} ->
-      base_val = get_in(base_metrics, [metric, key])
-      delta_val = get_in(delta_metrics, [metric, key])
-      {dir_key, classify_change(base_val, delta_val)}
-    end)
-  end
-
-  defp classify_change(nil, _), do: "stable"
-  defp classify_change(_, nil), do: "stable"
-  defp classify_change(0, _), do: "stable"
-  defp classify_change(+0.0, _), do: "stable"
-
-  defp classify_change(base_val, delta_val) do
-    ratio = abs(delta_val) / abs(base_val)
-
-    cond do
-      ratio < @threshold_stable -> "stable"
-      ratio < @threshold_slight and delta_val > 0 -> "increased slightly"
-      ratio < @threshold_slight -> "decreased slightly"
-      delta_val > 0 -> "increased"
-      true -> "decreased"
-    end
-  end
-
-  defp build_file_gist(directions) do
-    parts =
-      directions
-      |> Enum.reject(fn {_, d} -> d == "stable" end)
-      |> Enum.map(fn {k, d} -> "#{k} #{d}" end)
-
-    if parts == [], do: "all metrics stable", else: Enum.join(parts, ", ")
-  end
-
-  defp build_codebase_gist(file_counts, directions) do
-    file_parts =
-      [
-        {"added", file_counts["added"]},
-        {"modified", file_counts["modified"]},
-        {"deleted", file_counts["deleted"]}
-      ]
-      |> Enum.filter(fn {_, c} -> c > 0 end)
-      |> Enum.map(fn {s, c} -> "#{c} #{s}" end)
-
-    file_summary = if file_parts == [], do: "no changes", else: Enum.join(file_parts, ", ")
-
-    dir_parts =
-      directions
-      |> Enum.reject(fn {_, d} -> d == "stable" end)
-      |> Enum.map(fn {k, d} -> "#{k} #{d}" end)
-
-    if dir_parts == [] do
-      "#{file_summary} — all metrics stable"
-    else
-      "#{file_summary} — #{Enum.join(dir_parts, ", ")}"
-    end
-  end
-end
diff --git a/test/codeqa/cli_compare_test.exs b/test/codeqa/cli_compare_test.exs
deleted file mode 100644
index b39e2c2..0000000
--- a/test/codeqa/cli_compare_test.exs
+++ /dev/null
@@ -1,91 +0,0 @@
-defmodule CodeQA.CLI.CompareTest do
-  use ExUnit.Case, async: true
-
-  @moduletag :tmp_dir
-
-  setup %{tmp_dir: tmp_dir} do
-    # Initialize a git repo with one source file and one non-source file
-    System.cmd("git", ["init"], cd: tmp_dir)
-    System.cmd("git", ["config", "user.email", "test@test.com"], cd: tmp_dir)
-    System.cmd("git", ["config", "user.name", "Test"], cd: tmp_dir)
-
-    File.mkdir_p!(Path.join(tmp_dir, "lib"))
-    File.write!(Path.join(tmp_dir, "lib/app.ex"), "defmodule App do\nend")
-    System.cmd("git", ["add", "."], cd: tmp_dir)
-    System.cmd("git", ["commit", "-m", "initial"], cd: tmp_dir)
-
-    %{repo: tmp_dir}
-  end
-
-  describe "compare with github format" do
-    test "file changes section shows actual file count when source files changed", %{repo: repo} do
-      File.write!(Path.join(repo, "lib/app.ex"), """
-      defmodule App do
-        def hello, do: :world
-        def goodbye, do: :world
-      end
-      """)
-
-      System.cmd("git", ["add", "."], cd: repo)
-      System.cmd("git", ["commit", "-m", "update app"], cd: repo)
-
-      stdout = CodeQA.CLI.main(["compare", repo, "--base-ref", "HEAD~1", "--format", "github"])
-
-      assert stdout =~ "File changes — 1 modified"
-      refute stdout =~ "File changes — no changes"
-    end
-  end
-
-  describe "compare with no source file changes" do
-    test "exits 0 when only non-source files changed", %{repo: repo} do
-      # Create a branch, change only a .md file (not a source file)
-      File.write!(Path.join(repo, "README.txt"), "hello")
-      System.cmd("git", ["add", "."], cd: repo)
-      System.cmd("git", ["commit", "-m", "add readme"], cd: repo)
-
-      # compare should succeed (not crash) when no source files changed
-      {base_ref, head_ref} = {"HEAD~1", "HEAD"}
-
-      changes = CodeQA.Git.changed_files(repo, base_ref, head_ref)
-      assert changes == [], "expected no source file changes, got: #{inspect(changes)}"
-
-      # Verify the CLI handles this gracefully by calling main
-      stdout =
-        CodeQA.CLI.main([
-          "compare",
-          repo,
-          "--base-ref",
-          base_ref,
-          "--changes-only",
-          "--format",
-          "json"
-        ])
-
-      result = Jason.decode!(stdout)
-
-      assert result["metadata"]["total_files_compared"] == 0
-    end
-
-    test "outputs valid JSON with empty comparison", %{repo: repo} do
-      # Change only a non-source file
-      File.write!(Path.join(repo, "README.txt"), "hello")
-      System.cmd("git", ["add", "."], cd: repo)
-      System.cmd("git", ["commit", "-m", "add readme"], cd: repo)
-
-      # Assert on JSON return value directly
-      stdout =
-        CodeQA.CLI.main([
-          "compare",
-          repo,
-          "--base-ref",
-          "HEAD~1",
-          "--changes-only",
-          "--format",
-          "json"
-        ])
-
-      assert {:ok, result} = Jason.decode(stdout)
-      assert result["metadata"]["total_files_compared"] == 0
-    end
-  end
-end
diff --git a/test/codeqa/formatter_test.exs b/test/codeqa/formatter_test.exs
deleted file mode 100644
index de5be57..0000000
--- a/test/codeqa/formatter_test.exs
+++ /dev/null
@@ -1,150 +0,0 @@
-defmodule CodeQA.FormatterTest do
-  use ExUnit.Case, async: true
-
-  alias CodeQA.Formatter
-
-  @sample_comparison %{
-    "metadata" => %{
-      "total_files_compared" => 1,
-      "summary" => "1 modified",
-      "base_ref" => "abc123",
-      "head_ref" => "HEAD"
-    },
-    "files" => %{
-      "lib/foo.ex" => %{
-        "status" => "modified",
-        "base" => %{
-          "metrics" => %{"halstead" => %{"volume" => 1000.0}},
-          "lines" => 100,
-          "bytes" => 3000
-        },
-        "head" => %{
-          "metrics" => %{"halstead" => %{"volume" => 800.0}},
-          "lines" => 95,
-          "bytes" => 2800
-        },
-        "delta" => %{
-          "metrics" => %{"halstead" => %{"volume" => -200.0}},
-          "lines" => -5,
-          "bytes" => -200
-        }
-      }
-    },
-    "codebase" => %{
-      "base" => %{
-        "aggregate" => %{
-          "readability" => %{
-            "mean_flesch_adapted" => 65.0,
-            "mean_fog_adapted" => 8.0,
-            "mean_avg_tokens_per_line" => 7.0,
-            "mean_avg_line_length" => 45.0
-          },
-          "halstead" => %{
-            "mean_difficulty" => 15.0,
-            "mean_effort" => 8000.0,
-            "mean_volume" => 500.0,
-            "mean_estimated_bugs" => 0.2
-          }
-        }
-      },
-      "head" => %{
-        "aggregate" => %{
-          "readability" => %{
-            "mean_flesch_adapted" => 75.0,
-            "mean_fog_adapted" => 7.0,
-            "mean_avg_tokens_per_line" => 6.0,
-            "mean_avg_line_length" => 42.0
-          },
-          "halstead" => %{
-            "mean_difficulty" => 12.0,
-            "mean_effort" => 6000.0,
-            "mean_volume" => 400.0,
-            "mean_estimated_bugs" => 0.15
-          }
-        }
-      },
-      "delta" => %{
-        "aggregate" => %{
-          "readability" => %{
-            "mean_flesch_adapted" => 10.0,
-            "mean_fog_adapted" => -1.0,
-            "mean_avg_tokens_per_line" => -1.0,
-            "mean_avg_line_length" => -3.0
-          },
-          "halstead" => %{
-            "mean_difficulty" => -3.0,
-            "mean_effort" => -2000.0,
-            "mean_volume" => -100.0,
-            "mean_estimated_bugs" => -0.05
-          }
-        }
-      }
-    }
-  }
-
-  describe "format_github/1" do
-    test "includes mermaid chart of head scores" do
-      result = Formatter.format_github(@sample_comparison)
-      assert result =~ "```mermaid"
-      assert result =~ "xychart-beta"
-      assert result =~ "bar ["
-    end
-
-    test "includes progress bars with base → head" do
-      result = Formatter.format_github(@sample_comparison)
-      assert result =~ "→"
-    end
-
-    test "includes grade emoji" do
-      result = Formatter.format_github(@sample_comparison)
-      assert result =~ "🟢" or result =~ "🟡" or result =~ "🟠" or result =~ "🔴"
-    end
-
-    test "wraps file details in collapsible section" do
-      result = Formatter.format_github(@sample_comparison)
-      assert result =~ "<details>"
-      assert result =~ "</details>"
-    end
-
-    test "shows no changes message when zero files compared" do
-      comparison = put_in(@sample_comparison, ["metadata", "total_files_compared"], 0)
-      result = Formatter.format_github(comparison)
-      assert result =~ "No file changes detected"
-    end
-
-    test "shows 🟢 in aggregate delta for improving high-is-better metric" do
-      # flesch_adapted is good: :high, delta +10.0 → improvement
-      result = Formatter.format_github(@sample_comparison)
-      assert result =~ "🟢 +10.00"
-    end
-
-    test "file changes section shows actual file counts, not 'no changes'" do
-      result = Formatter.format_github(@sample_comparison)
-      assert result =~ "File changes — 1 modified"
-      refute result =~ "File changes — no changes"
-    end
-
-    test "file changes section reflects metric directions from codebase data" do
-      result = Formatter.format_github(@sample_comparison)
-
-      # halstead.mean_volume drops 100/500 = 20% → "decreased"; readability rises 10/65 ≈ 15% → "increased slightly"
-      refute result =~ "File changes — 1 modified — all metrics stable"
-    end
-
-    test "shows 🔴 in aggregate delta for worsening low-is-better metric" do
-      # halstead.volume is good: :low, delta +300 → regression
-      worsening =
-        put_in(
-          @sample_comparison,
-          ["codebase", "head", "aggregate", "halstead", "mean_volume"],
-          800.0
-        )
-        |> put_in(["codebase", "delta", "aggregate"], %{
-          "halstead" => %{"mean_volume" => 300.0}
-        })
-
-      result = Formatter.format_github(worsening)
-      assert result =~ "🔴 +300.00"
-    end
-  end
-end

From 1deed5aa047b4a9a1563043a17519fd7316a9eae Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 14:23:19 +0100
Subject: [PATCH 43/71] chore(quality): fix all credo and dialyzer issues
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add dialyzer ignores for Mix.Task PLT false positives and Engine.Registry unknown type
- Fix [W] warnings: length/1 comparisons → list equality, always-returns-left expressions
- Fix [F] refactoring: extract nested lambdas to helpers across ~20 files, merge double Enum.filter, swap negated conditions, replace Enum.map+join with Enum.map_join, split complex functions into clauses
- Fix [R] readability: add @moduledoc false to all 40 language modules, sort all alias blocks alphabetically, fix long lines and numeric underscore
- Fix [D] design: alias all inline module references throughout lib/ and test/

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .dialyzer_ignore.exs                          |  10 +-
 lib/codeqa/analysis/behavior_config_server.ex |  24 +-
 lib/codeqa/analysis/file_context_server.ex    |   8 +-
 .../ast/classification/node_classifier.ex     |  25 +-
 .../ast/classification/node_type_detector.ex  |   2 +-
 .../ast/enrichment/compound_node_builder.ex   |   6 +-
 lib/codeqa/ast/enrichment/node_analyzer.ex    |   2 +-
 lib/codeqa/ast/lexing/token_normalizer.ex     |  38 +--
 lib/codeqa/ast/nodes/attribute_node.ex        |   4 +-
 lib/codeqa/ast/nodes/code_node.ex             |   4 +-
 lib/codeqa/ast/nodes/doc_node.ex              |   4 +-
 lib/codeqa/ast/nodes/function_node.ex         |   4 +-
 lib/codeqa/ast/nodes/import_node.ex           |   4 +-
 lib/codeqa/ast/nodes/module_node.ex           |   4 +-
 lib/codeqa/ast/nodes/test_node.ex             |   4 +-
 lib/codeqa/ast/parsing/parser.ex              |   5 +-
 lib/codeqa/ast/parsing/signal_registry.ex     |   2 +-
 lib/codeqa/ast/parsing/signal_stream.ex       |  28 +-
 .../classification/attribute_signal.ex        |  30 +-
 .../classification/comment_density_signal.ex  |  15 +-
 .../signals/classification/config_signal.ex   |  16 +-
 .../signals/classification/function_signal.ex |  18 +-
 .../signals/classification/import_signal.ex   |  20 +-
 .../signals/classification/module_signal.ex   |  18 +-
 .../ast/signals/classification/test_signal.ex |  20 +-
 .../ast/signals/classification/type_signal.ex |  16 +-
 lib/codeqa/block_impact_analyzer.ex           |   3 -
 lib/codeqa/cli.ex                             |   3 +-
 lib/codeqa/cli/analyze.ex                     |  14 +-
 lib/codeqa/cli/correlate.ex                   |   3 +-
 lib/codeqa/cli/health_report.ex               |  24 +-
 lib/codeqa/cli/history.ex                     |  18 +-
 lib/codeqa/cli/options.ex                     |   5 +-
 lib/codeqa/cli/progress.ex                    |   6 +-
 lib/codeqa/combined_metrics/category.ex       |   4 +-
 lib/codeqa/combined_metrics/code_smells.ex    |   5 +-
 lib/codeqa/combined_metrics/consistency.ex    |   5 +-
 lib/codeqa/combined_metrics/dependencies.ex   |   5 +-
 lib/codeqa/combined_metrics/documentation.ex  |   5 +-
 lib/codeqa/combined_metrics/error_handling.ex |   5 +-
 lib/codeqa/combined_metrics/file_scorer.ex    |  14 +-
 lib/codeqa/combined_metrics/file_structure.ex |   5 +-
 .../combined_metrics/function_design.ex       |   5 +-
 .../combined_metrics/naming_conventions.ex    |   5 +-
 lib/codeqa/combined_metrics/sample_runner.ex  | 285 ++++++++++--------
 .../combined_metrics/scope_and_assignment.ex  |   5 +-
 lib/codeqa/combined_metrics/scorer.ex         |   4 +-
 lib/codeqa/combined_metrics/testing.ex        |   5 +-
 lib/codeqa/combined_metrics/type_and_value.ex |   5 +-
 .../combined_metrics/variable_naming.ex       |   5 +-
 lib/codeqa/diagnostics.ex                     |  38 ++-
 lib/codeqa/engine/analyzer.ex                 |  12 +-
 lib/codeqa/engine/parallel.ex                 |  10 +-
 lib/codeqa/git.ex                             |   4 +-
 lib/codeqa/health_report.ex                   |  26 +-
 lib/codeqa/health_report/formatter/github.ex  | 103 +++----
 lib/codeqa/health_report/formatter/plain.ex   |  68 ++---
 lib/codeqa/health_report/grader.ex            |  22 +-
 lib/codeqa/health_report/top_blocks.ex        |  21 +-
 lib/codeqa/languages/code/native/cpp.ex       |   1 +
 lib/codeqa/languages/code/native/go.ex        |   1 +
 lib/codeqa/languages/code/native/haskell.ex   |   1 +
 lib/codeqa/languages/code/native/ocaml.ex     |   1 +
 lib/codeqa/languages/code/native/rust.ex      |   1 +
 lib/codeqa/languages/code/native/swift.ex     |   1 +
 lib/codeqa/languages/code/native/zig.ex       |   1 +
 lib/codeqa/languages/code/scripting/julia.ex  |   1 +
 lib/codeqa/languages/code/scripting/lua.ex    |   1 +
 lib/codeqa/languages/code/scripting/perl.ex   |   1 +
 lib/codeqa/languages/code/scripting/php.ex    |   1 +
 lib/codeqa/languages/code/scripting/python.ex |   1 +
 lib/codeqa/languages/code/scripting/r.ex      |   1 +
 lib/codeqa/languages/code/scripting/ruby.ex   |   1 +
 lib/codeqa/languages/code/scripting/shell.ex  |   1 +
 lib/codeqa/languages/code/vm/clojure.ex       |   1 +
 lib/codeqa/languages/code/vm/csharp.ex        |   1 +
 lib/codeqa/languages/code/vm/dart.ex          |   1 +
 lib/codeqa/languages/code/vm/elixir.ex        |   1 +
 lib/codeqa/languages/code/vm/erlang.ex        |   1 +
 lib/codeqa/languages/code/vm/fsharp.ex        |   1 +
 lib/codeqa/languages/code/vm/java.ex          |   1 +
 lib/codeqa/languages/code/vm/kotlin.ex        |   1 +
 lib/codeqa/languages/code/vm/scala.ex         |   1 +
 lib/codeqa/languages/code/web/javascript.ex   |   1 +
 lib/codeqa/languages/code/web/typescript.ex   |   1 +
 lib/codeqa/languages/config/dockerfile.ex     |   1 +
 lib/codeqa/languages/config/makefile.ex       |   1 +
 lib/codeqa/languages/config/terraform.ex      |   1 +
 lib/codeqa/languages/data/graphql.ex          |   1 +
 lib/codeqa/languages/data/json.ex             |   1 +
 lib/codeqa/languages/data/sql.ex              |   1 +
 lib/codeqa/languages/data/toml.ex             |   1 +
 lib/codeqa/languages/data/yaml.ex             |   1 +
 lib/codeqa/languages/language.ex              |   3 +-
 lib/codeqa/languages/markup/css.ex            |   1 +
 lib/codeqa/languages/markup/html.ex           |   1 +
 lib/codeqa/languages/markup/markdown.ex       |   1 +
 lib/codeqa/languages/markup/xml.ex            |   1 +
 lib/codeqa/languages/unknown.ex               |   1 +
 lib/codeqa/metrics/codebase/similarity.ex     |  18 +-
 lib/codeqa/metrics/file/casing_entropy.ex     |   4 +-
 .../metrics/file/near_duplicate_blocks.ex     |  72 +++--
 .../metrics/post_processing/menzerath.ex      |  30 +-
 lib/mix/tasks/codeqa/sample_report.ex         |  46 +--
 priv/combined_metrics/code_smells.yml         |   5 +
 priv/combined_metrics/variable_naming.yml     |  14 +
 .../analysis/behavior_config_server_test.exs  |   2 +-
 .../analysis/file_metrics_server_test.exs     |   3 +-
 .../classification/node_classifier_test.exs   |  25 +-
 .../ast/classification/node_protocol_test.exs |   9 +-
 .../node_type_detector_test.exs               |  44 +--
 ...ompound_node_assertions_languages_test.exs |  10 +-
 .../enrichment/compound_node_builder_test.exs |   9 +-
 .../ast/lexing/token_normalizer_test.exs      |   4 +-
 .../codeqa/ast/lexing/token_protocol_test.exs |   2 +-
 test/codeqa/ast/nodes/code_node_test.exs      |   2 +-
 test/codeqa/ast/nodes/function_node_test.exs  |   2 +-
 test/codeqa/ast/nodes/import_node_test.exs    |   2 +-
 .../ast/parsing/parser_languages_test.exs     |  10 +-
 test/codeqa/ast/parsing/parser_test.exs       |   6 +-
 .../codeqa/ast/parsing/signal_stream_test.exs |   2 +-
 .../comment_density_signal_test.exs           |   2 +-
 .../classification/config_signal_test.exs     |   2 +-
 .../classification/data_signal_test.exs       |   2 +-
 .../classification/type_signal_test.exs       |   2 +-
 .../access_modifier_signal_test.exs           |   4 +-
 .../assignment_function_signal_test.exs       |   4 +-
 .../structural/blank_line_signal_test.exs     |   4 +-
 .../structural/bracket_signal_test.exs        |   4 +-
 .../structural/branch_split_signal_test.exs   |  10 +-
 .../structural/colon_indent_signal_test.exs   |   7 +-
 .../comment_divider_signal_test.exs           |   4 +-
 .../structural/decorator_signal_test.exs      |   4 +-
 .../structural/dedent_to_zero_signal_test.exs |   4 +-
 .../doc_comment_lead_signal_test.exs          |   4 +-
 .../structural/keyword_signal_test.exs        |   4 +-
 .../structural/sql_block_signal_test.exs      |   4 +-
 .../structural/triple_quote_signal_test.exs   |   4 +-
 .../block_impact/codebase_impact_test.exs     |   5 +-
 test/codeqa/block_impact/file_impact_test.exs |   2 +-
 .../refactoring_potentials_test.exs           |  21 +-
 test/codeqa/block_impact_analyzer_test.exs    |  11 +-
 .../combined_metrics/file_scorer_test.exs     |   2 +-
 .../combined_metrics/sample_runner_test.exs   |  19 +-
 test/codeqa/engine/analyzer_test.exs          |   8 +-
 test/codeqa/health_report/grader_test.exs     |  10 +-
 test/codeqa/health_report/top_blocks_test.exs |  22 +-
 test/codeqa/health_report_test.exs            |  51 ++--
 test/codeqa/metrics/file/bradford_test.exs    |   2 +-
 test/codeqa/metrics/file/branching_test.exs   |   2 +-
 test/codeqa/metrics/file/brevity_test.exs     |   2 +-
 .../metrics/file/function_metrics_test.exs    |   6 +-
 .../file/near_duplicate_blocks_file_test.exs  |   2 +-
 test/codeqa/metrics/file/rfc_test.exs         |   2 +-
 154 files changed, 977 insertions(+), 700 deletions(-)

diff --git a/.dialyzer_ignore.exs b/.dialyzer_ignore.exs
index b76a4d0..9722072 100644
--- a/.dialyzer_ignore.exs
+++ b/.dialyzer_ignore.exs
@@ -2,5 +2,13 @@
   # Dialyzer specializes analyze/2 for the codebase call-site where include_pairs
   # is always true, making the false branch appear unreachable. Both branches are
   # valid and reachable at runtime from the file-level and codebase callers.
-  {"lib/codeqa/metrics/file/near_duplicate_blocks.ex", :pattern_match}
+  {"lib/codeqa/metrics/file/near_duplicate_blocks.ex", :pattern_match},
+  # Mix module type information is not available in the PLT; these are valid
+  # Mix.Task callbacks and standard Mix module calls.
+  {"lib/mix/tasks/codeqa/sample_report.ex", :callback_info_missing},
+  {"lib/mix/tasks/codeqa/signal_debug.ex", :callback_info_missing},
+  {"lib/mix/tasks/codeqa/sample_report.ex", :unknown_function},
+  {"lib/mix/tasks/codeqa/signal_debug.ex", :unknown_function},
+  # CodeQA.Engine.Registry.t/0 is defined via a macro; type is available at runtime.
+  {"lib/codeqa/analysis/file_metrics_server.ex", :unknown_type}
 ]
diff --git a/lib/codeqa/analysis/behavior_config_server.ex b/lib/codeqa/analysis/behavior_config_server.ex
index f526b20..04cc9ba 100644
--- a/lib/codeqa/analysis/behavior_config_server.ex
+++ b/lib/codeqa/analysis/behavior_config_server.ex
@@ -85,23 +85,25 @@ defmodule CodeQA.Analysis.BehaviorConfigServer do
       {:ok, files} ->
         files
         |> Enum.filter(&String.ends_with?(&1, ".yml"))
-        |> Enum.each(fn yml_file ->
-          category = String.trim_trailing(yml_file, ".yml")
-          yaml_path = Path.join(@yaml_dir, yml_file)
-          {:ok, data} = YamlElixir.read_from_file(yaml_path)
-
-          data
-          |> Enum.filter(fn {_k, v} -> is_map(v) end)
-          |> Enum.each(fn {behavior, behavior_data} ->
-            :ets.insert(tid, {{category, behavior}, behavior_data})
-          end)
-        end)
+        |> Enum.each(&load_yml_file(&1, tid))
 
       {:error, _} ->
         :ok
     end
   end
 
+  defp load_yml_file(yml_file, tid) do
+    category = String.trim_trailing(yml_file, ".yml")
+    yaml_path = Path.join(@yaml_dir, yml_file)
+    {:ok, data} = YamlElixir.read_from_file(yaml_path)
+
+    data
+    |> Enum.filter(fn {_k, v} -> is_map(v) end)
+    |> Enum.each(fn {behavior, behavior_data} ->
+      :ets.insert(tid, {{category, behavior}, behavior_data})
+    end)
+  end
+
   @doc false
   def scalars_from_behavior_data(behavior_data) do
     behavior_data
diff --git a/lib/codeqa/analysis/file_context_server.ex b/lib/codeqa/analysis/file_context_server.ex
index 28f9670..3de7859 100644
--- a/lib/codeqa/analysis/file_context_server.ex
+++ b/lib/codeqa/analysis/file_context_server.ex
@@ -17,6 +17,8 @@ defmodule CodeQA.Analysis.FileContextServer do
   use GenServer
 
   alias CodeQA.Engine.{FileContext, Pipeline}
+  alias CodeQA.Language
+  alias CodeQA.Languages.Unknown
 
   # --- Public API ---
 
@@ -72,14 +74,14 @@ defmodule CodeQA.Analysis.FileContextServer do
   defp resolve_language_name(opts) do
     cond do
       lang = Keyword.get(opts, :language) ->
-        mod = CodeQA.Language.find(lang) || CodeQA.Languages.Unknown
+        mod = Language.find(lang) || Unknown
         mod.name()
 
       path = Keyword.get(opts, :path) ->
-        CodeQA.Language.detect(path).name()
+        Language.detect(path).name()
 
       true ->
-        CodeQA.Languages.Unknown.name()
+        Unknown.name()
     end
   end
 end
diff --git a/lib/codeqa/ast/classification/node_classifier.ex b/lib/codeqa/ast/classification/node_classifier.ex
index 57c559d..b6f20fa 100644
--- a/lib/codeqa/ast/classification/node_classifier.ex
+++ b/lib/codeqa/ast/classification/node_classifier.ex
@@ -35,27 +35,28 @@ defmodule CodeQA.AST.Classification.NodeClassifier do
   """
 
   alias CodeQA.AST.Enrichment.Node
-  alias CodeQA.AST.Parsing.SignalStream
-
-  alias CodeQA.AST.Signals.Classification.{
-    DocSignal,
-    AttributeSignal,
-    FunctionSignal,
-    ModuleSignal,
-    ImportSignal,
-    TestSignal
-  }
 
   alias CodeQA.AST.Nodes.{
+    AttributeNode,
     CodeNode,
     DocNode,
     FunctionNode,
-    ModuleNode,
     ImportNode,
-    AttributeNode,
+    ModuleNode,
     TestNode
   }
 
+  alias CodeQA.AST.Parsing.SignalStream
+
+  alias CodeQA.AST.Signals.Classification.{
+    AttributeSignal,
+    DocSignal,
+    FunctionSignal,
+    ImportSignal,
+    ModuleSignal,
+    TestSignal
+  }
+
   @classification_signals [
     %DocSignal{},
     %AttributeSignal{},
diff --git a/lib/codeqa/ast/classification/node_type_detector.ex b/lib/codeqa/ast/classification/node_type_detector.ex
index 6175968..5038371 100644
--- a/lib/codeqa/ast/classification/node_type_detector.ex
+++ b/lib/codeqa/ast/classification/node_type_detector.ex
@@ -7,8 +7,8 @@ defmodule CodeQA.AST.Classification.NodeTypeDetector do
   for the full list of signals and their weights.
   """
 
-  alias CodeQA.AST.Enrichment.Node
   alias CodeQA.AST.Classification.NodeClassifier
+  alias CodeQA.AST.Enrichment.Node
 
   @doc """
   Classify each node in the list into the most specific typed struct.
diff --git a/lib/codeqa/ast/enrichment/compound_node_builder.ex b/lib/codeqa/ast/enrichment/compound_node_builder.ex
index f446e72..27c6165 100644
--- a/lib/codeqa/ast/enrichment/compound_node_builder.ex
+++ b/lib/codeqa/ast/enrichment/compound_node_builder.ex
@@ -13,11 +13,11 @@ defmodule CodeQA.AST.Enrichment.CompoundNodeBuilder do
   promoted to the compound's `docs`/`typespecs` lists.
   """
 
-  alias CodeQA.AST.Enrichment.Node
-  alias CodeQA.AST.Enrichment.CompoundNode
   alias CodeQA.AST.Classification.NodeProtocol
-  alias CodeQA.AST.Nodes.{DocNode, AttributeNode}
+  alias CodeQA.AST.Enrichment.CompoundNode
+  alias CodeQA.AST.Enrichment.Node
   alias CodeQA.AST.Lexing.{NewlineToken, WhitespaceToken}
+  alias CodeQA.AST.Nodes.{AttributeNode, DocNode}
 
   @doc """
   Groups a list of typed nodes into CompoundNode structs.
diff --git a/lib/codeqa/ast/enrichment/node_analyzer.ex b/lib/codeqa/ast/enrichment/node_analyzer.ex
index d506d3d..2f6221c 100644
--- a/lib/codeqa/ast/enrichment/node_analyzer.ex
+++ b/lib/codeqa/ast/enrichment/node_analyzer.ex
@@ -7,8 +7,8 @@ defmodule CodeQA.AST.Enrichment.NodeAnalyzer do
   reference and should not appear in the node's domain fingerprint.
   """
 
-  alias CodeQA.AST.Lexing.Token
   alias CodeQA.AST.Lexing.NewlineToken
+  alias CodeQA.AST.Lexing.Token
 
   @doc """
   Returns a MapSet of lowercase identifier names that are locally bound
diff --git a/lib/codeqa/ast/lexing/token_normalizer.ex b/lib/codeqa/ast/lexing/token_normalizer.ex
index d2f0016..5cabba3 100644
--- a/lib/codeqa/ast/lexing/token_normalizer.ex
+++ b/lib/codeqa/ast/lexing/token_normalizer.ex
@@ -5,9 +5,9 @@ defmodule CodeQA.AST.Lexing.TokenNormalizer do
   See [lexical analysis](https://en.wikipedia.org/wiki/Lexical_analysis).
   """
 
-  alias CodeQA.AST.Lexing.Token
-  alias CodeQA.AST.Lexing.StringToken
   alias CodeQA.AST.Lexing.NewlineToken
+  alias CodeQA.AST.Lexing.StringToken
+  alias CodeQA.AST.Lexing.Token
   alias CodeQA.AST.Lexing.WhitespaceToken
 
   @doc """
@@ -28,24 +28,28 @@ defmodule CodeQA.AST.Lexing.TokenNormalizer do
     lines
     |> Enum.with_index()
     |> Enum.flat_map(fn {line, idx} ->
-      line_num = idx + 1
-      {tokens, last_token} = tokenize_line(line, line_num)
-
-      if idx < last_idx do
-        # last_token is tracked during scanning — O(1) vs List.last/1 which is O(N).
-        nl_col =
-          case last_token do
-            nil -> 0
-            t -> t.col + String.length(t.content)
-          end
-
-        tokens ++ [%NewlineToken{content: "\n", line: line_num, col: nl_col}]
-      else
-        tokens
-      end
+      tokens_with_newline(line, idx, last_idx)
     end)
   end
 
+  defp tokens_with_newline(line, idx, last_idx) do
+    line_num = idx + 1
+    {tokens, last_token} = tokenize_line(line, line_num)
+
+    if idx < last_idx do
+      # last_token is tracked during scanning — O(1) vs List.last/1 which is O(N).
+      nl_col =
+        case last_token do
+          nil -> 0
+          t -> t.col + String.length(t.content)
+        end
+
+      tokens ++ [%NewlineToken{content: "\n", line: line_num, col: nl_col}]
+    else
+      tokens
+    end
+  end
+
   # Returns {tokens, last_token} where last_token is the final token on the line
   # (or nil for an empty line), allowing normalize_structural to compute nl_col
   # in O(1) without calling List.last/1.
diff --git a/lib/codeqa/ast/nodes/attribute_node.ex b/lib/codeqa/ast/nodes/attribute_node.ex
index dba171d..7dd106c 100644
--- a/lib/codeqa/ast/nodes/attribute_node.ex
+++ b/lib/codeqa/ast/nodes/attribute_node.ex
@@ -49,6 +49,8 @@ defmodule CodeQA.AST.Nodes.AttributeNode do
   end
 
   defimpl CodeQA.AST.Classification.NodeProtocol do
+    alias CodeQA.AST.Classification.NodeProtocol
+
     def tokens(n), do: n.tokens
     def line_count(n), do: n.line_count
     def children(n), do: n.children
@@ -59,7 +61,7 @@ defmodule CodeQA.AST.Nodes.AttributeNode do
     def flat_tokens(n) do
       if Enum.empty?(n.children),
         do: n.tokens,
-        else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+        else: Enum.flat_map(n.children, &NodeProtocol.flat_tokens/1)
     end
   end
 end
diff --git a/lib/codeqa/ast/nodes/code_node.ex b/lib/codeqa/ast/nodes/code_node.ex
index 1b26244..b7dfd9d 100644
--- a/lib/codeqa/ast/nodes/code_node.ex
+++ b/lib/codeqa/ast/nodes/code_node.ex
@@ -28,6 +28,8 @@ defmodule CodeQA.AST.Nodes.CodeNode do
   end
 
   defimpl CodeQA.AST.Classification.NodeProtocol do
+    alias CodeQA.AST.Classification.NodeProtocol
+
     def tokens(n), do: n.tokens
     def line_count(n), do: n.line_count
     def children(n), do: n.children
@@ -38,7 +40,7 @@ defmodule CodeQA.AST.Nodes.CodeNode do
     def flat_tokens(n) do
       if Enum.empty?(n.children),
         do: n.tokens,
-        else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+        else: Enum.flat_map(n.children, &NodeProtocol.flat_tokens/1)
     end
   end
 end
diff --git a/lib/codeqa/ast/nodes/doc_node.ex b/lib/codeqa/ast/nodes/doc_node.ex
index 2b6dbfd..5e011ca 100644
--- a/lib/codeqa/ast/nodes/doc_node.ex
+++ b/lib/codeqa/ast/nodes/doc_node.ex
@@ -28,6 +28,8 @@ defmodule CodeQA.AST.Nodes.DocNode do
   end
 
   defimpl CodeQA.AST.Classification.NodeProtocol do
+    alias CodeQA.AST.Classification.NodeProtocol
+
     def tokens(n), do: n.tokens
     def line_count(n), do: n.line_count
     def children(n), do: n.children
@@ -38,7 +40,7 @@ defmodule CodeQA.AST.Nodes.DocNode do
     def flat_tokens(n) do
       if Enum.empty?(n.children),
         do: n.tokens,
-        else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+        else: Enum.flat_map(n.children, &NodeProtocol.flat_tokens/1)
     end
   end
 end
diff --git a/lib/codeqa/ast/nodes/function_node.ex b/lib/codeqa/ast/nodes/function_node.ex
index 6d91c88..48c6a5d 100644
--- a/lib/codeqa/ast/nodes/function_node.ex
+++ b/lib/codeqa/ast/nodes/function_node.ex
@@ -41,6 +41,8 @@ defmodule CodeQA.AST.Nodes.FunctionNode do
   end
 
   defimpl CodeQA.AST.Classification.NodeProtocol do
+    alias CodeQA.AST.Classification.NodeProtocol
+
     def tokens(n), do: n.tokens
     def line_count(n), do: n.line_count
     def children(n), do: n.children
@@ -51,7 +53,7 @@ defmodule CodeQA.AST.Nodes.FunctionNode do
     def flat_tokens(n) do
       if Enum.empty?(n.children),
         do: n.tokens,
-        else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+        else: Enum.flat_map(n.children, &NodeProtocol.flat_tokens/1)
     end
   end
 end
diff --git a/lib/codeqa/ast/nodes/import_node.ex b/lib/codeqa/ast/nodes/import_node.ex
index 999013d..3730370 100644
--- a/lib/codeqa/ast/nodes/import_node.ex
+++ b/lib/codeqa/ast/nodes/import_node.ex
@@ -29,6 +29,8 @@ defmodule CodeQA.AST.Nodes.ImportNode do
   end
 
   defimpl CodeQA.AST.Classification.NodeProtocol do
+    alias CodeQA.AST.Classification.NodeProtocol
+
     def tokens(n), do: n.tokens
     def line_count(n), do: n.line_count
     def children(n), do: n.children
@@ -39,7 +41,7 @@ defmodule CodeQA.AST.Nodes.ImportNode do
     def flat_tokens(n) do
       if Enum.empty?(n.children),
         do: n.tokens,
-        else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+        else: Enum.flat_map(n.children, &NodeProtocol.flat_tokens/1)
     end
   end
 end
diff --git a/lib/codeqa/ast/nodes/module_node.ex b/lib/codeqa/ast/nodes/module_node.ex
index 9ad3efb..c8d5072 100644
--- a/lib/codeqa/ast/nodes/module_node.ex
+++ b/lib/codeqa/ast/nodes/module_node.ex
@@ -30,6 +30,8 @@ defmodule CodeQA.AST.Nodes.ModuleNode do
   end
 
   defimpl CodeQA.AST.Classification.NodeProtocol do
+    alias CodeQA.AST.Classification.NodeProtocol
+
     def tokens(n), do: n.tokens
     def line_count(n), do: n.line_count
     def children(n), do: n.children
@@ -40,7 +42,7 @@ defmodule CodeQA.AST.Nodes.ModuleNode do
     def flat_tokens(n) do
       if Enum.empty?(n.children),
         do: n.tokens,
-        else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+        else: Enum.flat_map(n.children, &NodeProtocol.flat_tokens/1)
     end
   end
 end
diff --git a/lib/codeqa/ast/nodes/test_node.ex b/lib/codeqa/ast/nodes/test_node.ex
index 4fc955c..b3460cf 100644
--- a/lib/codeqa/ast/nodes/test_node.ex
+++ b/lib/codeqa/ast/nodes/test_node.ex
@@ -29,6 +29,8 @@ defmodule CodeQA.AST.Nodes.TestNode do
   end
 
   defimpl CodeQA.AST.Classification.NodeProtocol do
+    alias CodeQA.AST.Classification.NodeProtocol
+
     def tokens(n), do: n.tokens
     def line_count(n), do: n.line_count
     def children(n), do: n.children
@@ -39,7 +41,7 @@ defmodule CodeQA.AST.Nodes.TestNode do
     def flat_tokens(n) do
       if Enum.empty?(n.children),
         do: n.tokens,
-        else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+        else: Enum.flat_map(n.children, &NodeProtocol.flat_tokens/1)
     end
   end
 end
diff --git a/lib/codeqa/ast/parsing/parser.ex b/lib/codeqa/ast/parsing/parser.ex
index cb23a91..2615bb9 100644
--- a/lib/codeqa/ast/parsing/parser.ex
+++ b/lib/codeqa/ast/parsing/parser.ex
@@ -34,9 +34,8 @@ defmodule CodeQA.AST.Parsing.Parser do
   """
 
   alias CodeQA.AST.Enrichment.Node
-  alias CodeQA.AST.Parsing.SignalStream
-  alias CodeQA.Language
   alias CodeQA.AST.Lexing.{NewlineToken, WhitespaceToken}
+  alias CodeQA.AST.Parsing.SignalStream
 
   alias CodeQA.AST.Signals.Structural.{
     BlankLineSignal,
@@ -46,6 +45,8 @@ defmodule CodeQA.AST.Parsing.Parser do
     TripleQuoteSignal
   }
 
+  alias CodeQA.Language
+
   @spec detect_blocks([CodeQA.AST.Lexing.Token.t()], module()) :: [Node.t()]
   def detect_blocks([], _lang_mod), do: []
 
diff --git a/lib/codeqa/ast/parsing/signal_registry.ex b/lib/codeqa/ast/parsing/signal_registry.ex
index 555de16..0f4a752 100644
--- a/lib/codeqa/ast/parsing/signal_registry.ex
+++ b/lib/codeqa/ast/parsing/signal_registry.ex
@@ -11,8 +11,8 @@ defmodule CodeQA.AST.Parsing.SignalRegistry do
     AccessModifierSignal,
     AssignmentFunctionSignal,
     BlankLineSignal,
-    BranchSplitSignal,
     BracketSignal,
+    BranchSplitSignal,
     ColonIndentSignal,
     CommentDividerSignal,
     DecoratorSignal,
diff --git a/lib/codeqa/ast/parsing/signal_stream.ex b/lib/codeqa/ast/parsing/signal_stream.ex
index 935cbc2..8b6f451 100644
--- a/lib/codeqa/ast/parsing/signal_stream.ex
+++ b/lib/codeqa/ast/parsing/signal_stream.ex
@@ -34,21 +34,25 @@ defmodule CodeQA.AST.Parsing.SignalStream do
 
       {_final_state, emissions} =
         Enum.reduce_while(triples, {init_state, []}, fn triple, {state, acc} ->
-          {emitted, new_state} = Signal.emit(signal, triple, state)
-
-          new_acc =
-            emitted
-            |> Enum.map(fn {name, value} -> {source, group, name, value} end)
-            |> Enum.reduce(acc, fn e, a -> [e | a] end)
-
-          if new_state == :halt do
-            {:halt, {new_state, new_acc}}
-          else
-            {:cont, {new_state, new_acc}}
-          end
+          emit_step(signal, triple, state, acc, source, group)
         end)
 
       Enum.reverse(emissions)
     end)
   end
+
+  defp emit_step(signal, triple, state, acc, source, group) do
+    {emitted, new_state} = Signal.emit(signal, triple, state)
+
+    new_acc =
+      emitted
+      |> Enum.map(fn {name, value} -> {source, group, name, value} end)
+      |> Enum.reduce(acc, fn e, a -> [e | a] end)
+
+    if new_state == :halt do
+      {:halt, {new_state, new_acc}}
+    else
+      {:cont, {new_state, new_acc}}
+    end
+  end
 end
diff --git a/lib/codeqa/ast/signals/classification/attribute_signal.ex b/lib/codeqa/ast/signals/classification/attribute_signal.ex
index 18a52cd..aaaa640 100644
--- a/lib/codeqa/ast/signals/classification/attribute_signal.ex
+++ b/lib/codeqa/ast/signals/classification/attribute_signal.ex
@@ -42,24 +42,26 @@ defmodule CodeQA.AST.Signals.Classification.AttributeSignal do
           {MapSet.new(), %{state | saw_at: true, at_line_start: false}}
 
         "<ID>" when saw_at ->
-          name = token.content
+          emit_attribute(token.content, state)
 
-          cond do
-            MapSet.member?(@skip_attrs, name) ->
-              # @doc/@moduledoc: let DocSignal handle via <DOC> tokens
-              {MapSet.new(), %{state | saw_at: false, at_line_start: false, voted: true}}
+        _ ->
+          {MapSet.new(), %{state | saw_at: false, at_line_start: false}}
+      end
+    end
 
-            MapSet.member?(@typespec_attrs, name) ->
-              {MapSet.new([{:attribute_vote, 3}]),
-               %{state | saw_at: false, at_line_start: false, voted: true}}
+    defp emit_attribute(name, state) do
+      base_state = %{state | saw_at: false, at_line_start: false, voted: true}
 
-            true ->
-              {MapSet.new([{:attribute_vote, 2}]),
-               %{state | saw_at: false, at_line_start: false, voted: true}}
-          end
+      cond do
+        MapSet.member?(@skip_attrs, name) ->
+          # @doc/@moduledoc: let DocSignal handle via <DOC> tokens
+          {MapSet.new(), base_state}
 
-        _ ->
-          {MapSet.new(), %{state | saw_at: false, at_line_start: false}}
+        MapSet.member?(@typespec_attrs, name) ->
+          {MapSet.new([{:attribute_vote, 3}]), base_state}
+
+        true ->
+          {MapSet.new([{:attribute_vote, 2}]), base_state}
       end
     end
   end
diff --git a/lib/codeqa/ast/signals/classification/comment_density_signal.ex b/lib/codeqa/ast/signals/classification/comment_density_signal.ex
index cc3614f..ceb4c23 100644
--- a/lib/codeqa/ast/signals/classification/comment_density_signal.ex
+++ b/lib/codeqa/ast/signals/classification/comment_density_signal.ex
@@ -47,15 +47,18 @@ defmodule CodeQA.AST.Signals.Classification.CommentDensitySignal do
             %{state | at_line_start: false}
         end
 
-      if next == nil and map_size(prefixes) > 0 and state.total_lines > 0 do
-        if state.comment_lines / state.total_lines > 0.6 do
-          {MapSet.new([{:comment_vote, 2}]), :halt}
-        else
-          {MapSet.new(), state}
-        end
+      maybe_emit_vote(next, prefixes, state)
+    end
+
+    defp maybe_emit_vote(nil, prefixes, state)
+         when map_size(prefixes) > 0 and state.total_lines > 0 do
+      if state.comment_lines / state.total_lines > 0.6 do
+        {MapSet.new([{:comment_vote, 2}]), :halt}
       else
         {MapSet.new(), state}
       end
     end
+
+    defp maybe_emit_vote(_next, _prefixes, state), do: {MapSet.new(), state}
   end
 end
diff --git a/lib/codeqa/ast/signals/classification/config_signal.ex b/lib/codeqa/ast/signals/classification/config_signal.ex
index d6453b1..43b5872 100644
--- a/lib/codeqa/ast/signals/classification/config_signal.ex
+++ b/lib/codeqa/ast/signals/classification/config_signal.ex
@@ -42,12 +42,16 @@ defmodule CodeQA.AST.Signals.Classification.ConfigSignal do
            %{state | bracket_depth: max(0, bd - 1), at_line_start: false, is_first: false}}
 
         _ ->
-          if ind == 0 and bd == 0 and MapSet.member?(@config_keywords, token.content) do
-            weight = if first, do: 3, else: 1
-            {MapSet.new([{:config_vote, weight}]), :halt}
-          else
-            {MapSet.new(), %{state | at_line_start: false, is_first: false}}
-          end
+          emit_content_token(token, state, ind, bd, first)
+      end
+    end
+
+    defp emit_content_token(token, state, ind, bd, first) do
+      if ind == 0 and bd == 0 and MapSet.member?(@config_keywords, token.content) do
+        weight = if first, do: 3, else: 1
+        {MapSet.new([{:config_vote, weight}]), :halt}
+      else
+        {MapSet.new(), %{state | at_line_start: false, is_first: false}}
       end
     end
   end
diff --git a/lib/codeqa/ast/signals/classification/function_signal.ex b/lib/codeqa/ast/signals/classification/function_signal.ex
index ca261ce..62d3f48 100644
--- a/lib/codeqa/ast/signals/classification/function_signal.ex
+++ b/lib/codeqa/ast/signals/classification/function_signal.ex
@@ -58,14 +58,18 @@ defmodule CodeQA.AST.Signals.Classification.FunctionSignal do
            %{state | bracket_depth: max(0, bd - 1), is_first: false, at_line_start: false}}
 
         _ ->
-          if ind == 0 and bd == 0 and MapSet.member?(state.keywords, token.content) do
-            weight = if first, do: 3, else: 1
+          emit_content_token(token, state, ind, bd, first)
+      end
+    end
+
+    defp emit_content_token(token, state, ind, bd, first) do
+      base_state = %{state | is_first: false, at_line_start: false}
 
-            {MapSet.new([{:function_vote, weight}]),
-             %{state | is_first: false, at_line_start: false, voted: true}}
-          else
-            {MapSet.new(), %{state | is_first: false, at_line_start: false}}
-          end
+      if ind == 0 and bd == 0 and MapSet.member?(state.keywords, token.content) do
+        weight = if first, do: 3, else: 1
+        {MapSet.new([{:function_vote, weight}]), %{base_state | voted: true}}
+      else
+        {MapSet.new(), base_state}
       end
     end
   end
diff --git a/lib/codeqa/ast/signals/classification/import_signal.ex b/lib/codeqa/ast/signals/classification/import_signal.ex
index b6ad524..e27ed8a 100644
--- a/lib/codeqa/ast/signals/classification/import_signal.ex
+++ b/lib/codeqa/ast/signals/classification/import_signal.ex
@@ -48,14 +48,18 @@ defmodule CodeQA.AST.Signals.Classification.ImportSignal do
           {MapSet.new(), state}
 
         _ ->
-          if ind == 0 and MapSet.member?(state.keywords, token.content) do
-            weight = if first, do: 3, else: 1
-
-            {MapSet.new([{:import_vote, weight}]),
-             %{state | is_first: false, at_line_start: false, voted: true}}
-          else
-            {MapSet.new(), %{state | is_first: false, at_line_start: false}}
-          end
+          emit_content_token(token, state, ind, first)
+      end
+    end
+
+    defp emit_content_token(token, state, ind, first) do
+      base_state = %{state | is_first: false, at_line_start: false}
+
+      if ind == 0 and MapSet.member?(state.keywords, token.content) do
+        weight = if first, do: 3, else: 1
+        {MapSet.new([{:import_vote, weight}]), %{base_state | voted: true}}
+      else
+        {MapSet.new(), base_state}
       end
     end
   end
diff --git a/lib/codeqa/ast/signals/classification/module_signal.ex b/lib/codeqa/ast/signals/classification/module_signal.ex
index e58a150..4e9ca98 100644
--- a/lib/codeqa/ast/signals/classification/module_signal.ex
+++ b/lib/codeqa/ast/signals/classification/module_signal.ex
@@ -57,14 +57,18 @@ defmodule CodeQA.AST.Signals.Classification.ModuleSignal do
            %{state | bracket_depth: max(0, bd - 1), is_first: false, at_line_start: false}}
 
         _ ->
-          if ind == 0 and bd == 0 and MapSet.member?(state.keywords, token.content) do
-            weight = if first, do: 3, else: 1
+          emit_content_token(token, state, ind, bd, first)
+      end
+    end
+
+    defp emit_content_token(token, state, ind, bd, first) do
+      base_state = %{state | is_first: false, at_line_start: false}
 
-            {MapSet.new([{:module_vote, weight}]),
-             %{state | is_first: false, at_line_start: false, voted: true}}
-          else
-            {MapSet.new(), %{state | is_first: false, at_line_start: false}}
-          end
+      if ind == 0 and bd == 0 and MapSet.member?(state.keywords, token.content) do
+        weight = if first, do: 3, else: 1
+        {MapSet.new([{:module_vote, weight}]), %{base_state | voted: true}}
+      else
+        {MapSet.new(), base_state}
       end
     end
   end
diff --git a/lib/codeqa/ast/signals/classification/test_signal.ex b/lib/codeqa/ast/signals/classification/test_signal.ex
index b9d5a8c..de6abe5 100644
--- a/lib/codeqa/ast/signals/classification/test_signal.ex
+++ b/lib/codeqa/ast/signals/classification/test_signal.ex
@@ -49,14 +49,18 @@ defmodule CodeQA.AST.Signals.Classification.TestSignal do
           {MapSet.new(), state}
 
         _ ->
-          if ind == 0 and MapSet.member?(state.keywords, token.content) do
-            weight = if first, do: 3, else: 1
-
-            {MapSet.new([{:test_vote, weight}]),
-             %{state | is_first: false, at_line_start: false, voted: true}}
-          else
-            {MapSet.new(), %{state | is_first: false, at_line_start: false}}
-          end
+          emit_content_token(token, state, ind, first)
+      end
+    end
+
+    defp emit_content_token(token, state, ind, first) do
+      base_state = %{state | is_first: false, at_line_start: false}
+
+      if ind == 0 and MapSet.member?(state.keywords, token.content) do
+        weight = if first, do: 3, else: 1
+        {MapSet.new([{:test_vote, weight}]), %{base_state | voted: true}}
+      else
+        {MapSet.new(), base_state}
       end
     end
   end
diff --git a/lib/codeqa/ast/signals/classification/type_signal.ex b/lib/codeqa/ast/signals/classification/type_signal.ex
index 0acf6ad..fc4440f 100644
--- a/lib/codeqa/ast/signals/classification/type_signal.ex
+++ b/lib/codeqa/ast/signals/classification/type_signal.ex
@@ -34,16 +34,20 @@ defmodule CodeQA.AST.Signals.Classification.TypeSignal do
           {MapSet.new(), %{state | saw_at: true, at_line_start: false}}
 
         _ when state.saw_at and state.indent == 0 ->
-          if MapSet.member?(@type_attrs, token.content) do
-            weight = if state.is_first, do: 3, else: 1
-            {MapSet.new([{:type_vote, weight}]), :halt}
-          else
-            {MapSet.new(), %{state | saw_at: false, is_first: false, at_line_start: false}}
-          end
+          emit_after_at(token, state)
 
         _ ->
           {MapSet.new(), %{state | saw_at: false, is_first: false, at_line_start: false}}
       end
     end
+
+    defp emit_after_at(token, state) do
+      if MapSet.member?(@type_attrs, token.content) do
+        weight = if state.is_first, do: 3, else: 1
+        {MapSet.new([{:type_vote, weight}]), :halt}
+      else
+        {MapSet.new(), %{state | saw_at: false, is_first: false, at_line_start: false}}
+      end
+    end
   end
 end
diff --git a/lib/codeqa/block_impact_analyzer.ex b/lib/codeqa/block_impact_analyzer.ex
index 4f62549..de00e02 100644
--- a/lib/codeqa/block_impact_analyzer.ex
+++ b/lib/codeqa/block_impact_analyzer.ex
@@ -104,7 +104,6 @@ defmodule CodeQA.BlockImpactAnalyzer do
         serialize_node(
           node,
           path,
-          content,
           root_tokens,
           baseline_file_cosines,
           file_results,
@@ -120,7 +119,6 @@ defmodule CodeQA.BlockImpactAnalyzer do
   defp serialize_node(
          node,
          path,
-         content,
          root_tokens,
          baseline_file_cosines,
          file_results,
@@ -150,7 +148,6 @@ defmodule CodeQA.BlockImpactAnalyzer do
         serialize_node(
           child,
           path,
-          content,
           root_tokens,
           baseline_file_cosines,
           file_results,
diff --git a/lib/codeqa/cli.ex b/lib/codeqa/cli.ex
index fcb8e01..3e36d57 100644
--- a/lib/codeqa/cli.ex
+++ b/lib/codeqa/cli.ex
@@ -27,8 +27,7 @@ defmodule CodeQA.CLI do
     command_usages =
       @commands
       |> Enum.sort_by(fn {name, _} -> name end)
-      |> Enum.map(fn {_name, mod} -> mod.usage() end)
-      |> Enum.join("\n")
+      |> Enum.map_join("\n", fn {_name, mod} -> mod.usage() end)
 
     "Usage: codeqa <command> [options]\n\n" <> command_usages
   end
diff --git a/lib/codeqa/cli/analyze.ex b/lib/codeqa/cli/analyze.ex
index 81f4970..475e15c 100644
--- a/lib/codeqa/cli/analyze.ex
+++ b/lib/codeqa/cli/analyze.ex
@@ -3,7 +3,11 @@ defmodule CodeQA.CLI.Analyze do
 
   @behaviour CodeQA.CLI.Command
 
+  alias CodeQA.BlockImpactAnalyzer
   alias CodeQA.CLI.Options
+  alias CodeQA.Config
+  alias CodeQA.Engine.Analyzer
+  alias CodeQA.Engine.Collector
 
   @version "0.1.0"
 
@@ -40,10 +44,10 @@ defmodule CodeQA.CLI.Analyze do
       Options.parse(args, [output: :string], o: :output)
 
     Options.validate_dir!(path)
-    CodeQA.Config.load(path)
+    Config.load(path)
 
     files =
-      CodeQA.Engine.Collector.collect_files(path, Options.parse_ignore_paths(opts[:ignore_paths]))
+      Collector.collect_files(path, Options.parse_ignore_paths(opts[:ignore_paths]))
 
     if map_size(files) == 0 do
       IO.puts(:stderr, "Warning: no source files found in '#{path}'")
@@ -53,16 +57,16 @@ defmodule CodeQA.CLI.Analyze do
     print_progress(opts, files)
 
     analyze_opts =
-      Options.build_analyze_opts(opts) ++ CodeQA.Config.near_duplicate_blocks_opts()
+      Options.build_analyze_opts(opts) ++ Config.near_duplicate_blocks_opts()
 
     start_time = System.monotonic_time(:millisecond)
-    results = CodeQA.Engine.Analyzer.analyze_codebase(files, analyze_opts)
+    results = Analyzer.analyze_codebase(files, analyze_opts)
     end_time = System.monotonic_time(:millisecond)
 
     IO.puts(:stderr, "Analysis completed in #{end_time - start_time}ms")
 
     nodes_top = opts[:nodes_top] || 3
-    results = CodeQA.BlockImpactAnalyzer.analyze(results, files, nodes_top: nodes_top)
+    results = BlockImpactAnalyzer.analyze(results, files, nodes_top: nodes_top)
 
     total_bytes = results["files"] |> Map.values() |> Enum.map(& &1["bytes"]) |> Enum.sum()
     results = filter_files_for_output(results, opts, "json")
diff --git a/lib/codeqa/cli/correlate.ex b/lib/codeqa/cli/correlate.ex
index 5021842..c38a248 100644
--- a/lib/codeqa/cli/correlate.ex
+++ b/lib/codeqa/cli/correlate.ex
@@ -4,6 +4,7 @@ defmodule CodeQA.CLI.Correlate do
   @behaviour CodeQA.CLI.Command
 
   alias CodeQA.CLI.Options
+  alias CodeQA.CLI.UI
 
   @impl CodeQA.CLI.Command
   def usage do
@@ -266,7 +267,7 @@ defmodule CodeQA.CLI.Correlate do
       eta_ms = round((total_pairs - current) * avg_time)
 
       output =
-        CodeQA.CLI.UI.progress_bar(current, total_pairs, eta: CodeQA.CLI.UI.format_eta(eta_ms))
+        UI.progress_bar(current, total_pairs, eta: UI.format_eta(eta_ms))
 
       IO.write(:stderr, "\r" <> output)
       if current == total_pairs, do: IO.puts(:stderr, "")
diff --git a/lib/codeqa/cli/health_report.ex b/lib/codeqa/cli/health_report.ex
index 680bbbc..66b769d 100644
--- a/lib/codeqa/cli/health_report.ex
+++ b/lib/codeqa/cli/health_report.ex
@@ -3,7 +3,13 @@ defmodule CodeQA.CLI.HealthReport do
 
   @behaviour CodeQA.CLI.Command
 
+  alias CodeQA.BlockImpactAnalyzer
   alias CodeQA.CLI.Options
+  alias CodeQA.Config
+  alias CodeQA.Engine.Analyzer
+  alias CodeQA.Engine.Collector
+  alias CodeQA.Git
+  alias CodeQA.HealthReport
 
   @impl CodeQA.CLI.Command
   def usage do
@@ -54,7 +60,7 @@ defmodule CodeQA.CLI.HealthReport do
     head_ref = opts[:head_ref] || "HEAD"
 
     files =
-      CodeQA.Engine.Collector.collect_files(path, extra_ignore_patterns)
+      Collector.collect_files(path, extra_ignore_patterns)
 
     if map_size(files) == 0 do
       IO.puts(:stderr, "Warning: no source files found in '#{path}'")
@@ -64,16 +70,16 @@ defmodule CodeQA.CLI.HealthReport do
     IO.puts(:stderr, "Analyzing #{map_size(files)} files for health report...")
 
     analyze_opts =
-      Options.build_analyze_opts(opts) ++ CodeQA.Config.near_duplicate_blocks_opts()
+      Options.build_analyze_opts(opts) ++ Config.near_duplicate_blocks_opts()
 
     start_time = System.monotonic_time(:millisecond)
-    results = CodeQA.Engine.Analyzer.analyze_codebase(files, analyze_opts)
+    results = Analyzer.analyze_codebase(files, analyze_opts)
     end_time = System.monotonic_time(:millisecond)
 
     IO.puts(:stderr, "Analysis completed in #{end_time - start_time}ms")
 
     nodes_top = opts[:nodes_top] || 3
-    results = CodeQA.BlockImpactAnalyzer.analyze(results, files, nodes_top: nodes_top)
+    results = BlockImpactAnalyzer.analyze(results, files, nodes_top: nodes_top)
 
     total_bytes = results["files"] |> Map.values() |> Enum.map(& &1["bytes"]) |> Enum.sum()
 
@@ -88,11 +94,11 @@ defmodule CodeQA.CLI.HealthReport do
     {base_results, changed_files} =
       if base_ref do
         IO.puts(:stderr, "Collecting base snapshot at #{base_ref}...")
-        base_files = CodeQA.Git.collect_files_at_ref(path, base_ref)
-        changed = CodeQA.Git.changed_files(path, base_ref, head_ref)
+        base_files = Git.collect_files_at_ref(path, base_ref)
+        changed = Git.changed_files(path, base_ref, head_ref)
 
         IO.puts(:stderr, "Analyzing base snapshot (#{map_size(base_files)} files)...")
-        base_res = CodeQA.Engine.Analyzer.analyze_codebase(base_files, analyze_opts)
+        base_res = Analyzer.analyze_codebase(base_files, analyze_opts)
 
         {base_res, changed}
       else
@@ -104,7 +110,7 @@ defmodule CodeQA.CLI.HealthReport do
     top_n = opts[:top] || 5
 
     report =
-      CodeQA.HealthReport.generate(results,
+      HealthReport.generate(results,
         config: opts[:config],
         detail: detail,
         top: top_n,
@@ -112,7 +118,7 @@ defmodule CodeQA.CLI.HealthReport do
         changed_files: changed_files
       )
 
-    markdown = CodeQA.HealthReport.to_markdown(report, detail, format)
+    markdown = HealthReport.to_markdown(report, detail, format)
 
     case opts[:output] do
       nil ->
diff --git a/lib/codeqa/cli/history.ex b/lib/codeqa/cli/history.ex
index b24ea4c..ca40669 100644
--- a/lib/codeqa/cli/history.ex
+++ b/lib/codeqa/cli/history.ex
@@ -4,6 +4,11 @@ defmodule CodeQA.CLI.History do
   @behaviour CodeQA.CLI.Command
 
   alias CodeQA.CLI.Options
+  alias CodeQA.CLI.Progress
+  alias CodeQA.Config
+  alias CodeQA.Engine.Analyzer
+  alias CodeQA.Engine.Collector
+  alias CodeQA.Git
 
   @version "0.1.0"
 
@@ -58,10 +63,10 @@ defmodule CodeQA.CLI.History do
     commits = resolve_commits(opts, path)
     IO.puts(:stderr, "Found #{length(commits)} commits to analyze.")
 
-    CodeQA.Config.load(path)
+    Config.load(path)
 
     analyze_opts =
-      Options.build_analyze_opts(opts) ++ CodeQA.Config.near_duplicate_blocks_opts()
+      Options.build_analyze_opts(opts) ++ Config.near_duplicate_blocks_opts()
 
     ignore_patterns = Options.parse_ignore_paths(opts[:ignore_paths])
 
@@ -97,14 +102,13 @@ defmodule CodeQA.CLI.History do
     current_opts =
       if opts[:progress],
         do: [
-          {:on_progress,
-           fn c, t, p, _tt -> CodeQA.CLI.Progress.callback(c, t, p, start_time_progress) end}
+          {:on_progress, fn c, t, p, _tt -> Progress.callback(c, t, p, start_time_progress) end}
           | analyze_opts
         ],
         else: analyze_opts
 
-    files = CodeQA.Git.collect_files_at_ref(path, commit)
-    files = CodeQA.Engine.Collector.reject_ignored_map(files, ignore_patterns)
+    files = Git.collect_files_at_ref(path, commit)
+    files = Collector.reject_ignored_map(files, ignore_patterns)
 
     if map_size(files) == 0 do
       IO.puts(:stderr, "Warning: no source files found at commit #{commit}")
@@ -115,7 +119,7 @@ defmodule CodeQA.CLI.History do
 
   defp write_commit_result(commit, path, output_dir, files, analyze_opts) do
     start_time = System.monotonic_time(:millisecond)
-    results = CodeQA.Engine.Analyzer.analyze_codebase(files, analyze_opts)
+    results = Analyzer.analyze_codebase(files, analyze_opts)
     end_time = System.monotonic_time(:millisecond)
 
     IO.puts(:stderr, "  Analysis completed in #{end_time - start_time}ms")
diff --git a/lib/codeqa/cli/options.ex b/lib/codeqa/cli/options.ex
index 5003292..199a95d 100644
--- a/lib/codeqa/cli/options.ex
+++ b/lib/codeqa/cli/options.ex
@@ -1,6 +1,8 @@
 defmodule CodeQA.CLI.Options do
   @moduledoc false
 
+  alias CodeQA.CLI.Progress
+
   @common_strict [
     workers: :integer,
     cache: :boolean,
@@ -68,8 +70,7 @@ defmodule CodeQA.CLI.Options do
       [{:timeout, opts[:timeout] || 5000}]
       |> maybe_add(
         opts[:progress],
-        {:on_progress,
-         fn c, t, p, _tt -> CodeQA.CLI.Progress.callback(c, t, p, start_time_progress) end}
+        {:on_progress, fn c, t, p, _tt -> Progress.callback(c, t, p, start_time_progress) end}
       )
       |> maybe_add(opts[:cache], {:cache_dir, opts[:cache_dir] || ".codeqa_cache"})
       |> maybe_add(
diff --git a/lib/codeqa/cli/progress.ex b/lib/codeqa/cli/progress.ex
index 6ffdd14..aa09b05 100644
--- a/lib/codeqa/cli/progress.ex
+++ b/lib/codeqa/cli/progress.ex
@@ -1,6 +1,8 @@
 defmodule CodeQA.CLI.Progress do
   @moduledoc false
 
+  alias CodeQA.CLI.UI
+
   @spec callback(integer(), integer(), String.t(), integer()) :: :ok
   def callback(completed, total, path, start_time) do
     now = System.monotonic_time(:millisecond)
@@ -11,8 +13,8 @@ defmodule CodeQA.CLI.Progress do
     label = if String.length(path) > 30, do: "..." <> String.slice(path, -27..-1), else: path
 
     output =
-      CodeQA.CLI.UI.progress_bar(completed, total,
-        eta: CodeQA.CLI.UI.format_eta(eta_ms),
+      UI.progress_bar(completed, total,
+        eta: UI.format_eta(eta_ms),
         label: label
       )
 
diff --git a/lib/codeqa/combined_metrics/category.ex b/lib/codeqa/combined_metrics/category.ex
index 2467969..def09ad 100644
--- a/lib/codeqa/combined_metrics/category.ex
+++ b/lib/codeqa/combined_metrics/category.ex
@@ -22,6 +22,8 @@ defmodule CodeQA.CombinedMetrics.Category do
 
   defmacro __using__(yaml_path: yaml_path) do
     quote do
+      alias CodeQA.CombinedMetrics.Scorer
+
       @callback score(metrics :: map()) :: float()
 
       @doc """
@@ -31,7 +33,7 @@ defmodule CodeQA.CombinedMetrics.Category do
       """
       @spec compute_score(String.t(), map()) :: float()
       def compute_score(metric_name, metrics) do
-        CodeQA.CombinedMetrics.Scorer.compute_score(unquote(yaml_path), metric_name, metrics)
+        Scorer.compute_score(unquote(yaml_path), metric_name, metrics)
       end
     end
   end
diff --git a/lib/codeqa/combined_metrics/code_smells.ex b/lib/codeqa/combined_metrics/code_smells.ex
index 5b5678a..13586ba 100644
--- a/lib/codeqa/combined_metrics/code_smells.ex
+++ b/lib/codeqa/combined_metrics/code_smells.ex
@@ -17,12 +17,13 @@ defmodule CodeQA.CombinedMetrics.CodeSmells do
 
   for {key, doc} <- @behaviors do
     defmodule Module.concat(CodeQA.CombinedMetrics.CodeSmells, Macro.camelize(key)) do
+      alias CodeQA.CombinedMetrics.CodeSmells
       @moduledoc doc
-      @behaviour CodeQA.CombinedMetrics.CodeSmells
+      @behaviour CodeSmells
       @score_key key
       @impl true
       def score(metrics),
-        do: CodeQA.CombinedMetrics.CodeSmells.compute_score(@score_key, metrics)
+        do: CodeSmells.compute_score(@score_key, metrics)
     end
   end
 end
diff --git a/lib/codeqa/combined_metrics/consistency.ex b/lib/codeqa/combined_metrics/consistency.ex
index 6a1474e..1c4af0c 100644
--- a/lib/codeqa/combined_metrics/consistency.ex
+++ b/lib/codeqa/combined_metrics/consistency.ex
@@ -18,12 +18,13 @@ defmodule CodeQA.CombinedMetrics.Consistency do
 
   for {key, doc} <- @behaviors do
     defmodule Module.concat(CodeQA.CombinedMetrics.Consistency, Macro.camelize(key)) do
+      alias CodeQA.CombinedMetrics.Consistency
       @moduledoc doc
-      @behaviour CodeQA.CombinedMetrics.Consistency
+      @behaviour Consistency
       @score_key key
       @impl true
       def score(metrics),
-        do: CodeQA.CombinedMetrics.Consistency.compute_score(@score_key, metrics)
+        do: Consistency.compute_score(@score_key, metrics)
     end
   end
 end
diff --git a/lib/codeqa/combined_metrics/dependencies.ex b/lib/codeqa/combined_metrics/dependencies.ex
index 0cde033..f0b25aa 100644
--- a/lib/codeqa/combined_metrics/dependencies.ex
+++ b/lib/codeqa/combined_metrics/dependencies.ex
@@ -17,12 +17,13 @@ defmodule CodeQA.CombinedMetrics.Dependencies do
 
   for {key, doc} <- @behaviors do
     defmodule Module.concat(CodeQA.CombinedMetrics.Dependencies, Macro.camelize(key)) do
+      alias CodeQA.CombinedMetrics.Dependencies
       @moduledoc doc
-      @behaviour CodeQA.CombinedMetrics.Dependencies
+      @behaviour Dependencies
       @score_key key
       @impl true
       def score(metrics),
-        do: CodeQA.CombinedMetrics.Dependencies.compute_score(@score_key, metrics)
+        do: Dependencies.compute_score(@score_key, metrics)
     end
   end
 end
diff --git a/lib/codeqa/combined_metrics/documentation.ex b/lib/codeqa/combined_metrics/documentation.ex
index 31abd0e..94f8a95 100644
--- a/lib/codeqa/combined_metrics/documentation.ex
+++ b/lib/codeqa/combined_metrics/documentation.ex
@@ -17,12 +17,13 @@ defmodule CodeQA.CombinedMetrics.Documentation do
 
   for {key, doc} <- @behaviors do
     defmodule Module.concat(CodeQA.CombinedMetrics.Documentation, Macro.camelize(key)) do
+      alias CodeQA.CombinedMetrics.Documentation
       @moduledoc doc
-      @behaviour CodeQA.CombinedMetrics.Documentation
+      @behaviour Documentation
       @score_key key
       @impl true
       def score(metrics),
-        do: CodeQA.CombinedMetrics.Documentation.compute_score(@score_key, metrics)
+        do: Documentation.compute_score(@score_key, metrics)
     end
   end
 end
diff --git a/lib/codeqa/combined_metrics/error_handling.ex b/lib/codeqa/combined_metrics/error_handling.ex
index 62e2032..9039ef6 100644
--- a/lib/codeqa/combined_metrics/error_handling.ex
+++ b/lib/codeqa/combined_metrics/error_handling.ex
@@ -17,12 +17,13 @@ defmodule CodeQA.CombinedMetrics.ErrorHandling do
 
   for {key, doc} <- @behaviors do
     defmodule Module.concat(CodeQA.CombinedMetrics.ErrorHandling, Macro.camelize(key)) do
+      alias CodeQA.CombinedMetrics.ErrorHandling
       @moduledoc doc
-      @behaviour CodeQA.CombinedMetrics.ErrorHandling
+      @behaviour ErrorHandling
       @score_key key
       @impl true
       def score(metrics),
-        do: CodeQA.CombinedMetrics.ErrorHandling.compute_score(@score_key, metrics)
+        do: ErrorHandling.compute_score(@score_key, metrics)
     end
   end
 end
diff --git a/lib/codeqa/combined_metrics/file_scorer.ex b/lib/codeqa/combined_metrics/file_scorer.ex
index 4ea54b4..a35a473 100644
--- a/lib/codeqa/combined_metrics/file_scorer.ex
+++ b/lib/codeqa/combined_metrics/file_scorer.ex
@@ -7,6 +7,9 @@ defmodule CodeQA.CombinedMetrics.FileScorer do
   """
 
   alias CodeQA.CombinedMetrics.SampleRunner
+  alias CodeQA.Config
+  alias CodeQA.HealthReport.Grader
+  alias CodeQA.Language
 
   @doc """
   Converts a single file's raw metric map to aggregate format.
@@ -56,7 +59,10 @@ defmodule CodeQA.CombinedMetrics.FileScorer do
             ]
           }
   def worst_files_per_behavior(files_map, opts \\ []) do
-    # TODO(option-c): cosine similarity is computed at file level; a line-level mapping would require computing a separate cosine score for each AST node by projecting that node's metric vector against the behavior's feature-weight vector. This is not currently possible because serialized nodes do not carry their own metric values.
+    # NOTE: cosine similarity is computed at file level; a line-level mapping would require computing a separate
+    # cosine score for each AST node by projecting that node's metric vector against the behavior's
+    # feature-weight vector. This is not currently possible because serialized nodes do not carry their own
+    # metric values.
     top_n = Keyword.get(opts, :combined_top, 2)
 
     files_map
@@ -64,8 +70,8 @@ defmodule CodeQA.CombinedMetrics.FileScorer do
       file_data |> Map.get("metrics", %{}) |> map_size() == 0
     end)
     |> Enum.reduce(%{}, fn {path, file_data}, acc ->
-      top_nodes = CodeQA.HealthReport.Grader.top_3_nodes(Map.get(file_data, "nodes"))
-      language = CodeQA.Language.detect(path).name()
+      top_nodes = Grader.top_3_nodes(Map.get(file_data, "nodes"))
+      language = Language.detect(path).name()
 
       file_data
       |> Map.get("metrics", %{})
@@ -84,7 +90,7 @@ defmodule CodeQA.CombinedMetrics.FileScorer do
       end)
     end)
     |> Map.new(fn {key, entries} ->
-      threshold = CodeQA.Config.cosine_significance_threshold()
+      threshold = Config.cosine_significance_threshold()
 
       sorted =
         entries
diff --git a/lib/codeqa/combined_metrics/file_structure.ex b/lib/codeqa/combined_metrics/file_structure.ex
index 164d3c9..aa6f153 100644
--- a/lib/codeqa/combined_metrics/file_structure.ex
+++ b/lib/codeqa/combined_metrics/file_structure.ex
@@ -17,12 +17,13 @@ defmodule CodeQA.CombinedMetrics.FileStructure do
 
   for {key, doc} <- @behaviors do
     defmodule Module.concat(CodeQA.CombinedMetrics.FileStructure, Macro.camelize(key)) do
+      alias CodeQA.CombinedMetrics.FileStructure
       @moduledoc doc
-      @behaviour CodeQA.CombinedMetrics.FileStructure
+      @behaviour FileStructure
       @score_key key
       @impl true
       def score(metrics),
-        do: CodeQA.CombinedMetrics.FileStructure.compute_score(@score_key, metrics)
+        do: FileStructure.compute_score(@score_key, metrics)
     end
   end
 end
diff --git a/lib/codeqa/combined_metrics/function_design.ex b/lib/codeqa/combined_metrics/function_design.ex
index 3e2e5e9..3eab5f7 100644
--- a/lib/codeqa/combined_metrics/function_design.ex
+++ b/lib/codeqa/combined_metrics/function_design.ex
@@ -17,12 +17,13 @@ defmodule CodeQA.CombinedMetrics.FunctionDesign do
 
   for {key, doc} <- @behaviors do
     defmodule Module.concat(CodeQA.CombinedMetrics.FunctionDesign, Macro.camelize(key)) do
+      alias CodeQA.CombinedMetrics.FunctionDesign
       @moduledoc doc
-      @behaviour CodeQA.CombinedMetrics.FunctionDesign
+      @behaviour FunctionDesign
       @score_key key
       @impl true
       def score(metrics),
-        do: CodeQA.CombinedMetrics.FunctionDesign.compute_score(@score_key, metrics)
+        do: FunctionDesign.compute_score(@score_key, metrics)
     end
   end
 end
diff --git a/lib/codeqa/combined_metrics/naming_conventions.ex b/lib/codeqa/combined_metrics/naming_conventions.ex
index f463b85..eafb5dc 100644
--- a/lib/codeqa/combined_metrics/naming_conventions.ex
+++ b/lib/codeqa/combined_metrics/naming_conventions.ex
@@ -19,12 +19,13 @@ defmodule CodeQA.CombinedMetrics.NamingConventions do
 
   for {key, doc} <- @behaviors do
     defmodule Module.concat(CodeQA.CombinedMetrics.NamingConventions, Macro.camelize(key)) do
+      alias CodeQA.CombinedMetrics.NamingConventions
       @moduledoc doc
-      @behaviour CodeQA.CombinedMetrics.NamingConventions
+      @behaviour NamingConventions
       @score_key key
       @impl true
       def score(metrics),
-        do: CodeQA.CombinedMetrics.NamingConventions.compute_score(@score_key, metrics)
+        do: NamingConventions.compute_score(@score_key, metrics)
     end
   end
 end
diff --git a/lib/codeqa/combined_metrics/sample_runner.ex b/lib/codeqa/combined_metrics/sample_runner.ex
index bcf3375..76566d4 100644
--- a/lib/codeqa/combined_metrics/sample_runner.ex
+++ b/lib/codeqa/combined_metrics/sample_runner.ex
@@ -7,6 +7,8 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
   """
 
   alias CodeQA.CombinedMetrics.Scorer
+  alias CodeQA.Engine.Analyzer
+  alias CodeQA.Engine.Collector
 
   @samples_root "priv/combined_metrics/samples"
   @yaml_dir "priv/combined_metrics"
@@ -85,8 +87,8 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
 
   defp analyze(dir) do
     dir
-    |> CodeQA.Engine.Collector.collect_files()
-    |> CodeQA.Engine.Analyzer.analyze_codebase()
+    |> Collector.collect_files()
+    |> Analyzer.analyze_codebase()
     |> get_in(["codebase", "aggregate"])
   end
 
@@ -296,55 +298,15 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
       data
       |> Enum.filter(fn {_k, v} -> is_map(v) end)
       |> Enum.flat_map(fn {behavior, behavior_data} ->
-        behavior_langs = Map.get(behavior_data, "_languages", [])
-
-        if not behavior_language_applies?(behavior_langs, language, languages) do
-          []
-        else
-          scalars = Scorer.scalars_for(yaml_path, behavior)
-
-          if map_size(scalars) == 0 do
-            []
-          else
-            log_baseline = Map.get(behavior_data, "_log_baseline", 0.0) / 1.0
-
-            {dot, norm_s_sq, norm_v_sq, contributions} =
-              Enum.reduce(scalars, {0.0, 0.0, 0.0, []}, fn {{group, key}, scalar},
-                                                           {d, ns, nv, contribs} ->
-                log_m = :math.log(Scorer.get(aggregate, group, key))
-                contrib = scalar * log_m
-
-                {d + contrib, ns + scalar * scalar, nv + log_m * log_m,
-                 [{:"#{group}.#{key}", contrib} | contribs]}
-              end)
-
-            cos_sim =
-              if norm_s_sq > 0 and norm_v_sq > 0,
-                do: dot / (:math.sqrt(norm_s_sq) * :math.sqrt(norm_v_sq)),
-                else: 0.0
-
-            raw_score = Scorer.compute_score(yaml_path, behavior, aggregate)
-            calibrated = :math.log(max(raw_score, 1.0e-300)) - log_baseline
-
-            top_metrics =
-              contributions
-              |> Enum.sort_by(fn {_, c} -> c end)
-              |> Enum.take(5)
-              |> Enum.map(fn {metric, contribution} ->
-                %{metric: to_string(metric), contribution: Float.round(contribution, 4)}
-              end)
-
-            [
-              %{
-                category: category,
-                behavior: behavior,
-                cosine: Float.round(cos_sim, 4),
-                score: Float.round(calibrated, 4),
-                top_metrics: top_metrics
-              }
-            ]
-          end
-        end
+        maybe_score_behavior(
+          yaml_path,
+          behavior,
+          behavior_data,
+          aggregate,
+          category,
+          language,
+          languages
+        )
       end)
     end)
     |> Enum.sort_by(& &1.cosine)
@@ -370,9 +332,9 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
 
     @yaml_dir
     |> File.ls!()
-    |> Enum.filter(&String.ends_with?(&1, ".yml"))
     |> Enum.filter(fn yml_file ->
-      filter_category == nil or String.trim_trailing(yml_file, ".yml") == filter_category
+      String.ends_with?(yml_file, ".yml") and
+        (filter_category == nil or String.trim_trailing(yml_file, ".yml") == filter_category)
     end)
     |> Enum.sort()
     |> Enum.map(fn yml_file ->
@@ -401,23 +363,29 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
             {Map.put(acc_yaml, behavior, groups), Map.update!(stats, :skipped, &(&1 + 1))}
 
           metrics ->
-            {new_groups, log_baseline, n_updated, n_deadzoned} = groups_from_report(metrics)
-            # Fall back to current groups if everything was deadzoned
-            groups =
-              if(map_size(new_groups) > 0, do: new_groups, else: current_groups)
-              |> Map.put("_log_baseline", Float.round(log_baseline, 6))
-              |> maybe_put_doc(doc)
-
-            {Map.put(acc_yaml, behavior, groups),
-             %{
-               stats
-               | updated: stats.updated + n_updated,
-                 deadzoned: stats.deadzoned + n_deadzoned
-             }}
+            apply_metrics(acc_yaml, stats, behavior, current_groups, metrics, doc)
         end
     end)
   end
 
+  defp apply_metrics(acc_yaml, stats, behavior, current_groups, metrics, doc) do
+    {new_groups, log_baseline, n_updated, n_deadzoned} = groups_from_report(metrics)
+    # Fall back to current groups if everything was deadzoned
+    base_groups = if map_size(new_groups) > 0, do: new_groups, else: current_groups
+
+    groups =
+      base_groups
+      |> Map.put("_log_baseline", Float.round(log_baseline, 6))
+      |> maybe_put_doc(doc)
+
+    {Map.put(acc_yaml, behavior, groups),
+     %{
+       stats
+       | updated: stats.updated + n_updated,
+         deadzoned: stats.deadzoned + n_deadzoned
+     }}
+  end
+
   defp read_behavior_doc(category, behavior) do
     config_path = Path.join([@samples_root, category, behavior, "config.yml"])
 
@@ -444,24 +412,96 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
       if deadzone?(data.ratio) do
         {groups, log_baseline, n_updated, n_deadzoned + 1}
       else
-        new_groups =
-          Map.update(
-            groups,
-            group,
-            %{key => data.suggested_scalar},
-            &Map.put(&1, key, data.suggested_scalar)
-          )
-
-        # Baseline: expected log score at the geometric mean of good/bad sample values
-        geo_mean = :math.sqrt(max(data.bad, 1.0e-10) * max(data.good, 1.0e-10))
-        new_baseline = log_baseline + data.suggested_scalar * :math.log(geo_mean)
-        {new_groups, new_baseline, n_updated + 1, n_deadzoned}
+        accumulate_metric(groups, log_baseline, n_updated, n_deadzoned, group, key, data)
       end
     end)
   end
 
+  defp accumulate_metric(groups, log_baseline, n_updated, n_deadzoned, group, key, data) do
+    new_groups =
+      Map.update(
+        groups,
+        group,
+        %{key => data.suggested_scalar},
+        &Map.put(&1, key, data.suggested_scalar)
+      )
+
+    # Baseline: expected log score at the geometric mean of good/bad sample values
+    geo_mean = :math.sqrt(max(data.bad, 1.0e-10) * max(data.good, 1.0e-10))
+    new_baseline = log_baseline + data.suggested_scalar * :math.log(geo_mean)
+    {new_groups, new_baseline, n_updated + 1, n_deadzoned}
+  end
+
   defp deadzone?(ratio), do: ratio >= @deadzone_low and ratio <= @deadzone_high
 
+  defp maybe_score_behavior(
+         yaml_path,
+         behavior,
+         behavior_data,
+         aggregate,
+         category,
+         language,
+         languages
+       ) do
+    behavior_langs = Map.get(behavior_data, "_languages", [])
+
+    if behavior_language_applies?(behavior_langs, language, languages) do
+      score_behavior_cosine(yaml_path, behavior, behavior_data, aggregate, category)
+    else
+      []
+    end
+  end
+
+  defp score_behavior_cosine(yaml_path, behavior, behavior_data, aggregate, category) do
+    scalars = Scorer.scalars_for(yaml_path, behavior)
+
+    if map_size(scalars) == 0 do
+      []
+    else
+      build_cosine_result(yaml_path, behavior, behavior_data, aggregate, category, scalars)
+    end
+  end
+
+  defp build_cosine_result(yaml_path, behavior, behavior_data, aggregate, category, scalars) do
+    log_baseline = Map.get(behavior_data, "_log_baseline", 0.0) / 1.0
+
+    {dot, norm_s_sq, norm_v_sq, contributions} =
+      Enum.reduce(scalars, {0.0, 0.0, 0.0, []}, fn {{group, key}, scalar},
+                                                   {d, ns, nv, contribs} ->
+        log_m = :math.log(Scorer.get(aggregate, group, key))
+        contrib = scalar * log_m
+
+        {d + contrib, ns + scalar * scalar, nv + log_m * log_m,
+         [{:"#{group}.#{key}", contrib} | contribs]}
+      end)
+
+    cos_sim =
+      if norm_s_sq > 0 and norm_v_sq > 0,
+        do: dot / (:math.sqrt(norm_s_sq) * :math.sqrt(norm_v_sq)),
+        else: 0.0
+
+    raw_score = Scorer.compute_score(yaml_path, behavior, aggregate)
+    calibrated = :math.log(max(raw_score, 1.0e-300)) - log_baseline
+
+    top_metrics =
+      contributions
+      |> Enum.sort_by(fn {_, c} -> c end)
+      |> Enum.take(5)
+      |> Enum.map(fn {metric, contribution} ->
+        %{metric: to_string(metric), contribution: Float.round(contribution, 4)}
+      end)
+
+    [
+      %{
+        category: category,
+        behavior: behavior,
+        cosine: Float.round(cos_sim, 4),
+        score: Float.round(calibrated, 4),
+        top_metrics: top_metrics
+      }
+    ]
+  end
+
   # Returns true if the behavior should be included for the given language context.
   # behavior_langs: the "_languages" list from the YAML ([] = applies to all)
   # language: single language string from :language opt (nil = no filter)
@@ -488,54 +528,51 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
     lines =
       data
       |> Enum.sort_by(fn {behavior, _} -> behavior end)
-      |> Enum.flat_map(fn {behavior, groups} ->
-        doc_line =
-          case Map.get(groups, "_doc") do
-            nil -> []
-            doc -> ["  _doc: #{inspect(doc)}"]
-          end
-
-        baseline_line =
-          case Map.get(groups, "_log_baseline") do
-            nil -> []
-            val -> ["  _log_baseline: #{fmt_scalar(val)}"]
-          end
-
-        fix_hint_line =
-          case Map.get(groups, "_fix_hint") do
-            nil -> []
-            hint -> ["  _fix_hint: #{inspect(hint)}"]
-          end
-
-        languages_line =
-          case Map.get(groups, "_languages") do
-            nil -> []
-            [] -> []
-            langs -> ["  _languages: [#{Enum.join(langs, ", ")}]"]
-          end
-
-        group_lines =
-          groups
-          |> Enum.filter(fn {k, v} ->
-            k not in ["_doc", "_log_baseline", "_fix_hint", "_languages"] and is_map(v)
-          end)
-          |> Enum.sort_by(fn {group, _} -> group end)
-          |> Enum.flat_map(fn {group, keys} ->
-            key_lines =
-              keys
-              |> Enum.sort_by(fn {key, _} -> key end)
-              |> Enum.map(fn {key, scalar} -> "    #{key}: #{fmt_scalar(scalar)}" end)
-
-            ["  #{group}:" | key_lines]
-          end)
-
-        ["#{behavior}:" | doc_line] ++
-          fix_hint_line ++ languages_line ++ baseline_line ++ group_lines ++ [""]
-      end)
+      |> Enum.flat_map(fn {behavior, groups} -> format_behavior_lines(behavior, groups) end)
 
     Enum.join(lines, "\n") <> "\n"
   end
 
+  defp format_behavior_lines(behavior, groups) do
+    doc_line = yaml_doc_line(Map.get(groups, "_doc"))
+    baseline_line = yaml_baseline_line(Map.get(groups, "_log_baseline"))
+    fix_hint_line = yaml_fix_hint_line(Map.get(groups, "_fix_hint"))
+    languages_line = yaml_languages_line(Map.get(groups, "_languages"))
+    group_lines = format_group_lines(groups)
+
+    ["#{behavior}:" | doc_line] ++
+      fix_hint_line ++ languages_line ++ baseline_line ++ group_lines ++ [""]
+  end
+
+  defp yaml_doc_line(nil), do: []
+  defp yaml_doc_line(doc), do: ["  _doc: #{inspect(doc)}"]
+
+  defp yaml_baseline_line(nil), do: []
+  defp yaml_baseline_line(val), do: ["  _log_baseline: #{fmt_scalar(val)}"]
+
+  defp yaml_fix_hint_line(nil), do: []
+  defp yaml_fix_hint_line(hint), do: ["  _fix_hint: #{inspect(hint)}"]
+
+  defp yaml_languages_line(nil), do: []
+  defp yaml_languages_line([]), do: []
+  defp yaml_languages_line(langs), do: ["  _languages: [#{Enum.join(langs, ", ")}]"]
+
+  defp format_group_lines(groups) do
+    groups
+    |> Enum.filter(fn {k, v} ->
+      k not in ["_doc", "_log_baseline", "_fix_hint", "_languages"] and is_map(v)
+    end)
+    |> Enum.sort_by(fn {group, _} -> group end)
+    |> Enum.flat_map(fn {group, keys} ->
+      key_lines =
+        keys
+        |> Enum.sort_by(fn {key, _} -> key end)
+        |> Enum.map(fn {key, scalar} -> "    #{key}: #{fmt_scalar(scalar)}" end)
+
+      ["  #{group}:" | key_lines]
+    end)
+  end
+
   defp fmt_scalar(f) when is_float(f), do: :erlang.float_to_binary(f, decimals: 4)
   defp fmt_scalar(n) when is_integer(n), do: "#{n}.0"
 
@@ -589,9 +626,9 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
 
     @yaml_dir
     |> File.ls!()
-    |> Enum.filter(&String.ends_with?(&1, ".yml"))
     |> Enum.filter(fn yml_file ->
-      filter_category == nil or String.trim_trailing(yml_file, ".yml") == filter_category
+      String.ends_with?(yml_file, ".yml") and
+        (filter_category == nil or String.trim_trailing(yml_file, ".yml") == filter_category)
     end)
     |> Enum.sort()
     |> Enum.map(fn yml_file ->
diff --git a/lib/codeqa/combined_metrics/scope_and_assignment.ex b/lib/codeqa/combined_metrics/scope_and_assignment.ex
index ddb1d11..0b3e616 100644
--- a/lib/codeqa/combined_metrics/scope_and_assignment.ex
+++ b/lib/codeqa/combined_metrics/scope_and_assignment.ex
@@ -17,12 +17,13 @@ defmodule CodeQA.CombinedMetrics.ScopeAndAssignment do
 
   for {key, doc} <- @behaviors do
     defmodule Module.concat(CodeQA.CombinedMetrics.ScopeAndAssignment, Macro.camelize(key)) do
+      alias CodeQA.CombinedMetrics.ScopeAndAssignment
       @moduledoc doc
-      @behaviour CodeQA.CombinedMetrics.ScopeAndAssignment
+      @behaviour ScopeAndAssignment
       @score_key key
       @impl true
       def score(metrics),
-        do: CodeQA.CombinedMetrics.ScopeAndAssignment.compute_score(@score_key, metrics)
+        do: ScopeAndAssignment.compute_score(@score_key, metrics)
     end
   end
 end
diff --git a/lib/codeqa/combined_metrics/scorer.ex b/lib/codeqa/combined_metrics/scorer.ex
index 29b6d2f..627fc97 100644
--- a/lib/codeqa/combined_metrics/scorer.ex
+++ b/lib/codeqa/combined_metrics/scorer.ex
@@ -1,4 +1,6 @@
 defmodule CodeQA.CombinedMetrics.Scorer do
+  alias CodeQA.Engine.Analyzer
+
   @moduledoc """
   Pure computation engine for combined metric formulas.
 
@@ -45,7 +47,7 @@ defmodule CodeQA.CombinedMetrics.Scorer do
   @doc "Returns the full default scalar map: all registered file metric keys mapped to 0.0."
   @spec default_scalars() :: %{{String.t(), String.t()} => float()}
   def default_scalars do
-    CodeQA.Engine.Analyzer.build_registry().file_metrics
+    Analyzer.build_registry().file_metrics
     |> Enum.flat_map(fn mod ->
       Enum.map(mod.keys(), fn key -> {{mod.name(), "mean_" <> key}, 0.0} end)
     end)
diff --git a/lib/codeqa/combined_metrics/testing.ex b/lib/codeqa/combined_metrics/testing.ex
index 8876453..52b41e4 100644
--- a/lib/codeqa/combined_metrics/testing.ex
+++ b/lib/codeqa/combined_metrics/testing.ex
@@ -17,12 +17,13 @@ defmodule CodeQA.CombinedMetrics.Testing do
 
   for {key, doc} <- @behaviors do
     defmodule Module.concat(CodeQA.CombinedMetrics.Testing, Macro.camelize(key)) do
+      alias CodeQA.CombinedMetrics.Testing
       @moduledoc doc
-      @behaviour CodeQA.CombinedMetrics.Testing
+      @behaviour Testing
       @score_key key
       @impl true
       def score(metrics),
-        do: CodeQA.CombinedMetrics.Testing.compute_score(@score_key, metrics)
+        do: Testing.compute_score(@score_key, metrics)
     end
   end
 end
diff --git a/lib/codeqa/combined_metrics/type_and_value.ex b/lib/codeqa/combined_metrics/type_and_value.ex
index 5f76a8a..d461c60 100644
--- a/lib/codeqa/combined_metrics/type_and_value.ex
+++ b/lib/codeqa/combined_metrics/type_and_value.ex
@@ -17,12 +17,13 @@ defmodule CodeQA.CombinedMetrics.TypeAndValue do
 
   for {key, doc} <- @behaviors do
     defmodule Module.concat(CodeQA.CombinedMetrics.TypeAndValue, Macro.camelize(key)) do
+      alias CodeQA.CombinedMetrics.TypeAndValue
       @moduledoc doc
-      @behaviour CodeQA.CombinedMetrics.TypeAndValue
+      @behaviour TypeAndValue
       @score_key key
       @impl true
       def score(metrics),
-        do: CodeQA.CombinedMetrics.TypeAndValue.compute_score(@score_key, metrics)
+        do: TypeAndValue.compute_score(@score_key, metrics)
     end
   end
 end
diff --git a/lib/codeqa/combined_metrics/variable_naming.ex b/lib/codeqa/combined_metrics/variable_naming.ex
index c846414..db49793 100644
--- a/lib/codeqa/combined_metrics/variable_naming.ex
+++ b/lib/codeqa/combined_metrics/variable_naming.ex
@@ -17,12 +17,13 @@ defmodule CodeQA.CombinedMetrics.VariableNaming do
 
   for {key, doc} <- @behaviors do
     defmodule Module.concat(CodeQA.CombinedMetrics.VariableNaming, Macro.camelize(key)) do
+      alias CodeQA.CombinedMetrics.VariableNaming
       @moduledoc doc
-      @behaviour CodeQA.CombinedMetrics.VariableNaming
+      @behaviour VariableNaming
       @score_key key
       @impl true
       def score(metrics),
-        do: CodeQA.CombinedMetrics.VariableNaming.compute_score(@score_key, metrics)
+        do: VariableNaming.compute_score(@score_key, metrics)
     end
   end
 end
diff --git a/lib/codeqa/diagnostics.ex b/lib/codeqa/diagnostics.ex
index d086e44..f2479e0 100644
--- a/lib/codeqa/diagnostics.ex
+++ b/lib/codeqa/diagnostics.ex
@@ -4,7 +4,10 @@ defmodule CodeQA.Diagnostics do
   cosine similarity against combined metric behavior profiles.
   """
 
-  alias CodeQA.CombinedMetrics.{SampleRunner, FileScorer}
+  alias CodeQA.CombinedMetrics.FileScorer
+  alias CodeQA.CombinedMetrics.SampleRunner
+  alias CodeQA.Engine.Analyzer
+  alias CodeQA.Engine.Collector
   alias CodeQA.HealthReport.Grader
 
   @doc """
@@ -25,8 +28,8 @@ defmodule CodeQA.Diagnostics do
     top = opts[:top] || 15
     format = opts[:format] || :plain
 
-    files = CodeQA.Engine.Collector.collect_files(path)
-    result = CodeQA.Engine.Analyzer.analyze_codebase(files, [])
+    files = Collector.collect_files(path)
+    result = Analyzer.analyze_codebase(files, [])
 
     case mode do
       :per_file -> run_per_file(result, top, format)
@@ -78,16 +81,7 @@ defmodule CodeQA.Diagnostics do
       :json ->
         files_json =
           Enum.map(file_diagnoses, fn {file_path, diagnoses} ->
-            behaviors =
-              Enum.map(diagnoses, fn d ->
-                %{
-                  behavior: "#{d.category}.#{d.behavior}",
-                  cosine: d.cosine,
-                  score: Grader.score_cosine(d.cosine)
-                }
-              end)
-
-            %{file: file_path, behaviors: behaviors}
+            %{file: file_path, behaviors: Enum.map(diagnoses, &diagnosis_to_map/1)}
           end)
 
         Jason.encode!(%{files: files_json}, pretty: true)
@@ -95,15 +89,27 @@ defmodule CodeQA.Diagnostics do
       _ ->
         file_rows =
           Enum.flat_map(file_diagnoses, fn {file_path, diagnoses} ->
-            Enum.map(diagnoses, fn %{category: cat, behavior: beh, cosine: cosine, score: score} ->
-              {file_path, "#{cat}.#{beh}", cosine, score}
-            end)
+            diagnoses_to_rows(file_path, diagnoses)
           end)
 
         "## Diagnose: per-file\n\n" <> per_file_table(file_rows, top)
     end
   end
 
+  defp diagnosis_to_map(d) do
+    %{
+      behavior: "#{d.category}.#{d.behavior}",
+      cosine: d.cosine,
+      score: Grader.score_cosine(d.cosine)
+    }
+  end
+
+  defp diagnoses_to_rows(file_path, diagnoses) do
+    Enum.map(diagnoses, fn %{category: cat, behavior: beh, cosine: cosine, score: score} ->
+      {file_path, "#{cat}.#{beh}", cosine, score}
+    end)
+  end
+
   defp project_languages(files_map) do
     files_map
     |> Map.keys()
diff --git a/lib/codeqa/engine/analyzer.ex b/lib/codeqa/engine/analyzer.ex
index b7e5c4e..6fe8cf0 100644
--- a/lib/codeqa/engine/analyzer.ex
+++ b/lib/codeqa/engine/analyzer.ex
@@ -2,9 +2,11 @@ defmodule CodeQA.Engine.Analyzer do
   @moduledoc "Orchestrates metric computation across files."
 
   alias CodeQA.Analysis.RunSupervisor
+  alias CodeQA.Engine.Parallel
+  alias CodeQA.Engine.Pipeline
   alias CodeQA.Engine.Registry
-  alias CodeQA.Metrics.File, as: Metrics
   alias CodeQA.Metrics.Codebase, as: CodebaseMetrics
+  alias CodeQA.Metrics.File, as: Metrics
 
   @registry Registry.new()
             |> Registry.register_file_metric(Metrics.Entropy)
@@ -35,14 +37,14 @@ defmodule CodeQA.Engine.Analyzer do
 
   @spec analyze_file(String.t(), String.t()) :: map()
   def analyze_file(_path, content) do
-    ctx = CodeQA.Engine.Pipeline.build_file_context(content)
-    CodeQA.Engine.Registry.run_file_metrics(@registry, ctx, [])
+    ctx = Pipeline.build_file_context(content)
+    Registry.run_file_metrics(@registry, ctx, [])
   end
 
   @spec analyze_codebase_aggregate(map(), keyword()) :: map()
   def analyze_codebase_aggregate(files_map, opts \\ []) do
     with_run_context(opts, fn opts ->
-      file_results = CodeQA.Engine.Parallel.analyze_files(files_map, opts)
+      file_results = Parallel.analyze_files(files_map, opts)
       aggregate_file_metrics(file_results)
     end)
   end
@@ -66,7 +68,7 @@ defmodule CodeQA.Engine.Analyzer do
   defp do_analyze_codebase(files, opts) do
     registry = @registry
 
-    file_results = CodeQA.Engine.Parallel.analyze_files(files, opts)
+    file_results = Parallel.analyze_files(files, opts)
     codebase_metrics = Registry.run_codebase_metrics(registry, files, opts)
     aggregate = aggregate_file_metrics(file_results)
 
diff --git a/lib/codeqa/engine/parallel.ex b/lib/codeqa/engine/parallel.ex
index 5ddf757..f5a8da1 100644
--- a/lib/codeqa/engine/parallel.ex
+++ b/lib/codeqa/engine/parallel.ex
@@ -1,4 +1,8 @@
 defmodule CodeQA.Engine.Parallel do
+  alias CodeQA.Analysis.FileContextServer
+  alias CodeQA.Engine.Analyzer
+  alias CodeQA.Engine.Registry
+
   @moduledoc "Parallel file analysis using Flow (GenStage-based)."
 
   def analyze_files(files, opts \\ []) when is_map(files) do
@@ -65,12 +69,12 @@ defmodule CodeQA.Engine.Parallel do
   end
 
   defp analyze_single_file(path, content, opts) do
-    registry = CodeQA.Engine.Analyzer.build_registry()
+    registry = Analyzer.build_registry()
     file_opts = Keyword.put(opts, :path, path)
     pid = Keyword.fetch!(opts, :file_context_pid)
 
-    ctx = CodeQA.Analysis.FileContextServer.get(pid, content, file_opts)
-    metrics = CodeQA.Engine.Registry.run_file_metrics(registry, ctx, opts)
+    ctx = FileContextServer.get(pid, content, file_opts)
+    metrics = Registry.run_file_metrics(registry, ctx, opts)
 
     %{
       "bytes" => ctx.byte_count,
diff --git a/lib/codeqa/git.ex b/lib/codeqa/git.ex
index 0576ddc..106ce54 100644
--- a/lib/codeqa/git.ex
+++ b/lib/codeqa/git.ex
@@ -8,6 +8,8 @@ defmodule CodeQA.Git do
     defstruct @enforce_keys
   end
 
+  alias CodeQA.Engine.Collector
+
   @status_map %{"A" => "added", "M" => "modified", "D" => "deleted"}
 
   @spec gitignored_files(String.t(), [String.t()]) :: MapSet.t()
@@ -82,6 +84,6 @@ defmodule CodeQA.Git do
 
   defp source_file?(path) do
     ext = path |> Path.extname() |> String.downcase()
-    MapSet.member?(CodeQA.Engine.Collector.source_extensions(), ext)
+    MapSet.member?(Collector.source_extensions(), ext)
   end
 end
diff --git a/lib/codeqa/health_report.ex b/lib/codeqa/health_report.ex
index 1e8be12..a634a02 100644
--- a/lib/codeqa/health_report.ex
+++ b/lib/codeqa/health_report.ex
@@ -1,8 +1,8 @@
 defmodule CodeQA.HealthReport do
   @moduledoc "Orchestrates health report generation from analysis results."
 
-  alias CodeQA.HealthReport.{Config, Grader, Formatter, Delta, TopBlocks}
   alias CodeQA.CombinedMetrics.{FileScorer, SampleRunner}
+  alias CodeQA.HealthReport.{Config, Delta, Formatter, Grader, TopBlocks}
 
   @spec generate(map(), keyword()) :: map()
   def generate(analysis_results, opts \\ []) do
@@ -59,6 +59,13 @@ defmodule CodeQA.HealthReport do
 
     top_blocks = TopBlocks.build(analysis_results, changed_files, codebase_cosine_lookup)
 
+    grading_cfg = %{
+      category_defs: categories,
+      grade_scale: grade_scale,
+      impact_map: impact_map,
+      combined_top: combined_top
+    }
+
     {codebase_delta, pr_summary} =
       if base_results do
         build_delta_and_summary(
@@ -66,11 +73,7 @@ defmodule CodeQA.HealthReport do
           analysis_results,
           overall_score,
           overall_grade,
-          all_categories,
-          categories,
-          grade_scale,
-          impact_map,
-          combined_top,
+          grading_cfg,
           changed_files,
           top_blocks
         )
@@ -100,11 +103,12 @@ defmodule CodeQA.HealthReport do
          head_results,
          head_score,
          head_grade,
-         _head_categories,
-         category_defs,
-         grade_scale,
-         impact_map,
-         combined_top,
+         %{
+           category_defs: category_defs,
+           grade_scale: grade_scale,
+           impact_map: impact_map,
+           combined_top: combined_top
+         },
          changed_files,
          top_blocks
        ) do
diff --git a/lib/codeqa/health_report/formatter/github.ex b/lib/codeqa/health_report/formatter/github.ex
index 694b7ff..e0d9170 100644
--- a/lib/codeqa/health_report/formatter/github.ex
+++ b/lib/codeqa/health_report/formatter/github.ex
@@ -52,23 +52,19 @@ defmodule CodeQA.HealthReport.Formatter.Github do
     end
   end
 
-  defp grade_letter_from_score(score) do
-    cond do
-      score >= 97 -> "A+"
-      score >= 93 -> "A"
-      score >= 90 -> "A-"
-      score >= 87 -> "B+"
-      score >= 83 -> "B"
-      score >= 80 -> "B-"
-      score >= 77 -> "C+"
-      score >= 73 -> "C"
-      score >= 70 -> "C-"
-      score >= 67 -> "D+"
-      score >= 63 -> "D"
-      score >= 60 -> "D-"
-      true -> "F"
-    end
-  end
+  defp grade_letter_from_score(score) when score >= 97, do: "A+"
+  defp grade_letter_from_score(score) when score >= 93, do: "A"
+  defp grade_letter_from_score(score) when score >= 90, do: "A-"
+  defp grade_letter_from_score(score) when score >= 87, do: "B+"
+  defp grade_letter_from_score(score) when score >= 83, do: "B"
+  defp grade_letter_from_score(score) when score >= 80, do: "B-"
+  defp grade_letter_from_score(score) when score >= 77, do: "C+"
+  defp grade_letter_from_score(score) when score >= 73, do: "C"
+  defp grade_letter_from_score(score) when score >= 70, do: "C-"
+  defp grade_letter_from_score(score) when score >= 67, do: "D+"
+  defp grade_letter_from_score(score) when score >= 63, do: "D"
+  defp grade_letter_from_score(score) when score >= 60, do: "D-"
+  defp grade_letter_from_score(_score), do: "F"
 
   defp header(report) do
     emoji = grade_emoji(report.overall_grade)
@@ -284,11 +280,9 @@ defmodule CodeQA.HealthReport.Formatter.Github do
 
   defp top_issues_section(issues, _detail) do
     rows =
-      issues
-      |> Enum.map(fn i ->
+      Enum.map_join(issues, "\n", fn i ->
         "| `#{i.category}.#{i.behavior}` | #{format_num(i.cosine)} | #{format_num(i.score)} |"
       end)
-      |> Enum.join("\n")
 
     table = "| Behavior | Cosine | Score |\n|----------|--------|-------|\n#{rows}"
 
@@ -361,19 +355,7 @@ defmodule CodeQA.HealthReport.Formatter.Github do
       {"Structure", "branching", "mean_branch_count"}
     ]
 
-    rows =
-      Enum.flat_map(metrics, fn {label, group, key} ->
-        base_val = get_in(base_agg, [group, key])
-        head_val = get_in(head_agg, [group, key])
-
-        if is_number(base_val) and is_number(head_val) do
-          diff = Float.round(head_val - base_val, 2)
-          diff_str = if diff >= 0, do: "+#{format_num(diff)}", else: "#{format_num(diff)}"
-          ["| #{label} | #{format_num(base_val)} | #{format_num(head_val)} | #{diff_str} |"]
-        else
-          []
-        end
-      end)
+    rows = Enum.flat_map(metrics, &format_metric_row(&1, base_agg, head_agg))
 
     if rows == [] do
       []
@@ -388,6 +370,19 @@ defmodule CodeQA.HealthReport.Formatter.Github do
     end
   end
 
+  defp format_metric_row({label, group, key}, base_agg, head_agg) do
+    base_val = get_in(base_agg, [group, key])
+    head_val = get_in(head_agg, [group, key])
+
+    if is_number(base_val) and is_number(head_val) do
+      diff = Float.round(head_val - base_val, 2)
+      diff_str = if diff >= 0, do: "+#{format_num(diff)}", else: "#{format_num(diff)}"
+      ["| #{label} | #{format_num(base_val)} | #{format_num(head_val)} | #{diff_str} |"]
+    else
+      []
+    end
+  end
+
   defp blocks_section([]), do: []
 
   defp blocks_section(top_blocks) do
@@ -398,27 +393,8 @@ defmodule CodeQA.HealthReport.Formatter.Github do
         status_str = if group.status, do: " [#{group.status}]", else: ""
         summary_line = "🔍 #{group.path}#{status_str} — #{length(group.blocks)} block(s)"
 
-        block_lines =
-          Enum.flat_map(group.blocks, fn block ->
-            end_line = block.end_line || block.start_line
-
-            potential_lines =
-              Enum.flat_map(block.potentials, fn p ->
-                icon = severity_icon(p.severity)
-                delta_str = format_num(p.cosine_delta)
-                label = String.upcase(to_string(p.severity))
-                line = "**#{icon} #{label}** `#{p.category}/#{p.behavior}` (Δ #{delta_str})"
-                fix = if p.fix_hint, do: ["> #{p.fix_hint}"], else: []
-                [line | fix]
-              end)
-
-            [
-              "**lines #{block.start_line}–#{end_line}** · #{block.type} · #{block.token_count} tokens"
-            ] ++
-              potential_lines ++ [""]
-          end)
-
-        inner = List.flatten(block_lines) |> Enum.join("\n")
+        inner =
+          group.blocks |> Enum.flat_map(&format_block/1) |> List.flatten() |> Enum.join("\n")
 
         [
           "<details>",
@@ -437,6 +413,25 @@ defmodule CodeQA.HealthReport.Formatter.Github do
     ]
   end
 
+  defp format_block(block) do
+    end_line = block.end_line || block.start_line
+
+    header =
+      "**lines #{block.start_line}–#{end_line}** · #{block.type} · #{block.token_count} tokens"
+
+    potential_lines = Enum.flat_map(block.potentials, &format_potential/1)
+    [header] ++ potential_lines ++ [""]
+  end
+
+  defp format_potential(p) do
+    icon = severity_icon(p.severity)
+    delta_str = format_num(p.cosine_delta)
+    label = String.upcase(to_string(p.severity))
+    line = "**#{icon} #{label}** `#{p.category}/#{p.behavior}` (Δ #{delta_str})"
+    fix = if p.fix_hint, do: ["> #{p.fix_hint}"], else: []
+    [line | fix]
+  end
+
   defp severity_icon(:critical), do: "🔴"
   defp severity_icon(:high), do: "🟠"
   defp severity_icon(:medium), do: "🟡"
diff --git a/lib/codeqa/health_report/formatter/plain.ex b/lib/codeqa/health_report/formatter/plain.ex
index 25117a3..0b99b5c 100644
--- a/lib/codeqa/health_report/formatter/plain.ex
+++ b/lib/codeqa/health_report/formatter/plain.ex
@@ -178,19 +178,7 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
       {"Structure", "branching", "mean_branch_count"}
     ]
 
-    rows =
-      Enum.flat_map(metrics, fn {label, group, key} ->
-        base_val = get_in(base_agg, [group, key])
-        head_val = get_in(head_agg, [group, key])
-
-        if is_number(base_val) and is_number(head_val) do
-          diff = Float.round(head_val - base_val, 2)
-          diff_str = if diff >= 0, do: "+#{format_num(diff)}", else: "#{format_num(diff)}"
-          ["| #{label} | #{format_num(base_val)} | #{format_num(head_val)} | #{diff_str} |"]
-        else
-          []
-        end
-      end)
+    rows = Enum.flat_map(metrics, &format_metric_row(&1, base_agg, head_agg))
 
     if rows == [] do
       []
@@ -205,6 +193,19 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
     end
   end
 
+  defp format_metric_row({label, group, key}, base_agg, head_agg) do
+    base_val = get_in(base_agg, [group, key])
+    head_val = get_in(head_agg, [group, key])
+
+    if is_number(base_val) and is_number(head_val) do
+      diff = Float.round(head_val - base_val, 2)
+      diff_str = if diff >= 0, do: "+#{format_num(diff)}", else: "#{format_num(diff)}"
+      ["| #{label} | #{format_num(base_val)} | #{format_num(head_val)} | #{diff_str} |"]
+    else
+      []
+    end
+  end
+
   defp blocks_section([]), do: []
 
   defp blocks_section(top_blocks) do
@@ -213,27 +214,7 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
     file_parts =
       Enum.flat_map(top_blocks, fn group ->
         status_str = if group.status, do: "  [#{group.status}]", else: ""
-
-        block_lines =
-          Enum.flat_map(group.blocks, fn block ->
-            end_line = block.end_line || block.start_line
-
-            header =
-              "**lines #{block.start_line}–#{end_line}** · #{block.type} · #{block.token_count} tokens"
-
-            potential_lines =
-              Enum.flat_map(block.potentials, fn p ->
-                icon = severity_icon(p.severity)
-                delta_str = format_num(p.cosine_delta)
-                label = "#{String.upcase(to_string(p.severity))}"
-                line = "  #{icon} #{label}  #{p.category} / #{p.behavior}  (Δ #{delta_str})"
-                fix = if p.fix_hint, do: ["    → #{p.fix_hint}"], else: []
-                [line | fix]
-              end)
-
-            [header | potential_lines] ++ [""]
-          end)
-
+        block_lines = Enum.flat_map(group.blocks, &format_block/1)
         ["### #{group.path}#{status_str}", "" | block_lines]
       end)
 
@@ -244,6 +225,25 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
     ]
   end
 
+  defp format_block(block) do
+    end_line = block.end_line || block.start_line
+
+    header =
+      "**lines #{block.start_line}–#{end_line}** · #{block.type} · #{block.token_count} tokens"
+
+    potential_lines = Enum.flat_map(block.potentials, &format_potential/1)
+    [header | potential_lines] ++ [""]
+  end
+
+  defp format_potential(p) do
+    icon = severity_icon(p.severity)
+    delta_str = format_num(p.cosine_delta)
+    label = String.upcase(to_string(p.severity))
+    line = "  #{icon} #{label}  #{p.category} / #{p.behavior}  (Δ #{delta_str})"
+    fix = if p.fix_hint, do: ["    → #{p.fix_hint}"], else: []
+    [line | fix]
+  end
+
   defp severity_icon(:critical), do: "🔴"
   defp severity_icon(:high), do: "🟠"
   defp severity_icon(:medium), do: "🟡"
diff --git a/lib/codeqa/health_report/grader.ex b/lib/codeqa/health_report/grader.ex
index 20413c9..8011c8f 100644
--- a/lib/codeqa/health_report/grader.ex
+++ b/lib/codeqa/health_report/grader.ex
@@ -2,6 +2,8 @@ defmodule CodeQA.HealthReport.Grader do
   @moduledoc "Scores metrics and assigns letter grades."
 
   alias CodeQA.CombinedMetrics.SampleRunner
+  alias CodeQA.Config
+  alias CodeQA.HealthReport.Categories
 
   @doc """
   Score a single metric value (0-100) based on thresholds and direction.
@@ -100,7 +102,7 @@ defmodule CodeQA.HealthReport.Grader do
 
   @doc "Convert a numeric score (0-100) to a letter grade using the given scale."
   @spec grade_letter(number(), [{number(), String.t()}]) :: String.t()
-  def grade_letter(score, scale \\ CodeQA.HealthReport.Categories.default_grade_scale()) do
+  def grade_letter(score, scale \\ Categories.default_grade_scale()) do
     Enum.find_value(scale, "F", fn {min, letter} ->
       if score >= min, do: letter
     end)
@@ -114,7 +116,7 @@ defmodule CodeQA.HealthReport.Grader do
   def grade_category(
         category,
         file_metrics,
-        scale \\ CodeQA.HealthReport.Categories.default_grade_scale()
+        scale \\ Categories.default_grade_scale()
       ) do
     scored =
       category.metrics
@@ -161,7 +163,7 @@ defmodule CodeQA.HealthReport.Grader do
   def grade_file(
         categories,
         file_metrics,
-        scale \\ CodeQA.HealthReport.Categories.default_grade_scale()
+        scale \\ Categories.default_grade_scale()
       ) do
     Enum.map(categories, &grade_category(&1, file_metrics, scale))
   end
@@ -173,7 +175,7 @@ defmodule CodeQA.HealthReport.Grader do
   def grade_aggregate(
         categories,
         aggregate,
-        scale \\ CodeQA.HealthReport.Categories.default_grade_scale()
+        scale \\ Categories.default_grade_scale()
       ) do
     # Convert aggregate format (mean_X keys) to file-metric-like format
     file_like =
@@ -205,7 +207,7 @@ defmodule CodeQA.HealthReport.Grader do
         ) :: {integer(), String.t()}
   def overall_score(
         category_grades,
-        scale \\ CodeQA.HealthReport.Categories.default_grade_scale(),
+        scale \\ Categories.default_grade_scale(),
         impact_map \\ %{}
       ) do
     if category_grades == [] do
@@ -240,10 +242,10 @@ defmodule CodeQA.HealthReport.Grader do
   def grade_cosine_categories(
         aggregate,
         worst_files,
-        scale \\ CodeQA.HealthReport.Categories.default_grade_scale(),
+        scale \\ Categories.default_grade_scale(),
         languages \\ []
       ) do
-    threshold = CodeQA.Config.cosine_significance_threshold()
+    threshold = Config.cosine_significance_threshold()
 
     aggregate
     |> SampleRunner.diagnose_aggregate(top: 99_999, languages: languages)
@@ -297,9 +299,11 @@ defmodule CodeQA.HealthReport.Grader do
         category,
         all_file_metrics,
         top_n,
-        scale \\ CodeQA.HealthReport.Categories.default_grade_scale()
+        scale \\ Categories.default_grade_scale()
       ) do
-    # TODO(option-c): threshold metric scores are file-level aggregates; line-level attribution would require each AST node to carry its own per-metric values so that the node with the highest contribution to the bad metric score could be identified and reported directly.
+    # NOTE: threshold metric scores are file-level aggregates; line-level attribution would require
+    # each AST node to carry its own per-metric values so that the node with the highest
+    # contribution to the bad metric score could be identified and reported directly.
     all_file_metrics
     |> Enum.map(fn {path, file_data} ->
       metrics = Map.get(file_data, "metrics", %{})
diff --git a/lib/codeqa/health_report/top_blocks.ex b/lib/codeqa/health_report/top_blocks.ex
index dda0bb8..1761941 100644
--- a/lib/codeqa/health_report/top_blocks.ex
+++ b/lib/codeqa/health_report/top_blocks.ex
@@ -100,18 +100,17 @@ defmodule CodeQA.HealthReport.TopBlocks do
     Scorer.all_yamls()
     |> Enum.flat_map(fn {yaml_path, data} ->
       category = yaml_path |> Path.basename() |> String.trim_trailing(".yml")
-
-      Enum.flat_map(data, fn
-        {behavior, behavior_data} when is_map(behavior_data) ->
-          case Map.get(behavior_data, "_fix_hint") do
-            nil -> []
-            hint -> [{{category, behavior}, hint}]
-          end
-
-        _ ->
-          []
-      end)
+      Enum.flat_map(data, &hints_for_behavior(category, &1))
     end)
     |> Map.new()
   end
+
+  defp hints_for_behavior(category, {behavior, behavior_data}) when is_map(behavior_data) do
+    case Map.get(behavior_data, "_fix_hint") do
+      nil -> []
+      hint -> [{{category, behavior}, hint}]
+    end
+  end
+
+  defp hints_for_behavior(_category, _entry), do: []
 end
diff --git a/lib/codeqa/languages/code/native/cpp.ex b/lib/codeqa/languages/code/native/cpp.ex
index 3cc8724..31cbb4e 100644
--- a/lib/codeqa/languages/code/native/cpp.ex
+++ b/lib/codeqa/languages/code/native/cpp.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Native.Cpp do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/native/go.ex b/lib/codeqa/languages/code/native/go.ex
index 45ea58d..b728aab 100644
--- a/lib/codeqa/languages/code/native/go.ex
+++ b/lib/codeqa/languages/code/native/go.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Native.Go do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/native/haskell.ex b/lib/codeqa/languages/code/native/haskell.ex
index c0b1075..48cd646 100644
--- a/lib/codeqa/languages/code/native/haskell.ex
+++ b/lib/codeqa/languages/code/native/haskell.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Native.Haskell do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/native/ocaml.ex b/lib/codeqa/languages/code/native/ocaml.ex
index 6857a5f..d1e8b21 100644
--- a/lib/codeqa/languages/code/native/ocaml.ex
+++ b/lib/codeqa/languages/code/native/ocaml.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Native.Ocaml do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/native/rust.ex b/lib/codeqa/languages/code/native/rust.ex
index 4aa7907..0616834 100644
--- a/lib/codeqa/languages/code/native/rust.ex
+++ b/lib/codeqa/languages/code/native/rust.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Native.Rust do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/native/swift.ex b/lib/codeqa/languages/code/native/swift.ex
index 1a83b67..0422528 100644
--- a/lib/codeqa/languages/code/native/swift.ex
+++ b/lib/codeqa/languages/code/native/swift.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Native.Swift do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/native/zig.ex b/lib/codeqa/languages/code/native/zig.ex
index 4141a2e..f3e13f8 100644
--- a/lib/codeqa/languages/code/native/zig.ex
+++ b/lib/codeqa/languages/code/native/zig.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Native.Zig do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/scripting/julia.ex b/lib/codeqa/languages/code/scripting/julia.ex
index e99f8e3..8f859d1 100644
--- a/lib/codeqa/languages/code/scripting/julia.ex
+++ b/lib/codeqa/languages/code/scripting/julia.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Scripting.Julia do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/scripting/lua.ex b/lib/codeqa/languages/code/scripting/lua.ex
index e9e94b8..7ae8e9d 100644
--- a/lib/codeqa/languages/code/scripting/lua.ex
+++ b/lib/codeqa/languages/code/scripting/lua.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Scripting.Lua do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/scripting/perl.ex b/lib/codeqa/languages/code/scripting/perl.ex
index 5f90eeb..3155f1c 100644
--- a/lib/codeqa/languages/code/scripting/perl.ex
+++ b/lib/codeqa/languages/code/scripting/perl.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Scripting.Perl do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/scripting/php.ex b/lib/codeqa/languages/code/scripting/php.ex
index 0311e69..294b9a1 100644
--- a/lib/codeqa/languages/code/scripting/php.ex
+++ b/lib/codeqa/languages/code/scripting/php.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Scripting.PHP do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/scripting/python.ex b/lib/codeqa/languages/code/scripting/python.ex
index bdb31aa..e1c4bb4 100644
--- a/lib/codeqa/languages/code/scripting/python.ex
+++ b/lib/codeqa/languages/code/scripting/python.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Scripting.Python do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/scripting/r.ex b/lib/codeqa/languages/code/scripting/r.ex
index c22cb15..d735d2b 100644
--- a/lib/codeqa/languages/code/scripting/r.ex
+++ b/lib/codeqa/languages/code/scripting/r.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Scripting.R do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/scripting/ruby.ex b/lib/codeqa/languages/code/scripting/ruby.ex
index 90b17a7..d1e9761 100644
--- a/lib/codeqa/languages/code/scripting/ruby.ex
+++ b/lib/codeqa/languages/code/scripting/ruby.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Scripting.Ruby do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/scripting/shell.ex b/lib/codeqa/languages/code/scripting/shell.ex
index acbe37c..710d28a 100644
--- a/lib/codeqa/languages/code/scripting/shell.ex
+++ b/lib/codeqa/languages/code/scripting/shell.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Scripting.Shell do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/vm/clojure.ex b/lib/codeqa/languages/code/vm/clojure.ex
index 770b280..5dd149b 100644
--- a/lib/codeqa/languages/code/vm/clojure.ex
+++ b/lib/codeqa/languages/code/vm/clojure.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Vm.Clojure do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/vm/csharp.ex b/lib/codeqa/languages/code/vm/csharp.ex
index b90933f..85edce7 100644
--- a/lib/codeqa/languages/code/vm/csharp.ex
+++ b/lib/codeqa/languages/code/vm/csharp.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Vm.CSharp do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/vm/dart.ex b/lib/codeqa/languages/code/vm/dart.ex
index 16e29de..e821e22 100644
--- a/lib/codeqa/languages/code/vm/dart.ex
+++ b/lib/codeqa/languages/code/vm/dart.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Vm.Dart do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/vm/elixir.ex b/lib/codeqa/languages/code/vm/elixir.ex
index 401f808..2eab027 100644
--- a/lib/codeqa/languages/code/vm/elixir.ex
+++ b/lib/codeqa/languages/code/vm/elixir.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Vm.Elixir do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/vm/erlang.ex b/lib/codeqa/languages/code/vm/erlang.ex
index d390e01..c835dd6 100644
--- a/lib/codeqa/languages/code/vm/erlang.ex
+++ b/lib/codeqa/languages/code/vm/erlang.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Vm.Erlang do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/vm/fsharp.ex b/lib/codeqa/languages/code/vm/fsharp.ex
index e6b12ef..9c7792f 100644
--- a/lib/codeqa/languages/code/vm/fsharp.ex
+++ b/lib/codeqa/languages/code/vm/fsharp.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Vm.Fsharp do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/vm/java.ex b/lib/codeqa/languages/code/vm/java.ex
index 151bee1..fa018e0 100644
--- a/lib/codeqa/languages/code/vm/java.ex
+++ b/lib/codeqa/languages/code/vm/java.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Vm.Java do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/vm/kotlin.ex b/lib/codeqa/languages/code/vm/kotlin.ex
index 72980a2..4c286c2 100644
--- a/lib/codeqa/languages/code/vm/kotlin.ex
+++ b/lib/codeqa/languages/code/vm/kotlin.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Vm.Kotlin do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/vm/scala.ex b/lib/codeqa/languages/code/vm/scala.ex
index 55a7a00..08ac7ab 100644
--- a/lib/codeqa/languages/code/vm/scala.ex
+++ b/lib/codeqa/languages/code/vm/scala.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Vm.Scala do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/web/javascript.ex b/lib/codeqa/languages/code/web/javascript.ex
index 38194f1..87f48f5 100644
--- a/lib/codeqa/languages/code/web/javascript.ex
+++ b/lib/codeqa/languages/code/web/javascript.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Web.JavaScript do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/code/web/typescript.ex b/lib/codeqa/languages/code/web/typescript.ex
index 23ab690..b8a422a 100644
--- a/lib/codeqa/languages/code/web/typescript.ex
+++ b/lib/codeqa/languages/code/web/typescript.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Code.Web.TypeScript do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/config/dockerfile.ex b/lib/codeqa/languages/config/dockerfile.ex
index 97373ea..e1ed3a6 100644
--- a/lib/codeqa/languages/config/dockerfile.ex
+++ b/lib/codeqa/languages/config/dockerfile.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Config.Dockerfile do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/config/makefile.ex b/lib/codeqa/languages/config/makefile.ex
index 6ad3d7b..ffb4522 100644
--- a/lib/codeqa/languages/config/makefile.ex
+++ b/lib/codeqa/languages/config/makefile.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Config.Makefile do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/config/terraform.ex b/lib/codeqa/languages/config/terraform.ex
index bf257bc..c35cb9f 100644
--- a/lib/codeqa/languages/config/terraform.ex
+++ b/lib/codeqa/languages/config/terraform.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Config.Terraform do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/data/graphql.ex b/lib/codeqa/languages/data/graphql.ex
index 70e02e2..47dbc51 100644
--- a/lib/codeqa/languages/data/graphql.ex
+++ b/lib/codeqa/languages/data/graphql.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Data.GraphQL do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/data/json.ex b/lib/codeqa/languages/data/json.ex
index c0b0589..0b1909e 100644
--- a/lib/codeqa/languages/data/json.ex
+++ b/lib/codeqa/languages/data/json.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Data.Json do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/data/sql.ex b/lib/codeqa/languages/data/sql.ex
index 9178fe5..ddc4018 100644
--- a/lib/codeqa/languages/data/sql.ex
+++ b/lib/codeqa/languages/data/sql.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Data.Sql do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/data/toml.ex b/lib/codeqa/languages/data/toml.ex
index 9f555a3..1051c0d 100644
--- a/lib/codeqa/languages/data/toml.ex
+++ b/lib/codeqa/languages/data/toml.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Data.Toml do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/data/yaml.ex b/lib/codeqa/languages/data/yaml.ex
index 77d8f1f..8beb0cb 100644
--- a/lib/codeqa/languages/data/yaml.ex
+++ b/lib/codeqa/languages/data/yaml.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Data.Yaml do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/language.ex b/lib/codeqa/languages/language.ex
index ada7fa1..3ccd172 100644
--- a/lib/codeqa/languages/language.ex
+++ b/lib/codeqa/languages/language.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Language do
+  @moduledoc false
   @callback name() :: String.t()
   @callback extensions() :: [String.t()]
   @callback comment_prefixes() :: [String.t()]
@@ -168,7 +169,7 @@ defmodule CodeQA.Language do
   defp strip_line_comments(content, []), do: content
 
   defp strip_line_comments(content, prefixes) do
-    pattern = prefixes |> Enum.map(&Regex.escape/1) |> Enum.join("|")
+    pattern = Enum.map_join(prefixes, "|", &Regex.escape/1)
     Regex.replace(Regex.compile!("(#{pattern}).*$", [:multiline]), content, "")
   end
 
diff --git a/lib/codeqa/languages/markup/css.ex b/lib/codeqa/languages/markup/css.ex
index 81a8e7c..0b0af14 100644
--- a/lib/codeqa/languages/markup/css.ex
+++ b/lib/codeqa/languages/markup/css.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Markup.Css do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/markup/html.ex b/lib/codeqa/languages/markup/html.ex
index 4835835..31a0fe8 100644
--- a/lib/codeqa/languages/markup/html.ex
+++ b/lib/codeqa/languages/markup/html.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Markup.Html do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/markup/markdown.ex b/lib/codeqa/languages/markup/markdown.ex
index 1e81a8c..ee75d60 100644
--- a/lib/codeqa/languages/markup/markdown.ex
+++ b/lib/codeqa/languages/markup/markdown.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Markup.Markdown do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/markup/xml.ex b/lib/codeqa/languages/markup/xml.ex
index 8c136c9..85c7668 100644
--- a/lib/codeqa/languages/markup/xml.ex
+++ b/lib/codeqa/languages/markup/xml.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Markup.Xml do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/languages/unknown.ex b/lib/codeqa/languages/unknown.ex
index 9873a86..11a0f7a 100644
--- a/lib/codeqa/languages/unknown.ex
+++ b/lib/codeqa/languages/unknown.ex
@@ -1,4 +1,5 @@
 defmodule CodeQA.Languages.Unknown do
+  @moduledoc false
   use CodeQA.Language
 
   @impl true
diff --git a/lib/codeqa/metrics/codebase/similarity.ex b/lib/codeqa/metrics/codebase/similarity.ex
index cc8b644..e20e556 100644
--- a/lib/codeqa/metrics/codebase/similarity.ex
+++ b/lib/codeqa/metrics/codebase/similarity.ex
@@ -13,6 +13,10 @@ defmodule CodeQA.Metrics.Codebase.Similarity do
 
   @behaviour CodeQA.Metrics.Codebase.CodebaseMetric
 
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.CLI.UI
+  alias CodeQA.Metrics.File.Winnowing
+
   @impl true
   def name, do: "similarity"
 
@@ -99,7 +103,7 @@ defmodule CodeQA.Metrics.Codebase.Similarity do
 
   defp maybe_print_fingerprint_progress(true, i, total) do
     if rem(i + 1, max(1, div(total, 20))) == 0 do
-      IO.write(:stderr, "\r" <> CodeQA.CLI.UI.progress_bar(i + 1, total, label: "Fingerprinting"))
+      IO.write(:stderr, "\r" <> UI.progress_bar(i + 1, total, label: "Fingerprinting"))
     end
   end
 
@@ -130,7 +134,7 @@ defmodule CodeQA.Metrics.Codebase.Similarity do
 
   defp maybe_print_index_progress(true, idx, total) do
     if rem(idx + 1, max(1, div(total, 20))) == 0 do
-      IO.write(:stderr, "\r" <> CodeQA.CLI.UI.progress_bar(idx + 1, total, label: "Indexing"))
+      IO.write(:stderr, "\r" <> UI.progress_bar(idx + 1, total, label: "Indexing"))
     end
   end
 
@@ -231,7 +235,7 @@ defmodule CodeQA.Metrics.Codebase.Similarity do
 
   defp maybe_print_lsh_progress(true, idx, total) do
     if rem(idx + 1, max(1, div(total, 20))) == 0 do
-      IO.write(:stderr, "\r" <> CodeQA.CLI.UI.progress_bar(idx + 1, total, label: "LSH Filter"))
+      IO.write(:stderr, "\r" <> UI.progress_bar(idx + 1, total, label: "LSH Filter"))
     end
   end
 
@@ -284,8 +288,8 @@ defmodule CodeQA.Metrics.Codebase.Similarity do
       eta_ms = round((total_pairs - c) * avg_time)
 
       output =
-        CodeQA.CLI.UI.progress_bar(c, total_pairs,
-          eta: CodeQA.CLI.UI.format_eta(eta_ms),
+        UI.progress_bar(c, total_pairs,
+          eta: UI.format_eta(eta_ms),
           label: "NCD Compression"
         )
 
@@ -327,9 +331,9 @@ defmodule CodeQA.Metrics.Codebase.Similarity do
 
   defp compute_fingerprints(content, _opts) do
     content
-    |> CodeQA.AST.Lexing.TokenNormalizer.normalize_structural()
+    |> TokenNormalizer.normalize_structural()
     |> Enum.map(& &1.kind)
-    |> CodeQA.Metrics.File.Winnowing.kgrams(5)
+    |> Winnowing.kgrams(5)
     |> MapSet.new()
   end
 
diff --git a/lib/codeqa/metrics/file/casing_entropy.ex b/lib/codeqa/metrics/file/casing_entropy.ex
index 6f1cb2d..4256e0e 100644
--- a/lib/codeqa/metrics/file/casing_entropy.ex
+++ b/lib/codeqa/metrics/file/casing_entropy.ex
@@ -20,6 +20,8 @@ defmodule CodeQA.Metrics.File.CasingEntropy do
 
   @behaviour CodeQA.Metrics.File.FileMetric
 
+  alias CodeQA.Metrics.File.Inflector
+
   @impl true
   def name, do: "casing_entropy"
 
@@ -45,7 +47,7 @@ defmodule CodeQA.Metrics.File.CasingEntropy do
   def analyze(%{identifiers: identifiers}) do
     counts =
       identifiers
-      |> Enum.map(&CodeQA.Metrics.File.Inflector.detect_casing/1)
+      |> Enum.map(&Inflector.detect_casing/1)
       |> Enum.frequencies()
 
     total = length(identifiers)
diff --git a/lib/codeqa/metrics/file/near_duplicate_blocks.ex b/lib/codeqa/metrics/file/near_duplicate_blocks.ex
index c1cb707..94ba060 100644
--- a/lib/codeqa/metrics/file/near_duplicate_blocks.ex
+++ b/lib/codeqa/metrics/file/near_duplicate_blocks.ex
@@ -11,11 +11,11 @@ defmodule CodeQA.Metrics.File.NearDuplicateBlocks do
     d5 ≤ 25%, d6 ≤ 30%, d7 ≤ 40%, d8 ≤ 50%
   """
 
-  alias CodeQA.AST.Enrichment.Node
   alias CodeQA.AST.Classification.NodeProtocol
-  alias CodeQA.AST.Parsing.Parser
-  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Enrichment.Node
   alias CodeQA.AST.Lexing.{NewlineToken, WhitespaceToken}
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Parsing.Parser
   alias CodeQA.Language
 
   @max_bucket 8
@@ -230,10 +230,7 @@ defmodule CodeQA.Metrics.File.NearDuplicateBlocks do
 
       decorated =
         if MapSet.size(pruned) > 0 do
-          Enum.map(decorated, fn {i, b, v, h, l, c, n, bigrams} ->
-            {i, b, v, h, l, c, n,
-             Enum.reject(bigrams, &MapSet.member?(pruned, :erlang.phash2(&1)))}
-          end)
+          Enum.map(decorated, &prune_bigrams(&1, pruned))
         else
           decorated
         end
@@ -361,38 +358,53 @@ defmodule CodeQA.Metrics.File.NearDuplicateBlocks do
       bigrams_a
       |> Enum.reduce(%{}, fn bigram, acc ->
         h = :erlang.phash2(bigram)
-
-        Map.get(shingle_index, h, [])
-        |> Enum.reduce(acc, fn j, cnt ->
-          if j > i, do: Map.update(cnt, j, 1, &(&1 + 1)), else: cnt
-        end)
+        Map.get(shingle_index, h, []) |> Enum.reduce(acc, &count_candidate(&1, &2, i))
       end)
       |> Enum.filter(fn {_, count} -> count >= min_shared end)
       |> Enum.map(&elem(&1, 0))
       |> Enum.reject(fn j -> j in exact_list end)
       |> Enum.flat_map(fn j ->
-        {_j, block_b, values_b, _hash_b, len_b, children_b, newlines_b, _bigrams_b} =
-          elem(decorated_arr, j)
+        near_pair_for_candidate(
+          j,
+          decorated_arr,
+          block_a,
+          values_a,
+          len_a,
+          children_a,
+          newlines_a
+        )
+      end)
+
+    exact_pairs ++ near_pairs
+  end
 
-        min_count = min(len_a, len_b)
-        max_allowed = round(min_count * 0.5)
+  defp count_candidate(j, cnt, i) when j > i, do: Map.update(cnt, j, 1, &(&1 + 1))
+  defp count_candidate(_j, cnt, _i), do: cnt
 
-        if structure_compatible?(children_a, newlines_a, children_b, newlines_b) and
-             abs(len_a - len_b) <= max_allowed do
-          ed = token_edit_distance_bounded(values_a, values_b, max_allowed)
+  defp near_pair_for_candidate(j, decorated_arr, block_a, values_a, len_a, children_a, newlines_a) do
+    {_j, block_b, values_b, _hash_b, len_b, children_b, newlines_b, _bigrams_b} =
+      elem(decorated_arr, j)
 
-          case percent_bucket(ed, min_count) do
-            nil -> []
-            bucket when bucket > 0 -> [{bucket, {block_a.label, block_b.label}}]
-            # ed=0 handled by exact_pairs above
-            _ -> []
-          end
-        else
-          []
-        end
-      end)
+    min_count = min(len_a, len_b)
+    max_allowed = round(min_count * 0.5)
 
-    exact_pairs ++ near_pairs
+    if structure_compatible?(children_a, newlines_a, children_b, newlines_b) and
+         abs(len_a - len_b) <= max_allowed do
+      ed = token_edit_distance_bounded(values_a, values_b, max_allowed)
+
+      case percent_bucket(ed, min_count) do
+        nil -> []
+        bucket when bucket > 0 -> [{bucket, {block_a.label, block_b.label}}]
+        # ed=0 handled by exact_pairs above
+        _ -> []
+      end
+    else
+      []
+    end
+  end
+
+  defp prune_bigrams({i, b, v, h, l, c, n, bigrams}, pruned) do
+    {i, b, v, h, l, c, n, Enum.reject(bigrams, &MapSet.member?(pruned, :erlang.phash2(&1)))}
   end
 
   # Uses pre-computed children counts and newline counts from the decorated tuple
diff --git a/lib/codeqa/metrics/post_processing/menzerath.ex b/lib/codeqa/metrics/post_processing/menzerath.ex
index 2d9bd32..4b5b10c 100644
--- a/lib/codeqa/metrics/post_processing/menzerath.ex
+++ b/lib/codeqa/metrics/post_processing/menzerath.ex
@@ -256,22 +256,26 @@ defmodule CodeQA.Metrics.PostProcessing.Menzerath do
       if denom == 0.0 do
         {nil, nil}
       else
-        b = (n * sum_lxly - sum_lx * sum_ly) / denom
-        log_a = (sum_ly - b * sum_lx) / n
-        mean_ly = sum_ly / n
+        fit_power_law_coefficients(log_xs, log_ys, sum_lx, sum_ly, sum_lxly, n, denom)
+      end
+    end
+  end
 
-        ss_tot = Enum.reduce(log_ys, 0.0, fn ly, acc -> acc + (ly - mean_ly) ** 2 end)
+  defp fit_power_law_coefficients(log_xs, log_ys, sum_lx, sum_ly, sum_lxly, n, denom) do
+    b = (n * sum_lxly - sum_lx * sum_ly) / denom
+    log_a = (sum_ly - b * sum_lx) / n
+    mean_ly = sum_ly / n
 
-        ss_res =
-          Enum.zip(log_xs, log_ys)
-          |> Enum.reduce(0.0, fn {lx, ly}, acc ->
-            acc + (ly - (log_a + b * lx)) ** 2
-          end)
+    ss_tot = Enum.reduce(log_ys, 0.0, fn ly, acc -> acc + (ly - mean_ly) ** 2 end)
 
-        r_squared = if ss_tot == 0.0, do: 0.0, else: 1.0 - ss_res / ss_tot
-        {b, r_squared}
-      end
-    end
+    ss_res =
+      Enum.zip(log_xs, log_ys)
+      |> Enum.reduce(0.0, fn {lx, ly}, acc ->
+        acc + (ly - (log_a + b * lx)) ** 2
+      end)
+
+    r_squared = if ss_tot == 0.0, do: 0.0, else: 1.0 - ss_res / ss_tot
+    {b, r_squared}
   end
 
   defp round4(v), do: Float.round(v * 1.0, 4)
diff --git a/lib/mix/tasks/codeqa/sample_report.ex b/lib/mix/tasks/codeqa/sample_report.ex
index e4a1ba5..1bc5cf0 100644
--- a/lib/mix/tasks/codeqa/sample_report.ex
+++ b/lib/mix/tasks/codeqa/sample_report.ex
@@ -38,11 +38,15 @@ defmodule Mix.Tasks.Codeqa.SampleReport do
     top: :integer
   ]
 
+  alias CodeQA.CombinedMetrics.SampleRunner
+  alias CodeQA.Engine.Analyzer
+  alias CodeQA.Engine.Collector
+
   def run(args) do
     Mix.Task.run("app.start")
     {opts, _, _} = OptionParser.parse(args, switches: @switches)
 
-    results = CodeQA.CombinedMetrics.SampleRunner.run(opts)
+    results = SampleRunner.run(opts)
 
     results
     |> Enum.group_by(& &1.category)
@@ -54,19 +58,19 @@ defmodule Mix.Tasks.Codeqa.SampleReport do
     end
 
     if path = opts[:report] do
-      report = CodeQA.CombinedMetrics.SampleRunner.build_metric_report(opts)
+      report = SampleRunner.build_metric_report(opts)
       File.write!(path, Jason.encode!(report, pretty: true))
       IO.puts("\nMetric report written to #{path}")
     end
 
     if opts[:apply_scalars] do
-      stats = CodeQA.CombinedMetrics.SampleRunner.apply_scalars(opts)
+      stats = SampleRunner.apply_scalars(opts)
       IO.puts("\nApplied scalars to YAML configs:")
       Enum.each(stats, &print_scalar_stats/1)
     end
 
     if opts[:apply_languages] do
-      stats = CodeQA.CombinedMetrics.SampleRunner.apply_languages(opts)
+      stats = SampleRunner.apply_languages(opts)
       IO.puts("\nApplied language coverage to YAML configs:")
 
       Enum.each(stats, fn %{category: cat, behaviors_with_languages: n} ->
@@ -116,28 +120,30 @@ defmodule Mix.Tasks.Codeqa.SampleReport do
     )
 
     if opts[:verbose] do
-      Enum.each(r.metric_detail, fn m ->
-        scalar_str = if m.scalar >= 0, do: "+#{m.scalar}", else: "#{m.scalar}"
-
-        IO.puts(
-          "      " <>
-            pad("#{m.group}.#{m.key}", 45) <>
-            pad(scalar_str, 7) <>
-            pad(fmt(m.bad), 8) <>
-            pad(fmt(m.good), 8) <>
-            "#{m.ratio}x"
-        )
-      end)
+      Enum.each(r.metric_detail, &print_metric_detail/1)
     end
   end
 
+  defp print_metric_detail(m) do
+    scalar_str = if m.scalar >= 0, do: "+#{m.scalar}", else: "#{m.scalar}"
+
+    IO.puts(
+      "      " <>
+        pad("#{m.group}.#{m.key}", 45) <>
+        pad(scalar_str, 7) <>
+        pad(fmt(m.bad), 8) <>
+        pad(fmt(m.good), 8) <>
+        "#{m.ratio}x"
+    )
+  end
+
   defp print_file_scores(path, opts) do
     expanded = Path.expand(path)
 
     files =
       cond do
         File.dir?(expanded) ->
-          CodeQA.Engine.Collector.collect_files(expanded)
+          Collector.collect_files(expanded)
 
         File.regular?(expanded) ->
           %{Path.basename(expanded) => File.read!(expanded)}
@@ -152,18 +158,18 @@ defmodule Mix.Tasks.Codeqa.SampleReport do
 
       aggregate =
         files
-        |> CodeQA.Engine.Analyzer.analyze_codebase()
+        |> Analyzer.analyze_codebase()
         |> get_in(["codebase", "aggregate"])
 
       top_n = opts[:top] || 15
-      issues = CodeQA.CombinedMetrics.SampleRunner.diagnose_aggregate(aggregate, top: top_n)
+      issues = SampleRunner.diagnose_aggregate(aggregate, top: top_n)
       IO.puts("\nTop #{top_n} likely issues (by cosine similarity):")
       IO.puts(String.duplicate("-", 75))
       IO.puts("  " <> pad("behavior", 38) <> pad("cosine", 9) <> "score")
       Enum.each(issues, &print_issue_row/1)
 
       IO.puts("\nFull breakdown by category:")
-      combined = CodeQA.CombinedMetrics.SampleRunner.score_aggregate(aggregate)
+      combined = SampleRunner.score_aggregate(aggregate)
       IO.puts("")
       Enum.each(combined, &print_combined_category/1)
     else
diff --git a/priv/combined_metrics/code_smells.yml b/priv/combined_metrics/code_smells.yml
index f1c73c5..2201f7d 100644
--- a/priv/combined_metrics/code_smells.yml
+++ b/priv/combined_metrics/code_smells.yml
@@ -1,5 +1,6 @@
 consistent_string_quote_style:
   _doc: "Files should use a single, consistent string quoting style throughout."
+  _languages: [elixir]
   _log_baseline: -18.2553
   branching:
     mean_branching_density: 0.0243
@@ -101,6 +102,7 @@ consistent_string_quote_style:
 
 no_dead_code_after_return:
   _doc: "There should be no unreachable statements after a return or early exit."
+  _languages: [elixir]
   _log_baseline: -55.8435
   branching:
     mean_branch_count: -2.0000
@@ -211,6 +213,7 @@ no_dead_code_after_return:
 
 no_debug_print_statements:
   _doc: "Debug output (`console.log`, `IO.inspect`, `fmt.Println`) must not be left in committed code."
+  _languages: [elixir]
   _log_baseline: -88.0844
   branching:
     mean_branch_count: -0.3540
@@ -321,6 +324,7 @@ no_debug_print_statements:
 
 no_fixme_comments:
   _doc: "FIXME, XXX, and HACK comments indicate known problems that should be resolved before merging."
+  _languages: [elixir]
   _log_baseline: -2.0233
   branching:
     mean_branch_count: 0.1755
@@ -435,6 +439,7 @@ no_fixme_comments:
 
 no_nested_ternary:
   _doc: "Nested conditional expressions (ternary-within-ternary) are harder to read than a plain if-else."
+  _languages: [elixir]
   _log_baseline: 7.6475
   branching:
     mean_branch_count: -0.5662
diff --git a/priv/combined_metrics/variable_naming.yml b/priv/combined_metrics/variable_naming.yml
index 1be9c6b..e7bc6fa 100644
--- a/priv/combined_metrics/variable_naming.yml
+++ b/priv/combined_metrics/variable_naming.yml
@@ -1,5 +1,6 @@
 boolean_has_is_has_prefix:
   _doc: "Boolean variables should be prefixed with `is_`, `has_`, or `can_`."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 15.9481
   brevity:
     mean_sample_size: 0.0752
@@ -62,6 +63,7 @@ boolean_has_is_has_prefix:
 
 collection_name_is_plural:
   _doc: "Variables holding a collection should use a plural name."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 21.8380
   brevity:
     mean_sample_size: -0.5320
@@ -123,6 +125,7 @@ collection_name_is_plural:
 
 loop_var_is_single_letter:
   _doc: "Loop index variables (`i`, `j`, `k`) are acceptable inside loop bodies."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -28.3218
   brevity:
     mean_sample_size: -0.1049
@@ -202,6 +205,7 @@ loop_var_is_single_letter:
 
 name_contains_and:
   _doc: "Variable names containing `and` signal a variable that holds two concerns."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 0.4689
   branching:
     mean_branch_count: -0.3666
@@ -320,6 +324,7 @@ name_contains_and:
 
 name_contains_type_suffix:
   _doc: "Type suffixes in names (`userString`, `nameList`) are redundant noise."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -26.6817
   branching:
     mean_branch_count: -0.4150
@@ -405,6 +410,7 @@ name_contains_type_suffix:
 
 name_is_abbreviation:
   _doc: "Abbreviated names (`usr`, `cfg`, `mgr`) reduce readability."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 10.7370
   brevity:
     mean_sample_size: -0.1542
@@ -491,6 +497,7 @@ name_is_abbreviation:
 
 name_is_generic:
   _doc: "Generic names (`data`, `result`, `tmp`, `val`, `obj`) convey no domain meaning."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 37.4815
   branching:
     mean_branch_count: 0.5193
@@ -607,6 +614,7 @@ name_is_generic:
 
 name_is_number_like:
   _doc: "Number-suffixed names (`var1`, `thing2`) signal a missing abstraction."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 1.7611
   brevity:
     mean_sample_size: -0.0262
@@ -685,6 +693,7 @@ name_is_number_like:
 
 name_is_single_letter:
   _doc: "Single-letter names outside loop indices are too opaque."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 26.2113
   branching:
     mean_branching_density: -0.0458
@@ -782,6 +791,7 @@ name_is_single_letter:
 
 name_is_too_long:
   _doc: "Names longer than ~30 characters harm readability."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -7.8322
   branching:
     mean_branch_count: 0.0340
@@ -902,6 +912,7 @@ name_is_too_long:
 
 name_is_too_short:
   _doc: "Names shorter than 3 characters (outside loops) are too opaque."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -2.7224
   branching:
     mean_branch_count: -0.2327
@@ -989,6 +1000,7 @@ name_is_too_short:
 
 negated_boolean_name:
   _doc: "Negated boolean names (`isNotValid`, `notActive`) are harder to reason about."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -4.4565
   brevity:
     mean_sample_size: -0.0998
@@ -1059,6 +1071,7 @@ negated_boolean_name:
 
 no_hungarian_notation:
   _doc: "Hungarian notation prefixes (`strName`, `bFlag`) add noise without type safety."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -15.5962
   brevity:
     mean_sample_size: -0.0814
@@ -1134,6 +1147,7 @@ no_hungarian_notation:
 
 screaming_snake_for_constants:
   _doc: "Module-level constants should use SCREAMING_SNAKE_CASE."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -5.9884
   branching:
     mean_branching_density: 0.0176
diff --git a/test/codeqa/analysis/behavior_config_server_test.exs b/test/codeqa/analysis/behavior_config_server_test.exs
index b8afe6a..ebcc31b 100644
--- a/test/codeqa/analysis/behavior_config_server_test.exs
+++ b/test/codeqa/analysis/behavior_config_server_test.exs
@@ -16,7 +16,7 @@ defmodule CodeQA.Analysis.BehaviorConfigServerTest do
     Enum.each(behaviors, fn {category, list} ->
       assert is_binary(category)
       assert is_list(list)
-      assert length(list) > 0
+      assert list != []
 
       Enum.each(list, fn {behavior, data} ->
         assert is_binary(behavior)
diff --git a/test/codeqa/analysis/file_metrics_server_test.exs b/test/codeqa/analysis/file_metrics_server_test.exs
index 791c315..b68f4b3 100644
--- a/test/codeqa/analysis/file_metrics_server_test.exs
+++ b/test/codeqa/analysis/file_metrics_server_test.exs
@@ -2,9 +2,10 @@ defmodule CodeQA.Analysis.FileMetricsServerTest do
   use ExUnit.Case, async: true
 
   alias CodeQA.Analysis.FileMetricsServer
+  alias CodeQA.Engine.Analyzer
 
   defp build_registry do
-    CodeQA.Engine.Analyzer.build_registry()
+    Analyzer.build_registry()
   end
 
   setup do
diff --git a/test/codeqa/ast/classification/node_classifier_test.exs b/test/codeqa/ast/classification/node_classifier_test.exs
index 5ec0055..f266a2f 100644
--- a/test/codeqa/ast/classification/node_classifier_test.exs
+++ b/test/codeqa/ast/classification/node_classifier_test.exs
@@ -2,33 +2,34 @@ defmodule CodeQA.AST.NodeClassifierTest do
   use ExUnit.Case, async: true
 
   alias CodeQA.AST.Classification.NodeClassifier
-  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Enrichment.Node
   alias CodeQA.AST.Lexing.Token
+  alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Parser
-  alias CodeQA.AST.Enrichment.Node
 
   alias CodeQA.AST.Nodes.{
+    AttributeNode,
     CodeNode,
     DocNode,
     FunctionNode,
-    ModuleNode,
     ImportNode,
-    AttributeNode,
+    ModuleNode,
     TestNode
   }
 
-  alias CodeQA.Languages.Code.Vm.Elixir, as: ElixirLang
-  alias CodeQA.Languages.Code.Scripting.Python
-  alias CodeQA.Languages.Code.Web.JavaScript
   alias CodeQA.Languages.Code.Native.Go
   alias CodeQA.Languages.Code.Native.Rust
+  alias CodeQA.Languages.Code.Scripting.Python
   alias CodeQA.Languages.Code.Scripting.Ruby
-  alias CodeQA.Languages.Code.Web.TypeScript
-  alias CodeQA.Languages.Code.Vm.Java
   alias CodeQA.Languages.Code.Vm.CSharp
+  alias CodeQA.Languages.Code.Vm.Elixir, as: ElixirLang
+  alias CodeQA.Languages.Code.Vm.Java
+  alias CodeQA.Languages.Code.Web.JavaScript
+  alias CodeQA.Languages.Code.Web.TypeScript
+  alias CodeQA.Languages.Unknown
 
   defp classify_first(code, opts \\ []) do
-    lang_mod = opts[:language_module] || CodeQA.Languages.Unknown
+    lang_mod = opts[:language_module] || Unknown
 
     [block | _] =
       code
@@ -155,7 +156,7 @@ defmodule CodeQA.AST.NodeClassifierTest do
       doc_token = %Token{kind: "<DOC>", content: ~s("""), line: 1, col: 0}
       nl = %Token{kind: "<NL>", content: "\n", line: 2, col: 0}
       node = node_with_tokens([doc_token, nl])
-      assert %DocNode{} = NodeClassifier.classify(node, CodeQA.Languages.Unknown)
+      assert %DocNode{} = NodeClassifier.classify(node, Unknown)
     end
   end
 
@@ -207,7 +208,7 @@ defmodule CodeQA.AST.NodeClassifierTest do
       node = node_with_tokens([nl])
 
       assert %CodeNode{} =
-               NodeClassifier.classify(node, CodeQA.Languages.Unknown)
+               NodeClassifier.classify(node, Unknown)
     end
   end
 
diff --git a/test/codeqa/ast/classification/node_protocol_test.exs b/test/codeqa/ast/classification/node_protocol_test.exs
index 54c922a..5e79a00 100644
--- a/test/codeqa/ast/classification/node_protocol_test.exs
+++ b/test/codeqa/ast/classification/node_protocol_test.exs
@@ -2,6 +2,8 @@ defmodule CodeQA.AST.NodeProtocolTest.FakeNode do
   defstruct [:tokens, :line_count, :children, :start_line, :end_line, :label]
 
   defimpl CodeQA.AST.Classification.NodeProtocol do
+    alias CodeQA.AST.Classification.NodeProtocol
+
     def tokens(n), do: n.tokens
     def line_count(n), do: n.line_count
     def children(n), do: n.children
@@ -12,7 +14,7 @@ defmodule CodeQA.AST.NodeProtocolTest.FakeNode do
     def flat_tokens(n) do
       if Enum.empty?(n.children),
         do: n.tokens,
-        else: Enum.flat_map(n.children, &CodeQA.AST.Classification.NodeProtocol.flat_tokens/1)
+        else: Enum.flat_map(n.children, &NodeProtocol.flat_tokens/1)
     end
   end
 end
@@ -21,6 +23,7 @@ defmodule CodeQA.AST.NodeProtocolTest do
   use ExUnit.Case, async: true
 
   alias CodeQA.AST.Classification.NodeProtocol
+  alias CodeQA.AST.Enrichment.Node
   alias CodeQA.AST.NodeProtocolTest.FakeNode
 
   @node %FakeNode{
@@ -57,8 +60,6 @@ defmodule CodeQA.AST.NodeProtocolTest do
   end
 
   describe "flat_tokens/1" do
-    alias CodeQA.AST.Enrichment.Node
-
     test "leaf node returns own tokens" do
       leaf = %Node{tokens: [:a, :b], line_count: 1, children: []}
       assert NodeProtocol.flat_tokens(leaf) == [:a, :b]
@@ -80,8 +81,6 @@ defmodule CodeQA.AST.NodeProtocolTest do
   end
 
   describe "Node implements NodeProtocol" do
-    alias CodeQA.AST.Enrichment.Node
-
     setup do
       node = %Node{
         tokens: [:x, :y],
diff --git a/test/codeqa/ast/classification/node_type_detector_test.exs b/test/codeqa/ast/classification/node_type_detector_test.exs
index caf0c7f..f4c9753 100644
--- a/test/codeqa/ast/classification/node_type_detector_test.exs
+++ b/test/codeqa/ast/classification/node_type_detector_test.exs
@@ -1,11 +1,15 @@
 defmodule CodeQA.AST.Classification.NodeTypeDetectorTest do
   use ExUnit.Case, async: true
-  alias CodeQA.AST.Parsing.Parser
   alias CodeQA.AST.Classification.NodeTypeDetector
+  alias CodeQA.AST.Enrichment.Node
+  alias CodeQA.AST.Lexing.Token
   alias CodeQA.AST.Lexing.TokenNormalizer
-  alias CodeQA.AST.Nodes.{CodeNode, DocNode, AttributeNode, FunctionNode}
+  alias CodeQA.AST.Nodes.{AttributeNode, CodeNode, DocNode, FunctionNode}
+  alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.Languages.Code.Vm.Elixir, as: ElixirLang
+  alias CodeQA.Languages.Unknown
 
-  defp detect_types(code, lang_mod \\ CodeQA.Languages.Code.Vm.Elixir) do
+  defp detect_types(code, lang_mod \\ ElixirLang) do
     code
     |> TokenNormalizer.normalize_structural()
     |> Parser.detect_blocks(lang_mod)
@@ -70,16 +74,16 @@ defmodule CodeQA.AST.Classification.NodeTypeDetectorTest do
     end
 
     test "empty list returns empty list" do
-      assert [] == NodeTypeDetector.detect_types([], CodeQA.Languages.Unknown)
+      assert [] == NodeTypeDetector.detect_types([], Unknown)
     end
   end
 
   describe "detect_types/1 — typed struct output" do
     test "returns DocNode for doc blocks" do
-      doc_token = %CodeQA.AST.Lexing.Token{kind: "<DOC>", content: ~s("""), line: 1, col: 0}
-      nl = %CodeQA.AST.Lexing.Token{kind: "<NL>", content: "\n", line: 2, col: 0}
+      doc_token = %Token{kind: "<DOC>", content: ~s("""), line: 1, col: 0}
+      nl = %Token{kind: "<NL>", content: "\n", line: 2, col: 0}
 
-      node = %CodeQA.AST.Enrichment.Node{
+      node = %Node{
         tokens: [doc_token, nl],
         line_count: 2,
         children: [],
@@ -88,20 +92,20 @@ defmodule CodeQA.AST.Classification.NodeTypeDetectorTest do
       }
 
       [result] =
-        CodeQA.AST.Classification.NodeTypeDetector.detect_types(
+        NodeTypeDetector.detect_types(
           [node],
-          CodeQA.Languages.Code.Vm.Elixir
+          ElixirLang
         )
 
       assert is_struct(result, DocNode)
     end
 
     test "returns AttributeNode for typespec blocks" do
-      at = %CodeQA.AST.Lexing.Token{kind: "@", content: "@", line: 1, col: 0}
-      spec = %CodeQA.AST.Lexing.Token{kind: "<ID>", content: "spec", line: 1, col: 1}
-      nl = %CodeQA.AST.Lexing.Token{kind: "<NL>", content: "\n", line: 1, col: 5}
+      at = %Token{kind: "@", content: "@", line: 1, col: 0}
+      spec = %Token{kind: "<ID>", content: "spec", line: 1, col: 1}
+      nl = %Token{kind: "<NL>", content: "\n", line: 1, col: 5}
 
-      node = %CodeQA.AST.Enrichment.Node{
+      node = %Node{
         tokens: [at, spec, nl],
         line_count: 1,
         children: [],
@@ -110,9 +114,9 @@ defmodule CodeQA.AST.Classification.NodeTypeDetectorTest do
       }
 
       [result] =
-        CodeQA.AST.Classification.NodeTypeDetector.detect_types(
+        NodeTypeDetector.detect_types(
           [node],
-          CodeQA.Languages.Code.Vm.Elixir
+          ElixirLang
         )
 
       assert is_struct(result, AttributeNode)
@@ -120,10 +124,10 @@ defmodule CodeQA.AST.Classification.NodeTypeDetectorTest do
     end
 
     test "returns CodeNode for unclassified blocks" do
-      id = %CodeQA.AST.Lexing.Token{kind: "<ID>", content: "foo", line: 1, col: 0}
-      nl = %CodeQA.AST.Lexing.Token{kind: "<NL>", content: "\n", line: 1, col: 3}
+      id = %Token{kind: "<ID>", content: "foo", line: 1, col: 0}
+      nl = %Token{kind: "<NL>", content: "\n", line: 1, col: 3}
 
-      node = %CodeQA.AST.Enrichment.Node{
+      node = %Node{
         tokens: [id, nl],
         line_count: 1,
         children: [],
@@ -132,9 +136,9 @@ defmodule CodeQA.AST.Classification.NodeTypeDetectorTest do
       }
 
       [result] =
-        CodeQA.AST.Classification.NodeTypeDetector.detect_types(
+        NodeTypeDetector.detect_types(
           [node],
-          CodeQA.Languages.Code.Vm.Elixir
+          ElixirLang
         )
 
       assert is_struct(result, CodeNode)
diff --git a/test/codeqa/ast/enrichment/compound_node_assertions_languages_test.exs b/test/codeqa/ast/enrichment/compound_node_assertions_languages_test.exs
index d1e1b8f..3a6adbb 100644
--- a/test/codeqa/ast/enrichment/compound_node_assertions_languages_test.exs
+++ b/test/codeqa/ast/enrichment/compound_node_assertions_languages_test.exs
@@ -1,14 +1,14 @@
 defmodule CodeQA.AST.Enrichment.CompoundNodeAssertionsLanguagesTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Lexing.TokenNormalizer
-  alias CodeQA.AST.Parsing.Parser
-  alias CodeQA.Languages.Unknown
-  alias CodeQA.AST.Classification.NodeTypeDetector
   alias CodeQA.AST.Classification.NodeProtocol
-  alias CodeQA.AST.Enrichment.CompoundNodeBuilder
+  alias CodeQA.AST.Classification.NodeTypeDetector
   alias CodeQA.AST.Enrichment.CompoundNode
+  alias CodeQA.AST.Enrichment.CompoundNodeBuilder
   alias CodeQA.AST.Enrichment.Node
+  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.Languages.Unknown
 
   Module.register_attribute(__MODULE__, :fixture, accumulate: true, persist: false)
 
diff --git a/test/codeqa/ast/enrichment/compound_node_builder_test.exs b/test/codeqa/ast/enrichment/compound_node_builder_test.exs
index 3881e9e..00a1006 100644
--- a/test/codeqa/ast/enrichment/compound_node_builder_test.exs
+++ b/test/codeqa/ast/enrichment/compound_node_builder_test.exs
@@ -1,13 +1,12 @@
 defmodule CodeQA.AST.Enrichment.CompoundNodeBuilderTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Parsing.Parser
   alias CodeQA.AST.Classification.NodeTypeDetector
   alias CodeQA.AST.Enrichment.CompoundNode
   alias CodeQA.AST.Enrichment.CompoundNodeBuilder
   alias CodeQA.AST.Lexing.TokenNormalizer
-
-  alias CodeQA.AST.Nodes.{DocNode, AttributeNode, CodeNode}
+  alias CodeQA.AST.Nodes.{AttributeNode, CodeNode, DocNode}
+  alias CodeQA.AST.Parsing.Parser
 
   defp build(code) do
     lang_mod = CodeQA.Languages.Code.Vm.Elixir
@@ -112,7 +111,7 @@ defmodule CodeQA.AST.Enrichment.CompoundNodeBuilderTest do
       doc = %DocNode{tokens: [:d], line_count: 1, children: [], start_line: 1, end_line: 1}
       code = %CodeNode{tokens: [:c], line_count: 2, children: [], start_line: 2, end_line: 3}
 
-      [compound] = CodeQA.AST.Enrichment.CompoundNodeBuilder.build([doc, code])
+      [compound] = CompoundNodeBuilder.build([doc, code])
       assert length(compound.docs) == 1
       assert is_struct(hd(compound.docs), DocNode)
     end
@@ -129,7 +128,7 @@ defmodule CodeQA.AST.Enrichment.CompoundNodeBuilderTest do
 
       code = %CodeNode{tokens: [:c], line_count: 2, children: [], start_line: 2, end_line: 3}
 
-      [compound] = CodeQA.AST.Enrichment.CompoundNodeBuilder.build([attr, code])
+      [compound] = CompoundNodeBuilder.build([attr, code])
       assert length(compound.typespecs) == 1
       assert is_struct(hd(compound.typespecs), AttributeNode)
     end
diff --git a/test/codeqa/ast/lexing/token_normalizer_test.exs b/test/codeqa/ast/lexing/token_normalizer_test.exs
index e8264ad..19a886a 100644
--- a/test/codeqa/ast/lexing/token_normalizer_test.exs
+++ b/test/codeqa/ast/lexing/token_normalizer_test.exs
@@ -1,8 +1,8 @@
 defmodule CodeQA.AST.TokenNormalizerTest do
   use ExUnit.Case, async: true
-  alias CodeQA.AST.Lexing.TokenNormalizer
-  alias CodeQA.AST.Lexing.Token
   alias CodeQA.AST.Lexing.StringToken
+  alias CodeQA.AST.Lexing.Token
+  alias CodeQA.AST.Lexing.TokenNormalizer
 
   defp kinds(tokens), do: Enum.map(tokens, & &1.kind)
 
diff --git a/test/codeqa/ast/lexing/token_protocol_test.exs b/test/codeqa/ast/lexing/token_protocol_test.exs
index 5534d10..340d94a 100644
--- a/test/codeqa/ast/lexing/token_protocol_test.exs
+++ b/test/codeqa/ast/lexing/token_protocol_test.exs
@@ -1,8 +1,8 @@
 defmodule CodeQA.AST.Lexing.TokenProtocolTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Lexing.Token
   alias CodeQA.AST.Lexing.StringToken
+  alias CodeQA.AST.Lexing.Token
   alias CodeQA.AST.Lexing.TokenProtocol
 
   describe "Token implementation" do
diff --git a/test/codeqa/ast/nodes/code_node_test.exs b/test/codeqa/ast/nodes/code_node_test.exs
index f161ad8..20082f0 100644
--- a/test/codeqa/ast/nodes/code_node_test.exs
+++ b/test/codeqa/ast/nodes/code_node_test.exs
@@ -1,8 +1,8 @@
 defmodule CodeQA.AST.Nodes.CodeNodeTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Nodes.{CodeNode, DocNode}
   alias CodeQA.AST.Classification.NodeProtocol
+  alias CodeQA.AST.Nodes.{CodeNode, DocNode}
 
   @tokens [:a, :b, :c]
 
diff --git a/test/codeqa/ast/nodes/function_node_test.exs b/test/codeqa/ast/nodes/function_node_test.exs
index 029a2a7..a1770bc 100644
--- a/test/codeqa/ast/nodes/function_node_test.exs
+++ b/test/codeqa/ast/nodes/function_node_test.exs
@@ -1,8 +1,8 @@
 defmodule CodeQA.AST.Nodes.FunctionNodeTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Nodes.{FunctionNode, ModuleNode}
   alias CodeQA.AST.Classification.NodeProtocol
+  alias CodeQA.AST.Nodes.{FunctionNode, ModuleNode}
 
   describe "FunctionNode" do
     setup do
diff --git a/test/codeqa/ast/nodes/import_node_test.exs b/test/codeqa/ast/nodes/import_node_test.exs
index 16c6771..53c4a98 100644
--- a/test/codeqa/ast/nodes/import_node_test.exs
+++ b/test/codeqa/ast/nodes/import_node_test.exs
@@ -1,8 +1,8 @@
 defmodule CodeQA.AST.Nodes.ImportNodeTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Nodes.{ImportNode, AttributeNode, TestNode}
   alias CodeQA.AST.Classification.NodeProtocol
+  alias CodeQA.AST.Nodes.{AttributeNode, ImportNode, TestNode}
 
   describe "ImportNode" do
     test "implements NodeProtocol" do
diff --git a/test/codeqa/ast/parsing/parser_languages_test.exs b/test/codeqa/ast/parsing/parser_languages_test.exs
index e2f3040..5526d10 100644
--- a/test/codeqa/ast/parsing/parser_languages_test.exs
+++ b/test/codeqa/ast/parsing/parser_languages_test.exs
@@ -1,8 +1,8 @@
 defmodule CodeQA.AST.Parsing.ParserLanguagesTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Parsing.Parser
   alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Parsing.Parser
   alias CodeQA.Language
   alias CodeQA.Languages.Unknown
 
@@ -118,13 +118,13 @@ defmodule CodeQA.AST.Parsing.ParserLanguagesTest do
                                 code
                               end, block_assertions}
 
-  defp blocks(code, lang_mod \\ CodeQA.Languages.Unknown) do
+  defp blocks(code, lang_mod \\ Unknown) do
     code
     |> TokenNormalizer.normalize_structural()
     |> Parser.detect_blocks(lang_mod)
   end
 
-  defp children(code, lang_mod \\ CodeQA.Languages.Unknown) do
+  defp children(code, lang_mod \\ Unknown) do
     code
     |> TokenNormalizer.normalize_structural()
     |> Parser.detect_blocks(lang_mod)
@@ -141,7 +141,7 @@ defmodule CodeQA.AST.Parsing.ParserLanguagesTest do
         result = blocks(unquote(code), lang_mod)
 
         if unquote(lang_mod) == Unknown do
-          assert length(result) >= 1
+          assert result != []
         else
           assert length(result) >= 3
         end
@@ -152,7 +152,7 @@ defmodule CodeQA.AST.Parsing.ParserLanguagesTest do
         result = children(unquote(code), lang_mod)
 
         if unquote(lang_mod) == Unknown do
-          assert length(result) >= 0
+          assert is_list(result)
         else
           assert length(result) >= 3
         end
diff --git a/test/codeqa/ast/parsing/parser_test.exs b/test/codeqa/ast/parsing/parser_test.exs
index c37a8a8..51ead52 100644
--- a/test/codeqa/ast/parsing/parser_test.exs
+++ b/test/codeqa/ast/parsing/parser_test.exs
@@ -1,9 +1,10 @@
 defmodule CodeQA.AST.Parsing.ParserTest do
   use ExUnit.Case, async: true
-  alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.AST.Enrichment.Node
   alias CodeQA.AST.Lexing.TokenNormalizer
-  alias CodeQA.Languages.Code.Vm.Elixir, as: ElixirLang
+  alias CodeQA.AST.Parsing.Parser
   alias CodeQA.Languages.Code.Scripting.Python
+  alias CodeQA.Languages.Code.Vm.Elixir, as: ElixirLang
   alias CodeQA.Languages.Unknown
 
   defp tokenize(code), do: TokenNormalizer.normalize_structural(code)
@@ -54,7 +55,6 @@ defmodule CodeQA.AST.Parsing.ParserTest do
     end
 
     test "block has children_count accessible via Node.children_count/1" do
-      alias CodeQA.AST.Enrichment.Node
       tokens = tokenize("foo(a)\nbar(b)\n")
       [block] = Parser.detect_blocks(tokens, Unknown)
       assert Node.children_count(block) == length(block.children)
diff --git a/test/codeqa/ast/parsing/signal_stream_test.exs b/test/codeqa/ast/parsing/signal_stream_test.exs
index 20c9226..69cfcaf 100644
--- a/test/codeqa/ast/parsing/signal_stream_test.exs
+++ b/test/codeqa/ast/parsing/signal_stream_test.exs
@@ -1,8 +1,8 @@
 defmodule CodeQA.AST.SignalStreamTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Parsing.SignalStream
   alias CodeQA.AST.Lexing.Token
+  alias CodeQA.AST.Parsing.SignalStream
   alias CodeQA.Support.CounterSignal
 
   defp tok(kind, content), do: %Token{kind: kind, content: content, line: 1, col: 0}
diff --git a/test/codeqa/ast/signals/classification/comment_density_signal_test.exs b/test/codeqa/ast/signals/classification/comment_density_signal_test.exs
index 71069d7..374b191 100644
--- a/test/codeqa/ast/signals/classification/comment_density_signal_test.exs
+++ b/test/codeqa/ast/signals/classification/comment_density_signal_test.exs
@@ -1,7 +1,7 @@
 defmodule CodeQA.AST.Signals.Classification.CommentDensitySignalTest do
   use ExUnit.Case, async: true
-  alias CodeQA.AST.Signals.Classification.CommentDensitySignal
   alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Signals.Classification.CommentDensitySignal
   alias CodeQA.Languages.Code.Scripting.Python
   alias CodeQA.Languages.Unknown
 
diff --git a/test/codeqa/ast/signals/classification/config_signal_test.exs b/test/codeqa/ast/signals/classification/config_signal_test.exs
index 5c63672..da510c2 100644
--- a/test/codeqa/ast/signals/classification/config_signal_test.exs
+++ b/test/codeqa/ast/signals/classification/config_signal_test.exs
@@ -1,7 +1,7 @@
 defmodule CodeQA.AST.Signals.Classification.ConfigSignalTest do
   use ExUnit.Case, async: true
-  alias CodeQA.AST.Signals.Classification.ConfigSignal
   alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Signals.Classification.ConfigSignal
 
   defp run(tokens), do: SignalStream.run(tokens, [%ConfigSignal{}], []) |> List.flatten()
   defp t(content, kind \\ "<ID>"), do: %{kind: kind, content: content, line: 1, col: 0}
diff --git a/test/codeqa/ast/signals/classification/data_signal_test.exs b/test/codeqa/ast/signals/classification/data_signal_test.exs
index c537f95..852067b 100644
--- a/test/codeqa/ast/signals/classification/data_signal_test.exs
+++ b/test/codeqa/ast/signals/classification/data_signal_test.exs
@@ -1,7 +1,7 @@
 defmodule CodeQA.AST.Signals.Classification.DataSignalTest do
   use ExUnit.Case, async: true
-  alias CodeQA.AST.Signals.Classification.DataSignal
   alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Signals.Classification.DataSignal
 
   defp run(tokens), do: SignalStream.run(tokens, [%DataSignal{}], []) |> List.flatten()
 
diff --git a/test/codeqa/ast/signals/classification/type_signal_test.exs b/test/codeqa/ast/signals/classification/type_signal_test.exs
index 96811e6..aa400d3 100644
--- a/test/codeqa/ast/signals/classification/type_signal_test.exs
+++ b/test/codeqa/ast/signals/classification/type_signal_test.exs
@@ -1,7 +1,7 @@
 defmodule CodeQA.AST.Signals.Classification.TypeSignalTest do
   use ExUnit.Case, async: true
-  alias CodeQA.AST.Signals.Classification.TypeSignal
   alias CodeQA.AST.Parsing.SignalStream
+  alias CodeQA.AST.Signals.Classification.TypeSignal
 
   defp run(tokens), do: SignalStream.run(tokens, [%TypeSignal{}], []) |> List.flatten()
 
diff --git a/test/codeqa/ast/signals/structural/access_modifier_signal_test.exs b/test/codeqa/ast/signals/structural/access_modifier_signal_test.exs
index 5300881..2a86352 100644
--- a/test/codeqa/ast/signals/structural/access_modifier_signal_test.exs
+++ b/test/codeqa/ast/signals/structural/access_modifier_signal_test.exs
@@ -1,10 +1,10 @@
 defmodule CodeQA.AST.Signals.Structural.AccessModifierSignalTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Signals.Structural.AccessModifierSignal
+  alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Signal
   alias CodeQA.AST.Parsing.SignalStream
-  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Signals.Structural.AccessModifierSignal
   alias CodeQA.Languages.Code.Vm.Java
 
   defp split_values(code, lang_mod) do
diff --git a/test/codeqa/ast/signals/structural/assignment_function_signal_test.exs b/test/codeqa/ast/signals/structural/assignment_function_signal_test.exs
index 534b735..bd76abf 100644
--- a/test/codeqa/ast/signals/structural/assignment_function_signal_test.exs
+++ b/test/codeqa/ast/signals/structural/assignment_function_signal_test.exs
@@ -1,10 +1,10 @@
 defmodule CodeQA.AST.Signals.Structural.AssignmentFunctionSignalTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Signals.Structural.AssignmentFunctionSignal
+  alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Signal
   alias CodeQA.AST.Parsing.SignalStream
-  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Signals.Structural.AssignmentFunctionSignal
 
   defp split_indices(code) do
     tokens = TokenNormalizer.normalize_structural(code)
diff --git a/test/codeqa/ast/signals/structural/blank_line_signal_test.exs b/test/codeqa/ast/signals/structural/blank_line_signal_test.exs
index 464ca46..4e7d9d2 100644
--- a/test/codeqa/ast/signals/structural/blank_line_signal_test.exs
+++ b/test/codeqa/ast/signals/structural/blank_line_signal_test.exs
@@ -1,10 +1,10 @@
 defmodule CodeQA.AST.Signals.Structural.BlankLineSignalTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Signals.Structural.BlankLineSignal
+  alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Signal
   alias CodeQA.AST.Parsing.SignalStream
-  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Signals.Structural.BlankLineSignal
   alias CodeQA.Languages.Code.Vm.Elixir, as: ElixirLang
 
   defp split_values(code, lang_mod) do
diff --git a/test/codeqa/ast/signals/structural/bracket_signal_test.exs b/test/codeqa/ast/signals/structural/bracket_signal_test.exs
index 4159b6b..611474b 100644
--- a/test/codeqa/ast/signals/structural/bracket_signal_test.exs
+++ b/test/codeqa/ast/signals/structural/bracket_signal_test.exs
@@ -1,10 +1,10 @@
 defmodule CodeQA.AST.Signals.Structural.BracketSignalTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Signals.Structural.BracketSignal
+  alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Signal
   alias CodeQA.AST.Parsing.SignalStream
-  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Signals.Structural.BracketSignal
 
   defp enclosure_values(code) do
     tokens = TokenNormalizer.normalize_structural(code)
diff --git a/test/codeqa/ast/signals/structural/branch_split_signal_test.exs b/test/codeqa/ast/signals/structural/branch_split_signal_test.exs
index 7a7eb94..320390c 100644
--- a/test/codeqa/ast/signals/structural/branch_split_signal_test.exs
+++ b/test/codeqa/ast/signals/structural/branch_split_signal_test.exs
@@ -1,13 +1,13 @@
 defmodule CodeQA.AST.Signals.Structural.BranchSplitSignalTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Signals.Structural.BranchSplitSignal
-  alias CodeQA.AST.Parsing.{Signal, SignalStream}
   alias CodeQA.AST.Lexing.TokenNormalizer
-  alias CodeQA.Languages.Code.Vm.Elixir, as: ElixirLang
+  alias CodeQA.AST.Parsing.{Signal, SignalStream}
+  alias CodeQA.AST.Signals.Structural.BranchSplitSignal
+  alias CodeQA.Languages.Code.Scripting.PHP
   alias CodeQA.Languages.Code.Scripting.Python
   alias CodeQA.Languages.Code.Scripting.Ruby
-  alias CodeQA.Languages.Code.Scripting.PHP
+  alias CodeQA.Languages.Code.Vm.Elixir, as: ElixirLang
   alias CodeQA.Languages.Code.Vm.Java
 
   defp split_values(code, lang_mod) do
@@ -83,7 +83,7 @@ defmodule CodeQA.AST.Signals.Structural.BranchSplitSignalTest do
     splits =
       split_values("switch x\n  case 1:\n    :a\n  case 2:\n    :b\nend\n", Java)
 
-    assert length(splits) >= 1
+    assert splits != []
   end
 
   test "emits split at when keyword" do
diff --git a/test/codeqa/ast/signals/structural/colon_indent_signal_test.exs b/test/codeqa/ast/signals/structural/colon_indent_signal_test.exs
index 484edf6..7ff96a0 100644
--- a/test/codeqa/ast/signals/structural/colon_indent_signal_test.exs
+++ b/test/codeqa/ast/signals/structural/colon_indent_signal_test.exs
@@ -1,11 +1,12 @@
 defmodule CodeQA.AST.Signals.Structural.ColonIndentSignalTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Signals.Structural.ColonIndentSignal
+  alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Signal
   alias CodeQA.AST.Parsing.SignalStream
-  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Signals.Structural.ColonIndentSignal
   alias CodeQA.Languages.Code.Scripting.Python
+  alias CodeQA.Languages.Unknown
 
   defp enclosure_values(code, lang_mod \\ Python) do
     tokens = TokenNormalizer.normalize_structural(code)
@@ -14,7 +15,7 @@ defmodule CodeQA.AST.Signals.Structural.ColonIndentSignalTest do
   end
 
   test "no enclosures for non-python language" do
-    assert enclosure_values("def foo:\n    return 1\n", CodeQA.Languages.Unknown) ==
+    assert enclosure_values("def foo:\n    return 1\n", Unknown) ==
              []
   end
 
diff --git a/test/codeqa/ast/signals/structural/comment_divider_signal_test.exs b/test/codeqa/ast/signals/structural/comment_divider_signal_test.exs
index 329c910..29762cb 100644
--- a/test/codeqa/ast/signals/structural/comment_divider_signal_test.exs
+++ b/test/codeqa/ast/signals/structural/comment_divider_signal_test.exs
@@ -1,10 +1,10 @@
 defmodule CodeQA.AST.Signals.Structural.CommentDividerSignalTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Signals.Structural.CommentDividerSignal
+  alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Signal
   alias CodeQA.AST.Parsing.SignalStream
-  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Signals.Structural.CommentDividerSignal
   alias CodeQA.Languages.Code.Vm.Elixir, as: ElixirLang
   alias CodeQA.Languages.Code.Vm.Java
   alias CodeQA.Languages.Data.Sql
diff --git a/test/codeqa/ast/signals/structural/decorator_signal_test.exs b/test/codeqa/ast/signals/structural/decorator_signal_test.exs
index b1474d7..6a5bb10 100644
--- a/test/codeqa/ast/signals/structural/decorator_signal_test.exs
+++ b/test/codeqa/ast/signals/structural/decorator_signal_test.exs
@@ -1,10 +1,10 @@
 defmodule CodeQA.AST.Signals.Structural.DecoratorSignalTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Signals.Structural.DecoratorSignal
+  alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Signal
   alias CodeQA.AST.Parsing.SignalStream
-  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Signals.Structural.DecoratorSignal
 
   defp split_values(code) do
     tokens = TokenNormalizer.normalize_structural(code)
diff --git a/test/codeqa/ast/signals/structural/dedent_to_zero_signal_test.exs b/test/codeqa/ast/signals/structural/dedent_to_zero_signal_test.exs
index 749e165..ddf8702 100644
--- a/test/codeqa/ast/signals/structural/dedent_to_zero_signal_test.exs
+++ b/test/codeqa/ast/signals/structural/dedent_to_zero_signal_test.exs
@@ -1,10 +1,10 @@
 defmodule CodeQA.AST.Signals.Structural.DedentToZeroSignalTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Signals.Structural.DedentToZeroSignal
+  alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Signal
   alias CodeQA.AST.Parsing.SignalStream
-  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Signals.Structural.DedentToZeroSignal
 
   defp split_count(code) do
     tokens = TokenNormalizer.normalize_structural(code)
diff --git a/test/codeqa/ast/signals/structural/doc_comment_lead_signal_test.exs b/test/codeqa/ast/signals/structural/doc_comment_lead_signal_test.exs
index 28965c4..da269e8 100644
--- a/test/codeqa/ast/signals/structural/doc_comment_lead_signal_test.exs
+++ b/test/codeqa/ast/signals/structural/doc_comment_lead_signal_test.exs
@@ -1,10 +1,10 @@
 defmodule CodeQA.AST.Signals.Structural.DocCommentLeadSignalTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Signals.Structural.DocCommentLeadSignal
+  alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Signal
   alias CodeQA.AST.Parsing.SignalStream
-  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Signals.Structural.DocCommentLeadSignal
 
   defp split_values(code) do
     tokens = TokenNormalizer.normalize_structural(code)
diff --git a/test/codeqa/ast/signals/structural/keyword_signal_test.exs b/test/codeqa/ast/signals/structural/keyword_signal_test.exs
index 4aecba6..b269c40 100644
--- a/test/codeqa/ast/signals/structural/keyword_signal_test.exs
+++ b/test/codeqa/ast/signals/structural/keyword_signal_test.exs
@@ -1,10 +1,10 @@
 defmodule CodeQA.AST.Signals.Structural.KeywordSignalTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Signals.Structural.KeywordSignal
+  alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Signal
   alias CodeQA.AST.Parsing.SignalStream
-  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Signals.Structural.KeywordSignal
   alias CodeQA.Languages.Code.Vm.Elixir, as: ElixirLang
 
   defp split_values(code, lang_mod) do
diff --git a/test/codeqa/ast/signals/structural/sql_block_signal_test.exs b/test/codeqa/ast/signals/structural/sql_block_signal_test.exs
index e655f8d..5f89598 100644
--- a/test/codeqa/ast/signals/structural/sql_block_signal_test.exs
+++ b/test/codeqa/ast/signals/structural/sql_block_signal_test.exs
@@ -1,10 +1,10 @@
 defmodule CodeQA.AST.Signals.Structural.SQLBlockSignalTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Signals.Structural.SQLBlockSignal
+  alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Signal
   alias CodeQA.AST.Parsing.SignalStream
-  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Signals.Structural.SQLBlockSignal
   alias CodeQA.Languages.Data.Sql
 
   defp split_values(code) do
diff --git a/test/codeqa/ast/signals/structural/triple_quote_signal_test.exs b/test/codeqa/ast/signals/structural/triple_quote_signal_test.exs
index fed5f3f..2b840bd 100644
--- a/test/codeqa/ast/signals/structural/triple_quote_signal_test.exs
+++ b/test/codeqa/ast/signals/structural/triple_quote_signal_test.exs
@@ -1,10 +1,10 @@
 defmodule CodeQA.AST.Signals.Structural.TripleQuoteSignalTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.AST.Signals.Structural.TripleQuoteSignal
+  alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Signal
   alias CodeQA.AST.Parsing.SignalStream
-  alias CodeQA.AST.Lexing.TokenNormalizer
+  alias CodeQA.AST.Signals.Structural.TripleQuoteSignal
 
   defp split_values(code) do
     tokens = TokenNormalizer.normalize_structural(code)
diff --git a/test/codeqa/block_impact/codebase_impact_test.exs b/test/codeqa/block_impact/codebase_impact_test.exs
index 0a0c264..55ef4b4 100644
--- a/test/codeqa/block_impact/codebase_impact_test.exs
+++ b/test/codeqa/block_impact/codebase_impact_test.exs
@@ -1,9 +1,10 @@
 defmodule CodeQA.BlockImpact.CodebaseImpactTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.BlockImpact.CodebaseImpact
   alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.BlockImpact.CodebaseImpact
+  alias CodeQA.Engine.Analyzer
   alias CodeQA.Languages.Unknown
 
   @content_a """
@@ -48,7 +49,7 @@ defmodule CodeQA.BlockImpact.CodebaseImpactTest do
       node = first_block(@content_a)
 
       if length(node.tokens) >= 10 do
-        baseline = CodeQA.Engine.Analyzer.analyze_codebase_aggregate(files_map())
+        baseline = Analyzer.analyze_codebase_aggregate(files_map())
         without = CodebaseImpact.compute("lib/a.ex", @content_a, node, files_map())
         # Not necessarily different in all keys, but result is valid
         assert is_map(without)
diff --git a/test/codeqa/block_impact/file_impact_test.exs b/test/codeqa/block_impact/file_impact_test.exs
index 3bffe8c..b44f0a9 100644
--- a/test/codeqa/block_impact/file_impact_test.exs
+++ b/test/codeqa/block_impact/file_impact_test.exs
@@ -1,9 +1,9 @@
 defmodule CodeQA.BlockImpact.FileImpactTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.BlockImpact.FileImpact
   alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Parser
+  alias CodeQA.BlockImpact.FileImpact
   alias CodeQA.Languages.Unknown
 
   @fixture_content """
diff --git a/test/codeqa/block_impact/refactoring_potentials_test.exs b/test/codeqa/block_impact/refactoring_potentials_test.exs
index d5f2014..a1252f2 100644
--- a/test/codeqa/block_impact/refactoring_potentials_test.exs
+++ b/test/codeqa/block_impact/refactoring_potentials_test.exs
@@ -4,6 +4,7 @@ defmodule CodeQA.BlockImpact.RefactoringPotentialsTest do
   alias CodeQA.BlockImpact.RefactoringPotentials
   alias CodeQA.CombinedMetrics.FileScorer
   alias CodeQA.CombinedMetrics.SampleRunner
+  alias CodeQA.Engine.Analyzer
 
   defp file_cosines(fm) do
     fm
@@ -27,13 +28,13 @@ defmodule CodeQA.BlockImpact.RefactoringPotentialsTest do
       end
       """
 
-      baseline_fm = CodeQA.Engine.Analyzer.analyze_file("lib/foo.ex", content)
+      baseline_fm = Analyzer.analyze_file("lib/foo.ex", content)
       simple = "defmodule Foo do\n  def bar, do: :ok\nend\n"
-      without_fm = CodeQA.Engine.Analyzer.analyze_file("lib/foo.ex", simple)
+      without_fm = Analyzer.analyze_file("lib/foo.ex", simple)
 
       files = %{"lib/foo.ex" => content}
-      baseline_agg = CodeQA.Engine.Analyzer.analyze_codebase_aggregate(files)
-      without_agg = CodeQA.Engine.Analyzer.analyze_codebase_aggregate(%{"lib/foo.ex" => simple})
+      baseline_agg = Analyzer.analyze_codebase_aggregate(files)
+      without_agg = Analyzer.analyze_codebase_aggregate(%{"lib/foo.ex" => simple})
 
       baseline_file_cosines = file_cosines(baseline_fm)
       baseline_codebase_cosines = SampleRunner.diagnose_aggregate(baseline_agg, top: 99_999)
@@ -60,8 +61,8 @@ defmodule CodeQA.BlockImpact.RefactoringPotentialsTest do
 
     test "returns at most top N results (default 3)" do
       content = "defmodule A do\n  def foo, do: 1\nend\n"
-      fm = CodeQA.Engine.Analyzer.analyze_file("lib/a.ex", content)
-      agg = CodeQA.Engine.Analyzer.analyze_codebase_aggregate(%{"lib/a.ex" => content})
+      fm = Analyzer.analyze_file("lib/a.ex", content)
+      agg = Analyzer.analyze_codebase_aggregate(%{"lib/a.ex" => content})
 
       baseline_file_cosines = file_cosines(fm)
       baseline_codebase_cosines = SampleRunner.diagnose_aggregate(agg, top: 99_999)
@@ -74,8 +75,8 @@ defmodule CodeQA.BlockImpact.RefactoringPotentialsTest do
 
     test "respects top: N option" do
       content = "defmodule A do\n  def foo, do: 1\nend\n"
-      fm = CodeQA.Engine.Analyzer.analyze_file("lib/a.ex", content)
-      agg = CodeQA.Engine.Analyzer.analyze_codebase_aggregate(%{"lib/a.ex" => content})
+      fm = Analyzer.analyze_file("lib/a.ex", content)
+      agg = Analyzer.analyze_codebase_aggregate(%{"lib/a.ex" => content})
 
       baseline_file_cosines = file_cosines(fm)
       baseline_codebase_cosines = SampleRunner.diagnose_aggregate(agg, top: 99_999)
@@ -90,8 +91,8 @@ defmodule CodeQA.BlockImpact.RefactoringPotentialsTest do
 
     test "results are sorted descending by cosine_delta" do
       content = "defmodule A do\n  def foo, do: 1\nend\n"
-      fm = CodeQA.Engine.Analyzer.analyze_file("lib/a.ex", content)
-      agg = CodeQA.Engine.Analyzer.analyze_codebase_aggregate(%{"lib/a.ex" => content})
+      fm = Analyzer.analyze_file("lib/a.ex", content)
+      agg = Analyzer.analyze_codebase_aggregate(%{"lib/a.ex" => content})
 
       baseline_file_cosines = file_cosines(fm)
       baseline_codebase_cosines = SampleRunner.diagnose_aggregate(agg, top: 99_999)
diff --git a/test/codeqa/block_impact_analyzer_test.exs b/test/codeqa/block_impact_analyzer_test.exs
index a8341e9..be644e9 100644
--- a/test/codeqa/block_impact_analyzer_test.exs
+++ b/test/codeqa/block_impact_analyzer_test.exs
@@ -3,6 +3,7 @@ defmodule CodeQA.BlockImpactAnalyzerTest do
   use ExUnit.Case, async: false
 
   alias CodeQA.BlockImpactAnalyzer
+  alias CodeQA.Engine.Analyzer
 
   @fixture_content """
   defmodule MyModule do
@@ -21,7 +22,7 @@ defmodule CodeQA.BlockImpactAnalyzerTest do
   describe "analyze/3" do
     test "adds 'nodes' key to each file entry in the pipeline result" do
       files = %{"lib/my_module.ex" => @fixture_content}
-      pipeline_result = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      pipeline_result = Analyzer.analyze_codebase(files)
 
       result = BlockImpactAnalyzer.analyze(pipeline_result, files)
 
@@ -34,7 +35,7 @@ defmodule CodeQA.BlockImpactAnalyzerTest do
 
     test "each node has required fields" do
       files = %{"lib/my_module.ex" => @fixture_content}
-      pipeline_result = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      pipeline_result = Analyzer.analyze_codebase(files)
       result = BlockImpactAnalyzer.analyze(pipeline_result, files)
 
       nodes = result["files"]["lib/my_module.ex"]["nodes"]
@@ -55,7 +56,7 @@ defmodule CodeQA.BlockImpactAnalyzerTest do
 
     test "nodes are sorted by start_line ascending" do
       files = %{"lib/my_module.ex" => @fixture_content}
-      pipeline_result = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      pipeline_result = Analyzer.analyze_codebase(files)
       result = BlockImpactAnalyzer.analyze(pipeline_result, files)
 
       nodes = result["files"]["lib/my_module.ex"]["nodes"]
@@ -65,7 +66,7 @@ defmodule CodeQA.BlockImpactAnalyzerTest do
 
     test "preserves existing 'codebase' key in pipeline result" do
       files = %{"lib/my_module.ex" => @fixture_content}
-      pipeline_result = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      pipeline_result = Analyzer.analyze_codebase(files)
       result = BlockImpactAnalyzer.analyze(pipeline_result, files)
 
       assert Map.has_key?(result, "codebase")
@@ -74,7 +75,7 @@ defmodule CodeQA.BlockImpactAnalyzerTest do
 
     test "nodes_top option limits refactoring_potentials per node" do
       files = %{"lib/my_module.ex" => @fixture_content}
-      pipeline_result = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      pipeline_result = Analyzer.analyze_codebase(files)
       result = BlockImpactAnalyzer.analyze(pipeline_result, files, nodes_top: 1)
 
       nodes = result["files"]["lib/my_module.ex"]["nodes"]
diff --git a/test/codeqa/combined_metrics/file_scorer_test.exs b/test/codeqa/combined_metrics/file_scorer_test.exs
index c280cd3..55ef933 100644
--- a/test/codeqa/combined_metrics/file_scorer_test.exs
+++ b/test/codeqa/combined_metrics/file_scorer_test.exs
@@ -262,7 +262,7 @@ defmodule CodeQA.CombinedMetrics.FileScorerTest do
             "vocabulary" => 60.0,
             "volume" => 1200.0,
             "difficulty" => 30.0,
-            "effort" => 36000.0,
+            "effort" => 36_000.0,
             "bugs" => 0.4
           },
           "branching" => %{
diff --git a/test/codeqa/combined_metrics/sample_runner_test.exs b/test/codeqa/combined_metrics/sample_runner_test.exs
index 103b805..c1986aa 100644
--- a/test/codeqa/combined_metrics/sample_runner_test.exs
+++ b/test/codeqa/combined_metrics/sample_runner_test.exs
@@ -2,6 +2,9 @@ defmodule CodeQA.CombinedMetrics.SampleRunnerTest do
   use ExUnit.Case
 
   alias CodeQA.CombinedMetrics.SampleRunner
+  alias CodeQA.Engine.Analyzer
+  alias CodeQA.Engine.Collector
+  alias CodeQA.HealthReport.Grader
 
   setup_all do
     results = SampleRunner.run(category: "variable_naming", verbose: true)
@@ -22,7 +25,7 @@ defmodule CodeQA.CombinedMetrics.SampleRunnerTest do
       {:ok, data} = YamlElixir.read_from_file("priv/combined_metrics/variable_naming.yml")
       langs = get_in(data, ["name_is_generic", "_languages"])
       assert is_list(langs)
-      assert length(langs) > 0
+      assert langs != []
       assert Enum.all?(langs, &is_binary/1)
     end
 
@@ -34,7 +37,7 @@ defmodule CodeQA.CombinedMetrics.SampleRunnerTest do
         if is_map(groups) do
           case Map.get(groups, "_languages") do
             nil -> :ok
-            langs -> assert is_list(langs) and length(langs) > 0
+            langs -> assert is_list(langs) and langs != []
           end
         end
       end)
@@ -72,8 +75,8 @@ defmodule CodeQA.CombinedMetrics.SampleRunnerTest do
     test "with language option returns subset of unfiltered results" do
       agg =
         "priv/combined_metrics/samples/variable_naming/name_is_generic/bad"
-        |> CodeQA.Engine.Collector.collect_files()
-        |> CodeQA.Engine.Analyzer.analyze_codebase()
+        |> Collector.collect_files()
+        |> Analyzer.analyze_codebase()
         |> get_in(["codebase", "aggregate"])
 
       all = SampleRunner.diagnose_aggregate(agg, top: 999)
@@ -96,8 +99,8 @@ defmodule CodeQA.CombinedMetrics.SampleRunnerTest do
     test "with languages option returns fewer behaviors than unfiltered" do
       agg =
         "priv/combined_metrics/samples/variable_naming/name_is_generic/bad"
-        |> CodeQA.Engine.Collector.collect_files()
-        |> CodeQA.Engine.Analyzer.analyze_codebase()
+        |> Collector.collect_files()
+        |> Analyzer.analyze_codebase()
         |> get_in(["codebase", "aggregate"])
 
       all_count = SampleRunner.score_aggregate(agg) |> Enum.flat_map(& &1.behaviors) |> length()
@@ -114,7 +117,7 @@ defmodule CodeQA.CombinedMetrics.SampleRunnerTest do
 
   describe "grade_cosine_categories/4 languages wiring" do
     test "accepts languages argument" do
-      result = CodeQA.HealthReport.Grader.grade_cosine_categories(%{}, %{}, [], ["elixir"])
+      result = Grader.grade_cosine_categories(%{}, %{}, [], ["elixir"])
       assert is_list(result)
     end
   end
@@ -122,7 +125,7 @@ defmodule CodeQA.CombinedMetrics.SampleRunnerTest do
   describe "run/1" do
     test "returns a list of results with required keys", %{results: results} do
       assert is_list(results)
-      assert length(results) > 0
+      assert results != []
       result = hd(results)
       assert Map.has_key?(result, :bad_score)
       assert Map.has_key?(result, :good_score)
diff --git a/test/codeqa/engine/analyzer_test.exs b/test/codeqa/engine/analyzer_test.exs
index ccc4a41..3d0d79a 100644
--- a/test/codeqa/engine/analyzer_test.exs
+++ b/test/codeqa/engine/analyzer_test.exs
@@ -1,10 +1,12 @@
 defmodule CodeQA.Engine.AnalyzerTest do
   use ExUnit.Case, async: true
 
+  alias CodeQA.Engine.Analyzer
+
   describe "analyze_file/2" do
     test "returns a metrics map with group keys" do
       content = "defmodule Foo do\n  def bar, do: :ok\nend\n"
-      result = CodeQA.Engine.Analyzer.analyze_file("lib/foo.ex", content)
+      result = Analyzer.analyze_file("lib/foo.ex", content)
       assert is_map(result)
       assert map_size(result) > 0
       # Each value should be a map of metric keys to numbers
@@ -21,7 +23,7 @@ defmodule CodeQA.Engine.AnalyzerTest do
         "lib/b.ex" => "defmodule B do\n  def bar, do: :b\nend\n"
       }
 
-      agg = CodeQA.Engine.Analyzer.analyze_codebase_aggregate(files)
+      agg = Analyzer.analyze_codebase_aggregate(files)
       assert is_map(agg)
       # At least one group should have mean_ keys
       Enum.each(agg, fn {_group, keys} ->
@@ -37,7 +39,7 @@ defmodule CodeQA.Engine.AnalyzerTest do
     test "does not run codebase metrics (returns quickly for large input)" do
       # Just assert it returns without error for a reasonable input
       files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: 1\nend\n"}
-      agg = CodeQA.Engine.Analyzer.analyze_codebase_aggregate(files)
+      agg = Analyzer.analyze_codebase_aggregate(files)
       assert is_map(agg)
     end
   end
diff --git a/test/codeqa/health_report/grader_test.exs b/test/codeqa/health_report/grader_test.exs
index 21de94e..b8c5c14 100644
--- a/test/codeqa/health_report/grader_test.exs
+++ b/test/codeqa/health_report/grader_test.exs
@@ -1,6 +1,8 @@
 defmodule CodeQA.HealthReport.GraderTest do
   use ExUnit.Case, async: true
 
+  alias CodeQA.Engine.Analyzer
+  alias CodeQA.Engine.Collector
   alias CodeQA.HealthReport.Grader
 
   @default_scale CodeQA.HealthReport.Categories.default_grade_scale()
@@ -118,7 +120,7 @@ defmodule CodeQA.HealthReport.GraderTest do
       # weighted = (80*2 + 60*1) / 3 = 220/3 ≈ 73
       impact_map = %{"readability" => 2}
       {score, _grade} = Grader.overall_score(categories, @default_scale, impact_map)
-      assert score == round((80 * 2 + 60 * 1) / 3)
+      assert score == 73
     end
 
     test "backward compat: /2 call with empty impact_map equals arithmetic mean" do
@@ -151,14 +153,14 @@ defmodule CodeQA.HealthReport.GraderTest do
       impact_map = %{"function_design" => 2, "variable_naming" => 1}
       {score, _} = Grader.overall_score(categories, @default_scale, impact_map)
       # (60*2 + 40*1) / 3 = 160/3 ≈ 53
-      assert score == round((60 * 2 + 40 * 1) / 3)
+      assert score == 53
     end
   end
 
   # Shared aggregate for grade_cosine_categories/3 tests — computed once for the module.
   setup_all do
-    files = CodeQA.Engine.Collector.collect_files("lib", [])
-    result = CodeQA.Engine.Analyzer.analyze_codebase(files)
+    files = Collector.collect_files("lib", [])
+    result = Analyzer.analyze_codebase(files)
     aggregate = get_in(result, ["codebase", "aggregate"])
     {:ok, aggregate: aggregate}
   end
diff --git a/test/codeqa/health_report/top_blocks_test.exs b/test/codeqa/health_report/top_blocks_test.exs
index c5f1bdb..feb1194 100644
--- a/test/codeqa/health_report/top_blocks_test.exs
+++ b/test/codeqa/health_report/top_blocks_test.exs
@@ -1,8 +1,8 @@
 defmodule CodeQA.HealthReport.TopBlocksTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.HealthReport.TopBlocks
   alias CodeQA.Git.ChangedFile
+  alias CodeQA.HealthReport.TopBlocks
 
   # A node with cosine_delta 0.60 — will be :critical when codebase_cosine = 0.0 (gap=1.0, ratio=0.60)
   defp make_node(cosine_delta, token_count \\ 20) do
@@ -126,8 +126,24 @@ defmodule CodeQA.HealthReport.TopBlocksTest do
 
   describe "fix hints" do
     test "includes fix_hint string for known behavior" do
-      # function_design/cyclomatic_complexity_under_10 has _fix_hint in YAML
-      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup())
+      # naming_conventions/file_name_matches_primary_export has _fix_hint in YAML
+      node = %{
+        "start_line" => 1,
+        "end_line" => 10,
+        "type" => "code",
+        "token_count" => 20,
+        "refactoring_potentials" => [
+          %{
+            "category" => "naming_conventions",
+            "behavior" => "file_name_matches_primary_export",
+            "cosine_delta" => 0.60
+          }
+        ],
+        "children" => []
+      }
+
+      hint_lookup = %{{"naming_conventions", "file_name_matches_primary_export"} => 0.0}
+      [group] = TopBlocks.build(make_results([node]), [], hint_lookup)
       potential = hd(hd(group.blocks).potentials)
       assert is_binary(potential.fix_hint)
     end
diff --git a/test/codeqa/health_report_test.exs b/test/codeqa/health_report_test.exs
index 1eb4c64..8d25e4d 100644
--- a/test/codeqa/health_report_test.exs
+++ b/test/codeqa/health_report_test.exs
@@ -1,14 +1,19 @@
 defmodule CodeQA.HealthReportTest do
   use ExUnit.Case, async: true
 
+  alias CodeQA.BlockImpactAnalyzer
+  alias CodeQA.Engine.Analyzer
+  alias CodeQA.Git.ChangedFile
+  alias CodeQA.HealthReport
+
   describe "generate/2 output keys" do
     @tag :slow
     test "without base_results: pr_summary and codebase_delta are nil" do
       files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
-      results = CodeQA.Engine.Analyzer.analyze_codebase(files)
-      results = CodeQA.BlockImpactAnalyzer.analyze(results, files)
+      results = Analyzer.analyze_codebase(files)
+      results = BlockImpactAnalyzer.analyze(results, files)
 
-      report = CodeQA.HealthReport.generate(results)
+      report = HealthReport.generate(results)
 
       assert report.pr_summary == nil
       assert report.codebase_delta == nil
@@ -22,10 +27,10 @@ defmodule CodeQA.HealthReportTest do
     @tag :slow
     test "without base_results: top_blocks shows all files with significant blocks" do
       files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
-      results = CodeQA.Engine.Analyzer.analyze_codebase(files)
-      results = CodeQA.BlockImpactAnalyzer.analyze(results, files)
+      results = Analyzer.analyze_codebase(files)
+      results = BlockImpactAnalyzer.analyze(results, files)
 
-      report = CodeQA.HealthReport.generate(results)
+      report = HealthReport.generate(results)
 
       # top_blocks is a list of file groups (may be empty if no blocks above threshold)
       assert is_list(report.top_blocks)
@@ -41,10 +46,10 @@ defmodule CodeQA.HealthReportTest do
     @tag :slow
     test "worst_offenders is always empty in categories" do
       files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
-      results = CodeQA.Engine.Analyzer.analyze_codebase(files)
-      results = CodeQA.BlockImpactAnalyzer.analyze(results, files)
+      results = Analyzer.analyze_codebase(files)
+      results = BlockImpactAnalyzer.analyze(results, files)
 
-      report = CodeQA.HealthReport.generate(results)
+      report = HealthReport.generate(results)
 
       Enum.each(report.categories, fn cat ->
         assert Map.get(cat, :worst_offenders, []) == []
@@ -56,14 +61,14 @@ defmodule CodeQA.HealthReportTest do
     @tag :slow
     test "pr_summary is populated" do
       files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
-      head_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
-      head_results = CodeQA.BlockImpactAnalyzer.analyze(head_results, files)
-      base_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      head_results = Analyzer.analyze_codebase(files)
+      head_results = BlockImpactAnalyzer.analyze(head_results, files)
+      base_results = Analyzer.analyze_codebase(files)
 
-      changed = [%CodeQA.Git.ChangedFile{path: "lib/foo.ex", status: "modified"}]
+      changed = [%ChangedFile{path: "lib/foo.ex", status: "modified"}]
 
       report =
-        CodeQA.HealthReport.generate(head_results,
+        HealthReport.generate(head_results,
           base_results: base_results,
           changed_files: changed
         )
@@ -89,11 +94,11 @@ defmodule CodeQA.HealthReportTest do
     @tag :slow
     test "codebase_delta is populated" do
       files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
-      head_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
-      head_results = CodeQA.BlockImpactAnalyzer.analyze(head_results, files)
-      base_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      head_results = Analyzer.analyze_codebase(files)
+      head_results = BlockImpactAnalyzer.analyze(head_results, files)
+      base_results = Analyzer.analyze_codebase(files)
 
-      report = CodeQA.HealthReport.generate(head_results, base_results: base_results)
+      report = HealthReport.generate(head_results, base_results: base_results)
 
       assert %{base: %{aggregate: _}, head: %{aggregate: _}, delta: %{aggregate: _}} =
                report.codebase_delta
@@ -106,14 +111,14 @@ defmodule CodeQA.HealthReportTest do
         "lib/bar.ex" => "defmodule Bar do\n  def baz, do: :ok\nend\n"
       }
 
-      head_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
-      head_results = CodeQA.BlockImpactAnalyzer.analyze(head_results, files)
-      base_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
+      head_results = Analyzer.analyze_codebase(files)
+      head_results = BlockImpactAnalyzer.analyze(head_results, files)
+      base_results = Analyzer.analyze_codebase(files)
 
-      changed = [%CodeQA.Git.ChangedFile{path: "lib/foo.ex", status: "modified"}]
+      changed = [%ChangedFile{path: "lib/foo.ex", status: "modified"}]
 
       report =
-        CodeQA.HealthReport.generate(head_results,
+        HealthReport.generate(head_results,
           base_results: base_results,
           changed_files: changed
         )
diff --git a/test/codeqa/metrics/file/bradford_test.exs b/test/codeqa/metrics/file/bradford_test.exs
index f323ca8..db948d9 100644
--- a/test/codeqa/metrics/file/bradford_test.exs
+++ b/test/codeqa/metrics/file/bradford_test.exs
@@ -1,8 +1,8 @@
 defmodule CodeQA.Metrics.File.BradfordTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.Metrics.File.Bradford
   alias CodeQA.Engine.Pipeline
+  alias CodeQA.Metrics.File.Bradford
 
   # Bradford zones are built by ranking lines densest-first, then walking down
   # until each third of total tokens is accumulated:
diff --git a/test/codeqa/metrics/file/branching_test.exs b/test/codeqa/metrics/file/branching_test.exs
index d527a60..c4749b3 100644
--- a/test/codeqa/metrics/file/branching_test.exs
+++ b/test/codeqa/metrics/file/branching_test.exs
@@ -1,8 +1,8 @@
 defmodule CodeQA.Metrics.File.BranchingTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.Metrics.File.Branching
   alias CodeQA.Engine.Pipeline
+  alias CodeQA.Metrics.File.Branching
 
   defp ctx(code), do: Pipeline.build_file_context(code)
   defp density(code), do: Branching.analyze(ctx(code))["branching_density"]
diff --git a/test/codeqa/metrics/file/brevity_test.exs b/test/codeqa/metrics/file/brevity_test.exs
index 2f5662d..4f65fa0 100644
--- a/test/codeqa/metrics/file/brevity_test.exs
+++ b/test/codeqa/metrics/file/brevity_test.exs
@@ -1,8 +1,8 @@
 defmodule CodeQA.Metrics.File.BrevityTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.Metrics.File.Brevity
   alias CodeQA.Engine.Pipeline
+  alias CodeQA.Metrics.File.Brevity
 
   defp ctx(code), do: Pipeline.build_file_context(code)
   defp result(code), do: Brevity.analyze(ctx(code))
diff --git a/test/codeqa/metrics/file/function_metrics_test.exs b/test/codeqa/metrics/file/function_metrics_test.exs
index eee4bc2..7f05b90 100644
--- a/test/codeqa/metrics/file/function_metrics_test.exs
+++ b/test/codeqa/metrics/file/function_metrics_test.exs
@@ -1,8 +1,8 @@
 defmodule CodeQA.Metrics.File.FunctionMetricsTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.Metrics.File.FunctionMetrics
   alias CodeQA.Engine.Pipeline
+  alias CodeQA.Metrics.File.FunctionMetrics
 
   defp ctx(code), do: Pipeline.build_file_context(code)
   defp analyze(code), do: FunctionMetrics.analyze(ctx(code))
@@ -50,7 +50,7 @@ defmodule CodeQA.Metrics.File.FunctionMetricsTest do
     for keyword <- FunctionMetrics.func_keywords() do
       test "detects function starting with #{keyword}" do
         code = "#{unquote(keyword)} my_func(x) {\n  return x\n}"
-        result = FunctionMetrics.analyze(CodeQA.Engine.Pipeline.build_file_context(code))
+        result = FunctionMetrics.analyze(Pipeline.build_file_context(code))
 
         assert result["avg_function_lines"] > 0,
                "expected '#{unquote(keyword)}' to be detected as function start"
@@ -62,7 +62,7 @@ defmodule CodeQA.Metrics.File.FunctionMetricsTest do
     for modifier <- FunctionMetrics.access_modifiers() do
       test "detects method starting with #{modifier}" do
         code = "#{unquote(modifier)} void MyMethod() {\n  return;\n}"
-        result = FunctionMetrics.analyze(CodeQA.Engine.Pipeline.build_file_context(code))
+        result = FunctionMetrics.analyze(Pipeline.build_file_context(code))
 
         assert result["avg_function_lines"] > 0,
                "expected '#{unquote(modifier)}' access modifier to trigger method detection"
diff --git a/test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs b/test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs
index d52234f..c59f707 100644
--- a/test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs
+++ b/test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs
@@ -1,7 +1,7 @@
 defmodule CodeQA.Metrics.File.NearDuplicateBlocksFileTest do
   use ExUnit.Case, async: true
-  alias CodeQA.Metrics.File.NearDuplicateBlocksFile
   alias CodeQA.Engine.Pipeline
+  alias CodeQA.Metrics.File.NearDuplicateBlocksFile
 
   defp ctx(code, path \\ "test.ex") do
     base = Pipeline.build_file_context(code)
diff --git a/test/codeqa/metrics/file/rfc_test.exs b/test/codeqa/metrics/file/rfc_test.exs
index 3ac9fcd..19716f3 100644
--- a/test/codeqa/metrics/file/rfc_test.exs
+++ b/test/codeqa/metrics/file/rfc_test.exs
@@ -1,8 +1,8 @@
 defmodule CodeQA.Metrics.File.RFCTest do
   use ExUnit.Case, async: true
 
-  alias CodeQA.Metrics.File.RFC
   alias CodeQA.Engine.Pipeline
+  alias CodeQA.Metrics.File.RFC
 
   defp ctx(code), do: Pipeline.build_file_context(code)
   defp result(code), do: RFC.analyze(ctx(code))

From 1876aebed925ded97dd555e9dbe95cceb01c81cc Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Sat, 21 Mar 2026 13:27:38 +0000
Subject: [PATCH 44/71] chore(combined-metrics): sync language coverage and
 scalar vectors [skip ci]

---
 priv/combined_metrics/code_smells.yml     |  5 -----
 priv/combined_metrics/variable_naming.yml | 14 --------------
 2 files changed, 19 deletions(-)

diff --git a/priv/combined_metrics/code_smells.yml b/priv/combined_metrics/code_smells.yml
index 2201f7d..f1c73c5 100644
--- a/priv/combined_metrics/code_smells.yml
+++ b/priv/combined_metrics/code_smells.yml
@@ -1,6 +1,5 @@
 consistent_string_quote_style:
   _doc: "Files should use a single, consistent string quoting style throughout."
-  _languages: [elixir]
   _log_baseline: -18.2553
   branching:
     mean_branching_density: 0.0243
@@ -102,7 +101,6 @@ consistent_string_quote_style:
 
 no_dead_code_after_return:
   _doc: "There should be no unreachable statements after a return or early exit."
-  _languages: [elixir]
   _log_baseline: -55.8435
   branching:
     mean_branch_count: -2.0000
@@ -213,7 +211,6 @@ no_dead_code_after_return:
 
 no_debug_print_statements:
   _doc: "Debug output (`console.log`, `IO.inspect`, `fmt.Println`) must not be left in committed code."
-  _languages: [elixir]
   _log_baseline: -88.0844
   branching:
     mean_branch_count: -0.3540
@@ -324,7 +321,6 @@ no_debug_print_statements:
 
 no_fixme_comments:
   _doc: "FIXME, XXX, and HACK comments indicate known problems that should be resolved before merging."
-  _languages: [elixir]
   _log_baseline: -2.0233
   branching:
     mean_branch_count: 0.1755
@@ -439,7 +435,6 @@ no_fixme_comments:
 
 no_nested_ternary:
   _doc: "Nested conditional expressions (ternary-within-ternary) are harder to read than a plain if-else."
-  _languages: [elixir]
   _log_baseline: 7.6475
   branching:
     mean_branch_count: -0.5662
diff --git a/priv/combined_metrics/variable_naming.yml b/priv/combined_metrics/variable_naming.yml
index e7bc6fa..1be9c6b 100644
--- a/priv/combined_metrics/variable_naming.yml
+++ b/priv/combined_metrics/variable_naming.yml
@@ -1,6 +1,5 @@
 boolean_has_is_has_prefix:
   _doc: "Boolean variables should be prefixed with `is_`, `has_`, or `can_`."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 15.9481
   brevity:
     mean_sample_size: 0.0752
@@ -63,7 +62,6 @@ boolean_has_is_has_prefix:
 
 collection_name_is_plural:
   _doc: "Variables holding a collection should use a plural name."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 21.8380
   brevity:
     mean_sample_size: -0.5320
@@ -125,7 +123,6 @@ collection_name_is_plural:
 
 loop_var_is_single_letter:
   _doc: "Loop index variables (`i`, `j`, `k`) are acceptable inside loop bodies."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -28.3218
   brevity:
     mean_sample_size: -0.1049
@@ -205,7 +202,6 @@ loop_var_is_single_letter:
 
 name_contains_and:
   _doc: "Variable names containing `and` signal a variable that holds two concerns."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 0.4689
   branching:
     mean_branch_count: -0.3666
@@ -324,7 +320,6 @@ name_contains_and:
 
 name_contains_type_suffix:
   _doc: "Type suffixes in names (`userString`, `nameList`) are redundant noise."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -26.6817
   branching:
     mean_branch_count: -0.4150
@@ -410,7 +405,6 @@ name_contains_type_suffix:
 
 name_is_abbreviation:
   _doc: "Abbreviated names (`usr`, `cfg`, `mgr`) reduce readability."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 10.7370
   brevity:
     mean_sample_size: -0.1542
@@ -497,7 +491,6 @@ name_is_abbreviation:
 
 name_is_generic:
   _doc: "Generic names (`data`, `result`, `tmp`, `val`, `obj`) convey no domain meaning."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 37.4815
   branching:
     mean_branch_count: 0.5193
@@ -614,7 +607,6 @@ name_is_generic:
 
 name_is_number_like:
   _doc: "Number-suffixed names (`var1`, `thing2`) signal a missing abstraction."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 1.7611
   brevity:
     mean_sample_size: -0.0262
@@ -693,7 +685,6 @@ name_is_number_like:
 
 name_is_single_letter:
   _doc: "Single-letter names outside loop indices are too opaque."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 26.2113
   branching:
     mean_branching_density: -0.0458
@@ -791,7 +782,6 @@ name_is_single_letter:
 
 name_is_too_long:
   _doc: "Names longer than ~30 characters harm readability."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -7.8322
   branching:
     mean_branch_count: 0.0340
@@ -912,7 +902,6 @@ name_is_too_long:
 
 name_is_too_short:
   _doc: "Names shorter than 3 characters (outside loops) are too opaque."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -2.7224
   branching:
     mean_branch_count: -0.2327
@@ -1000,7 +989,6 @@ name_is_too_short:
 
 negated_boolean_name:
   _doc: "Negated boolean names (`isNotValid`, `notActive`) are harder to reason about."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -4.4565
   brevity:
     mean_sample_size: -0.0998
@@ -1071,7 +1059,6 @@ negated_boolean_name:
 
 no_hungarian_notation:
   _doc: "Hungarian notation prefixes (`strName`, `bFlag`) add noise without type safety."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -15.5962
   brevity:
     mean_sample_size: -0.0814
@@ -1147,7 +1134,6 @@ no_hungarian_notation:
 
 screaming_snake_for_constants:
   _doc: "Module-level constants should use SCREAMING_SNAKE_CASE."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -5.9884
   branching:
     mean_branching_density: 0.0176

From 05019e87a2d785377dffaf5184b3e5bb85b4e278 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 15:10:10 +0100
Subject: [PATCH 45/71] refactor(codebase): structural cleanup from health
 report analysis
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Split sample_runner.ex (655→393 lines) into three focused modules:
  cosine_vector.ex (vector math), yaml_formatter.ex (YAML serialisation),
  scalar_applier.ex (scalar/language writing)
- Split near_duplicate_blocks.ex (454→198 lines) into distance.ex
  (Levenshtein + bucketing) and candidates.ex (fingerprinting + pair finding)
- Extract accumulate_file_behaviors/3 from file_scorer.ex reduce callback
  that was doing two things (SRP fix)
- Unify score_low_is_good/score_high_is_good → score_by_direction/3 in
  grader.ex; unify interpolate_below_d pair → interpolate_beyond_d/3
  using abs() to remove directional duplication
- Add _languages metadata to code_smells and variable_naming YAML behaviors

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/combined_metrics/cosine_vector.ex  |  69 +++
 lib/codeqa/combined_metrics/file_scorer.ex    |  41 +-
 lib/codeqa/combined_metrics/sample_runner.ex  | 524 +++++-------------
 lib/codeqa/combined_metrics/scalar_applier.ex | 209 +++++++
 lib/codeqa/combined_metrics/yaml_formatter.ex |  72 +++
 lib/codeqa/health_report/grader.ex            | 157 +++---
 .../metrics/file/near_duplicate_blocks.ex     | 316 +----------
 .../file/near_duplicate_blocks/candidates.ex  | 214 +++++++
 .../file/near_duplicate_blocks/distance.ex    | 114 ++++
 priv/combined_metrics/code_smells.yml         |   5 +
 priv/combined_metrics/variable_naming.yml     |  14 +
 11 files changed, 973 insertions(+), 762 deletions(-)
 create mode 100644 lib/codeqa/combined_metrics/cosine_vector.ex
 create mode 100644 lib/codeqa/combined_metrics/scalar_applier.ex
 create mode 100644 lib/codeqa/combined_metrics/yaml_formatter.ex
 create mode 100644 lib/codeqa/metrics/file/near_duplicate_blocks/candidates.ex
 create mode 100644 lib/codeqa/metrics/file/near_duplicate_blocks/distance.ex

diff --git a/lib/codeqa/combined_metrics/cosine_vector.ex b/lib/codeqa/combined_metrics/cosine_vector.ex
new file mode 100644
index 0000000..158b24e
--- /dev/null
+++ b/lib/codeqa/combined_metrics/cosine_vector.ex
@@ -0,0 +1,69 @@
+defmodule CodeQA.CombinedMetrics.CosineVector do
+  @moduledoc """
+  Computes cosine similarity between a behavior's scalar weight vector and a
+  log-metric vector derived from an aggregate.
+
+  Pure math — no I/O, no YAML loading. Intended for internal use by `SampleRunner`.
+  """
+
+  alias CodeQA.CombinedMetrics.Scorer
+
+  @doc """
+  Builds the cosine result entry for a single behavior against the given aggregate.
+
+  Returns a one-element list `[result_map]` on success or `[]` when the behavior
+  has no non-zero scalars (no sample data) and should be excluded.
+  """
+  @spec compute(String.t(), String.t(), map(), map(), String.t()) :: [map()]
+  def compute(yaml_path, behavior, behavior_data, aggregate, category) do
+    scalars = Scorer.scalars_for(yaml_path, behavior)
+
+    if map_size(scalars) == 0 do
+      []
+    else
+      build_result(yaml_path, behavior, behavior_data, aggregate, category, scalars)
+    end
+  end
+
+  # --- Internal helpers ---
+
+  defp build_result(yaml_path, behavior, behavior_data, aggregate, category, scalars) do
+    log_baseline = Map.get(behavior_data, "_log_baseline", 0.0) / 1.0
+
+    {dot, norm_s_sq, norm_v_sq, contributions} =
+      Enum.reduce(scalars, {0.0, 0.0, 0.0, []}, fn {{group, key}, scalar},
+                                                   {d, ns, nv, contribs} ->
+        log_m = :math.log(Scorer.get(aggregate, group, key))
+        contrib = scalar * log_m
+
+        {d + contrib, ns + scalar * scalar, nv + log_m * log_m,
+         [{:"#{group}.#{key}", contrib} | contribs]}
+      end)
+
+    cos_sim =
+      if norm_s_sq > 0 and norm_v_sq > 0,
+        do: dot / (:math.sqrt(norm_s_sq) * :math.sqrt(norm_v_sq)),
+        else: 0.0
+
+    raw_score = Scorer.compute_score(yaml_path, behavior, aggregate)
+    calibrated = :math.log(max(raw_score, 1.0e-300)) - log_baseline
+
+    top_metrics =
+      contributions
+      |> Enum.sort_by(fn {_, c} -> c end)
+      |> Enum.take(5)
+      |> Enum.map(fn {metric, contribution} ->
+        %{metric: to_string(metric), contribution: Float.round(contribution, 4)}
+      end)
+
+    [
+      %{
+        category: category,
+        behavior: behavior,
+        cosine: Float.round(cos_sim, 4),
+        score: Float.round(calibrated, 4),
+        top_metrics: top_metrics
+      }
+    ]
+  end
+end
diff --git a/lib/codeqa/combined_metrics/file_scorer.ex b/lib/codeqa/combined_metrics/file_scorer.ex
index a35a473..e7479b0 100644
--- a/lib/codeqa/combined_metrics/file_scorer.ex
+++ b/lib/codeqa/combined_metrics/file_scorer.ex
@@ -70,24 +70,7 @@ defmodule CodeQA.CombinedMetrics.FileScorer do
       file_data |> Map.get("metrics", %{}) |> map_size() == 0
     end)
     |> Enum.reduce(%{}, fn {path, file_data}, acc ->
-      top_nodes = Grader.top_3_nodes(Map.get(file_data, "nodes"))
-      language = Language.detect(path).name()
-
-      file_data
-      |> Map.get("metrics", %{})
-      |> file_to_aggregate()
-      |> SampleRunner.diagnose_aggregate(top: 99_999, language: language)
-      |> Enum.reduce(acc, fn %{
-                               category: category,
-                               behavior: behavior,
-                               cosine: cosine,
-                               top_metrics: top_metrics
-                             },
-                             inner_acc ->
-        key = "#{category}.#{behavior}"
-        entry = %{file: path, cosine: cosine, top_metrics: top_metrics, top_nodes: top_nodes}
-        Map.update(inner_acc, key, [entry], &[entry | &1])
-      end)
+      accumulate_file_behaviors(path, file_data, acc)
     end)
     |> Map.new(fn {key, entries} ->
       threshold = Config.cosine_significance_threshold()
@@ -101,4 +84,26 @@ defmodule CodeQA.CombinedMetrics.FileScorer do
       {key, sorted}
     end)
   end
+
+  # Diagnoses a single file's metrics and merges per-behavior entries into the accumulator.
+  defp accumulate_file_behaviors(path, file_data, acc) do
+    top_nodes = Grader.top_3_nodes(Map.get(file_data, "nodes"))
+    language = Language.detect(path).name()
+
+    file_data
+    |> Map.get("metrics", %{})
+    |> file_to_aggregate()
+    |> SampleRunner.diagnose_aggregate(top: 99_999, language: language)
+    |> Enum.reduce(acc, fn %{
+                             category: category,
+                             behavior: behavior,
+                             cosine: cosine,
+                             top_metrics: top_metrics
+                           },
+                           inner_acc ->
+      key = "#{category}.#{behavior}"
+      entry = %{file: path, cosine: cosine, top_metrics: top_metrics, top_nodes: top_nodes}
+      Map.update(inner_acc, key, [entry], &[entry | &1])
+    end)
+  end
 end
diff --git a/lib/codeqa/combined_metrics/sample_runner.ex b/lib/codeqa/combined_metrics/sample_runner.ex
index 76566d4..3cd6533 100644
--- a/lib/codeqa/combined_metrics/sample_runner.ex
+++ b/lib/codeqa/combined_metrics/sample_runner.ex
@@ -6,14 +6,14 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
   manual scalar tuning of combined metric formulas.
   """
 
-  alias CodeQA.CombinedMetrics.Scorer
-  alias CodeQA.Engine.Analyzer
-  alias CodeQA.Engine.Collector
+  alias CodeQA.CombinedMetrics.{CosineVector, ScalarApplier, Scorer}
+  alias CodeQA.Engine.{Analyzer, Collector}
 
   @samples_root "priv/combined_metrics/samples"
-  @yaml_dir "priv/combined_metrics"
-  @deadzone_low 0.995
-  @deadzone_high 1.005
+
+  # ---------------------------------------------------------------------------
+  # Public API
+  # ---------------------------------------------------------------------------
 
   @doc """
   Runs all behaviors found in sample directories, optionally filtered by category.
@@ -40,12 +40,7 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
     filter_category = opts[:category]
 
     @samples_root
-    |> File.ls!()
-    |> Enum.flat_map(fn category ->
-      Path.join([@samples_root, category])
-      |> File.ls!()
-      |> Enum.map(&{category, &1})
-    end)
+    |> list_behaviors()
     |> Enum.filter(fn {category, behavior} ->
       (filter_category == nil or category == filter_category) and
         has_both_dirs?(category, behavior)
@@ -55,62 +50,6 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
     end)
   end
 
-  defp has_both_dirs?(category, behavior) do
-    File.dir?(sample_path(category, behavior, "bad")) and
-      File.dir?(sample_path(category, behavior, "good"))
-  end
-
-  defp score_behavior(category, behavior, opts) do
-    yaml_path = "priv/combined_metrics/#{category}.yml"
-    bad_agg = analyze(sample_path(category, behavior, "bad"))
-    good_agg = analyze(sample_path(category, behavior, "good"))
-
-    bad_score = Scorer.compute_score(yaml_path, behavior, bad_agg)
-    good_score = Scorer.compute_score(yaml_path, behavior, good_agg)
-    ratio = if bad_score > 0, do: good_score / bad_score, else: 0.0
-
-    base = %{
-      category: category,
-      behavior: behavior,
-      bad_score: bad_score,
-      good_score: good_score,
-      ratio: Float.round(ratio, 2),
-      direction_ok: good_score >= bad_score
-    }
-
-    if opts[:verbose] do
-      Map.put(base, :metric_detail, metric_detail(yaml_path, behavior, bad_agg, good_agg))
-    else
-      Map.put(base, :metric_detail, [])
-    end
-  end
-
-  defp analyze(dir) do
-    dir
-    |> Collector.collect_files()
-    |> Analyzer.analyze_codebase()
-    |> get_in(["codebase", "aggregate"])
-  end
-
-  defp metric_detail(yaml_path, behavior, bad_agg, good_agg) do
-    Scorer.scalars_for(yaml_path, behavior)
-    |> Enum.map(fn {{group, key}, scalar} ->
-      bad_val = Scorer.get(bad_agg, group, key)
-      good_val = Scorer.get(good_agg, group, key)
-      ratio = if bad_val > 0, do: Float.round(good_val / bad_val, 2), else: 0.0
-
-      %{
-        group: group,
-        key: key,
-        scalar: scalar,
-        bad: bad_val,
-        good: good_val,
-        ratio: ratio
-      }
-    end)
-    |> Enum.sort_by(&abs(&1.ratio - 1.0), :desc)
-  end
-
   @doc """
   Builds a per-behavior metric correlation report for scalar tuning.
 
@@ -144,12 +83,7 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
     filter_category = opts[:category]
 
     @samples_root
-    |> File.ls!()
-    |> Enum.flat_map(fn category ->
-      Path.join([@samples_root, category])
-      |> File.ls!()
-      |> Enum.map(&{category, &1})
-    end)
+    |> list_behaviors()
     |> Enum.filter(fn {category, behavior} ->
       (filter_category == nil or category == filter_category) and
         has_both_dirs?(category, behavior)
@@ -159,44 +93,6 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
     end)
   end
 
-  defp behavior_metric_table(category, behavior) do
-    bad_agg = analyze(sample_path(category, behavior, "bad"))
-    good_agg = analyze(sample_path(category, behavior, "good"))
-
-    entries =
-      Scorer.default_scalars()
-      |> Map.keys()
-      |> Enum.map(fn {group, key} ->
-        bad_val = Scorer.get(bad_agg, group, key)
-        good_val = Scorer.get(good_agg, group, key)
-        log_bad = :math.log(bad_val)
-        log_good = :math.log(good_val)
-        ratio = good_val / bad_val
-        log_diff = log_good - log_bad
-        {"#{group}.#{key}", bad_val, good_val, log_bad, log_good, ratio, log_diff}
-      end)
-
-    max_abs_log_diff =
-      entries
-      |> Enum.map(fn {_, _, _, _, _, _, ld} -> abs(ld) end)
-      |> Enum.max(fn -> 1.0 end)
-      |> max(1.0e-10)
-
-    Map.new(entries, fn {metric_key, bad_val, good_val, log_bad, log_good, ratio, log_diff} ->
-      suggested_scalar = Float.round(2.0 * log_diff / max_abs_log_diff, 4)
-
-      {metric_key,
-       %{
-         bad: r4(bad_val),
-         good: r4(good_val),
-         log_bad: r4(log_bad),
-         log_good: r4(log_good),
-         ratio: r4(ratio),
-         suggested_scalar: suggested_scalar
-       }}
-    end)
-  end
-
   @doc """
   Scores all combined metric behaviors against the given codebase aggregate map.
 
@@ -246,12 +142,6 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
     end)
   end
 
-  defp humanize(slug) do
-    slug
-    |> String.split("_")
-    |> Enum.map_join(" ", &String.capitalize/1)
-  end
-
   @doc """
   Identifies the most likely code quality issues in an aggregate by cosine similarity.
 
@@ -298,7 +188,7 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
       data
       |> Enum.filter(fn {_k, v} -> is_map(v) end)
       |> Enum.flat_map(fn {behavior, behavior_data} ->
-        maybe_score_behavior(
+        maybe_diagnose_behavior(
           yaml_path,
           behavior,
           behavior_data,
@@ -317,9 +207,9 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
   Applies suggested scalars from sample analysis back to the YAML config files.
 
   For each behavior that has sample data, rewrites its scalar entries using the
-  log-linear suggestion method. Metrics whose ratio falls in the deadzone
-  (#{@deadzone_low} ≤ ratio ≤ #{@deadzone_high}) are excluded. All non-deadzoned
-  metrics are written, even if they were not previously present in the YAML.
+  log-linear suggestion method. Metrics whose ratio falls in the deadzone are
+  excluded. All non-deadzoned metrics are written, even if they were not
+  previously present in the YAML.
 
   Behaviors without sample data are left unchanged.
 
@@ -328,113 +218,144 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
   @spec apply_scalars(keyword()) :: [map()]
   def apply_scalars(opts \\ []) do
     report = build_metric_report(opts)
-    filter_category = opts[:category]
+    ScalarApplier.apply_scalars(report, opts)
+  end
 
-    @yaml_dir
-    |> File.ls!()
-    |> Enum.filter(fn yml_file ->
-      String.ends_with?(yml_file, ".yml") and
-        (filter_category == nil or String.trim_trailing(yml_file, ".yml") == filter_category)
-    end)
-    |> Enum.sort()
-    |> Enum.map(fn yml_file ->
-      category = String.trim_trailing(yml_file, ".yml")
-      yaml_path = Path.join(@yaml_dir, yml_file)
-      {:ok, existing} = YamlElixir.read_from_file(yaml_path)
+  @doc """
+  Updates only the `_languages` field in YAML config files based on sample data.
 
-      {updated_yaml, stats} = apply_to_category(existing, category, report)
-      File.write!(yaml_path, format_yaml(updated_yaml))
+  Scans `bad/` and `good/` sample directories for each behavior, detects languages
+  from file extensions via `CodeQA.Language.detect/1`, and writes the intersection
+  as `_languages` to the YAML. Behaviors without sample data are left without a
+  `_languages` key (treated as applying to all languages at scoring time).
+  All existing scalars and baselines are preserved.
 
-      Map.put(stats, :category, category)
-    end)
+  Returns a list of `%{category: String.t(), behaviors_with_languages: non_neg_integer()}`.
+  """
+  @spec apply_languages(keyword()) :: [map()]
+  def apply_languages(opts \\ []) do
+    ScalarApplier.apply_languages(opts)
   end
 
-  defp apply_to_category(existing, category, report) do
-    existing
-    |> Enum.filter(fn {_k, v} -> is_map(v) end)
-    |> Enum.reduce({%{}, %{updated: 0, deadzoned: 0, skipped: 0}}, fn
-      {behavior, current_groups}, {acc_yaml, stats} ->
-        report_key = "#{category}.#{behavior}"
-        doc = read_behavior_doc(category, behavior)
-
-        case Map.get(report, report_key) do
-          nil ->
-            groups = maybe_put_doc(current_groups, doc)
-            {Map.put(acc_yaml, behavior, groups), Map.update!(stats, :skipped, &(&1 + 1))}
-
-          metrics ->
-            apply_metrics(acc_yaml, stats, behavior, current_groups, metrics, doc)
-        end
+  # ---------------------------------------------------------------------------
+  # Sample discovery
+  # ---------------------------------------------------------------------------
+
+  defp list_behaviors(samples_root) do
+    samples_root
+    |> File.ls!()
+    |> Enum.flat_map(fn category ->
+      Path.join([samples_root, category])
+      |> File.ls!()
+      |> Enum.map(&{category, &1})
     end)
   end
 
-  defp apply_metrics(acc_yaml, stats, behavior, current_groups, metrics, doc) do
-    {new_groups, log_baseline, n_updated, n_deadzoned} = groups_from_report(metrics)
-    # Fall back to current groups if everything was deadzoned
-    base_groups = if map_size(new_groups) > 0, do: new_groups, else: current_groups
-
-    groups =
-      base_groups
-      |> Map.put("_log_baseline", Float.round(log_baseline, 6))
-      |> maybe_put_doc(doc)
-
-    {Map.put(acc_yaml, behavior, groups),
-     %{
-       stats
-       | updated: stats.updated + n_updated,
-         deadzoned: stats.deadzoned + n_deadzoned
-     }}
+  defp has_both_dirs?(category, behavior) do
+    File.dir?(sample_path(category, behavior, "bad")) and
+      File.dir?(sample_path(category, behavior, "good"))
+  end
+
+  defp sample_path(category, behavior, kind) do
+    Path.join([@samples_root, category, behavior, kind])
+  end
+
+  defp analyze(dir) do
+    dir
+    |> Collector.collect_files()
+    |> Analyzer.analyze_codebase()
+    |> get_in(["codebase", "aggregate"])
   end
 
-  defp read_behavior_doc(category, behavior) do
-    config_path = Path.join([@samples_root, category, behavior, "config.yml"])
+  # ---------------------------------------------------------------------------
+  # Sample scoring
+  # ---------------------------------------------------------------------------
 
-    case File.read(config_path) do
-      {:ok, content} ->
-        case YamlElixir.read_from_string(content) do
-          {:ok, %{"doc" => doc}} when is_binary(doc) -> doc
-          _ -> nil
-        end
+  defp score_behavior(category, behavior, opts) do
+    yaml_path = "priv/combined_metrics/#{category}.yml"
+    bad_agg = analyze(sample_path(category, behavior, "bad"))
+    good_agg = analyze(sample_path(category, behavior, "good"))
+
+    bad_score = Scorer.compute_score(yaml_path, behavior, bad_agg)
+    good_score = Scorer.compute_score(yaml_path, behavior, good_agg)
+    ratio = if bad_score > 0, do: good_score / bad_score, else: 0.0
+
+    base = %{
+      category: category,
+      behavior: behavior,
+      bad_score: bad_score,
+      good_score: good_score,
+      ratio: Float.round(ratio, 2),
+      direction_ok: good_score >= bad_score
+    }
 
-      _ ->
-        nil
+    if opts[:verbose] do
+      Map.put(base, :metric_detail, metric_detail(yaml_path, behavior, bad_agg, good_agg))
+    else
+      Map.put(base, :metric_detail, [])
     end
   end
 
-  defp maybe_put_doc(groups, nil), do: groups
-  defp maybe_put_doc(groups, doc), do: Map.put(groups, "_doc", doc)
+  defp metric_detail(yaml_path, behavior, bad_agg, good_agg) do
+    Scorer.scalars_for(yaml_path, behavior)
+    |> Enum.map(fn {{group, key}, scalar} ->
+      bad_val = Scorer.get(bad_agg, group, key)
+      good_val = Scorer.get(good_agg, group, key)
+      ratio = if bad_val > 0, do: Float.round(good_val / bad_val, 2), else: 0.0
+      %{group: group, key: key, scalar: scalar, bad: bad_val, good: good_val, ratio: ratio}
+    end)
+    |> Enum.sort_by(&abs(&1.ratio - 1.0), :desc)
+  end
+
+  # ---------------------------------------------------------------------------
+  # Metric report (vector building)
+  # ---------------------------------------------------------------------------
+
+  defp behavior_metric_table(category, behavior) do
+    bad_agg = analyze(sample_path(category, behavior, "bad"))
+    good_agg = analyze(sample_path(category, behavior, "good"))
+
+    entries =
+      Scorer.default_scalars()
+      |> Map.keys()
+      |> Enum.map(fn {group, key} ->
+        bad_val = Scorer.get(bad_agg, group, key)
+        good_val = Scorer.get(good_agg, group, key)
+        log_bad = :math.log(bad_val)
+        log_good = :math.log(good_val)
+        ratio = good_val / bad_val
+        log_diff = log_good - log_bad
+        {"#{group}.#{key}", bad_val, good_val, log_bad, log_good, ratio, log_diff}
+      end)
 
-  defp groups_from_report(metrics) do
-    Enum.reduce(metrics, {%{}, 0.0, 0, 0}, fn {metric_key, data},
-                                              {groups, log_baseline, n_updated, n_deadzoned} ->
-      [group, key] = String.split(metric_key, ".", parts: 2)
+    max_abs_log_diff =
+      entries
+      |> Enum.map(fn {_, _, _, _, _, _, ld} -> abs(ld) end)
+      |> Enum.max(fn -> 1.0 end)
+      |> max(1.0e-10)
 
-      if deadzone?(data.ratio) do
-        {groups, log_baseline, n_updated, n_deadzoned + 1}
-      else
-        accumulate_metric(groups, log_baseline, n_updated, n_deadzoned, group, key, data)
-      end
+    Map.new(entries, fn {metric_key, bad_val, good_val, log_bad, log_good, ratio, log_diff} ->
+      suggested_scalar = Float.round(2.0 * log_diff / max_abs_log_diff, 4)
+
+      {metric_key,
+       %{
+         bad: r4(bad_val),
+         good: r4(good_val),
+         log_bad: r4(log_bad),
+         log_good: r4(log_good),
+         ratio: r4(ratio),
+         suggested_scalar: suggested_scalar
+       }}
     end)
   end
 
-  defp accumulate_metric(groups, log_baseline, n_updated, n_deadzoned, group, key, data) do
-    new_groups =
-      Map.update(
-        groups,
-        group,
-        %{key => data.suggested_scalar},
-        &Map.put(&1, key, data.suggested_scalar)
-      )
-
-    # Baseline: expected log score at the geometric mean of good/bad sample values
-    geo_mean = :math.sqrt(max(data.bad, 1.0e-10) * max(data.good, 1.0e-10))
-    new_baseline = log_baseline + data.suggested_scalar * :math.log(geo_mean)
-    {new_groups, new_baseline, n_updated + 1, n_deadzoned}
-  end
+  defp r4(f), do: Float.round(f / 1.0, 4)
 
-  defp deadzone?(ratio), do: ratio >= @deadzone_low and ratio <= @deadzone_high
+  # ---------------------------------------------------------------------------
+  # Cosine diagnosis (delegates vector math to CosineVector)
+  # ---------------------------------------------------------------------------
 
-  defp maybe_score_behavior(
+  defp maybe_diagnose_behavior(
          yaml_path,
          behavior,
          behavior_data,
@@ -446,70 +367,22 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
     behavior_langs = Map.get(behavior_data, "_languages", [])
 
     if behavior_language_applies?(behavior_langs, language, languages) do
-      score_behavior_cosine(yaml_path, behavior, behavior_data, aggregate, category)
+      CosineVector.compute(yaml_path, behavior, behavior_data, aggregate, category)
     else
       []
     end
   end
 
-  defp score_behavior_cosine(yaml_path, behavior, behavior_data, aggregate, category) do
-    scalars = Scorer.scalars_for(yaml_path, behavior)
-
-    if map_size(scalars) == 0 do
-      []
-    else
-      build_cosine_result(yaml_path, behavior, behavior_data, aggregate, category, scalars)
-    end
-  end
-
-  defp build_cosine_result(yaml_path, behavior, behavior_data, aggregate, category, scalars) do
-    log_baseline = Map.get(behavior_data, "_log_baseline", 0.0) / 1.0
-
-    {dot, norm_s_sq, norm_v_sq, contributions} =
-      Enum.reduce(scalars, {0.0, 0.0, 0.0, []}, fn {{group, key}, scalar},
-                                                   {d, ns, nv, contribs} ->
-        log_m = :math.log(Scorer.get(aggregate, group, key))
-        contrib = scalar * log_m
-
-        {d + contrib, ns + scalar * scalar, nv + log_m * log_m,
-         [{:"#{group}.#{key}", contrib} | contribs]}
-      end)
-
-    cos_sim =
-      if norm_s_sq > 0 and norm_v_sq > 0,
-        do: dot / (:math.sqrt(norm_s_sq) * :math.sqrt(norm_v_sq)),
-        else: 0.0
-
-    raw_score = Scorer.compute_score(yaml_path, behavior, aggregate)
-    calibrated = :math.log(max(raw_score, 1.0e-300)) - log_baseline
-
-    top_metrics =
-      contributions
-      |> Enum.sort_by(fn {_, c} -> c end)
-      |> Enum.take(5)
-      |> Enum.map(fn {metric, contribution} ->
-        %{metric: to_string(metric), contribution: Float.round(contribution, 4)}
-      end)
-
-    [
-      %{
-        category: category,
-        behavior: behavior,
-        cosine: Float.round(cos_sim, 4),
-        score: Float.round(calibrated, 4),
-        top_metrics: top_metrics
-      }
-    ]
-  end
+  # ---------------------------------------------------------------------------
+  # Language filtering
+  # ---------------------------------------------------------------------------
 
-  # Returns true if the behavior should be included for the given language context.
   # behavior_langs: the "_languages" list from the YAML ([] = applies to all)
   # language: single language string from :language opt (nil = no filter)
   # languages: project language list from :languages opt (nil = no filter)
   defp behavior_language_applies?(_behavior_langs, nil, nil), do: true
 
   # Empty behavior_langs means "applies to all languages" — always include.
-  # This clause takes priority over all non-nil filter cases.
   defp behavior_language_applies?([], _language, _languages), do: true
 
   defp behavior_language_applies?(_behavior_langs, nil, []), do: true
@@ -524,132 +397,13 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
        when is_binary(language) and is_list(languages),
        do: language in behavior_langs or Enum.any?(behavior_langs, &(&1 in languages))
 
-  defp format_yaml(data) do
-    lines =
-      data
-      |> Enum.sort_by(fn {behavior, _} -> behavior end)
-      |> Enum.flat_map(fn {behavior, groups} -> format_behavior_lines(behavior, groups) end)
-
-    Enum.join(lines, "\n") <> "\n"
-  end
-
-  defp format_behavior_lines(behavior, groups) do
-    doc_line = yaml_doc_line(Map.get(groups, "_doc"))
-    baseline_line = yaml_baseline_line(Map.get(groups, "_log_baseline"))
-    fix_hint_line = yaml_fix_hint_line(Map.get(groups, "_fix_hint"))
-    languages_line = yaml_languages_line(Map.get(groups, "_languages"))
-    group_lines = format_group_lines(groups)
-
-    ["#{behavior}:" | doc_line] ++
-      fix_hint_line ++ languages_line ++ baseline_line ++ group_lines ++ [""]
-  end
-
-  defp yaml_doc_line(nil), do: []
-  defp yaml_doc_line(doc), do: ["  _doc: #{inspect(doc)}"]
-
-  defp yaml_baseline_line(nil), do: []
-  defp yaml_baseline_line(val), do: ["  _log_baseline: #{fmt_scalar(val)}"]
-
-  defp yaml_fix_hint_line(nil), do: []
-  defp yaml_fix_hint_line(hint), do: ["  _fix_hint: #{inspect(hint)}"]
-
-  defp yaml_languages_line(nil), do: []
-  defp yaml_languages_line([]), do: []
-  defp yaml_languages_line(langs), do: ["  _languages: [#{Enum.join(langs, ", ")}]"]
-
-  defp format_group_lines(groups) do
-    groups
-    |> Enum.filter(fn {k, v} ->
-      k not in ["_doc", "_log_baseline", "_fix_hint", "_languages"] and is_map(v)
-    end)
-    |> Enum.sort_by(fn {group, _} -> group end)
-    |> Enum.flat_map(fn {group, keys} ->
-      key_lines =
-        keys
-        |> Enum.sort_by(fn {key, _} -> key end)
-        |> Enum.map(fn {key, scalar} -> "    #{key}: #{fmt_scalar(scalar)}" end)
-
-      ["  #{group}:" | key_lines]
-    end)
-  end
-
-  defp fmt_scalar(f) when is_float(f), do: :erlang.float_to_binary(f, decimals: 4)
-  defp fmt_scalar(n) when is_integer(n), do: "#{n}.0"
-
-  defp r4(f), do: Float.round(f / 1.0, 4)
-
-  defp sample_path(category, behavior, kind) do
-    Path.join([@samples_root, category, behavior, kind])
-  end
-
-  defp dir_languages(dir) do
-    case File.ls(dir) do
-      {:ok, files} ->
-        files
-        |> Enum.map(&CodeQA.Language.detect/1)
-        |> Enum.map(& &1.name())
-        |> MapSet.new()
-
-      _ ->
-        MapSet.new()
-    end
-  end
-
-  defp languages_for_behavior(category, behavior) do
-    bad_langs = dir_languages(sample_path(category, behavior, "bad"))
-    good_langs = dir_languages(sample_path(category, behavior, "good"))
-
-    bad_langs
-    |> MapSet.intersection(good_langs)
-    |> MapSet.to_list()
-    |> Enum.reject(&(&1 == "unknown"))
-    |> Enum.sort()
-  end
-
-  defp maybe_put_languages(groups, []), do: groups
-  defp maybe_put_languages(groups, langs), do: Map.put(groups, "_languages", langs)
-
-  @doc """
-  Updates only the `_languages` field in YAML config files based on sample data.
+  # ---------------------------------------------------------------------------
+  # Misc
+  # ---------------------------------------------------------------------------
 
-  Scans `bad/` and `good/` sample directories for each behavior, detects languages
-  from file extensions via `CodeQA.Language.detect/1`, and writes the intersection
-  as `_languages` to the YAML. Behaviors without sample data are left without a
-  `_languages` key (treated as applying to all languages at scoring time).
-  All existing scalars and baselines are preserved.
-
-  Returns a list of `%{category: String.t(), behaviors_with_languages: non_neg_integer()}`.
-  """
-  @spec apply_languages(keyword()) :: [map()]
-  def apply_languages(opts \\ []) do
-    filter_category = opts[:category]
-
-    @yaml_dir
-    |> File.ls!()
-    |> Enum.filter(fn yml_file ->
-      String.ends_with?(yml_file, ".yml") and
-        (filter_category == nil or String.trim_trailing(yml_file, ".yml") == filter_category)
-    end)
-    |> Enum.sort()
-    |> Enum.map(fn yml_file ->
-      category = String.trim_trailing(yml_file, ".yml")
-      yaml_path = Path.join(@yaml_dir, yml_file)
-      {:ok, existing} = YamlElixir.read_from_file(yaml_path)
-
-      updated =
-        existing
-        |> Enum.filter(fn {_k, v} -> is_map(v) end)
-        |> Map.new(fn {behavior, groups} ->
-          langs = languages_for_behavior(category, behavior)
-          {behavior, maybe_put_languages(groups, langs)}
-        end)
-
-      File.write!(yaml_path, format_yaml(updated))
-
-      behaviors_with_languages =
-        Enum.count(updated, fn {_b, groups} -> Map.has_key?(groups, "_languages") end)
-
-      %{category: category, behaviors_with_languages: behaviors_with_languages}
-    end)
+  defp humanize(slug) do
+    slug
+    |> String.split("_")
+    |> Enum.map_join(" ", &String.capitalize/1)
   end
 end
diff --git a/lib/codeqa/combined_metrics/scalar_applier.ex b/lib/codeqa/combined_metrics/scalar_applier.ex
new file mode 100644
index 0000000..1c8ec4b
--- /dev/null
+++ b/lib/codeqa/combined_metrics/scalar_applier.ex
@@ -0,0 +1,209 @@
+defmodule CodeQA.CombinedMetrics.ScalarApplier do
+  @moduledoc """
+  Writes suggested scalars and language metadata back to the combined-metrics YAML
+  config files under `priv/combined_metrics/`.
+
+  Intended for internal use by `SampleRunner`. Two entry points:
+
+  * `apply_scalars/2`   — rewrites scalar weights using log-linear suggestions
+  * `apply_languages/2` — rewrites `_languages` based on sample file extensions
+  """
+
+  alias CodeQA.CombinedMetrics.YamlFormatter
+
+  @samples_root "priv/combined_metrics/samples"
+  @yaml_dir "priv/combined_metrics"
+  @deadzone_low 0.995
+  @deadzone_high 1.005
+
+  @doc """
+  Applies suggested scalars from `report` (a `build_metric_report/1` result) to
+  the YAML files under `priv/combined_metrics/`.
+
+  Returns a list of per-category stats maps with `:category`, `:updated`,
+  `:deadzoned`, and `:skipped` keys.
+  """
+  @spec apply_scalars(map(), keyword()) :: [map()]
+  def apply_scalars(report, opts \\ []) do
+    filter_category = opts[:category]
+
+    @yaml_dir
+    |> File.ls!()
+    |> Enum.filter(fn yml_file ->
+      String.ends_with?(yml_file, ".yml") and
+        (filter_category == nil or String.trim_trailing(yml_file, ".yml") == filter_category)
+    end)
+    |> Enum.sort()
+    |> Enum.map(fn yml_file ->
+      category = String.trim_trailing(yml_file, ".yml")
+      yaml_path = Path.join(@yaml_dir, yml_file)
+      {:ok, existing} = YamlElixir.read_from_file(yaml_path)
+
+      {updated_yaml, stats} = apply_to_category(existing, category, report)
+      File.write!(yaml_path, YamlFormatter.format(updated_yaml))
+
+      Map.put(stats, :category, category)
+    end)
+  end
+
+  @doc """
+  Updates only the `_languages` field in YAML config files based on sample data.
+
+  Returns a list of `%{category: String.t(), behaviors_with_languages: non_neg_integer()}`.
+  """
+  @spec apply_languages(keyword()) :: [map()]
+  def apply_languages(opts \\ []) do
+    filter_category = opts[:category]
+
+    @yaml_dir
+    |> File.ls!()
+    |> Enum.filter(fn yml_file ->
+      String.ends_with?(yml_file, ".yml") and
+        (filter_category == nil or String.trim_trailing(yml_file, ".yml") == filter_category)
+    end)
+    |> Enum.sort()
+    |> Enum.map(fn yml_file ->
+      category = String.trim_trailing(yml_file, ".yml")
+      yaml_path = Path.join(@yaml_dir, yml_file)
+      {:ok, existing} = YamlElixir.read_from_file(yaml_path)
+
+      updated =
+        existing
+        |> Enum.filter(fn {_k, v} -> is_map(v) end)
+        |> Map.new(fn {behavior, groups} ->
+          langs = languages_for_behavior(category, behavior)
+          {behavior, maybe_put_languages(groups, langs)}
+        end)
+
+      File.write!(yaml_path, YamlFormatter.format(updated))
+
+      behaviors_with_languages =
+        Enum.count(updated, fn {_b, groups} -> Map.has_key?(groups, "_languages") end)
+
+      %{category: category, behaviors_with_languages: behaviors_with_languages}
+    end)
+  end
+
+  # ---------------------------------------------------------------------------
+  # Scalar application helpers
+  # ---------------------------------------------------------------------------
+
+  defp apply_to_category(existing, category, report) do
+    existing
+    |> Enum.filter(fn {_k, v} -> is_map(v) end)
+    |> Enum.reduce({%{}, %{updated: 0, deadzoned: 0, skipped: 0}}, fn
+      {behavior, current_groups}, {acc_yaml, stats} ->
+        report_key = "#{category}.#{behavior}"
+        doc = read_behavior_doc(category, behavior)
+
+        case Map.get(report, report_key) do
+          nil ->
+            groups = maybe_put_doc(current_groups, doc)
+            {Map.put(acc_yaml, behavior, groups), Map.update!(stats, :skipped, &(&1 + 1))}
+
+          metrics ->
+            apply_metrics(acc_yaml, stats, behavior, current_groups, metrics, doc)
+        end
+    end)
+  end
+
+  defp apply_metrics(acc_yaml, stats, behavior, current_groups, metrics, doc) do
+    {new_groups, log_baseline, n_updated, n_deadzoned} = groups_from_report(metrics)
+    # Fall back to current groups if everything was deadzoned
+    base_groups = if map_size(new_groups) > 0, do: new_groups, else: current_groups
+
+    groups =
+      base_groups
+      |> Map.put("_log_baseline", Float.round(log_baseline, 6))
+      |> maybe_put_doc(doc)
+
+    {Map.put(acc_yaml, behavior, groups),
+     %{
+       stats
+       | updated: stats.updated + n_updated,
+         deadzoned: stats.deadzoned + n_deadzoned
+     }}
+  end
+
+  defp groups_from_report(metrics) do
+    Enum.reduce(metrics, {%{}, 0.0, 0, 0}, fn {metric_key, data},
+                                              {groups, log_baseline, n_updated, n_deadzoned} ->
+      [group, key] = String.split(metric_key, ".", parts: 2)
+
+      if deadzone?(data.ratio) do
+        {groups, log_baseline, n_updated, n_deadzoned + 1}
+      else
+        accumulate_metric(groups, log_baseline, n_updated, n_deadzoned, group, key, data)
+      end
+    end)
+  end
+
+  defp accumulate_metric(groups, log_baseline, n_updated, n_deadzoned, group, key, data) do
+    new_groups =
+      Map.update(
+        groups,
+        group,
+        %{key => data.suggested_scalar},
+        &Map.put(&1, key, data.suggested_scalar)
+      )
+
+    geo_mean = :math.sqrt(max(data.bad, 1.0e-10) * max(data.good, 1.0e-10))
+    new_baseline = log_baseline + data.suggested_scalar * :math.log(geo_mean)
+    {new_groups, new_baseline, n_updated + 1, n_deadzoned}
+  end
+
+  defp deadzone?(ratio), do: ratio >= @deadzone_low and ratio <= @deadzone_high
+
+  defp read_behavior_doc(category, behavior) do
+    config_path = Path.join([@samples_root, category, behavior, "config.yml"])
+
+    case File.read(config_path) do
+      {:ok, content} ->
+        case YamlElixir.read_from_string(content) do
+          {:ok, %{"doc" => doc}} when is_binary(doc) -> doc
+          _ -> nil
+        end
+
+      _ ->
+        nil
+    end
+  end
+
+  defp maybe_put_doc(groups, nil), do: groups
+  defp maybe_put_doc(groups, doc), do: Map.put(groups, "_doc", doc)
+
+  # ---------------------------------------------------------------------------
+  # Language detection helpers
+  # ---------------------------------------------------------------------------
+
+  defp dir_languages(dir) do
+    case File.ls(dir) do
+      {:ok, files} ->
+        files
+        |> Enum.map(&CodeQA.Language.detect/1)
+        |> Enum.map(& &1.name())
+        |> MapSet.new()
+
+      _ ->
+        MapSet.new()
+    end
+  end
+
+  defp languages_for_behavior(category, behavior) do
+    bad_langs = dir_languages(sample_path(category, behavior, "bad"))
+    good_langs = dir_languages(sample_path(category, behavior, "good"))
+
+    bad_langs
+    |> MapSet.intersection(good_langs)
+    |> MapSet.to_list()
+    |> Enum.reject(&(&1 == "unknown"))
+    |> Enum.sort()
+  end
+
+  defp maybe_put_languages(groups, []), do: groups
+  defp maybe_put_languages(groups, langs), do: Map.put(groups, "_languages", langs)
+
+  defp sample_path(category, behavior, kind) do
+    Path.join([@samples_root, category, behavior, kind])
+  end
+end
diff --git a/lib/codeqa/combined_metrics/yaml_formatter.ex b/lib/codeqa/combined_metrics/yaml_formatter.ex
new file mode 100644
index 0000000..ca034b2
--- /dev/null
+++ b/lib/codeqa/combined_metrics/yaml_formatter.ex
@@ -0,0 +1,72 @@
+defmodule CodeQA.CombinedMetrics.YamlFormatter do
+  @moduledoc """
+  Serialises a combined-metrics behavior map back to the hand-authored YAML format.
+
+  Intended for internal use by `SampleRunner`. The output format preserves the
+  conventions used across `priv/combined_metrics/*.yml`:
+
+  - Behaviors sorted alphabetically
+  - Meta-keys (`_doc`, `_fix_hint`, `_languages`, `_log_baseline`) emitted before
+    group sections
+  - Groups and keys within groups sorted alphabetically
+  - Floats written with four decimal places
+  """
+
+  @doc """
+  Serialises a `%{behavior => groups}` map to a YAML string.
+  """
+  @spec format(map()) :: String.t()
+  def format(data) do
+    lines =
+      data
+      |> Enum.sort_by(fn {behavior, _} -> behavior end)
+      |> Enum.flat_map(fn {behavior, groups} -> behavior_lines(behavior, groups) end)
+
+    Enum.join(lines, "\n") <> "\n"
+  end
+
+  # --- Behavior-level serialisation ---
+
+  defp behavior_lines(behavior, groups) do
+    doc_line = doc_line(Map.get(groups, "_doc"))
+    baseline_line = baseline_line(Map.get(groups, "_log_baseline"))
+    fix_hint_line = fix_hint_line(Map.get(groups, "_fix_hint"))
+    languages_line = languages_line(Map.get(groups, "_languages"))
+    group_lines = group_lines(groups)
+
+    ["#{behavior}:" | doc_line] ++
+      fix_hint_line ++ languages_line ++ baseline_line ++ group_lines ++ [""]
+  end
+
+  defp doc_line(nil), do: []
+  defp doc_line(doc), do: ["  _doc: #{inspect(doc)}"]
+
+  defp baseline_line(nil), do: []
+  defp baseline_line(val), do: ["  _log_baseline: #{fmt_scalar(val)}"]
+
+  defp fix_hint_line(nil), do: []
+  defp fix_hint_line(hint), do: ["  _fix_hint: #{inspect(hint)}"]
+
+  defp languages_line(nil), do: []
+  defp languages_line([]), do: []
+  defp languages_line(langs), do: ["  _languages: [#{Enum.join(langs, ", ")}]"]
+
+  defp group_lines(groups) do
+    groups
+    |> Enum.filter(fn {k, v} ->
+      k not in ["_doc", "_log_baseline", "_fix_hint", "_languages"] and is_map(v)
+    end)
+    |> Enum.sort_by(fn {group, _} -> group end)
+    |> Enum.flat_map(fn {group, keys} ->
+      key_lines =
+        keys
+        |> Enum.sort_by(fn {key, _} -> key end)
+        |> Enum.map(fn {key, scalar} -> "    #{key}: #{fmt_scalar(scalar)}" end)
+
+      ["  #{group}:" | key_lines]
+    end)
+  end
+
+  defp fmt_scalar(f) when is_float(f), do: :erlang.float_to_binary(f, decimals: 4)
+  defp fmt_scalar(n) when is_integer(n), do: "#{n}.0"
+end
diff --git a/lib/codeqa/health_report/grader.ex b/lib/codeqa/health_report/grader.ex
index 8011c8f..46ed374 100644
--- a/lib/codeqa/health_report/grader.ex
+++ b/lib/codeqa/health_report/grader.ex
@@ -13,11 +13,11 @@ defmodule CodeQA.HealthReport.Grader do
   """
   @spec score_metric(map(), number()) :: integer()
   def score_metric(%{good: :high, thresholds: t}, value) do
-    value |> score_high_is_good(t) |> clamp(0, 100)
+    score_by_direction(:high, value, t) |> clamp(0, 100)
   end
 
   def score_metric(%{good: _, thresholds: t}, value) do
-    value |> score_low_is_good(t) |> clamp(0, 100)
+    score_by_direction(:low, value, t) |> clamp(0, 100)
   end
 
   @doc """
@@ -46,28 +46,27 @@ defmodule CodeQA.HealthReport.Grader do
   defp cosine_to_score(c) when c >= -0.3, do: interpolate_between(c, -0.3, 30, 0.0, 50)
   defp cosine_to_score(c), do: interpolate_between(c, -1.0, 0, -0.3, 30)
 
-  # Lower values are better: below A = 100, A = 90, A-B = 70-90, etc.
-  defp score_low_is_good(val, t) do
+  # :low  — lower values are better (t.a < t.b < t.c < t.d); below t.a = 100
+  # :high — higher values are better (t.a > t.b > t.c > t.d); above t.a = 100
+  defp score_by_direction(:low, val, t) do
     cond do
       val < t.a -> 100
       val == t.a -> 90
       val <= t.b -> interpolate_between(val, t.a, 90, t.b, 70)
       val <= t.c -> interpolate_between(val, t.b, 70, t.c, 50)
       val <= t.d -> interpolate_between(val, t.c, 50, t.d, 30)
-      true -> interpolate_below_d(val, t.d, 30)
+      true -> interpolate_beyond_d(val, t.d, 30)
     end
   end
 
-  # Higher values are better: above A = 100, A = 90, A-B = 70-90, etc.
-  # Thresholds are in descending order (a > b > c > d)
-  defp score_high_is_good(val, t) do
+  defp score_by_direction(:high, val, t) do
     cond do
       val > t.a -> 100
       val == t.a -> 90
       val >= t.b -> interpolate_between(val, t.a, 90, t.b, 70)
       val >= t.c -> interpolate_between(val, t.b, 70, t.c, 50)
       val >= t.d -> interpolate_between(val, t.c, 50, t.d, 30)
-      true -> interpolate_below_d_high(val, t.d, 30)
+      true -> interpolate_beyond_d(val, t.d, 30)
     end
   end
 
@@ -82,24 +81,19 @@ defmodule CodeQA.HealthReport.Grader do
     end
   end
 
-  # Value beyond D threshold (low is good): score degrades below 30
-  defp interpolate_below_d(_val, threshold_d, _score_at_d) when threshold_d == 0, do: 0
+  # Score degrades below 30 when value is beyond the D threshold in either direction.
+  # abs(val - threshold_d) captures overshoot for :low and undershoot for :high uniformly.
+  defp interpolate_beyond_d(_val, 0, _score_at_d), do: 0
 
-  defp interpolate_below_d(val, threshold_d, score_at_d) do
-    overshoot = (val - threshold_d) / threshold_d
-    round(Kernel.max(0, score_at_d - overshoot * score_at_d))
+  defp interpolate_beyond_d(val, threshold_d, score_at_d) do
+    deviation = abs(val - threshold_d) / threshold_d
+    round(Kernel.max(0, score_at_d - deviation * score_at_d))
   end
 
-  # Value below D threshold (high is good): score degrades below 30
-  defp interpolate_below_d_high(_val, threshold_d, _score_at_d) when threshold_d == 0, do: 0
-
-  defp interpolate_below_d_high(val, threshold_d, score_at_d) do
-    undershoot = (threshold_d - val) / threshold_d
-    round(Kernel.max(0, score_at_d - undershoot * score_at_d))
+  defp clamp(val, min_val, max_val) do
+    val |> Kernel.max(min_val) |> Kernel.min(max_val)
   end
 
-  defp clamp(val, min_val, max_val), do: val |> Kernel.max(min_val) |> Kernel.min(max_val)
-
   @doc "Convert a numeric score (0-100) to a letter grade using the given scale."
   @spec grade_letter(number(), [{number(), String.t()}]) :: String.t()
   def grade_letter(score, scale \\ Categories.default_grade_scale()) do
@@ -120,31 +114,10 @@ defmodule CodeQA.HealthReport.Grader do
       ) do
     scored =
       category.metrics
-      |> Enum.map(fn metric_def ->
-        value = get_in(file_metrics, [metric_def.source, metric_def.name])
-
-        if value do
-          %{
-            name: metric_def.name,
-            source: metric_def.source,
-            weight: metric_def.weight,
-            good: metric_def.good,
-            value: value,
-            score: score_metric(metric_def, value)
-          }
-        end
-      end)
+      |> Enum.map(&score_metric_entry(&1, file_metrics))
       |> Enum.reject(&is_nil/1)
 
-    total_weight = Enum.reduce(scored, 0.0, fn s, acc -> acc + s.weight end)
-
-    score =
-      if total_weight > 0 do
-        weighted = Enum.reduce(scored, 0.0, fn s, acc -> acc + s.score * s.weight end)
-        round(weighted / total_weight)
-      else
-        0
-      end
+    score = weighted_category_score(scored)
 
     %{
       key: category.key,
@@ -155,6 +128,34 @@ defmodule CodeQA.HealthReport.Grader do
     }
   end
 
+  defp score_metric_entry(metric_def, file_metrics) do
+    value = get_in(file_metrics, [metric_def.source, metric_def.name])
+
+    if value do
+      %{
+        name: metric_def.name,
+        source: metric_def.source,
+        weight: metric_def.weight,
+        good: metric_def.good,
+        value: value,
+        score: score_metric(metric_def, value)
+      }
+    end
+  end
+
+  defp weighted_category_score([]), do: 0
+
+  defp weighted_category_score(scored) do
+    total_weight = Enum.reduce(scored, 0.0, fn s, acc -> acc + s.weight end)
+
+    if total_weight > 0 do
+      weighted = Enum.reduce(scored, 0.0, fn s, acc -> acc + s.score * s.weight end)
+      round(weighted / total_weight)
+    else
+      0
+    end
+  end
+
   @doc """
   Grade a file's metrics against all categories.
   `file_metrics` is the `%{"entropy" => %{...}, "halstead" => %{...}}` map from analysis.
@@ -252,38 +253,48 @@ defmodule CodeQA.HealthReport.Grader do
     |> Enum.group_by(& &1.category)
     |> Enum.map(fn {category, behaviors} ->
       behavior_entries =
-        behaviors
-        |> Enum.reject(fn b -> abs(b.cosine) < threshold end)
-        |> Enum.map(fn b ->
-          cosine_score = score_cosine(b.cosine)
-
-          %{
-            behavior: b.behavior,
-            cosine: b.cosine,
-            score: cosine_score,
-            grade: grade_letter(cosine_score, scale),
-            worst_offenders: Map.get(worst_files, "#{category}.#{b.behavior}", [])
-          }
-        end)
-
-      category_score =
-        if behavior_entries == [] do
-          50
-        else
-          round(Enum.sum(Enum.map(behavior_entries, & &1.score)) / length(behavior_entries))
-        end
+        score_behavior_entries(behaviors, threshold, worst_files, scale, category)
 
-      %{
-        type: :cosine,
-        key: category,
-        name: humanize_category(category),
-        score: category_score,
-        grade: grade_letter(category_score, scale),
-        behaviors: behavior_entries
-      }
+      category_score = average_behavior_score(behavior_entries)
+      build_cosine_category(category, category_score, behavior_entries, scale)
     end)
   end
 
+  defp score_behavior_entries(behaviors, threshold, worst_files, scale, category) do
+    behaviors
+    |> Enum.reject(fn b -> abs(b.cosine) < threshold end)
+    |> Enum.map(&score_behavior_entry(&1, worst_files, scale, category))
+  end
+
+  defp score_behavior_entry(b, worst_files, scale, category) do
+    cosine_score = score_cosine(b.cosine)
+
+    %{
+      behavior: b.behavior,
+      cosine: b.cosine,
+      score: cosine_score,
+      grade: grade_letter(cosine_score, scale),
+      worst_offenders: Map.get(worst_files, "#{category}.#{b.behavior}", [])
+    }
+  end
+
+  defp average_behavior_score([]), do: 50
+
+  defp average_behavior_score(entries) do
+    round(Enum.sum(Enum.map(entries, & &1.score)) / length(entries))
+  end
+
+  defp build_cosine_category(category, category_score, behavior_entries, scale) do
+    %{
+      type: :cosine,
+      key: category,
+      name: humanize_category(category),
+      score: category_score,
+      grade: grade_letter(category_score, scale),
+      behaviors: behavior_entries
+    }
+  end
+
   defp humanize_category(slug) do
     slug
     |> String.split("_")
diff --git a/lib/codeqa/metrics/file/near_duplicate_blocks.ex b/lib/codeqa/metrics/file/near_duplicate_blocks.ex
index 94ba060..e1e0c08 100644
--- a/lib/codeqa/metrics/file/near_duplicate_blocks.ex
+++ b/lib/codeqa/metrics/file/near_duplicate_blocks.ex
@@ -11,114 +11,30 @@ defmodule CodeQA.Metrics.File.NearDuplicateBlocks do
     d5 ≤ 25%, d6 ≤ 30%, d7 ≤ 40%, d8 ≤ 50%
   """
 
-  alias CodeQA.AST.Classification.NodeProtocol
   alias CodeQA.AST.Enrichment.Node
-  alias CodeQA.AST.Lexing.{NewlineToken, WhitespaceToken}
   alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Parser
   alias CodeQA.Language
+  alias CodeQA.Metrics.File.NearDuplicateBlocks.Candidates
+  alias CodeQA.Metrics.File.NearDuplicateBlocks.Distance
 
   @max_bucket 8
-  @bucket_thresholds [
-    {0, 0.0},
-    {1, 0.05},
-    {2, 0.10},
-    {3, 0.15},
-    {4, 0.20},
-    {5, 0.25},
-    {6, 0.30},
-    {7, 0.40},
-    {8, 0.50}
-  ]
-
-  # Pre-compute token kind strings to avoid repeated function calls in the hot path.
-  @nl_kind NewlineToken.kind()
-  @ws_kind WhitespaceToken.kind()
+
+  # ---------------------------------------------------------------------------
+  # Public API — distance helpers delegated to Distance submodule
+  # ---------------------------------------------------------------------------
 
   @doc "Standard Levenshtein distance between two token lists."
   @spec token_edit_distance([String.t()], [String.t()]) :: non_neg_integer()
-  def token_edit_distance([], b), do: length(b)
-  def token_edit_distance(a, []), do: length(a)
-
-  def token_edit_distance(a, b) do
-    a_arr = List.to_tuple(a)
-    b_arr = List.to_tuple(b)
-    lb = tuple_size(b_arr)
-    init_row = List.to_tuple(Enum.to_list(0..lb))
-    result_row = levenshtein_rows(a_arr, b_arr, tuple_size(a_arr), lb, init_row, 1)
-    elem(result_row, lb)
-  end
-
-  defp levenshtein_rows(_a, _b, la, _lb, prev, i) when i > la, do: prev
-
-  defp levenshtein_rows(a, b, la, lb, prev, i) do
-    ai = elem(a, i - 1)
-    curr_reversed = levenshtein_cols(b, lb, prev, ai, [i], 1)
-    curr = List.to_tuple(:lists.reverse(curr_reversed))
-    levenshtein_rows(a, b, la, lb, curr, i + 1)
-  end
-
-  defp levenshtein_cols(_b, lb, _prev, _ai, acc, j) when j > lb, do: acc
-
-  defp levenshtein_cols(b, lb, prev, ai, [last_val | _] = acc, j) do
-    cost = if ai == elem(b, j - 1), do: 0, else: 1
-    val = min(elem(prev, j) + 1, min(last_val + 1, elem(prev, j - 1) + cost))
-    levenshtein_cols(b, lb, prev, ai, [val | acc], j + 1)
-  end
-
-  # Bounded Levenshtein: returns the edit distance, or max_distance + 1 if the
-  # distance would exceed max_distance. Bails after each row when the row minimum
-  # already exceeds max_distance — the final distance can only grow from there.
-  defp token_edit_distance_bounded([], b, _max), do: length(b)
-  defp token_edit_distance_bounded(a, [], _max), do: length(a)
-
-  defp token_edit_distance_bounded(a, b, max_distance) do
-    a_arr = List.to_tuple(a)
-    b_arr = List.to_tuple(b)
-    lb = tuple_size(b_arr)
-    init_row = List.to_tuple(Enum.to_list(0..lb))
-    levenshtein_rows_bounded(a_arr, b_arr, tuple_size(a_arr), lb, init_row, max_distance, 1)
-  end
-
-  defp levenshtein_rows_bounded(_a, _b, la, lb, prev, _max, i) when i > la, do: elem(prev, lb)
-
-  defp levenshtein_rows_bounded(a, b, la, lb, prev, max_distance, i) do
-    ai = elem(a, i - 1)
-    # levenshtein_cols_with_min tracks the row minimum as it builds, avoiding
-    # a separate O(lb) pass to find the min after the row is complete.
-    {curr_reversed, row_min} = levenshtein_cols_with_min(b, lb, prev, ai, {[i], i}, 1)
-    curr = List.to_tuple(:lists.reverse(curr_reversed))
-
-    if row_min > max_distance do
-      max_distance + 1
-    else
-      levenshtein_rows_bounded(a, b, la, lb, curr, max_distance, i + 1)
-    end
-  end
-
-  defp levenshtein_cols_with_min(_b, lb, _prev, _ai, acc_and_min, j) when j > lb, do: acc_and_min
-
-  defp levenshtein_cols_with_min(b, lb, prev, ai, {[last_val | _] = acc, min_val}, j) do
-    cost = if ai == elem(b, j - 1), do: 0, else: 1
-    val = min(elem(prev, j) + 1, min(last_val + 1, elem(prev, j - 1) + cost))
-    levenshtein_cols_with_min(b, lb, prev, ai, {[val | acc], min(min_val, val)}, j + 1)
-  end
+  defdelegate token_edit_distance(a, b), to: Distance
 
   @doc "Map an edit distance and min token count to a percentage bucket 0–8, or nil if > 50%."
   @spec percent_bucket(non_neg_integer(), non_neg_integer()) :: 0..8 | nil
-  def percent_bucket(_ed, 0), do: nil
-  def percent_bucket(0, _min_count), do: 0
+  defdelegate percent_bucket(ed, min_count), to: Distance
 
-  def percent_bucket(ed, min_count) do
-    pct = ed / min_count
-
-    @bucket_thresholds
-    |> Enum.find(fn {bucket, threshold} -> bucket > 0 and pct <= threshold end)
-    |> case do
-      {bucket, _} -> bucket
-      nil -> nil
-    end
-  end
+  # ---------------------------------------------------------------------------
+  # Public API — analysis entry points
+  # ---------------------------------------------------------------------------
 
   @doc """
   Analyze a list of `{path, content}` pairs for near-duplicate blocks.
@@ -192,6 +108,18 @@ defmodule CodeQA.Metrics.File.NearDuplicateBlocks do
     buckets
   end
 
+  @doc false
+  def label_blocks(blocks, path) do
+    Enum.map(blocks, fn block ->
+      label = if block.start_line, do: "#{path}:#{block.start_line}", else: path
+      %{block | label: label}
+    end)
+  end
+
+  # ---------------------------------------------------------------------------
+  # Internal pair-finding pipeline
+  # ---------------------------------------------------------------------------
+
   # Internal implementation returning {buckets, sub_block_count} so that
   # analyze_from_blocks gets both without a redundant NodeProtocol.children pass.
   defp do_find_pairs(blocks, opts) do
@@ -203,21 +131,7 @@ defmodule CodeQA.Metrics.File.NearDuplicateBlocks do
     if length(blocks) < 2 do
       {%{}, 0}
     else
-      # Pre-compute canonical values and hashes once per block. Each decorated entry
-      # is {index, block, values, hash, len_values, children_count, newline_count, bigrams}
-      # so downstream functions never recompute them.
-      decorated =
-        blocks
-        |> Enum.with_index()
-        |> Enum.map(fn {block, i} ->
-          values = canonical_values(NodeProtocol.flat_tokens(block))
-          children_count = length(NodeProtocol.children(block))
-          newline_count = Enum.count(values, &(&1 == @nl_kind))
-          bigrams = Enum.chunk_every(values, 2, 1, :discard)
-
-          {i, block, values, :erlang.phash2(values), length(values), children_count,
-           newline_count, bigrams}
-        end)
+      decorated = Candidates.decorate(blocks)
 
       # sub_block_count derived from the already-computed children_count in decorated.
       sub_block_count =
@@ -226,16 +140,16 @@ defmodule CodeQA.Metrics.File.NearDuplicateBlocks do
       # IDF: prune bigrams that appear in more than idf_max_freq fraction of blocks.
       # These are structural noise (e.g. "end nil", "return false") that inflate the
       # candidate set without helping identify true duplicates.
-      pruned = compute_frequent_bigrams(decorated, idf_max_freq)
+      pruned = Candidates.compute_frequent_bigrams(decorated, idf_max_freq)
 
       decorated =
         if MapSet.size(pruned) > 0 do
-          Enum.map(decorated, &prune_bigrams(&1, pruned))
+          Enum.map(decorated, &Candidates.prune_bigrams(&1, pruned))
         else
           decorated
         end
 
-      {exact_index, shingle_index} = build_indexes(decorated)
+      {exact_index, shingle_index} = Candidates.build_indexes(decorated)
 
       total = length(decorated)
       # Convert to tuple for O(1) indexed lookup inside the hot comparison loop.
@@ -247,177 +161,15 @@ defmodule CodeQA.Metrics.File.NearDuplicateBlocks do
       raw_pairs =
         decorated
         |> Flow.from_enumerable(max_demand: 10, stages: workers)
-        |> Flow.flat_map(&find_pairs_for_block(&1, decorated_arr, exact_index, shingle_index))
+        |> Flow.flat_map(
+          &Candidates.find_pairs_for_block(&1, decorated_arr, exact_index, shingle_index)
+        )
         |> Enum.to_list()
 
       {bucket_pairs(raw_pairs, max_pairs), sub_block_count}
     end
   end
 
-  # Returns the set of bigram hashes that appear in more than max_freq fraction of blocks.
-  defp compute_frequent_bigrams(decorated, max_freq) do
-    total = length(decorated)
-    # Minimum threshold of 2 so a bigram must appear in 3+ blocks before being
-    # pruned — prevents over-pruning when the total block count is very small
-    # (e.g. with 2 blocks, any shared bigram would otherwise always be pruned).
-    threshold = max(2, round(total * max_freq))
-
-    decorated
-    |> Enum.reduce(%{}, fn {_, _, _, _, _, _, _, bigrams}, acc ->
-      bigrams
-      |> Enum.uniq_by(&:erlang.phash2/1)
-      |> Enum.reduce(acc, fn bigram, a ->
-        Map.update(a, :erlang.phash2(bigram), 1, &(&1 + 1))
-      end)
-    end)
-    |> Enum.filter(fn {_, count} -> count > threshold end)
-    |> Enum.map(&elem(&1, 0))
-    |> MapSet.new()
-  end
-
-  # Strip leading/trailing <NL> and <WS> tokens and extract kind values as strings.
-  # This ensures blocks split at blank-line boundaries compare as equal
-  # even if trailing newlines differ between first and last blocks.
-  # Returns [String.t()] (kinds only) so hashing, comparison, and edit distance
-  # are independent of token line/col metadata.
-  #
-  # Optimised to 3 passes: one reduce (skip leading NL/WS + collect reversed kinds),
-  # one drop_while (strip trailing from the reversed list), one :lists.reverse.
-  defp canonical_values(tokens) do
-    # Pass 1: skip leading NL/WS while building a reversed kinds list.
-    {reversed, _in_content} =
-      Enum.reduce(tokens, {[], false}, fn t, {acc, in_content} ->
-        kind = t.kind
-        is_skip = kind == @nl_kind or kind == @ws_kind
-
-        if in_content or not is_skip do
-          {[kind | acc], true}
-        else
-          {acc, false}
-        end
-      end)
-
-    # Pass 2: drop trailing NL/WS (which appear as leading in the reversed list).
-    # Pass 3: reverse back to source order via native BIF.
-    reversed
-    |> Enum.drop_while(&(&1 == @nl_kind or &1 == @ws_kind))
-    |> :lists.reverse()
-  end
-
-  # Build both exact (hash → [idx]) and shingle (bigram_hash → [idx]) indexes in one pass,
-  # using the pre-computed values from the decorated list.
-  defp build_indexes(decorated) do
-    Enum.reduce(decorated, {%{}, %{}}, fn {idx, _block, _values, hash, _len, _children, _newlines,
-                                           bigrams},
-                                          {exact_acc, shingle_acc} ->
-      exact_acc = Map.update(exact_acc, hash, [idx], &[idx | &1])
-
-      shingle_acc =
-        bigrams
-        |> Enum.reduce(shingle_acc, fn bigram, sh_acc ->
-          h = :erlang.phash2(bigram)
-          Map.update(sh_acc, h, [idx], &[idx | &1])
-        end)
-
-      {exact_acc, shingle_acc}
-    end)
-  end
-
-  defp find_pairs_for_block(
-         {i, block_a, values_a, hash_a, len_a, children_a, newlines_a, bigrams_a},
-         decorated_arr,
-         exact_index,
-         shingle_index
-       ) do
-    # For small exact-match lists (typically 0–3 entries) a plain list membership
-    # check avoids the overhead of constructing a MapSet.
-    exact_list = Map.get(exact_index, hash_a, [])
-
-    # For d0 (exact), find hash-matching blocks and confirm with value equality
-    # to guard against phash2 collisions.
-    exact_pairs =
-      exact_list
-      |> Enum.filter(&(&1 > i))
-      |> Enum.map(fn j ->
-        {_j, block_b, values_b, _hash_b, _len_b, children_b, newlines_b, _bigrams_b} =
-          elem(decorated_arr, j)
-
-        if values_b == values_a and
-             structure_compatible?(children_a, newlines_a, children_b, newlines_b) do
-          {0, {block_a.label, block_b.label}}
-        else
-          nil
-        end
-      end)
-      |> Enum.reject(&is_nil/1)
-
-    # For d1-d8 (near), use shingle index to find candidates.
-    min_shared = max(0, round(len_a * 0.5) - 1)
-
-    near_pairs =
-      bigrams_a
-      |> Enum.reduce(%{}, fn bigram, acc ->
-        h = :erlang.phash2(bigram)
-        Map.get(shingle_index, h, []) |> Enum.reduce(acc, &count_candidate(&1, &2, i))
-      end)
-      |> Enum.filter(fn {_, count} -> count >= min_shared end)
-      |> Enum.map(&elem(&1, 0))
-      |> Enum.reject(fn j -> j in exact_list end)
-      |> Enum.flat_map(fn j ->
-        near_pair_for_candidate(
-          j,
-          decorated_arr,
-          block_a,
-          values_a,
-          len_a,
-          children_a,
-          newlines_a
-        )
-      end)
-
-    exact_pairs ++ near_pairs
-  end
-
-  defp count_candidate(j, cnt, i) when j > i, do: Map.update(cnt, j, 1, &(&1 + 1))
-  defp count_candidate(_j, cnt, _i), do: cnt
-
-  defp near_pair_for_candidate(j, decorated_arr, block_a, values_a, len_a, children_a, newlines_a) do
-    {_j, block_b, values_b, _hash_b, len_b, children_b, newlines_b, _bigrams_b} =
-      elem(decorated_arr, j)
-
-    min_count = min(len_a, len_b)
-    max_allowed = round(min_count * 0.5)
-
-    if structure_compatible?(children_a, newlines_a, children_b, newlines_b) and
-         abs(len_a - len_b) <= max_allowed do
-      ed = token_edit_distance_bounded(values_a, values_b, max_allowed)
-
-      case percent_bucket(ed, min_count) do
-        nil -> []
-        bucket when bucket > 0 -> [{bucket, {block_a.label, block_b.label}}]
-        # ed=0 handled by exact_pairs above
-        _ -> []
-      end
-    else
-      []
-    end
-  end
-
-  defp prune_bigrams({i, b, v, h, l, c, n, bigrams}, pruned) do
-    {i, b, v, h, l, c, n, Enum.reject(bigrams, &MapSet.member?(pruned, :erlang.phash2(&1)))}
-  end
-
-  # Uses pre-computed children counts and newline counts from the decorated tuple
-  # so NodeProtocol.children/1 and Enum.count/2 are not called per candidate pair.
-  defp structure_compatible?(children_a, newlines_a, children_b, newlines_b) do
-    sub_diff = abs(children_a - children_b)
-    lines_a = newlines_a + 1
-    lines_b = newlines_b + 1
-    max_lines = max(lines_a, lines_b)
-    line_ratio = if max_lines > 0, do: abs(lines_a - lines_b) / max_lines, else: 0.0
-    sub_diff <= 1 and line_ratio <= 0.30
-  end
-
   defp bucket_pairs(raw_pairs, max_pairs) do
     Enum.reduce(raw_pairs, %{}, fn {bucket, pair}, acc ->
       Map.update(
@@ -438,14 +190,6 @@ defmodule CodeQA.Metrics.File.NearDuplicateBlocks do
   defp maybe_append(list, _pair, max, count) when is_integer(max) and count >= max, do: list
   defp maybe_append(list, pair, _max, _count), do: [pair | list]
 
-  @doc false
-  def label_blocks(blocks, path) do
-    Enum.map(blocks, fn block ->
-      label = if block.start_line, do: "#{path}:#{block.start_line}", else: path
-      %{block | label: label}
-    end)
-  end
-
   defp format_pairs(pairs) do
     Enum.map(pairs, fn {label_a, label_b} ->
       %{"source_a" => label_a, "source_b" => label_b}
diff --git a/lib/codeqa/metrics/file/near_duplicate_blocks/candidates.ex b/lib/codeqa/metrics/file/near_duplicate_blocks/candidates.ex
new file mode 100644
index 0000000..01fa53e
--- /dev/null
+++ b/lib/codeqa/metrics/file/near_duplicate_blocks/candidates.ex
@@ -0,0 +1,214 @@
+defmodule CodeQA.Metrics.File.NearDuplicateBlocks.Candidates do
+  @moduledoc """
+  Block fingerprinting, indexing, and candidate-pair matching for near-duplicate detection.
+
+  Handles:
+  - Canonical token-value extraction (stripping leading/trailing whitespace tokens)
+  - Exact-hash and shingle indexes for fast candidate lookup
+  - IDF-based bigram pruning to reduce structural-noise candidates
+  - Structural compatibility checks (child-count and line-ratio guards)
+  - Pair scoring and bucketing
+  """
+
+  alias CodeQA.AST.Classification.NodeProtocol
+  alias CodeQA.AST.Lexing.{NewlineToken, WhitespaceToken}
+  alias CodeQA.Metrics.File.NearDuplicateBlocks.Distance
+
+  # Pre-compute token kind strings to avoid repeated function calls in the hot path.
+  @nl_kind NewlineToken.kind()
+  @ws_kind WhitespaceToken.kind()
+
+  @doc """
+  Decorate a list of blocks with pre-computed canonical values, hashes, bigrams, and
+  structural metadata. Each entry is an 8-tuple:
+
+      {index, block, values, hash, len_values, children_count, newline_count, bigrams}
+  """
+  @spec decorate([term()]) :: [tuple()]
+  def decorate(blocks) do
+    blocks
+    |> Enum.with_index()
+    |> Enum.map(fn {block, i} ->
+      values = canonical_values(NodeProtocol.flat_tokens(block))
+      children_count = length(NodeProtocol.children(block))
+      newline_count = Enum.count(values, &(&1 == @nl_kind))
+      bigrams = Enum.chunk_every(values, 2, 1, :discard)
+
+      {i, block, values, :erlang.phash2(values), length(values), children_count, newline_count,
+       bigrams}
+    end)
+  end
+
+  @doc """
+  Build both exact (hash → [idx]) and shingle (bigram_hash → [idx]) indexes in one pass,
+  using the pre-computed values from the decorated list.
+  """
+  @spec build_indexes([tuple()]) :: {map(), map()}
+  def build_indexes(decorated) do
+    Enum.reduce(decorated, {%{}, %{}}, fn {idx, _block, _values, hash, _len, _children, _newlines,
+                                           bigrams},
+                                          {exact_acc, shingle_acc} ->
+      exact_acc = Map.update(exact_acc, hash, [idx], &[idx | &1])
+
+      shingle_acc =
+        bigrams
+        |> Enum.reduce(shingle_acc, fn bigram, sh_acc ->
+          h = :erlang.phash2(bigram)
+          Map.update(sh_acc, h, [idx], &[idx | &1])
+        end)
+
+      {exact_acc, shingle_acc}
+    end)
+  end
+
+  @doc """
+  Returns the set of bigram hashes that appear in more than `max_freq` fraction of blocks.
+
+  Minimum threshold of 2 so a bigram must appear in 3+ blocks before being pruned —
+  prevents over-pruning when the total block count is very small.
+  """
+  @spec compute_frequent_bigrams([tuple()], float()) :: MapSet.t()
+  def compute_frequent_bigrams(decorated, max_freq) do
+    total = length(decorated)
+    threshold = max(2, round(total * max_freq))
+
+    decorated
+    |> Enum.reduce(%{}, fn {_, _, _, _, _, _, _, bigrams}, acc ->
+      bigrams
+      |> Enum.uniq_by(&:erlang.phash2/1)
+      |> Enum.reduce(acc, fn bigram, a ->
+        Map.update(a, :erlang.phash2(bigram), 1, &(&1 + 1))
+      end)
+    end)
+    |> Enum.filter(fn {_, count} -> count > threshold end)
+    |> Enum.map(&elem(&1, 0))
+    |> MapSet.new()
+  end
+
+  @doc "Remove bigrams whose hash is in the pruned set from a decorated tuple."
+  @spec prune_bigrams(tuple(), MapSet.t()) :: tuple()
+  def prune_bigrams({i, b, v, h, l, c, n, bigrams}, pruned) do
+    {i, b, v, h, l, c, n, Enum.reject(bigrams, &MapSet.member?(pruned, :erlang.phash2(&1)))}
+  end
+
+  @doc """
+  Find all near-duplicate pairs for a single block against the full decorated array.
+  Returns a list of `{bucket, {label_a, label_b}}` pairs.
+  """
+  @spec find_pairs_for_block(tuple(), tuple(), map(), map()) :: list()
+  def find_pairs_for_block(
+        {i, block_a, values_a, hash_a, len_a, children_a, newlines_a, bigrams_a},
+        decorated_arr,
+        exact_index,
+        shingle_index
+      ) do
+    # For small exact-match lists (typically 0–3 entries) a plain list membership
+    # check avoids the overhead of constructing a MapSet.
+    exact_list = Map.get(exact_index, hash_a, [])
+
+    # For d0 (exact), find hash-matching blocks and confirm with value equality
+    # to guard against phash2 collisions.
+    exact_pairs =
+      exact_list
+      |> Enum.filter(&(&1 > i))
+      |> Enum.map(fn j ->
+        {_j, block_b, values_b, _hash_b, _len_b, children_b, newlines_b, _bigrams_b} =
+          elem(decorated_arr, j)
+
+        if values_b == values_a and
+             structure_compatible?(children_a, newlines_a, children_b, newlines_b) do
+          {0, {block_a.label, block_b.label}}
+        else
+          nil
+        end
+      end)
+      |> Enum.reject(&is_nil/1)
+
+    # For d1-d8 (near), use shingle index to find candidates.
+    min_shared = max(0, round(len_a * 0.5) - 1)
+
+    near_pairs =
+      bigrams_a
+      |> Enum.reduce(%{}, fn bigram, acc ->
+        h = :erlang.phash2(bigram)
+        Map.get(shingle_index, h, []) |> Enum.reduce(acc, &count_candidate(&1, &2, i))
+      end)
+      |> Enum.filter(fn {_, count} -> count >= min_shared end)
+      |> Enum.map(&elem(&1, 0))
+      |> Enum.reject(fn j -> j in exact_list end)
+      |> Enum.flat_map(fn j ->
+        near_pair_for_candidate(
+          j,
+          decorated_arr,
+          block_a,
+          values_a,
+          len_a,
+          children_a,
+          newlines_a
+        )
+      end)
+
+    exact_pairs ++ near_pairs
+  end
+
+  # ---------------------------------------------------------------------------
+  # Private helpers
+  # ---------------------------------------------------------------------------
+
+  # Strip leading/trailing <NL> and <WS> tokens and extract kind values as strings.
+  # Optimised to 3 passes: one reduce (skip leading NL/WS + collect reversed kinds),
+  # one drop_while (strip trailing), one :lists.reverse.
+  defp canonical_values(tokens) do
+    {reversed, _in_content} =
+      Enum.reduce(tokens, {[], false}, fn t, {acc, in_content} ->
+        kind = t.kind
+        is_skip = kind == @nl_kind or kind == @ws_kind
+
+        if in_content or not is_skip do
+          {[kind | acc], true}
+        else
+          {acc, false}
+        end
+      end)
+
+    reversed
+    |> Enum.drop_while(&(&1 == @nl_kind or &1 == @ws_kind))
+    |> :lists.reverse()
+  end
+
+  defp count_candidate(j, cnt, i) when j > i, do: Map.update(cnt, j, 1, &(&1 + 1))
+  defp count_candidate(_j, cnt, _i), do: cnt
+
+  defp near_pair_for_candidate(j, decorated_arr, block_a, values_a, len_a, children_a, newlines_a) do
+    {_j, block_b, values_b, _hash_b, len_b, children_b, newlines_b, _bigrams_b} =
+      elem(decorated_arr, j)
+
+    min_count = min(len_a, len_b)
+    max_allowed = round(min_count * 0.5)
+
+    if structure_compatible?(children_a, newlines_a, children_b, newlines_b) and
+         abs(len_a - len_b) <= max_allowed do
+      ed = Distance.token_edit_distance_bounded(values_a, values_b, max_allowed)
+
+      case Distance.percent_bucket(ed, min_count) do
+        nil -> []
+        bucket when bucket > 0 -> [{bucket, {block_a.label, block_b.label}}]
+        # ed=0 handled by exact_pairs above
+        _ -> []
+      end
+    else
+      []
+    end
+  end
+
+  # Uses pre-computed children counts and newline counts from the decorated tuple
+  # so NodeProtocol.children/1 and Enum.count/2 are not called per candidate pair.
+  defp structure_compatible?(children_a, newlines_a, children_b, newlines_b) do
+    sub_diff = abs(children_a - children_b)
+    lines_a = newlines_a + 1
+    lines_b = newlines_b + 1
+    max_lines = max(lines_a, lines_b)
+    line_ratio = if max_lines > 0, do: abs(lines_a - lines_b) / max_lines, else: 0.0
+    sub_diff <= 1 and line_ratio <= 0.30
+  end
+end
diff --git a/lib/codeqa/metrics/file/near_duplicate_blocks/distance.ex b/lib/codeqa/metrics/file/near_duplicate_blocks/distance.ex
new file mode 100644
index 0000000..475aa3e
--- /dev/null
+++ b/lib/codeqa/metrics/file/near_duplicate_blocks/distance.ex
@@ -0,0 +1,114 @@
+defmodule CodeQA.Metrics.File.NearDuplicateBlocks.Distance do
+  @moduledoc """
+  Token-level edit distance and percentage-bucket classification for near-duplicate detection.
+
+  Provides standard Levenshtein distance, a bounded variant that short-circuits
+  when the distance already exceeds a threshold, and a bucket classifier that maps
+  an edit distance + minimum token count to a similarity bucket (d0–d8).
+
+  Distance buckets:
+    d0 = exact (0%), d1 ≤ 5%, d2 ≤ 10%, d3 ≤ 15%, d4 ≤ 20%,
+    d5 ≤ 25%, d6 ≤ 30%, d7 ≤ 40%, d8 ≤ 50%
+  """
+
+  @bucket_thresholds [
+    {0, 0.0},
+    {1, 0.05},
+    {2, 0.10},
+    {3, 0.15},
+    {4, 0.20},
+    {5, 0.25},
+    {6, 0.30},
+    {7, 0.40},
+    {8, 0.50}
+  ]
+
+  @doc "Standard Levenshtein distance between two token lists."
+  @spec token_edit_distance([String.t()], [String.t()]) :: non_neg_integer()
+  def token_edit_distance([], b), do: length(b)
+  def token_edit_distance(a, []), do: length(a)
+
+  def token_edit_distance(a, b) do
+    a_arr = List.to_tuple(a)
+    b_arr = List.to_tuple(b)
+    lb = tuple_size(b_arr)
+    init_row = List.to_tuple(Enum.to_list(0..lb))
+    result_row = levenshtein_rows(a_arr, b_arr, tuple_size(a_arr), lb, init_row, 1)
+    elem(result_row, lb)
+  end
+
+  defp levenshtein_rows(_a, _b, la, _lb, prev, i) when i > la, do: prev
+
+  defp levenshtein_rows(a, b, la, lb, prev, i) do
+    ai = elem(a, i - 1)
+    curr_reversed = levenshtein_cols(b, lb, prev, ai, [i], 1)
+    curr = List.to_tuple(:lists.reverse(curr_reversed))
+    levenshtein_rows(a, b, la, lb, curr, i + 1)
+  end
+
+  defp levenshtein_cols(_b, lb, _prev, _ai, acc, j) when j > lb, do: acc
+
+  defp levenshtein_cols(b, lb, prev, ai, [last_val | _] = acc, j) do
+    cost = if ai == elem(b, j - 1), do: 0, else: 1
+    val = min(elem(prev, j) + 1, min(last_val + 1, elem(prev, j - 1) + cost))
+    levenshtein_cols(b, lb, prev, ai, [val | acc], j + 1)
+  end
+
+  # Bounded Levenshtein: returns the edit distance, or max_distance + 1 if the
+  # distance would exceed max_distance. Bails after each row when the row minimum
+  # already exceeds max_distance — the final distance can only grow from there.
+  @doc false
+  @spec token_edit_distance_bounded([String.t()], [String.t()], non_neg_integer()) ::
+          non_neg_integer()
+  def token_edit_distance_bounded([], b, _max), do: length(b)
+  def token_edit_distance_bounded(a, [], _max), do: length(a)
+
+  def token_edit_distance_bounded(a, b, max_distance) do
+    a_arr = List.to_tuple(a)
+    b_arr = List.to_tuple(b)
+    lb = tuple_size(b_arr)
+    init_row = List.to_tuple(Enum.to_list(0..lb))
+    levenshtein_rows_bounded(a_arr, b_arr, tuple_size(a_arr), lb, init_row, max_distance, 1)
+  end
+
+  defp levenshtein_rows_bounded(_a, _b, la, lb, prev, _max, i) when i > la, do: elem(prev, lb)
+
+  defp levenshtein_rows_bounded(a, b, la, lb, prev, max_distance, i) do
+    ai = elem(a, i - 1)
+    # levenshtein_cols_with_min tracks the row minimum as it builds, avoiding
+    # a separate O(lb) pass to find the min after the row is complete.
+    {curr_reversed, row_min} = levenshtein_cols_with_min(b, lb, prev, ai, {[i], i}, 1)
+    curr = List.to_tuple(:lists.reverse(curr_reversed))
+
+    if row_min > max_distance do
+      max_distance + 1
+    else
+      levenshtein_rows_bounded(a, b, la, lb, curr, max_distance, i + 1)
+    end
+  end
+
+  defp levenshtein_cols_with_min(_b, lb, _prev, _ai, acc_and_min, j) when j > lb,
+    do: acc_and_min
+
+  defp levenshtein_cols_with_min(b, lb, prev, ai, {[last_val | _] = acc, min_val}, j) do
+    cost = if ai == elem(b, j - 1), do: 0, else: 1
+    val = min(elem(prev, j) + 1, min(last_val + 1, elem(prev, j - 1) + cost))
+    levenshtein_cols_with_min(b, lb, prev, ai, {[val | acc], min(min_val, val)}, j + 1)
+  end
+
+  @doc "Map an edit distance and min token count to a percentage bucket 0–8, or nil if > 50%."
+  @spec percent_bucket(non_neg_integer(), non_neg_integer()) :: 0..8 | nil
+  def percent_bucket(_ed, 0), do: nil
+  def percent_bucket(0, _min_count), do: 0
+
+  def percent_bucket(ed, min_count) do
+    pct = ed / min_count
+
+    @bucket_thresholds
+    |> Enum.find(fn {bucket, threshold} -> bucket > 0 and pct <= threshold end)
+    |> case do
+      {bucket, _} -> bucket
+      nil -> nil
+    end
+  end
+end
diff --git a/priv/combined_metrics/code_smells.yml b/priv/combined_metrics/code_smells.yml
index f1c73c5..2201f7d 100644
--- a/priv/combined_metrics/code_smells.yml
+++ b/priv/combined_metrics/code_smells.yml
@@ -1,5 +1,6 @@
 consistent_string_quote_style:
   _doc: "Files should use a single, consistent string quoting style throughout."
+  _languages: [elixir]
   _log_baseline: -18.2553
   branching:
     mean_branching_density: 0.0243
@@ -101,6 +102,7 @@ consistent_string_quote_style:
 
 no_dead_code_after_return:
   _doc: "There should be no unreachable statements after a return or early exit."
+  _languages: [elixir]
   _log_baseline: -55.8435
   branching:
     mean_branch_count: -2.0000
@@ -211,6 +213,7 @@ no_dead_code_after_return:
 
 no_debug_print_statements:
   _doc: "Debug output (`console.log`, `IO.inspect`, `fmt.Println`) must not be left in committed code."
+  _languages: [elixir]
   _log_baseline: -88.0844
   branching:
     mean_branch_count: -0.3540
@@ -321,6 +324,7 @@ no_debug_print_statements:
 
 no_fixme_comments:
   _doc: "FIXME, XXX, and HACK comments indicate known problems that should be resolved before merging."
+  _languages: [elixir]
   _log_baseline: -2.0233
   branching:
     mean_branch_count: 0.1755
@@ -435,6 +439,7 @@ no_fixme_comments:
 
 no_nested_ternary:
   _doc: "Nested conditional expressions (ternary-within-ternary) are harder to read than a plain if-else."
+  _languages: [elixir]
   _log_baseline: 7.6475
   branching:
     mean_branch_count: -0.5662
diff --git a/priv/combined_metrics/variable_naming.yml b/priv/combined_metrics/variable_naming.yml
index 1be9c6b..e7bc6fa 100644
--- a/priv/combined_metrics/variable_naming.yml
+++ b/priv/combined_metrics/variable_naming.yml
@@ -1,5 +1,6 @@
 boolean_has_is_has_prefix:
   _doc: "Boolean variables should be prefixed with `is_`, `has_`, or `can_`."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 15.9481
   brevity:
     mean_sample_size: 0.0752
@@ -62,6 +63,7 @@ boolean_has_is_has_prefix:
 
 collection_name_is_plural:
   _doc: "Variables holding a collection should use a plural name."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 21.8380
   brevity:
     mean_sample_size: -0.5320
@@ -123,6 +125,7 @@ collection_name_is_plural:
 
 loop_var_is_single_letter:
   _doc: "Loop index variables (`i`, `j`, `k`) are acceptable inside loop bodies."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -28.3218
   brevity:
     mean_sample_size: -0.1049
@@ -202,6 +205,7 @@ loop_var_is_single_letter:
 
 name_contains_and:
   _doc: "Variable names containing `and` signal a variable that holds two concerns."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 0.4689
   branching:
     mean_branch_count: -0.3666
@@ -320,6 +324,7 @@ name_contains_and:
 
 name_contains_type_suffix:
   _doc: "Type suffixes in names (`userString`, `nameList`) are redundant noise."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -26.6817
   branching:
     mean_branch_count: -0.4150
@@ -405,6 +410,7 @@ name_contains_type_suffix:
 
 name_is_abbreviation:
   _doc: "Abbreviated names (`usr`, `cfg`, `mgr`) reduce readability."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 10.7370
   brevity:
     mean_sample_size: -0.1542
@@ -491,6 +497,7 @@ name_is_abbreviation:
 
 name_is_generic:
   _doc: "Generic names (`data`, `result`, `tmp`, `val`, `obj`) convey no domain meaning."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 37.4815
   branching:
     mean_branch_count: 0.5193
@@ -607,6 +614,7 @@ name_is_generic:
 
 name_is_number_like:
   _doc: "Number-suffixed names (`var1`, `thing2`) signal a missing abstraction."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 1.7611
   brevity:
     mean_sample_size: -0.0262
@@ -685,6 +693,7 @@ name_is_number_like:
 
 name_is_single_letter:
   _doc: "Single-letter names outside loop indices are too opaque."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 26.2113
   branching:
     mean_branching_density: -0.0458
@@ -782,6 +791,7 @@ name_is_single_letter:
 
 name_is_too_long:
   _doc: "Names longer than ~30 characters harm readability."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -7.8322
   branching:
     mean_branch_count: 0.0340
@@ -902,6 +912,7 @@ name_is_too_long:
 
 name_is_too_short:
   _doc: "Names shorter than 3 characters (outside loops) are too opaque."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -2.7224
   branching:
     mean_branch_count: -0.2327
@@ -989,6 +1000,7 @@ name_is_too_short:
 
 negated_boolean_name:
   _doc: "Negated boolean names (`isNotValid`, `notActive`) are harder to reason about."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -4.4565
   brevity:
     mean_sample_size: -0.0998
@@ -1059,6 +1071,7 @@ negated_boolean_name:
 
 no_hungarian_notation:
   _doc: "Hungarian notation prefixes (`strName`, `bFlag`) add noise without type safety."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -15.5962
   brevity:
     mean_sample_size: -0.0814
@@ -1134,6 +1147,7 @@ no_hungarian_notation:
 
 screaming_snake_for_constants:
   _doc: "Module-level constants should use SCREAMING_SNAKE_CASE."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -5.9884
   branching:
     mean_branching_density: 0.0176

From 97cb5d0b654caf19604deecb1ccadf7e1158aa08 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Sat, 21 Mar 2026 14:15:00 +0000
Subject: [PATCH 46/71] chore(combined-metrics): sync language coverage and
 scalar vectors [skip ci]

---
 priv/combined_metrics/code_smells.yml     |  5 -----
 priv/combined_metrics/variable_naming.yml | 14 --------------
 2 files changed, 19 deletions(-)

diff --git a/priv/combined_metrics/code_smells.yml b/priv/combined_metrics/code_smells.yml
index 2201f7d..f1c73c5 100644
--- a/priv/combined_metrics/code_smells.yml
+++ b/priv/combined_metrics/code_smells.yml
@@ -1,6 +1,5 @@
 consistent_string_quote_style:
   _doc: "Files should use a single, consistent string quoting style throughout."
-  _languages: [elixir]
   _log_baseline: -18.2553
   branching:
     mean_branching_density: 0.0243
@@ -102,7 +101,6 @@ consistent_string_quote_style:
 
 no_dead_code_after_return:
   _doc: "There should be no unreachable statements after a return or early exit."
-  _languages: [elixir]
   _log_baseline: -55.8435
   branching:
     mean_branch_count: -2.0000
@@ -213,7 +211,6 @@ no_dead_code_after_return:
 
 no_debug_print_statements:
   _doc: "Debug output (`console.log`, `IO.inspect`, `fmt.Println`) must not be left in committed code."
-  _languages: [elixir]
   _log_baseline: -88.0844
   branching:
     mean_branch_count: -0.3540
@@ -324,7 +321,6 @@ no_debug_print_statements:
 
 no_fixme_comments:
   _doc: "FIXME, XXX, and HACK comments indicate known problems that should be resolved before merging."
-  _languages: [elixir]
   _log_baseline: -2.0233
   branching:
     mean_branch_count: 0.1755
@@ -439,7 +435,6 @@ no_fixme_comments:
 
 no_nested_ternary:
   _doc: "Nested conditional expressions (ternary-within-ternary) are harder to read than a plain if-else."
-  _languages: [elixir]
   _log_baseline: 7.6475
   branching:
     mean_branch_count: -0.5662
diff --git a/priv/combined_metrics/variable_naming.yml b/priv/combined_metrics/variable_naming.yml
index e7bc6fa..1be9c6b 100644
--- a/priv/combined_metrics/variable_naming.yml
+++ b/priv/combined_metrics/variable_naming.yml
@@ -1,6 +1,5 @@
 boolean_has_is_has_prefix:
   _doc: "Boolean variables should be prefixed with `is_`, `has_`, or `can_`."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 15.9481
   brevity:
     mean_sample_size: 0.0752
@@ -63,7 +62,6 @@ boolean_has_is_has_prefix:
 
 collection_name_is_plural:
   _doc: "Variables holding a collection should use a plural name."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 21.8380
   brevity:
     mean_sample_size: -0.5320
@@ -125,7 +123,6 @@ collection_name_is_plural:
 
 loop_var_is_single_letter:
   _doc: "Loop index variables (`i`, `j`, `k`) are acceptable inside loop bodies."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -28.3218
   brevity:
     mean_sample_size: -0.1049
@@ -205,7 +202,6 @@ loop_var_is_single_letter:
 
 name_contains_and:
   _doc: "Variable names containing `and` signal a variable that holds two concerns."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 0.4689
   branching:
     mean_branch_count: -0.3666
@@ -324,7 +320,6 @@ name_contains_and:
 
 name_contains_type_suffix:
   _doc: "Type suffixes in names (`userString`, `nameList`) are redundant noise."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -26.6817
   branching:
     mean_branch_count: -0.4150
@@ -410,7 +405,6 @@ name_contains_type_suffix:
 
 name_is_abbreviation:
   _doc: "Abbreviated names (`usr`, `cfg`, `mgr`) reduce readability."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 10.7370
   brevity:
     mean_sample_size: -0.1542
@@ -497,7 +491,6 @@ name_is_abbreviation:
 
 name_is_generic:
   _doc: "Generic names (`data`, `result`, `tmp`, `val`, `obj`) convey no domain meaning."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 37.4815
   branching:
     mean_branch_count: 0.5193
@@ -614,7 +607,6 @@ name_is_generic:
 
 name_is_number_like:
   _doc: "Number-suffixed names (`var1`, `thing2`) signal a missing abstraction."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 1.7611
   brevity:
     mean_sample_size: -0.0262
@@ -693,7 +685,6 @@ name_is_number_like:
 
 name_is_single_letter:
   _doc: "Single-letter names outside loop indices are too opaque."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 26.2113
   branching:
     mean_branching_density: -0.0458
@@ -791,7 +782,6 @@ name_is_single_letter:
 
 name_is_too_long:
   _doc: "Names longer than ~30 characters harm readability."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -7.8322
   branching:
     mean_branch_count: 0.0340
@@ -912,7 +902,6 @@ name_is_too_long:
 
 name_is_too_short:
   _doc: "Names shorter than 3 characters (outside loops) are too opaque."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -2.7224
   branching:
     mean_branch_count: -0.2327
@@ -1000,7 +989,6 @@ name_is_too_short:
 
 negated_boolean_name:
   _doc: "Negated boolean names (`isNotValid`, `notActive`) are harder to reason about."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -4.4565
   brevity:
     mean_sample_size: -0.0998
@@ -1071,7 +1059,6 @@ negated_boolean_name:
 
 no_hungarian_notation:
   _doc: "Hungarian notation prefixes (`strName`, `bFlag`) add noise without type safety."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -15.5962
   brevity:
     mean_sample_size: -0.0814
@@ -1147,7 +1134,6 @@ no_hungarian_notation:
 
 screaming_snake_for_constants:
   _doc: "Module-level constants should use SCREAMING_SNAKE_CASE."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -5.9884
   branching:
     mean_branching_density: 0.0176

From 579f1919806f4165ee390ae3f13ceb8e9a06a7e5 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sat, 21 Mar 2026 15:21:18 +0100
Subject: [PATCH 47/71] chore(ci): upgrade checkout to v6, add caching, remove
 dead blocks command

- Upgrade all workflows and README examples to actions/checkout@v6
- Add deps/_build caching to release, compare, health-report workflows
- Fix dialyzer PLT cache path (configure priv/plts in mix.exs) so PLTs actually cache instead of rebuilding every run
- Fix cache keys across workflows: include MIX_ENV, OTP/Elixir versions, and mix.exs in hash to prevent stale cache hits after version bumps
- Skip mix deps.get on cache hit in test.yml
- Delete blocks.yml workflow and remove all references to the blocks command from action.yml and run.sh (command was never implemented in the CLI)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .github/workflows/blocks.yml                 | 18 ---------------
 .github/workflows/bootstrap-labels.yml       |  2 +-
 .github/workflows/compare.yml                | 11 ++++++++-
 .github/workflows/dialyzer.yml               |  6 ++---
 .github/workflows/health-report.yml          | 12 +++++++++-
 .github/workflows/release.yml                | 24 +++++++++++++++++---
 .github/workflows/sync-behavior-coverage.yml |  6 ++---
 .github/workflows/test.yml                   |  9 +++++---
 .github/workflows/validate-issue-links.yml   |  2 +-
 README.md                                    |  4 ++--
 action.yml                                   |  2 +-
 mix.exs                                      |  6 ++++-
 scripts/run.sh                               |  6 +----
 13 files changed, 65 insertions(+), 43 deletions(-)
 delete mode 100644 .github/workflows/blocks.yml

diff --git a/.github/workflows/blocks.yml b/.github/workflows/blocks.yml
deleted file mode 100644
index 284adec..0000000
--- a/.github/workflows/blocks.yml
+++ /dev/null
@@ -1,18 +0,0 @@
-name: Extract Code Blocks
-
-on:
-  pull_request:
-    branches: [main]
-
-permissions:
-  contents: read
-
-jobs:
-  blocks:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ./
-        with:
-          command: blocks
-          build: source
diff --git a/.github/workflows/bootstrap-labels.yml b/.github/workflows/bootstrap-labels.yml
index a865335..52c644a 100644
--- a/.github/workflows/bootstrap-labels.yml
+++ b/.github/workflows/bootstrap-labels.yml
@@ -10,7 +10,7 @@ jobs:
   bootstrap:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Bootstrap labels
         uses: actions/github-script@v7
diff --git a/.github/workflows/compare.yml b/.github/workflows/compare.yml
index fa13ef0..5a672ad 100644
--- a/.github/workflows/compare.yml
+++ b/.github/workflows/compare.yml
@@ -12,10 +12,19 @@ jobs:
   compare:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 0
 
+      - name: Cache Mix deps and build
+        uses: actions/cache@v4
+        with:
+          path: |
+            deps
+            _build
+          key: ${{ runner.os }}-mix-1.19-27.3-${{ hashFiles('mix.lock', 'mix.exs') }}
+          restore-keys: ${{ runner.os }}-mix-1.19-27.3-
+
       - name: Get fork point
         id: fork-point
         run: |
diff --git a/.github/workflows/dialyzer.yml b/.github/workflows/dialyzer.yml
index 0674398..dfaca60 100644
--- a/.github/workflows/dialyzer.yml
+++ b/.github/workflows/dialyzer.yml
@@ -25,7 +25,7 @@ jobs:
 
     steps:
       - name: Checkout PR
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Set up Elixir
         uses: erlef/setup-beam@v1
@@ -45,9 +45,9 @@ jobs:
         uses: actions/cache@v4
         with:
           path: _build
-          key: build-${{ env.ELIXIR_VERSION }}-${{ env.OTP_VERSION }}-${{ hashFiles('mix.lock') }}
+          key: build-${{ env.MIX_ENV }}-${{ env.ELIXIR_VERSION }}-${{ env.OTP_VERSION }}-${{ hashFiles('mix.lock') }}
           restore-keys: |
-            build-${{ env.ELIXIR_VERSION }}-${{ env.OTP_VERSION }}-
+            build-${{ env.MIX_ENV }}-${{ env.ELIXIR_VERSION }}-${{ env.OTP_VERSION }}-
 
       - name: Cache PLT
         uses: actions/cache@v4
diff --git a/.github/workflows/health-report.yml b/.github/workflows/health-report.yml
index 55e38f0..2e0b896 100644
--- a/.github/workflows/health-report.yml
+++ b/.github/workflows/health-report.yml
@@ -12,7 +12,17 @@ jobs:
   health-report:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
+
+      - name: Cache Mix deps and build
+        uses: actions/cache@v4
+        with:
+          path: |
+            deps
+            _build
+          key: ${{ runner.os }}-mix-1.19-27.3-${{ hashFiles('mix.lock', 'mix.exs') }}
+          restore-keys: ${{ runner.os }}-mix-1.19-27.3-
+
       - uses: ./
         with:
           command: health-report
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index d1ebf66..13300bd 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -17,15 +17,33 @@ jobs:
   build:
     runs-on: ubuntu-latest
 
+    env:
+      ELIXIR_VERSION: "1.19"
+      OTP_VERSION: "27.3"
+
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Set up Elixir
         uses: erlef/setup-beam@v1
         with:
-          otp-version: "27.3"
-          elixir-version: "1.19"
+          otp-version: ${{ env.OTP_VERSION }}
+          elixir-version: ${{ env.ELIXIR_VERSION }}
+
+      - name: Cache deps
+        uses: actions/cache@v4
+        with:
+          path: deps
+          key: deps-${{ env.ELIXIR_VERSION }}-${{ env.OTP_VERSION }}-${{ hashFiles('mix.lock', 'mix.exs') }}
+          restore-keys: deps-${{ env.ELIXIR_VERSION }}-${{ env.OTP_VERSION }}-
+
+      - name: Cache build
+        uses: actions/cache@v4
+        with:
+          path: _build
+          key: build-${{ env.ELIXIR_VERSION }}-${{ env.OTP_VERSION }}-${{ hashFiles('mix.lock', 'mix.exs') }}
+          restore-keys: build-${{ env.ELIXIR_VERSION }}-${{ env.OTP_VERSION }}-
 
       - name: Build escript
         run: |
diff --git a/.github/workflows/sync-behavior-coverage.yml b/.github/workflows/sync-behavior-coverage.yml
index 8529dcc..dc1cc4f 100644
--- a/.github/workflows/sync-behavior-coverage.yml
+++ b/.github/workflows/sync-behavior-coverage.yml
@@ -14,7 +14,7 @@ jobs:
 
     steps:
       - name: Checkout PR branch
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           ref: ${{ github.head_ref }}
           token: ${{ secrets.GITHUB_TOKEN }}
@@ -31,8 +31,8 @@ jobs:
           path: |
             deps
             _build
-          key: ${{ runner.os }}-mix-${{ hashFiles('mix.lock') }}
-          restore-keys: ${{ runner.os }}-mix-
+          key: ${{ runner.os }}-mix-dev-otp27.3-elixir1.19-${{ hashFiles('mix.lock', 'mix.exs') }}
+          restore-keys: ${{ runner.os }}-mix-dev-otp27.3-elixir1.19-
 
       - name: Install dependencies
         run: mix deps.get
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index d560a17..04ba9b3 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -10,24 +10,27 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Set up Elixir
+        id: beam
         uses: erlef/setup-beam@v1
         with:
           otp-version: "27.3"
           elixir-version: "1.19"
 
       - name: Cache deps
+        id: mix-cache
         uses: actions/cache@v4
         with:
           path: |
             deps
             _build
-          key: ${{ runner.os }}-mix-${{ hashFiles('mix.lock') }}
-          restore-keys: ${{ runner.os }}-mix-
+          key: ${{ runner.os }}-mix-${{ steps.beam.outputs.otp-version }}-${{ steps.beam.outputs.elixir-version }}-${{ hashFiles('mix.lock', 'mix.exs') }}
+          restore-keys: ${{ runner.os }}-mix-${{ steps.beam.outputs.otp-version }}-${{ steps.beam.outputs.elixir-version }}-
 
       - name: Install dependencies
+        if: steps.mix-cache.outputs.cache-hit != 'true'
         run: mix deps.get
 
       - name: Compile
diff --git a/.github/workflows/validate-issue-links.yml b/.github/workflows/validate-issue-links.yml
index e366437..5960df4 100644
--- a/.github/workflows/validate-issue-links.yml
+++ b/.github/workflows/validate-issue-links.yml
@@ -12,7 +12,7 @@ jobs:
   validate:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Validate issue template links
         run: |
diff --git a/README.md b/README.md
index 071789b..1eab2d4 100644
--- a/README.md
+++ b/README.md
@@ -76,7 +76,7 @@ jobs:
   health-report:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - uses: num42/codeqa-action@v1
         with:
           command: health-report
@@ -95,7 +95,7 @@ jobs:
   compare:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 0
       - name: Get fork point
diff --git a/action.yml b/action.yml
index f680469..6be6078 100644
--- a/action.yml
+++ b/action.yml
@@ -8,7 +8,7 @@ branding:
 
 inputs:
   command:
-    description: "Command to run: health-report, compare, analyze, or blocks"
+    description: "Command to run: health-report, compare, or analyze"
     required: true
   path:
     description: "Directory to analyze"
diff --git a/mix.exs b/mix.exs
index 3c06031..cb2f413 100644
--- a/mix.exs
+++ b/mix.exs
@@ -12,7 +12,11 @@ defmodule CodeQA.MixProject do
       elixirc_paths: elixirc_paths(Mix.env()),
       preferred_envs: [precommit: :test],
       aliases: aliases(),
-      dialyzer: [ignore_warnings: ".dialyzer_ignore.exs"],
+      dialyzer: [
+        ignore_warnings: ".dialyzer_ignore.exs",
+        plt_local_path: "priv/plts",
+        plt_core_path: "priv/plts"
+      ],
       consolidate_protocols: Mix.env() != :test
     ]
   end
diff --git a/scripts/run.sh b/scripts/run.sh
index cac8046..9804205 100755
--- a/scripts/run.sh
+++ b/scripts/run.sh
@@ -38,9 +38,8 @@ case "$INPUT_COMMAND" in
     fi
     ;;
   analyze) OUTPUT_FILE="${OUTPUT_FILE}.json" ;;
-  blocks) OUTPUT_FILE="${OUTPUT_FILE}.json" ;;
   *)
-    echo "::error::Unknown command: $INPUT_COMMAND. Must be health-report, compare, analyze, or blocks."
+    echo "::error::Unknown command: $INPUT_COMMAND. Must be health-report, compare, or analyze."
     exit 1
     ;;
 esac
@@ -83,9 +82,6 @@ case "$INPUT_COMMAND" in
   analyze)
     ARGS+=("--output" "$OUTPUT_FILE")
     ;;
-  blocks)
-    ARGS+=("--output" "$OUTPUT_FILE")
-    ;;
 esac
 
 # Parse ignore-paths YAML list into --ignore-paths flag

From 0787134f12b099ab3acd92c300acefac81d79e2a Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sun, 22 Mar 2026 16:48:07 +0100
Subject: [PATCH 48/71] fix(near-duplicate-blocks): return zeroed map when
 blocks is nil

LOO analysis skips structural tokenization, producing a nil blocks field.
Add a dedicated clause so NearDuplicateBlocksFile.analyze/1 returns a
zeroed map instead of crashing on a missing pattern match.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/metrics/file/near_duplicate_blocks_file.ex | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lib/codeqa/metrics/file/near_duplicate_blocks_file.ex b/lib/codeqa/metrics/file/near_duplicate_blocks_file.ex
index 86f71e3..7a15e74 100644
--- a/lib/codeqa/metrics/file/near_duplicate_blocks_file.ex
+++ b/lib/codeqa/metrics/file/near_duplicate_blocks_file.ex
@@ -20,6 +20,8 @@ defmodule CodeQA.Metrics.File.NearDuplicateBlocksFile do
   end
 
   @impl true
+  def analyze(%{blocks: nil}), do: Map.new(keys(), fn k -> {k, 0} end)
+
   def analyze(%{path: path, blocks: blocks}) when is_list(blocks) do
     NearDuplicateBlocks.analyze_from_blocks(
       NearDuplicateBlocks.label_blocks(blocks, path || "unknown"),

From 20d1773c4e197262e277ee7d67a5990fb1fef4b8 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sun, 22 Mar 2026 16:48:12 +0100
Subject: [PATCH 49/71] chore(combined-metrics): annotate language coverage for
 all behaviors

Adds _languages constraints to behaviors that are language-specific,
enabling the analyzer to skip irrelevant behaviors when only a subset
of languages is present in the project.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 priv/combined_metrics/code_smells.yml     |  5 +++++
 priv/combined_metrics/variable_naming.yml | 14 ++++++++++++++
 2 files changed, 19 insertions(+)

diff --git a/priv/combined_metrics/code_smells.yml b/priv/combined_metrics/code_smells.yml
index f1c73c5..2201f7d 100644
--- a/priv/combined_metrics/code_smells.yml
+++ b/priv/combined_metrics/code_smells.yml
@@ -1,5 +1,6 @@
 consistent_string_quote_style:
   _doc: "Files should use a single, consistent string quoting style throughout."
+  _languages: [elixir]
   _log_baseline: -18.2553
   branching:
     mean_branching_density: 0.0243
@@ -101,6 +102,7 @@ consistent_string_quote_style:
 
 no_dead_code_after_return:
   _doc: "There should be no unreachable statements after a return or early exit."
+  _languages: [elixir]
   _log_baseline: -55.8435
   branching:
     mean_branch_count: -2.0000
@@ -211,6 +213,7 @@ no_dead_code_after_return:
 
 no_debug_print_statements:
   _doc: "Debug output (`console.log`, `IO.inspect`, `fmt.Println`) must not be left in committed code."
+  _languages: [elixir]
   _log_baseline: -88.0844
   branching:
     mean_branch_count: -0.3540
@@ -321,6 +324,7 @@ no_debug_print_statements:
 
 no_fixme_comments:
   _doc: "FIXME, XXX, and HACK comments indicate known problems that should be resolved before merging."
+  _languages: [elixir]
   _log_baseline: -2.0233
   branching:
     mean_branch_count: 0.1755
@@ -435,6 +439,7 @@ no_fixme_comments:
 
 no_nested_ternary:
   _doc: "Nested conditional expressions (ternary-within-ternary) are harder to read than a plain if-else."
+  _languages: [elixir]
   _log_baseline: 7.6475
   branching:
     mean_branch_count: -0.5662
diff --git a/priv/combined_metrics/variable_naming.yml b/priv/combined_metrics/variable_naming.yml
index 1be9c6b..e7bc6fa 100644
--- a/priv/combined_metrics/variable_naming.yml
+++ b/priv/combined_metrics/variable_naming.yml
@@ -1,5 +1,6 @@
 boolean_has_is_has_prefix:
   _doc: "Boolean variables should be prefixed with `is_`, `has_`, or `can_`."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 15.9481
   brevity:
     mean_sample_size: 0.0752
@@ -62,6 +63,7 @@ boolean_has_is_has_prefix:
 
 collection_name_is_plural:
   _doc: "Variables holding a collection should use a plural name."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 21.8380
   brevity:
     mean_sample_size: -0.5320
@@ -123,6 +125,7 @@ collection_name_is_plural:
 
 loop_var_is_single_letter:
   _doc: "Loop index variables (`i`, `j`, `k`) are acceptable inside loop bodies."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -28.3218
   brevity:
     mean_sample_size: -0.1049
@@ -202,6 +205,7 @@ loop_var_is_single_letter:
 
 name_contains_and:
   _doc: "Variable names containing `and` signal a variable that holds two concerns."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 0.4689
   branching:
     mean_branch_count: -0.3666
@@ -320,6 +324,7 @@ name_contains_and:
 
 name_contains_type_suffix:
   _doc: "Type suffixes in names (`userString`, `nameList`) are redundant noise."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -26.6817
   branching:
     mean_branch_count: -0.4150
@@ -405,6 +410,7 @@ name_contains_type_suffix:
 
 name_is_abbreviation:
   _doc: "Abbreviated names (`usr`, `cfg`, `mgr`) reduce readability."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 10.7370
   brevity:
     mean_sample_size: -0.1542
@@ -491,6 +497,7 @@ name_is_abbreviation:
 
 name_is_generic:
   _doc: "Generic names (`data`, `result`, `tmp`, `val`, `obj`) convey no domain meaning."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 37.4815
   branching:
     mean_branch_count: 0.5193
@@ -607,6 +614,7 @@ name_is_generic:
 
 name_is_number_like:
   _doc: "Number-suffixed names (`var1`, `thing2`) signal a missing abstraction."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 1.7611
   brevity:
     mean_sample_size: -0.0262
@@ -685,6 +693,7 @@ name_is_number_like:
 
 name_is_single_letter:
   _doc: "Single-letter names outside loop indices are too opaque."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 26.2113
   branching:
     mean_branching_density: -0.0458
@@ -782,6 +791,7 @@ name_is_single_letter:
 
 name_is_too_long:
   _doc: "Names longer than ~30 characters harm readability."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -7.8322
   branching:
     mean_branch_count: 0.0340
@@ -902,6 +912,7 @@ name_is_too_long:
 
 name_is_too_short:
   _doc: "Names shorter than 3 characters (outside loops) are too opaque."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -2.7224
   branching:
     mean_branch_count: -0.2327
@@ -989,6 +1000,7 @@ name_is_too_short:
 
 negated_boolean_name:
   _doc: "Negated boolean names (`isNotValid`, `notActive`) are harder to reason about."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -4.4565
   brevity:
     mean_sample_size: -0.0998
@@ -1059,6 +1071,7 @@ negated_boolean_name:
 
 no_hungarian_notation:
   _doc: "Hungarian notation prefixes (`strName`, `bFlag`) add noise without type safety."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -15.5962
   brevity:
     mean_sample_size: -0.0814
@@ -1134,6 +1147,7 @@ no_hungarian_notation:
 
 screaming_snake_for_constants:
   _doc: "Module-level constants should use SCREAMING_SNAKE_CASE."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -5.9884
   branching:
     mean_branching_density: 0.0176

From e68cbd3c58ab3d5ea545ed94bdc2b94f6754b523 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sun, 22 Mar 2026 16:48:21 +0100
Subject: [PATCH 50/71] perf(block-impact): precompute log metrics and cache
 behaviors for cosine scoring
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Three complementary optimizations that cut repeated work per LOO iteration:

1. SampleRunner.diagnose_aggregate/2 now precomputes a log-metrics map
   once per call, so CosineVector inner loops do O(1) lookups instead of
   recomputing :math.log for every (behavior, metric) pair.

2. BlockImpactAnalyzer.analyze/3 accepts a behavior_config_pid and fetches
   all behaviors once at the start of each run, filtering by project
   languages before passing the cached map down through RefactoringPotentials
   and SampleRunner — eliminating repeated YAML reads per node.

3. BlockImpactAnalyzer computes an incremental aggregate structure up front
   and applies O(behaviors) swap operations per node instead of re-aggregating
   the full files map from scratch each time.

Telemetry events are emitted at the codebase, file, and node levels to
surface bottlenecks without requiring profiling runs.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../block_impact/refactoring_potentials.ex    |  22 +-
 lib/codeqa/block_impact_analyzer.ex           | 325 +++++++++++++++---
 lib/codeqa/combined_metrics/cosine_vector.ex  |  31 +-
 lib/codeqa/combined_metrics/sample_runner.ex  |  92 +++--
 4 files changed, 381 insertions(+), 89 deletions(-)

diff --git a/lib/codeqa/block_impact/refactoring_potentials.ex b/lib/codeqa/block_impact/refactoring_potentials.ex
index 092d97b..f2417ef 100644
--- a/lib/codeqa/block_impact/refactoring_potentials.ex
+++ b/lib/codeqa/block_impact/refactoring_potentials.ex
@@ -42,11 +42,13 @@ defmodule CodeQA.BlockImpact.RefactoringPotentials do
     top_n = Keyword.get(opts, :top, 3)
     language = Keyword.get(opts, :language)
     languages = Keyword.get(opts, :languages)
+    behavior_map = Keyword.get(opts, :behavior_map)
 
-    file_delta = compute_file_delta(baseline_file_cosines, without_file_metrics, language)
+    file_delta =
+      compute_file_delta(baseline_file_cosines, without_file_metrics, language, behavior_map)
 
     codebase_delta =
-      compute_codebase_delta(baseline_codebase_cosines, without_codebase_agg, languages)
+      compute_codebase_delta(baseline_codebase_cosines, without_codebase_agg, languages, behavior_map)
 
     all_keys = Enum.uniq(Map.keys(file_delta) ++ Map.keys(codebase_delta))
 
@@ -68,18 +70,26 @@ defmodule CodeQA.BlockImpact.RefactoringPotentials do
     end)
   end
 
-  defp compute_file_delta(baseline_cosines, without_metrics, language) do
+  defp compute_file_delta(baseline_cosines, without_metrics, language, behavior_map) do
     without_agg = FileScorer.file_to_aggregate(without_metrics)
 
     without_cosines =
-      SampleRunner.diagnose_aggregate(without_agg, top: 99_999, language: language)
+      SampleRunner.diagnose_aggregate(without_agg,
+        top: 99_999,
+        language: language,
+        behavior_map: behavior_map
+      )
 
     cosines_to_delta(baseline_cosines, without_cosines)
   end
 
-  defp compute_codebase_delta(baseline_cosines, without_agg, languages) do
+  defp compute_codebase_delta(baseline_cosines, without_agg, languages, behavior_map) do
     without_cosines =
-      SampleRunner.diagnose_aggregate(without_agg, top: 99_999, languages: languages)
+      SampleRunner.diagnose_aggregate(without_agg,
+        top: 99_999,
+        languages: languages,
+        behavior_map: behavior_map
+      )
 
     cosines_to_delta(baseline_cosines, without_cosines)
   end
diff --git a/lib/codeqa/block_impact_analyzer.ex b/lib/codeqa/block_impact_analyzer.ex
index de00e02..c317617 100644
--- a/lib/codeqa/block_impact_analyzer.ex
+++ b/lib/codeqa/block_impact_analyzer.ex
@@ -8,8 +8,29 @@ defmodule CodeQA.BlockImpactAnalyzer do
 
   The pipeline result is returned with a `"nodes"` key added to each file entry.
   All other keys in the result are preserved unchanged.
+
+  ## Telemetry
+
+  Emits the following events (all durations in microseconds):
+
+    - `[:codeqa, :block_impact, :analyze]` — full run
+      measurements: `%{duration: us}`
+      metadata: `%{file_count: n}`
+
+    - `[:codeqa, :block_impact, :codebase_cosines]` — codebase baseline cosine computation
+      measurements: `%{duration: us}`
+      metadata: `%{behavior_count: n}`
+
+    - `[:codeqa, :block_impact, :file]` — per-file node computation
+      measurements: `%{duration: us, tokenize_us: us, parse_us: us, file_cosines_us: us, node_count: n}`
+      metadata: `%{path: string}`
+
+    - `[:codeqa, :block_impact, :node]` — per-node leave-one-out computation
+      measurements: `%{duration: us, reconstruct_us: us, analyze_file_us: us, aggregate_us: us, refactoring_us: us}`
+      metadata: `%{path: string, token_count: n}`
   """
 
+  alias CodeQA.Analysis.BehaviorConfigServer
   alias CodeQA.AST.Enrichment.Node
   alias CodeQA.AST.Lexing.TokenNormalizer
   alias CodeQA.AST.Parsing.Parser
@@ -34,20 +55,49 @@ defmodule CodeQA.BlockImpactAnalyzer do
 
   - `:nodes_top` — number of refactoring potentials per node (default 3)
   - `:workers` — parallelism for `Task.async_stream` (default `System.schedulers_online()`)
+  - `:baseline_codebase_agg` — pre-computed codebase aggregate (skips redundant analysis)
   """
   @spec analyze(map(), map(), keyword()) :: map()
   def analyze(pipeline_result, files_map, opts \\ []) do
     nodes_top = Keyword.get(opts, :nodes_top, 3)
     workers = Keyword.get(opts, :workers, System.schedulers_online())
 
-    baseline_codebase_agg = Analyzer.analyze_codebase_aggregate(files_map)
+    t0 = now()
+
+    baseline_codebase_agg =
+      Keyword.get_lazy(opts, :baseline_codebase_agg, fn ->
+        Analyzer.analyze_codebase_aggregate(files_map)
+      end)
+
+    cached_behaviors =
+      case Keyword.get(opts, :behavior_config_pid) do
+        nil -> nil
+        pid -> BehaviorConfigServer.get_all_behaviors(pid)
+      end
+
     project_langs = project_languages(files_map)
 
-    baseline_codebase_cosines =
-      SampleRunner.diagnose_aggregate(baseline_codebase_agg,
-        top: 99_999,
-        languages: project_langs
-      )
+    filtered_behaviors =
+      if cached_behaviors && project_langs != [] do
+        filter_behaviors_by_languages(cached_behaviors, project_langs)
+      else
+        cached_behaviors
+      end
+
+    {baseline_codebase_cosines, cosines_us} =
+      timed(fn ->
+        SampleRunner.diagnose_aggregate(baseline_codebase_agg,
+          top: 99_999,
+          languages: project_langs,
+          behavior_map: filtered_behaviors
+        )
+      end)
+
+    :telemetry.execute(
+      [:codeqa, :block_impact, :codebase_cosines],
+      %{duration: cosines_us},
+      %{behavior_count: length(baseline_codebase_cosines)}
+    )
 
     file_results = pipeline_result["files"]
 
@@ -58,16 +108,23 @@ defmodule CodeQA.BlockImpactAnalyzer do
           content = Map.get(files_map, path, "")
           baseline_file_metrics = Map.get(file_data, "metrics", %{})
 
-          nodes =
-            compute_nodes(
+          {nodes, file_measurements} =
+            compute_nodes_timed(
               path,
               content,
               baseline_file_metrics,
               file_results,
               baseline_codebase_cosines,
-              nodes_top
+              nodes_top,
+              filtered_behaviors
             )
 
+          :telemetry.execute(
+            [:codeqa, :block_impact, :file],
+            file_measurements,
+            %{path: path}
+          )
+
           {path, Map.put(file_data, "nodes", nodes)}
         end,
         max_concurrency: workers,
@@ -76,43 +133,80 @@ defmodule CodeQA.BlockImpactAnalyzer do
       )
       |> Enum.reduce(%{}, fn {:ok, {path, data}}, acc -> Map.put(acc, path, data) end)
 
+    :telemetry.execute(
+      [:codeqa, :block_impact, :analyze],
+      %{duration: now() - t0},
+      %{file_count: map_size(file_results)}
+    )
+
     Map.put(pipeline_result, "files", updated_files)
   end
 
-  defp compute_nodes(
+  defp compute_nodes_timed(
          path,
          content,
          baseline_file_metrics,
          file_results,
          baseline_codebase_cosines,
-         nodes_top
+         nodes_top,
+         cached_behaviors
        ) do
     if content == "" do
-      []
+      {[], %{duration: 0, tokenize_us: 0, parse_us: 0, file_cosines_us: 0, node_count: 0}}
     else
-      root_tokens = TokenNormalizer.normalize_structural(content)
-      top_level_nodes = Parser.detect_blocks(root_tokens, Unknown)
+      t0 = now()
+
+      {root_tokens, tokenize_us} = timed(fn -> TokenNormalizer.normalize_structural(content) end)
+      {top_level_nodes, parse_us} = timed(fn -> Parser.detect_blocks(root_tokens, Unknown) end)
 
       baseline_file_agg = FileScorer.file_to_aggregate(baseline_file_metrics)
       language = CodeQA.Language.detect(path).name()
 
-      baseline_file_cosines =
-        SampleRunner.diagnose_aggregate(baseline_file_agg, top: 99_999, language: language)
+      {baseline_file_cosines, file_cosines_us} =
+        timed(fn ->
+          SampleRunner.diagnose_aggregate(baseline_file_agg,
+            top: 99_999,
+            language: language,
+            behavior_map: cached_behaviors
+          )
+        end)
 
-      top_level_nodes
-      |> Enum.map(fn node ->
-        serialize_node(
-          node,
-          path,
-          root_tokens,
-          baseline_file_cosines,
-          file_results,
-          baseline_codebase_cosines,
-          nodes_top,
-          language
-        )
-      end)
-      |> Enum.sort_by(fn n -> {n["start_line"], n["column_start"]} end)
+      inc_agg = build_incremental_agg(file_results)
+      old_file_triples = file_metrics_to_triples(baseline_file_metrics)
+      project_langs = project_languages(file_results)
+
+      node_ctx = %{
+        inc_agg: inc_agg,
+        old_file_triples: old_file_triples,
+        project_langs: project_langs,
+        cached_behaviors: cached_behaviors
+      }
+
+      nodes =
+        top_level_nodes
+        |> Enum.map(fn node ->
+          serialize_node(
+            node,
+            path,
+            root_tokens,
+            baseline_file_cosines,
+            baseline_codebase_cosines,
+            nodes_top,
+            language,
+            node_ctx
+          )
+        end)
+        |> Enum.sort_by(fn n -> {n["start_line"], n["column_start"]} end)
+
+      measurements = %{
+        duration: now() - t0,
+        tokenize_us: tokenize_us,
+        parse_us: parse_us,
+        file_cosines_us: file_cosines_us,
+        node_count: length(top_level_nodes)
+      }
+
+      {nodes, measurements}
     end
   end
 
@@ -121,24 +215,24 @@ defmodule CodeQA.BlockImpactAnalyzer do
          path,
          root_tokens,
          baseline_file_cosines,
-         file_results,
          baseline_codebase_cosines,
          nodes_top,
-         language
+         language,
+         node_ctx
        ) do
     potentials =
       if length(node.tokens) < @min_tokens do
         []
       else
-        compute_potentials(
+        compute_potentials_timed(
           node,
           path,
           root_tokens,
           baseline_file_cosines,
-          file_results,
           baseline_codebase_cosines,
           nodes_top,
-          language
+          language,
+          node_ctx
         )
       end
 
@@ -150,10 +244,10 @@ defmodule CodeQA.BlockImpactAnalyzer do
           path,
           root_tokens,
           baseline_file_cosines,
-          file_results,
           baseline_codebase_cosines,
           nodes_top,
-          language
+          language,
+          node_ctx
         )
       end)
       |> Enum.sort_by(fn n -> {n["start_line"], n["column_start"]} end)
@@ -173,35 +267,144 @@ defmodule CodeQA.BlockImpactAnalyzer do
     }
   end
 
-  defp compute_potentials(
+  defp compute_potentials_timed(
          %Node{} = node,
          path,
          root_tokens,
          baseline_file_cosines,
-         file_results,
          baseline_codebase_cosines,
          nodes_top,
-         language
+         language,
+         node_ctx
        ) do
-    reconstructed = FileImpact.reconstruct_without(root_tokens, node)
-    without_file_metrics = Analyzer.analyze_file(path, reconstructed)
+    t0 = now()
 
-    without_codebase_agg =
-      file_results
-      |> Map.put(path, %{"metrics" => without_file_metrics})
-      |> Analyzer.aggregate_file_metrics()
-
-    project_langs = project_languages(file_results)
-
-    RefactoringPotentials.compute(
-      baseline_file_cosines,
-      without_file_metrics,
-      baseline_codebase_cosines,
-      without_codebase_agg,
-      top: nodes_top,
-      language: language,
-      languages: project_langs
+    {reconstructed, reconstruct_us} =
+      timed(fn -> FileImpact.reconstruct_without(root_tokens, node) end)
+
+    {without_file_metrics, analyze_file_us} =
+      timed(fn -> Analyzer.analyze_file_for_loo(path, reconstructed) end)
+
+    {without_codebase_agg, aggregate_us} =
+      timed(fn ->
+        new_triples = file_metrics_to_triples(without_file_metrics)
+
+        node_ctx.inc_agg
+        |> swap_file_in_agg(node_ctx.old_file_triples, new_triples)
+        |> incremental_agg_to_aggregate()
+      end)
+
+    {potentials, refactoring_us} =
+      timed(fn ->
+        RefactoringPotentials.compute(
+          baseline_file_cosines,
+          without_file_metrics,
+          baseline_codebase_cosines,
+          without_codebase_agg,
+          top: nodes_top,
+          language: language,
+          languages: node_ctx.project_langs,
+          behavior_map: node_ctx.cached_behaviors
+        )
+      end)
+
+    :telemetry.execute(
+      [:codeqa, :block_impact, :node],
+      %{
+        duration: now() - t0,
+        reconstruct_us: reconstruct_us,
+        analyze_file_us: analyze_file_us,
+        aggregate_us: aggregate_us,
+        refactoring_us: refactoring_us
+      },
+      %{path: path, token_count: length(node.tokens)}
     )
+
+    potentials
+  end
+
+  defp file_metrics_to_triples(metrics) when is_map(metrics) do
+    metrics
+    |> Enum.flat_map(fn {metric_name, metric_data} when is_map(metric_data) ->
+      metric_data
+      |> Enum.filter(fn {_k, v} -> is_number(v) end)
+      |> Enum.map(fn {key, value} -> {metric_name, key, value / 1} end)
+
+      _ -> []
+    end)
+  end
+
+  defp build_incremental_agg(file_results) do
+    file_results
+    |> Map.values()
+    |> Enum.flat_map(fn file_data ->
+      file_data |> Map.get("metrics", %{}) |> file_metrics_to_triples()
+    end)
+    |> Enum.group_by(fn {metric, key, _val} -> {metric, key} end, fn {_, _, val} -> val end)
+    |> Map.new(fn {{metric, key}, values} ->
+      n = length(values)
+      sum = Enum.sum(values)
+      sum_sq = Enum.reduce(values, 0.0, fn v, acc -> acc + v * v end)
+      {{metric, key}, %{sum: sum, sum_sq: sum_sq, min: Enum.min(values), max: Enum.max(values), count: n}}
+    end)
+  end
+
+  defp swap_file_in_agg(inc_agg, old_triples, new_triples) do
+    old_map = Map.new(old_triples, fn {metric, key, val} -> {{metric, key}, val} end)
+    new_map = Map.new(new_triples, fn {metric, key, val} -> {{metric, key}, val} end)
+    all_keys = Enum.uniq(Map.keys(old_map) ++ Map.keys(new_map))
+
+    Enum.reduce(all_keys, inc_agg, fn mk, acc ->
+      case Map.get(acc, mk) do
+        nil ->
+          acc
+
+        state ->
+          old_val = Map.get(old_map, mk, 0.0)
+          new_val = Map.get(new_map, mk, 0.0)
+
+          Map.put(acc, mk, %{
+            sum: state.sum - old_val + new_val,
+            sum_sq: state.sum_sq - old_val * old_val + new_val * new_val,
+            min: min(state.min, new_val),
+            max: max(state.max, new_val),
+            count: state.count
+          })
+      end
+    end)
+  end
+
+  defp incremental_agg_to_aggregate(inc_agg) do
+    Enum.reduce(inc_agg, %{}, fn {{metric, key}, state}, acc ->
+      n = state.count
+      mean = if n > 0, do: state.sum / n, else: 0.0
+      variance = if n > 0, do: max(state.sum_sq / n - mean * mean, 0.0), else: 0.0
+      std = :math.sqrt(variance)
+
+      metric_agg = Map.get(acc, metric, %{})
+
+      updated =
+        Map.merge(metric_agg, %{
+          "mean_#{key}" => Float.round(mean * 1.0, 4),
+          "std_#{key}" => Float.round(std * 1.0, 4),
+          "min_#{key}" => Float.round(state.min * 1.0, 4),
+          "max_#{key}" => Float.round(state.max * 1.0, 4)
+        })
+
+      Map.put(acc, metric, updated)
+    end)
+  end
+
+  defp filter_behaviors_by_languages(behaviors_map, project_langs) do
+    Map.new(behaviors_map, fn {category, behaviors} ->
+      filtered =
+        Enum.filter(behaviors, fn {_behavior, behavior_data} ->
+          behavior_langs = Map.get(behavior_data, "_languages", [])
+          behavior_langs == [] or Enum.any?(behavior_langs, &(&1 in project_langs))
+        end)
+
+      {category, filtered}
+    end)
   end
 
   defp project_languages(path_keyed_map) do
@@ -211,4 +414,12 @@ defmodule CodeQA.BlockImpactAnalyzer do
     |> Enum.reject(&(&1 == "unknown"))
     |> Enum.uniq()
   end
+
+  defp timed(fun) do
+    t = now()
+    result = fun.()
+    {result, now() - t}
+  end
+
+  defp now, do: System.monotonic_time(:microsecond)
 end
diff --git a/lib/codeqa/combined_metrics/cosine_vector.ex b/lib/codeqa/combined_metrics/cosine_vector.ex
index 158b24e..36bbe23 100644
--- a/lib/codeqa/combined_metrics/cosine_vector.ex
+++ b/lib/codeqa/combined_metrics/cosine_vector.ex
@@ -13,27 +13,35 @@ defmodule CodeQA.CombinedMetrics.CosineVector do
 
   Returns a one-element list `[result_map]` on success or `[]` when the behavior
   has no non-zero scalars (no sample data) and should be excluded.
+
+  ## Options
+
+    * `:log_metrics` - precomputed log-metric map `%{group => %{key => log_val}}`.
+      When present, values are looked up directly instead of being recomputed via
+      `:math.log/1`. Falls back to inline computation when absent or when a key is
+      not found in the map.
   """
-  @spec compute(String.t(), String.t(), map(), map(), String.t()) :: [map()]
-  def compute(yaml_path, behavior, behavior_data, aggregate, category) do
+  @spec compute(String.t(), String.t(), map(), map(), String.t(), keyword()) :: [map()]
+  def compute(yaml_path, behavior, behavior_data, aggregate, category, opts \\ []) do
     scalars = Scorer.scalars_for(yaml_path, behavior)
 
     if map_size(scalars) == 0 do
       []
     else
-      build_result(yaml_path, behavior, behavior_data, aggregate, category, scalars)
+      build_result(yaml_path, behavior, behavior_data, aggregate, category, scalars, opts)
     end
   end
 
   # --- Internal helpers ---
 
-  defp build_result(yaml_path, behavior, behavior_data, aggregate, category, scalars) do
+  defp build_result(yaml_path, behavior, behavior_data, aggregate, category, scalars, opts) do
     log_baseline = Map.get(behavior_data, "_log_baseline", 0.0) / 1.0
+    log_metrics = Keyword.get(opts, :log_metrics)
 
     {dot, norm_s_sq, norm_v_sq, contributions} =
       Enum.reduce(scalars, {0.0, 0.0, 0.0, []}, fn {{group, key}, scalar},
                                                    {d, ns, nv, contribs} ->
-        log_m = :math.log(Scorer.get(aggregate, group, key))
+        log_m = lookup_log_metric(log_metrics, aggregate, group, key)
         contrib = scalar * log_m
 
         {d + contrib, ns + scalar * scalar, nv + log_m * log_m,
@@ -66,4 +74,17 @@ defmodule CodeQA.CombinedMetrics.CosineVector do
       }
     ]
   end
+
+  # Returns a precomputed log value when available, otherwise computes inline.
+  # Both paths apply the same max(val, 1.0e-300) floor guard to ensure identical
+  # results regardless of whether log_metrics was precomputed or not.
+  defp lookup_log_metric(nil, aggregate, group, key),
+    do: :math.log(max(Scorer.get(aggregate, group, key) / 1.0, 1.0e-300))
+
+  defp lookup_log_metric(log_metrics, aggregate, group, key) do
+    case get_in(log_metrics, [group, key]) do
+      nil -> :math.log(max(Scorer.get(aggregate, group, key) / 1.0, 1.0e-300))
+      log_val -> log_val
+    end
+  end
 end
diff --git a/lib/codeqa/combined_metrics/sample_runner.ex b/lib/codeqa/combined_metrics/sample_runner.ex
index 3cd6533..6c5b6c9 100644
--- a/lib/codeqa/combined_metrics/sample_runner.ex
+++ b/lib/codeqa/combined_metrics/sample_runner.ex
@@ -179,26 +179,55 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
     top_n = Keyword.get(opts, :top, 15)
     language = Keyword.get(opts, :language)
     languages = Keyword.get(opts, :languages)
+    behavior_map = Keyword.get(opts, :behavior_map)
+
+    log_metrics = precompute_log_metrics(aggregate)
+    cosine_opts = [log_metrics: log_metrics]
+
+    behaviors_stream =
+      if behavior_map do
+        behavior_map
+        |> Enum.sort_by(fn {category, _} -> category end)
+        |> Enum.flat_map(fn {category, behaviors} ->
+          Enum.flat_map(behaviors, fn {behavior, behavior_data} ->
+            yaml_path = "priv/combined_metrics/#{category}.yml"
+
+            maybe_diagnose_behavior(
+              yaml_path,
+              behavior,
+              behavior_data,
+              aggregate,
+              category,
+              language,
+              languages,
+              cosine_opts
+            )
+          end)
+        end)
+      else
+        Scorer.all_yamls()
+        |> Enum.sort_by(fn {path, _} -> path end)
+        |> Enum.flat_map(fn {yaml_path, data} ->
+          category = yaml_path |> Path.basename() |> String.trim_trailing(".yml")
+
+          data
+          |> Enum.filter(fn {_k, v} -> is_map(v) end)
+          |> Enum.flat_map(fn {behavior, behavior_data} ->
+            maybe_diagnose_behavior(
+              yaml_path,
+              behavior,
+              behavior_data,
+              aggregate,
+              category,
+              language,
+              languages,
+              cosine_opts
+            )
+          end)
+        end)
+      end
 
-    Scorer.all_yamls()
-    |> Enum.sort_by(fn {path, _} -> path end)
-    |> Enum.flat_map(fn {yaml_path, data} ->
-      category = yaml_path |> Path.basename() |> String.trim_trailing(".yml")
-
-      data
-      |> Enum.filter(fn {_k, v} -> is_map(v) end)
-      |> Enum.flat_map(fn {behavior, behavior_data} ->
-        maybe_diagnose_behavior(
-          yaml_path,
-          behavior,
-          behavior_data,
-          aggregate,
-          category,
-          language,
-          languages
-        )
-      end)
-    end)
+    behaviors_stream
     |> Enum.sort_by(& &1.cosine)
     |> Enum.take(top_n)
   end
@@ -355,6 +384,26 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
   # Cosine diagnosis (delegates vector math to CosineVector)
   # ---------------------------------------------------------------------------
 
+  # Builds a nested map of precomputed log values for all numeric entries in the
+  # aggregate: %{group => %{key => :math.log(max(val, 1.0e-300))}}.
+  # Called once per diagnose_aggregate/2 invocation so the inner reduce in
+  # CosineVector.build_result can do O(1) lookups instead of recomputing log
+  # for every (behavior, metric) pair.
+  defp precompute_log_metrics(aggregate) do
+    aggregate
+    |> Enum.filter(fn {_group, sub_map} -> is_map(sub_map) end)
+    |> Map.new(fn {group, sub_map} ->
+      log_sub =
+        sub_map
+        |> Enum.filter(fn {_key, val} -> is_number(val) end)
+        |> Map.new(fn {key, val} ->
+          {key, :math.log(max(val / 1.0, 1.0e-300))}
+        end)
+
+      {group, log_sub}
+    end)
+  end
+
   defp maybe_diagnose_behavior(
          yaml_path,
          behavior,
@@ -362,12 +411,13 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
          aggregate,
          category,
          language,
-         languages
+         languages,
+         cosine_opts \\ []
        ) do
     behavior_langs = Map.get(behavior_data, "_languages", [])
 
     if behavior_language_applies?(behavior_langs, language, languages) do
-      CosineVector.compute(yaml_path, behavior, behavior_data, aggregate, category)
+      CosineVector.compute(yaml_path, behavior, behavior_data, aggregate, category, cosine_opts)
     else
       []
     end

From 70302cf2b29be7891ae384034ec9ccac259975d5 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sun, 22 Mar 2026 16:48:27 +0100
Subject: [PATCH 51/71] refactor(health-report): pre-compute cosines outside
 Grader

Grader.grade_cosine_categories/3 now accepts a pre-grouped
cosines_by_category map instead of calling diagnose_aggregate internally.
HealthReport.generate/2 computes and groups the cosines once, eliminating
a duplicate diagnose_aggregate call that existed for top_issues downstream.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/health_report.ex            | 19 ++++++++------
 lib/codeqa/health_report/grader.ex     | 24 ++++++++----------
 lib/codeqa/health_report/top_blocks.ex | 35 +++++++++++++-------------
 3 files changed, 41 insertions(+), 37 deletions(-)

diff --git a/lib/codeqa/health_report.ex b/lib/codeqa/health_report.ex
index a634a02..e70525b 100644
--- a/lib/codeqa/health_report.ex
+++ b/lib/codeqa/health_report.ex
@@ -36,8 +36,13 @@ defmodule CodeQA.HealthReport do
 
     worst_files_map = FileScorer.worst_files_per_behavior(files, combined_top: combined_top)
 
+    all_cosines =
+      SampleRunner.diagnose_aggregate(aggregate, top: 99_999, languages: project_langs)
+
+    cosines_by_category = Enum.group_by(all_cosines, & &1.category)
+
     cosine_grades =
-      Grader.grade_cosine_categories(aggregate, worst_files_map, grade_scale, project_langs)
+      Grader.grade_cosine_categories(cosines_by_category, worst_files_map, grade_scale)
 
     all_categories =
       (threshold_grades ++ cosine_grades)
@@ -49,9 +54,6 @@ defmodule CodeQA.HealthReport do
 
     metadata = build_metadata(analysis_results)
 
-    all_cosines =
-      SampleRunner.diagnose_aggregate(aggregate, top: 99_999, languages: project_langs)
-
     top_issues = Enum.take(all_cosines, 10)
 
     codebase_cosine_lookup =
@@ -131,12 +133,15 @@ defmodule CodeQA.HealthReport do
     base_worst_files_map =
       FileScorer.worst_files_per_behavior(base_files, combined_top: combined_top)
 
+    base_cosines_by_category =
+      SampleRunner.diagnose_aggregate(base_aggregate, top: 99_999, languages: base_project_langs)
+      |> Enum.group_by(& &1.category)
+
     base_cosine_grades =
       Grader.grade_cosine_categories(
-        base_aggregate,
+        base_cosines_by_category,
         base_worst_files_map,
-        grade_scale,
-        base_project_langs
+        grade_scale
       )
 
     base_all_categories =
diff --git a/lib/codeqa/health_report/grader.ex b/lib/codeqa/health_report/grader.ex
index 46ed374..d671a0b 100644
--- a/lib/codeqa/health_report/grader.ex
+++ b/lib/codeqa/health_report/grader.ex
@@ -1,7 +1,6 @@
 defmodule CodeQA.HealthReport.Grader do
   @moduledoc "Scores metrics and assigns letter grades."
 
-  alias CodeQA.CombinedMetrics.SampleRunner
   alias CodeQA.Config
   alias CodeQA.HealthReport.Categories
 
@@ -228,29 +227,28 @@ defmodule CodeQA.HealthReport.Grader do
   @doc """
   Grade codebase aggregate metrics using cosine similarity.
 
-  Calls `SampleRunner.diagnose_aggregate/2` to get all behaviors with cosine
-  values, groups them by category, and returns a graded category list suitable
-  for use with `overall_score/3`.
+  Accepts `cosines_by_category`, a map of category string keys to lists of
+  behavior cosine entries as returned by
+  `Enum.group_by(SampleRunner.diagnose_aggregate(...), & &1.category)`.
+
+  The caller is responsible for computing `cosines_by_category` so that
+  `diagnose_aggregate/2` is invoked only once across the report pipeline.
 
   Categories with zero behaviors are skipped.
   """
   @spec grade_cosine_categories(
-          aggregate :: map(),
+          cosines_by_category :: %{String.t() => [map()]},
           worst_files :: %{String.t() => [map()]},
-          grade_scale :: [{number(), String.t()}],
-          languages :: [String.t()]
+          grade_scale :: [{number(), String.t()}]
         ) :: [map()]
   def grade_cosine_categories(
-        aggregate,
+        cosines_by_category,
         worst_files,
-        scale \\ Categories.default_grade_scale(),
-        languages \\ []
+        scale \\ Categories.default_grade_scale()
       ) do
     threshold = Config.cosine_significance_threshold()
 
-    aggregate
-    |> SampleRunner.diagnose_aggregate(top: 99_999, languages: languages)
-    |> Enum.group_by(& &1.category)
+    cosines_by_category
     |> Enum.map(fn {category, behaviors} ->
       behavior_entries =
         score_behavior_entries(behaviors, threshold, worst_files, scale, category)
diff --git a/lib/codeqa/health_report/top_blocks.ex b/lib/codeqa/health_report/top_blocks.ex
index 1761941..6b59bc3 100644
--- a/lib/codeqa/health_report/top_blocks.ex
+++ b/lib/codeqa/health_report/top_blocks.ex
@@ -9,6 +9,24 @@ defmodule CodeQA.HealthReport.TopBlocks do
   @severity_medium 0.10
   @gap_floor 0.01
 
+  defp build_fix_hint_lookup do
+    Scorer.all_yamls()
+    |> Enum.flat_map(fn {yaml_path, data} ->
+      category = yaml_path |> Path.basename() |> String.trim_trailing(".yml")
+      Enum.flat_map(data, &hints_for_behavior(category, &1))
+    end)
+    |> Map.new()
+  end
+
+  defp hints_for_behavior(category, {behavior, behavior_data}) when is_map(behavior_data) do
+    case Map.get(behavior_data, "_fix_hint") do
+      nil -> []
+      hint -> [{{category, behavior}, hint}]
+    end
+  end
+
+  defp hints_for_behavior(_category, _entry), do: []
+
   @spec build(map(), [struct()], map()) :: [map()]
   def build(analysis_results, changed_files, codebase_cosine_lookup) do
     files = Map.get(analysis_results, "files", %{})
@@ -96,21 +114,4 @@ defmodule CodeQA.HealthReport.TopBlocks do
   defp max_delta(%{potentials: potentials}),
     do: Enum.max_by(potentials, & &1.cosine_delta).cosine_delta
 
-  defp build_fix_hint_lookup do
-    Scorer.all_yamls()
-    |> Enum.flat_map(fn {yaml_path, data} ->
-      category = yaml_path |> Path.basename() |> String.trim_trailing(".yml")
-      Enum.flat_map(data, &hints_for_behavior(category, &1))
-    end)
-    |> Map.new()
-  end
-
-  defp hints_for_behavior(category, {behavior, behavior_data}) when is_map(behavior_data) do
-    case Map.get(behavior_data, "_fix_hint") do
-      nil -> []
-      hint -> [{{category, behavior}, hint}]
-    end
-  end
-
-  defp hints_for_behavior(_category, _entry), do: []
 end

From 71c8f0ae4dcda932447bb4d2924310c1cfbf2724 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sun, 22 Mar 2026 16:48:36 +0100
Subject: [PATCH 52/71] refactor(engine): integrate block impact computation
 into the analyzer pipeline

Block impact analysis is now triggered via compute_nodes: true in
analyze_codebase/2 instead of requiring callers to invoke
BlockImpactAnalyzer.analyze/3 as a separate step. The CLI commands are
simplified accordingly.

Supporting changes:
- FileMetricsServer removed from RunSupervisor (unused since the LOO path
  now uses analyze_file_for_loo/2 which bypasses the run context)
- Analyzer.with_run_context/2 now exposes behavior_config_pid so the block
  impact path can reuse the shared BehaviorConfigServer
- Pipeline.build_file_context/2 accepts skip_structural: true for LOO paths
  that do not need block detection
- Collector defaults now ignore *.md and *.mdx files
- CLI health-report exposes --telemetry flag to print block impact timings

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 lib/codeqa/analysis/file_context_server.ex |   2 +-
 lib/codeqa/analysis/run_context.ex         |   5 +-
 lib/codeqa/analysis/run_supervisor.ex      |  10 +-
 lib/codeqa/cli/analyze.ex                  |   4 -
 lib/codeqa/cli/health_report.ex            | 120 ++++++++++++++++++++-
 lib/codeqa/engine/analyzer.ex              |  39 +++++--
 lib/codeqa/engine/collector.ex             |   4 +-
 lib/codeqa/engine/pipeline.ex              |   5 +
 8 files changed, 163 insertions(+), 26 deletions(-)

diff --git a/lib/codeqa/analysis/file_context_server.ex b/lib/codeqa/analysis/file_context_server.ex
index 3de7859..987595f 100644
--- a/lib/codeqa/analysis/file_context_server.ex
+++ b/lib/codeqa/analysis/file_context_server.ex
@@ -35,7 +35,7 @@ defmodule CodeQA.Analysis.FileContextServer do
   Returns a cached (or freshly built) `FileContext` for `content`.
 
   The language is resolved from `opts` (`:language` or `:path`); defaults to
-  `Unknown`, consistent with how `FileImpact` calls `build_file_context/2`.
+  `Unknown`.
   """
   @spec get(pid(), String.t(), keyword()) :: FileContext.t()
   def get(pid, content, opts \\ []) do
diff --git a/lib/codeqa/analysis/run_context.ex b/lib/codeqa/analysis/run_context.ex
index e9e4aae..e0e9d52 100644
--- a/lib/codeqa/analysis/run_context.ex
+++ b/lib/codeqa/analysis/run_context.ex
@@ -6,11 +6,10 @@ defmodule CodeQA.Analysis.RunContext do
   cached state without named process registration.
   """
 
-  defstruct [:behavior_config_pid, :file_context_pid, :file_metrics_pid]
+  defstruct [:behavior_config_pid, :file_context_pid]
 
   @type t :: %__MODULE__{
           behavior_config_pid: pid(),
-          file_context_pid: pid(),
-          file_metrics_pid: pid()
+          file_context_pid: pid()
         }
 end
diff --git a/lib/codeqa/analysis/run_supervisor.ex b/lib/codeqa/analysis/run_supervisor.ex
index 687e58c..ab6bb10 100644
--- a/lib/codeqa/analysis/run_supervisor.ex
+++ b/lib/codeqa/analysis/run_supervisor.ex
@@ -2,7 +2,7 @@ defmodule CodeQA.Analysis.RunSupervisor do
   @moduledoc """
   One-shot supervisor for the per-analysis-run GenServers.
 
-  Started at the top of `BlockImpactAnalyzer.analyze/3` and stopped (via
+  Started at the top of `Analyzer.with_run_context/2` and stopped (via
   `Supervisor.stop/1`) in an `after` block when the run completes.
 
   Servers are not registered by name, preventing collisions when multiple
@@ -11,7 +11,7 @@ defmodule CodeQA.Analysis.RunSupervisor do
 
   use Supervisor
 
-  alias CodeQA.Analysis.{BehaviorConfigServer, FileContextServer, FileMetricsServer, RunContext}
+  alias CodeQA.Analysis.{BehaviorConfigServer, FileContextServer, RunContext}
 
   @spec start_link(keyword()) :: Supervisor.on_start()
   def start_link(opts \\ []) do
@@ -29,8 +29,7 @@ defmodule CodeQA.Analysis.RunSupervisor do
 
     %RunContext{
       behavior_config_pid: find_pid(children, BehaviorConfigServer),
-      file_context_pid: find_pid(children, FileContextServer),
-      file_metrics_pid: find_pid(children, FileMetricsServer)
+      file_context_pid: find_pid(children, FileContextServer)
     }
   end
 
@@ -38,8 +37,7 @@ defmodule CodeQA.Analysis.RunSupervisor do
   def init(_opts) do
     children = [
       {BehaviorConfigServer, []},
-      {FileContextServer, []},
-      {FileMetricsServer, []}
+      {FileContextServer, []}
     ]
 
     Supervisor.init(children, strategy: :one_for_one)
diff --git a/lib/codeqa/cli/analyze.ex b/lib/codeqa/cli/analyze.ex
index 475e15c..9c1f840 100644
--- a/lib/codeqa/cli/analyze.ex
+++ b/lib/codeqa/cli/analyze.ex
@@ -3,7 +3,6 @@ defmodule CodeQA.CLI.Analyze do
 
   @behaviour CodeQA.CLI.Command
 
-  alias CodeQA.BlockImpactAnalyzer
   alias CodeQA.CLI.Options
   alias CodeQA.Config
   alias CodeQA.Engine.Analyzer
@@ -65,9 +64,6 @@ defmodule CodeQA.CLI.Analyze do
 
     IO.puts(:stderr, "Analysis completed in #{end_time - start_time}ms")
 
-    nodes_top = opts[:nodes_top] || 3
-    results = BlockImpactAnalyzer.analyze(results, files, nodes_top: nodes_top)
-
     total_bytes = results["files"] |> Map.values() |> Enum.map(& &1["bytes"]) |> Enum.sum()
     results = filter_files_for_output(results, opts, "json")
 
diff --git a/lib/codeqa/cli/health_report.ex b/lib/codeqa/cli/health_report.ex
index 66b769d..0e6cceb 100644
--- a/lib/codeqa/cli/health_report.ex
+++ b/lib/codeqa/cli/health_report.ex
@@ -3,7 +3,6 @@ defmodule CodeQA.CLI.HealthReport do
 
   @behaviour CodeQA.CLI.Command
 
-  alias CodeQA.BlockImpactAnalyzer
   alias CodeQA.CLI.Options
   alias CodeQA.Config
   alias CodeQA.Engine.Analyzer
@@ -48,7 +47,8 @@ defmodule CodeQA.CLI.HealthReport do
     format: :string,
     ignore_paths: :string,
     base_ref: :string,
-    head_ref: :string
+    head_ref: :string,
+    telemetry: :boolean
   ]
 
   def run(args) do
@@ -69,8 +69,10 @@ defmodule CodeQA.CLI.HealthReport do
 
     IO.puts(:stderr, "Analyzing #{map_size(files)} files for health report...")
 
+    telemetry_pid = if opts[:telemetry], do: attach_block_impact_telemetry()
+
     analyze_opts =
-      Options.build_analyze_opts(opts) ++ Config.near_duplicate_blocks_opts()
+      Options.build_analyze_opts(opts) ++ Config.near_duplicate_blocks_opts() ++ [compute_nodes: true]
 
     start_time = System.monotonic_time(:millisecond)
     results = Analyzer.analyze_codebase(files, analyze_opts)
@@ -78,8 +80,7 @@ defmodule CodeQA.CLI.HealthReport do
 
     IO.puts(:stderr, "Analysis completed in #{end_time - start_time}ms")
 
-    nodes_top = opts[:nodes_top] || 3
-    results = BlockImpactAnalyzer.analyze(results, files, nodes_top: nodes_top)
+    if telemetry_pid, do: print_block_impact_telemetry(telemetry_pid)
 
     total_bytes = results["files"] |> Map.values() |> Enum.map(& &1["bytes"]) |> Enum.sum()
 
@@ -149,4 +150,113 @@ defmodule CodeQA.CLI.HealthReport do
     IO.puts(:stderr, "Warning: unknown format '#{other}', using 'plain'")
     :plain
   end
+
+  # ---------------------------------------------------------------------------
+  # Block impact telemetry
+  # ---------------------------------------------------------------------------
+
+  defp attach_block_impact_telemetry do
+    {:ok, pid} = Agent.start_link(fn -> %{nodes: [], files: [], codebase_cosines_us: 0} end)
+
+    :telemetry.attach_many(
+      "block-impact-reporter",
+      [
+        [:codeqa, :block_impact, :codebase_cosines],
+        [:codeqa, :block_impact, :file],
+        [:codeqa, :block_impact, :node]
+      ],
+      fn event, measurements, metadata, ^pid ->
+        case event do
+          [:codeqa, :block_impact, :codebase_cosines] ->
+            Agent.update(pid, &Map.put(&1, :codebase_cosines_us, measurements.duration))
+
+          [:codeqa, :block_impact, :file] ->
+            Agent.update(pid, fn state ->
+              Map.update!(state, :files, &[{metadata.path, measurements} | &1])
+            end)
+
+          [:codeqa, :block_impact, :node] ->
+            Agent.update(pid, fn state ->
+              Map.update!(state, :nodes, &[{metadata.path, measurements} | &1])
+            end)
+        end
+      end,
+      pid
+    )
+
+    pid
+  end
+
+  defp print_block_impact_telemetry(pid) do
+    state = Agent.get(pid, & &1)
+    Agent.stop(pid)
+    :telemetry.detach("block-impact-reporter")
+
+    nodes = state.nodes
+    files = state.files
+
+    total_nodes = length(nodes)
+    total_files = length(files)
+
+    node_totals = Enum.map(nodes, fn {_, m} -> m end)
+    file_totals = Enum.map(files, fn {_, m} -> m end)
+
+    IO.puts(:stderr, """
+
+    ── Block Impact Telemetry ──────────────────────────────
+    Codebase cosines:     #{us(state.codebase_cosines_us)}
+    Files processed:      #{total_files}
+    Nodes processed:      #{total_nodes}
+
+    Per-file breakdown (avg across #{total_files} files):
+      tokenize:           #{avg_us(file_totals, :tokenize_us)}
+      parse blocks:       #{avg_us(file_totals, :parse_us)}
+      file cosines:       #{avg_us(file_totals, :file_cosines_us)}
+      total/file:         #{avg_us(file_totals, :duration)}
+
+    Per-node breakdown (avg across #{total_nodes} nodes):
+      reconstruct:        #{avg_us(node_totals, :reconstruct_us)}
+      analyze_file:       #{avg_us(node_totals, :analyze_file_us)}
+      aggregate:          #{avg_us(node_totals, :aggregate_us)}
+      refactoring cosine: #{avg_us(node_totals, :refactoring_us)}
+      total/node:         #{avg_us(node_totals, :duration)}
+
+    Top 5 slowest files (total node time):
+    #{top_slow_files(files, nodes)}
+    ────────────────────────────────────────────────────────
+    """)
+  end
+
+  defp top_slow_files(files, nodes) do
+    node_time_by_file =
+      nodes
+      |> Enum.group_by(fn {path, _} -> path end, fn {_, m} -> m.duration end)
+      |> Map.new(fn {path, durations} -> {path, Enum.sum(durations)} end)
+
+    files
+    |> Enum.map(fn {path, fm} ->
+      node_time = Map.get(node_time_by_file, path, 0)
+      {path, fm.node_count, node_time}
+    end)
+    |> Enum.sort_by(fn {_, _, t} -> -t end)
+    |> Enum.take(5)
+    |> Enum.map_join("\n", fn {path, node_count, node_time} ->
+      "  #{path}  (#{node_count} nodes, #{us(node_time)} node time)"
+    end)
+  end
+
+  defp avg_us([], _key), do: "n/a"
+
+  defp avg_us(measurements, key) do
+    total = Enum.sum(Enum.map(measurements, &Map.get(&1, key, 0)))
+    us(div(total, length(measurements)))
+  end
+
+  defp us(microseconds) when microseconds >= 1_000_000,
+    do: "#{Float.round(microseconds / 1_000_000, 2)}s"
+
+  defp us(microseconds) when microseconds >= 1_000,
+    do: "#{Float.round(microseconds / 1_000, 1)}ms"
+
+  defp us(microseconds), do: "#{microseconds}µs"
 end
diff --git a/lib/codeqa/engine/analyzer.ex b/lib/codeqa/engine/analyzer.ex
index 6fe8cf0..bd55e11 100644
--- a/lib/codeqa/engine/analyzer.ex
+++ b/lib/codeqa/engine/analyzer.ex
@@ -2,6 +2,7 @@ defmodule CodeQA.Engine.Analyzer do
   @moduledoc "Orchestrates metric computation across files."
 
   alias CodeQA.Analysis.RunSupervisor
+  alias CodeQA.BlockImpactAnalyzer
   alias CodeQA.Engine.Parallel
   alias CodeQA.Engine.Pipeline
   alias CodeQA.Engine.Registry
@@ -41,6 +42,12 @@ defmodule CodeQA.Engine.Analyzer do
     Registry.run_file_metrics(@registry, ctx, [])
   end
 
+  @spec analyze_file_for_loo(String.t(), String.t()) :: map()
+  def analyze_file_for_loo(_path, content) do
+    ctx = Pipeline.build_file_context(content, skip_structural: true)
+    Registry.run_file_metrics(@registry, ctx, [])
+  end
+
   @spec analyze_codebase_aggregate(map(), keyword()) :: map()
   def analyze_codebase_aggregate(files_map, opts \\ []) do
     with_run_context(opts, fn opts ->
@@ -57,6 +64,7 @@ defmodule CodeQA.Engine.Analyzer do
     {:ok, sup} = RunSupervisor.start_link()
     run_ctx = RunSupervisor.run_context(sup)
     opts = Keyword.put(opts, :file_context_pid, run_ctx.file_context_pid)
+    opts = Keyword.put(opts, :behavior_config_pid, run_ctx.behavior_config_pid)
 
     try do
       fun.(opts)
@@ -67,15 +75,34 @@ defmodule CodeQA.Engine.Analyzer do
 
   defp do_analyze_codebase(files, opts) do
     registry = @registry
-
     file_results = Parallel.analyze_files(files, opts)
-    codebase_metrics = Registry.run_codebase_metrics(registry, files, opts)
     aggregate = aggregate_file_metrics(file_results)
 
-    %{
-      "files" => file_results,
-      "codebase" => Map.put(codebase_metrics, "aggregate", aggregate)
-    }
+    if Keyword.get(opts, :compute_nodes, false) do
+      nodes_opts =
+        [baseline_codebase_agg: aggregate] ++
+          Keyword.take(opts, [:nodes_top, :workers, :behavior_config_pid])
+
+      pipeline_result = %{
+        "files" => file_results,
+        "codebase" => %{"aggregate" => aggregate}
+      }
+
+      updated_pipeline_result = BlockImpactAnalyzer.analyze(pipeline_result, files, nodes_opts)
+      codebase_metrics = Registry.run_codebase_metrics(registry, files, opts)
+
+      updated_codebase =
+        Map.merge(codebase_metrics, updated_pipeline_result["codebase"])
+
+      Map.put(updated_pipeline_result, "codebase", updated_codebase)
+    else
+      codebase_metrics = Registry.run_codebase_metrics(registry, files, opts)
+
+      %{
+        "files" => file_results,
+        "codebase" => Map.put(codebase_metrics, "aggregate", aggregate)
+      }
+    end
   end
 
   defp metric_data_to_triples({metric_name, metric_data}) do
diff --git a/lib/codeqa/engine/collector.ex b/lib/codeqa/engine/collector.ex
index ea6b16f..1315c77 100644
--- a/lib/codeqa/engine/collector.ex
+++ b/lib/codeqa/engine/collector.ex
@@ -7,6 +7,8 @@ defmodule CodeQA.Engine.Collector do
     .next coverage
   ])
 
+  @default_ignore_patterns ~w[**/*.md **/*.mdx]
+
   @spec source_extensions() :: MapSet.t()
   def source_extensions do
     CodeQA.Language.all()
@@ -57,7 +59,7 @@ defmodule CodeQA.Engine.Collector do
     Enum.reject(list, fn item -> ignored?(key_fn.(item), patterns) end)
   end
 
-  defp all_ignore_patterns(extra), do: extra ++ CodeQA.Config.ignore_paths()
+  defp all_ignore_patterns(extra), do: extra ++ @default_ignore_patterns ++ CodeQA.Config.ignore_paths()
 
   defp do_reject_ignored_map(files_map, []), do: files_map
 
diff --git a/lib/codeqa/engine/pipeline.ex b/lib/codeqa/engine/pipeline.ex
index 33a9229..8a697a0 100644
--- a/lib/codeqa/engine/pipeline.ex
+++ b/lib/codeqa/engine/pipeline.ex
@@ -34,11 +34,16 @@ defmodule CodeQA.Engine.Pipeline do
     lines = content |> String.split("\n") |> trim_trailing_empty()
     encoded = content
 
+    skip_structural = Keyword.get(opts, :skip_structural, false)
+
     {path, blocks} =
       case Keyword.get(opts, :path) do
         nil ->
           {nil, nil}
 
+        p when skip_structural ->
+          {p, nil}
+
         p ->
           lang_mod = Language.detect(p)
           structural_tokens = TokenNormalizer.normalize_structural(content)

From 3abbc0aed5f48175ee4bd1edda426224ad6edf2a Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sun, 22 Mar 2026 16:48:42 +0100
Subject: [PATCH 53/71] test: update tests for refactored grader and
 near-duplicate-blocks interfaces

- GraderTest: setup_all now computes cosines_by_category once and passes it
  into all grade_cosine_categories/3 tests, matching the new signature
- SampleRunnerTest: update describe block to reflect the 3-arity signature
- NearDuplicateBlocksFileTest: add test for nil blocks (LOO skip_structural path)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../combined_metrics/sample_runner_test.exs   |  6 +-
 test/codeqa/health_report/grader_test.exs     | 63 ++++++++++---------
 .../file/near_duplicate_blocks_file_test.exs  | 11 ++++
 3 files changed, 49 insertions(+), 31 deletions(-)

diff --git a/test/codeqa/combined_metrics/sample_runner_test.exs b/test/codeqa/combined_metrics/sample_runner_test.exs
index c1986aa..692c306 100644
--- a/test/codeqa/combined_metrics/sample_runner_test.exs
+++ b/test/codeqa/combined_metrics/sample_runner_test.exs
@@ -115,9 +115,9 @@ defmodule CodeQA.CombinedMetrics.SampleRunnerTest do
     end
   end
 
-  describe "grade_cosine_categories/4 languages wiring" do
-    test "accepts languages argument" do
-      result = Grader.grade_cosine_categories(%{}, %{}, [], ["elixir"])
+  describe "grade_cosine_categories/3" do
+    test "returns a list for empty input" do
+      result = Grader.grade_cosine_categories(%{}, %{})
       assert is_list(result)
     end
   end
diff --git a/test/codeqa/health_report/grader_test.exs b/test/codeqa/health_report/grader_test.exs
index b8c5c14..6f9ea54 100644
--- a/test/codeqa/health_report/grader_test.exs
+++ b/test/codeqa/health_report/grader_test.exs
@@ -1,6 +1,7 @@
 defmodule CodeQA.HealthReport.GraderTest do
   use ExUnit.Case, async: true
 
+  alias CodeQA.CombinedMetrics.SampleRunner
   alias CodeQA.Engine.Analyzer
   alias CodeQA.Engine.Collector
   alias CodeQA.HealthReport.Grader
@@ -157,12 +158,14 @@ defmodule CodeQA.HealthReport.GraderTest do
     end
   end
 
-  # Shared aggregate for grade_cosine_categories/3 tests — computed once for the module.
+  # Shared cosines_by_category for grade_cosine_categories/3 tests — computed once for the module.
   setup_all do
     files = Collector.collect_files("lib", [])
     result = Analyzer.analyze_codebase(files)
     aggregate = get_in(result, ["codebase", "aggregate"])
-    {:ok, aggregate: aggregate}
+    all_cosines = SampleRunner.diagnose_aggregate(aggregate, top: 99_999)
+    cosines_by_category = Enum.group_by(all_cosines, & &1.category)
+    {:ok, cosines_by_category: cosines_by_category}
   end
 
   # -----------------------------------------------------------------------
@@ -170,13 +173,13 @@ defmodule CodeQA.HealthReport.GraderTest do
   # -----------------------------------------------------------------------
 
   describe "grade_cosine_categories/3" do
-    test "returns a list", %{aggregate: aggregate} do
-      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+    test "returns a list", %{cosines_by_category: cosines_by_category} do
+      result = Grader.grade_cosine_categories(cosines_by_category, %{}, @default_scale)
       assert is_list(result)
     end
 
-    test "each entry has required top-level keys", %{aggregate: aggregate} do
-      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+    test "each entry has required top-level keys", %{cosines_by_category: cosines_by_category} do
+      result = Grader.grade_cosine_categories(cosines_by_category, %{}, @default_scale)
 
       for cat <- result do
         assert Map.has_key?(cat, :type), "missing :type in #{inspect(cat)}"
@@ -188,13 +191,13 @@ defmodule CodeQA.HealthReport.GraderTest do
       end
     end
 
-    test "type is :cosine for every entry", %{aggregate: aggregate} do
-      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+    test "type is :cosine for every entry", %{cosines_by_category: cosines_by_category} do
+      result = Grader.grade_cosine_categories(cosines_by_category, %{}, @default_scale)
       for cat <- result, do: assert(cat.type == :cosine)
     end
 
-    test "scores are integers in [0, 100]", %{aggregate: aggregate} do
-      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+    test "scores are integers in [0, 100]", %{cosines_by_category: cosines_by_category} do
+      result = Grader.grade_cosine_categories(cosines_by_category, %{}, @default_scale)
 
       for cat <- result do
         assert is_integer(cat.score), "score not integer in #{cat.key}"
@@ -202,20 +205,20 @@ defmodule CodeQA.HealthReport.GraderTest do
       end
     end
 
-    test "grade is a string", %{aggregate: aggregate} do
-      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+    test "grade is a string", %{cosines_by_category: cosines_by_category} do
+      result = Grader.grade_cosine_categories(cosines_by_category, %{}, @default_scale)
       for cat <- result, do: assert(is_binary(cat.grade))
     end
 
     test "impact key is absent (HealthReport.generate/2 is responsible for embedding impact)", %{
-      aggregate: aggregate
+      cosines_by_category: cosines_by_category
     } do
-      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+      result = Grader.grade_cosine_categories(cosines_by_category, %{}, @default_scale)
       for cat <- result, do: refute(Map.has_key?(cat, :impact))
     end
 
-    test "name is humanized from key", %{aggregate: aggregate} do
-      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+    test "name is humanized from key", %{cosines_by_category: cosines_by_category} do
+      result = Grader.grade_cosine_categories(cosines_by_category, %{}, @default_scale)
 
       for cat <- result do
         # name must be a non-empty string, words capitalized
@@ -226,8 +229,8 @@ defmodule CodeQA.HealthReport.GraderTest do
       end
     end
 
-    test "each behavior entry has required keys", %{aggregate: aggregate} do
-      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+    test "each behavior entry has required keys", %{cosines_by_category: cosines_by_category} do
+      result = Grader.grade_cosine_categories(cosines_by_category, %{}, @default_scale)
 
       for cat <- result, b <- cat.behaviors do
         assert Map.has_key?(b, :behavior)
@@ -238,8 +241,8 @@ defmodule CodeQA.HealthReport.GraderTest do
       end
     end
 
-    test "behavior scores are integers in [0, 100]", %{aggregate: aggregate} do
-      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+    test "behavior scores are integers in [0, 100]", %{cosines_by_category: cosines_by_category} do
+      result = Grader.grade_cosine_categories(cosines_by_category, %{}, @default_scale)
 
       for cat <- result, b <- cat.behaviors do
         assert is_integer(b.score)
@@ -247,22 +250,24 @@ defmodule CodeQA.HealthReport.GraderTest do
       end
     end
 
-    test "worst_offenders uses worst_files lookup", %{aggregate: aggregate} do
+    test "worst_offenders uses worst_files lookup", %{cosines_by_category: cosines_by_category} do
       sentinel = [%{file: "lib/sentinel.ex", cosine: -0.99}]
       # Get one real behavior key to inject into worst_files
-      [first_cat | _] = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+      [first_cat | _] = Grader.grade_cosine_categories(cosines_by_category, %{}, @default_scale)
       first_behavior = hd(first_cat.behaviors)
       lookup_key = "#{first_cat.key}.#{first_behavior.behavior}"
 
       worst_files = %{lookup_key => sentinel}
-      result = Grader.grade_cosine_categories(aggregate, worst_files, @default_scale)
+      result = Grader.grade_cosine_categories(cosines_by_category, worst_files, @default_scale)
 
       found_cat = Enum.find(result, &(&1.key == first_cat.key))
       found_behavior = Enum.find(found_cat.behaviors, &(&1.behavior == first_behavior.behavior))
       assert found_behavior.worst_offenders == sentinel
     end
 
-    test "top_metrics and top_nodes pass through unmodified", %{aggregate: aggregate} do
+    test "top_metrics and top_nodes pass through unmodified", %{
+      cosines_by_category: cosines_by_category
+    } do
       sentinel = [
         %{
           file: "lib/sentinel.ex",
@@ -272,20 +277,22 @@ defmodule CodeQA.HealthReport.GraderTest do
         }
       ]
 
-      [first_cat | _] = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+      [first_cat | _] = Grader.grade_cosine_categories(cosines_by_category, %{}, @default_scale)
       first_behavior = hd(first_cat.behaviors)
       lookup_key = "#{first_cat.key}.#{first_behavior.behavior}"
 
       worst_files = %{lookup_key => sentinel}
-      result = Grader.grade_cosine_categories(aggregate, worst_files, @default_scale)
+      result = Grader.grade_cosine_categories(cosines_by_category, worst_files, @default_scale)
 
       found_cat = Enum.find(result, &(&1.key == first_cat.key))
       found_behavior = Enum.find(found_cat.behaviors, &(&1.behavior == first_behavior.behavior))
       assert found_behavior.worst_offenders == sentinel
     end
 
-    test "worst_offenders defaults to [] when key absent", %{aggregate: aggregate} do
-      result = Grader.grade_cosine_categories(aggregate, %{}, @default_scale)
+    test "worst_offenders defaults to [] when key absent", %{
+      cosines_by_category: cosines_by_category
+    } do
+      result = Grader.grade_cosine_categories(cosines_by_category, %{}, @default_scale)
       for cat <- result, b <- cat.behaviors, do: assert(b.worst_offenders == [])
     end
   end
diff --git a/test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs b/test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs
index c59f707..8b7b6ab 100644
--- a/test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs
+++ b/test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs
@@ -25,6 +25,17 @@ defmodule CodeQA.Metrics.File.NearDuplicateBlocksFileTest do
     end
   end
 
+  describe "analyze/1 with nil blocks" do
+    test "returns zeroed map with all keys when blocks is nil" do
+      ctx = Pipeline.build_file_context("x = 1\n", skip_structural: true)
+      result = NearDuplicateBlocksFile.analyze(ctx)
+      assert Map.has_key?(result, "block_count")
+      assert Map.has_key?(result, "sub_block_count")
+      for d <- 0..8, do: assert(Map.has_key?(result, "near_dup_block_d#{d}"))
+      for {_key, value} <- result, do: assert(value == 0)
+    end
+  end
+
   describe "analyze/1" do
     test "returns a map with all expected keys" do
       result = NearDuplicateBlocksFile.analyze(ctx("x = 1\n"))

From 3b67dbbe1dcdbcbaf9f5a0e0452babf04080d919 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sun, 22 Mar 2026 17:00:18 +0100
Subject: [PATCH 54/71] refactor: fix dialyzer, credo nesting, and compiler
 warnings

- Remove dead do_reject_ignored_map(_, []) clause in Collector (patterns list always non-empty)
- Extract handle_block_impact_event/4 multi-clause fn in HealthReport to reduce nesting depth
- Extract diagnose_from_behavior_map_entry/5 and diagnose_from_yaml/5 in SampleRunner to reduce nesting depth
- Remove unused default arg \\ [] from private maybe_diagnose_behavior/8

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../block_impact/refactoring_potentials.ex    |  7 ++-
 lib/codeqa/block_impact_analyzer.ex           | 16 +++--
 lib/codeqa/cli/health_report.ex               | 36 +++++------
 lib/codeqa/combined_metrics/sample_runner.ex  | 60 ++++++++-----------
 lib/codeqa/engine/collector.ex                |  5 +-
 lib/codeqa/health_report/top_blocks.ex        |  1 -
 6 files changed, 62 insertions(+), 63 deletions(-)

diff --git a/lib/codeqa/block_impact/refactoring_potentials.ex b/lib/codeqa/block_impact/refactoring_potentials.ex
index f2417ef..0dc1738 100644
--- a/lib/codeqa/block_impact/refactoring_potentials.ex
+++ b/lib/codeqa/block_impact/refactoring_potentials.ex
@@ -48,7 +48,12 @@ defmodule CodeQA.BlockImpact.RefactoringPotentials do
       compute_file_delta(baseline_file_cosines, without_file_metrics, language, behavior_map)
 
     codebase_delta =
-      compute_codebase_delta(baseline_codebase_cosines, without_codebase_agg, languages, behavior_map)
+      compute_codebase_delta(
+        baseline_codebase_cosines,
+        without_codebase_agg,
+        languages,
+        behavior_map
+      )
 
     all_keys = Enum.uniq(Map.keys(file_delta) ++ Map.keys(codebase_delta))
 
diff --git a/lib/codeqa/block_impact_analyzer.ex b/lib/codeqa/block_impact_analyzer.ex
index c317617..aaebdf6 100644
--- a/lib/codeqa/block_impact_analyzer.ex
+++ b/lib/codeqa/block_impact_analyzer.ex
@@ -325,12 +325,14 @@ defmodule CodeQA.BlockImpactAnalyzer do
 
   defp file_metrics_to_triples(metrics) when is_map(metrics) do
     metrics
-    |> Enum.flat_map(fn {metric_name, metric_data} when is_map(metric_data) ->
-      metric_data
-      |> Enum.filter(fn {_k, v} -> is_number(v) end)
-      |> Enum.map(fn {key, value} -> {metric_name, key, value / 1} end)
+    |> Enum.flat_map(fn
+      {metric_name, metric_data} when is_map(metric_data) ->
+        metric_data
+        |> Enum.filter(fn {_k, v} -> is_number(v) end)
+        |> Enum.map(fn {key, value} -> {metric_name, key, value / 1} end)
 
-      _ -> []
+      _ ->
+        []
     end)
   end
 
@@ -345,7 +347,9 @@ defmodule CodeQA.BlockImpactAnalyzer do
       n = length(values)
       sum = Enum.sum(values)
       sum_sq = Enum.reduce(values, 0.0, fn v, acc -> acc + v * v end)
-      {{metric, key}, %{sum: sum, sum_sq: sum_sq, min: Enum.min(values), max: Enum.max(values), count: n}}
+
+      {{metric, key},
+       %{sum: sum, sum_sq: sum_sq, min: Enum.min(values), max: Enum.max(values), count: n}}
     end)
   end
 
diff --git a/lib/codeqa/cli/health_report.ex b/lib/codeqa/cli/health_report.ex
index 0e6cceb..6d20ab2 100644
--- a/lib/codeqa/cli/health_report.ex
+++ b/lib/codeqa/cli/health_report.ex
@@ -72,7 +72,8 @@ defmodule CodeQA.CLI.HealthReport do
     telemetry_pid = if opts[:telemetry], do: attach_block_impact_telemetry()
 
     analyze_opts =
-      Options.build_analyze_opts(opts) ++ Config.near_duplicate_blocks_opts() ++ [compute_nodes: true]
+      Options.build_analyze_opts(opts) ++
+        Config.near_duplicate_blocks_opts() ++ [compute_nodes: true]
 
     start_time = System.monotonic_time(:millisecond)
     results = Analyzer.analyze_codebase(files, analyze_opts)
@@ -165,28 +166,29 @@ defmodule CodeQA.CLI.HealthReport do
         [:codeqa, :block_impact, :file],
         [:codeqa, :block_impact, :node]
       ],
-      fn event, measurements, metadata, ^pid ->
-        case event do
-          [:codeqa, :block_impact, :codebase_cosines] ->
-            Agent.update(pid, &Map.put(&1, :codebase_cosines_us, measurements.duration))
-
-          [:codeqa, :block_impact, :file] ->
-            Agent.update(pid, fn state ->
-              Map.update!(state, :files, &[{metadata.path, measurements} | &1])
-            end)
-
-          [:codeqa, :block_impact, :node] ->
-            Agent.update(pid, fn state ->
-              Map.update!(state, :nodes, &[{metadata.path, measurements} | &1])
-            end)
-        end
-      end,
+      &handle_block_impact_event(&1, &2, &3, &4),
       pid
     )
 
     pid
   end
 
+  defp handle_block_impact_event([:codeqa, :block_impact, :codebase_cosines], measurements, _metadata, pid) do
+    Agent.update(pid, &Map.put(&1, :codebase_cosines_us, measurements.duration))
+  end
+
+  defp handle_block_impact_event([:codeqa, :block_impact, :file], measurements, metadata, pid) do
+    Agent.update(pid, fn state ->
+      Map.update!(state, :files, &[{metadata.path, measurements} | &1])
+    end)
+  end
+
+  defp handle_block_impact_event([:codeqa, :block_impact, :node], measurements, metadata, pid) do
+    Agent.update(pid, fn state ->
+      Map.update!(state, :nodes, &[{metadata.path, measurements} | &1])
+    end)
+  end
+
   defp print_block_impact_telemetry(pid) do
     state = Agent.get(pid, & &1)
     Agent.stop(pid)
diff --git a/lib/codeqa/combined_metrics/sample_runner.ex b/lib/codeqa/combined_metrics/sample_runner.ex
index 6c5b6c9..4bd397b 100644
--- a/lib/codeqa/combined_metrics/sample_runner.ex
+++ b/lib/codeqa/combined_metrics/sample_runner.ex
@@ -188,43 +188,15 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
       if behavior_map do
         behavior_map
         |> Enum.sort_by(fn {category, _} -> category end)
-        |> Enum.flat_map(fn {category, behaviors} ->
-          Enum.flat_map(behaviors, fn {behavior, behavior_data} ->
-            yaml_path = "priv/combined_metrics/#{category}.yml"
-
-            maybe_diagnose_behavior(
-              yaml_path,
-              behavior,
-              behavior_data,
-              aggregate,
-              category,
-              language,
-              languages,
-              cosine_opts
-            )
-          end)
-        end)
+        |> Enum.flat_map(
+          &diagnose_from_behavior_map_entry(&1, aggregate, language, languages, cosine_opts)
+        )
       else
         Scorer.all_yamls()
         |> Enum.sort_by(fn {path, _} -> path end)
-        |> Enum.flat_map(fn {yaml_path, data} ->
-          category = yaml_path |> Path.basename() |> String.trim_trailing(".yml")
-
-          data
-          |> Enum.filter(fn {_k, v} -> is_map(v) end)
-          |> Enum.flat_map(fn {behavior, behavior_data} ->
-            maybe_diagnose_behavior(
-              yaml_path,
-              behavior,
-              behavior_data,
-              aggregate,
-              category,
-              language,
-              languages,
-              cosine_opts
-            )
-          end)
-        end)
+        |> Enum.flat_map(
+          &diagnose_from_yaml(&1, aggregate, language, languages, cosine_opts)
+        )
       end
 
     behaviors_stream
@@ -404,6 +376,24 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
     end)
   end
 
+  defp diagnose_from_behavior_map_entry({category, behaviors}, aggregate, language, languages, cosine_opts) do
+    yaml_path = "priv/combined_metrics/#{category}.yml"
+
+    Enum.flat_map(behaviors, fn {behavior, behavior_data} ->
+      maybe_diagnose_behavior(yaml_path, behavior, behavior_data, aggregate, category, language, languages, cosine_opts)
+    end)
+  end
+
+  defp diagnose_from_yaml({yaml_path, data}, aggregate, language, languages, cosine_opts) do
+    category = yaml_path |> Path.basename() |> String.trim_trailing(".yml")
+
+    data
+    |> Enum.filter(fn {_k, v} -> is_map(v) end)
+    |> Enum.flat_map(fn {behavior, behavior_data} ->
+      maybe_diagnose_behavior(yaml_path, behavior, behavior_data, aggregate, category, language, languages, cosine_opts)
+    end)
+  end
+
   defp maybe_diagnose_behavior(
          yaml_path,
          behavior,
@@ -412,7 +402,7 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
          category,
          language,
          languages,
-         cosine_opts \\ []
+         cosine_opts
        ) do
     behavior_langs = Map.get(behavior_data, "_languages", [])
 
diff --git a/lib/codeqa/engine/collector.ex b/lib/codeqa/engine/collector.ex
index 1315c77..3d1b8b4 100644
--- a/lib/codeqa/engine/collector.ex
+++ b/lib/codeqa/engine/collector.ex
@@ -59,9 +59,8 @@ defmodule CodeQA.Engine.Collector do
     Enum.reject(list, fn item -> ignored?(key_fn.(item), patterns) end)
   end
 
-  defp all_ignore_patterns(extra), do: extra ++ @default_ignore_patterns ++ CodeQA.Config.ignore_paths()
-
-  defp do_reject_ignored_map(files_map, []), do: files_map
+  defp all_ignore_patterns(extra),
+    do: extra ++ @default_ignore_patterns ++ CodeQA.Config.ignore_paths()
 
   defp do_reject_ignored_map(files_map, patterns) do
     Map.reject(files_map, fn {path, _} -> ignored?(path, patterns) end)
diff --git a/lib/codeqa/health_report/top_blocks.ex b/lib/codeqa/health_report/top_blocks.ex
index 6b59bc3..42a0bfd 100644
--- a/lib/codeqa/health_report/top_blocks.ex
+++ b/lib/codeqa/health_report/top_blocks.ex
@@ -113,5 +113,4 @@ defmodule CodeQA.HealthReport.TopBlocks do
 
   defp max_delta(%{potentials: potentials}),
     do: Enum.max_by(potentials, & &1.cosine_delta).cosine_delta
-
 end

From 03cce19204d22e32af03dc0293498d7c8989276b Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sun, 22 Mar 2026 17:03:57 +0100
Subject: [PATCH 55/71] fix(test): pass path to build_file_context in
 NearDuplicateBlocksFileTest

After the pipeline refactor, build_file_context computes blocks only when a
path is provided. The test helper was building context without a path then
patching it in, so blocks were always nil and the analyze/1 nil-clause
short-circuited to zeros. Pass path: directly so blocks are populated.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs b/test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs
index 8b7b6ab..cb10540 100644
--- a/test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs
+++ b/test/codeqa/metrics/file/near_duplicate_blocks_file_test.exs
@@ -4,8 +4,7 @@ defmodule CodeQA.Metrics.File.NearDuplicateBlocksFileTest do
   alias CodeQA.Metrics.File.NearDuplicateBlocksFile
 
   defp ctx(code, path \\ "test.ex") do
-    base = Pipeline.build_file_context(code)
-    Map.put(base, :path, path)
+    Pipeline.build_file_context(code, path: path)
   end
 
   describe "name/0" do

From ddff5c1fb2ae2396deb88eabdf2618c3b37913ae Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Sun, 22 Mar 2026 16:08:32 +0000
Subject: [PATCH 56/71] chore(combined-metrics): sync language coverage and
 scalar vectors [skip ci]

---
 priv/combined_metrics/code_smells.yml     |  5 -----
 priv/combined_metrics/variable_naming.yml | 14 --------------
 2 files changed, 19 deletions(-)

diff --git a/priv/combined_metrics/code_smells.yml b/priv/combined_metrics/code_smells.yml
index 2201f7d..f1c73c5 100644
--- a/priv/combined_metrics/code_smells.yml
+++ b/priv/combined_metrics/code_smells.yml
@@ -1,6 +1,5 @@
 consistent_string_quote_style:
   _doc: "Files should use a single, consistent string quoting style throughout."
-  _languages: [elixir]
   _log_baseline: -18.2553
   branching:
     mean_branching_density: 0.0243
@@ -102,7 +101,6 @@ consistent_string_quote_style:
 
 no_dead_code_after_return:
   _doc: "There should be no unreachable statements after a return or early exit."
-  _languages: [elixir]
   _log_baseline: -55.8435
   branching:
     mean_branch_count: -2.0000
@@ -213,7 +211,6 @@ no_dead_code_after_return:
 
 no_debug_print_statements:
   _doc: "Debug output (`console.log`, `IO.inspect`, `fmt.Println`) must not be left in committed code."
-  _languages: [elixir]
   _log_baseline: -88.0844
   branching:
     mean_branch_count: -0.3540
@@ -324,7 +321,6 @@ no_debug_print_statements:
 
 no_fixme_comments:
   _doc: "FIXME, XXX, and HACK comments indicate known problems that should be resolved before merging."
-  _languages: [elixir]
   _log_baseline: -2.0233
   branching:
     mean_branch_count: 0.1755
@@ -439,7 +435,6 @@ no_fixme_comments:
 
 no_nested_ternary:
   _doc: "Nested conditional expressions (ternary-within-ternary) are harder to read than a plain if-else."
-  _languages: [elixir]
   _log_baseline: 7.6475
   branching:
     mean_branch_count: -0.5662
diff --git a/priv/combined_metrics/variable_naming.yml b/priv/combined_metrics/variable_naming.yml
index e7bc6fa..1be9c6b 100644
--- a/priv/combined_metrics/variable_naming.yml
+++ b/priv/combined_metrics/variable_naming.yml
@@ -1,6 +1,5 @@
 boolean_has_is_has_prefix:
   _doc: "Boolean variables should be prefixed with `is_`, `has_`, or `can_`."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 15.9481
   brevity:
     mean_sample_size: 0.0752
@@ -63,7 +62,6 @@ boolean_has_is_has_prefix:
 
 collection_name_is_plural:
   _doc: "Variables holding a collection should use a plural name."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 21.8380
   brevity:
     mean_sample_size: -0.5320
@@ -125,7 +123,6 @@ collection_name_is_plural:
 
 loop_var_is_single_letter:
   _doc: "Loop index variables (`i`, `j`, `k`) are acceptable inside loop bodies."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -28.3218
   brevity:
     mean_sample_size: -0.1049
@@ -205,7 +202,6 @@ loop_var_is_single_letter:
 
 name_contains_and:
   _doc: "Variable names containing `and` signal a variable that holds two concerns."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 0.4689
   branching:
     mean_branch_count: -0.3666
@@ -324,7 +320,6 @@ name_contains_and:
 
 name_contains_type_suffix:
   _doc: "Type suffixes in names (`userString`, `nameList`) are redundant noise."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -26.6817
   branching:
     mean_branch_count: -0.4150
@@ -410,7 +405,6 @@ name_contains_type_suffix:
 
 name_is_abbreviation:
   _doc: "Abbreviated names (`usr`, `cfg`, `mgr`) reduce readability."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 10.7370
   brevity:
     mean_sample_size: -0.1542
@@ -497,7 +491,6 @@ name_is_abbreviation:
 
 name_is_generic:
   _doc: "Generic names (`data`, `result`, `tmp`, `val`, `obj`) convey no domain meaning."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 37.4815
   branching:
     mean_branch_count: 0.5193
@@ -614,7 +607,6 @@ name_is_generic:
 
 name_is_number_like:
   _doc: "Number-suffixed names (`var1`, `thing2`) signal a missing abstraction."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 1.7611
   brevity:
     mean_sample_size: -0.0262
@@ -693,7 +685,6 @@ name_is_number_like:
 
 name_is_single_letter:
   _doc: "Single-letter names outside loop indices are too opaque."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 26.2113
   branching:
     mean_branching_density: -0.0458
@@ -791,7 +782,6 @@ name_is_single_letter:
 
 name_is_too_long:
   _doc: "Names longer than ~30 characters harm readability."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -7.8322
   branching:
     mean_branch_count: 0.0340
@@ -912,7 +902,6 @@ name_is_too_long:
 
 name_is_too_short:
   _doc: "Names shorter than 3 characters (outside loops) are too opaque."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -2.7224
   branching:
     mean_branch_count: -0.2327
@@ -1000,7 +989,6 @@ name_is_too_short:
 
 negated_boolean_name:
   _doc: "Negated boolean names (`isNotValid`, `notActive`) are harder to reason about."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -4.4565
   brevity:
     mean_sample_size: -0.0998
@@ -1071,7 +1059,6 @@ negated_boolean_name:
 
 no_hungarian_notation:
   _doc: "Hungarian notation prefixes (`strName`, `bFlag`) add noise without type safety."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -15.5962
   brevity:
     mean_sample_size: -0.0814
@@ -1147,7 +1134,6 @@ no_hungarian_notation:
 
 screaming_snake_for_constants:
   _doc: "Module-level constants should use SCREAMING_SNAKE_CASE."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -5.9884
   branching:
     mean_branching_density: 0.0176

From 4e2eeb0ce429265aaa4dddb9c799ab34d4d9e8de Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sun, 22 Mar 2026 17:33:52 +0100
Subject: [PATCH 57/71] docs: add multi-part PR comment design spec

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 ...026-03-22-multi-part-pr-comments-design.md | 108 ++++++++++++++++++
 1 file changed, 108 insertions(+)
 create mode 100644 docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md

diff --git a/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md b/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md
new file mode 100644
index 0000000..ef2deb5
--- /dev/null
+++ b/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md
@@ -0,0 +1,108 @@
+# Multi-Part PR Comments Design
+
+**Date:** 2026-03-22
+**Status:** Proposed
+
+## Context
+
+The `codeqa health-report` GitHub Action posts a markdown report as a sticky PR comment via `marocchino/sticky-pull-request-comment@v2`. GitHub's PR comment API has a hard 65,536 character limit. On large codebases (300+ files), the generated report exceeds this limit and the posting step fails.
+
+## Solution
+
+Split the report into fixed-section parts, each posted as a separate sticky PR comment. No content compression — splitting is purely a rendering concern.
+
+## Part Assignment
+
+Parts are fixed, not dynamically determined by content size (except Part 3+ which slices the blocks section).
+
+| Part | Sticky Header | Content |
+|------|--------------|---------|
+| 1 | `codeqa-health-report-1` | Header + overall grade + mermaid chart + progress bars + overall category table + PR summary + metric changes (delta) |
+| 2 | `codeqa-health-report-2` | Top likely issues + all category detail sections (threshold metrics + cosine behaviors) |
+| 3+ | `codeqa-health-report-3`, `codeqa-health-report-4`, … | Blocks section, sliced at 60,000 characters per part |
+
+Each non-final chunk of Part 3+ ends with:
+
+```
+> ⚠️ Truncated at 60,000 chars — continued in next comment
+```
+
+If there are no blocks, Part 3 is written as a single empty part (`""`).
+
+## Formatter Changes
+
+**File:** `lib/codeqa/health_report/formatter/github.ex`
+
+Add three new rendering entry points alongside the existing `render/3`:
+
+- `render_part_1(report, opts)` → `String.t()` — header, summary table, PR summary, delta, mermaid chart, progress bars
+- `render_part_2(report, opts)` → `String.t()` — top issues, all category detail sections
+- `render_parts_3(report, opts)` → `[String.t()]` — blocks section sliced into 60,000-char chunks; returns `[""]` when no blocks exist
+
+The existing `render/3` is not changed. It continues to produce the full single-string report for `--output file` usage.
+
+## CLI Changes
+
+**File:** `lib/codeqa/cli/health_report.ex`
+
+Add `render_parts(report, opts)` → `[String.t()]` — returns a flat list `[part_1, part_2, part_3a, part_3b, ...]`. Used internally when the `comment: true` path is active.
+
+When writing output for comment mode, the CLI writes each part to a numbered temp file:
+
+- `$TMPDIR/codeqa-part-1.md`
+- `$TMPDIR/codeqa-part-2.md`
+- `$TMPDIR/codeqa-part-3.md`
+- … etc.
+
+It also writes `$TMPDIR/codeqa-part-count.txt` containing the integer count of parts.
+
+The existing `--output` flag behaviour (write single file) is unchanged.
+
+## Stale Comment Handling
+
+If a previous run produced 4 parts and the current run produces 2, the old parts 3 and 4 remain stale. To handle this, always write a minimum of 3 part files. Parts beyond the actual content get a single-line placeholder:
+
+```
+> _No content for this section._
+```
+
+The sticky comment action overwrites the stale comment with the placeholder rather than leaving old content. The minimum of 3 is sufficient for the current fixed-section design. Real content is written for any blocks overflow to part 4+.
+
+## Action / run.sh Changes
+
+**File:** `scripts/run.sh`
+
+After generating part files, loop over them and post each using `gh pr comment` (or the GitHub API directly). Each part uses its own sticky header `codeqa-health-report-{N}`.
+
+`run.sh` takes ownership of the posting loop since it already has access to all required env vars. This avoids duplicating logic across multiple YAML steps.
+
+**File:** `.github/workflows/health-report.yml`
+
+The current single `marocchino/sticky-pull-request-comment@v2` step is replaced. The YAML posting step becomes a no-op for comment posting; run.sh handles it entirely. No YAML changes are needed as the number of parts varies — a shell loop in run.sh handles the variable count cleanly.
+
+## Key Constraints
+
+- `render/3` must not change behaviour — used by `--output` flag
+- Part 1 must always be self-contained — a reader seeing only Part 1 gets the full codebase health picture
+- Parts 2 and 3 are drill-down detail; safe to be empty if the codebase has no behaviors or blocks
+- 60,000 char slice limit (not 65,536) leaves headroom for sticky comment metadata
+
+## Breaking Change
+
+The sticky comment header for Part 1 changes from `codeqa-health-report` to `codeqa-health-report-1`. Old single-part comments will not be cleaned up automatically on the first run after upgrade.
+
+## Files Affected
+
+| File | Change |
+|------|--------|
+| `lib/codeqa/health_report/formatter/github.ex` | Add `render_part_1/2`, `render_part_2/2`, `render_parts_3/2` |
+| `lib/codeqa/cli/health_report.ex` | Add `render_parts/2`, multi-file output in comment mode |
+| `scripts/run.sh` | Loop to post multiple part files |
+| `.github/workflows/health-report.yml` | Simplified posting step |
+| `test/codeqa/health_report/formatter_test.exs` | Tests for new part renderers |
+
+## What Does Not Change
+
+- The `--detail`, `--top`, `--format`, `--output` CLI flags
+- The plain formatter (`Formatter.Plain`)
+- Report data assembly (`health_report.ex`, `grader.ex`, `top_blocks.ex`) — splitting is purely a rendering concern

From 9a220ddb318426de00c51fadc98d5ccb2601d85c Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sun, 22 Mar 2026 17:35:12 +0100
Subject: [PATCH 58/71] docs: address spec review issues in multi-part PR
 comments design

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 ...026-03-22-multi-part-pr-comments-design.md | 20 +++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md b/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md
index ef2deb5..52a6a79 100644
--- a/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md
+++ b/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md
@@ -45,7 +45,7 @@ The existing `render/3` is not changed. It continues to produce the full single-
 
 **File:** `lib/codeqa/cli/health_report.ex`
 
-Add `render_parts(report, opts)` → `[String.t()]` — returns a flat list `[part_1, part_2, part_3a, part_3b, ...]`. Used internally when the `comment: true` path is active.
+Add `render_parts(report, opts)` → `[String.t()]` — returns a flat list `[part_1, part_2, part_3a, part_3b, ...]`. Used internally when the `comment: true` path is active. `comment: true` is an **existing** flag (already parsed from `INPUT_COMMENT` env var in `run.sh` and passed as `--comment` to the CLI); no new flag is introduced.
 
 When writing output for comment mode, the CLI writes each part to a numbered temp file:
 
@@ -68,17 +68,29 @@ If a previous run produced 4 parts and the current run produces 2, the old parts
 
 The sticky comment action overwrites the stale comment with the placeholder rather than leaving old content. The minimum of 3 is sufficient for the current fixed-section design. Real content is written for any blocks overflow to part 4+.
 
+**Known limitation:** if run N produces more than 3 parts (e.g., 5) and run N+1 produces fewer (e.g., 3), parts 4 and 5 from run N remain stale permanently — the minimum-3 floor does not cover them. This is accepted as an edge case; the stale comments are cosmetic (they hold the placeholder text), and a future cleanup step can address it if needed.
+
 ## Action / run.sh Changes
 
 **File:** `scripts/run.sh`
 
-After generating part files, loop over them and post each using `gh pr comment` (or the GitHub API directly). Each part uses its own sticky header `codeqa-health-report-{N}`.
+After generating part files, loop over them and post each as a sticky PR comment. Use the GitHub REST API directly (`curl -s -X POST/PATCH`) with the following sticky update-or-create logic:
+
+1. Search existing PR comments for one whose body contains the sentinel `<!-- codeqa-health-report-{N} -->` (appended to each part by the formatter)
+2. If found: `PATCH /repos/{owner}/{repo}/issues/comments/{id}` with the new body
+3. If not found: `POST /repos/{owner}/{repo}/issues/{pr_number}/comments` with the new body
+
+Each part's markdown ends with the sentinel HTML comment so future runs can locate and update it:
+
+```
+<!-- codeqa-health-report-{N} -->
+```
 
-`run.sh` takes ownership of the posting loop since it already has access to all required env vars. This avoids duplicating logic across multiple YAML steps.
+This replicates the sticky semantics of `marocchino/sticky-pull-request-comment@v2` without depending on that action for a variable number of posts. `run.sh` uses `GITHUB_TOKEN` (already available in the action environment) and `GITHUB_API_URL`, `GITHUB_REPOSITORY`, and `PR_NUMBER` (sourced from the workflow env).
 
 **File:** `.github/workflows/health-report.yml`
 
-The current single `marocchino/sticky-pull-request-comment@v2` step is replaced. The YAML posting step becomes a no-op for comment posting; run.sh handles it entirely. No YAML changes are needed as the number of parts varies — a shell loop in run.sh handles the variable count cleanly.
+Remove the `marocchino/sticky-pull-request-comment@v2` step. `run.sh` now owns posting entirely. The workflow passes `PR_NUMBER: ${{ github.event.pull_request.number }}` as an env var to the run step.
 
 ## Key Constraints
 

From d2438f5b83aada34b9e1564fd66d069f2690aca8 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sun, 22 Mar 2026 17:36:03 +0100
Subject: [PATCH 59/71] docs: fix sentinel and part-count clarifications in
 multi-part spec

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../2026-03-22-multi-part-pr-comments-design.md      | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md b/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md
index 52a6a79..f67de67 100644
--- a/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md
+++ b/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md
@@ -39,7 +39,15 @@ Add three new rendering entry points alongside the existing `render/3`:
 - `render_part_2(report, opts)` → `String.t()` — top issues, all category detail sections
 - `render_parts_3(report, opts)` → `[String.t()]` — blocks section sliced into 60,000-char chunks; returns `[""]` when no blocks exist
 
-The existing `render/3` is not changed. It continues to produce the full single-string report for `--output file` usage.
+**Each rendered part must end with a sentinel HTML comment as its final line:**
+
+```
+<!-- codeqa-health-report-{N} -->
+```
+
+where `N` is the 1-based part index. This sentinel is the sole mechanism by which `run.sh` locates an existing comment to update (the `marocchino` action and its header concept are removed entirely). Without the sentinel, every run would create a new comment instead of updating the previous one.
+
+The existing `render/3` is not changed. It continues to produce the full single-string report for `--output file` usage and does not append a sentinel.
 
 ## CLI Changes
 
@@ -54,7 +62,7 @@ When writing output for comment mode, the CLI writes each part to a numbered tem
 - `$TMPDIR/codeqa-part-3.md`
 - … etc.
 
-It also writes `$TMPDIR/codeqa-part-count.txt` containing the integer count of parts.
+It also writes `$TMPDIR/codeqa-part-count.txt` containing the **padded** part count (i.e., `max(actual_parts, 3)`), which is the number of files `run.sh` should iterate over. The padding ensures stale cleanup files are always written.
 
 The existing `--output` flag behaviour (write single file) is unchanged.
 

From 757114e7f7eac42217e3c9dc964ea7902f6bd9a1 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Sun, 22 Mar 2026 17:36:46 +0100
Subject: [PATCH 60/71] =?UTF-8?q?docs:=20final=20spec=20clarifications=20?=
 =?UTF-8?q?=E2=80=94=20part-count=20loop=20and=20placeholder=20ownership?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../specs/2026-03-22-multi-part-pr-comments-design.md         | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md b/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md
index f67de67..8ece93b 100644
--- a/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md
+++ b/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md
@@ -37,7 +37,7 @@ Add three new rendering entry points alongside the existing `render/3`:
 
 - `render_part_1(report, opts)` → `String.t()` — header, summary table, PR summary, delta, mermaid chart, progress bars
 - `render_part_2(report, opts)` → `String.t()` — top issues, all category detail sections
-- `render_parts_3(report, opts)` → `[String.t()]` — blocks section sliced into 60,000-char chunks; returns `[""]` when no blocks exist
+- `render_parts_3(report, opts)` → `[String.t()]` — blocks section sliced into 60,000-char chunks; returns `["> _No content for this section._"]` when no blocks exist (the CLI does not substitute the placeholder — the formatter is responsible)
 
 **Each rendered part must end with a sentinel HTML comment as its final line:**
 
@@ -62,7 +62,7 @@ When writing output for comment mode, the CLI writes each part to a numbered tem
 - `$TMPDIR/codeqa-part-3.md`
 - … etc.
 
-It also writes `$TMPDIR/codeqa-part-count.txt` containing the **padded** part count (i.e., `max(actual_parts, 3)`), which is the number of files `run.sh` should iterate over. The padding ensures stale cleanup files are always written.
+It also writes `$TMPDIR/codeqa-part-count.txt` containing the **padded** part count (i.e., `max(actual_parts, 3)`). `run.sh` reads this file to determine how many iterations to perform — it does not infer part count from files on disk. The padding ensures stale cleanup files are always written for at least parts 1–3.
 
 The existing `--output` flag behaviour (write single file) is unchanged.
 

From ffa74003cf7042fddc067714db2e1c4f47978944 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 26 Mar 2026 14:35:21 +0100
Subject: [PATCH 61/71] feat(multi-part-comments): split health report into
 multiple PR comments

Implements the multi-part PR comments spec to handle GitHub's 65,536
character limit on PR comments. Large reports are now split into:

- Part 1: Header, grade, chart, progress bars
- Part 2: Top issues, category detail sections
- Part 3+: Blocks section, auto-sliced at 60,000 chars

Changes:
- Add render_part_1/2, render_part_2/2, render_parts_3/2 to Github formatter
- Add render_parts/2 to Formatter module
- Add --comment flag to CLI that writes numbered part files
- Update run.sh to post via GitHub API with sentinel-based sticky updates
- Remove marocchino/sticky-pull-request-comment dependency
- Add 13 tests for multi-part rendering

Breaking: Old single-part comments won't auto-clean on first run.
---
 action.yml                                   |   8 +-
 lib/codeqa/cli/health_report.ex              |  62 +++++++--
 lib/codeqa/combined_metrics/sample_runner.ex |  34 ++++-
 lib/codeqa/health_report/formatter.ex        |  19 +++
 lib/codeqa/health_report/formatter/github.ex | 132 +++++++++++++++++++
 scripts/run.sh                               |  78 ++++++++++-
 test/codeqa/health_report/formatter_test.exs | 119 +++++++++++++++++
 7 files changed, 427 insertions(+), 25 deletions(-)

diff --git a/action.yml b/action.yml
index 6be6078..3d43011 100644
--- a/action.yml
+++ b/action.yml
@@ -93,15 +93,9 @@ runs:
         INPUT_VERSION: ${{ inputs.version }}
         INPUT_BUILD: ${{ inputs.build }}
         GITHUB_ACTION_PATH: ${{ github.action_path }}
+        PR_NUMBER: ${{ github.event.pull_request.number }}
       run: ${{ github.action_path }}/scripts/run.sh
 
-    - name: Post PR comment
-      if: inputs.comment == 'true' && github.event_name == 'pull_request'
-      uses: marocchino/sticky-pull-request-comment@v2
-      with:
-        header: codeqa-${{ inputs.command }}
-        path: ${{ steps.run.outputs.report-file }}
-
     - name: Check grade threshold
       if: inputs.fail-grade != '' && inputs.command == 'health-report'
       shell: bash
diff --git a/lib/codeqa/cli/health_report.ex b/lib/codeqa/cli/health_report.ex
index 6d20ab2..b271bb4 100644
--- a/lib/codeqa/cli/health_report.ex
+++ b/lib/codeqa/cli/health_report.ex
@@ -31,6 +31,7 @@ defmodule CodeQA.CLI.HealthReport do
       --ignore-paths PATHS  Comma-separated list of path patterns to ignore (supports wildcards, e.g. "test/*,docs/*")
       --base-ref REF        Base git ref for PR comparison (enables delta and block scoping)
       --head-ref REF        Head git ref (default: HEAD)
+      --comment             Multi-part mode: writes numbered part files to TMPDIR for PR comments
     """
   end
 
@@ -48,7 +49,8 @@ defmodule CodeQA.CLI.HealthReport do
     ignore_paths: :string,
     base_ref: :string,
     head_ref: :string,
-    telemetry: :boolean
+    telemetry: :boolean,
+    comment: :boolean
   ]
 
   def run(args) do
@@ -120,17 +122,52 @@ defmodule CodeQA.CLI.HealthReport do
         changed_files: changed_files
       )
 
-    markdown = HealthReport.to_markdown(report, detail, format)
+    if opts[:comment] do
+      write_comment_parts(report, detail)
+    else
+      markdown = HealthReport.to_markdown(report, detail, format)
 
-    case opts[:output] do
-      nil ->
-        markdown
+      case opts[:output] do
+        nil ->
+          markdown
 
-      file ->
-        File.write!(file, markdown)
-        IO.puts(:stderr, "Health report written to #{file}")
-        ""
+        file ->
+          File.write!(file, markdown)
+          IO.puts(:stderr, "Health report written to #{file}")
+          ""
+      end
+    end
+  end
+
+  defp write_comment_parts(report, detail) do
+    tmpdir = System.get_env("TMPDIR", "/tmp")
+    parts = HealthReport.Formatter.render_parts(report, detail: detail)
+
+    # Write each part to a numbered file
+    Enum.with_index(parts, 1)
+    |> Enum.each(fn {content, n} ->
+      path = Path.join(tmpdir, "codeqa-part-#{n}.md")
+      File.write!(path, content)
+      IO.puts(:stderr, "Part #{n} written to #{path} (#{byte_size(content)} bytes)")
+    end)
+
+    # Ensure at least 3 parts exist for stale cleanup
+    actual_count = length(parts)
+    padded_count = max(actual_count, 3)
+
+    for n <- (actual_count + 1)..padded_count do
+      path = Path.join(tmpdir, "codeqa-part-#{n}.md")
+      placeholder = "> _No content for this section._\n\n<!-- codeqa-health-report-#{n} -->"
+      File.write!(path, placeholder)
+      IO.puts(:stderr, "Part #{n} (placeholder) written to #{path}")
     end
+
+    # Write part count for run.sh to read
+    count_path = Path.join(tmpdir, "codeqa-part-count.txt")
+    File.write!(count_path, to_string(padded_count))
+    IO.puts(:stderr, "Part count (#{padded_count}) written to #{count_path}")
+
+    ""
   end
 
   defp parse_detail(nil), do: :default
@@ -173,7 +210,12 @@ defmodule CodeQA.CLI.HealthReport do
     pid
   end
 
-  defp handle_block_impact_event([:codeqa, :block_impact, :codebase_cosines], measurements, _metadata, pid) do
+  defp handle_block_impact_event(
+         [:codeqa, :block_impact, :codebase_cosines],
+         measurements,
+         _metadata,
+         pid
+       ) do
     Agent.update(pid, &Map.put(&1, :codebase_cosines_us, measurements.duration))
   end
 
diff --git a/lib/codeqa/combined_metrics/sample_runner.ex b/lib/codeqa/combined_metrics/sample_runner.ex
index 4bd397b..f652c83 100644
--- a/lib/codeqa/combined_metrics/sample_runner.ex
+++ b/lib/codeqa/combined_metrics/sample_runner.ex
@@ -194,9 +194,7 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
       else
         Scorer.all_yamls()
         |> Enum.sort_by(fn {path, _} -> path end)
-        |> Enum.flat_map(
-          &diagnose_from_yaml(&1, aggregate, language, languages, cosine_opts)
-        )
+        |> Enum.flat_map(&diagnose_from_yaml(&1, aggregate, language, languages, cosine_opts))
       end
 
     behaviors_stream
@@ -376,11 +374,26 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
     end)
   end
 
-  defp diagnose_from_behavior_map_entry({category, behaviors}, aggregate, language, languages, cosine_opts) do
+  defp diagnose_from_behavior_map_entry(
+         {category, behaviors},
+         aggregate,
+         language,
+         languages,
+         cosine_opts
+       ) do
     yaml_path = "priv/combined_metrics/#{category}.yml"
 
     Enum.flat_map(behaviors, fn {behavior, behavior_data} ->
-      maybe_diagnose_behavior(yaml_path, behavior, behavior_data, aggregate, category, language, languages, cosine_opts)
+      maybe_diagnose_behavior(
+        yaml_path,
+        behavior,
+        behavior_data,
+        aggregate,
+        category,
+        language,
+        languages,
+        cosine_opts
+      )
     end)
   end
 
@@ -390,7 +403,16 @@ defmodule CodeQA.CombinedMetrics.SampleRunner do
     data
     |> Enum.filter(fn {_k, v} -> is_map(v) end)
     |> Enum.flat_map(fn {behavior, behavior_data} ->
-      maybe_diagnose_behavior(yaml_path, behavior, behavior_data, aggregate, category, language, languages, cosine_opts)
+      maybe_diagnose_behavior(
+        yaml_path,
+        behavior,
+        behavior_data,
+        aggregate,
+        category,
+        language,
+        languages,
+        cosine_opts
+      )
     end)
   end
 
diff --git a/lib/codeqa/health_report/formatter.ex b/lib/codeqa/health_report/formatter.ex
index df17d8d..d166f14 100644
--- a/lib/codeqa/health_report/formatter.ex
+++ b/lib/codeqa/health_report/formatter.ex
@@ -8,4 +8,23 @@ defmodule CodeQA.HealthReport.Formatter do
 
   def format_markdown(report, detail, :plain, _opts), do: Plain.render(report, detail)
   def format_markdown(report, detail, :github, opts), do: Github.render(report, detail, opts)
+
+  @doc """
+  Renders the report as multiple parts for GitHub PR comments.
+  Returns a flat list of strings: [part_1, part_2, part_3, ...].
+
+  Part 1: Header, summary, PR summary, delta, chart, progress bars
+  Part 2: Top issues, category detail sections
+  Part 3+: Blocks section, sliced at 60,000 chars per part
+
+  Each part ends with a sentinel comment for sticky comment identification.
+  """
+  @spec render_parts(map(), keyword()) :: [String.t()]
+  def render_parts(report, opts \\ []) do
+    part_1 = Github.render_part_1(report, opts)
+    part_2 = Github.render_part_2(report, opts)
+    parts_3 = Github.render_parts_3(report, opts)
+
+    [part_1, part_2 | parts_3]
+  end
 end
diff --git a/lib/codeqa/health_report/formatter/github.ex b/lib/codeqa/health_report/formatter/github.ex
index e0d9170..03c0b93 100644
--- a/lib/codeqa/health_report/formatter/github.ex
+++ b/lib/codeqa/health_report/formatter/github.ex
@@ -4,6 +4,7 @@ defmodule CodeQA.HealthReport.Formatter.Github do
   @bar_width 20
   @filled "█"
   @empty "░"
+  @part_char_limit 60_000
 
   @spec render(map(), atom(), keyword()) :: String.t()
   def render(report, detail, opts \\ []) do
@@ -26,6 +27,136 @@ defmodule CodeQA.HealthReport.Formatter.Github do
     |> Enum.join("\n")
   end
 
+  @doc """
+  Renders Part 1: header, summary table, PR summary, delta, mermaid chart, progress bars.
+  Each part ends with a sentinel HTML comment for sticky comment identification.
+  """
+  @spec render_part_1(map(), keyword()) :: String.t()
+  def render_part_1(report, opts \\ []) do
+    chart? = Keyword.get(opts, :chart, true)
+    display_categories = merge_cosine_categories(report.categories)
+
+    [
+      pr_summary_section(Map.get(report, :pr_summary)),
+      header(report),
+      cosine_legend(),
+      delta_section(Map.get(report, :codebase_delta)),
+      if(chart?, do: mermaid_chart(display_categories), else: []),
+      progress_bars(display_categories),
+      sentinel(1)
+    ]
+    |> List.flatten()
+    |> Enum.join("\n")
+  end
+
+  @doc """
+  Renders Part 2: top issues + all category detail sections.
+  """
+  @spec render_part_2(map(), keyword()) :: String.t()
+  def render_part_2(report, opts \\ []) do
+    detail = Keyword.get(opts, :detail, :default)
+    display_categories = merge_cosine_categories(report.categories)
+
+    [
+      top_issues_section(Map.get(report, :top_issues, []), detail),
+      category_sections(display_categories, detail),
+      sentinel(2)
+    ]
+    |> List.flatten()
+    |> Enum.join("\n")
+  end
+
+  @doc """
+  Renders Part 3+: blocks section sliced into 60,000-char chunks.
+  Returns a list of strings, one per part. If no blocks, returns a single placeholder.
+  """
+  @spec render_parts_3(map(), keyword()) :: [String.t()]
+  def render_parts_3(report, _opts \\ []) do
+    top_blocks = Map.get(report, :top_blocks, [])
+
+    if top_blocks == [] do
+      ["> _No content for this section._\n\n" <> sentinel_str(3)]
+    else
+      blocks_content = blocks_section(top_blocks) |> List.flatten() |> Enum.join("\n")
+      slice_blocks_content(blocks_content, 3)
+    end
+  end
+
+  defp slice_blocks_content(content, start_part) do
+    slice_blocks_content(content, start_part, [])
+  end
+
+  defp slice_blocks_content("", part_num, acc) do
+    # No more content; finalize the last part if any, or emit placeholder
+    case acc do
+      [] -> ["> _No content for this section._\n\n" <> sentinel_str(part_num)]
+      _ -> Enum.reverse(acc)
+    end
+  end
+
+  defp slice_blocks_content(content, part_num, acc) do
+    sentinel = sentinel_str(part_num)
+    truncation_warning = "\n\n> ⚠️ Truncated at 60,000 chars — continued in next comment\n\n"
+
+    # Reserve space for sentinel and potential truncation warning
+    available = @part_char_limit - byte_size(sentinel) - byte_size(truncation_warning) - 10
+
+    if byte_size(content) <= available + byte_size(truncation_warning) do
+      # Fits in this part
+      final_part = content <> "\n\n" <> sentinel
+      Enum.reverse([final_part | acc])
+    else
+      # Need to split
+      {chunk, rest} = split_at_safe_boundary(content, available)
+      part_content = chunk <> truncation_warning <> sentinel
+      slice_blocks_content(rest, part_num + 1, [part_content | acc])
+    end
+  end
+
+  defp split_at_safe_boundary(content, max_bytes) do
+    # Try to split at a </details> boundary to avoid breaking HTML structure
+    prefix = binary_part(content, 0, min(max_bytes, byte_size(content)))
+
+    case :binary.matches(prefix, "</details>") do
+      [] ->
+        # No good boundary, split at newline
+        split_at_newline(content, max_bytes)
+
+      matches ->
+        {pos, len} = List.last(matches)
+        split_pos = pos + len
+
+        if split_pos > div(max_bytes, 2) do
+          # Good split point
+          {binary_part(content, 0, split_pos),
+           binary_part(content, split_pos, byte_size(content) - split_pos)}
+        else
+          # Too early, try newline
+          split_at_newline(content, max_bytes)
+        end
+    end
+  end
+
+  defp split_at_newline(content, max_bytes) do
+    prefix = binary_part(content, 0, min(max_bytes, byte_size(content)))
+
+    case :binary.matches(prefix, "\n") do
+      [] ->
+        # No newline, hard split
+        {prefix, binary_part(content, byte_size(prefix), byte_size(content) - byte_size(prefix))}
+
+      matches ->
+        {pos, _len} = List.last(matches)
+
+        {binary_part(content, 0, pos),
+         binary_part(content, pos + 1, byte_size(content) - pos - 1)}
+    end
+  end
+
+  defp sentinel(n), do: [sentinel_str(n)]
+
+  defp sentinel_str(n), do: "<!-- codeqa-health-report-#{n} -->"
+
   defp merge_cosine_categories(categories) do
     {cosine, threshold} = Enum.split_with(categories, &(&1.type == :cosine))
 
@@ -300,6 +431,7 @@ defmodule CodeQA.HealthReport.Formatter.Github do
   end
 
   defp footer do
+    # Legacy footer for single-part render/3 (used by --output file mode)
     ["<!-- Sticky Pull Request Commentcodeqa-health-report -->", ""]
   end
 
diff --git a/scripts/run.sh b/scripts/run.sh
index 9804205..4cc0918 100755
--- a/scripts/run.sh
+++ b/scripts/run.sh
@@ -47,17 +47,20 @@ esac
 # --- Build CLI arguments ---
 ARGS=("$INPUT_COMMAND" "$INPUT_PATH")
 CAPTURE_STDOUT=false
+COMMENT_MODE=false
 
 case "$INPUT_COMMAND" in
   health-report)
-    ARGS+=("--output" "$OUTPUT_FILE")
     ARGS+=("--detail" "$INPUT_DETAIL")
     ARGS+=("--top" "$INPUT_TOP")
     if [[ -n "$INPUT_CONFIG" ]]; then
       ARGS+=("--config" "$INPUT_CONFIG")
     fi
     if [[ "${INPUT_COMMENT:-false}" == "true" ]]; then
-      ARGS+=("--format" "github")
+      ARGS+=("--comment")
+      COMMENT_MODE=true
+    else
+      ARGS+=("--output" "$OUTPUT_FILE")
     fi
     ;;
   compare)
@@ -117,6 +120,77 @@ else
   "$CODEQA" "${ARGS[@]}"
 fi
 
+# --- Post multi-part PR comments (health-report with comment mode) ---
+if [[ "$COMMENT_MODE" == "true" ]]; then
+  TMPDIR="${TMPDIR:-/tmp}"
+  PART_COUNT_FILE="${TMPDIR}/codeqa-part-count.txt"
+
+  if [[ ! -f "$PART_COUNT_FILE" ]]; then
+    echo "::error::Part count file not found at ${PART_COUNT_FILE}"
+    exit 1
+  fi
+
+  PART_COUNT=$(cat "$PART_COUNT_FILE")
+  echo "Posting ${PART_COUNT} comment parts..."
+
+  # GitHub API settings
+  API_URL="${GITHUB_API_URL:-https://api.github.com}"
+  REPO="${GITHUB_REPOSITORY}"
+  PR_NUMBER="${PR_NUMBER:-}"
+
+  if [[ -z "$PR_NUMBER" ]]; then
+    echo "::error::PR_NUMBER not set. Cannot post PR comments."
+    exit 1
+  fi
+
+  for i in $(seq 1 "$PART_COUNT"); do
+    PART_FILE="${TMPDIR}/codeqa-part-${i}.md"
+    SENTINEL="<!-- codeqa-health-report-${i} -->"
+
+    if [[ ! -f "$PART_FILE" ]]; then
+      echo "::warning::Part file ${PART_FILE} not found, skipping"
+      continue
+    fi
+
+    BODY=$(cat "$PART_FILE")
+
+    # Search for existing comment with this sentinel
+    echo "Searching for existing comment with sentinel: ${SENTINEL}"
+    COMMENTS_JSON=$(curl -fsSL \
+      -H "Authorization: Bearer ${GITHUB_TOKEN}" \
+      -H "Accept: application/vnd.github+json" \
+      "${API_URL}/repos/${REPO}/issues/${PR_NUMBER}/comments?per_page=100" 2>/dev/null || echo "[]")
+
+    # Find comment ID containing the sentinel
+    COMMENT_ID=$(echo "$COMMENTS_JSON" | jq -r --arg sentinel "$SENTINEL" \
+      '.[] | select(.body | contains($sentinel)) | .id' | head -1)
+
+    # Prepare JSON payload
+    PAYLOAD=$(jq -n --arg body "$BODY" '{"body": $body}')
+
+    if [[ -n "$COMMENT_ID" && "$COMMENT_ID" != "null" ]]; then
+      echo "Updating existing comment ${COMMENT_ID} for part ${i}..."
+      curl -fsSL -X PATCH \
+        -H "Authorization: Bearer ${GITHUB_TOKEN}" \
+        -H "Accept: application/vnd.github+json" \
+        "${API_URL}/repos/${REPO}/issues/comments/${COMMENT_ID}" \
+        -d "$PAYLOAD" > /dev/null
+    else
+      echo "Creating new comment for part ${i}..."
+      curl -fsSL -X POST \
+        -H "Authorization: Bearer ${GITHUB_TOKEN}" \
+        -H "Accept: application/vnd.github+json" \
+        "${API_URL}/repos/${REPO}/issues/${PR_NUMBER}/comments" \
+        -d "$PAYLOAD" > /dev/null
+    fi
+  done
+
+  echo "All ${PART_COUNT} comment parts posted successfully"
+
+  # Use part 1 as the main output file for grade extraction
+  OUTPUT_FILE="${TMPDIR}/codeqa-part-1.md"
+fi
+
 # --- Extract grade (health-report only) ---
 GRADE=""
 if [[ "$INPUT_COMMAND" == "health-report" && -f "$OUTPUT_FILE" ]]; then
diff --git a/test/codeqa/health_report/formatter_test.exs b/test/codeqa/health_report/formatter_test.exs
index 39ce63a..244091e 100644
--- a/test/codeqa/health_report/formatter_test.exs
+++ b/test/codeqa/health_report/formatter_test.exs
@@ -498,4 +498,123 @@ defmodule CodeQA.HealthReport.FormatterTest do
       assert result =~ "61.00"
     end
   end
+
+  describe "render_parts/2" do
+    test "returns at least 3 parts" do
+      parts = Formatter.render_parts(@sample_report)
+      assert length(parts) >= 3
+    end
+
+    test "each part ends with sentinel comment" do
+      parts = Formatter.render_parts(@sample_report)
+
+      Enum.with_index(parts, 1)
+      |> Enum.each(fn {part, n} ->
+        assert part =~ "<!-- codeqa-health-report-#{n} -->"
+      end)
+    end
+
+    test "part 1 contains header and grade" do
+      [part_1 | _] = Formatter.render_parts(@sample_report)
+      assert part_1 =~ "Code Health: B+"
+      assert part_1 =~ "(79/100)"
+    end
+
+    test "part 1 contains mermaid chart by default" do
+      [part_1 | _] = Formatter.render_parts(@sample_report)
+      assert part_1 =~ "```mermaid"
+    end
+
+    test "part 1 contains progress bars" do
+      [part_1 | _] = Formatter.render_parts(@sample_report)
+      assert part_1 =~ "████"
+    end
+
+    test "part 2 contains category details" do
+      [_, part_2 | _] = Formatter.render_parts(@sample_report)
+      assert part_2 =~ "<details>"
+      assert part_2 =~ "Readability"
+    end
+
+    test "part 3 is placeholder when no blocks" do
+      [_, _, part_3 | _] = Formatter.render_parts(@sample_report)
+      assert part_3 =~ "_No content for this section._"
+    end
+
+    test "part 3 contains blocks when present" do
+      report = Map.put(@sample_report, :top_blocks, @top_blocks_gh)
+      [_, _, part_3 | _] = Formatter.render_parts(report)
+      assert part_3 =~ "lib/foo.ex"
+      assert part_3 =~ "Blocks"
+    end
+  end
+
+  describe "Github.render_parts_3/2 slicing" do
+    alias CodeQA.HealthReport.Formatter.Github
+
+    @many_blocks Enum.map(1..100, fn i ->
+                   %{
+                     path: "lib/file_#{i}.ex",
+                     status: "modified",
+                     blocks:
+                       Enum.map(1..10, fn j ->
+                         %{
+                           start_line: j * 10,
+                           end_line: j * 10 + 20,
+                           type: "function",
+                           token_count: 150,
+                           potentials: [
+                             %{
+                               category: "function_design",
+                               behavior: "single_responsibility",
+                               cosine_delta: 0.35,
+                               severity: :high,
+                               fix_hint: "Consider extracting helper function"
+                             }
+                           ]
+                         }
+                       end)
+                   }
+                 end)
+
+    test "slices large blocks section into multiple parts" do
+      report = Map.put(@sample_report, :top_blocks, @many_blocks)
+      parts = Github.render_parts_3(report)
+
+      # With 100 files × 10 blocks, this should produce multiple parts
+      assert length(parts) > 1
+    end
+
+    test "each sliced part ends with sentinel" do
+      report = Map.put(@sample_report, :top_blocks, @many_blocks)
+      parts = Github.render_parts_3(report)
+
+      Enum.with_index(parts, 3)
+      |> Enum.each(fn {part, n} ->
+        assert part =~ "<!-- codeqa-health-report-#{n} -->"
+      end)
+    end
+
+    test "non-final parts have truncation warning" do
+      report = Map.put(@sample_report, :top_blocks, @many_blocks)
+      parts = Github.render_parts_3(report)
+
+      if length(parts) > 1 do
+        non_final = Enum.take(parts, length(parts) - 1)
+
+        Enum.each(non_final, fn part ->
+          assert part =~ "Truncated at 60,000 chars"
+        end)
+      end
+    end
+
+    test "each part is under 65536 chars" do
+      report = Map.put(@sample_report, :top_blocks, @many_blocks)
+      parts = Github.render_parts_3(report)
+
+      Enum.each(parts, fn part ->
+        assert byte_size(part) < 65_536, "Part exceeds GitHub comment limit"
+      end)
+    end
+  end
 end

From d198001c9ae4038430a028db7219e498e2f01d7c Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 26 Mar 2026 14:59:32 +0100
Subject: [PATCH 62/71] fix(action): pass GITHUB_TOKEN to run.sh for PR comment
 posting

The multi-part comment posting uses the GitHub API to create/update
comments. GITHUB_TOKEN must be explicitly passed via env in composite
actions - it's not automatically available.

Also fix Elixir 1.19 Range warning by using explicit step (//1) when
iterating over potentially empty ranges.
---
 action.yml                      | 1 +
 lib/codeqa/cli/health_report.ex | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/action.yml b/action.yml
index 3d43011..ebee062 100644
--- a/action.yml
+++ b/action.yml
@@ -94,6 +94,7 @@ runs:
         INPUT_BUILD: ${{ inputs.build }}
         GITHUB_ACTION_PATH: ${{ github.action_path }}
         PR_NUMBER: ${{ github.event.pull_request.number }}
+        GITHUB_TOKEN: ${{ github.token }}
       run: ${{ github.action_path }}/scripts/run.sh
 
     - name: Check grade threshold
diff --git a/lib/codeqa/cli/health_report.ex b/lib/codeqa/cli/health_report.ex
index b271bb4..fc9bbaa 100644
--- a/lib/codeqa/cli/health_report.ex
+++ b/lib/codeqa/cli/health_report.ex
@@ -155,7 +155,7 @@ defmodule CodeQA.CLI.HealthReport do
     actual_count = length(parts)
     padded_count = max(actual_count, 3)
 
-    for n <- (actual_count + 1)..padded_count do
+    for n <- (actual_count + 1)..padded_count//1 do
       path = Path.join(tmpdir, "codeqa-part-#{n}.md")
       placeholder = "> _No content for this section._\n\n<!-- codeqa-health-report-#{n} -->"
       File.write!(path, placeholder)

From 570812a7654add5e788cc8a2bfda740784fd79c9 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 26 Mar 2026 15:08:34 +0100
Subject: [PATCH 63/71] chore: remove docs/ and ignore test/ in codeqa analysis

- Remove superpowers specs/plans (implementation complete)
- Add test/ to ignore_paths in .codeqa.yml
---
 .codeqa.yml                                   |    1 +
 ...26-03-21-health-report-blocks-and-delta.md | 1679 -----------------
 ...26-03-20-health-report-blocks-and-delta.md |  312 ---
 ...026-03-22-multi-part-pr-comments-design.md |  128 --
 4 files changed, 1 insertion(+), 2119 deletions(-)
 delete mode 100644 docs/superpowers/plans/2026-03-21-health-report-blocks-and-delta.md
 delete mode 100644 docs/superpowers/specs/2026-03-20-health-report-blocks-and-delta.md
 delete mode 100644 docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md

diff --git a/.codeqa.yml b/.codeqa.yml
index 8fa1a5c..05b52a5 100644
--- a/.codeqa.yml
+++ b/.codeqa.yml
@@ -9,6 +9,7 @@ ignore_paths:
   - scripts/**
   - docs/**
   - plans/**
+  - test/**
   - devenv*
   - direnv*
 
diff --git a/docs/superpowers/plans/2026-03-21-health-report-blocks-and-delta.md b/docs/superpowers/plans/2026-03-21-health-report-blocks-and-delta.md
deleted file mode 100644
index 1d6e9d0..0000000
--- a/docs/superpowers/plans/2026-03-21-health-report-blocks-and-delta.md
+++ /dev/null
@@ -1,1679 +0,0 @@
-# Health Report: Block Impact, PR Delta, and Compare Consolidation
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Unify health-report and compare commands into a single PR-aware report showing impactful blocks per changed file, before/after metric delta, and a PR impact summary — while deleting the compare command entirely.
-
-**Architecture:** `HealthReport.generate/2` gains `base_results:` and `changed_files:` opts; a new `HealthReport.TopBlocks` module assembles severity-classified blocks from node data; a new `HealthReport.Delta` module wraps aggregate delta computation ported from `Comparator`; formatters gain PR summary, delta, and block sections and lose worst_offenders rendering; `CLI.HealthReport` gains `--base-ref`/`--head-ref` and runs dual analysis when provided.
-
-**Tech Stack:** Elixir, ExUnit, `CodeQA.Git`, `CodeQA.CombinedMetrics.{SampleRunner, Scorer}`, `CodeQA.HealthReport.Grader`, `CodeQA.BlockImpactAnalyzer`
-
----
-
-## File Map
-
-| File | Change |
-|------|--------|
-| `lib/codeqa/block_impact_analyzer.ex` | Add `"end_line"` to `serialize_node/9` output |
-| `lib/codeqa/health_report/delta.ex` | **Create** — aggregate delta computation (ported from `Comparator`) |
-| `lib/codeqa/health_report/top_blocks.ex` | **Create** — block assembly, severity, fix hint enrichment |
-| `lib/codeqa/health_report.ex` | Accept new opts, wire `Delta` + `TopBlocks`, drop `worst_offenders` computation |
-| `lib/codeqa/health_report/formatter/plain.ex` | Remove worst_offenders rendering; add PR summary, delta table, block section |
-| `lib/codeqa/health_report/formatter/github.ex` | Remove worst_offenders rendering; add PR summary, delta table, block section |
-| `lib/codeqa/cli/health_report.ex` | Add `--base-ref`/`--head-ref`; dual analysis when base-ref given |
-| `lib/codeqa/cli.ex` | Remove compare entry |
-| `lib/codeqa/cli/compare.ex` | **Delete** |
-| `lib/codeqa/comparator.ex` | **Delete** |
-| `lib/codeqa/formatter.ex` | **Delete** |
-| `lib/codeqa/summarizer.ex` | **Delete** |
-| `test/codeqa/block_impact_analyzer_test.exs` | Add `end_line` assertion |
-| `test/codeqa/health_report/delta_test.exs` | **Create** |
-| `test/codeqa/health_report/top_blocks_test.exs` | **Create** |
-| `test/codeqa/health_report_test.exs` | Add: `top_blocks`, `pr_summary`, `codebase_delta` keys; remove worst_offenders assertions |
-| `test/codeqa/health_report/formatter_test.exs` | Delete worst_offenders tests; add block/delta/summary tests |
-| `test/codeqa/cli_compare_test.exs` | **Delete** |
-
----
-
-## Task 1: Add `end_line` to BlockImpactAnalyzer node serialization
-
-**Files:**
-- Modify: `lib/codeqa/block_impact_analyzer.ex:167-175`
-- Test: `test/codeqa/block_impact_analyzer_test.exs:42-52`
-
-- [ ] **Step 1: Add `end_line` assertion to the existing "each node has required fields" test**
-
-In `test/codeqa/block_impact_analyzer_test.exs`, inside the `Enum.each(nodes, fn node ->` block (line 42), add after line 43:
-
-```elixir
-assert Map.has_key?(node, "end_line")
-```
-
-- [ ] **Step 2: Run the test to confirm it fails**
-
-```bash
-mix test test/codeqa/block_impact_analyzer_test.exs --trace
-```
-
-Expected: FAIL — `"end_line"` key missing.
-
-- [ ] **Step 3: Add `end_line` to the serialized node map**
-
-In `lib/codeqa/block_impact_analyzer.ex`, edit the map at line 167:
-
-```elixir
-%{
-  "start_line" => node.start_line,
-  "end_line" => node.end_line,
-  "column_start" => (first_token && first_token.col) || 0,
-  "char_length" => char_length,
-  "type" => Atom.to_string(node.type),
-  "token_count" => length(node.tokens),
-  "refactoring_potentials" => potentials,
-  "children" => children
-}
-```
-
-- [ ] **Step 4: Run the test to confirm it passes**
-
-```bash
-mix test test/codeqa/block_impact_analyzer_test.exs --trace
-```
-
-Expected: all tests PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add lib/codeqa/block_impact_analyzer.ex test/codeqa/block_impact_analyzer_test.exs
-git commit -m "feat(block-impact): serialize end_line in node output"
-```
-
----
-
-## Task 2: Create `HealthReport.Delta`
-
-**Files:**
-- Create: `lib/codeqa/health_report/delta.ex`
-- Create: `test/codeqa/health_report/delta_test.exs`
-
-- [ ] **Step 1: Write the test file**
-
-```elixir
-# test/codeqa/health_report/delta_test.exs
-defmodule CodeQA.HealthReport.DeltaTest do
-  use ExUnit.Case, async: true
-
-  alias CodeQA.HealthReport.Delta
-
-  defp make_results(aggregate) do
-    %{"codebase" => %{"aggregate" => aggregate}}
-  end
-
-  test "returns base, head, and delta aggregates" do
-    base = make_results(%{"entropy" => %{"mean_value" => 5.0}})
-    head = make_results(%{"entropy" => %{"mean_value" => 6.0}})
-
-    result = Delta.compute(base, head)
-
-    assert result.base.aggregate == %{"entropy" => %{"mean_value" => 5.0}}
-    assert result.head.aggregate == %{"entropy" => %{"mean_value" => 6.0}}
-    assert result.delta.aggregate == %{"entropy" => %{"mean_value" => 1.0}}
-  end
-
-  test "rounds delta to 4 decimal places" do
-    base = make_results(%{"entropy" => %{"mean_value" => 1.0}})
-    head = make_results(%{"entropy" => %{"mean_value" => 4.3333}})
-
-    result = Delta.compute(base, head)
-    assert result.delta.aggregate["entropy"]["mean_value"] == 3.3333
-  end
-
-  test "handles missing base codebase gracefully" do
-    base = %{}
-    head = make_results(%{"entropy" => %{"mean_value" => 6.0}})
-
-    result = Delta.compute(base, head)
-    assert result.delta.aggregate == %{}
-  end
-
-  test "handles missing head codebase gracefully" do
-    base = make_results(%{"entropy" => %{"mean_value" => 5.0}})
-    head = %{}
-
-    result = Delta.compute(base, head)
-    assert result.delta.aggregate == %{}
-  end
-
-  test "skips non-numeric metric keys" do
-    base = make_results(%{"entropy" => %{"mean_value" => 5.0, "label" => "x"}})
-    head = make_results(%{"entropy" => %{"mean_value" => 6.0, "label" => "y"}})
-
-    result = Delta.compute(base, head)
-    refute Map.has_key?(result.delta.aggregate["entropy"], "label")
-    assert result.delta.aggregate["entropy"]["mean_value"] == 1.0
-  end
-end
-```
-
-- [ ] **Step 2: Run test to confirm it fails**
-
-```bash
-mix test test/codeqa/health_report/delta_test.exs --trace
-```
-
-Expected: FAIL — module not found.
-
-- [ ] **Step 3: Create the module**
-
-```elixir
-# lib/codeqa/health_report/delta.ex
-defmodule CodeQA.HealthReport.Delta do
-  @moduledoc "Computes aggregate metric delta between two codebase analysis results."
-
-  @spec compute(map(), map()) :: %{
-          base: %{aggregate: map()},
-          head: %{aggregate: map()},
-          delta: %{aggregate: map()}
-        }
-  def compute(base_results, head_results) do
-    base_agg = get_in(base_results, ["codebase", "aggregate"]) || %{}
-    head_agg = get_in(head_results, ["codebase", "aggregate"]) || %{}
-
-    %{
-      base: %{aggregate: base_agg},
-      head: %{aggregate: head_agg},
-      delta: %{aggregate: compute_aggregate_delta(base_agg, head_agg)}
-    }
-  end
-
-  defp compute_aggregate_delta(base_agg, head_agg) do
-    MapSet.new(Map.keys(base_agg) ++ Map.keys(head_agg))
-    |> Enum.reduce(%{}, fn metric_name, acc ->
-      base_m = Map.get(base_agg, metric_name, %{})
-      head_m = Map.get(head_agg, metric_name, %{})
-      delta = compute_numeric_delta(base_m, head_m)
-      if delta == %{}, do: acc, else: Map.put(acc, metric_name, delta)
-    end)
-  end
-
-  defp compute_numeric_delta(base, head) do
-    MapSet.new(Map.keys(base) ++ Map.keys(head))
-    |> Enum.reduce(%{}, fn key, acc ->
-      case {Map.get(base, key), Map.get(head, key)} do
-        {b, h} when is_number(b) and is_number(h) ->
-          Map.put(acc, key, Float.round(h - b, 4))
-
-        _ ->
-          acc
-      end
-    end)
-  end
-end
-```
-
-- [ ] **Step 4: Run tests to confirm they pass**
-
-```bash
-mix test test/codeqa/health_report/delta_test.exs --trace
-```
-
-Expected: all PASS.
-
-- [ ] **Step 5: Commit**
-
-```bash
-git add lib/codeqa/health_report/delta.ex test/codeqa/health_report/delta_test.exs
-git commit -m "feat(health-report): add Delta module for aggregate metric comparison"
-```
-
----
-
-## Task 3: Create `HealthReport.TopBlocks`
-
-**Files:**
-- Create: `lib/codeqa/health_report/top_blocks.ex`
-- Create: `test/codeqa/health_report/top_blocks_test.exs`
-
-- [ ] **Step 1: Write the test file**
-
-```elixir
-# test/codeqa/health_report/top_blocks_test.exs
-defmodule CodeQA.HealthReport.TopBlocksTest do
-  use ExUnit.Case, async: true
-
-  alias CodeQA.HealthReport.TopBlocks
-  alias CodeQA.Git.ChangedFile
-
-  # A node with cosine_delta 0.60 — will be :critical when codebase_cosine = 0.0 (gap=1.0, ratio=0.60)
-  defp make_node(cosine_delta, token_count \\ 20) do
-    %{
-      "start_line" => 1,
-      "end_line" => 10,
-      "type" => "code",
-      "token_count" => token_count,
-      "refactoring_potentials" => [
-        %{
-          "category" => "function_design",
-          "behavior" => "cyclomatic_complexity_under_10",
-          "cosine_delta" => cosine_delta
-        }
-      ],
-      "children" => []
-    }
-  end
-
-  defp make_results(nodes) do
-    %{"files" => %{"lib/foo.ex" => %{"nodes" => nodes}}}
-  end
-
-  defp lookup(cosine \\ 0.0) do
-    %{{"function_design", "cyclomatic_complexity_under_10"} => cosine}
-  end
-
-  describe "severity classification" do
-    test ":critical when severity_ratio > 0.50" do
-      # gap = max(0.01, 1.0 - 0.0) = 1.0, ratio = 0.60 / 1.0 = 0.60 > 0.50
-      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup())
-      assert hd(hd(group.blocks).potentials).severity == :critical
-    end
-
-    test ":high when severity_ratio > 0.25 and <= 0.50" do
-      # ratio = 0.30 / 1.0 = 0.30
-      [group] = TopBlocks.build(make_results([make_node(0.30)]), [], lookup())
-      assert hd(hd(group.blocks).potentials).severity == :high
-    end
-
-    test ":medium when severity_ratio > 0.10 and <= 0.25" do
-      # ratio = 0.15 / 1.0 = 0.15
-      [group] = TopBlocks.build(make_results([make_node(0.15)]), [], lookup())
-      assert hd(hd(group.blocks).potentials).severity == :medium
-    end
-
-    test "filtered when severity_ratio <= 0.10" do
-      # ratio = 0.05 / 1.0 = 0.05 — block should not appear
-      assert TopBlocks.build(make_results([make_node(0.05)]), [], lookup()) == []
-    end
-
-    test "gap floor prevents division by zero when codebase_cosine = 1.0" do
-      # gap = max(0.01, 1.0 - 1.0) = 0.01, ratio = 0.02 / 0.01 = 2.0 → :critical
-      [group] = TopBlocks.build(make_results([make_node(0.02)]), [], lookup(1.0))
-      assert hd(hd(group.blocks).potentials).severity == :critical
-    end
-
-    test "gap handles negative codebase_cosine" do
-      # codebase_cosine = -0.5, gap = max(0.01, 1.0 - (-0.5)) = 1.5
-      # ratio = 0.60 / 1.5 = 0.40 → :high
-      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup(-0.5))
-      assert hd(hd(group.blocks).potentials).severity == :high
-    end
-
-    test "unknown behavior defaults codebase_cosine to 0.0" do
-      lookup_empty = %{}
-      # gap = 1.0, ratio = 0.60 → :critical
-      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup_empty)
-      assert hd(hd(group.blocks).potentials).severity == :critical
-    end
-  end
-
-  describe "changed_files filtering" do
-    test "when changed_files is empty, shows all files" do
-      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup())
-      assert group.path == "lib/foo.ex"
-      assert group.status == nil
-    end
-
-    test "when changed_files given, only shows matching files" do
-      changed = [%ChangedFile{path: "lib/other.ex", status: "added"}]
-      assert TopBlocks.build(make_results([make_node(0.60)]), changed, lookup()) == []
-    end
-
-    test "status comes from ChangedFile struct" do
-      changed = [%ChangedFile{path: "lib/foo.ex", status: "modified"}]
-      [group] = TopBlocks.build(make_results([make_node(0.60)]), changed, lookup())
-      assert group.status == "modified"
-    end
-  end
-
-  describe "block filtering" do
-    test "blocks with token_count < 10 are excluded" do
-      assert TopBlocks.build(make_results([make_node(0.60, 9)]), [], lookup()) == []
-    end
-
-    test "blocks are ordered by highest cosine_delta descending" do
-      node_low = make_node(0.20)
-      node_high = put_in(make_node(0.60), ["start_line"], 20)
-      results = %{"files" => %{"lib/foo.ex" => %{"nodes" => [node_low, node_high]}}}
-
-      [group] = TopBlocks.build(results, [], lookup())
-      deltas = Enum.map(group.blocks, fn b -> hd(b.potentials).cosine_delta end)
-      assert deltas == Enum.sort(deltas, :desc)
-    end
-
-    test "children nodes are included" do
-      parent = %{
-        "start_line" => 1, "end_line" => 20,
-        "type" => "code", "token_count" => 5,
-        "refactoring_potentials" => [],
-        "children" => [make_node(0.60)]
-      }
-      [group] = TopBlocks.build(make_results([parent]), [], lookup())
-      assert length(group.blocks) == 1
-    end
-  end
-
-  describe "fix hints" do
-    test "includes fix_hint string for known behavior" do
-      # function_design/cyclomatic_complexity_under_10 has _fix_hint in YAML
-      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup())
-      potential = hd(hd(group.blocks).potentials)
-      assert is_binary(potential.fix_hint)
-    end
-
-    test "fix_hint is nil for unknown behavior" do
-      node = %{
-        "start_line" => 1, "end_line" => 10, "type" => "code",
-        "token_count" => 20,
-        "refactoring_potentials" => [
-          %{"category" => "unknown_cat", "behavior" => "unknown_beh", "cosine_delta" => 0.60}
-        ],
-        "children" => []
-      }
-      [group] = TopBlocks.build(make_results([node]), [], %{})
-      assert hd(hd(group.blocks).potentials).fix_hint == nil
-    end
-  end
-end
-```
-
-- [ ] **Step 2: Run tests to confirm they fail**
-
-```bash
-mix test test/codeqa/health_report/top_blocks_test.exs --trace
-```
-
-Expected: FAIL — module not found.
-
-- [ ] **Step 3: Create the module**
-
-```elixir
-# lib/codeqa/health_report/top_blocks.ex
-defmodule CodeQA.HealthReport.TopBlocks do
-  @moduledoc "Assembles the top_blocks report section from analysis node data."
-
-  alias CodeQA.CombinedMetrics.Scorer
-
-  @min_tokens 10
-  @severity_critical 0.50
-  @severity_high 0.25
-  @severity_medium 0.10
-  @gap_floor 0.01
-
-  @spec build(map(), [struct()], map()) :: [map()]
-  def build(analysis_results, changed_files, codebase_cosine_lookup) do
-    files = Map.get(analysis_results, "files", %{})
-    fix_hints = build_fix_hint_lookup()
-
-    file_entries =
-      if changed_files == [] do
-        Enum.map(files, fn {path, data} -> {path, nil, data} end)
-      else
-        changed_index = Map.new(changed_files, &{&1.path, &1.status})
-
-        files
-        |> Enum.filter(fn {path, _} -> Map.has_key?(changed_index, path) end)
-        |> Enum.map(fn {path, data} -> {path, Map.get(changed_index, path), data} end)
-      end
-
-    file_entries
-    |> Enum.map(fn {path, status, file_data} ->
-      blocks =
-        file_data
-        |> Map.get("nodes", [])
-        |> Enum.flat_map(&collect_nodes/1)
-        |> Enum.filter(&(&1["token_count"] >= @min_tokens))
-        |> Enum.map(&enrich_block(&1, codebase_cosine_lookup, fix_hints))
-        |> Enum.reject(&(&1.potentials == []))
-        |> Enum.sort_by(&(-max_delta(&1)))
-
-      %{path: path, status: status, blocks: blocks}
-    end)
-    |> Enum.reject(&(&1.blocks == []))
-    |> Enum.sort_by(& &1.path)
-  end
-
-  defp collect_nodes(node) do
-    children = node |> Map.get("children", []) |> Enum.flat_map(&collect_nodes/1)
-    [node | children]
-  end
-
-  defp enrich_block(node, cosine_lookup, fix_hints) do
-    potentials =
-      node
-      |> Map.get("refactoring_potentials", [])
-      |> Enum.map(&enrich_potential(&1, cosine_lookup, fix_hints))
-      |> Enum.reject(&is_nil/1)
-      |> Enum.sort_by(& &1.cosine_delta, :desc)
-
-    %{
-      start_line: node["start_line"],
-      end_line: node["end_line"],
-      type: node["type"],
-      token_count: node["token_count"],
-      potentials: potentials
-    }
-  end
-
-  defp enrich_potential(p, cosine_lookup, fix_hints) do
-    category = p["category"]
-    behavior = p["behavior"]
-    cosine_delta = p["cosine_delta"]
-
-    codebase_cosine = Map.get(cosine_lookup, {category, behavior}, 0.0)
-    gap = max(@gap_floor, 1.0 - codebase_cosine)
-    severity = classify(cosine_delta / gap)
-
-    if severity == :filtered do
-      nil
-    else
-      %{
-        category: category,
-        behavior: behavior,
-        cosine_delta: cosine_delta,
-        severity: severity,
-        fix_hint: Map.get(fix_hints, {category, behavior})
-      }
-    end
-  end
-
-  defp classify(ratio) when ratio > @severity_critical, do: :critical
-  defp classify(ratio) when ratio > @severity_high, do: :high
-  defp classify(ratio) when ratio > @severity_medium, do: :medium
-  defp classify(_ratio), do: :filtered
-
-  defp max_delta(%{potentials: []}), do: 0.0
-  defp max_delta(%{potentials: potentials}), do: Enum.max_by(potentials, & &1.cosine_delta).cosine_delta
-
-  defp build_fix_hint_lookup do
-    Scorer.all_yamls()
-    |> Enum.flat_map(fn {yaml_path, data} ->
-      category = yaml_path |> Path.basename() |> String.trim_trailing(".yml")
-
-      Enum.flat_map(data, fn {behavior, behavior_data} ->
-        case get_in(behavior_data, ["_fix_hint"]) do
-          nil -> []
-          hint -> [{{category, behavior}, hint}]
-        end
-      end)
-    end)
-    |> Map.new()
-  end
-end
-```
-
-- [ ] **Step 4: Run tests to confirm they pass**
-
-```bash
-mix test test/codeqa/health_report/top_blocks_test.exs --trace
-```
-
-Expected: all PASS.
-
-- [ ] **Step 5: Run full suite**
-
-```bash
-mix test
-```
-
-Expected: all passing.
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add lib/codeqa/health_report/top_blocks.ex test/codeqa/health_report/top_blocks_test.exs
-git commit -m "feat(health-report): add TopBlocks module for severity-classified block assembly"
-```
-
----
-
-## Task 4: Update `HealthReport.generate/2`
-
-**Files:**
-- Modify: `lib/codeqa/health_report.ex`
-- Modify: `test/codeqa/health_report_test.exs`
-
-- [ ] **Step 1: Add tests for new output keys**
-
-Open `test/codeqa/health_report_test.exs`. Add a describe block (create the file if it doesn't exist):
-
-```elixir
-describe "generate/2 output keys" do
-  @tag :slow
-  test "without base_results: pr_summary and codebase_delta are nil" do
-    files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
-    results = CodeQA.Engine.Analyzer.analyze_codebase(files)
-    results = CodeQA.BlockImpactAnalyzer.analyze(results, files)
-
-    report = CodeQA.HealthReport.generate(results)
-
-    assert report.pr_summary == nil
-    assert report.codebase_delta == nil
-    assert is_list(report.top_blocks)
-    assert Map.has_key?(report, :overall_score)
-    assert Map.has_key?(report, :overall_grade)
-    assert Map.has_key?(report, :categories)
-    assert Map.has_key?(report, :top_issues)
-  end
-
-  @tag :slow
-  test "without base_results: top_blocks shows all files with significant blocks" do
-    files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
-    results = CodeQA.Engine.Analyzer.analyze_codebase(files)
-    results = CodeQA.BlockImpactAnalyzer.analyze(results, files)
-
-    report = CodeQA.HealthReport.generate(results)
-
-    # top_blocks is a list of file groups (may be empty if no blocks above threshold)
-    assert is_list(report.top_blocks)
-    Enum.each(report.top_blocks, fn group ->
-      assert Map.has_key?(group, :path)
-      assert Map.has_key?(group, :status)
-      assert Map.has_key?(group, :blocks)
-      assert group.status == nil
-    end)
-  end
-
-  test "worst_offenders is always empty in categories" do
-    files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
-    results = CodeQA.Engine.Analyzer.analyze_codebase(files)
-    results = CodeQA.BlockImpactAnalyzer.analyze(results, files)
-
-    report = CodeQA.HealthReport.generate(results)
-
-    Enum.each(report.categories, fn cat ->
-      assert Map.get(cat, :worst_offenders, []) == []
-    end)
-  end
-end
-
-describe "generate/2 with base_results" do
-  @tag :slow
-  test "pr_summary is populated" do
-    files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
-    head_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
-    head_results = CodeQA.BlockImpactAnalyzer.analyze(head_results, files)
-    base_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
-
-    changed = [%CodeQA.Git.ChangedFile{path: "lib/foo.ex", status: "modified"}]
-
-    report = CodeQA.HealthReport.generate(head_results,
-      base_results: base_results,
-      changed_files: changed
-    )
-
-    assert %{
-      base_score: base_score,
-      head_score: head_score,
-      score_delta: delta,
-      base_grade: _,
-      head_grade: _,
-      blocks_flagged: flagged,
-      files_changed: 1,
-      files_added: 0,
-      files_modified: 1
-    } = report.pr_summary
-
-    assert is_integer(base_score)
-    assert is_integer(head_score)
-    assert delta == head_score - base_score
-    assert is_integer(flagged)
-  end
-
-  @tag :slow
-  test "codebase_delta is populated" do
-    files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
-    head_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
-    head_results = CodeQA.BlockImpactAnalyzer.analyze(head_results, files)
-    base_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
-
-    report = CodeQA.HealthReport.generate(head_results, base_results: base_results)
-
-    assert %{base: %{aggregate: _}, head: %{aggregate: _}, delta: %{aggregate: _}} =
-             report.codebase_delta
-  end
-
-  @tag :slow
-  test "top_blocks scoped to changed_files" do
-    files = %{
-      "lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n",
-      "lib/bar.ex" => "defmodule Bar do\n  def baz, do: :ok\nend\n"
-    }
-    head_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
-    head_results = CodeQA.BlockImpactAnalyzer.analyze(head_results, files)
-    base_results = CodeQA.Engine.Analyzer.analyze_codebase(files)
-
-    changed = [%CodeQA.Git.ChangedFile{path: "lib/foo.ex", status: "modified"}]
-
-    report = CodeQA.HealthReport.generate(head_results,
-      base_results: base_results,
-      changed_files: changed
-    )
-
-    paths = Enum.map(report.top_blocks, & &1.path)
-    refute "lib/bar.ex" in paths
-  end
-end
-```
-
-- [ ] **Step 2: Run new tests to confirm they fail**
-
-```bash
-mix test test/codeqa/health_report_test.exs --trace
-```
-
-Expected: FAIL — `pr_summary` key missing, etc.
-
-- [ ] **Step 3: Update `lib/codeqa/health_report.ex`**
-
-Replace the entire file:
-
-```elixir
-defmodule CodeQA.HealthReport do
-  @moduledoc "Orchestrates health report generation from analysis results."
-
-  alias CodeQA.HealthReport.{Config, Grader, Formatter, Delta, TopBlocks}
-  alias CodeQA.CombinedMetrics.{FileScorer, SampleRunner}
-
-  @spec generate(map(), keyword()) :: map()
-  def generate(analysis_results, opts \\ []) do
-    config_path = Keyword.get(opts, :config)
-    detail = Keyword.get(opts, :detail, :default)
-    base_results = Keyword.get(opts, :base_results)
-    changed_files = Keyword.get(opts, :changed_files, [])
-
-    %{
-      categories: categories,
-      grade_scale: grade_scale,
-      impact_map: impact_map,
-      combined_top: combined_top
-    } =
-      Config.load(config_path)
-
-    aggregate = get_in(analysis_results, ["codebase", "aggregate"]) || %{}
-    files = Map.get(analysis_results, "files", %{})
-    project_langs = project_languages(files)
-
-    threshold_grades =
-      categories
-      |> Grader.grade_aggregate(aggregate, grade_scale)
-      |> Enum.zip(categories)
-      |> Enum.map(fn {graded, _cat_def} ->
-        summary = build_category_summary(graded)
-
-        graded
-        |> Map.put(:type, :threshold)
-        |> Map.merge(%{summary: summary, worst_offenders: []})
-      end)
-
-    worst_files_map = FileScorer.worst_files_per_behavior(files, combined_top: combined_top)
-
-    cosine_grades =
-      Grader.grade_cosine_categories(aggregate, worst_files_map, grade_scale, project_langs)
-
-    all_categories =
-      (threshold_grades ++ cosine_grades)
-      |> Enum.map(fn cat ->
-        Map.put(cat, :impact, Map.get(impact_map, to_string(cat.key), 1))
-      end)
-
-    {overall_score, overall_grade} = Grader.overall_score(all_categories, grade_scale, impact_map)
-
-    metadata = build_metadata(analysis_results)
-
-    all_cosines =
-      SampleRunner.diagnose_aggregate(aggregate, top: 99_999, languages: project_langs)
-
-    top_issues = Enum.take(all_cosines, 10)
-
-    codebase_cosine_lookup =
-      Map.new(all_cosines, fn i -> {{i.category, i.behavior}, i.cosine} end)
-
-    top_blocks = TopBlocks.build(analysis_results, changed_files, codebase_cosine_lookup)
-
-    {codebase_delta, pr_summary} =
-      if base_results do
-        build_delta_and_summary(
-          base_results,
-          analysis_results,
-          overall_score,
-          overall_grade,
-          all_categories,
-          categories,
-          grade_scale,
-          impact_map,
-          combined_top,
-          changed_files,
-          top_blocks
-        )
-      else
-        {nil, nil}
-      end
-
-    %{
-      metadata: metadata,
-      pr_summary: pr_summary,
-      overall_score: overall_score,
-      overall_grade: overall_grade,
-      codebase_delta: codebase_delta,
-      categories: all_categories,
-      top_issues: top_issues,
-      top_blocks: top_blocks
-    }
-  end
-
-  @spec to_markdown(map(), atom(), atom()) :: String.t()
-  def to_markdown(report, detail \\ :default, format \\ :plain) do
-    Formatter.format_markdown(report, detail, format)
-  end
-
-  defp build_delta_and_summary(
-         base_results,
-         head_results,
-         head_score,
-         head_grade,
-         head_categories,
-         category_defs,
-         grade_scale,
-         impact_map,
-         combined_top,
-         changed_files,
-         top_blocks
-       ) do
-    delta = Delta.compute(base_results, head_results)
-
-    base_aggregate = get_in(base_results, ["codebase", "aggregate"]) || %{}
-    base_files = Map.get(base_results, "files", %{})
-    base_project_langs = project_languages(base_files)
-
-    base_threshold_grades =
-      category_defs
-      |> Grader.grade_aggregate(base_aggregate, grade_scale)
-      |> Enum.zip(category_defs)
-      |> Enum.map(fn {graded, _cat_def} ->
-        graded
-        |> Map.put(:type, :threshold)
-        |> Map.merge(%{summary: "", worst_offenders: []})
-      end)
-
-    base_worst_files_map =
-      FileScorer.worst_files_per_behavior(base_files, combined_top: combined_top)
-
-    base_cosine_grades =
-      Grader.grade_cosine_categories(
-        base_aggregate,
-        base_worst_files_map,
-        grade_scale,
-        base_project_langs
-      )
-
-    base_all_categories =
-      (base_threshold_grades ++ base_cosine_grades)
-      |> Enum.map(fn cat ->
-        Map.put(cat, :impact, Map.get(impact_map, to_string(cat.key), 1))
-      end)
-
-    {base_score, base_grade} = Grader.overall_score(base_all_categories, grade_scale, impact_map)
-
-    blocks_flagged = Enum.sum(Enum.map(top_blocks, fn g -> length(g.blocks) end))
-    files_added = Enum.count(changed_files, &(&1.status == "added"))
-    files_modified = Enum.count(changed_files, &(&1.status == "modified"))
-
-    summary = %{
-      base_score: base_score,
-      head_score: head_score,
-      score_delta: head_score - base_score,
-      base_grade: base_grade,
-      head_grade: head_grade,
-      blocks_flagged: blocks_flagged,
-      files_changed: length(changed_files),
-      files_added: files_added,
-      files_modified: files_modified
-    }
-
-    {delta, summary}
-  end
-
-  defp build_metadata(analysis_results) do
-    meta = Map.get(analysis_results, "metadata", %{})
-
-    %{
-      path: meta["path"] || "unknown",
-      timestamp: meta["timestamp"] || DateTime.utc_now() |> DateTime.to_iso8601(),
-      total_files: meta["total_files"] || map_size(Map.get(analysis_results, "files", %{}))
-    }
-  end
-
-  defp project_languages(files_map) do
-    files_map
-    |> Map.keys()
-    |> Enum.map(&CodeQA.Language.detect(&1).name())
-    |> Enum.reject(&(&1 == "unknown"))
-    |> Enum.uniq()
-  end
-
-  defp build_category_summary(%{type: :cosine}), do: ""
-
-  defp build_category_summary(graded) do
-    low_scorers =
-      graded.metric_scores
-      |> Enum.filter(fn m -> m.score < 60 end)
-      |> length()
-
-    cond do
-      graded.score >= 90 -> "Excellent"
-      graded.score >= 70 and low_scorers == 0 -> "Good"
-      graded.score >= 70 -> "Good overall, #{low_scorers} metric(s) need attention"
-      graded.score >= 50 -> "Needs improvement"
-      true -> "Critical — requires attention"
-    end
-  end
-end
-```
-
-- [ ] **Step 4: Run tests**
-
-```bash
-mix test test/codeqa/health_report_test.exs --trace
-```
-
-Expected: new tests PASS.
-
-- [ ] **Step 5: Run full suite to check for regressions**
-
-```bash
-mix test
-```
-
-Fix any test that asserts on `worst_offenders` being non-empty in the report output — those assertions should now expect `[]`.
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add lib/codeqa/health_report.ex test/codeqa/health_report_test.exs
-git commit -m "feat(health-report): add top_blocks, pr_summary, codebase_delta; drop worst_offenders"
-```
-
----
-
-## Task 5: Update plain formatter
-
-**Files:**
-- Modify: `lib/codeqa/health_report/formatter/plain.ex`
-- Modify: `test/codeqa/health_report/formatter_test.exs`
-
-- [ ] **Step 1: Delete failing worst_offenders tests and add new tests**
-
-In `test/codeqa/health_report/formatter_test.exs`:
-
-**Delete** these tests (they assert on worst_offenders rendering that is now gone):
-- `"includes worst offenders section"` (lines 186–194)
-- `"renders cosine worst offenders per behavior"` (lines 216–226)
-
-**Update** `"summary detail omits category sections"` (line 196) — change to:
-```elixir
-test "summary detail omits category sections" do
-  result = Formatter.format_markdown(@sample_report, :summary, :plain)
-  refute result =~ "Codebase averages"
-end
-```
-
-**Add** these tests after the existing plain describe blocks:
-
-```elixir
-describe "plain formatter: PR summary section" do
-  @sample_report_with_pr Map.put(@sample_report, :pr_summary, %{
-    base_score: 85,
-    head_score: 77,
-    score_delta: -8,
-    base_grade: "B+",
-    head_grade: "C+",
-    blocks_flagged: 6,
-    files_changed: 3,
-    files_added: 1,
-    files_modified: 2
-  })
-
-  test "renders PR summary line when pr_summary present" do
-    result = Formatter.format_markdown(@sample_report_with_pr, :default, :plain)
-    assert result =~ "B+"
-    assert result =~ "C+"
-    assert result =~ "-8"
-    assert result =~ "6"
-    assert result =~ "1 added"
-    assert result =~ "2 modified"
-  end
-
-  test "omits PR summary when pr_summary is nil" do
-    result = Formatter.format_markdown(@sample_report, :default, :plain)
-    refute result =~ "Score:"
-  end
-end
-
-describe "plain formatter: delta section" do
-  @delta %{
-    base: %{aggregate: %{"readability" => %{"mean_flesch_adapted" => 65.0}, "halstead" => %{"mean_difficulty" => 12.0}}},
-    head: %{aggregate: %{"readability" => %{"mean_flesch_adapted" => 61.0}, "halstead" => %{"mean_difficulty" => 15.0}}}
-  }
-
-  @sample_report_with_delta Map.put(@sample_report, :codebase_delta, @delta)
-
-  test "renders metric changes table when codebase_delta present" do
-    result = Formatter.format_markdown(@sample_report_with_delta, :default, :plain)
-    assert result =~ "Metric Changes"
-    assert result =~ "Readability"
-    assert result =~ "65.00"
-    assert result =~ "61.00"
-  end
-
-  test "omits delta section when codebase_delta is nil" do
-    result = Formatter.format_markdown(@sample_report, :default, :plain)
-    refute result =~ "Metric Changes"
-  end
-end
-
-describe "plain formatter: block section" do
-  @block_potential %{
-    category: "function_design",
-    behavior: "cyclomatic_complexity_under_10",
-    cosine_delta: 0.41,
-    severity: :critical,
-    fix_hint: "Reduce branching"
-  }
-
-  @top_blocks [
-    %{
-      path: "lib/foo.ex",
-      status: "modified",
-      blocks: [
-        %{
-          start_line: 42,
-          end_line: 67,
-          type: "code",
-          token_count: 84,
-          potentials: [@block_potential]
-        }
-      ]
-    }
-  ]
-
-  @sample_report_with_blocks Map.put(@sample_report, :top_blocks, @top_blocks)
-
-  test "renders block section header" do
-    result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
-    assert result =~ "Blocks"
-    assert result =~ "1 flagged"
-  end
-
-  test "renders file group with status" do
-    result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
-    assert result =~ "lib/foo.ex"
-    assert result =~ "modified"
-  end
-
-  test "renders block location and type" do
-    result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
-    assert result =~ "lines 42"
-    assert result =~ "67"
-    assert result =~ "84 tokens"
-  end
-
-  test "renders severity icon and behavior" do
-    result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
-    assert result =~ "🔴"
-    assert result =~ "CRITICAL"
-    assert result =~ "cyclomatic_complexity_under_10"
-    assert result =~ "0.41"
-  end
-
-  test "renders fix hint" do
-    result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
-    assert result =~ "Reduce branching"
-  end
-
-  test "omits block section when top_blocks is empty" do
-    report = Map.put(@sample_report, :top_blocks, [])
-    result = Formatter.format_markdown(report, :default, :plain)
-    refute result =~ "## Blocks"
-  end
-
-  test "omits block section when top_blocks key absent" do
-    result = Formatter.format_markdown(@sample_report, :default, :plain)
-    refute result =~ "## Blocks"
-  end
-end
-```
-
-- [ ] **Step 2: Run formatter tests to confirm failures**
-
-```bash
-mix test test/codeqa/health_report/formatter_test.exs --trace
-```
-
-Expected: new tests FAIL, deleted tests no longer present.
-
-- [ ] **Step 3: Update `lib/codeqa/health_report/formatter/plain.ex`**
-
-Replace the `render/2` function and remove `cosine_worst_offenders/2` + `worst_offenders_section/2`. Add new section functions:
-
-```elixir
-@spec render(map(), atom()) :: String.t()
-def render(report, detail) do
-  [
-    pr_summary_section(Map.get(report, :pr_summary)),
-    header(report),
-    cosine_legend(),
-    delta_section(Map.get(report, :codebase_delta)),
-    overall_table(report),
-    top_issues_section(Map.get(report, :top_issues, []), detail),
-    blocks_section(Map.get(report, :top_blocks, [])),
-    category_sections(report.categories, detail)
-  ]
-  |> List.flatten()
-  |> Enum.join("\n")
-end
-```
-
-Remove `cosine_worst_offenders/2` (lines 91–116) and `worst_offenders_section/2` (lines 196–235) entirely.
-
-Update `render_category/2` for cosine — remove the `cosine_worst_offenders` call:
-
-```elixir
-defp render_category(%{type: :cosine} = cat, _detail) do
-  cosine_section_header(cat) ++ cosine_behaviors_table(cat)
-end
-
-defp render_category(cat, _detail) do
-  section_header(cat) ++ metric_detail(cat)
-end
-```
-
-Add the three new private functions at the bottom of the module:
-
-```elixir
-defp pr_summary_section(nil), do: []
-
-defp pr_summary_section(summary) do
-  delta_str =
-    if summary.score_delta >= 0,
-      do: "+#{summary.score_delta}",
-      else: "#{summary.score_delta}"
-
-  status_str = "#{summary.files_modified} modified, #{summary.files_added} added"
-
-  [
-    "> **Score:** #{summary.base_grade} → #{summary.head_grade}  |  **Δ** #{delta_str} pts  |  **#{summary.blocks_flagged}** blocks flagged across #{summary.files_changed} files  |  #{status_str}",
-    ""
-  ]
-end
-
-defp delta_section(nil), do: []
-
-defp delta_section(delta) do
-  base_agg = delta.base.aggregate
-  head_agg = delta.head.aggregate
-
-  metrics = [
-    {"Readability", "readability", "mean_flesch_adapted"},
-    {"Complexity", "halstead", "mean_difficulty"},
-    {"Duplication", "compression", "mean_redundancy"},
-    {"Structure", "branching", "mean_branch_count"}
-  ]
-
-  rows =
-    Enum.flat_map(metrics, fn {label, group, key} ->
-      base_val = get_in(base_agg, [group, key])
-      head_val = get_in(head_agg, [group, key])
-
-      if is_number(base_val) and is_number(head_val) do
-        diff = Float.round(head_val - base_val, 2)
-        diff_str = if diff >= 0, do: "+#{format_num(diff)}", else: "#{format_num(diff)}"
-        ["| #{label} | #{format_num(base_val)} | #{format_num(head_val)} | #{diff_str} |"]
-      else
-        []
-      end
-    end)
-
-  if rows == [] do
-    []
-  else
-    [
-      "## Metric Changes",
-      "",
-      "| Category | Base | Head | Δ |",
-      "|----------|------|------|---|"
-      | rows
-    ] ++ [""]
-  end
-end
-
-defp blocks_section([]), do: []
-
-defp blocks_section(top_blocks) do
-  total = Enum.sum(Enum.map(top_blocks, fn g -> length(g.blocks) end))
-
-  file_parts =
-    Enum.flat_map(top_blocks, fn group ->
-      status_str = if group.status, do: "  [#{group.status}]", else: ""
-
-      block_lines =
-        Enum.flat_map(group.blocks, fn block ->
-          end_line = block.end_line || block.start_line
-          header = "**lines #{block.start_line}–#{end_line}** · #{block.type} · #{block.token_count} tokens"
-
-          potential_lines =
-            Enum.flat_map(block.potentials, fn p ->
-              icon = severity_icon(p.severity)
-              delta_str = format_num(p.cosine_delta)
-              label = "#{String.upcase(to_string(p.severity))}"
-              line = "  #{icon} #{label}  #{p.category} / #{p.behavior}  (Δ #{delta_str})"
-              fix = if p.fix_hint, do: ["    → #{p.fix_hint}"], else: []
-              [line | fix]
-            end)
-
-          [header | potential_lines] ++ [""]
-        end)
-
-      ["### #{group.path}#{status_str}", "" | block_lines]
-    end)
-
-  [
-    "## Blocks  (#{total} flagged across #{length(top_blocks)} files)",
-    ""
-    | file_parts
-  ]
-end
-
-defp severity_icon(:critical), do: "🔴"
-defp severity_icon(:high), do: "🟠"
-defp severity_icon(:medium), do: "🟡"
-```
-
-- [ ] **Step 4: Run formatter tests**
-
-```bash
-mix test test/codeqa/health_report/formatter_test.exs --trace
-```
-
-Expected: all PASS.
-
-- [ ] **Step 5: Run full suite**
-
-```bash
-mix test
-```
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add lib/codeqa/health_report/formatter/plain.ex test/codeqa/health_report/formatter_test.exs
-git commit -m "feat(formatter): add block, delta, PR summary sections; remove worst_offenders (plain)"
-```
-
----
-
-## Task 6: Update GitHub formatter
-
-**Files:**
-- Modify: `lib/codeqa/health_report/formatter/github.ex`
-- Modify: `test/codeqa/health_report/formatter_test.exs`
-
-- [ ] **Step 1: Add GitHub formatter tests**
-
-In `test/codeqa/health_report/formatter_test.exs`, add a new describe block:
-
-```elixir
-describe "github formatter: block section" do
-  @block_potential %{
-    category: "function_design",
-    behavior: "cyclomatic_complexity_under_10",
-    cosine_delta: 0.41,
-    severity: :critical,
-    fix_hint: "Reduce branching"
-  }
-
-  @top_blocks_gh [
-    %{
-      path: "lib/foo.ex",
-      status: "modified",
-      blocks: [
-        %{start_line: 42, end_line: 67, type: "code", token_count: 84, potentials: [@block_potential]}
-      ]
-    }
-  ]
-
-  @report_with_blocks_gh Map.put(@sample_report, :top_blocks, @top_blocks_gh)
-
-  test "renders block section with details wrapper per file" do
-    result = Formatter.format_markdown(@report_with_blocks_gh, :default, :github)
-    assert result =~ "Blocks"
-    assert result =~ "<details>"
-    assert result =~ "lib/foo.ex"
-    assert result =~ "modified"
-  end
-
-  test "renders severity and fix hint" do
-    result = Formatter.format_markdown(@report_with_blocks_gh, :default, :github)
-    assert result =~ "🔴"
-    assert result =~ "cyclomatic_complexity_under_10"
-    assert result =~ "Reduce branching"
-  end
-end
-
-describe "github formatter: PR summary and delta" do
-  @pr_summary_gh %{
-    base_score: 85, head_score: 77, score_delta: -8,
-    base_grade: "B+", head_grade: "C+",
-    blocks_flagged: 6, files_changed: 3, files_added: 1, files_modified: 2
-  }
-
-  @delta_gh %{
-    base: %{aggregate: %{"readability" => %{"mean_flesch_adapted" => 65.0}}},
-    head: %{aggregate: %{"readability" => %{"mean_flesch_adapted" => 61.0}}}
-  }
-
-  test "renders PR summary" do
-    report = @sample_report |> Map.put(:pr_summary, @pr_summary_gh)
-    result = Formatter.format_markdown(report, :default, :github)
-    assert result =~ "B+"
-    assert result =~ "C+"
-    assert result =~ "-8"
-  end
-
-  test "renders delta section" do
-    report = @sample_report |> Map.put(:codebase_delta, @delta_gh)
-    result = Formatter.format_markdown(report, :default, :github)
-    assert result =~ "Metric Changes"
-    assert result =~ "65.00"
-    assert result =~ "61.00"
-  end
-end
-```
-
-- [ ] **Step 2: Run tests to confirm failures**
-
-```bash
-mix test test/codeqa/health_report/formatter_test.exs --trace 2>&1 | grep -E "FAILED|failure"
-```
-
-- [ ] **Step 3: Update `lib/codeqa/health_report/formatter/github.ex`**
-
-Update `render/3` to include new sections and remove worst_offenders:
-
-```elixir
-def render(report, detail, opts \\ []) do
-  chart? = Keyword.get(opts, :chart, true)
-  display_categories = merge_cosine_categories(report.categories)
-
-  [
-    pr_summary_section(Map.get(report, :pr_summary)),
-    header(report),
-    cosine_legend(),
-    delta_section(Map.get(report, :codebase_delta)),
-    if(chart?, do: mermaid_chart(display_categories), else: []),
-    progress_bars(display_categories),
-    top_issues_section(Map.get(report, :top_issues, []), detail),
-    blocks_section(Map.get(report, :top_blocks, [])),
-    category_sections(display_categories, detail),
-    footer()
-  ]
-  |> List.flatten()
-  |> Enum.join("\n")
-end
-```
-
-Remove `cosine_worst_offenders/2` (lines 254–304) and `worst_offenders/2` (lines 384–435).
-
-Update `cosine_section_content/2` — remove the call to `cosine_worst_offenders`:
-
-```elixir
-defp cosine_section_content(cat, _detail) do
-  # ... existing behaviors_table code ...
-  behaviors_table ++ [""]
-end
-```
-
-Update `section_content/2` — remove the `++ worst_offenders(cat)` at the end (line 381):
-
-```elixir
-defp section_content(cat, _detail) do
-  # ... existing code without worst_offenders ...
-  [
-    "Codebase averages: #{metric_summary}",
-    ""
-    | metrics_table
-  ] ++ [""]
-end
-```
-
-Add new private functions at the bottom:
-
-```elixir
-defp pr_summary_section(nil), do: []
-
-defp pr_summary_section(summary) do
-  delta_str =
-    if summary.score_delta >= 0,
-      do: "+#{summary.score_delta}",
-      else: "#{summary.score_delta}"
-
-  status_str = "#{summary.files_modified} modified, #{summary.files_added} added"
-
-  [
-    "> **Score:** #{summary.base_grade} → #{summary.head_grade}  |  **Δ** #{delta_str} pts  |  **#{summary.blocks_flagged}** blocks flagged across #{summary.files_changed} files  |  #{status_str}",
-    ""
-  ]
-end
-
-defp delta_section(nil), do: []
-
-defp delta_section(delta) do
-  base_agg = delta.base.aggregate
-  head_agg = delta.head.aggregate
-
-  metrics = [
-    {"Readability", "readability", "mean_flesch_adapted"},
-    {"Complexity", "halstead", "mean_difficulty"},
-    {"Duplication", "compression", "mean_redundancy"},
-    {"Structure", "branching", "mean_branch_count"}
-  ]
-
-  rows =
-    Enum.flat_map(metrics, fn {label, group, key} ->
-      base_val = get_in(base_agg, [group, key])
-      head_val = get_in(head_agg, [group, key])
-
-      if is_number(base_val) and is_number(head_val) do
-        diff = Float.round(head_val - base_val, 2)
-        diff_str = if diff >= 0, do: "+#{format_num(diff)}", else: "#{format_num(diff)}"
-        ["| #{label} | #{format_num(base_val)} | #{format_num(head_val)} | #{diff_str} |"]
-      else
-        []
-      end
-    end)
-
-  if rows == [] do
-    []
-  else
-    [
-      "## Metric Changes",
-      "",
-      "| Category | Base | Head | Δ |",
-      "|----------|------|------|---|"
-      | rows
-    ] ++ [""]
-  end
-end
-
-defp blocks_section([]), do: []
-
-defp blocks_section(top_blocks) do
-  total = Enum.sum(Enum.map(top_blocks, fn g -> length(g.blocks) end))
-
-  file_cards =
-    Enum.flat_map(top_blocks, fn group ->
-      status_str = if group.status, do: " [#{group.status}]", else: ""
-      summary_line = "🔍 #{group.path}#{status_str} — #{length(group.blocks)} block(s)"
-
-      block_lines =
-        Enum.flat_map(group.blocks, fn block ->
-          end_line = block.end_line || block.start_line
-
-          potential_lines =
-            Enum.flat_map(block.potentials, fn p ->
-              icon = severity_icon(p.severity)
-              delta_str = format_num(p.cosine_delta)
-              label = String.upcase(to_string(p.severity))
-              line = "**#{icon} #{label}** `#{p.category}/#{p.behavior}` (Δ #{delta_str})"
-              fix = if p.fix_hint, do: ["> #{p.fix_hint}"], else: []
-              [line | fix]
-            end)
-
-          ["**lines #{block.start_line}–#{end_line}** · #{block.type} · #{block.token_count} tokens"] ++
-            potential_lines ++ [""]
-        end)
-
-      inner = List.flatten(block_lines) |> Enum.join("\n")
-
-      [
-        "<details>",
-        "<summary>#{summary_line}</summary>",
-        "",
-        inner,
-        "</details>",
-        ""
-      ]
-    end)
-
-  [
-    "## 🔍 Blocks  (#{total} flagged across #{length(top_blocks)} files)",
-    ""
-    | file_cards
-  ]
-end
-
-defp severity_icon(:critical), do: "🔴"
-defp severity_icon(:high), do: "🟠"
-defp severity_icon(:medium), do: "🟡"
-```
-
-- [ ] **Step 4: Run formatter tests**
-
-```bash
-mix test test/codeqa/health_report/formatter_test.exs --trace
-```
-
-Expected: all PASS.
-
-- [ ] **Step 5: Run full suite**
-
-```bash
-mix test
-```
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add lib/codeqa/health_report/formatter/github.ex test/codeqa/health_report/formatter_test.exs
-git commit -m "feat(formatter): add block, delta, PR summary sections; remove worst_offenders (github)"
-```
-
----
-
-## Task 7: Update `CLI.HealthReport`
-
-**Files:**
-- Modify: `lib/codeqa/cli/health_report.ex`
-
-- [ ] **Step 1: Update `@command_options` and usage string**
-
-In `lib/codeqa/cli/health_report.ex`, add to `@command_options`:
-
-```elixir
-@command_options [
-  output: :string,
-  config: :string,
-  detail: :string,
-  top: :integer,
-  format: :string,
-  ignore_paths: :string,
-  base_ref: :string,
-  head_ref: :string
-]
-```
-
-Add to the usage string:
-
-```
-      --base-ref REF        Base git ref for PR comparison (enables delta and block scoping)
-      --head-ref REF        Head git ref (default: HEAD)
-```
-
-- [ ] **Step 2: Update `run/1` to wire dual analysis**
-
-Replace the `run/1` body (keeping the existing single-pass as the fallback when no `--base-ref`). The full updated `run/1`:
-
-```elixir
-def run(args) do
-  {opts, [path], _} = Options.parse(args, @command_options, o: :output)
-  Options.validate_dir!(path)
-  extra_ignore_patterns = Options.parse_ignore_paths(opts[:ignore_paths])
-
-  base_ref = opts[:base_ref]
-  head_ref = opts[:head_ref] || "HEAD"
-
-  files =
-    CodeQA.Engine.Collector.collect_files(path, extra_ignore_patterns)
-
-  if map_size(files) == 0 do
-    IO.puts(:stderr, "Warning: no source files found in '#{path}'")
-    exit({:shutdown, 1})
-  end
-
-  IO.puts(:stderr, "Analyzing #{map_size(files)} files for health report...")
-
-  analyze_opts =
-    Options.build_analyze_opts(opts) ++ CodeQA.Config.near_duplicate_blocks_opts()
-
-  start_time = System.monotonic_time(:millisecond)
-  results = CodeQA.Engine.Analyzer.analyze_codebase(files, analyze_opts)
-  end_time = System.monotonic_time(:millisecond)
-
-  IO.puts(:stderr, "Analysis completed in #{end_time - start_time}ms")
-
-  nodes_top = opts[:nodes_top] || 3
-  results = CodeQA.BlockImpactAnalyzer.analyze(results, files, nodes_top: nodes_top)
-
-  total_bytes = results["files"] |> Map.values() |> Enum.map(& &1["bytes"]) |> Enum.sum()
-
-  results =
-    Map.put(results, "metadata", %{
-      "path" => Path.expand(path),
-      "timestamp" => DateTime.utc_now() |> DateTime.to_iso8601(),
-      "total_files" => map_size(files),
-      "total_bytes" => total_bytes
-    })
-
-  {base_results, changed_files} =
-    if base_ref do
-      IO.puts(:stderr, "Collecting base snapshot at #{base_ref}...")
-      base_files = CodeQA.Git.collect_files_at_ref(path, base_ref)
-      changed = CodeQA.Git.changed_files(path, base_ref, head_ref)
-
-      IO.puts(:stderr, "Analyzing base snapshot (#{map_size(base_files)} files)...")
-      base_res = CodeQA.Engine.Analyzer.analyze_codebase(base_files, analyze_opts)
-
-      {base_res, changed}
-    else
-      {nil, []}
-    end
-
-  detail = parse_detail(opts[:detail])
-  format = parse_format(opts[:format])
-  top_n = opts[:top] || 5
-
-  report =
-    CodeQA.HealthReport.generate(results,
-      config: opts[:config],
-      detail: detail,
-      top: top_n,
-      base_results: base_results,
-      changed_files: changed_files
-    )
-
-  markdown = CodeQA.HealthReport.to_markdown(report, detail, format)
-
-  case opts[:output] do
-    nil ->
-      markdown
-
-    file ->
-      File.write!(file, markdown)
-      IO.puts(:stderr, "Health report written to #{file}")
-      ""
-  end
-end
-```
-
-- [ ] **Step 3: Run full test suite**
-
-```bash
-mix test
-```
-
-Expected: all PASS (no tests for git integration at this stage — the git calls require an actual repo with refs, which integration tests would mock or skip).
-
-- [ ] **Step 4: Commit**
-
-```bash
-git add lib/codeqa/cli/health_report.ex
-git commit -m "feat(cli): add --base-ref/--head-ref to health-report for PR delta and block scoping"
-```
-
----
-
-## Task 8: Delete compare command and related files
-
-**Files:**
-- Delete: `lib/codeqa/cli/compare.ex`
-- Delete: `lib/codeqa/comparator.ex`
-- Delete: `lib/codeqa/formatter.ex`
-- Delete: `lib/codeqa/summarizer.ex`
-- Delete: `test/codeqa/cli_compare_test.exs`
-- Modify: `lib/codeqa/cli.ex`
-
-- [ ] **Step 1: Remove compare from the CLI router**
-
-Read `lib/codeqa/cli.ex` and remove the line that registers `compare` (line 6). It will look like:
-
-```elixir
-"compare" => CodeQA.CLI.Compare,
-```
-
-Remove that entry entirely.
-
-- [ ] **Step 2: Delete the four source files**
-
-```bash
-rm lib/codeqa/cli/compare.ex lib/codeqa/comparator.ex lib/codeqa/formatter.ex lib/codeqa/summarizer.ex
-```
-
-- [ ] **Step 3: Delete compare tests**
-
-```bash
-rm test/codeqa/cli_compare_test.exs
-```
-
-- [ ] **Step 4: Verify no remaining references**
-
-```bash
-grep -r "CLI\.Compare\|CodeQA\.Comparator\|CodeQA\.Formatter\b\|CodeQA\.Summarizer" lib/ test/ --include="*.ex" --include="*.exs"
-```
-
-Expected: no output.
-
-- [ ] **Step 5: Run full test suite**
-
-```bash
-mix test
-```
-
-Expected: all PASS, no references to deleted modules.
-
-- [ ] **Step 6: Commit**
-
-```bash
-git add -A
-git commit -m "feat(cli): delete compare command — absorbed into health-report"
-```
-
----
diff --git a/docs/superpowers/specs/2026-03-20-health-report-blocks-and-delta.md b/docs/superpowers/specs/2026-03-20-health-report-blocks-and-delta.md
deleted file mode 100644
index 75f2013..0000000
--- a/docs/superpowers/specs/2026-03-20-health-report-blocks-and-delta.md
+++ /dev/null
@@ -1,312 +0,0 @@
-# Health Report: Block Impact Section, PR Delta, and Compare Consolidation
-
-**Date:** 2026-03-20
-**Status:** Approved for implementation
-
----
-
-## Goal
-
-Unify the health-report and compare commands into a single PR-aware report that:
-
-1. Shows impactful code blocks per changed file with severity and fix hints
-2. Shows a before/after metric delta with bar graphs when a base ref is provided
-3. Shows a PR impact summary at the top of the report
-4. Removes file-level worst_offenders (replaced by block-level view)
-5. Deletes the compare command entirely
-
----
-
-## User Stories Addressed
-
-| User | Need | How addressed |
-|------|------|---------------|
-| PR author | Find antipatterns by file and line | Block section: file-grouped, line-precise, behavior + fix hint |
-| Reviewer | Estimate merge risk quickly | PR impact summary: score drift, blocks flagged, files changed |
-| Reviewer | Spot quality regressions | Block severity label + delta bar graphs |
-| New repo user | Assess overall code quality | Overall grade + category breakdown (unchanged) |
-
----
-
-## Architecture
-
-### What Changes
-
-| Component | Change |
-|-----------|--------|
-| `CLI.HealthReport` | Add `--base-ref`, `--head-ref` flags; wire git diff and dual analysis |
-| `HealthReport.generate/2` | Accept `changed_files` + `base_results` opts; add `top_blocks` and `codebase_delta` keys; drop `worst_offenders` |
-| `HealthReport.Delta` | New module — wraps delta computation (logic ported from `Comparator`) |
-| `HealthReport.Formatter` | Remove worst_offenders rendering; add PR summary, delta bar graphs, block section |
-| `BlockImpactAnalyzer` | Add `end_line` to serialized node output |
-| `CLI.Compare` | **Deleted** |
-| `Comparator` | **Deleted** (logic moved to `HealthReport.Delta`) |
-| `lib/codeqa/formatter.ex` | **Deleted** (compare-only formatter — confirmed no health-report usage) |
-| `Summarizer` | **Deleted** (confirmed compare-only) |
-
-### What Stays the Same
-
-- Overall score, grade, categories (threshold + cosine)
-- `top_issues` (SampleRunner diagnose_aggregate)
-- Metadata section
-- All analysis options (workers, cache, timeout, NCD flags)
-- Backward compatibility: running without `--base-ref` produces the existing report minus worst_offenders
-
----
-
-## Data Flow
-
-### With `--base-ref`
-
-```
-CLI.HealthReport
-  ├── Git.collect_files_at_ref(path, base_ref) → base_files_map
-  ├── Git.collect_files_at_ref(path, head_ref) → head_files_map  (head_ref defaults to HEAD)
-  ├── Git.changed_files(path, base_ref, head_ref) → [%ChangedFile{path, status}]
-  ├── Analyzer.analyze_codebase(head_files_map) → head_results
-  ├── BlockImpactAnalyzer.analyze(head_results, head_files_map) → head_results_with_nodes
-  ├── Analyzer.analyze_codebase(base_files_map) → base_results
-  └── HealthReport.generate(head_results_with_nodes,
-        base_results: base_results,
-        changed_files: [%ChangedFile{path, status}])   # full structs, not just paths
-```
-
-### Without `--base-ref`
-
-```
-CLI.HealthReport
-  ├── Analyzer.analyze_codebase(files_map) → results
-  ├── BlockImpactAnalyzer.analyze(results, files_map) → results_with_nodes
-  └── HealthReport.generate(results_with_nodes)
-      (no delta, blocks shown for all files with significant impact, status: nil)
-```
-
----
-
-## CLI Options
-
-Added to `codeqa health-report <path>`:
-
-| Option | Default | Description |
-|--------|---------|-------------|
-| `--base-ref REF` | (none) | Base git ref to compare from. Enables delta and PR scoping. |
-| `--head-ref REF` | `HEAD` | Head git ref for comparison |
-
-Removed: `--changes-only` (never used; always analyzes all files).
-
----
-
-## `HealthReport.generate/2` Output Shape
-
-```elixir
-%{
-  metadata: %{path, timestamp, total_files},
-  pr_summary: %{                          # nil when no base_results
-    base_score: integer(),
-    head_score: integer(),
-    score_delta: integer(),               # head - base
-    base_grade: String.t(),
-    head_grade: String.t(),
-    blocks_flagged: integer(),            # derived: Enum.sum(Enum.map(top_blocks, &length(&1.blocks)))
-    files_changed: integer(),
-    files_added: integer(),
-    files_modified: integer()
-  },
-  overall_score: integer(),
-  overall_grade: String.t(),
-  codebase_delta: map() | nil,            # nil when no base_results
-  categories: [category_map],             # worst_offenders removed from each
-  top_issues: [behavior_map],
-  top_blocks: [file_block_group]          # new
-}
-```
-
-### `pr_summary` Computation Notes
-
-- `base_score` / `base_grade`: requires running the full grading pipeline on `base_results` (same `Grader.grade_aggregate` + `Grader.overall_score` calls as for head). This is a second pass over base data — not a shortcut.
-- `blocks_flagged`: computed after `top_blocks` is assembled (sum of all blocks across all file groups).
-- `files_added` / `files_modified`: counted from `changed_files` structs (`:status` field).
-
-### `top_blocks` Shape
-
-```elixir
-[
-  %{
-    path: String.t(),
-    status: "added" | "modified" | nil,  # nil when no base_results (no --base-ref)
-    blocks: [
-      %{
-        start_line: integer(),
-        end_line: integer(),
-        type: String.t(),                 # "code" | "doc" | "typespec"
-        token_count: integer(),
-        potentials: [
-          %{
-            category: String.t(),
-            behavior: String.t(),
-            cosine_delta: float(),
-            severity: :critical | :high | :medium,
-            fix_hint: String.t() | nil    # nil if not defined for that behavior
-          }
-        ]
-      }
-    ]
-  }
-]
-```
-
-### Severity Computation
-
-Severity is computed during `top_blocks` assembly in `HealthReport.generate/2`, not in `BlockImpactAnalyzer`. The baseline codebase cosine scores are already available via `SampleRunner.diagnose_aggregate(baseline_codebase_agg, top: 99_999, languages: project_langs)` — the same call already made for `top_issues`. Pass these as a lookup map `%{{category, behavior} => codebase_cosine}` into the block assembly step.
-
-For each `{behavior, cosine_delta}` on a block:
-
-```
-codebase_cosine = lookup codebase cosine for that {category, behavior}
-                  (default to 0.0 if behavior not found in codebase diagnose)
-gap = max(0.01, 1.0 - codebase_cosine)   # floor prevents division by zero
-severity_ratio = cosine_delta / gap       # fraction of existing gap this block causes
-
-:critical  when severity_ratio > 0.50
-:high      when severity_ratio > 0.25
-:medium    when severity_ratio > 0.10
-(filtered) when severity_ratio <= 0.10   (below significance, not shown)
-```
-
-**Note on thresholds:** These are initial defaults. The gap-relative formula means a block with `cosine_delta = 0.12` may be `:critical` in a healthy codebase (small gap) and `:medium` in a poor one (large gap). This is intentional — severity reflects impact relative to where the codebase currently stands. Thresholds should be validated against real codebases and are configurable in future iterations.
-
-### Fix Hint Enrichment
-
-Fix hints are sourced from the combined_metrics YAMLs (`priv/combined_metrics/<category>.yml`, `_fix_hint` key per behavior). All 12 category YAMLs have `_fix_hint` fields. Enrichment happens during `top_blocks` assembly in `HealthReport.generate/2` using `CombinedMetrics.Scorer.all_yamls()` (compiled at module load time). Pattern mirrors the existing `cosine_fix_hint/2` in formatters. If a behavior has no `_fix_hint`, the field is `nil`.
-
-### Block Filtering
-
-A block appears in `top_blocks` when:
-- `token_count >= 10` (already guaranteed by BlockImpactAnalyzer, but re-checked for safety)
-- At least one potential has `severity != filtered` (i.e. `severity_ratio > 0.10`)
-- File path is in `changed_files` paths (when `--base-ref` given) or any file (when not)
-
-Blocks within a file are ordered by their highest `cosine_delta` descending.
-
----
-
-## `BlockImpactAnalyzer` Change: Add `end_line`
-
-The serialized node map in `serialize_node/9` (`block_impact_analyzer.ex:167-175`) currently omits `end_line`. Add it:
-
-```elixir
-%{
-  "start_line"  => node.start_line,
-  "end_line"    => node.end_line,       # ADD THIS
-  "column_start" => ...,
-  ...
-}
-```
-
-The `Node` struct already has `end_line` — this is a one-line addition. The existing test in `block_impact_analyzer_test.exs` must also assert `Map.has_key?(node, "end_line")`.
-
----
-
-## `HealthReport.Delta` Module
-
-New module wrapping delta computation, ported from `Comparator`:
-
-```elixir
-@spec compute(base_results :: map(), head_results :: map()) :: map()
-def compute(base_results, head_results)
-```
-
-Returns per-metric aggregate delta (head minus base), porting `compute_aggregate_delta/2` and `compute_numeric_delta/2` from `Comparator`. File-level deltas are not included (compare-only, now removed).
-
----
-
-## Formatter Changes
-
-### Removed
-
-- Worst offenders tables in all category sections (both threshold and cosine):
-  - `plain.ex`: remove calls at lines 60, 64 and functions `cosine_worst_offenders/2` (91-117), `worst_offenders_section/2` (204-245)
-  - `github.ex`: remove calls at lines 249, 381 and functions `cosine_worst_offenders/2` (254-304), `worst_offenders/2` (384-435)
-- All compare-command formatting code (`lib/codeqa/formatter.ex` deleted)
-
-### Added
-
-**1. PR Impact Summary** (top of report, only when `pr_summary` present; omitted entirely when nil)
-
-```
-Score: B+ → C  |  Δ −8 pts  |  6 blocks flagged across 3 files  |  4 modified, 1 added
-```
-
-**2. Delta Bar Graphs** (after PR summary, before categories; only when `codebase_delta` present)
-
-Bar graphs per major category (complexity, readability, duplication, structure) showing base vs head values. Port `progress_bars/2` and `mermaid_chart/1` logic from `lib/codeqa/formatter.ex`. Plain formatter uses ASCII, GitHub formatter uses mermaid.
-
-**3. Block Section** (after top_issues)
-
-```
-## Blocks  (6 flagged across 3 files)
-
-### path/to/file.ex  [modified]
-
-**lines 42–67** · function · 84 tokens
-  🔴 CRITICAL  function_design / cyclomatic_complexity_under_10  (Δ 0.41)
-    → Break this function into smaller single-responsibility functions.
-  🟠 HIGH      structure / deep_nesting  (Δ 0.18)
-    → Flatten nested conditionals using early returns or pattern matching.
-
-**lines 120–134** · code · 31 tokens
-  🟡 MEDIUM    naming / identifier_length  (Δ 0.12)
-    → Use descriptive names that convey intent without abbreviation.
-```
-
-Severity icons: 🔴 CRITICAL, 🟠 HIGH, 🟡 MEDIUM.
-GitHub formatter wraps each file in a `<details><summary>` block (consistent with how categories are already wrapped in `github.ex:137-195`).
-
----
-
-## Deletions
-
-The following files are deleted as part of this work (all confirmed compare-only, no health-report dependencies):
-
-- `lib/codeqa/cli/compare.ex`
-- `lib/codeqa/comparator.ex`
-- `lib/codeqa/formatter.ex`
-- `lib/codeqa/summarizer.ex`
-- `test/codeqa/cli_compare_test.exs`
-
----
-
-## Testing
-
-### New tests required
-
-- Unit tests for `HealthReport.Delta.compute/2`
-- Unit tests for severity computation: all three thresholds, filter boundary, gap floor (gap=0 → floored to 0.01), behavior not found in codebase diagnose (default 0.0)
-- Unit tests for `top_blocks` assembly: filtering by token_count, severity, changed_files; ordering by cosine_delta; fix_hint inclusion and nil case
-- Unit tests for PR summary computation: score/grade computation from base+head, blocks_flagged derivation, file status counts
-- Integration test: `HealthReport.generate/2` with and without `base_results` — verify output keys present/nil correctly
-- Formatter tests: block section renders correctly for plain and github formats; pr_summary nil omits summary and delta sections gracefully
-- CLI test: `--base-ref` wires through to `Git.collect_files_at_ref`, `Git.changed_files`, and `HealthReport.generate` correctly
-- `BlockImpactAnalyzer` test: assert `end_line` present in serialized node
-
-### Tests to delete
-
-- `test/codeqa/cli_compare_test.exs` (entire file)
-- `test/codeqa/health_report/formatter_test.exs:186-194` — "includes worst offenders section"
-- `test/codeqa/health_report/formatter_test.exs:216-226` — "renders cosine worst offenders per behavior"
-
-### Tests to update
-
-- `test/codeqa/health_report/formatter_test.exs:196-200` — "summary detail omits category sections" (refute reason changes)
-- Any test referencing `worst_offenders` in the generate output shape
-- `test/codeqa/block_impact_analyzer_test.exs` — add `end_line` assertion
-
----
-
-## Out of Scope
-
-- Per-block raw metric values (blocks carry cosine_delta only, not raw metrics)
-- File-level delta details (compare's per-file before/after table is dropped)
-- Near-duplicate block pairs in the block section (they exist as metrics but are not surfaced here)
-- Relative severity across blocks (no "this block is Nx worse than average block")
-- Configurable severity thresholds (hardcoded defaults for now; future iteration)
diff --git a/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md b/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md
deleted file mode 100644
index 8ece93b..0000000
--- a/docs/superpowers/specs/2026-03-22-multi-part-pr-comments-design.md
+++ /dev/null
@@ -1,128 +0,0 @@
-# Multi-Part PR Comments Design
-
-**Date:** 2026-03-22
-**Status:** Proposed
-
-## Context
-
-The `codeqa health-report` GitHub Action posts a markdown report as a sticky PR comment via `marocchino/sticky-pull-request-comment@v2`. GitHub's PR comment API has a hard 65,536 character limit. On large codebases (300+ files), the generated report exceeds this limit and the posting step fails.
-
-## Solution
-
-Split the report into fixed-section parts, each posted as a separate sticky PR comment. No content compression — splitting is purely a rendering concern.
-
-## Part Assignment
-
-Parts are fixed, not dynamically determined by content size (except Part 3+ which slices the blocks section).
-
-| Part | Sticky Header | Content |
-|------|--------------|---------|
-| 1 | `codeqa-health-report-1` | Header + overall grade + mermaid chart + progress bars + overall category table + PR summary + metric changes (delta) |
-| 2 | `codeqa-health-report-2` | Top likely issues + all category detail sections (threshold metrics + cosine behaviors) |
-| 3+ | `codeqa-health-report-3`, `codeqa-health-report-4`, … | Blocks section, sliced at 60,000 characters per part |
-
-Each non-final chunk of Part 3+ ends with:
-
-```
-> ⚠️ Truncated at 60,000 chars — continued in next comment
-```
-
-If there are no blocks, Part 3 is written as a single empty part (`""`).
-
-## Formatter Changes
-
-**File:** `lib/codeqa/health_report/formatter/github.ex`
-
-Add three new rendering entry points alongside the existing `render/3`:
-
-- `render_part_1(report, opts)` → `String.t()` — header, summary table, PR summary, delta, mermaid chart, progress bars
-- `render_part_2(report, opts)` → `String.t()` — top issues, all category detail sections
-- `render_parts_3(report, opts)` → `[String.t()]` — blocks section sliced into 60,000-char chunks; returns `["> _No content for this section._"]` when no blocks exist (the CLI does not substitute the placeholder — the formatter is responsible)
-
-**Each rendered part must end with a sentinel HTML comment as its final line:**
-
-```
-<!-- codeqa-health-report-{N} -->
-```
-
-where `N` is the 1-based part index. This sentinel is the sole mechanism by which `run.sh` locates an existing comment to update (the `marocchino` action and its header concept are removed entirely). Without the sentinel, every run would create a new comment instead of updating the previous one.
-
-The existing `render/3` is not changed. It continues to produce the full single-string report for `--output file` usage and does not append a sentinel.
-
-## CLI Changes
-
-**File:** `lib/codeqa/cli/health_report.ex`
-
-Add `render_parts(report, opts)` → `[String.t()]` — returns a flat list `[part_1, part_2, part_3a, part_3b, ...]`. Used internally when the `comment: true` path is active. `comment: true` is an **existing** flag (already parsed from `INPUT_COMMENT` env var in `run.sh` and passed as `--comment` to the CLI); no new flag is introduced.
-
-When writing output for comment mode, the CLI writes each part to a numbered temp file:
-
-- `$TMPDIR/codeqa-part-1.md`
-- `$TMPDIR/codeqa-part-2.md`
-- `$TMPDIR/codeqa-part-3.md`
-- … etc.
-
-It also writes `$TMPDIR/codeqa-part-count.txt` containing the **padded** part count (i.e., `max(actual_parts, 3)`). `run.sh` reads this file to determine how many iterations to perform — it does not infer part count from files on disk. The padding ensures stale cleanup files are always written for at least parts 1–3.
-
-The existing `--output` flag behaviour (write single file) is unchanged.
-
-## Stale Comment Handling
-
-If a previous run produced 4 parts and the current run produces 2, the old parts 3 and 4 remain stale. To handle this, always write a minimum of 3 part files. Parts beyond the actual content get a single-line placeholder:
-
-```
-> _No content for this section._
-```
-
-The sticky comment action overwrites the stale comment with the placeholder rather than leaving old content. The minimum of 3 is sufficient for the current fixed-section design. Real content is written for any blocks overflow to part 4+.
-
-**Known limitation:** if run N produces more than 3 parts (e.g., 5) and run N+1 produces fewer (e.g., 3), parts 4 and 5 from run N remain stale permanently — the minimum-3 floor does not cover them. This is accepted as an edge case; the stale comments are cosmetic (they hold the placeholder text), and a future cleanup step can address it if needed.
-
-## Action / run.sh Changes
-
-**File:** `scripts/run.sh`
-
-After generating part files, loop over them and post each as a sticky PR comment. Use the GitHub REST API directly (`curl -s -X POST/PATCH`) with the following sticky update-or-create logic:
-
-1. Search existing PR comments for one whose body contains the sentinel `<!-- codeqa-health-report-{N} -->` (appended to each part by the formatter)
-2. If found: `PATCH /repos/{owner}/{repo}/issues/comments/{id}` with the new body
-3. If not found: `POST /repos/{owner}/{repo}/issues/{pr_number}/comments` with the new body
-
-Each part's markdown ends with the sentinel HTML comment so future runs can locate and update it:
-
-```
-<!-- codeqa-health-report-{N} -->
-```
-
-This replicates the sticky semantics of `marocchino/sticky-pull-request-comment@v2` without depending on that action for a variable number of posts. `run.sh` uses `GITHUB_TOKEN` (already available in the action environment) and `GITHUB_API_URL`, `GITHUB_REPOSITORY`, and `PR_NUMBER` (sourced from the workflow env).
-
-**File:** `.github/workflows/health-report.yml`
-
-Remove the `marocchino/sticky-pull-request-comment@v2` step. `run.sh` now owns posting entirely. The workflow passes `PR_NUMBER: ${{ github.event.pull_request.number }}` as an env var to the run step.
-
-## Key Constraints
-
-- `render/3` must not change behaviour — used by `--output` flag
-- Part 1 must always be self-contained — a reader seeing only Part 1 gets the full codebase health picture
-- Parts 2 and 3 are drill-down detail; safe to be empty if the codebase has no behaviors or blocks
-- 60,000 char slice limit (not 65,536) leaves headroom for sticky comment metadata
-
-## Breaking Change
-
-The sticky comment header for Part 1 changes from `codeqa-health-report` to `codeqa-health-report-1`. Old single-part comments will not be cleaned up automatically on the first run after upgrade.
-
-## Files Affected
-
-| File | Change |
-|------|--------|
-| `lib/codeqa/health_report/formatter/github.ex` | Add `render_part_1/2`, `render_part_2/2`, `render_parts_3/2` |
-| `lib/codeqa/cli/health_report.ex` | Add `render_parts/2`, multi-file output in comment mode |
-| `scripts/run.sh` | Loop to post multiple part files |
-| `.github/workflows/health-report.yml` | Simplified posting step |
-| `test/codeqa/health_report/formatter_test.exs` | Tests for new part renderers |
-
-## What Does Not Change
-
-- The `--detail`, `--top`, `--format`, `--output` CLI flags
-- The plain formatter (`Formatter.Plain`)
-- Report data assembly (`health_report.ex`, `grader.ex`, `top_blocks.ex`) — splitting is purely a rendering concern

From 4b43621bcf2f260770ea6d2a3cbaa0dd4e891df4 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 26 Mar 2026 15:13:21 +0100
Subject: [PATCH 64/71] chore: ignore README.md and action.yml in codeqa
 analysis

---
 .codeqa.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.codeqa.yml b/.codeqa.yml
index 05b52a5..26f39be 100644
--- a/.codeqa.yml
+++ b/.codeqa.yml
@@ -12,6 +12,8 @@ ignore_paths:
   - test/**
   - devenv*
   - direnv*
+  - README.md
+  - action.yml
 
 # Impact weights for overall score calculation.
 # Combined metric categories default to 1 (can be overridden here).

From fe643c3019d251d6462958e55d8996c248d34f55 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 26 Mar 2026 15:38:57 +0100
Subject: [PATCH 65/71] feat(blocks): show top 10 blocks by impact with source
 code

Replaces the overwhelming "all blocks grouped by file" output with a
focused, actionable view:

- Flatten all blocks across the codebase into a single list
- Rank by highest cosine_delta (strongest anti-pattern signal)
- Take only the top 10 most impactful blocks
- Include actual source code in collapsed <details> blocks
- Show line numbers for easy navigation

This reduces the blocks section from 20+ PR comment parts (hundreds of
KB) to a single compact section that developers can actually act on.

Changes:
- TopBlocks.build/3 now returns flat list of blocks with source code
- Github formatter shows collapsed code blocks with syntax highlighting
- Plain formatter updated to match new structure
- Removed multi-part slicing (no longer needed with top 10 limit)
---
 lib/codeqa/health_report.ex                   |   2 +-
 lib/codeqa/health_report/formatter/github.ex  | 173 ++++++---------
 lib/codeqa/health_report/formatter/plain.ex   |  35 ++-
 lib/codeqa/health_report/top_blocks.ex        |  50 +++--
 test/codeqa/health_report/formatter_test.exs  | 208 ++++++++++--------
 test/codeqa/health_report/top_blocks_test.exs | 105 ++++++---
 test/codeqa/health_report_test.exs            |  15 +-
 7 files changed, 330 insertions(+), 258 deletions(-)

diff --git a/lib/codeqa/health_report.ex b/lib/codeqa/health_report.ex
index e70525b..f97d2f8 100644
--- a/lib/codeqa/health_report.ex
+++ b/lib/codeqa/health_report.ex
@@ -152,7 +152,7 @@ defmodule CodeQA.HealthReport do
 
     {base_score, base_grade} = Grader.overall_score(base_all_categories, grade_scale, impact_map)
 
-    blocks_flagged = Enum.sum(Enum.map(top_blocks, fn g -> length(g.blocks) end))
+    blocks_flagged = length(top_blocks)
     files_added = Enum.count(changed_files, &(&1.status == "added"))
     files_modified = Enum.count(changed_files, &(&1.status == "modified"))
 
diff --git a/lib/codeqa/health_report/formatter/github.ex b/lib/codeqa/health_report/formatter/github.ex
index 03c0b93..b3cf6df 100644
--- a/lib/codeqa/health_report/formatter/github.ex
+++ b/lib/codeqa/health_report/formatter/github.ex
@@ -4,7 +4,6 @@ defmodule CodeQA.HealthReport.Formatter.Github do
   @bar_width 20
   @filled "█"
   @empty "░"
-  @part_char_limit 60_000
 
   @spec render(map(), atom(), keyword()) :: String.t()
   def render(report, detail, opts \\ []) do
@@ -67,89 +66,18 @@ defmodule CodeQA.HealthReport.Formatter.Github do
   end
 
   @doc """
-  Renders Part 3+: blocks section sliced into 60,000-char chunks.
-  Returns a list of strings, one per part. If no blocks, returns a single placeholder.
+  Renders Part 3: blocks section (top 10 blocks with code).
+  Returns a list with a single part since blocks are now limited to top 10.
   """
   @spec render_parts_3(map(), keyword()) :: [String.t()]
   def render_parts_3(report, _opts \\ []) do
     top_blocks = Map.get(report, :top_blocks, [])
 
     if top_blocks == [] do
-      ["> _No content for this section._\n\n" <> sentinel_str(3)]
+      ["> _No near-duplicate blocks detected._\n\n" <> sentinel_str(3)]
     else
       blocks_content = blocks_section(top_blocks) |> List.flatten() |> Enum.join("\n")
-      slice_blocks_content(blocks_content, 3)
-    end
-  end
-
-  defp slice_blocks_content(content, start_part) do
-    slice_blocks_content(content, start_part, [])
-  end
-
-  defp slice_blocks_content("", part_num, acc) do
-    # No more content; finalize the last part if any, or emit placeholder
-    case acc do
-      [] -> ["> _No content for this section._\n\n" <> sentinel_str(part_num)]
-      _ -> Enum.reverse(acc)
-    end
-  end
-
-  defp slice_blocks_content(content, part_num, acc) do
-    sentinel = sentinel_str(part_num)
-    truncation_warning = "\n\n> ⚠️ Truncated at 60,000 chars — continued in next comment\n\n"
-
-    # Reserve space for sentinel and potential truncation warning
-    available = @part_char_limit - byte_size(sentinel) - byte_size(truncation_warning) - 10
-
-    if byte_size(content) <= available + byte_size(truncation_warning) do
-      # Fits in this part
-      final_part = content <> "\n\n" <> sentinel
-      Enum.reverse([final_part | acc])
-    else
-      # Need to split
-      {chunk, rest} = split_at_safe_boundary(content, available)
-      part_content = chunk <> truncation_warning <> sentinel
-      slice_blocks_content(rest, part_num + 1, [part_content | acc])
-    end
-  end
-
-  defp split_at_safe_boundary(content, max_bytes) do
-    # Try to split at a </details> boundary to avoid breaking HTML structure
-    prefix = binary_part(content, 0, min(max_bytes, byte_size(content)))
-
-    case :binary.matches(prefix, "</details>") do
-      [] ->
-        # No good boundary, split at newline
-        split_at_newline(content, max_bytes)
-
-      matches ->
-        {pos, len} = List.last(matches)
-        split_pos = pos + len
-
-        if split_pos > div(max_bytes, 2) do
-          # Good split point
-          {binary_part(content, 0, split_pos),
-           binary_part(content, split_pos, byte_size(content) - split_pos)}
-        else
-          # Too early, try newline
-          split_at_newline(content, max_bytes)
-        end
-    end
-  end
-
-  defp split_at_newline(content, max_bytes) do
-    prefix = binary_part(content, 0, min(max_bytes, byte_size(content)))
-
-    case :binary.matches(prefix, "\n") do
-      [] ->
-        # No newline, hard split
-        {prefix, binary_part(content, byte_size(prefix), byte_size(content) - byte_size(prefix))}
-
-      matches ->
-        {pos, _len} = List.last(matches)
-
-        {binary_part(content, 0, pos),
-         binary_part(content, pos + 1, byte_size(content) - pos - 1)}
+      [blocks_content <> "\n\n" <> sentinel_str(3)]
     end
   end
 
@@ -518,52 +446,79 @@ defmodule CodeQA.HealthReport.Formatter.Github do
   defp blocks_section([]), do: []
 
   defp blocks_section(top_blocks) do
-    total = Enum.sum(Enum.map(top_blocks, fn g -> length(g.blocks) end))
-
-    file_cards =
-      Enum.flat_map(top_blocks, fn group ->
-        status_str = if group.status, do: " [#{group.status}]", else: ""
-        summary_line = "🔍 #{group.path}#{status_str} — #{length(group.blocks)} block(s)"
-
-        inner =
-          group.blocks |> Enum.flat_map(&format_block/1) |> List.flatten() |> Enum.join("\n")
-
-        [
-          "<details>",
-          "<summary>#{summary_line}</summary>",
-          "",
-          inner,
-          "</details>",
-          ""
-        ]
-      end)
+    block_cards = Enum.flat_map(top_blocks, &format_block_card/1)
 
     [
-      "## 🔍 Blocks  (#{total} flagged across #{length(top_blocks)} files)",
+      "## 🔍 Top #{length(top_blocks)} Code Blocks by Impact",
+      "",
+      "> Ranked by cosine delta — highest anti-pattern signal first.",
       ""
-      | file_cards
+      | block_cards
     ]
   end
 
-  defp format_block(block) do
+  defp format_block_card(block) do
     end_line = block.end_line || block.start_line
+    top_potential = List.first(block.potentials)
+    icon = severity_icon(top_potential.severity)
+    delta_str = format_num(top_potential.cosine_delta)
+    status_str = if block.status, do: " [#{block.status}]", else: ""
 
-    header =
-      "**lines #{block.start_line}–#{end_line}** · #{block.type} · #{block.token_count} tokens"
+    summary_line =
+      "#{icon} <code>#{block.path}:#{block.start_line}-#{end_line}</code>#{status_str} — #{block.type} (#{block.token_count} tokens) — Δ#{delta_str}"
 
-    potential_lines = Enum.flat_map(block.potentials, &format_potential/1)
-    [header] ++ potential_lines ++ [""]
+    issues = format_block_issues(block.potentials)
+    code_block = format_code_block(block)
+
+    [
+      "<details>",
+      "<summary>#{summary_line}</summary>",
+      "",
+      "**Issues:**",
+      ""
+      | issues
+    ] ++ ["", code_block, "", "</details>", ""]
+  end
+
+  defp format_block_issues(potentials) do
+    Enum.flat_map(potentials, fn p ->
+      icon = severity_icon(p.severity)
+      label = String.upcase(to_string(p.severity))
+      delta_str = format_num(p.cosine_delta)
+      line = "- #{icon} **#{label}** `#{p.category}/#{p.behavior}` (Δ #{delta_str})"
+      fix = if p.fix_hint, do: ["  > #{p.fix_hint}"], else: []
+      [line | fix]
+    end)
   end
 
-  defp format_potential(p) do
-    icon = severity_icon(p.severity)
-    delta_str = format_num(p.cosine_delta)
-    label = String.upcase(to_string(p.severity))
-    line = "**#{icon} #{label}** `#{p.category}/#{p.behavior}` (Δ #{delta_str})"
-    fix = if p.fix_hint, do: ["> #{p.fix_hint}"], else: []
-    [line | fix]
+  defp format_code_block(%{source: nil}), do: "_Source code not available_"
+
+  defp format_code_block(%{source: source, language: lang, start_line: start_line}) do
+    lang_hint = code_fence_lang(lang)
+    # Add line number comments for context
+    lines = String.split(source, "\n")
+
+    numbered_lines =
+      lines
+      |> Enum.with_index(start_line)
+      |> Enum.map(fn {line, num} -> "#{String.pad_leading(to_string(num), 4)} │ #{line}" end)
+      |> Enum.join("\n")
+
+    "```#{lang_hint}\n#{numbered_lines}\n```"
   end
 
+  defp code_fence_lang("elixir"), do: "elixir"
+  defp code_fence_lang("ruby"), do: "ruby"
+  defp code_fence_lang("javascript"), do: "javascript"
+  defp code_fence_lang("typescript"), do: "typescript"
+  defp code_fence_lang("python"), do: "python"
+  defp code_fence_lang("swift"), do: "swift"
+  defp code_fence_lang("kotlin"), do: "kotlin"
+  defp code_fence_lang("java"), do: "java"
+  defp code_fence_lang("go"), do: "go"
+  defp code_fence_lang("rust"), do: "rust"
+  defp code_fence_lang(_), do: ""
+
   defp severity_icon(:critical), do: "🔴"
   defp severity_icon(:high), do: "🟠"
   defp severity_icon(:medium), do: "🟡"
diff --git a/lib/codeqa/health_report/formatter/plain.ex b/lib/codeqa/health_report/formatter/plain.ex
index 0b99b5c..3576ed6 100644
--- a/lib/codeqa/health_report/formatter/plain.ex
+++ b/lib/codeqa/health_report/formatter/plain.ex
@@ -209,30 +209,41 @@ defmodule CodeQA.HealthReport.Formatter.Plain do
   defp blocks_section([]), do: []
 
   defp blocks_section(top_blocks) do
-    total = Enum.sum(Enum.map(top_blocks, fn g -> length(g.blocks) end))
-
-    file_parts =
-      Enum.flat_map(top_blocks, fn group ->
-        status_str = if group.status, do: "  [#{group.status}]", else: ""
-        block_lines = Enum.flat_map(group.blocks, &format_block/1)
-        ["### #{group.path}#{status_str}", "" | block_lines]
-      end)
+    block_parts = Enum.flat_map(top_blocks, &format_block/1)
 
     [
-      "## Blocks  (#{total} flagged across #{length(top_blocks)} files)",
+      "## Top #{length(top_blocks)} Code Blocks by Impact",
       ""
-      | file_parts
+      | block_parts
     ]
   end
 
   defp format_block(block) do
     end_line = block.end_line || block.start_line
+    status_str = if block.status, do: " [#{block.status}]", else: ""
 
     header =
-      "**lines #{block.start_line}–#{end_line}** · #{block.type} · #{block.token_count} tokens"
+      "### #{block.path}:#{block.start_line}-#{end_line}#{status_str}"
+
+    subheader =
+      "#{block.type} · #{block.token_count} tokens"
 
     potential_lines = Enum.flat_map(block.potentials, &format_potential/1)
-    [header | potential_lines] ++ [""]
+    code_lines = format_code_block(block)
+    [header, subheader, "" | potential_lines] ++ ["" | code_lines] ++ [""]
+  end
+
+  defp format_code_block(%{source: nil}), do: ["_Source code not available_"]
+
+  defp format_code_block(%{source: source, start_line: start_line}) do
+    lines = String.split(source, "\n")
+
+    numbered_lines =
+      lines
+      |> Enum.with_index(start_line)
+      |> Enum.map(fn {line, num} -> "  #{String.pad_leading(to_string(num), 4)} │ #{line}" end)
+
+    ["```" | numbered_lines] ++ ["```"]
   end
 
   defp format_potential(p) do
diff --git a/lib/codeqa/health_report/top_blocks.ex b/lib/codeqa/health_report/top_blocks.ex
index 42a0bfd..57fd933 100644
--- a/lib/codeqa/health_report/top_blocks.ex
+++ b/lib/codeqa/health_report/top_blocks.ex
@@ -8,6 +8,7 @@ defmodule CodeQA.HealthReport.TopBlocks do
   @severity_high 0.25
   @severity_medium 0.10
   @gap_floor 0.01
+  @top_n 10
 
   defp build_fix_hint_lookup do
     Scorer.all_yamls()
@@ -30,6 +31,7 @@ defmodule CodeQA.HealthReport.TopBlocks do
   @spec build(map(), [struct()], map()) :: [map()]
   def build(analysis_results, changed_files, codebase_cosine_lookup) do
     files = Map.get(analysis_results, "files", %{})
+    base_path = get_in(analysis_results, ["metadata", "path"]) || "."
     fix_hints = build_fix_hint_lookup()
 
     file_entries =
@@ -43,21 +45,22 @@ defmodule CodeQA.HealthReport.TopBlocks do
         |> Enum.map(fn {path, data} -> {path, Map.get(changed_index, path), data} end)
       end
 
+    # Flatten all blocks across all files, enrich with path and source code
     file_entries
-    |> Enum.map(fn {path, status, file_data} ->
-      blocks =
-        file_data
-        |> Map.get("nodes", [])
-        |> Enum.flat_map(&collect_nodes/1)
-        |> Enum.filter(&(&1["token_count"] >= @min_tokens))
-        |> Enum.map(&enrich_block(&1, codebase_cosine_lookup, fix_hints))
-        |> Enum.reject(&(&1.potentials == []))
-        |> Enum.sort_by(&(-max_delta(&1)))
-
-      %{path: path, status: status, blocks: blocks}
+    |> Enum.flat_map(fn {path, status, file_data} ->
+      file_data
+      |> Map.get("nodes", [])
+      |> Enum.flat_map(&collect_nodes/1)
+      |> Enum.filter(&(&1["token_count"] >= @min_tokens))
+      |> Enum.map(&enrich_block(&1, codebase_cosine_lookup, fix_hints))
+      |> Enum.reject(&(&1.potentials == []))
+      |> Enum.map(&Map.merge(&1, %{path: path, status: status}))
     end)
-    |> Enum.reject(&(&1.blocks == []))
-    |> Enum.sort_by(& &1.path)
+    # Rank by highest cosine_delta and take top N
+    |> Enum.sort_by(&(-max_delta(&1)))
+    |> Enum.take(@top_n)
+    # Add source code for each block
+    |> Enum.map(&add_source_code(&1, base_path))
   end
 
   defp collect_nodes(node) do
@@ -113,4 +116,25 @@ defmodule CodeQA.HealthReport.TopBlocks do
 
   defp max_delta(%{potentials: potentials}),
     do: Enum.max_by(potentials, & &1.cosine_delta).cosine_delta
+
+  defp add_source_code(block, base_path) do
+    full_path = Path.join(base_path, block.path)
+    start_line = block.start_line
+    end_line = block.end_line || start_line
+
+    source =
+      case File.read(full_path) do
+        {:ok, content} ->
+          content
+          |> String.split("\n")
+          |> Enum.slice((start_line - 1)..(end_line - 1)//1)
+          |> Enum.join("\n")
+
+        {:error, _} ->
+          nil
+      end
+
+    lang = CodeQA.Language.detect(block.path).name()
+    Map.merge(block, %{source: source, language: lang})
+  end
 end
diff --git a/test/codeqa/health_report/formatter_test.exs b/test/codeqa/health_report/formatter_test.exs
index 244091e..1b87051 100644
--- a/test/codeqa/health_report/formatter_test.exs
+++ b/test/codeqa/health_report/formatter_test.exs
@@ -282,15 +282,13 @@ defmodule CodeQA.HealthReport.FormatterTest do
       %{
         path: "lib/foo.ex",
         status: "modified",
-        blocks: [
-          %{
-            start_line: 42,
-            end_line: 67,
-            type: "code",
-            token_count: 84,
-            potentials: [@block_potential]
-          }
-        ]
+        start_line: 42,
+        end_line: 67,
+        type: "code",
+        token_count: 84,
+        source: "def foo do\n  :bar\nend",
+        language: "elixir",
+        potentials: [@block_potential]
       }
     ]
 
@@ -298,11 +296,10 @@ defmodule CodeQA.HealthReport.FormatterTest do
 
     test "renders block section header" do
       result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
-      assert result =~ "Blocks"
-      assert result =~ "1 flagged"
+      assert result =~ "Top 1 Code Blocks by Impact"
     end
 
-    test "renders file group with status" do
+    test "renders file path with status" do
       result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
       assert result =~ "lib/foo.ex"
       assert result =~ "modified"
@@ -310,8 +307,7 @@ defmodule CodeQA.HealthReport.FormatterTest do
 
     test "renders block location and type" do
       result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
-      assert result =~ "lines 42"
-      assert result =~ "67"
+      assert result =~ "42-67"
       assert result =~ "84 tokens"
     end
 
@@ -328,15 +324,21 @@ defmodule CodeQA.HealthReport.FormatterTest do
       assert result =~ "Reduce branching"
     end
 
+    test "renders source code" do
+      result = Formatter.format_markdown(@sample_report_with_blocks, :default, :plain)
+      assert result =~ "def foo do"
+      assert result =~ ":bar"
+    end
+
     test "omits block section when top_blocks is empty" do
       report = Map.put(@sample_report, :top_blocks, [])
       result = Formatter.format_markdown(report, :default, :plain)
-      refute result =~ "## Blocks"
+      refute result =~ "Code Blocks"
     end
 
     test "omits block section when top_blocks key absent" do
       result = Formatter.format_markdown(@sample_report, :default, :plain)
-      refute result =~ "## Blocks"
+      refute result =~ "Code Blocks"
     end
   end
 
@@ -434,23 +436,21 @@ defmodule CodeQA.HealthReport.FormatterTest do
       %{
         path: "lib/foo.ex",
         status: "modified",
-        blocks: [
-          %{
-            start_line: 42,
-            end_line: 67,
-            type: "code",
-            token_count: 84,
-            potentials: [@block_potential]
-          }
-        ]
+        start_line: 42,
+        end_line: 67,
+        type: "code",
+        token_count: 84,
+        source: "def foo do\n  :bar\nend",
+        language: "elixir",
+        potentials: [@block_potential]
       }
     ]
 
     @report_with_blocks_gh Map.put(@sample_report, :top_blocks, @top_blocks_gh)
 
-    test "renders block section with details wrapper per file" do
+    test "renders block section with details wrapper per block" do
       result = Formatter.format_markdown(@report_with_blocks_gh, :default, :github)
-      assert result =~ "Blocks"
+      assert result =~ "Top 1 Code Blocks by Impact"
       assert result =~ "<details>"
       assert result =~ "lib/foo.ex"
       assert result =~ "modified"
@@ -462,6 +462,12 @@ defmodule CodeQA.HealthReport.FormatterTest do
       assert result =~ "cyclomatic_complexity_under_10"
       assert result =~ "Reduce branching"
     end
+
+    test "renders source code in collapsed block" do
+      result = Formatter.format_markdown(@report_with_blocks_gh, :default, :github)
+      assert result =~ "```elixir"
+      assert result =~ "def foo do"
+    end
   end
 
   describe "github formatter: PR summary and delta" do
@@ -538,83 +544,107 @@ defmodule CodeQA.HealthReport.FormatterTest do
 
     test "part 3 is placeholder when no blocks" do
       [_, _, part_3 | _] = Formatter.render_parts(@sample_report)
-      assert part_3 =~ "_No content for this section._"
+      assert part_3 =~ "_No near-duplicate blocks detected._"
     end
 
     test "part 3 contains blocks when present" do
       report = Map.put(@sample_report, :top_blocks, @top_blocks_gh)
       [_, _, part_3 | _] = Formatter.render_parts(report)
       assert part_3 =~ "lib/foo.ex"
-      assert part_3 =~ "Blocks"
+      assert part_3 =~ "Code Blocks"
     end
   end
 
-  describe "Github.render_parts_3/2 slicing" do
+  describe "Github.render_parts_3/2" do
     alias CodeQA.HealthReport.Formatter.Github
 
-    @many_blocks Enum.map(1..100, fn i ->
-                   %{
-                     path: "lib/file_#{i}.ex",
-                     status: "modified",
-                     blocks:
-                       Enum.map(1..10, fn j ->
-                         %{
-                           start_line: j * 10,
-                           end_line: j * 10 + 20,
-                           type: "function",
-                           token_count: 150,
-                           potentials: [
-                             %{
-                               category: "function_design",
-                               behavior: "single_responsibility",
-                               cosine_delta: 0.35,
-                               severity: :high,
-                               fix_hint: "Consider extracting helper function"
-                             }
-                           ]
-                         }
-                       end)
-                   }
-                 end)
-
-    test "slices large blocks section into multiple parts" do
-      report = Map.put(@sample_report, :top_blocks, @many_blocks)
-      parts = Github.render_parts_3(report)
-
-      # With 100 files × 10 blocks, this should produce multiple parts
-      assert length(parts) > 1
-    end
-
-    test "each sliced part ends with sentinel" do
-      report = Map.put(@sample_report, :top_blocks, @many_blocks)
-      parts = Github.render_parts_3(report)
-
-      Enum.with_index(parts, 3)
-      |> Enum.each(fn {part, n} ->
-        assert part =~ "<!-- codeqa-health-report-#{n} -->"
-      end)
-    end
-
-    test "non-final parts have truncation warning" do
-      report = Map.put(@sample_report, :top_blocks, @many_blocks)
-      parts = Github.render_parts_3(report)
-
-      if length(parts) > 1 do
-        non_final = Enum.take(parts, length(parts) - 1)
-
-        Enum.each(non_final, fn part ->
-          assert part =~ "Truncated at 60,000 chars"
+    test "returns single part with blocks (top 10 limit means no slicing needed)" do
+      blocks =
+        Enum.map(1..10, fn i ->
+          %{
+            path: "lib/file_#{i}.ex",
+            status: "modified",
+            start_line: 10,
+            end_line: 30,
+            type: "function",
+            token_count: 150,
+            source: "def foo, do: :bar",
+            language: "elixir",
+            potentials: [
+              %{
+                category: "function_design",
+                behavior: "single_responsibility",
+                cosine_delta: 0.35,
+                severity: :high,
+                fix_hint: "Consider extracting helper function"
+              }
+            ]
+          }
         end)
-      end
-    end
 
-    test "each part is under 65536 chars" do
-      report = Map.put(@sample_report, :top_blocks, @many_blocks)
+      report = Map.put(@sample_report, :top_blocks, blocks)
       parts = Github.render_parts_3(report)
 
-      Enum.each(parts, fn part ->
-        assert byte_size(part) < 65_536, "Part exceeds GitHub comment limit"
-      end)
+      # With top 10 blocks, should be a single part
+      assert length(parts) == 1
+    end
+
+    test "part ends with sentinel" do
+      blocks = [
+        %{
+          path: "lib/foo.ex",
+          status: nil,
+          start_line: 1,
+          end_line: 10,
+          type: "code",
+          token_count: 50,
+          source: "def foo, do: :bar",
+          language: "elixir",
+          potentials: [
+            %{
+              category: "function_design",
+              behavior: "single_responsibility",
+              cosine_delta: 0.35,
+              severity: :high,
+              fix_hint: nil
+            }
+          ]
+        }
+      ]
+
+      report = Map.put(@sample_report, :top_blocks, blocks)
+      [part] = Github.render_parts_3(report)
+      assert part =~ "<!-- codeqa-health-report-3 -->"
+    end
+
+    test "renders source code in fenced block" do
+      blocks = [
+        %{
+          path: "lib/foo.ex",
+          status: nil,
+          start_line: 1,
+          end_line: 10,
+          type: "code",
+          token_count: 50,
+          source: "def hello do\n  :world\nend",
+          language: "elixir",
+          potentials: [
+            %{
+              category: "function_design",
+              behavior: "single_responsibility",
+              cosine_delta: 0.35,
+              severity: :high,
+              fix_hint: nil
+            }
+          ]
+        }
+      ]
+
+      report = Map.put(@sample_report, :top_blocks, blocks)
+      [part] = Github.render_parts_3(report)
+      assert part =~ "```elixir"
+      assert part =~ "def hello do"
+      assert part =~ ":world"
     end
   end
 end
diff --git a/test/codeqa/health_report/top_blocks_test.exs b/test/codeqa/health_report/top_blocks_test.exs
index feb1194..91eb7af 100644
--- a/test/codeqa/health_report/top_blocks_test.exs
+++ b/test/codeqa/health_report/top_blocks_test.exs
@@ -23,7 +23,7 @@ defmodule CodeQA.HealthReport.TopBlocksTest do
   end
 
   defp make_results(nodes) do
-    %{"files" => %{"lib/foo.ex" => %{"nodes" => nodes}}}
+    %{"files" => %{"lib/foo.ex" => %{"nodes" => nodes}}, "metadata" => %{"path" => "/tmp"}}
   end
 
   defp lookup(cosine \\ 0.0) do
@@ -33,20 +33,20 @@ defmodule CodeQA.HealthReport.TopBlocksTest do
   describe "severity classification" do
     test ":critical when severity_ratio > 0.50" do
       # gap = max(0.01, 1.0 - 0.0) = 1.0, ratio = 0.60 / 1.0 = 0.60 > 0.50
-      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup())
-      assert hd(hd(group.blocks).potentials).severity == :critical
+      [block] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup())
+      assert hd(block.potentials).severity == :critical
     end
 
     test ":high when severity_ratio > 0.25 and <= 0.50" do
       # ratio = 0.30 / 1.0 = 0.30
-      [group] = TopBlocks.build(make_results([make_node(0.30)]), [], lookup())
-      assert hd(hd(group.blocks).potentials).severity == :high
+      [block] = TopBlocks.build(make_results([make_node(0.30)]), [], lookup())
+      assert hd(block.potentials).severity == :high
     end
 
     test ":medium when severity_ratio > 0.10 and <= 0.25" do
       # ratio = 0.15 / 1.0 = 0.15
-      [group] = TopBlocks.build(make_results([make_node(0.15)]), [], lookup())
-      assert hd(hd(group.blocks).potentials).severity == :medium
+      [block] = TopBlocks.build(make_results([make_node(0.15)]), [], lookup())
+      assert hd(block.potentials).severity == :medium
     end
 
     test "filtered when severity_ratio <= 0.10" do
@@ -56,30 +56,30 @@ defmodule CodeQA.HealthReport.TopBlocksTest do
 
     test "gap floor prevents division by zero when codebase_cosine = 1.0" do
       # gap = max(0.01, 1.0 - 1.0) = 0.01, ratio = 0.02 / 0.01 = 2.0 → :critical
-      [group] = TopBlocks.build(make_results([make_node(0.02)]), [], lookup(1.0))
-      assert hd(hd(group.blocks).potentials).severity == :critical
+      [block] = TopBlocks.build(make_results([make_node(0.02)]), [], lookup(1.0))
+      assert hd(block.potentials).severity == :critical
     end
 
     test "gap handles negative codebase_cosine" do
       # codebase_cosine = -0.5, gap = max(0.01, 1.0 - (-0.5)) = 1.5
       # ratio = 0.60 / 1.5 = 0.40 → :high
-      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup(-0.5))
-      assert hd(hd(group.blocks).potentials).severity == :high
+      [block] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup(-0.5))
+      assert hd(block.potentials).severity == :high
     end
 
     test "unknown behavior defaults codebase_cosine to 0.0" do
       lookup_empty = %{}
       # gap = 1.0, ratio = 0.60 → :critical
-      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup_empty)
-      assert hd(hd(group.blocks).potentials).severity == :critical
+      [block] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup_empty)
+      assert hd(block.potentials).severity == :critical
     end
   end
 
   describe "changed_files filtering" do
     test "when changed_files is empty, shows all files" do
-      [group] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup())
-      assert group.path == "lib/foo.ex"
-      assert group.status == nil
+      [block] = TopBlocks.build(make_results([make_node(0.60)]), [], lookup())
+      assert block.path == "lib/foo.ex"
+      assert block.status == nil
     end
 
     test "when changed_files given, only shows matching files" do
@@ -89,8 +89,8 @@ defmodule CodeQA.HealthReport.TopBlocksTest do
 
     test "status comes from ChangedFile struct" do
       changed = [%ChangedFile{path: "lib/foo.ex", status: "modified"}]
-      [group] = TopBlocks.build(make_results([make_node(0.60)]), changed, lookup())
-      assert group.status == "modified"
+      [block] = TopBlocks.build(make_results([make_node(0.60)]), changed, lookup())
+      assert block.status == "modified"
     end
   end
 
@@ -102,10 +102,14 @@ defmodule CodeQA.HealthReport.TopBlocksTest do
     test "blocks are ordered by highest cosine_delta descending" do
       node_low = make_node(0.20)
       node_high = put_in(make_node(0.60), ["start_line"], 20)
-      results = %{"files" => %{"lib/foo.ex" => %{"nodes" => [node_low, node_high]}}}
 
-      [group] = TopBlocks.build(results, [], lookup())
-      deltas = Enum.map(group.blocks, fn b -> hd(b.potentials).cosine_delta end)
+      results = %{
+        "files" => %{"lib/foo.ex" => %{"nodes" => [node_low, node_high]}},
+        "metadata" => %{"path" => "/tmp"}
+      }
+
+      blocks = TopBlocks.build(results, [], lookup())
+      deltas = Enum.map(blocks, fn b -> hd(b.potentials).cosine_delta end)
       assert deltas == Enum.sort(deltas, :desc)
     end
 
@@ -119,8 +123,8 @@ defmodule CodeQA.HealthReport.TopBlocksTest do
         "children" => [make_node(0.60)]
       }
 
-      [group] = TopBlocks.build(make_results([parent]), [], lookup())
-      assert length(group.blocks) == 1
+      blocks = TopBlocks.build(make_results([parent]), [], lookup())
+      assert length(blocks) == 1
     end
   end
 
@@ -143,8 +147,8 @@ defmodule CodeQA.HealthReport.TopBlocksTest do
       }
 
       hint_lookup = %{{"naming_conventions", "file_name_matches_primary_export"} => 0.0}
-      [group] = TopBlocks.build(make_results([node]), [], hint_lookup)
-      potential = hd(hd(group.blocks).potentials)
+      [block] = TopBlocks.build(make_results([node]), [], hint_lookup)
+      potential = hd(block.potentials)
       assert is_binary(potential.fix_hint)
     end
 
@@ -160,8 +164,55 @@ defmodule CodeQA.HealthReport.TopBlocksTest do
         "children" => []
       }
 
-      [group] = TopBlocks.build(make_results([node]), [], %{})
-      assert hd(hd(group.blocks).potentials).fix_hint == nil
+      [block] = TopBlocks.build(make_results([node]), [], %{})
+      assert hd(block.potentials).fix_hint == nil
+    end
+  end
+
+  describe "source code extraction" do
+    test "includes source code when file exists" do
+      # Create a temp file
+      tmp_dir = System.tmp_dir!()
+      test_dir = Path.join(tmp_dir, "top_blocks_test_#{:rand.uniform(100_000)}")
+      File.mkdir_p!(test_dir)
+      file_path = Path.join(test_dir, "test.ex")
+      File.write!(file_path, "line 1\nline 2\nline 3\nline 4\nline 5")
+
+      results = %{
+        "files" => %{"test.ex" => %{"nodes" => [make_node(0.60) |> Map.put("end_line", 3)]}},
+        "metadata" => %{"path" => test_dir}
+      }
+
+      [block] = TopBlocks.build(results, [], lookup())
+      assert block.source == "line 1\nline 2\nline 3"
+      assert block.language == "elixir"
+
+      File.rm_rf!(test_dir)
+    end
+
+    test "source is nil when file does not exist" do
+      results = %{
+        "files" => %{"nonexistent.ex" => %{"nodes" => [make_node(0.60)]}},
+        "metadata" => %{"path" => "/nonexistent/path"}
+      }
+
+      [block] = TopBlocks.build(results, [], lookup())
+      assert block.source == nil
+    end
+  end
+
+  describe "top N limiting" do
+    test "returns at most 10 blocks" do
+      # Create 15 nodes
+      nodes = for i <- 1..15, do: put_in(make_node(0.60 + i * 0.01), ["start_line"], i * 10)
+
+      results = %{
+        "files" => %{"lib/foo.ex" => %{"nodes" => nodes}},
+        "metadata" => %{"path" => "/tmp"}
+      }
+
+      blocks = TopBlocks.build(results, [], lookup())
+      assert length(blocks) == 10
     end
   end
 end
diff --git a/test/codeqa/health_report_test.exs b/test/codeqa/health_report_test.exs
index 8d25e4d..80f8575 100644
--- a/test/codeqa/health_report_test.exs
+++ b/test/codeqa/health_report_test.exs
@@ -25,21 +25,22 @@ defmodule CodeQA.HealthReportTest do
     end
 
     @tag :slow
-    test "without base_results: top_blocks shows all files with significant blocks" do
+    test "without base_results: top_blocks shows top 10 blocks by impact" do
       files = %{"lib/foo.ex" => "defmodule Foo do\n  def bar, do: :ok\nend\n"}
       results = Analyzer.analyze_codebase(files)
       results = BlockImpactAnalyzer.analyze(results, files)
 
       report = HealthReport.generate(results)
 
-      # top_blocks is a list of file groups (may be empty if no blocks above threshold)
+      # top_blocks is a flat list of blocks (may be empty if no blocks above threshold)
       assert is_list(report.top_blocks)
 
-      Enum.each(report.top_blocks, fn group ->
-        assert Map.has_key?(group, :path)
-        assert Map.has_key?(group, :status)
-        assert Map.has_key?(group, :blocks)
-        assert group.status == nil
+      Enum.each(report.top_blocks, fn block ->
+        assert Map.has_key?(block, :path)
+        assert Map.has_key?(block, :status)
+        assert Map.has_key?(block, :potentials)
+        assert Map.has_key?(block, :source)
+        assert block.status == nil
       end)
     end
 

From 228aef2890534ec201e346fc41aacedc5644a2d3 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 26 Mar 2026 15:42:09 +0100
Subject: [PATCH 66/71] chore: trigger CI


From 9b2d18497f1f444afc1ce46ba50b880e83a8629a Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 26 Mar 2026 20:52:15 +0100
Subject: [PATCH 67/71] feat(blocks): filter blocks by line count (3-20 lines
 default)

Adds configurable line range filtering for code blocks to focus on
actionable, refactorable chunks:

- Default: only show blocks between 3 and 20 lines
- Configurable via .codeqa.yml:
  - block_min_lines: 3  (default)
  - block_max_lines: 20 (default)

Blocks outside this range are excluded before ranking. This filters out:
- Tiny blocks (< 3 lines) that are too small to be meaningful
- Large blocks (> 20 lines) that need bigger refactoring
---
 lib/codeqa/health_report.ex                   | 10 ++-
 lib/codeqa/health_report/config.ex            | 14 +++-
 lib/codeqa/health_report/top_blocks.ex        | 17 ++++-
 test/codeqa/health_report/top_blocks_test.exs | 69 ++++++++++++++++++-
 4 files changed, 101 insertions(+), 9 deletions(-)

diff --git a/lib/codeqa/health_report.ex b/lib/codeqa/health_report.ex
index f97d2f8..9a64de8 100644
--- a/lib/codeqa/health_report.ex
+++ b/lib/codeqa/health_report.ex
@@ -14,7 +14,9 @@ defmodule CodeQA.HealthReport do
       categories: categories,
       grade_scale: grade_scale,
       impact_map: impact_map,
-      combined_top: combined_top
+      combined_top: combined_top,
+      block_min_lines: block_min_lines,
+      block_max_lines: block_max_lines
     } =
       Config.load(config_path)
 
@@ -59,7 +61,11 @@ defmodule CodeQA.HealthReport do
     codebase_cosine_lookup =
       Map.new(all_cosines, fn i -> {{i.category, i.behavior}, i.cosine} end)
 
-    top_blocks = TopBlocks.build(analysis_results, changed_files, codebase_cosine_lookup)
+    top_blocks =
+      TopBlocks.build(analysis_results, changed_files, codebase_cosine_lookup,
+        block_min_lines: block_min_lines,
+        block_max_lines: block_max_lines
+      )
 
     grading_cfg = %{
       category_defs: categories,
diff --git a/lib/codeqa/health_report/config.ex b/lib/codeqa/health_report/config.ex
index 0b06a1d..7c457b2 100644
--- a/lib/codeqa/health_report/config.ex
+++ b/lib/codeqa/health_report/config.ex
@@ -7,14 +7,18 @@ defmodule CodeQA.HealthReport.Config do
           categories: [map()],
           grade_scale: [{number(), String.t()}],
           impact_map: %{String.t() => pos_integer()},
-          combined_top: pos_integer()
+          combined_top: pos_integer(),
+          block_min_lines: pos_integer(),
+          block_max_lines: pos_integer()
         }
   def load(nil) do
     %{
       categories: Categories.defaults(),
       grade_scale: Categories.default_grade_scale(),
       impact_map: CodeQA.Config.impact_map(),
-      combined_top: CodeQA.Config.combined_top()
+      combined_top: CodeQA.Config.combined_top(),
+      block_min_lines: 3,
+      block_max_lines: 20
     }
   end
 
@@ -43,12 +47,16 @@ defmodule CodeQA.HealthReport.Config do
     grade_scale = parse_grade_scale(Map.get(yaml, "grade_scale"))
     impact_map = parse_impact(Map.get(yaml, "impact"))
     combined_top = Map.get(yaml, "combined_top", 2)
+    block_min_lines = Map.get(yaml, "block_min_lines", 3)
+    block_max_lines = Map.get(yaml, "block_max_lines", 20)
 
     %{
       categories: categories,
       grade_scale: grade_scale,
       impact_map: impact_map,
-      combined_top: combined_top
+      combined_top: combined_top,
+      block_min_lines: block_min_lines,
+      block_max_lines: block_max_lines
     }
   end
 
diff --git a/lib/codeqa/health_report/top_blocks.ex b/lib/codeqa/health_report/top_blocks.ex
index 57fd933..1bd370a 100644
--- a/lib/codeqa/health_report/top_blocks.ex
+++ b/lib/codeqa/health_report/top_blocks.ex
@@ -9,6 +9,8 @@ defmodule CodeQA.HealthReport.TopBlocks do
   @severity_medium 0.10
   @gap_floor 0.01
   @top_n 10
+  @default_min_lines 3
+  @default_max_lines 20
 
   defp build_fix_hint_lookup do
     Scorer.all_yamls()
@@ -28,12 +30,15 @@ defmodule CodeQA.HealthReport.TopBlocks do
 
   defp hints_for_behavior(_category, _entry), do: []
 
-  @spec build(map(), [struct()], map()) :: [map()]
-  def build(analysis_results, changed_files, codebase_cosine_lookup) do
+  @spec build(map(), [struct()], map(), keyword()) :: [map()]
+  def build(analysis_results, changed_files, codebase_cosine_lookup, opts \\ []) do
     files = Map.get(analysis_results, "files", %{})
     base_path = get_in(analysis_results, ["metadata", "path"]) || "."
     fix_hints = build_fix_hint_lookup()
 
+    min_lines = Keyword.get(opts, :block_min_lines, @default_min_lines)
+    max_lines = Keyword.get(opts, :block_max_lines, @default_max_lines)
+
     file_entries =
       if changed_files == [] do
         Enum.map(files, fn {path, data} -> {path, nil, data} end)
@@ -52,6 +57,7 @@ defmodule CodeQA.HealthReport.TopBlocks do
       |> Map.get("nodes", [])
       |> Enum.flat_map(&collect_nodes/1)
       |> Enum.filter(&(&1["token_count"] >= @min_tokens))
+      |> Enum.filter(&block_in_line_range?(&1, min_lines, max_lines))
       |> Enum.map(&enrich_block(&1, codebase_cosine_lookup, fix_hints))
       |> Enum.reject(&(&1.potentials == []))
       |> Enum.map(&Map.merge(&1, %{path: path, status: status}))
@@ -63,6 +69,13 @@ defmodule CodeQA.HealthReport.TopBlocks do
     |> Enum.map(&add_source_code(&1, base_path))
   end
 
+  defp block_in_line_range?(node, min_lines, max_lines) do
+    start_line = node["start_line"] || 1
+    end_line = node["end_line"] || start_line
+    line_count = end_line - start_line + 1
+    line_count >= min_lines and line_count <= max_lines
+  end
+
   defp collect_nodes(node) do
     children = node |> Map.get("children", []) |> Enum.flat_map(&collect_nodes/1)
     [node | children]
diff --git a/test/codeqa/health_report/top_blocks_test.exs b/test/codeqa/health_report/top_blocks_test.exs
index 91eb7af..c86001b 100644
--- a/test/codeqa/health_report/top_blocks_test.exs
+++ b/test/codeqa/health_report/top_blocks_test.exs
@@ -203,8 +203,13 @@ defmodule CodeQA.HealthReport.TopBlocksTest do
 
   describe "top N limiting" do
     test "returns at most 10 blocks" do
-      # Create 15 nodes
-      nodes = for i <- 1..15, do: put_in(make_node(0.60 + i * 0.01), ["start_line"], i * 10)
+      # Create 15 nodes, each 10 lines (within default 3-20 range)
+      nodes =
+        for i <- 1..15 do
+          make_node(0.60 + i * 0.01)
+          |> put_in(["start_line"], i * 20)
+          |> put_in(["end_line"], i * 20 + 9)
+        end
 
       results = %{
         "files" => %{"lib/foo.ex" => %{"nodes" => nodes}},
@@ -215,4 +220,64 @@ defmodule CodeQA.HealthReport.TopBlocksTest do
       assert length(blocks) == 10
     end
   end
+
+  describe "line range filtering" do
+    test "blocks outside line range are excluded" do
+      # 2-line block (below min of 3)
+      small_node =
+        make_node(0.60)
+        |> put_in(["start_line"], 1)
+        |> put_in(["end_line"], 2)
+
+      # 25-line block (above max of 20)
+      large_node =
+        make_node(0.60)
+        |> put_in(["start_line"], 10)
+        |> put_in(["end_line"], 34)
+
+      results = %{
+        "files" => %{"lib/foo.ex" => %{"nodes" => [small_node, large_node]}},
+        "metadata" => %{"path" => "/tmp"}
+      }
+
+      blocks = TopBlocks.build(results, [], lookup())
+      assert blocks == []
+    end
+
+    test "blocks within line range are included" do
+      # 10-line block (within 3-20 range)
+      node =
+        make_node(0.60)
+        |> put_in(["start_line"], 1)
+        |> put_in(["end_line"], 10)
+
+      results = %{
+        "files" => %{"lib/foo.ex" => %{"nodes" => [node]}},
+        "metadata" => %{"path" => "/tmp"}
+      }
+
+      blocks = TopBlocks.build(results, [], lookup())
+      assert length(blocks) == 1
+    end
+
+    test "line range is configurable" do
+      # 2-line block
+      small_node =
+        make_node(0.60)
+        |> put_in(["start_line"], 1)
+        |> put_in(["end_line"], 2)
+
+      results = %{
+        "files" => %{"lib/foo.ex" => %{"nodes" => [small_node]}},
+        "metadata" => %{"path" => "/tmp"}
+      }
+
+      # Default range (3-20) excludes it
+      assert TopBlocks.build(results, [], lookup()) == []
+
+      # Custom range (1-5) includes it
+      blocks = TopBlocks.build(results, [], lookup(), block_min_lines: 1, block_max_lines: 5)
+      assert length(blocks) == 1
+    end
+  end
 end

From bfa9e3e5e4a33b9f6d899efa0a0ecd2d2a5d822e Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 26 Mar 2026 21:22:13 +0100
Subject: [PATCH 68/71] feat(blocks): filter blocks by diff line overlap when
 --base-ref provided

When comparing refs, only show blocks whose lines overlap with the
actual diff hunks, not just blocks in changed files. This surfaces
only blocks relevant to the current PR changes.

- Add Git.diff_line_ranges/3 to parse unified diff and extract
  changed line ranges per file
- Add filter_by_diff_overlap/3 to TopBlocks to filter by line overlap
- Integrate in health-report CLI when --base-ref is provided
- Add warning when diff parsing fails (graceful degradation)
- Add comprehensive tests for edge cases
---
 lib/codeqa/cli/health_report.ex               |  20 +-
 lib/codeqa/git.ex                             |  72 +++++++
 lib/codeqa/health_report.ex                   |   4 +-
 lib/codeqa/health_report/top_blocks.ex        |  33 +++
 test/codeqa/git_test.exs                      | 185 +++++++++++++++++
 test/codeqa/health_report/top_blocks_test.exs | 188 ++++++++++++++++++
 6 files changed, 497 insertions(+), 5 deletions(-)

diff --git a/lib/codeqa/cli/health_report.ex b/lib/codeqa/cli/health_report.ex
index fc9bbaa..a21a743 100644
--- a/lib/codeqa/cli/health_report.ex
+++ b/lib/codeqa/cli/health_report.ex
@@ -95,18 +95,29 @@ defmodule CodeQA.CLI.HealthReport do
         "total_bytes" => total_bytes
       })
 
-    {base_results, changed_files} =
+    {base_results, changed_files, diff_line_ranges} =
       if base_ref do
         IO.puts(:stderr, "Collecting base snapshot at #{base_ref}...")
         base_files = Git.collect_files_at_ref(path, base_ref)
         changed = Git.changed_files(path, base_ref, head_ref)
 
+        diff_ranges =
+          case Git.diff_line_ranges(path, base_ref, head_ref) do
+            {:ok, ranges} ->
+              ranges
+
+            {:error, reason} ->
+              IO.puts(:stderr, "Warning: failed to parse diff line ranges: #{inspect(reason)}")
+              IO.puts(:stderr, "Block scoping disabled - showing all blocks in changed files")
+              %{}
+          end
+
         IO.puts(:stderr, "Analyzing base snapshot (#{map_size(base_files)} files)...")
         base_res = Analyzer.analyze_codebase(base_files, analyze_opts)
 
-        {base_res, changed}
+        {base_res, changed, diff_ranges}
       else
-        {nil, []}
+        {nil, [], %{}}
       end
 
     detail = parse_detail(opts[:detail])
@@ -119,7 +130,8 @@ defmodule CodeQA.CLI.HealthReport do
         detail: detail,
         top: top_n,
         base_results: base_results,
-        changed_files: changed_files
+        changed_files: changed_files,
+        diff_line_ranges: diff_line_ranges
       )
 
     if opts[:comment] do
diff --git a/lib/codeqa/git.ex b/lib/codeqa/git.ex
index 106ce54..4489205 100644
--- a/lib/codeqa/git.ex
+++ b/lib/codeqa/git.ex
@@ -43,6 +43,78 @@ defmodule CodeQA.Git do
     |> Enum.flat_map(&parse_change_line/1)
   end
 
+  @doc """
+  Returns a map of file paths to lists of changed line ranges in the head version.
+
+  Each range is a tuple `{start_line, end_line}` representing lines that were
+  added or modified in the diff between base_ref and head_ref.
+  """
+  @spec diff_line_ranges(String.t(), String.t(), String.t()) ::
+          {:ok, %{String.t() => [{pos_integer(), pos_integer()}]}} | {:error, term()}
+  def diff_line_ranges(repo_path, base_ref, head_ref) do
+    case System.cmd(
+           "git",
+           ["diff", "-U0", "#{base_ref}..#{head_ref}"],
+           cd: repo_path,
+           stderr_to_stdout: false
+         ) do
+      {output, 0} ->
+        {:ok, parse_diff_hunks(output)}
+
+      {_output, code} ->
+        {:error, "git diff exited with code #{code}"}
+    end
+  end
+
+  @typep parse_state :: {String.t() | nil, %{String.t() => [{pos_integer(), pos_integer()}]}}
+
+  @spec parse_diff_hunks(String.t()) :: %{String.t() => [{pos_integer(), pos_integer()}]}
+  defp parse_diff_hunks(diff_output) do
+    diff_output
+    |> String.split("\n")
+    |> Enum.reduce({nil, %{}}, &parse_diff_line/2)
+    |> elem(1)
+    |> Map.new(fn {path, ranges} -> {path, Enum.reverse(ranges)} end)
+  end
+
+  @spec parse_diff_line(String.t(), parse_state()) :: parse_state()
+  defp parse_diff_line("diff --git a/" <> rest, {_current_file, acc}) do
+    # Extract the "b/..." path from the diff header
+    case Regex.run(~r/ b\/(.+)$/, rest) do
+      [_, path] -> {path, acc}
+      nil -> {nil, acc}
+    end
+  end
+
+  defp parse_diff_line("@@ " <> rest, {current_file, acc}) when is_binary(current_file) do
+    # Parse hunk header: @@ -old_start,old_count +new_start,new_count @@
+    case Regex.run(~r/\+(\d+)(?:,(\d+))?/, rest) do
+      [_, start_str] ->
+        # Single line change (no count means 1 line)
+        start = String.to_integer(start_str)
+        updated = Map.update(acc, current_file, [{start, start}], &[{start, start} | &1])
+        {current_file, updated}
+
+      [_, start_str, count_str] ->
+        start = String.to_integer(start_str)
+        count = String.to_integer(count_str)
+
+        if count == 0 do
+          # Deletion only, no new lines
+          {current_file, acc}
+        else
+          end_line = start + count - 1
+          updated = Map.update(acc, current_file, [{start, end_line}], &[{start, end_line} | &1])
+          {current_file, updated}
+        end
+
+      nil ->
+        {current_file, acc}
+    end
+  end
+
+  defp parse_diff_line(_line, state), do: state
+
   def read_file_at_ref(repo_path, ref, path) do
     case System.cmd("git", ["show", "#{ref}:#{path}"], cd: repo_path, stderr_to_stdout: true) do
       {output, 0} -> output
diff --git a/lib/codeqa/health_report.ex b/lib/codeqa/health_report.ex
index 9a64de8..7ffa31a 100644
--- a/lib/codeqa/health_report.ex
+++ b/lib/codeqa/health_report.ex
@@ -9,6 +9,7 @@ defmodule CodeQA.HealthReport do
     config_path = Keyword.get(opts, :config)
     base_results = Keyword.get(opts, :base_results)
     changed_files = Keyword.get(opts, :changed_files, [])
+    diff_line_ranges = Keyword.get(opts, :diff_line_ranges, %{})
 
     %{
       categories: categories,
@@ -64,7 +65,8 @@ defmodule CodeQA.HealthReport do
     top_blocks =
       TopBlocks.build(analysis_results, changed_files, codebase_cosine_lookup,
         block_min_lines: block_min_lines,
-        block_max_lines: block_max_lines
+        block_max_lines: block_max_lines,
+        diff_line_ranges: diff_line_ranges
       )
 
     grading_cfg = %{
diff --git a/lib/codeqa/health_report/top_blocks.ex b/lib/codeqa/health_report/top_blocks.ex
index 1bd370a..fb3be04 100644
--- a/lib/codeqa/health_report/top_blocks.ex
+++ b/lib/codeqa/health_report/top_blocks.ex
@@ -38,6 +38,7 @@ defmodule CodeQA.HealthReport.TopBlocks do
 
     min_lines = Keyword.get(opts, :block_min_lines, @default_min_lines)
     max_lines = Keyword.get(opts, :block_max_lines, @default_max_lines)
+    diff_line_ranges = Keyword.get(opts, :diff_line_ranges, %{})
 
     file_entries =
       if changed_files == [] do
@@ -53,11 +54,14 @@ defmodule CodeQA.HealthReport.TopBlocks do
     # Flatten all blocks across all files, enrich with path and source code
     file_entries
     |> Enum.flat_map(fn {path, status, file_data} ->
+      path_diff_ranges = Map.get(diff_line_ranges, path, [])
+
       file_data
       |> Map.get("nodes", [])
       |> Enum.flat_map(&collect_nodes/1)
       |> Enum.filter(&(&1["token_count"] >= @min_tokens))
       |> Enum.filter(&block_in_line_range?(&1, min_lines, max_lines))
+      |> filter_by_diff_overlap(path_diff_ranges, diff_line_ranges)
       |> Enum.map(&enrich_block(&1, codebase_cosine_lookup, fix_hints))
       |> Enum.reject(&(&1.potentials == []))
       |> Enum.map(&Map.merge(&1, %{path: path, status: status}))
@@ -69,6 +73,7 @@ defmodule CodeQA.HealthReport.TopBlocks do
     |> Enum.map(&add_source_code(&1, base_path))
   end
 
+  @spec block_in_line_range?(map(), pos_integer(), pos_integer()) :: boolean()
   defp block_in_line_range?(node, min_lines, max_lines) do
     start_line = node["start_line"] || 1
     end_line = node["end_line"] || start_line
@@ -76,6 +81,34 @@ defmodule CodeQA.HealthReport.TopBlocks do
     line_count >= min_lines and line_count <= max_lines
   end
 
+  # When no diff_line_ranges provided (empty map), show all blocks - no filtering needed
+  @spec filter_by_diff_overlap([map()], [{pos_integer(), pos_integer()}], map()) :: [map()]
+  defp filter_by_diff_overlap(blocks, _path_ranges, diff_line_ranges)
+       when map_size(diff_line_ranges) == 0,
+       do: blocks
+
+  # When diff_line_ranges provided, filter blocks by overlap
+  defp filter_by_diff_overlap(blocks, path_ranges, _diff_line_ranges) do
+    Enum.filter(blocks, &block_overlaps_diff?(&1, path_ranges))
+  end
+
+  @spec block_overlaps_diff?(map(), [{pos_integer(), pos_integer()}]) :: boolean()
+  defp block_overlaps_diff?(_node, []), do: false
+
+  defp block_overlaps_diff?(node, path_ranges) do
+    block_start = node["start_line"] || 1
+    block_end = node["end_line"] || block_start
+
+    Enum.any?(path_ranges, fn {diff_start, diff_end} ->
+      ranges_overlap?(block_start, block_end, diff_start, diff_end)
+    end)
+  end
+
+  @spec ranges_overlap?(pos_integer(), pos_integer(), pos_integer(), pos_integer()) :: boolean()
+  defp ranges_overlap?(start1, end1, start2, end2) do
+    start1 <= end2 and start2 <= end1
+  end
+
   defp collect_nodes(node) do
     children = node |> Map.get("children", []) |> Enum.flat_map(&collect_nodes/1)
     [node | children]
diff --git a/test/codeqa/git_test.exs b/test/codeqa/git_test.exs
index 2d1ec2f..f1a800c 100644
--- a/test/codeqa/git_test.exs
+++ b/test/codeqa/git_test.exs
@@ -96,6 +96,191 @@ defmodule CodeQA.GitTest do
     end
   end
 
+  describe "diff_line_ranges/3" do
+    test "parses single-line hunks" do
+      in_tmp_git_repo(fn repo ->
+        # Create initial commit
+        File.write!(Path.join(repo, "foo.ex"), "line1\nline2\nline3\n")
+        System.cmd("git", ["add", "."], cd: repo)
+        System.cmd("git", ["commit", "-m", "initial"], cd: repo)
+
+        # Modify a single line
+        File.write!(Path.join(repo, "foo.ex"), "line1\nmodified\nline3\n")
+        System.cmd("git", ["add", "."], cd: repo)
+        System.cmd("git", ["commit", "-m", "change"], cd: repo)
+
+        {:ok, ranges} = Git.diff_line_ranges(repo, "HEAD~1", "HEAD")
+
+        assert Map.has_key?(ranges, "foo.ex")
+        assert {2, 2} in ranges["foo.ex"]
+      end)
+    end
+
+    test "parses multi-line hunks" do
+      in_tmp_git_repo(fn repo ->
+        File.write!(Path.join(repo, "foo.ex"), "a\nb\nc\nd\ne\n")
+        {_, 0} = System.cmd("git", ["add", "."], cd: repo)
+        {_, 0} = System.cmd("git", ["commit", "-m", "initial"], cd: repo)
+
+        # Replace lines 2-4
+        File.write!(Path.join(repo, "foo.ex"), "a\nX\nY\nZ\ne\n")
+        {_, 0} = System.cmd("git", ["add", "."], cd: repo)
+        {_, 0} = System.cmd("git", ["commit", "-m", "change"], cd: repo)
+
+        {:ok, ranges} = Git.diff_line_ranges(repo, "HEAD~1", "HEAD")
+
+        assert Map.has_key?(ranges, "foo.ex")
+        assert {2, 4} in ranges["foo.ex"]
+      end)
+    end
+
+    test "handles multiple hunks in same file" do
+      in_tmp_git_repo(fn repo ->
+        lines = Enum.map_join(1..20, "\n", &"line#{&1}")
+        File.write!(Path.join(repo, "foo.ex"), lines <> "\n")
+        {_, 0} = System.cmd("git", ["add", "."], cd: repo)
+        {_, 0} = System.cmd("git", ["commit", "-m", "initial"], cd: repo)
+
+        # Change line 2 and line 15
+        new_lines =
+          1..20
+          |> Enum.map(fn
+            2 -> "changed2"
+            15 -> "changed15"
+            n -> "line#{n}"
+          end)
+          |> Enum.join("\n")
+
+        File.write!(Path.join(repo, "foo.ex"), new_lines <> "\n")
+        {_, 0} = System.cmd("git", ["add", "."], cd: repo)
+        {_, 0} = System.cmd("git", ["commit", "-m", "change"], cd: repo)
+
+        {:ok, ranges} = Git.diff_line_ranges(repo, "HEAD~1", "HEAD")
+
+        assert Map.has_key?(ranges, "foo.ex")
+        assert length(ranges["foo.ex"]) == 2
+        assert {2, 2} in ranges["foo.ex"]
+        assert {15, 15} in ranges["foo.ex"]
+      end)
+    end
+
+    test "handles multiple files" do
+      in_tmp_git_repo(fn repo ->
+        File.write!(Path.join(repo, "a.ex"), "a1\na2\n")
+        File.write!(Path.join(repo, "b.ex"), "b1\nb2\n")
+        {_, 0} = System.cmd("git", ["add", "."], cd: repo)
+        {_, 0} = System.cmd("git", ["commit", "-m", "initial"], cd: repo)
+
+        File.write!(Path.join(repo, "a.ex"), "a1\nchanged\n")
+        File.write!(Path.join(repo, "b.ex"), "b1\nchanged\n")
+        {_, 0} = System.cmd("git", ["add", "."], cd: repo)
+        {_, 0} = System.cmd("git", ["commit", "-m", "change"], cd: repo)
+
+        {:ok, ranges} = Git.diff_line_ranges(repo, "HEAD~1", "HEAD")
+
+        assert {2, 2} in ranges["a.ex"]
+        assert {2, 2} in ranges["b.ex"]
+      end)
+    end
+
+    test "handles added lines (insertion)" do
+      in_tmp_git_repo(fn repo ->
+        File.write!(Path.join(repo, "foo.ex"), "a\nb\n")
+        System.cmd("git", ["add", "."], cd: repo)
+        System.cmd("git", ["commit", "-m", "initial"], cd: repo)
+
+        # Insert new line between a and b
+        File.write!(Path.join(repo, "foo.ex"), "a\nnew\nb\n")
+        System.cmd("git", ["add", "."], cd: repo)
+        System.cmd("git", ["commit", "-m", "insert"], cd: repo)
+
+        {:ok, ranges} = Git.diff_line_ranges(repo, "HEAD~1", "HEAD")
+
+        assert Map.has_key?(ranges, "foo.ex")
+        # Line 2 is the new line
+        assert {2, 2} in ranges["foo.ex"]
+      end)
+    end
+
+    test "handles deleted lines (no new lines)" do
+      in_tmp_git_repo(fn repo ->
+        File.write!(Path.join(repo, "foo.ex"), "a\nb\nc\n")
+        System.cmd("git", ["add", "."], cd: repo)
+        System.cmd("git", ["commit", "-m", "initial"], cd: repo)
+
+        # Delete line b
+        File.write!(Path.join(repo, "foo.ex"), "a\nc\n")
+        System.cmd("git", ["add", "."], cd: repo)
+        System.cmd("git", ["commit", "-m", "delete"], cd: repo)
+
+        {:ok, ranges} = Git.diff_line_ranges(repo, "HEAD~1", "HEAD")
+
+        # File should either not be in ranges or have empty list (deletion only)
+        ranges_for_file = Map.get(ranges, "foo.ex", [])
+        # No new lines were added, so no ranges pointing to new content
+        assert ranges_for_file == [] or not Map.has_key?(ranges, "foo.ex")
+      end)
+    end
+
+    test "returns empty map when no diff" do
+      in_tmp_git_repo(fn repo ->
+        File.write!(Path.join(repo, "foo.ex"), "content\n")
+        {_, 0} = System.cmd("git", ["add", "."], cd: repo)
+        {_, 0} = System.cmd("git", ["commit", "-m", "initial"], cd: repo)
+
+        {:ok, ranges} = Git.diff_line_ranges(repo, "HEAD", "HEAD")
+
+        assert ranges == %{}
+      end)
+    end
+
+    test "handles new file (no base version)" do
+      in_tmp_git_repo(fn repo ->
+        File.write!(Path.join(repo, "existing.ex"), "existing\n")
+        {_, 0} = System.cmd("git", ["add", "."], cd: repo)
+        {_, 0} = System.cmd("git", ["commit", "-m", "initial"], cd: repo)
+
+        File.write!(Path.join(repo, "new.ex"), "line1\nline2\nline3\n")
+        {_, 0} = System.cmd("git", ["add", "."], cd: repo)
+        {_, 0} = System.cmd("git", ["commit", "-m", "add new file"], cd: repo)
+
+        {:ok, ranges} = Git.diff_line_ranges(repo, "HEAD~1", "HEAD")
+
+        assert Map.has_key?(ranges, "new.ex")
+        assert {1, 3} in ranges["new.ex"]
+      end)
+    end
+
+    test "returns ranges in ascending order" do
+      in_tmp_git_repo(fn repo ->
+        lines = Enum.map_join(1..20, "\n", &"line#{&1}")
+        File.write!(Path.join(repo, "foo.ex"), lines <> "\n")
+        {_, 0} = System.cmd("git", ["add", "."], cd: repo)
+        {_, 0} = System.cmd("git", ["commit", "-m", "initial"], cd: repo)
+
+        # Change lines 2, 10, and 18
+        new_lines =
+          1..20
+          |> Enum.map(fn
+            2 -> "changed2"
+            10 -> "changed10"
+            18 -> "changed18"
+            n -> "line#{n}"
+          end)
+          |> Enum.join("\n")
+
+        File.write!(Path.join(repo, "foo.ex"), new_lines <> "\n")
+        {_, 0} = System.cmd("git", ["add", "."], cd: repo)
+        {_, 0} = System.cmd("git", ["commit", "-m", "change"], cd: repo)
+
+        {:ok, ranges} = Git.diff_line_ranges(repo, "HEAD~1", "HEAD")
+
+        # Ranges should be in ascending order by start line
+        assert ranges["foo.ex"] == [{2, 2}, {10, 10}, {18, 18}]
+      end)
+    end
+  end
+
   defp in_tmp_git_repo(fun) do
     tmp = Path.join(System.tmp_dir!(), "codeqa_git_test_#{:rand.uniform(999_999)}")
     File.mkdir_p!(tmp)
diff --git a/test/codeqa/health_report/top_blocks_test.exs b/test/codeqa/health_report/top_blocks_test.exs
index c86001b..4bef28b 100644
--- a/test/codeqa/health_report/top_blocks_test.exs
+++ b/test/codeqa/health_report/top_blocks_test.exs
@@ -280,4 +280,192 @@ defmodule CodeQA.HealthReport.TopBlocksTest do
       assert length(blocks) == 1
     end
   end
+
+  describe "diff_line_ranges filtering" do
+    test "when diff_line_ranges is empty map, shows all blocks" do
+      node = make_node(0.60)
+      [block] = TopBlocks.build(make_results([node]), [], lookup(), diff_line_ranges: %{})
+      assert block.path == "lib/foo.ex"
+    end
+
+    test "when diff_line_ranges provided, only shows blocks overlapping diff" do
+      # Block at lines 1-10
+      node = make_node(0.60)
+
+      # Diff changes lines 5-7 (overlaps with block)
+      diff_ranges = %{"lib/foo.ex" => [{5, 7}]}
+
+      [block] =
+        TopBlocks.build(make_results([node]), [], lookup(), diff_line_ranges: diff_ranges)
+
+      assert block.path == "lib/foo.ex"
+    end
+
+    test "excludes blocks that don't overlap with diff" do
+      # Block at lines 1-10
+      node = make_node(0.60)
+
+      # Diff changes lines 50-55 (no overlap)
+      diff_ranges = %{"lib/foo.ex" => [{50, 55}]}
+
+      blocks = TopBlocks.build(make_results([node]), [], lookup(), diff_line_ranges: diff_ranges)
+      assert blocks == []
+    end
+
+    test "excludes blocks when file has no diff ranges" do
+      node = make_node(0.60)
+
+      # Diff only has ranges for different file
+      diff_ranges = %{"lib/other.ex" => [{1, 10}]}
+
+      blocks = TopBlocks.build(make_results([node]), [], lookup(), diff_line_ranges: diff_ranges)
+      assert blocks == []
+    end
+
+    test "includes block with exact overlap" do
+      # Block at lines 5-15
+      node =
+        make_node(0.60)
+        |> put_in(["start_line"], 5)
+        |> put_in(["end_line"], 15)
+
+      # Diff changes exactly lines 5-15
+      diff_ranges = %{"lib/foo.ex" => [{5, 15}]}
+
+      [block] =
+        TopBlocks.build(make_results([node]), [], lookup(), diff_line_ranges: diff_ranges)
+
+      assert block.start_line == 5
+      assert block.end_line == 15
+    end
+
+    test "includes block with partial overlap at start" do
+      # Block at lines 10-20
+      node =
+        make_node(0.60)
+        |> put_in(["start_line"], 10)
+        |> put_in(["end_line"], 20)
+
+      # Diff changes lines 5-12 (overlaps start of block)
+      diff_ranges = %{"lib/foo.ex" => [{5, 12}]}
+
+      [block] =
+        TopBlocks.build(make_results([node]), [], lookup(), diff_line_ranges: diff_ranges)
+
+      assert block.start_line == 10
+    end
+
+    test "includes block with partial overlap at end" do
+      # Block at lines 10-20
+      node =
+        make_node(0.60)
+        |> put_in(["start_line"], 10)
+        |> put_in(["end_line"], 20)
+
+      # Diff changes lines 18-25 (overlaps end of block)
+      diff_ranges = %{"lib/foo.ex" => [{18, 25}]}
+
+      [block] =
+        TopBlocks.build(make_results([node]), [], lookup(), diff_line_ranges: diff_ranges)
+
+      assert block.end_line == 20
+    end
+
+    test "includes block when diff is entirely inside block" do
+      # Block at lines 1-10
+      node = make_node(0.60)
+
+      # Diff changes lines 3-5 (inside block)
+      diff_ranges = %{"lib/foo.ex" => [{3, 5}]}
+
+      [block] =
+        TopBlocks.build(make_results([node]), [], lookup(), diff_line_ranges: diff_ranges)
+
+      assert block.path == "lib/foo.ex"
+      assert block.start_line == 1
+      assert block.end_line == 10
+    end
+
+    test "works with multiple diff ranges for same file" do
+      # Block at lines 1-10
+      node = make_node(0.60)
+
+      # Diff changes lines 50-55 and 5-7 (second range overlaps)
+      diff_ranges = %{"lib/foo.ex" => [{50, 55}, {5, 7}]}
+
+      [block] =
+        TopBlocks.build(make_results([node]), [], lookup(), diff_line_ranges: diff_ranges)
+
+      assert block.path == "lib/foo.ex"
+      assert block.start_line == 1
+      assert block.end_line == 10
+    end
+
+    test "excludes adjacent but non-overlapping ranges" do
+      # Block at lines 1-10
+      node = make_node(0.60)
+
+      # Diff changes line 11 (adjacent but not overlapping)
+      diff_ranges = %{"lib/foo.ex" => [{11, 11}]}
+
+      blocks = TopBlocks.build(make_results([node]), [], lookup(), diff_line_ranges: diff_ranges)
+      assert blocks == []
+    end
+
+    test "excludes blocks when file has empty diff ranges list" do
+      node = make_node(0.60)
+
+      # File is present but with empty ranges (e.g., only deletions)
+      diff_ranges = %{"lib/foo.ex" => []}
+
+      blocks = TopBlocks.build(make_results([node]), [], lookup(), diff_line_ranges: diff_ranges)
+      assert blocks == []
+    end
+
+    test "single-line block overlapping single-line diff" do
+      # Single-line block at line 5
+      node =
+        make_node(0.60)
+        |> put_in(["start_line"], 5)
+        |> put_in(["end_line"], 5)
+
+      diff_ranges = %{"lib/foo.ex" => [{5, 5}]}
+
+      # Need to adjust min_lines for this test since block is only 1 line
+      [block] =
+        TopBlocks.build(make_results([node]), [], lookup(),
+          diff_line_ranges: diff_ranges,
+          block_min_lines: 1
+        )
+
+      assert block.start_line == 5
+      assert block.end_line == 5
+    end
+
+    test "when both changed_files and diff_line_ranges provided, both filters apply" do
+      node = make_node(0.60)
+      changed = [%ChangedFile{path: "lib/foo.ex", status: "modified"}]
+      diff_ranges = %{"lib/foo.ex" => [{5, 7}]}
+
+      [block] =
+        TopBlocks.build(make_results([node]), changed, lookup(), diff_line_ranges: diff_ranges)
+
+      assert block.path == "lib/foo.ex"
+      assert block.status == "modified"
+      assert block.start_line == 1
+      assert block.end_line == 10
+    end
+
+    test "changed_files filter applies before diff_line_ranges filter" do
+      node = make_node(0.60)
+      # File is in diff_ranges but not in changed_files
+      changed = [%ChangedFile{path: "lib/other.ex", status: "modified"}]
+      diff_ranges = %{"lib/foo.ex" => [{5, 7}]}
+
+      blocks =
+        TopBlocks.build(make_results([node]), changed, lookup(), diff_line_ranges: diff_ranges)
+
+      assert blocks == []
+    end
+  end
 end

From c9704ed5af3b29f9d915e4d1b7161ec336e70175 Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 26 Mar 2026 21:41:09 +0100
Subject: [PATCH 69/71] feat(report): show worst offending block per cosine
 category

Add worst_per_category/4 to TopBlocks that identifies the single worst
block for each cosine-based category (code_smells, function_design, etc.)
based on cosine_delta. Blocks must overlap with PR diff lines.

Display in GitHub formatter:
- Show source code if block is 4-10 lines
- Show file location only if <4 or >10 lines
---
 lib/codeqa/health_report.ex                  | 21 +++++--
 lib/codeqa/health_report/formatter/github.ex | 59 +++++++++++++++-----
 lib/codeqa/health_report/top_blocks.ex       | 50 ++++++++++++++---
 priv/combined_metrics/code_smells.yml        |  5 ++
 priv/combined_metrics/variable_naming.yml    | 14 +++++
 5 files changed, 123 insertions(+), 26 deletions(-)

diff --git a/lib/codeqa/health_report.ex b/lib/codeqa/health_report.ex
index 7ffa31a..183b737 100644
--- a/lib/codeqa/health_report.ex
+++ b/lib/codeqa/health_report.ex
@@ -62,11 +62,21 @@ defmodule CodeQA.HealthReport do
     codebase_cosine_lookup =
       Map.new(all_cosines, fn i -> {{i.category, i.behavior}, i.cosine} end)
 
+    block_opts = [
+      block_min_lines: block_min_lines,
+      block_max_lines: block_max_lines,
+      diff_line_ranges: diff_line_ranges
+    ]
+
     top_blocks =
-      TopBlocks.build(analysis_results, changed_files, codebase_cosine_lookup,
-        block_min_lines: block_min_lines,
-        block_max_lines: block_max_lines,
-        diff_line_ranges: diff_line_ranges
+      TopBlocks.build(analysis_results, changed_files, codebase_cosine_lookup, block_opts)
+
+    worst_blocks_by_category =
+      TopBlocks.worst_per_category(
+        analysis_results,
+        changed_files,
+        codebase_cosine_lookup,
+        block_opts
       )
 
     grading_cfg = %{
@@ -99,7 +109,8 @@ defmodule CodeQA.HealthReport do
       codebase_delta: codebase_delta,
       categories: all_categories,
       top_issues: top_issues,
-      top_blocks: top_blocks
+      top_blocks: top_blocks,
+      worst_blocks_by_category: worst_blocks_by_category
     }
   end
 
diff --git a/lib/codeqa/health_report/formatter/github.ex b/lib/codeqa/health_report/formatter/github.ex
index b3cf6df..b72b250 100644
--- a/lib/codeqa/health_report/formatter/github.ex
+++ b/lib/codeqa/health_report/formatter/github.ex
@@ -9,6 +9,7 @@ defmodule CodeQA.HealthReport.Formatter.Github do
   def render(report, detail, opts \\ []) do
     chart? = Keyword.get(opts, :chart, true)
     display_categories = merge_cosine_categories(report.categories)
+    worst_blocks = Map.get(report, :worst_blocks_by_category, %{})
 
     [
       pr_summary_section(Map.get(report, :pr_summary)),
@@ -19,7 +20,7 @@ defmodule CodeQA.HealthReport.Formatter.Github do
       progress_bars(display_categories),
       top_issues_section(Map.get(report, :top_issues, []), detail),
       blocks_section(Map.get(report, :top_blocks, [])),
-      category_sections(display_categories, detail),
+      category_sections(display_categories, detail, worst_blocks),
       footer()
     ]
     |> List.flatten()
@@ -55,10 +56,11 @@ defmodule CodeQA.HealthReport.Formatter.Github do
   def render_part_2(report, opts \\ []) do
     detail = Keyword.get(opts, :detail, :default)
     display_categories = merge_cosine_categories(report.categories)
+    worst_blocks = Map.get(report, :worst_blocks_by_category, %{})
 
     [
       top_issues_section(Map.get(report, :top_issues, []), detail),
-      category_sections(display_categories, detail),
+      category_sections(display_categories, detail, worst_blocks),
       sentinel(2)
     ]
     |> List.flatten()
@@ -186,18 +188,18 @@ defmodule CodeQA.HealthReport.Formatter.Github do
     String.duplicate(@filled, filled) <> String.duplicate(@empty, empty)
   end
 
-  defp category_sections(_categories, :summary), do: []
+  defp category_sections(_categories, :summary, _worst_blocks), do: []
 
-  defp category_sections(categories, detail) do
-    Enum.flat_map(categories, &render_category(&1, detail))
+  defp category_sections(categories, detail, worst_blocks) do
+    Enum.flat_map(categories, &render_category(&1, detail, worst_blocks))
   end
 
-  defp render_category(%{type: :cosine_group} = group, detail) do
+  defp render_category(%{type: :cosine_group} = group, detail, worst_blocks) do
     emoji = grade_emoji(group.grade)
     summary_line = "#{emoji} #{group.name} — #{group.grade} (#{group.score}/100)"
 
     inner =
-      cosine_group_content(group, detail)
+      cosine_group_content(group, detail, worst_blocks)
       |> List.flatten()
       |> Enum.join("\n")
 
@@ -212,12 +214,12 @@ defmodule CodeQA.HealthReport.Formatter.Github do
     ]
   end
 
-  defp render_category(%{type: :cosine} = cat, detail) do
+  defp render_category(%{type: :cosine} = cat, detail, worst_blocks) do
     emoji = grade_emoji(cat.grade)
     summary_line = "#{emoji} #{cat.name} — #{cat.grade} (#{cat.score}/100)"
 
     inner =
-      cosine_section_content(cat, detail)
+      cosine_section_content(cat, detail, worst_blocks)
       |> List.flatten()
       |> Enum.join("\n")
 
@@ -232,7 +234,7 @@ defmodule CodeQA.HealthReport.Formatter.Github do
     ]
   end
 
-  defp render_category(cat, detail) do
+  defp render_category(cat, detail, _worst_blocks) do
     emoji = grade_emoji(cat.grade)
     summary_line = "#{emoji} #{cat.name} — #{cat.grade} (#{cat.score}/100)"
 
@@ -252,7 +254,7 @@ defmodule CodeQA.HealthReport.Formatter.Github do
     ]
   end
 
-  defp cosine_group_content(group, detail) do
+  defp cosine_group_content(group, detail, worst_blocks) do
     rows =
       Enum.map(group.categories, fn cat ->
         emoji = grade_emoji(cat.grade)
@@ -270,7 +272,7 @@ defmodule CodeQA.HealthReport.Formatter.Github do
         emoji = grade_emoji(cat.grade)
 
         inner =
-          cosine_section_content(cat, detail)
+          cosine_section_content(cat, detail, worst_blocks)
           |> List.flatten()
           |> Enum.join("\n")
 
@@ -288,8 +290,9 @@ defmodule CodeQA.HealthReport.Formatter.Github do
     summary_table ++ [""] ++ sub_sections
   end
 
-  defp cosine_section_content(cat, _detail) do
+  defp cosine_section_content(cat, _detail, worst_blocks) do
     n = length(cat.behaviors)
+    category_key = to_string(cat.key)
 
     behaviors_rows =
       Enum.map(cat.behaviors, fn b ->
@@ -304,7 +307,35 @@ defmodule CodeQA.HealthReport.Formatter.Github do
       | behaviors_rows
     ]
 
-    behaviors_table ++ [""]
+    worst_block_section =
+      case Map.get(worst_blocks, category_key) do
+        nil -> []
+        block -> render_worst_block(block)
+      end
+
+    behaviors_table ++ [""] ++ worst_block_section
+  end
+
+  defp render_worst_block(block) do
+    line_count = (block.end_line || block.start_line) - block.start_line + 1
+    location = "#{block.path}:#{block.start_line}-#{block.end_line}"
+
+    if line_count >= 4 and line_count <= 10 and block.source do
+      lang = block.language || ""
+
+      [
+        "> **Worst offender** (`#{location}`):",
+        "> ```#{lang}",
+        block.source |> String.split("\n") |> Enum.map(&"> #{&1}") |> Enum.join("\n"),
+        "> ```",
+        ""
+      ]
+    else
+      [
+        "> **Worst offender**: `#{location}` (#{line_count} lines)",
+        ""
+      ]
+    end
   end
 
   defp section_content(cat, _detail) do
diff --git a/lib/codeqa/health_report/top_blocks.ex b/lib/codeqa/health_report/top_blocks.ex
index fb3be04..5ceddf5 100644
--- a/lib/codeqa/health_report/top_blocks.ex
+++ b/lib/codeqa/health_report/top_blocks.ex
@@ -32,8 +32,49 @@ defmodule CodeQA.HealthReport.TopBlocks do
 
   @spec build(map(), [struct()], map(), keyword()) :: [map()]
   def build(analysis_results, changed_files, codebase_cosine_lookup, opts \\ []) do
-    files = Map.get(analysis_results, "files", %{})
     base_path = get_in(analysis_results, ["metadata", "path"]) || "."
+
+    analysis_results
+    |> collect_enriched_blocks(changed_files, codebase_cosine_lookup, opts)
+    # Rank by highest cosine_delta and take top N
+    |> Enum.sort_by(&(-max_delta(&1)))
+    |> Enum.take(@top_n)
+    # Add source code for each block
+    |> Enum.map(&add_source_code(&1, base_path))
+  end
+
+  @doc """
+  Returns a map of category => worst offending block for that category.
+  Only includes blocks that overlap with the diff (if diff_line_ranges provided).
+  """
+  @spec worst_per_category(map(), [struct()], map(), keyword()) :: %{String.t() => map()}
+  def worst_per_category(analysis_results, changed_files, codebase_cosine_lookup, opts \\ []) do
+    base_path = get_in(analysis_results, ["metadata", "path"]) || "."
+
+    all_blocks =
+      collect_enriched_blocks(analysis_results, changed_files, codebase_cosine_lookup, opts)
+
+    # Group blocks by category, finding the worst block per category
+    all_blocks
+    |> Enum.flat_map(fn block ->
+      # Each block may contribute to multiple categories via its potentials
+      block.potentials
+      |> Enum.map(fn potential ->
+        {potential.category, block, potential.cosine_delta}
+      end)
+    end)
+    |> Enum.group_by(&elem(&1, 0), fn {_cat, block, delta} -> {block, delta} end)
+    |> Enum.map(fn {category, block_deltas} ->
+      # Find the block with highest cosine_delta for this category
+      {worst_block, _delta} = Enum.max_by(block_deltas, fn {_block, delta} -> delta end)
+      {category, add_source_code(worst_block, base_path)}
+    end)
+    |> Map.new()
+  end
+
+  # Shared logic for collecting and enriching blocks
+  defp collect_enriched_blocks(analysis_results, changed_files, codebase_cosine_lookup, opts) do
+    files = Map.get(analysis_results, "files", %{})
     fix_hints = build_fix_hint_lookup()
 
     min_lines = Keyword.get(opts, :block_min_lines, @default_min_lines)
@@ -51,7 +92,7 @@ defmodule CodeQA.HealthReport.TopBlocks do
         |> Enum.map(fn {path, data} -> {path, Map.get(changed_index, path), data} end)
       end
 
-    # Flatten all blocks across all files, enrich with path and source code
+    # Flatten all blocks across all files, enrich with path
     file_entries
     |> Enum.flat_map(fn {path, status, file_data} ->
       path_diff_ranges = Map.get(diff_line_ranges, path, [])
@@ -66,11 +107,6 @@ defmodule CodeQA.HealthReport.TopBlocks do
       |> Enum.reject(&(&1.potentials == []))
       |> Enum.map(&Map.merge(&1, %{path: path, status: status}))
     end)
-    # Rank by highest cosine_delta and take top N
-    |> Enum.sort_by(&(-max_delta(&1)))
-    |> Enum.take(@top_n)
-    # Add source code for each block
-    |> Enum.map(&add_source_code(&1, base_path))
   end
 
   @spec block_in_line_range?(map(), pos_integer(), pos_integer()) :: boolean()
diff --git a/priv/combined_metrics/code_smells.yml b/priv/combined_metrics/code_smells.yml
index f1c73c5..2201f7d 100644
--- a/priv/combined_metrics/code_smells.yml
+++ b/priv/combined_metrics/code_smells.yml
@@ -1,5 +1,6 @@
 consistent_string_quote_style:
   _doc: "Files should use a single, consistent string quoting style throughout."
+  _languages: [elixir]
   _log_baseline: -18.2553
   branching:
     mean_branching_density: 0.0243
@@ -101,6 +102,7 @@ consistent_string_quote_style:
 
 no_dead_code_after_return:
   _doc: "There should be no unreachable statements after a return or early exit."
+  _languages: [elixir]
   _log_baseline: -55.8435
   branching:
     mean_branch_count: -2.0000
@@ -211,6 +213,7 @@ no_dead_code_after_return:
 
 no_debug_print_statements:
   _doc: "Debug output (`console.log`, `IO.inspect`, `fmt.Println`) must not be left in committed code."
+  _languages: [elixir]
   _log_baseline: -88.0844
   branching:
     mean_branch_count: -0.3540
@@ -321,6 +324,7 @@ no_debug_print_statements:
 
 no_fixme_comments:
   _doc: "FIXME, XXX, and HACK comments indicate known problems that should be resolved before merging."
+  _languages: [elixir]
   _log_baseline: -2.0233
   branching:
     mean_branch_count: 0.1755
@@ -435,6 +439,7 @@ no_fixme_comments:
 
 no_nested_ternary:
   _doc: "Nested conditional expressions (ternary-within-ternary) are harder to read than a plain if-else."
+  _languages: [elixir]
   _log_baseline: 7.6475
   branching:
     mean_branch_count: -0.5662
diff --git a/priv/combined_metrics/variable_naming.yml b/priv/combined_metrics/variable_naming.yml
index 1be9c6b..e7bc6fa 100644
--- a/priv/combined_metrics/variable_naming.yml
+++ b/priv/combined_metrics/variable_naming.yml
@@ -1,5 +1,6 @@
 boolean_has_is_has_prefix:
   _doc: "Boolean variables should be prefixed with `is_`, `has_`, or `can_`."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 15.9481
   brevity:
     mean_sample_size: 0.0752
@@ -62,6 +63,7 @@ boolean_has_is_has_prefix:
 
 collection_name_is_plural:
   _doc: "Variables holding a collection should use a plural name."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 21.8380
   brevity:
     mean_sample_size: -0.5320
@@ -123,6 +125,7 @@ collection_name_is_plural:
 
 loop_var_is_single_letter:
   _doc: "Loop index variables (`i`, `j`, `k`) are acceptable inside loop bodies."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -28.3218
   brevity:
     mean_sample_size: -0.1049
@@ -202,6 +205,7 @@ loop_var_is_single_letter:
 
 name_contains_and:
   _doc: "Variable names containing `and` signal a variable that holds two concerns."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 0.4689
   branching:
     mean_branch_count: -0.3666
@@ -320,6 +324,7 @@ name_contains_and:
 
 name_contains_type_suffix:
   _doc: "Type suffixes in names (`userString`, `nameList`) are redundant noise."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -26.6817
   branching:
     mean_branch_count: -0.4150
@@ -405,6 +410,7 @@ name_contains_type_suffix:
 
 name_is_abbreviation:
   _doc: "Abbreviated names (`usr`, `cfg`, `mgr`) reduce readability."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 10.7370
   brevity:
     mean_sample_size: -0.1542
@@ -491,6 +497,7 @@ name_is_abbreviation:
 
 name_is_generic:
   _doc: "Generic names (`data`, `result`, `tmp`, `val`, `obj`) convey no domain meaning."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 37.4815
   branching:
     mean_branch_count: 0.5193
@@ -607,6 +614,7 @@ name_is_generic:
 
 name_is_number_like:
   _doc: "Number-suffixed names (`var1`, `thing2`) signal a missing abstraction."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 1.7611
   brevity:
     mean_sample_size: -0.0262
@@ -685,6 +693,7 @@ name_is_number_like:
 
 name_is_single_letter:
   _doc: "Single-letter names outside loop indices are too opaque."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: 26.2113
   branching:
     mean_branching_density: -0.0458
@@ -782,6 +791,7 @@ name_is_single_letter:
 
 name_is_too_long:
   _doc: "Names longer than ~30 characters harm readability."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -7.8322
   branching:
     mean_branch_count: 0.0340
@@ -902,6 +912,7 @@ name_is_too_long:
 
 name_is_too_short:
   _doc: "Names shorter than 3 characters (outside loops) are too opaque."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -2.7224
   branching:
     mean_branch_count: -0.2327
@@ -989,6 +1000,7 @@ name_is_too_short:
 
 negated_boolean_name:
   _doc: "Negated boolean names (`isNotValid`, `notActive`) are harder to reason about."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -4.4565
   brevity:
     mean_sample_size: -0.0998
@@ -1059,6 +1071,7 @@ negated_boolean_name:
 
 no_hungarian_notation:
   _doc: "Hungarian notation prefixes (`strName`, `bFlag`) add noise without type safety."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -15.5962
   brevity:
     mean_sample_size: -0.0814
@@ -1134,6 +1147,7 @@ no_hungarian_notation:
 
 screaming_snake_for_constants:
   _doc: "Module-level constants should use SCREAMING_SNAKE_CASE."
+  _languages: [elixir, javascript, ruby]
   _log_baseline: -5.9884
   branching:
     mean_branching_density: 0.0176

From 09c09017e3e78beb7f4568450427c4a542bcfed1 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Thu, 26 Mar 2026 20:45:57 +0000
Subject: [PATCH 70/71] chore(combined-metrics): sync language coverage and
 scalar vectors [skip ci]

---
 priv/combined_metrics/code_smells.yml     |  5 -----
 priv/combined_metrics/variable_naming.yml | 14 --------------
 2 files changed, 19 deletions(-)

diff --git a/priv/combined_metrics/code_smells.yml b/priv/combined_metrics/code_smells.yml
index 2201f7d..f1c73c5 100644
--- a/priv/combined_metrics/code_smells.yml
+++ b/priv/combined_metrics/code_smells.yml
@@ -1,6 +1,5 @@
 consistent_string_quote_style:
   _doc: "Files should use a single, consistent string quoting style throughout."
-  _languages: [elixir]
   _log_baseline: -18.2553
   branching:
     mean_branching_density: 0.0243
@@ -102,7 +101,6 @@ consistent_string_quote_style:
 
 no_dead_code_after_return:
   _doc: "There should be no unreachable statements after a return or early exit."
-  _languages: [elixir]
   _log_baseline: -55.8435
   branching:
     mean_branch_count: -2.0000
@@ -213,7 +211,6 @@ no_dead_code_after_return:
 
 no_debug_print_statements:
   _doc: "Debug output (`console.log`, `IO.inspect`, `fmt.Println`) must not be left in committed code."
-  _languages: [elixir]
   _log_baseline: -88.0844
   branching:
     mean_branch_count: -0.3540
@@ -324,7 +321,6 @@ no_debug_print_statements:
 
 no_fixme_comments:
   _doc: "FIXME, XXX, and HACK comments indicate known problems that should be resolved before merging."
-  _languages: [elixir]
   _log_baseline: -2.0233
   branching:
     mean_branch_count: 0.1755
@@ -439,7 +435,6 @@ no_fixme_comments:
 
 no_nested_ternary:
   _doc: "Nested conditional expressions (ternary-within-ternary) are harder to read than a plain if-else."
-  _languages: [elixir]
   _log_baseline: 7.6475
   branching:
     mean_branch_count: -0.5662
diff --git a/priv/combined_metrics/variable_naming.yml b/priv/combined_metrics/variable_naming.yml
index e7bc6fa..1be9c6b 100644
--- a/priv/combined_metrics/variable_naming.yml
+++ b/priv/combined_metrics/variable_naming.yml
@@ -1,6 +1,5 @@
 boolean_has_is_has_prefix:
   _doc: "Boolean variables should be prefixed with `is_`, `has_`, or `can_`."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 15.9481
   brevity:
     mean_sample_size: 0.0752
@@ -63,7 +62,6 @@ boolean_has_is_has_prefix:
 
 collection_name_is_plural:
   _doc: "Variables holding a collection should use a plural name."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 21.8380
   brevity:
     mean_sample_size: -0.5320
@@ -125,7 +123,6 @@ collection_name_is_plural:
 
 loop_var_is_single_letter:
   _doc: "Loop index variables (`i`, `j`, `k`) are acceptable inside loop bodies."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -28.3218
   brevity:
     mean_sample_size: -0.1049
@@ -205,7 +202,6 @@ loop_var_is_single_letter:
 
 name_contains_and:
   _doc: "Variable names containing `and` signal a variable that holds two concerns."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 0.4689
   branching:
     mean_branch_count: -0.3666
@@ -324,7 +320,6 @@ name_contains_and:
 
 name_contains_type_suffix:
   _doc: "Type suffixes in names (`userString`, `nameList`) are redundant noise."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -26.6817
   branching:
     mean_branch_count: -0.4150
@@ -410,7 +405,6 @@ name_contains_type_suffix:
 
 name_is_abbreviation:
   _doc: "Abbreviated names (`usr`, `cfg`, `mgr`) reduce readability."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 10.7370
   brevity:
     mean_sample_size: -0.1542
@@ -497,7 +491,6 @@ name_is_abbreviation:
 
 name_is_generic:
   _doc: "Generic names (`data`, `result`, `tmp`, `val`, `obj`) convey no domain meaning."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 37.4815
   branching:
     mean_branch_count: 0.5193
@@ -614,7 +607,6 @@ name_is_generic:
 
 name_is_number_like:
   _doc: "Number-suffixed names (`var1`, `thing2`) signal a missing abstraction."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 1.7611
   brevity:
     mean_sample_size: -0.0262
@@ -693,7 +685,6 @@ name_is_number_like:
 
 name_is_single_letter:
   _doc: "Single-letter names outside loop indices are too opaque."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: 26.2113
   branching:
     mean_branching_density: -0.0458
@@ -791,7 +782,6 @@ name_is_single_letter:
 
 name_is_too_long:
   _doc: "Names longer than ~30 characters harm readability."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -7.8322
   branching:
     mean_branch_count: 0.0340
@@ -912,7 +902,6 @@ name_is_too_long:
 
 name_is_too_short:
   _doc: "Names shorter than 3 characters (outside loops) are too opaque."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -2.7224
   branching:
     mean_branch_count: -0.2327
@@ -1000,7 +989,6 @@ name_is_too_short:
 
 negated_boolean_name:
   _doc: "Negated boolean names (`isNotValid`, `notActive`) are harder to reason about."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -4.4565
   brevity:
     mean_sample_size: -0.0998
@@ -1071,7 +1059,6 @@ negated_boolean_name:
 
 no_hungarian_notation:
   _doc: "Hungarian notation prefixes (`strName`, `bFlag`) add noise without type safety."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -15.5962
   brevity:
     mean_sample_size: -0.0814
@@ -1147,7 +1134,6 @@ no_hungarian_notation:
 
 screaming_snake_for_constants:
   _doc: "Module-level constants should use SCREAMING_SNAKE_CASE."
-  _languages: [elixir, javascript, ruby]
   _log_baseline: -5.9884
   branching:
     mean_branching_density: 0.0176

From 8925e76ade98083b48c257c45fbe869a12b0f37d Mon Sep 17 00:00:00 2001
From: Andreas Solleder <asol@num42.de>
Date: Thu, 26 Mar 2026 23:09:50 +0100
Subject: [PATCH 71/71] fix(report): display blocks from 1-15 lines instead of
 4-10

---
 lib/codeqa/health_report/formatter/github.ex | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/codeqa/health_report/formatter/github.ex b/lib/codeqa/health_report/formatter/github.ex
index b72b250..dd4a696 100644
--- a/lib/codeqa/health_report/formatter/github.ex
+++ b/lib/codeqa/health_report/formatter/github.ex
@@ -320,7 +320,7 @@ defmodule CodeQA.HealthReport.Formatter.Github do
     line_count = (block.end_line || block.start_line) - block.start_line + 1
     location = "#{block.path}:#{block.start_line}-#{block.end_line}"
 
-    if line_count >= 4 and line_count <= 10 and block.source do
+    if line_count >= 1 and line_count <= 15 and block.source do
       lang = block.language || ""
 
       [